1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * USB IBM C-It Video Camera driver
4  *
5  * Supports Xirlink C-It Video Camera, IBM PC Camera,
6  * IBM NetCamera and Veo Stingray.
7  *
8  * Copyright (C) 2010 Hans de Goede <hdegoede@redhat.com>
9  *
10  * This driver is based on earlier work of:
11  *
12  * (C) Copyright 1999 Johannes Erdfelt
13  * (C) Copyright 1999 Randy Dunlap
14  */
15 
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 
18 #define MODULE_NAME "xirlink-cit"
19 
20 #include <linux/input.h>
21 #include "gspca.h"
22 
23 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
24 MODULE_DESCRIPTION("Xirlink C-IT");
25 MODULE_LICENSE("GPL");
26 
27 /* FIXME we should autodetect this */
28 static int ibm_netcam_pro;
29 module_param(ibm_netcam_pro, int, 0);
30 MODULE_PARM_DESC(ibm_netcam_pro,
31 		 "Use IBM Netcamera Pro init sequences for Model 3 cams");
32 
33 /* FIXME this should be handled through the V4L2 input selection API */
34 static int rca_input;
35 module_param(rca_input, int, 0644);
36 MODULE_PARM_DESC(rca_input,
37 		 "Use rca input instead of ccd sensor on Model 3 cams");
38 
39 /* specific webcam descriptor */
40 struct sd {
41 	struct gspca_dev gspca_dev;		/* !! must be the first item */
42 	struct v4l2_ctrl *lighting;
43 	u8 model;
44 #define CIT_MODEL0 0 /* bcd version 0.01 cams ie the xvp-500 */
45 #define CIT_MODEL1 1 /* The model 1 - 4 nomenclature comes from the old */
46 #define CIT_MODEL2 2 /* ibmcam driver */
47 #define CIT_MODEL3 3
48 #define CIT_MODEL4 4
49 #define CIT_IBM_NETCAM_PRO 5
50 	u8 input_index;
51 	u8 button_state;
52 	u8 stop_on_control_change;
53 	u8 sof_read;
54 	u8 sof_len;
55 };
56 
57 static void sd_stop0(struct gspca_dev *gspca_dev);
58 
59 static const struct v4l2_pix_format cif_yuv_mode[] = {
60 	{176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
61 		.bytesperline = 176,
62 		.sizeimage = 176 * 144 * 3 / 2 + 4,
63 		.colorspace = V4L2_COLORSPACE_SRGB},
64 	{352, 288, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
65 		.bytesperline = 352,
66 		.sizeimage = 352 * 288 * 3 / 2 + 4,
67 		.colorspace = V4L2_COLORSPACE_SRGB},
68 };
69 
70 static const struct v4l2_pix_format vga_yuv_mode[] = {
71 	{160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
72 		.bytesperline = 160,
73 		.sizeimage = 160 * 120 * 3 / 2 + 4,
74 		.colorspace = V4L2_COLORSPACE_SRGB},
75 	{320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
76 		.bytesperline = 320,
77 		.sizeimage = 320 * 240 * 3 / 2 + 4,
78 		.colorspace = V4L2_COLORSPACE_SRGB},
79 	{640, 480, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
80 		.bytesperline = 640,
81 		.sizeimage = 640 * 480 * 3 / 2 + 4,
82 		.colorspace = V4L2_COLORSPACE_SRGB},
83 };
84 
85 static const struct v4l2_pix_format model0_mode[] = {
86 	{160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
87 		.bytesperline = 160,
88 		.sizeimage = 160 * 120 * 3 / 2 + 4,
89 		.colorspace = V4L2_COLORSPACE_SRGB},
90 	{176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
91 		.bytesperline = 176,
92 		.sizeimage = 176 * 144 * 3 / 2 + 4,
93 		.colorspace = V4L2_COLORSPACE_SRGB},
94 	{320, 240, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
95 		.bytesperline = 320,
96 		.sizeimage = 320 * 240 * 3 / 2 + 4,
97 		.colorspace = V4L2_COLORSPACE_SRGB},
98 };
99 
100 static const struct v4l2_pix_format model2_mode[] = {
101 	{160, 120, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
102 		.bytesperline = 160,
103 		.sizeimage = 160 * 120 * 3 / 2 + 4,
104 		.colorspace = V4L2_COLORSPACE_SRGB},
105 	{176, 144, V4L2_PIX_FMT_CIT_YYVYUY, V4L2_FIELD_NONE,
106 		.bytesperline = 176,
107 		.sizeimage = 176 * 144 * 3 / 2 + 4,
108 		.colorspace = V4L2_COLORSPACE_SRGB},
109 	{320, 240, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
110 		.bytesperline = 320,
111 		.sizeimage = 320 * 240 + 4,
112 		.colorspace = V4L2_COLORSPACE_SRGB},
113 	{352, 288, V4L2_PIX_FMT_SGRBG8, V4L2_FIELD_NONE,
114 		.bytesperline = 352,
115 		.sizeimage = 352 * 288 + 4,
116 		.colorspace = V4L2_COLORSPACE_SRGB},
117 };
118 
119 /*
120  * 01.01.08 - Added for RCA video in support -LO
121  * This struct is used to init the Model3 cam to use the RCA video in port
122  * instead of the CCD sensor.
123  */
124 static const u16 rca_initdata[][3] = {
125 	{0, 0x0000, 0x010c},
126 	{0, 0x0006, 0x012c},
127 	{0, 0x0078, 0x012d},
128 	{0, 0x0046, 0x012f},
129 	{0, 0xd141, 0x0124},
130 	{0, 0x0000, 0x0127},
131 	{0, 0xfea8, 0x0124},
132 	{1, 0x0000, 0x0116},
133 	{0, 0x0064, 0x0116},
134 	{1, 0x0000, 0x0115},
135 	{0, 0x0003, 0x0115},
136 	{0, 0x0008, 0x0123},
137 	{0, 0x0000, 0x0117},
138 	{0, 0x0000, 0x0112},
139 	{0, 0x0080, 0x0100},
140 	{0, 0x0000, 0x0100},
141 	{1, 0x0000, 0x0116},
142 	{0, 0x0060, 0x0116},
143 	{0, 0x0002, 0x0112},
144 	{0, 0x0000, 0x0123},
145 	{0, 0x0001, 0x0117},
146 	{0, 0x0040, 0x0108},
147 	{0, 0x0019, 0x012c},
148 	{0, 0x0040, 0x0116},
149 	{0, 0x000a, 0x0115},
150 	{0, 0x000b, 0x0115},
151 	{0, 0x0078, 0x012d},
152 	{0, 0x0046, 0x012f},
153 	{0, 0xd141, 0x0124},
154 	{0, 0x0000, 0x0127},
155 	{0, 0xfea8, 0x0124},
156 	{0, 0x0064, 0x0116},
157 	{0, 0x0000, 0x0115},
158 	{0, 0x0001, 0x0115},
159 	{0, 0xffff, 0x0124},
160 	{0, 0xfff9, 0x0124},
161 	{0, 0x0086, 0x0127},
162 	{0, 0xfff8, 0x0124},
163 	{0, 0xfffd, 0x0124},
164 	{0, 0x00aa, 0x0127},
165 	{0, 0xfff8, 0x0124},
166 	{0, 0xfffd, 0x0124},
167 	{0, 0x0000, 0x0127},
168 	{0, 0xfff8, 0x0124},
169 	{0, 0xfffd, 0x0124},
170 	{0, 0xfffa, 0x0124},
171 	{0, 0xffff, 0x0124},
172 	{0, 0xfff9, 0x0124},
173 	{0, 0x0086, 0x0127},
174 	{0, 0xfff8, 0x0124},
175 	{0, 0xfffd, 0x0124},
176 	{0, 0x00f2, 0x0127},
177 	{0, 0xfff8, 0x0124},
178 	{0, 0xfffd, 0x0124},
179 	{0, 0x000f, 0x0127},
180 	{0, 0xfff8, 0x0124},
181 	{0, 0xfffd, 0x0124},
182 	{0, 0xfffa, 0x0124},
183 	{0, 0xffff, 0x0124},
184 	{0, 0xfff9, 0x0124},
185 	{0, 0x0086, 0x0127},
186 	{0, 0xfff8, 0x0124},
187 	{0, 0xfffd, 0x0124},
188 	{0, 0x00f8, 0x0127},
189 	{0, 0xfff8, 0x0124},
190 	{0, 0xfffd, 0x0124},
191 	{0, 0x00fc, 0x0127},
192 	{0, 0xfff8, 0x0124},
193 	{0, 0xfffd, 0x0124},
194 	{0, 0xfffa, 0x0124},
195 	{0, 0xffff, 0x0124},
196 	{0, 0xfff9, 0x0124},
197 	{0, 0x0086, 0x0127},
198 	{0, 0xfff8, 0x0124},
199 	{0, 0xfffd, 0x0124},
200 	{0, 0x00f9, 0x0127},
201 	{0, 0xfff8, 0x0124},
202 	{0, 0xfffd, 0x0124},
203 	{0, 0x003c, 0x0127},
204 	{0, 0xfff8, 0x0124},
205 	{0, 0xfffd, 0x0124},
206 	{0, 0xfffa, 0x0124},
207 	{0, 0xffff, 0x0124},
208 	{0, 0xfff9, 0x0124},
209 	{0, 0x0086, 0x0127},
210 	{0, 0xfff8, 0x0124},
211 	{0, 0xfffd, 0x0124},
212 	{0, 0x0027, 0x0127},
213 	{0, 0xfff8, 0x0124},
214 	{0, 0xfffd, 0x0124},
215 	{0, 0x0019, 0x0127},
216 	{0, 0xfff8, 0x0124},
217 	{0, 0xfffd, 0x0124},
218 	{0, 0xfffa, 0x0124},
219 	{0, 0xfff9, 0x0124},
220 	{0, 0x0086, 0x0127},
221 	{0, 0xfff8, 0x0124},
222 	{0, 0xfffd, 0x0124},
223 	{0, 0x0037, 0x0127},
224 	{0, 0xfff8, 0x0124},
225 	{0, 0xfffd, 0x0124},
226 	{0, 0x0000, 0x0127},
227 	{0, 0xfff8, 0x0124},
228 	{0, 0xfffd, 0x0124},
229 	{0, 0x0021, 0x0127},
230 	{0, 0xfff8, 0x0124},
231 	{0, 0xfffd, 0x0124},
232 	{0, 0xfffa, 0x0124},
233 	{0, 0xfff9, 0x0124},
234 	{0, 0x0086, 0x0127},
235 	{0, 0xfff8, 0x0124},
236 	{0, 0xfffd, 0x0124},
237 	{0, 0x0038, 0x0127},
238 	{0, 0xfff8, 0x0124},
239 	{0, 0xfffd, 0x0124},
240 	{0, 0x0006, 0x0127},
241 	{0, 0xfff8, 0x0124},
242 	{0, 0xfffd, 0x0124},
243 	{0, 0x0045, 0x0127},
244 	{0, 0xfff8, 0x0124},
245 	{0, 0xfffd, 0x0124},
246 	{0, 0xfffa, 0x0124},
247 	{0, 0xfff9, 0x0124},
248 	{0, 0x0086, 0x0127},
249 	{0, 0xfff8, 0x0124},
250 	{0, 0xfffd, 0x0124},
251 	{0, 0x0037, 0x0127},
252 	{0, 0xfff8, 0x0124},
253 	{0, 0xfffd, 0x0124},
254 	{0, 0x0001, 0x0127},
255 	{0, 0xfff8, 0x0124},
256 	{0, 0xfffd, 0x0124},
257 	{0, 0x002a, 0x0127},
258 	{0, 0xfff8, 0x0124},
259 	{0, 0xfffd, 0x0124},
260 	{0, 0xfffa, 0x0124},
261 	{0, 0xfff9, 0x0124},
262 	{0, 0x0086, 0x0127},
263 	{0, 0xfff8, 0x0124},
264 	{0, 0xfffd, 0x0124},
265 	{0, 0x0038, 0x0127},
266 	{0, 0xfff8, 0x0124},
267 	{0, 0xfffd, 0x0124},
268 	{0, 0x0000, 0x0127},
269 	{0, 0xfff8, 0x0124},
270 	{0, 0xfffd, 0x0124},
271 	{0, 0x000e, 0x0127},
272 	{0, 0xfff8, 0x0124},
273 	{0, 0xfffd, 0x0124},
274 	{0, 0xfffa, 0x0124},
275 	{0, 0xfff9, 0x0124},
276 	{0, 0x0086, 0x0127},
277 	{0, 0xfff8, 0x0124},
278 	{0, 0xfffd, 0x0124},
279 	{0, 0x0037, 0x0127},
280 	{0, 0xfff8, 0x0124},
281 	{0, 0xfffd, 0x0124},
282 	{0, 0x0001, 0x0127},
283 	{0, 0xfff8, 0x0124},
284 	{0, 0xfffd, 0x0124},
285 	{0, 0x002b, 0x0127},
286 	{0, 0xfff8, 0x0124},
287 	{0, 0xfffd, 0x0124},
288 	{0, 0xfffa, 0x0124},
289 	{0, 0xfff9, 0x0124},
290 	{0, 0x0086, 0x0127},
291 	{0, 0xfff8, 0x0124},
292 	{0, 0xfffd, 0x0124},
293 	{0, 0x0038, 0x0127},
294 	{0, 0xfff8, 0x0124},
295 	{0, 0xfffd, 0x0124},
296 	{0, 0x0001, 0x0127},
297 	{0, 0xfff8, 0x0124},
298 	{0, 0xfffd, 0x0124},
299 	{0, 0x00f4, 0x0127},
300 	{0, 0xfff8, 0x0124},
301 	{0, 0xfffd, 0x0124},
302 	{0, 0xfffa, 0x0124},
303 	{0, 0xfff9, 0x0124},
304 	{0, 0x0086, 0x0127},
305 	{0, 0xfff8, 0x0124},
306 	{0, 0xfffd, 0x0124},
307 	{0, 0x0037, 0x0127},
308 	{0, 0xfff8, 0x0124},
309 	{0, 0xfffd, 0x0124},
310 	{0, 0x0001, 0x0127},
311 	{0, 0xfff8, 0x0124},
312 	{0, 0xfffd, 0x0124},
313 	{0, 0x002c, 0x0127},
314 	{0, 0xfff8, 0x0124},
315 	{0, 0xfffd, 0x0124},
316 	{0, 0xfffa, 0x0124},
317 	{0, 0xfff9, 0x0124},
318 	{0, 0x0086, 0x0127},
319 	{0, 0xfff8, 0x0124},
320 	{0, 0xfffd, 0x0124},
321 	{0, 0x0038, 0x0127},
322 	{0, 0xfff8, 0x0124},
323 	{0, 0xfffd, 0x0124},
324 	{0, 0x0001, 0x0127},
325 	{0, 0xfff8, 0x0124},
326 	{0, 0xfffd, 0x0124},
327 	{0, 0x0004, 0x0127},
328 	{0, 0xfff8, 0x0124},
329 	{0, 0xfffd, 0x0124},
330 	{0, 0xfffa, 0x0124},
331 	{0, 0xfff9, 0x0124},
332 	{0, 0x0086, 0x0127},
333 	{0, 0xfff8, 0x0124},
334 	{0, 0xfffd, 0x0124},
335 	{0, 0x0037, 0x0127},
336 	{0, 0xfff8, 0x0124},
337 	{0, 0xfffd, 0x0124},
338 	{0, 0x0001, 0x0127},
339 	{0, 0xfff8, 0x0124},
340 	{0, 0xfffd, 0x0124},
341 	{0, 0x002d, 0x0127},
342 	{0, 0xfff8, 0x0124},
343 	{0, 0xfffd, 0x0124},
344 	{0, 0xfffa, 0x0124},
345 	{0, 0xfff9, 0x0124},
346 	{0, 0x0086, 0x0127},
347 	{0, 0xfff8, 0x0124},
348 	{0, 0xfffd, 0x0124},
349 	{0, 0x0038, 0x0127},
350 	{0, 0xfff8, 0x0124},
351 	{0, 0xfffd, 0x0124},
352 	{0, 0x0000, 0x0127},
353 	{0, 0xfff8, 0x0124},
354 	{0, 0xfffd, 0x0124},
355 	{0, 0x0014, 0x0127},
356 	{0, 0xfff8, 0x0124},
357 	{0, 0xfffd, 0x0124},
358 	{0, 0xfffa, 0x0124},
359 	{0, 0xfff9, 0x0124},
360 	{0, 0x0086, 0x0127},
361 	{0, 0xfff8, 0x0124},
362 	{0, 0xfffd, 0x0124},
363 	{0, 0x0037, 0x0127},
364 	{0, 0xfff8, 0x0124},
365 	{0, 0xfffd, 0x0124},
366 	{0, 0x0001, 0x0127},
367 	{0, 0xfff8, 0x0124},
368 	{0, 0xfffd, 0x0124},
369 	{0, 0x002e, 0x0127},
370 	{0, 0xfff8, 0x0124},
371 	{0, 0xfffd, 0x0124},
372 	{0, 0xfffa, 0x0124},
373 	{0, 0xfff9, 0x0124},
374 	{0, 0x0086, 0x0127},
375 	{0, 0xfff8, 0x0124},
376 	{0, 0xfffd, 0x0124},
377 	{0, 0x0038, 0x0127},
378 	{0, 0xfff8, 0x0124},
379 	{0, 0xfffd, 0x0124},
380 	{0, 0x0003, 0x0127},
381 	{0, 0xfff8, 0x0124},
382 	{0, 0xfffd, 0x0124},
383 	{0, 0x0000, 0x0127},
384 	{0, 0xfff8, 0x0124},
385 	{0, 0xfffd, 0x0124},
386 	{0, 0xfffa, 0x0124},
387 	{0, 0xfff9, 0x0124},
388 	{0, 0x0086, 0x0127},
389 	{0, 0xfff8, 0x0124},
390 	{0, 0xfffd, 0x0124},
391 	{0, 0x0037, 0x0127},
392 	{0, 0xfff8, 0x0124},
393 	{0, 0xfffd, 0x0124},
394 	{0, 0x0001, 0x0127},
395 	{0, 0xfff8, 0x0124},
396 	{0, 0xfffd, 0x0124},
397 	{0, 0x002f, 0x0127},
398 	{0, 0xfff8, 0x0124},
399 	{0, 0xfffd, 0x0124},
400 	{0, 0xfffa, 0x0124},
401 	{0, 0xfff9, 0x0124},
402 	{0, 0x0086, 0x0127},
403 	{0, 0xfff8, 0x0124},
404 	{0, 0xfffd, 0x0124},
405 	{0, 0x0038, 0x0127},
406 	{0, 0xfff8, 0x0124},
407 	{0, 0xfffd, 0x0124},
408 	{0, 0x0003, 0x0127},
409 	{0, 0xfff8, 0x0124},
410 	{0, 0xfffd, 0x0124},
411 	{0, 0x0014, 0x0127},
412 	{0, 0xfff8, 0x0124},
413 	{0, 0xfffd, 0x0124},
414 	{0, 0xfffa, 0x0124},
415 	{0, 0xfff9, 0x0124},
416 	{0, 0x0086, 0x0127},
417 	{0, 0xfff8, 0x0124},
418 	{0, 0xfffd, 0x0124},
419 	{0, 0x0037, 0x0127},
420 	{0, 0xfff8, 0x0124},
421 	{0, 0xfffd, 0x0124},
422 	{0, 0x0001, 0x0127},
423 	{0, 0xfff8, 0x0124},
424 	{0, 0xfffd, 0x0124},
425 	{0, 0x0040, 0x0127},
426 	{0, 0xfff8, 0x0124},
427 	{0, 0xfffd, 0x0124},
428 	{0, 0xfffa, 0x0124},
429 	{0, 0xfff9, 0x0124},
430 	{0, 0x0086, 0x0127},
431 	{0, 0xfff8, 0x0124},
432 	{0, 0xfffd, 0x0124},
433 	{0, 0x0038, 0x0127},
434 	{0, 0xfff8, 0x0124},
435 	{0, 0xfffd, 0x0124},
436 	{0, 0x0000, 0x0127},
437 	{0, 0xfff8, 0x0124},
438 	{0, 0xfffd, 0x0124},
439 	{0, 0x0040, 0x0127},
440 	{0, 0xfff8, 0x0124},
441 	{0, 0xfffd, 0x0124},
442 	{0, 0xfffa, 0x0124},
443 	{0, 0xfff9, 0x0124},
444 	{0, 0x0086, 0x0127},
445 	{0, 0xfff8, 0x0124},
446 	{0, 0xfffd, 0x0124},
447 	{0, 0x0037, 0x0127},
448 	{0, 0xfff8, 0x0124},
449 	{0, 0xfffd, 0x0124},
450 	{0, 0x0001, 0x0127},
451 	{0, 0xfff8, 0x0124},
452 	{0, 0xfffd, 0x0124},
453 	{0, 0x0053, 0x0127},
454 	{0, 0xfff8, 0x0124},
455 	{0, 0xfffd, 0x0124},
456 	{0, 0xfffa, 0x0124},
457 	{0, 0xfff9, 0x0124},
458 	{0, 0x0086, 0x0127},
459 	{0, 0xfff8, 0x0124},
460 	{0, 0xfffd, 0x0124},
461 	{0, 0x0038, 0x0127},
462 	{0, 0xfff8, 0x0124},
463 	{0, 0xfffd, 0x0124},
464 	{0, 0x0000, 0x0127},
465 	{0, 0xfff8, 0x0124},
466 	{0, 0xfffd, 0x0124},
467 	{0, 0x0038, 0x0127},
468 	{0, 0xfff8, 0x0124},
469 	{0, 0xfffd, 0x0124},
470 	{0, 0xfffa, 0x0124},
471 	{0, 0x0000, 0x0101},
472 	{0, 0x00a0, 0x0103},
473 	{0, 0x0078, 0x0105},
474 	{0, 0x0000, 0x010a},
475 	{0, 0x0024, 0x010b},
476 	{0, 0x0028, 0x0119},
477 	{0, 0x0088, 0x011b},
478 	{0, 0x0002, 0x011d},
479 	{0, 0x0003, 0x011e},
480 	{0, 0x0000, 0x0129},
481 	{0, 0x00fc, 0x012b},
482 	{0, 0x0008, 0x0102},
483 	{0, 0x0000, 0x0104},
484 	{0, 0x0008, 0x011a},
485 	{0, 0x0028, 0x011c},
486 	{0, 0x0021, 0x012a},
487 	{0, 0x0000, 0x0118},
488 	{0, 0x0000, 0x0132},
489 	{0, 0x0000, 0x0109},
490 	{0, 0xfff9, 0x0124},
491 	{0, 0x0086, 0x0127},
492 	{0, 0xfff8, 0x0124},
493 	{0, 0xfffd, 0x0124},
494 	{0, 0x0037, 0x0127},
495 	{0, 0xfff8, 0x0124},
496 	{0, 0xfffd, 0x0124},
497 	{0, 0x0001, 0x0127},
498 	{0, 0xfff8, 0x0124},
499 	{0, 0xfffd, 0x0124},
500 	{0, 0x0031, 0x0127},
501 	{0, 0xfff8, 0x0124},
502 	{0, 0xfffd, 0x0124},
503 	{0, 0xfffa, 0x0124},
504 	{0, 0xfff9, 0x0124},
505 	{0, 0x0086, 0x0127},
506 	{0, 0xfff8, 0x0124},
507 	{0, 0xfffd, 0x0124},
508 	{0, 0x0038, 0x0127},
509 	{0, 0xfff8, 0x0124},
510 	{0, 0xfffd, 0x0124},
511 	{0, 0x0000, 0x0127},
512 	{0, 0xfff8, 0x0124},
513 	{0, 0xfffd, 0x0124},
514 	{0, 0x0000, 0x0127},
515 	{0, 0xfff8, 0x0124},
516 	{0, 0xfffd, 0x0124},
517 	{0, 0xfffa, 0x0124},
518 	{0, 0xfff9, 0x0124},
519 	{0, 0x0086, 0x0127},
520 	{0, 0xfff8, 0x0124},
521 	{0, 0xfffd, 0x0124},
522 	{0, 0x0037, 0x0127},
523 	{0, 0xfff8, 0x0124},
524 	{0, 0xfffd, 0x0124},
525 	{0, 0x0001, 0x0127},
526 	{0, 0xfff8, 0x0124},
527 	{0, 0xfffd, 0x0124},
528 	{0, 0x0040, 0x0127},
529 	{0, 0xfff8, 0x0124},
530 	{0, 0xfffd, 0x0124},
531 	{0, 0xfffa, 0x0124},
532 	{0, 0xfff9, 0x0124},
533 	{0, 0x0086, 0x0127},
534 	{0, 0xfff8, 0x0124},
535 	{0, 0xfffd, 0x0124},
536 	{0, 0x0038, 0x0127},
537 	{0, 0xfff8, 0x0124},
538 	{0, 0xfffd, 0x0124},
539 	{0, 0x0000, 0x0127},
540 	{0, 0xfff8, 0x0124},
541 	{0, 0xfffd, 0x0124},
542 	{0, 0x0040, 0x0127},
543 	{0, 0xfff8, 0x0124},
544 	{0, 0xfffd, 0x0124},
545 	{0, 0xfffa, 0x0124},
546 	{0, 0xfff9, 0x0124},
547 	{0, 0x0086, 0x0127},
548 	{0, 0xfff8, 0x0124},
549 	{0, 0xfffd, 0x0124},
550 	{0, 0x0037, 0x0127},
551 	{0, 0xfff8, 0x0124},
552 	{0, 0xfffd, 0x0124},
553 	{0, 0x0000, 0x0127},
554 	{0, 0xfff8, 0x0124},
555 	{0, 0xfffd, 0x0124},
556 	{0, 0x00dc, 0x0127},
557 	{0, 0xfff8, 0x0124},
558 	{0, 0xfffd, 0x0124},
559 	{0, 0xfffa, 0x0124},
560 	{0, 0xfff9, 0x0124},
561 	{0, 0x0086, 0x0127},
562 	{0, 0xfff8, 0x0124},
563 	{0, 0xfffd, 0x0124},
564 	{0, 0x0038, 0x0127},
565 	{0, 0xfff8, 0x0124},
566 	{0, 0xfffd, 0x0124},
567 	{0, 0x0000, 0x0127},
568 	{0, 0xfff8, 0x0124},
569 	{0, 0xfffd, 0x0124},
570 	{0, 0x0000, 0x0127},
571 	{0, 0xfff8, 0x0124},
572 	{0, 0xfffd, 0x0124},
573 	{0, 0xfffa, 0x0124},
574 	{0, 0xfff9, 0x0124},
575 	{0, 0x0086, 0x0127},
576 	{0, 0xfff8, 0x0124},
577 	{0, 0xfffd, 0x0124},
578 	{0, 0x0037, 0x0127},
579 	{0, 0xfff8, 0x0124},
580 	{0, 0xfffd, 0x0124},
581 	{0, 0x0001, 0x0127},
582 	{0, 0xfff8, 0x0124},
583 	{0, 0xfffd, 0x0124},
584 	{0, 0x0032, 0x0127},
585 	{0, 0xfff8, 0x0124},
586 	{0, 0xfffd, 0x0124},
587 	{0, 0xfffa, 0x0124},
588 	{0, 0xfff9, 0x0124},
589 	{0, 0x0086, 0x0127},
590 	{0, 0xfff8, 0x0124},
591 	{0, 0xfffd, 0x0124},
592 	{0, 0x0038, 0x0127},
593 	{0, 0xfff8, 0x0124},
594 	{0, 0xfffd, 0x0124},
595 	{0, 0x0001, 0x0127},
596 	{0, 0xfff8, 0x0124},
597 	{0, 0xfffd, 0x0124},
598 	{0, 0x0020, 0x0127},
599 	{0, 0xfff8, 0x0124},
600 	{0, 0xfffd, 0x0124},
601 	{0, 0xfffa, 0x0124},
602 	{0, 0xfff9, 0x0124},
603 	{0, 0x0086, 0x0127},
604 	{0, 0xfff8, 0x0124},
605 	{0, 0xfffd, 0x0124},
606 	{0, 0x0037, 0x0127},
607 	{0, 0xfff8, 0x0124},
608 	{0, 0xfffd, 0x0124},
609 	{0, 0x0001, 0x0127},
610 	{0, 0xfff8, 0x0124},
611 	{0, 0xfffd, 0x0124},
612 	{0, 0x0040, 0x0127},
613 	{0, 0xfff8, 0x0124},
614 	{0, 0xfffd, 0x0124},
615 	{0, 0xfffa, 0x0124},
616 	{0, 0xfff9, 0x0124},
617 	{0, 0x0086, 0x0127},
618 	{0, 0xfff8, 0x0124},
619 	{0, 0xfffd, 0x0124},
620 	{0, 0x0038, 0x0127},
621 	{0, 0xfff8, 0x0124},
622 	{0, 0xfffd, 0x0124},
623 	{0, 0x0000, 0x0127},
624 	{0, 0xfff8, 0x0124},
625 	{0, 0xfffd, 0x0124},
626 	{0, 0x0040, 0x0127},
627 	{0, 0xfff8, 0x0124},
628 	{0, 0xfffd, 0x0124},
629 	{0, 0xfffa, 0x0124},
630 	{0, 0xfff9, 0x0124},
631 	{0, 0x0086, 0x0127},
632 	{0, 0xfff8, 0x0124},
633 	{0, 0xfffd, 0x0124},
634 	{0, 0x0037, 0x0127},
635 	{0, 0xfff8, 0x0124},
636 	{0, 0xfffd, 0x0124},
637 	{0, 0x0000, 0x0127},
638 	{0, 0xfff8, 0x0124},
639 	{0, 0xfffd, 0x0124},
640 	{0, 0x0030, 0x0127},
641 	{0, 0xfff8, 0x0124},
642 	{0, 0xfffd, 0x0124},
643 	{0, 0xfffa, 0x0124},
644 	{0, 0xfff9, 0x0124},
645 	{0, 0x0086, 0x0127},
646 	{0, 0xfff8, 0x0124},
647 	{0, 0xfffd, 0x0124},
648 	{0, 0x0038, 0x0127},
649 	{0, 0xfff8, 0x0124},
650 	{0, 0xfffd, 0x0124},
651 	{0, 0x0008, 0x0127},
652 	{0, 0xfff8, 0x0124},
653 	{0, 0xfffd, 0x0124},
654 	{0, 0x0000, 0x0127},
655 	{0, 0xfff8, 0x0124},
656 	{0, 0xfffd, 0x0124},
657 	{0, 0xfffa, 0x0124},
658 	{0, 0x0003, 0x0111},
659 };
660 
661 /* TESTME the old ibmcam driver repeats certain commands to Model1 cameras, we
662    do the same for now (testing needed to see if this is really necessary) */
663 static const int cit_model1_ntries = 5;
664 static const int cit_model1_ntries2 = 2;
665 
666 static int cit_write_reg(struct gspca_dev *gspca_dev, u16 value, u16 index)
667 {
668 	struct usb_device *udev = gspca_dev->dev;
669 	int err;
670 
671 	err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
672 			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
673 			value, index, NULL, 0, 1000);
674 	if (err < 0)
675 		pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n",
676 		       index, value, err);
677 
678 	return 0;
679 }
680 
681 static int cit_read_reg(struct gspca_dev *gspca_dev, u16 index, int verbose)
682 {
683 	struct usb_device *udev = gspca_dev->dev;
684 	__u8 *buf = gspca_dev->usb_buf;
685 	int res;
686 
687 	res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x01,
688 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT,
689 			0x00, index, buf, 8, 1000);
690 	if (res < 0) {
691 		pr_err("Failed to read a register (index 0x%04X, error %d)\n",
692 		       index, res);
693 		return res;
694 	}
695 
696 	if (verbose)
697 		gspca_dbg(gspca_dev, D_PROBE, "Register %04x value: %02x\n",
698 			  index, buf[0]);
699 
700 	return 0;
701 }
702 
703 /*
704  * cit_send_FF_04_02()
705  *
706  * This procedure sends magic 3-command prefix to the camera.
707  * The purpose of this prefix is not known.
708  *
709  * History:
710  * 1/2/00   Created.
711  */
712 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
713 {
714 	cit_write_reg(gspca_dev, 0x00FF, 0x0127);
715 	cit_write_reg(gspca_dev, 0x0004, 0x0124);
716 	cit_write_reg(gspca_dev, 0x0002, 0x0124);
717 }
718 
719 static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
720 {
721 	cit_write_reg(gspca_dev, 0x0000, 0x0127);
722 	cit_write_reg(gspca_dev, 0x0004, 0x0124);
723 	cit_write_reg(gspca_dev, 0x0006, 0x0124);
724 }
725 
726 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
727 {
728 	cit_write_reg(gspca_dev, x,      0x0127);
729 	cit_write_reg(gspca_dev, 0x0000, 0x0124);
730 }
731 
732 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
733 {
734 	cit_send_x_00(gspca_dev, x);
735 	cit_write_reg(gspca_dev, 0x0005, 0x0124);
736 }
737 
738 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
739 {
740 	cit_write_reg(gspca_dev, x,      0x0127);
741 	cit_write_reg(gspca_dev, 0x0000, 0x0124);
742 	cit_write_reg(gspca_dev, 0x0005, 0x0124);
743 	cit_write_reg(gspca_dev, 0x0002, 0x0124);
744 }
745 
746 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
747 {
748 	cit_write_reg(gspca_dev, x,      0x0127);
749 	cit_write_reg(gspca_dev, 0x0001, 0x0124);
750 	cit_write_reg(gspca_dev, 0x0000, 0x0124);
751 	cit_write_reg(gspca_dev, 0x0005, 0x0124);
752 }
753 
754 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
755 {
756 	cit_write_reg(gspca_dev, x,      0x0127);
757 	cit_write_reg(gspca_dev, 0x0000, 0x0124);
758 	cit_write_reg(gspca_dev, 0x0005, 0x0124);
759 	cit_write_reg(gspca_dev, 0x0002, 0x0124);
760 	cit_write_reg(gspca_dev, 0x0001, 0x0124);
761 }
762 
763 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
764 {
765 	cit_write_reg(gspca_dev, x,      0x0127);
766 	cit_write_reg(gspca_dev, 0x0000, 0x0124);
767 	cit_write_reg(gspca_dev, 0x0005, 0x0124);
768 	cit_write_reg(gspca_dev, 0x0002, 0x0124);
769 	cit_write_reg(gspca_dev, 0x0008, 0x0124);
770 	cit_write_reg(gspca_dev, 0x0001, 0x0124);
771 }
772 
773 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
774 {
775 	cit_send_x_01_00_05(gspca_dev, 0x0088);
776 	cit_send_x_00_05(gspca_dev, fkey);
777 	cit_send_x_00_05_02_08_01(gspca_dev, val);
778 	cit_send_x_00_05(gspca_dev, 0x0088);
779 	cit_send_x_00_05_02_01(gspca_dev, fkey);
780 	cit_send_x_00_05(gspca_dev, 0x0089);
781 	cit_send_x_00(gspca_dev, fkey);
782 	cit_send_00_04_06(gspca_dev);
783 	cit_read_reg(gspca_dev, 0x0126, 0);
784 	cit_send_FF_04_02(gspca_dev);
785 }
786 
787 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
788 {
789 	cit_send_x_01_00_05(gspca_dev, 0x0088);
790 	cit_send_x_00_05(gspca_dev, fkey);
791 	cit_send_x_00_05_02(gspca_dev, val);
792 }
793 
794 static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
795 {
796 	cit_write_reg(gspca_dev, 0x00ff, 0x012d);
797 	cit_write_reg(gspca_dev, 0xfea3, 0x0124);
798 }
799 
800 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
801 {
802 	cit_write_reg(gspca_dev, 0x00aa, 0x012d);
803 	cit_write_reg(gspca_dev, 0x00ff, 0x012e);
804 	cit_write_reg(gspca_dev, v1,     0x012f);
805 	cit_write_reg(gspca_dev, 0x00ff, 0x0130);
806 	cit_write_reg(gspca_dev, 0xc719, 0x0124);
807 	cit_write_reg(gspca_dev, v2,     0x0127);
808 
809 	cit_model2_Packet2(gspca_dev);
810 }
811 
812 /*
813  * cit_model3_Packet1()
814  *
815  * 00_0078_012d
816  * 00_0097_012f
817  * 00_d141_0124
818  * 00_0096_0127
819  * 00_fea8_0124
820 */
821 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
822 {
823 	cit_write_reg(gspca_dev, 0x0078, 0x012d);
824 	cit_write_reg(gspca_dev, v1,     0x012f);
825 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
826 	cit_write_reg(gspca_dev, v2,     0x0127);
827 	cit_write_reg(gspca_dev, 0xfea8, 0x0124);
828 }
829 
830 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
831 {
832 	cit_write_reg(gspca_dev, 0x00aa, 0x012d);
833 	cit_write_reg(gspca_dev, v1,     0x012f);
834 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
835 	cit_write_reg(gspca_dev, v2,     0x0127);
836 	cit_write_reg(gspca_dev, 0xfea8, 0x0124);
837 }
838 
839 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
840 {
841 	cit_write_reg(gspca_dev, 0x00aa, 0x012d);
842 	cit_write_reg(gspca_dev, 0x0026, 0x012f);
843 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
844 	cit_write_reg(gspca_dev, val,    0x0127);
845 	cit_write_reg(gspca_dev, 0x00aa, 0x0130);
846 	cit_write_reg(gspca_dev, 0x82a8, 0x0124);
847 	cit_write_reg(gspca_dev, 0x0038, 0x012d);
848 	cit_write_reg(gspca_dev, 0x0004, 0x012f);
849 	cit_write_reg(gspca_dev, 0xd145, 0x0124);
850 	cit_write_reg(gspca_dev, 0xfffa, 0x0124);
851 }
852 
853 /* this function is called at probe time */
854 static int sd_config(struct gspca_dev *gspca_dev,
855 		     const struct usb_device_id *id)
856 {
857 	struct sd *sd = (struct sd *) gspca_dev;
858 	struct cam *cam;
859 
860 	sd->model = id->driver_info;
861 	if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
862 		sd->model = CIT_IBM_NETCAM_PRO;
863 
864 	cam = &gspca_dev->cam;
865 	switch (sd->model) {
866 	case CIT_MODEL0:
867 		cam->cam_mode = model0_mode;
868 		cam->nmodes = ARRAY_SIZE(model0_mode);
869 		sd->sof_len = 4;
870 		break;
871 	case CIT_MODEL1:
872 		cam->cam_mode = cif_yuv_mode;
873 		cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
874 		sd->sof_len = 4;
875 		break;
876 	case CIT_MODEL2:
877 		cam->cam_mode = model2_mode + 1; /* no 160x120 */
878 		cam->nmodes = 3;
879 		break;
880 	case CIT_MODEL3:
881 		cam->cam_mode = vga_yuv_mode;
882 		cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
883 		sd->stop_on_control_change = 1;
884 		sd->sof_len = 4;
885 		break;
886 	case CIT_MODEL4:
887 		cam->cam_mode = model2_mode;
888 		cam->nmodes = ARRAY_SIZE(model2_mode);
889 		break;
890 	case CIT_IBM_NETCAM_PRO:
891 		cam->cam_mode = vga_yuv_mode;
892 		cam->nmodes = 2; /* no 640 x 480 */
893 		cam->input_flags = V4L2_IN_ST_VFLIP;
894 		sd->stop_on_control_change = 1;
895 		sd->sof_len = 4;
896 		break;
897 	}
898 
899 	return 0;
900 }
901 
902 static int cit_init_model0(struct gspca_dev *gspca_dev)
903 {
904 	cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
905 	cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
906 	cit_write_reg(gspca_dev, 0x0000, 0x0400);
907 	cit_write_reg(gspca_dev, 0x0001, 0x0400);
908 	cit_write_reg(gspca_dev, 0x0000, 0x0420);
909 	cit_write_reg(gspca_dev, 0x0001, 0x0420);
910 	cit_write_reg(gspca_dev, 0x000d, 0x0409);
911 	cit_write_reg(gspca_dev, 0x0002, 0x040a);
912 	cit_write_reg(gspca_dev, 0x0018, 0x0405);
913 	cit_write_reg(gspca_dev, 0x0008, 0x0435);
914 	cit_write_reg(gspca_dev, 0x0026, 0x040b);
915 	cit_write_reg(gspca_dev, 0x0007, 0x0437);
916 	cit_write_reg(gspca_dev, 0x0015, 0x042f);
917 	cit_write_reg(gspca_dev, 0x002b, 0x0439);
918 	cit_write_reg(gspca_dev, 0x0026, 0x043a);
919 	cit_write_reg(gspca_dev, 0x0008, 0x0438);
920 	cit_write_reg(gspca_dev, 0x001e, 0x042b);
921 	cit_write_reg(gspca_dev, 0x0041, 0x042c);
922 
923 	return 0;
924 }
925 
926 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
927 {
928 	cit_read_reg(gspca_dev, 0x128, 1);
929 	cit_write_reg(gspca_dev, 0x0003, 0x0133);
930 	cit_write_reg(gspca_dev, 0x0000, 0x0117);
931 	cit_write_reg(gspca_dev, 0x0008, 0x0123);
932 	cit_write_reg(gspca_dev, 0x0000, 0x0100);
933 	cit_read_reg(gspca_dev, 0x0116, 0);
934 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
935 	cit_write_reg(gspca_dev, 0x0002, 0x0112);
936 	cit_write_reg(gspca_dev, 0x0000, 0x0133);
937 	cit_write_reg(gspca_dev, 0x0000, 0x0123);
938 	cit_write_reg(gspca_dev, 0x0001, 0x0117);
939 	cit_write_reg(gspca_dev, 0x0040, 0x0108);
940 	cit_write_reg(gspca_dev, 0x0019, 0x012c);
941 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
942 	cit_write_reg(gspca_dev, 0x0002, 0x0115);
943 	cit_write_reg(gspca_dev, 0x000b, 0x0115);
944 
945 	cit_write_reg(gspca_dev, 0x0078, 0x012d);
946 	cit_write_reg(gspca_dev, 0x0001, 0x012f);
947 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
948 	cit_write_reg(gspca_dev, 0x0079, 0x012d);
949 	cit_write_reg(gspca_dev, 0x00ff, 0x0130);
950 	cit_write_reg(gspca_dev, 0xcd41, 0x0124);
951 	cit_write_reg(gspca_dev, 0xfffa, 0x0124);
952 	cit_read_reg(gspca_dev, 0x0126, 1);
953 
954 	cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
955 	cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
956 	cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
957 	cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
958 	cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
959 	cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
960 	cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
961 	cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
962 	cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
963 	cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
964 	cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
965 	cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
966 	cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
967 	cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
968 	cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
969 	cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
970 	cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
971 	cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
972 	cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
973 	cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
974 	cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
975 	cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
976 	cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
977 	cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
978 	cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
979 	cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
980 	cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
981 	cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
982 	cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
983 	cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
984 	cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
985 	cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
986 	cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
987 	cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
988 	cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
989 	cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
990 	cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
991 	cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
992 	cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
993 	cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
994 	cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
995 	cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
996 	cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
997 	cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
998 	cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
999 	cit_model3_Packet1(gspca_dev, 0x0048, 0x0000);
1000 	cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
1001 	cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff);
1002 	cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff);
1003 	cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff);
1004 	cit_model3_Packet1(gspca_dev, 0x004f, 0x0000);
1005 	cit_model3_Packet1(gspca_dev, 0x0050, 0x0000);
1006 	cit_model3_Packet1(gspca_dev, 0x0051, 0x0002);
1007 	cit_model3_Packet1(gspca_dev, 0x0055, 0x0000);
1008 	cit_model3_Packet1(gspca_dev, 0x0056, 0x0000);
1009 	cit_model3_Packet1(gspca_dev, 0x0057, 0x0000);
1010 	cit_model3_Packet1(gspca_dev, 0x0058, 0x0002);
1011 	cit_model3_Packet1(gspca_dev, 0x0059, 0x0000);
1012 	cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);
1013 	cit_model3_Packet1(gspca_dev, 0x005d, 0x0022);
1014 	cit_model3_Packet1(gspca_dev, 0x005e, 0x003c);
1015 	cit_model3_Packet1(gspca_dev, 0x005f, 0x0050);
1016 	cit_model3_Packet1(gspca_dev, 0x0060, 0x0044);
1017 	cit_model3_Packet1(gspca_dev, 0x0061, 0x0005);
1018 	cit_model3_Packet1(gspca_dev, 0x006a, 0x007e);
1019 	cit_model3_Packet1(gspca_dev, 0x006f, 0x0000);
1020 	cit_model3_Packet1(gspca_dev, 0x0072, 0x001b);
1021 	cit_model3_Packet1(gspca_dev, 0x0073, 0x0005);
1022 	cit_model3_Packet1(gspca_dev, 0x0074, 0x000a);
1023 	cit_model3_Packet1(gspca_dev, 0x0075, 0x001b);
1024 	cit_model3_Packet1(gspca_dev, 0x0076, 0x002a);
1025 	cit_model3_Packet1(gspca_dev, 0x0077, 0x003c);
1026 	cit_model3_Packet1(gspca_dev, 0x0078, 0x0050);
1027 	cit_model3_Packet1(gspca_dev, 0x007b, 0x0000);
1028 	cit_model3_Packet1(gspca_dev, 0x007c, 0x0011);
1029 	cit_model3_Packet1(gspca_dev, 0x007d, 0x0024);
1030 	cit_model3_Packet1(gspca_dev, 0x007e, 0x0043);
1031 	cit_model3_Packet1(gspca_dev, 0x007f, 0x005a);
1032 	cit_model3_Packet1(gspca_dev, 0x0084, 0x0020);
1033 	cit_model3_Packet1(gspca_dev, 0x0085, 0x0033);
1034 	cit_model3_Packet1(gspca_dev, 0x0086, 0x000a);
1035 	cit_model3_Packet1(gspca_dev, 0x0087, 0x0030);
1036 	cit_model3_Packet1(gspca_dev, 0x0088, 0x0070);
1037 	cit_model3_Packet1(gspca_dev, 0x008b, 0x0008);
1038 	cit_model3_Packet1(gspca_dev, 0x008f, 0x0000);
1039 	cit_model3_Packet1(gspca_dev, 0x0090, 0x0006);
1040 	cit_model3_Packet1(gspca_dev, 0x0091, 0x0028);
1041 	cit_model3_Packet1(gspca_dev, 0x0092, 0x005a);
1042 	cit_model3_Packet1(gspca_dev, 0x0093, 0x0082);
1043 	cit_model3_Packet1(gspca_dev, 0x0096, 0x0014);
1044 	cit_model3_Packet1(gspca_dev, 0x0097, 0x0020);
1045 	cit_model3_Packet1(gspca_dev, 0x0098, 0x0000);
1046 	cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046);
1047 	cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000);
1048 	cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000);
1049 	cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004);
1050 	cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007);
1051 	cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002);
1052 	cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004);
1053 	cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000);
1054 	cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001);
1055 	cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000);
1056 	cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000);
1057 	cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8);
1058 	cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014);
1059 	cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001);
1060 	cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000);
1061 	cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004);
1062 	cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf);
1063 	cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf);
1064 	cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf);
1065 	cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000);
1066 	cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020);
1067 	cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040);
1068 	cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1069 	cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1070 	cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf);
1071 	cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf);
1072 	cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008);
1073 	cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000);
1074 	cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8);
1075 	cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001);
1076 	cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022);
1077 	cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000);
1078 	cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028);
1079 	cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002);
1080 	cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000);
1081 	cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000);
1082 	cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001);
1083 	cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000);
1084 	cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000);
1085 	cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000);
1086 	cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000);
1087 
1088 	cit_model3_Packet1(gspca_dev, 0x00be, 0x0003);
1089 	cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000);
1090 	cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020);
1091 	cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040);
1092 	cit_model3_Packet1(gspca_dev, 0x0053, 0x0001);
1093 	cit_model3_Packet1(gspca_dev, 0x0082, 0x000e);
1094 	cit_model3_Packet1(gspca_dev, 0x0083, 0x0020);
1095 	cit_model3_Packet1(gspca_dev, 0x0034, 0x003c);
1096 	cit_model3_Packet1(gspca_dev, 0x006e, 0x0055);
1097 	cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);
1098 	cit_model3_Packet1(gspca_dev, 0x0063, 0x0008);
1099 	cit_model3_Packet1(gspca_dev, 0x0066, 0x000a);
1100 	cit_model3_Packet1(gspca_dev, 0x0067, 0x0006);
1101 	cit_model3_Packet1(gspca_dev, 0x006b, 0x0010);
1102 	cit_model3_Packet1(gspca_dev, 0x005a, 0x0001);
1103 	cit_model3_Packet1(gspca_dev, 0x005b, 0x000a);
1104 	cit_model3_Packet1(gspca_dev, 0x0023, 0x0006);
1105 	cit_model3_Packet1(gspca_dev, 0x0026, 0x0004);
1106 	cit_model3_Packet1(gspca_dev, 0x0036, 0x0069);
1107 	cit_model3_Packet1(gspca_dev, 0x0038, 0x0064);
1108 	cit_model3_Packet1(gspca_dev, 0x003d, 0x0003);
1109 	cit_model3_Packet1(gspca_dev, 0x003e, 0x0001);
1110 	cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014);
1111 	cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014);
1112 	cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004);
1113 	cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001);
1114 
1115 	return 0;
1116 }
1117 
1118 /* this function is called at probe and resume time */
1119 static int sd_init(struct gspca_dev *gspca_dev)
1120 {
1121 	struct sd *sd = (struct sd *) gspca_dev;
1122 
1123 	switch (sd->model) {
1124 	case CIT_MODEL0:
1125 		cit_init_model0(gspca_dev);
1126 		sd_stop0(gspca_dev);
1127 		break;
1128 	case CIT_MODEL1:
1129 	case CIT_MODEL2:
1130 	case CIT_MODEL3:
1131 	case CIT_MODEL4:
1132 		break; /* All is done in sd_start */
1133 	case CIT_IBM_NETCAM_PRO:
1134 		cit_init_ibm_netcam_pro(gspca_dev);
1135 		sd_stop0(gspca_dev);
1136 		break;
1137 	}
1138 	return 0;
1139 }
1140 
1141 static int cit_set_brightness(struct gspca_dev *gspca_dev, s32 val)
1142 {
1143 	struct sd *sd = (struct sd *) gspca_dev;
1144 	int i;
1145 
1146 	switch (sd->model) {
1147 	case CIT_MODEL0:
1148 	case CIT_IBM_NETCAM_PRO:
1149 		/* No (known) brightness control for these */
1150 		break;
1151 	case CIT_MODEL1:
1152 		/* Model 1: Brightness range 0 - 63 */
1153 		cit_Packet_Format1(gspca_dev, 0x0031, val);
1154 		cit_Packet_Format1(gspca_dev, 0x0032, val);
1155 		cit_Packet_Format1(gspca_dev, 0x0033, val);
1156 		break;
1157 	case CIT_MODEL2:
1158 		/* Model 2: Brightness range 0x60 - 0xee */
1159 		/* Scale 0 - 63 to 0x60 - 0xee */
1160 		i = 0x60 + val * 2254 / 1000;
1161 		cit_model2_Packet1(gspca_dev, 0x001a, i);
1162 		break;
1163 	case CIT_MODEL3:
1164 		/* Model 3: Brightness range 'i' in [0x0C..0x3F] */
1165 		i = val;
1166 		if (i < 0x0c)
1167 			i = 0x0c;
1168 		cit_model3_Packet1(gspca_dev, 0x0036, i);
1169 		break;
1170 	case CIT_MODEL4:
1171 		/* Model 4: Brightness range 'i' in [0x04..0xb4] */
1172 		/* Scale 0 - 63 to 0x04 - 0xb4 */
1173 		i = 0x04 + val * 2794 / 1000;
1174 		cit_model4_BrightnessPacket(gspca_dev, i);
1175 		break;
1176 	}
1177 
1178 	return 0;
1179 }
1180 
1181 static int cit_set_contrast(struct gspca_dev *gspca_dev, s32 val)
1182 {
1183 	struct sd *sd = (struct sd *) gspca_dev;
1184 
1185 	switch (sd->model) {
1186 	case CIT_MODEL0: {
1187 		int i;
1188 		/* gain 0-15, 0-20 -> 0-15 */
1189 		i = val * 1000 / 1333;
1190 		cit_write_reg(gspca_dev, i, 0x0422);
1191 		/* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */
1192 		i = val * 2000 / 1333;
1193 		cit_write_reg(gspca_dev, i, 0x0423);
1194 		/* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63  */
1195 		i = val * 4000 / 1333;
1196 		cit_write_reg(gspca_dev, i, 0x0424);
1197 		/* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */
1198 		i = val * 8000 / 1333;
1199 		cit_write_reg(gspca_dev, i, 0x0425);
1200 		break;
1201 	}
1202 	case CIT_MODEL2:
1203 	case CIT_MODEL4:
1204 		/* These models do not have this control. */
1205 		break;
1206 	case CIT_MODEL1:
1207 	{
1208 		/* Scale 0 - 20 to 15 - 0 */
1209 		int i, new_contrast = (20 - val) * 1000 / 1333;
1210 		for (i = 0; i < cit_model1_ntries; i++) {
1211 			cit_Packet_Format1(gspca_dev, 0x0014, new_contrast);
1212 			cit_send_FF_04_02(gspca_dev);
1213 		}
1214 		break;
1215 	}
1216 	case CIT_MODEL3:
1217 	{	/* Preset hardware values */
1218 		static const struct {
1219 			unsigned short cv1;
1220 			unsigned short cv2;
1221 			unsigned short cv3;
1222 		} cv[7] = {
1223 			{ 0x05, 0x05, 0x0f },	/* Minimum */
1224 			{ 0x04, 0x04, 0x16 },
1225 			{ 0x02, 0x03, 0x16 },
1226 			{ 0x02, 0x08, 0x16 },
1227 			{ 0x01, 0x0c, 0x16 },
1228 			{ 0x01, 0x0e, 0x16 },
1229 			{ 0x01, 0x10, 0x16 }	/* Maximum */
1230 		};
1231 		int i = val / 3;
1232 		cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1);
1233 		cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2);
1234 		cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3);
1235 		break;
1236 	}
1237 	case CIT_IBM_NETCAM_PRO:
1238 		cit_model3_Packet1(gspca_dev, 0x005b, val + 1);
1239 		break;
1240 	}
1241 	return 0;
1242 }
1243 
1244 static int cit_set_hue(struct gspca_dev *gspca_dev, s32 val)
1245 {
1246 	struct sd *sd = (struct sd *) gspca_dev;
1247 
1248 	switch (sd->model) {
1249 	case CIT_MODEL0:
1250 	case CIT_MODEL1:
1251 	case CIT_IBM_NETCAM_PRO:
1252 		/* No hue control for these models */
1253 		break;
1254 	case CIT_MODEL2:
1255 		cit_model2_Packet1(gspca_dev, 0x0024, val);
1256 		/* cit_model2_Packet1(gspca_dev, 0x0020, sat); */
1257 		break;
1258 	case CIT_MODEL3: {
1259 		/* Model 3: Brightness range 'i' in [0x05..0x37] */
1260 		/* TESTME according to the ibmcam driver this does not work */
1261 		if (0) {
1262 			/* Scale 0 - 127 to 0x05 - 0x37 */
1263 			int i = 0x05 + val * 1000 / 2540;
1264 			cit_model3_Packet1(gspca_dev, 0x007e, i);
1265 		}
1266 		break;
1267 	}
1268 	case CIT_MODEL4:
1269 		/* HDG: taken from ibmcam, setting the color gains does not
1270 		 * really belong here.
1271 		 *
1272 		 * I am not sure r/g/b_gain variables exactly control gain
1273 		 * of those channels. Most likely they subtly change some
1274 		 * very internal image processing settings in the camera.
1275 		 * In any case, here is what they do, and feel free to tweak:
1276 		 *
1277 		 * r_gain: seriously affects red gain
1278 		 * g_gain: seriously affects green gain
1279 		 * b_gain: seriously affects blue gain
1280 		 * hue: changes average color from violet (0) to red (0xFF)
1281 		 */
1282 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
1283 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
1284 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
1285 		cit_write_reg(gspca_dev,    160, 0x0127);  /* Green gain */
1286 		cit_write_reg(gspca_dev,    160, 0x012e);  /* Red gain */
1287 		cit_write_reg(gspca_dev,    160, 0x0130);  /* Blue gain */
1288 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
1289 		cit_write_reg(gspca_dev, val, 0x012d); /* Hue */
1290 		cit_write_reg(gspca_dev, 0xf545, 0x0124);
1291 		break;
1292 	}
1293 	return 0;
1294 }
1295 
1296 static int cit_set_sharpness(struct gspca_dev *gspca_dev, s32 val)
1297 {
1298 	struct sd *sd = (struct sd *) gspca_dev;
1299 
1300 	switch (sd->model) {
1301 	case CIT_MODEL0:
1302 	case CIT_MODEL2:
1303 	case CIT_MODEL4:
1304 	case CIT_IBM_NETCAM_PRO:
1305 		/* These models do not have this control */
1306 		break;
1307 	case CIT_MODEL1: {
1308 		int i;
1309 		static const unsigned short sa[] = {
1310 			0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
1311 
1312 		for (i = 0; i < cit_model1_ntries; i++)
1313 			cit_PacketFormat2(gspca_dev, 0x0013, sa[val]);
1314 		break;
1315 	}
1316 	case CIT_MODEL3:
1317 	{	/*
1318 		 * "Use a table of magic numbers.
1319 		 *  This setting doesn't really change much.
1320 		 *  But that's how Windows does it."
1321 		 */
1322 		static const struct {
1323 			unsigned short sv1;
1324 			unsigned short sv2;
1325 			unsigned short sv3;
1326 			unsigned short sv4;
1327 		} sv[7] = {
1328 			{ 0x00, 0x00, 0x05, 0x14 },	/* Smoothest */
1329 			{ 0x01, 0x04, 0x05, 0x14 },
1330 			{ 0x02, 0x04, 0x05, 0x14 },
1331 			{ 0x03, 0x04, 0x05, 0x14 },
1332 			{ 0x03, 0x05, 0x05, 0x14 },
1333 			{ 0x03, 0x06, 0x05, 0x14 },
1334 			{ 0x03, 0x07, 0x05, 0x14 }	/* Sharpest */
1335 		};
1336 		cit_model3_Packet1(gspca_dev, 0x0060, sv[val].sv1);
1337 		cit_model3_Packet1(gspca_dev, 0x0061, sv[val].sv2);
1338 		cit_model3_Packet1(gspca_dev, 0x0062, sv[val].sv3);
1339 		cit_model3_Packet1(gspca_dev, 0x0063, sv[val].sv4);
1340 		break;
1341 	}
1342 	}
1343 	return 0;
1344 }
1345 
1346 /*
1347  * cit_set_lighting()
1348  *
1349  * Camera model 1:
1350  * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
1351  *
1352  * Camera model 2:
1353  * We have 16 levels of lighting, 0 for bright light and up to 15 for
1354  * low light. But values above 5 or so are useless because camera is
1355  * not really capable to produce anything worth viewing at such light.
1356  * This setting may be altered only in certain camera state.
1357  *
1358  * Low lighting forces slower FPS.
1359  *
1360  * History:
1361  * 1/5/00   Created.
1362  * 2/20/00  Added support for Model 2 cameras.
1363  */
1364 static void cit_set_lighting(struct gspca_dev *gspca_dev, s32 val)
1365 {
1366 	struct sd *sd = (struct sd *) gspca_dev;
1367 
1368 	switch (sd->model) {
1369 	case CIT_MODEL0:
1370 	case CIT_MODEL2:
1371 	case CIT_MODEL3:
1372 	case CIT_MODEL4:
1373 	case CIT_IBM_NETCAM_PRO:
1374 		break;
1375 	case CIT_MODEL1: {
1376 		int i;
1377 		for (i = 0; i < cit_model1_ntries; i++)
1378 			cit_Packet_Format1(gspca_dev, 0x0027, val);
1379 		break;
1380 	}
1381 	}
1382 }
1383 
1384 static void cit_set_hflip(struct gspca_dev *gspca_dev, s32 val)
1385 {
1386 	struct sd *sd = (struct sd *) gspca_dev;
1387 
1388 	switch (sd->model) {
1389 	case CIT_MODEL0:
1390 		if (val)
1391 			cit_write_reg(gspca_dev, 0x0020, 0x0115);
1392 		else
1393 			cit_write_reg(gspca_dev, 0x0040, 0x0115);
1394 		break;
1395 	case CIT_MODEL1:
1396 	case CIT_MODEL2:
1397 	case CIT_MODEL3:
1398 	case CIT_MODEL4:
1399 	case CIT_IBM_NETCAM_PRO:
1400 		break;
1401 	}
1402 }
1403 
1404 static int cit_restart_stream(struct gspca_dev *gspca_dev)
1405 {
1406 	struct sd *sd = (struct sd *) gspca_dev;
1407 
1408 	switch (sd->model) {
1409 	case CIT_MODEL0:
1410 	case CIT_MODEL1:
1411 		cit_write_reg(gspca_dev, 0x0001, 0x0114);
1412 		/* Fall through */
1413 	case CIT_MODEL2:
1414 	case CIT_MODEL4:
1415 		cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1416 		usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1417 		break;
1418 	case CIT_MODEL3:
1419 	case CIT_IBM_NETCAM_PRO:
1420 		cit_write_reg(gspca_dev, 0x0001, 0x0114);
1421 		cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1422 		usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1423 		/* Clear button events from while we were not streaming */
1424 		cit_write_reg(gspca_dev, 0x0001, 0x0113);
1425 		break;
1426 	}
1427 
1428 	sd->sof_read = 0;
1429 
1430 	return 0;
1431 }
1432 
1433 static int cit_get_packet_size(struct gspca_dev *gspca_dev)
1434 {
1435 	struct usb_host_interface *alt;
1436 	struct usb_interface *intf;
1437 
1438 	intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
1439 	alt = usb_altnum_to_altsetting(intf, gspca_dev->alt);
1440 	if (!alt) {
1441 		pr_err("Couldn't get altsetting\n");
1442 		return -EIO;
1443 	}
1444 
1445 	if (alt->desc.bNumEndpoints < 1)
1446 		return -ENODEV;
1447 
1448 	return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
1449 }
1450 
1451 /* Calculate the clockdiv giving us max fps given the available bandwidth */
1452 static int cit_get_clock_div(struct gspca_dev *gspca_dev)
1453 {
1454 	int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */
1455 	int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 };
1456 	int packet_size;
1457 
1458 	packet_size = cit_get_packet_size(gspca_dev);
1459 	if (packet_size < 0)
1460 		return packet_size;
1461 
1462 	while (clock_div > 3 &&
1463 			1000 * packet_size >
1464 			gspca_dev->pixfmt.width * gspca_dev->pixfmt.height *
1465 			fps[clock_div - 1] * 3 / 2)
1466 		clock_div--;
1467 
1468 	gspca_dbg(gspca_dev, D_PROBE,
1469 		  "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)\n",
1470 		  packet_size,
1471 		  gspca_dev->pixfmt.width, gspca_dev->pixfmt.height,
1472 		  clock_div, fps[clock_div]);
1473 
1474 	return clock_div;
1475 }
1476 
1477 static int cit_start_model0(struct gspca_dev *gspca_dev)
1478 {
1479 	const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1480 	int clock_div;
1481 
1482 	clock_div = cit_get_clock_div(gspca_dev);
1483 	if (clock_div < 0)
1484 		return clock_div;
1485 
1486 	cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1487 	cit_write_reg(gspca_dev, 0x0003, 0x0438);
1488 	cit_write_reg(gspca_dev, 0x001e, 0x042b);
1489 	cit_write_reg(gspca_dev, 0x0041, 0x042c);
1490 	cit_write_reg(gspca_dev, 0x0008, 0x0436);
1491 	cit_write_reg(gspca_dev, 0x0024, 0x0403);
1492 	cit_write_reg(gspca_dev, 0x002c, 0x0404);
1493 	cit_write_reg(gspca_dev, 0x0002, 0x0426);
1494 	cit_write_reg(gspca_dev, 0x0014, 0x0427);
1495 
1496 	switch (gspca_dev->pixfmt.width) {
1497 	case 160: /* 160x120 */
1498 		cit_write_reg(gspca_dev, 0x0004, 0x010b);
1499 		cit_write_reg(gspca_dev, 0x0001, 0x010a);
1500 		cit_write_reg(gspca_dev, 0x0010, 0x0102);
1501 		cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1502 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
1503 		cit_write_reg(gspca_dev, 0x0078, 0x0105);
1504 		break;
1505 
1506 	case 176: /* 176x144 */
1507 		cit_write_reg(gspca_dev, 0x0006, 0x010b);
1508 		cit_write_reg(gspca_dev, 0x0000, 0x010a);
1509 		cit_write_reg(gspca_dev, 0x0005, 0x0102);
1510 		cit_write_reg(gspca_dev, 0x00b0, 0x0103);
1511 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
1512 		cit_write_reg(gspca_dev, 0x0090, 0x0105);
1513 		break;
1514 
1515 	case 320: /* 320x240 */
1516 		cit_write_reg(gspca_dev, 0x0008, 0x010b);
1517 		cit_write_reg(gspca_dev, 0x0004, 0x010a);
1518 		cit_write_reg(gspca_dev, 0x0005, 0x0102);
1519 		cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1520 		cit_write_reg(gspca_dev, 0x0010, 0x0104);
1521 		cit_write_reg(gspca_dev, 0x0078, 0x0105);
1522 		break;
1523 	}
1524 
1525 	cit_write_reg(gspca_dev, compression, 0x0109);
1526 	cit_write_reg(gspca_dev, clock_div, 0x0111);
1527 
1528 	return 0;
1529 }
1530 
1531 static int cit_start_model1(struct gspca_dev *gspca_dev)
1532 {
1533 	struct sd *sd = (struct sd *) gspca_dev;
1534 	int i, clock_div;
1535 
1536 	clock_div = cit_get_clock_div(gspca_dev);
1537 	if (clock_div < 0)
1538 		return clock_div;
1539 
1540 	cit_read_reg(gspca_dev, 0x0128, 1);
1541 	cit_read_reg(gspca_dev, 0x0100, 0);
1542 	cit_write_reg(gspca_dev, 0x01, 0x0100);	/* LED On  */
1543 	cit_read_reg(gspca_dev, 0x0100, 0);
1544 	cit_write_reg(gspca_dev, 0x81, 0x0100);	/* LED Off */
1545 	cit_read_reg(gspca_dev, 0x0100, 0);
1546 	cit_write_reg(gspca_dev, 0x01, 0x0100);	/* LED On  */
1547 	cit_write_reg(gspca_dev, 0x01, 0x0108);
1548 
1549 	cit_write_reg(gspca_dev, 0x03, 0x0112);
1550 	cit_read_reg(gspca_dev, 0x0115, 0);
1551 	cit_write_reg(gspca_dev, 0x06, 0x0115);
1552 	cit_read_reg(gspca_dev, 0x0116, 0);
1553 	cit_write_reg(gspca_dev, 0x44, 0x0116);
1554 	cit_read_reg(gspca_dev, 0x0116, 0);
1555 	cit_write_reg(gspca_dev, 0x40, 0x0116);
1556 	cit_read_reg(gspca_dev, 0x0115, 0);
1557 	cit_write_reg(gspca_dev, 0x0e, 0x0115);
1558 	cit_write_reg(gspca_dev, 0x19, 0x012c);
1559 
1560 	cit_Packet_Format1(gspca_dev, 0x00, 0x1e);
1561 	cit_Packet_Format1(gspca_dev, 0x39, 0x0d);
1562 	cit_Packet_Format1(gspca_dev, 0x39, 0x09);
1563 	cit_Packet_Format1(gspca_dev, 0x3b, 0x00);
1564 	cit_Packet_Format1(gspca_dev, 0x28, 0x22);
1565 	cit_Packet_Format1(gspca_dev, 0x27, 0x00);
1566 	cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1567 	cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1568 
1569 	for (i = 0; i < cit_model1_ntries; i++)
1570 		cit_Packet_Format1(gspca_dev, 0x2c, 0x00);
1571 
1572 	for (i = 0; i < cit_model1_ntries; i++)
1573 		cit_Packet_Format1(gspca_dev, 0x30, 0x14);
1574 
1575 	cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1576 	cit_PacketFormat2(gspca_dev, 0x01, 0xe1);
1577 	cit_PacketFormat2(gspca_dev, 0x02, 0xcd);
1578 	cit_PacketFormat2(gspca_dev, 0x03, 0xcd);
1579 	cit_PacketFormat2(gspca_dev, 0x04, 0xfa);
1580 	cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1581 	cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1582 
1583 	cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1584 	cit_PacketFormat2(gspca_dev, 0x0a, 0x37);
1585 	cit_PacketFormat2(gspca_dev, 0x0b, 0xb8);
1586 	cit_PacketFormat2(gspca_dev, 0x0c, 0xf3);
1587 	cit_PacketFormat2(gspca_dev, 0x0d, 0xe3);
1588 	cit_PacketFormat2(gspca_dev, 0x0e, 0x0d);
1589 	cit_PacketFormat2(gspca_dev, 0x0f, 0xf2);
1590 	cit_PacketFormat2(gspca_dev, 0x10, 0xd5);
1591 	cit_PacketFormat2(gspca_dev, 0x11, 0xba);
1592 	cit_PacketFormat2(gspca_dev, 0x12, 0x53);
1593 	cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1594 	cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1595 
1596 	cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1597 	cit_PacketFormat2(gspca_dev, 0x16, 0x00);
1598 	cit_PacketFormat2(gspca_dev, 0x17, 0x28);
1599 	cit_PacketFormat2(gspca_dev, 0x18, 0x7d);
1600 	cit_PacketFormat2(gspca_dev, 0x19, 0xbe);
1601 	cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1602 	cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1603 
1604 	for (i = 0; i < cit_model1_ntries; i++)
1605 		cit_Packet_Format1(gspca_dev, 0x00, 0x18);
1606 	for (i = 0; i < cit_model1_ntries; i++)
1607 		cit_Packet_Format1(gspca_dev, 0x13, 0x18);
1608 	for (i = 0; i < cit_model1_ntries; i++)
1609 		cit_Packet_Format1(gspca_dev, 0x14, 0x06);
1610 
1611 	/* TESTME These are handled through controls
1612 	   KEEP until someone can test leaving this out is ok */
1613 	if (0) {
1614 		/* This is default brightness */
1615 		for (i = 0; i < cit_model1_ntries; i++)
1616 			cit_Packet_Format1(gspca_dev, 0x31, 0x37);
1617 		for (i = 0; i < cit_model1_ntries; i++)
1618 			cit_Packet_Format1(gspca_dev, 0x32, 0x46);
1619 		for (i = 0; i < cit_model1_ntries; i++)
1620 			cit_Packet_Format1(gspca_dev, 0x33, 0x55);
1621 	}
1622 
1623 	cit_Packet_Format1(gspca_dev, 0x2e, 0x04);
1624 	for (i = 0; i < cit_model1_ntries; i++)
1625 		cit_Packet_Format1(gspca_dev, 0x2d, 0x04);
1626 	for (i = 0; i < cit_model1_ntries; i++)
1627 		cit_Packet_Format1(gspca_dev, 0x29, 0x80);
1628 	cit_Packet_Format1(gspca_dev, 0x2c, 0x01);
1629 	cit_Packet_Format1(gspca_dev, 0x30, 0x17);
1630 	cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1631 	for (i = 0; i < cit_model1_ntries; i++)
1632 		cit_Packet_Format1(gspca_dev, 0x34, 0x00);
1633 
1634 	cit_write_reg(gspca_dev, 0x00, 0x0101);
1635 	cit_write_reg(gspca_dev, 0x00, 0x010a);
1636 
1637 	switch (gspca_dev->pixfmt.width) {
1638 	case 128: /* 128x96 */
1639 		cit_write_reg(gspca_dev, 0x80, 0x0103);
1640 		cit_write_reg(gspca_dev, 0x60, 0x0105);
1641 		cit_write_reg(gspca_dev, 0x0c, 0x010b);
1642 		cit_write_reg(gspca_dev, 0x04, 0x011b);	/* Same everywhere */
1643 		cit_write_reg(gspca_dev, 0x0b, 0x011d);
1644 		cit_write_reg(gspca_dev, 0x00, 0x011e);	/* Same everywhere */
1645 		cit_write_reg(gspca_dev, 0x00, 0x0129);
1646 		break;
1647 	case 176: /* 176x144 */
1648 		cit_write_reg(gspca_dev, 0xb0, 0x0103);
1649 		cit_write_reg(gspca_dev, 0x8f, 0x0105);
1650 		cit_write_reg(gspca_dev, 0x06, 0x010b);
1651 		cit_write_reg(gspca_dev, 0x04, 0x011b);	/* Same everywhere */
1652 		cit_write_reg(gspca_dev, 0x0d, 0x011d);
1653 		cit_write_reg(gspca_dev, 0x00, 0x011e);	/* Same everywhere */
1654 		cit_write_reg(gspca_dev, 0x03, 0x0129);
1655 		break;
1656 	case 352: /* 352x288 */
1657 		cit_write_reg(gspca_dev, 0xb0, 0x0103);
1658 		cit_write_reg(gspca_dev, 0x90, 0x0105);
1659 		cit_write_reg(gspca_dev, 0x02, 0x010b);
1660 		cit_write_reg(gspca_dev, 0x04, 0x011b);	/* Same everywhere */
1661 		cit_write_reg(gspca_dev, 0x05, 0x011d);
1662 		cit_write_reg(gspca_dev, 0x00, 0x011e);	/* Same everywhere */
1663 		cit_write_reg(gspca_dev, 0x00, 0x0129);
1664 		break;
1665 	}
1666 
1667 	cit_write_reg(gspca_dev, 0xff, 0x012b);
1668 
1669 	/* TESTME These are handled through controls
1670 	   KEEP until someone can test leaving this out is ok */
1671 	if (0) {
1672 		/* This is another brightness - don't know why */
1673 		for (i = 0; i < cit_model1_ntries; i++)
1674 			cit_Packet_Format1(gspca_dev, 0x31, 0xc3);
1675 		for (i = 0; i < cit_model1_ntries; i++)
1676 			cit_Packet_Format1(gspca_dev, 0x32, 0xd2);
1677 		for (i = 0; i < cit_model1_ntries; i++)
1678 			cit_Packet_Format1(gspca_dev, 0x33, 0xe1);
1679 
1680 		/* Default contrast */
1681 		for (i = 0; i < cit_model1_ntries; i++)
1682 			cit_Packet_Format1(gspca_dev, 0x14, 0x0a);
1683 
1684 		/* Default sharpness */
1685 		for (i = 0; i < cit_model1_ntries2; i++)
1686 			cit_PacketFormat2(gspca_dev, 0x13, 0x1a);
1687 
1688 		/* Default lighting conditions */
1689 		cit_Packet_Format1(gspca_dev, 0x0027,
1690 				   v4l2_ctrl_g_ctrl(sd->lighting));
1691 	}
1692 
1693 	/* Assorted init */
1694 	switch (gspca_dev->pixfmt.width) {
1695 	case 128: /* 128x96 */
1696 		cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1697 		cit_write_reg(gspca_dev, 0xc9, 0x0119);	/* Same everywhere */
1698 		cit_write_reg(gspca_dev, 0x80, 0x0109);	/* Same everywhere */
1699 		cit_write_reg(gspca_dev, 0x36, 0x0102);
1700 		cit_write_reg(gspca_dev, 0x1a, 0x0104);
1701 		cit_write_reg(gspca_dev, 0x04, 0x011a);	/* Same everywhere */
1702 		cit_write_reg(gspca_dev, 0x2b, 0x011c);
1703 		cit_write_reg(gspca_dev, 0x23, 0x012a);	/* Same everywhere */
1704 		break;
1705 	case 176: /* 176x144 */
1706 		cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1707 		cit_write_reg(gspca_dev, 0xc9, 0x0119);	/* Same everywhere */
1708 		cit_write_reg(gspca_dev, 0x80, 0x0109);	/* Same everywhere */
1709 		cit_write_reg(gspca_dev, 0x04, 0x0102);
1710 		cit_write_reg(gspca_dev, 0x02, 0x0104);
1711 		cit_write_reg(gspca_dev, 0x04, 0x011a);	/* Same everywhere */
1712 		cit_write_reg(gspca_dev, 0x2b, 0x011c);
1713 		cit_write_reg(gspca_dev, 0x23, 0x012a);	/* Same everywhere */
1714 		break;
1715 	case 352: /* 352x288 */
1716 		cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1717 		cit_write_reg(gspca_dev, 0xc9, 0x0119);	/* Same everywhere */
1718 		cit_write_reg(gspca_dev, 0x80, 0x0109);	/* Same everywhere */
1719 		cit_write_reg(gspca_dev, 0x08, 0x0102);
1720 		cit_write_reg(gspca_dev, 0x01, 0x0104);
1721 		cit_write_reg(gspca_dev, 0x04, 0x011a);	/* Same everywhere */
1722 		cit_write_reg(gspca_dev, 0x2f, 0x011c);
1723 		cit_write_reg(gspca_dev, 0x23, 0x012a);	/* Same everywhere */
1724 		break;
1725 	}
1726 
1727 	cit_write_reg(gspca_dev, 0x01, 0x0100);	/* LED On  */
1728 	cit_write_reg(gspca_dev, clock_div, 0x0111);
1729 
1730 	return 0;
1731 }
1732 
1733 static int cit_start_model2(struct gspca_dev *gspca_dev)
1734 {
1735 	struct sd *sd = (struct sd *) gspca_dev;
1736 	int clock_div = 0;
1737 
1738 	cit_write_reg(gspca_dev, 0x0000, 0x0100);	/* LED on */
1739 	cit_read_reg(gspca_dev, 0x0116, 0);
1740 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
1741 	cit_write_reg(gspca_dev, 0x0002, 0x0112);
1742 	cit_write_reg(gspca_dev, 0x00bc, 0x012c);
1743 	cit_write_reg(gspca_dev, 0x0008, 0x012b);
1744 	cit_write_reg(gspca_dev, 0x0000, 0x0108);
1745 	cit_write_reg(gspca_dev, 0x0001, 0x0133);
1746 	cit_write_reg(gspca_dev, 0x0001, 0x0102);
1747 	switch (gspca_dev->pixfmt.width) {
1748 	case 176: /* 176x144 */
1749 		cit_write_reg(gspca_dev, 0x002c, 0x0103);	/* All except 320x240 */
1750 		cit_write_reg(gspca_dev, 0x0000, 0x0104);	/* Same */
1751 		cit_write_reg(gspca_dev, 0x0024, 0x0105);	/* 176x144, 352x288 */
1752 		cit_write_reg(gspca_dev, 0x00b9, 0x010a);	/* Unique to this mode */
1753 		cit_write_reg(gspca_dev, 0x0038, 0x0119);	/* Unique to this mode */
1754 		/* TESTME HDG: this does not seem right
1755 		   (it is 2 for all other resolutions) */
1756 		sd->sof_len = 10;
1757 		break;
1758 	case 320: /* 320x240 */
1759 		cit_write_reg(gspca_dev, 0x0028, 0x0103);	/* Unique to this mode */
1760 		cit_write_reg(gspca_dev, 0x0000, 0x0104);	/* Same */
1761 		cit_write_reg(gspca_dev, 0x001e, 0x0105);	/* 320x240, 352x240 */
1762 		cit_write_reg(gspca_dev, 0x0039, 0x010a);	/* All except 176x144 */
1763 		cit_write_reg(gspca_dev, 0x0070, 0x0119);	/* All except 176x144 */
1764 		sd->sof_len = 2;
1765 		break;
1766 #if 0
1767 	case VIDEOSIZE_352x240:
1768 		cit_write_reg(gspca_dev, 0x002c, 0x0103);	/* All except 320x240 */
1769 		cit_write_reg(gspca_dev, 0x0000, 0x0104);	/* Same */
1770 		cit_write_reg(gspca_dev, 0x001e, 0x0105);	/* 320x240, 352x240 */
1771 		cit_write_reg(gspca_dev, 0x0039, 0x010a);	/* All except 176x144 */
1772 		cit_write_reg(gspca_dev, 0x0070, 0x0119);	/* All except 176x144 */
1773 		sd->sof_len = 2;
1774 		break;
1775 #endif
1776 	case 352: /* 352x288 */
1777 		cit_write_reg(gspca_dev, 0x002c, 0x0103);	/* All except 320x240 */
1778 		cit_write_reg(gspca_dev, 0x0000, 0x0104);	/* Same */
1779 		cit_write_reg(gspca_dev, 0x0024, 0x0105);	/* 176x144, 352x288 */
1780 		cit_write_reg(gspca_dev, 0x0039, 0x010a);	/* All except 176x144 */
1781 		cit_write_reg(gspca_dev, 0x0070, 0x0119);	/* All except 176x144 */
1782 		sd->sof_len = 2;
1783 		break;
1784 	}
1785 
1786 	cit_write_reg(gspca_dev, 0x0000, 0x0100);	/* LED on */
1787 
1788 	switch (gspca_dev->pixfmt.width) {
1789 	case 176: /* 176x144 */
1790 		cit_write_reg(gspca_dev, 0x0050, 0x0111);
1791 		cit_write_reg(gspca_dev, 0x00d0, 0x0111);
1792 		break;
1793 	case 320: /* 320x240 */
1794 	case 352: /* 352x288 */
1795 		cit_write_reg(gspca_dev, 0x0040, 0x0111);
1796 		cit_write_reg(gspca_dev, 0x00c0, 0x0111);
1797 		break;
1798 	}
1799 	cit_write_reg(gspca_dev, 0x009b, 0x010f);
1800 	cit_write_reg(gspca_dev, 0x00bb, 0x010f);
1801 
1802 	/*
1803 	 * Hardware settings, may affect CMOS sensor; not user controls!
1804 	 * -------------------------------------------------------------
1805 	 * 0x0004: no effect
1806 	 * 0x0006: hardware effect
1807 	 * 0x0008: no effect
1808 	 * 0x000a: stops video stream, probably important h/w setting
1809 	 * 0x000c: changes color in hardware manner (not user setting)
1810 	 * 0x0012: changes number of colors (does not affect speed)
1811 	 * 0x002a: no effect
1812 	 * 0x002c: hardware setting (related to scan lines)
1813 	 * 0x002e: stops video stream, probably important h/w setting
1814 	 */
1815 	cit_model2_Packet1(gspca_dev, 0x000a, 0x005c);
1816 	cit_model2_Packet1(gspca_dev, 0x0004, 0x0000);
1817 	cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb);
1818 	cit_model2_Packet1(gspca_dev, 0x0008, 0x0000);
1819 	cit_model2_Packet1(gspca_dev, 0x000c, 0x0009);
1820 	cit_model2_Packet1(gspca_dev, 0x0012, 0x000a);
1821 	cit_model2_Packet1(gspca_dev, 0x002a, 0x0000);
1822 	cit_model2_Packet1(gspca_dev, 0x002c, 0x0000);
1823 	cit_model2_Packet1(gspca_dev, 0x002e, 0x0008);
1824 
1825 	/*
1826 	 * Function 0x0030 pops up all over the place. Apparently
1827 	 * it is a hardware control register, with every bit assigned to
1828 	 * do something.
1829 	 */
1830 	cit_model2_Packet1(gspca_dev, 0x0030, 0x0000);
1831 
1832 	/*
1833 	 * Magic control of CMOS sensor. Only lower values like
1834 	 * 0-3 work, and picture shifts left or right. Don't change.
1835 	 */
1836 	switch (gspca_dev->pixfmt.width) {
1837 	case 176: /* 176x144 */
1838 		cit_model2_Packet1(gspca_dev, 0x0014, 0x0002);
1839 		cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1840 		cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1841 		clock_div = 6;
1842 		break;
1843 	case 320: /* 320x240 */
1844 		cit_model2_Packet1(gspca_dev, 0x0014, 0x0009);
1845 		cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */
1846 		cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */
1847 		clock_div = 8;
1848 		break;
1849 #if 0
1850 	case VIDEOSIZE_352x240:
1851 		/* This mode doesn't work as Windows programs it; changed to work */
1852 		cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */
1853 		cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */
1854 		cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
1855 		clock_div = 10;
1856 		break;
1857 #endif
1858 	case 352: /* 352x288 */
1859 		cit_model2_Packet1(gspca_dev, 0x0014, 0x0003);
1860 		cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1861 		cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1862 		clock_div = 16;
1863 		break;
1864 	}
1865 
1866 	/* TESTME These are handled through controls
1867 	   KEEP until someone can test leaving this out is ok */
1868 	if (0)
1869 		cit_model2_Packet1(gspca_dev, 0x001a, 0x005a);
1870 
1871 	/*
1872 	 * We have our own frame rate setting varying from 0 (slowest) to 6
1873 	 * (fastest). The camera model 2 allows frame rate in range [0..0x1F]
1874 	 # where 0 is also the slowest setting. However for all practical
1875 	 # reasons high settings make no sense because USB is not fast enough
1876 	 # to support high FPS. Be aware that the picture datastream will be
1877 	 # severely disrupted if you ask for frame rate faster than allowed
1878 	 # for the video size - see below:
1879 	 *
1880 	 * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
1881 	 * -----------------------------------------------------------------
1882 	 * 176x144: [6..31]
1883 	 * 320x240: [8..31]
1884 	 * 352x240: [10..31]
1885 	 * 352x288: [16..31] I have to raise lower threshold for stability...
1886 	 *
1887 	 * As usual, slower FPS provides better sensitivity.
1888 	 */
1889 	cit_model2_Packet1(gspca_dev, 0x001c, clock_div);
1890 
1891 	/*
1892 	 * This setting does not visibly affect pictures; left it here
1893 	 * because it was present in Windows USB data stream. This function
1894 	 * does not allow arbitrary values and apparently is a bit mask, to
1895 	 * be activated only at appropriate time. Don't change it randomly!
1896 	 */
1897 	switch (gspca_dev->pixfmt.width) {
1898 	case 176: /* 176x144 */
1899 		cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2);
1900 		break;
1901 	case 320: /* 320x240 */
1902 		cit_model2_Packet1(gspca_dev, 0x0026, 0x0044);
1903 		break;
1904 #if 0
1905 	case VIDEOSIZE_352x240:
1906 		cit_model2_Packet1(gspca_dev, 0x0026, 0x0046);
1907 		break;
1908 #endif
1909 	case 352: /* 352x288 */
1910 		cit_model2_Packet1(gspca_dev, 0x0026, 0x0048);
1911 		break;
1912 	}
1913 
1914 	cit_model2_Packet1(gspca_dev, 0x0028, v4l2_ctrl_g_ctrl(sd->lighting));
1915 	/* model2 cannot change the backlight compensation while streaming */
1916 	v4l2_ctrl_grab(sd->lighting, true);
1917 
1918 	/* color balance rg2 */
1919 	cit_model2_Packet1(gspca_dev, 0x001e, 0x002f);
1920 	/* saturation */
1921 	cit_model2_Packet1(gspca_dev, 0x0020, 0x0034);
1922 	/* color balance yb */
1923 	cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0);
1924 
1925 	/* Hardware control command */
1926 	cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
1927 
1928 	return 0;
1929 }
1930 
1931 static int cit_start_model3(struct gspca_dev *gspca_dev)
1932 {
1933 	const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1934 	int i, clock_div = 0;
1935 
1936 	/* HDG not in ibmcam driver, added to see if it helps with
1937 	   auto-detecting between model3 and ibm netcamera pro */
1938 	cit_read_reg(gspca_dev, 0x128, 1);
1939 
1940 	cit_write_reg(gspca_dev, 0x0000, 0x0100);
1941 	cit_read_reg(gspca_dev, 0x0116, 0);
1942 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
1943 	cit_write_reg(gspca_dev, 0x0002, 0x0112);
1944 	cit_write_reg(gspca_dev, 0x0000, 0x0123);
1945 	cit_write_reg(gspca_dev, 0x0001, 0x0117);
1946 	cit_write_reg(gspca_dev, 0x0040, 0x0108);
1947 	cit_write_reg(gspca_dev, 0x0019, 0x012c);
1948 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
1949 	cit_write_reg(gspca_dev, 0x0002, 0x0115);
1950 	cit_write_reg(gspca_dev, 0x0003, 0x0115);
1951 	cit_read_reg(gspca_dev, 0x0115, 0);
1952 	cit_write_reg(gspca_dev, 0x000b, 0x0115);
1953 
1954 	/* TESTME HDG not in ibmcam driver, added to see if it helps with
1955 	   auto-detecting between model3 and ibm netcamera pro */
1956 	if (0) {
1957 		cit_write_reg(gspca_dev, 0x0078, 0x012d);
1958 		cit_write_reg(gspca_dev, 0x0001, 0x012f);
1959 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
1960 		cit_write_reg(gspca_dev, 0x0079, 0x012d);
1961 		cit_write_reg(gspca_dev, 0x00ff, 0x0130);
1962 		cit_write_reg(gspca_dev, 0xcd41, 0x0124);
1963 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
1964 		cit_read_reg(gspca_dev, 0x0126, 1);
1965 	}
1966 
1967 	cit_model3_Packet1(gspca_dev, 0x000a, 0x0040);
1968 	cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6);
1969 	cit_model3_Packet1(gspca_dev, 0x000c, 0x0002);
1970 	cit_model3_Packet1(gspca_dev, 0x000d, 0x0020);
1971 	cit_model3_Packet1(gspca_dev, 0x000e, 0x0033);
1972 	cit_model3_Packet1(gspca_dev, 0x000f, 0x0007);
1973 	cit_model3_Packet1(gspca_dev, 0x0010, 0x0000);
1974 	cit_model3_Packet1(gspca_dev, 0x0011, 0x0070);
1975 	cit_model3_Packet1(gspca_dev, 0x0012, 0x0030);
1976 	cit_model3_Packet1(gspca_dev, 0x0013, 0x0000);
1977 	cit_model3_Packet1(gspca_dev, 0x0014, 0x0001);
1978 	cit_model3_Packet1(gspca_dev, 0x0015, 0x0001);
1979 	cit_model3_Packet1(gspca_dev, 0x0016, 0x0001);
1980 	cit_model3_Packet1(gspca_dev, 0x0017, 0x0001);
1981 	cit_model3_Packet1(gspca_dev, 0x0018, 0x0000);
1982 	cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3);
1983 	cit_model3_Packet1(gspca_dev, 0x0020, 0x0000);
1984 	cit_model3_Packet1(gspca_dev, 0x0028, 0x0010);
1985 	cit_model3_Packet1(gspca_dev, 0x0029, 0x0054);
1986 	cit_model3_Packet1(gspca_dev, 0x002a, 0x0013);
1987 	cit_model3_Packet1(gspca_dev, 0x002b, 0x0007);
1988 	cit_model3_Packet1(gspca_dev, 0x002d, 0x0028);
1989 	cit_model3_Packet1(gspca_dev, 0x002e, 0x0000);
1990 	cit_model3_Packet1(gspca_dev, 0x0031, 0x0000);
1991 	cit_model3_Packet1(gspca_dev, 0x0032, 0x0000);
1992 	cit_model3_Packet1(gspca_dev, 0x0033, 0x0000);
1993 	cit_model3_Packet1(gspca_dev, 0x0034, 0x0000);
1994 	cit_model3_Packet1(gspca_dev, 0x0035, 0x0038);
1995 	cit_model3_Packet1(gspca_dev, 0x003a, 0x0001);
1996 	cit_model3_Packet1(gspca_dev, 0x003c, 0x001e);
1997 	cit_model3_Packet1(gspca_dev, 0x003f, 0x000a);
1998 	cit_model3_Packet1(gspca_dev, 0x0041, 0x0000);
1999 	cit_model3_Packet1(gspca_dev, 0x0046, 0x003f);
2000 	cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
2001 	cit_model3_Packet1(gspca_dev, 0x0050, 0x0005);
2002 	cit_model3_Packet1(gspca_dev, 0x0052, 0x001a);
2003 	cit_model3_Packet1(gspca_dev, 0x0053, 0x0003);
2004 	cit_model3_Packet1(gspca_dev, 0x005a, 0x006b);
2005 	cit_model3_Packet1(gspca_dev, 0x005d, 0x001e);
2006 	cit_model3_Packet1(gspca_dev, 0x005e, 0x0030);
2007 	cit_model3_Packet1(gspca_dev, 0x005f, 0x0041);
2008 	cit_model3_Packet1(gspca_dev, 0x0064, 0x0008);
2009 	cit_model3_Packet1(gspca_dev, 0x0065, 0x0015);
2010 	cit_model3_Packet1(gspca_dev, 0x0068, 0x000f);
2011 	cit_model3_Packet1(gspca_dev, 0x0079, 0x0000);
2012 	cit_model3_Packet1(gspca_dev, 0x007a, 0x0000);
2013 	cit_model3_Packet1(gspca_dev, 0x007c, 0x003f);
2014 	cit_model3_Packet1(gspca_dev, 0x0082, 0x000f);
2015 	cit_model3_Packet1(gspca_dev, 0x0085, 0x0000);
2016 	cit_model3_Packet1(gspca_dev, 0x0099, 0x0000);
2017 	cit_model3_Packet1(gspca_dev, 0x009b, 0x0023);
2018 	cit_model3_Packet1(gspca_dev, 0x009c, 0x0022);
2019 	cit_model3_Packet1(gspca_dev, 0x009d, 0x0096);
2020 	cit_model3_Packet1(gspca_dev, 0x009e, 0x0096);
2021 	cit_model3_Packet1(gspca_dev, 0x009f, 0x000a);
2022 
2023 	switch (gspca_dev->pixfmt.width) {
2024 	case 160:
2025 		cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2026 		cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2027 		cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2028 		cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2029 		cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */
2030 		cit_write_reg(gspca_dev, 0x00a9, 0x0119);
2031 		cit_write_reg(gspca_dev, 0x0016, 0x011b);
2032 		cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2033 		cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2034 		cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2035 		cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2036 		cit_write_reg(gspca_dev, 0x0018, 0x0102);
2037 		cit_write_reg(gspca_dev, 0x0004, 0x0104);
2038 		cit_write_reg(gspca_dev, 0x0004, 0x011a);
2039 		cit_write_reg(gspca_dev, 0x0028, 0x011c);
2040 		cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2041 		cit_write_reg(gspca_dev, 0x0000, 0x0118);
2042 		cit_write_reg(gspca_dev, 0x0000, 0x0132);
2043 		cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2044 		cit_write_reg(gspca_dev, compression, 0x0109);
2045 		clock_div = 3;
2046 		break;
2047 	case 320:
2048 		cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2049 		cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2050 		cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2051 		cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2052 		cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */
2053 		cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */
2054 		cit_write_reg(gspca_dev, 0x0000, 0x011e);
2055 		cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2056 		cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2057 		/* 4 commands from 160x120 skipped */
2058 		cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2059 		cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2060 		cit_write_reg(gspca_dev, compression, 0x0109);
2061 		cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2062 		cit_write_reg(gspca_dev, 0x0006, 0x011b);
2063 		cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2064 		cit_write_reg(gspca_dev, 0x0010, 0x0104);
2065 		cit_write_reg(gspca_dev, 0x0004, 0x011a);
2066 		cit_write_reg(gspca_dev, 0x003f, 0x011c);
2067 		cit_write_reg(gspca_dev, 0x001c, 0x0118);
2068 		cit_write_reg(gspca_dev, 0x0000, 0x0132);
2069 		clock_div = 5;
2070 		break;
2071 	case 640:
2072 		cit_write_reg(gspca_dev, 0x00f0, 0x0105);
2073 		cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2074 		cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */
2075 		cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
2076 		cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
2077 		cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */
2078 		cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2079 		cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2080 		cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2081 		cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2082 		cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */
2083 		cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
2084 		cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
2085 		cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2086 		cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
2087 		cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2088 		cit_write_reg(gspca_dev, compression, 0x0109);
2089 		cit_write_reg(gspca_dev, 0x0040, 0x0101);
2090 		cit_write_reg(gspca_dev, 0x0040, 0x0103);
2091 		cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
2092 		clock_div = 7;
2093 		break;
2094 	}
2095 
2096 	cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);	/* Hue */
2097 	cit_model3_Packet1(gspca_dev, 0x0036, 0x0011);	/* Brightness */
2098 	cit_model3_Packet1(gspca_dev, 0x0060, 0x0002);	/* Sharpness */
2099 	cit_model3_Packet1(gspca_dev, 0x0061, 0x0004);	/* Sharpness */
2100 	cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);	/* Sharpness */
2101 	cit_model3_Packet1(gspca_dev, 0x0063, 0x0014);	/* Sharpness */
2102 	cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);	/* Red sharpness */
2103 	cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);	/* Blue sharpness */
2104 	cit_model3_Packet1(gspca_dev, 0x0067, 0x0001);	/* Contrast */
2105 	cit_model3_Packet1(gspca_dev, 0x005b, 0x000c);	/* Contrast */
2106 	cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);	/* Contrast */
2107 	cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2108 	cit_model3_Packet1(gspca_dev, 0x002c, 0x0003);	/* Was 1, broke 640x480 */
2109 	cit_model3_Packet1(gspca_dev, 0x002f, 0x002a);
2110 	cit_model3_Packet1(gspca_dev, 0x0030, 0x0029);
2111 	cit_model3_Packet1(gspca_dev, 0x0037, 0x0002);
2112 	cit_model3_Packet1(gspca_dev, 0x0038, 0x0059);
2113 	cit_model3_Packet1(gspca_dev, 0x003d, 0x002e);
2114 	cit_model3_Packet1(gspca_dev, 0x003e, 0x0028);
2115 	cit_model3_Packet1(gspca_dev, 0x0078, 0x0005);
2116 	cit_model3_Packet1(gspca_dev, 0x007b, 0x0011);
2117 	cit_model3_Packet1(gspca_dev, 0x007d, 0x004b);
2118 	cit_model3_Packet1(gspca_dev, 0x007f, 0x0022);
2119 	cit_model3_Packet1(gspca_dev, 0x0080, 0x000c);
2120 	cit_model3_Packet1(gspca_dev, 0x0081, 0x000b);
2121 	cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd);
2122 	cit_model3_Packet1(gspca_dev, 0x0086, 0x000b);
2123 	cit_model3_Packet1(gspca_dev, 0x0087, 0x000b);
2124 	cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);
2125 	cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0);	/* Red sharpness */
2126 	cit_model3_Packet1(gspca_dev, 0x0097, 0x0096);	/* Blue sharpness */
2127 	cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2128 
2129 	/* FIXME we should probably use cit_get_clock_div() here (in
2130 	   combination with isoc negotiation using the programmable isoc size)
2131 	   like with the IBM netcam pro). */
2132 	cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */
2133 
2134 	switch (gspca_dev->pixfmt.width) {
2135 	case 160:
2136 		cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2137 		cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2138 		cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2139 		cit_model3_Packet1(gspca_dev, 0x0040, 0x000a);
2140 		cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2141 		break;
2142 	case 320:
2143 		cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2144 		cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2145 		cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2146 		cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2147 		cit_model3_Packet1(gspca_dev, 0x0051, 0x000b);
2148 		break;
2149 	case 640:
2150 		cit_model3_Packet1(gspca_dev, 0x001f, 0x0002);	/* !Same */
2151 		cit_model3_Packet1(gspca_dev, 0x0039, 0x003e);	/* !Same */
2152 		cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2153 		cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2154 		break;
2155 	}
2156 
2157 /*	if (sd->input_index) { */
2158 	if (rca_input) {
2159 		for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2160 			if (rca_initdata[i][0])
2161 				cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2162 			else
2163 				cit_write_reg(gspca_dev, rca_initdata[i][1],
2164 					      rca_initdata[i][2]);
2165 		}
2166 	}
2167 
2168 	return 0;
2169 }
2170 
2171 static int cit_start_model4(struct gspca_dev *gspca_dev)
2172 {
2173 	struct sd *sd = (struct sd *) gspca_dev;
2174 
2175 	cit_write_reg(gspca_dev, 0x0000, 0x0100);
2176 	cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2177 	cit_write_reg(gspca_dev, 0x00bc, 0x012c);
2178 	cit_write_reg(gspca_dev, 0x0080, 0x012b);
2179 	cit_write_reg(gspca_dev, 0x0000, 0x0108);
2180 	cit_write_reg(gspca_dev, 0x0001, 0x0133);
2181 	cit_write_reg(gspca_dev, 0x009b, 0x010f);
2182 	cit_write_reg(gspca_dev, 0x00bb, 0x010f);
2183 	cit_model4_Packet1(gspca_dev, 0x0038, 0x0000);
2184 	cit_model4_Packet1(gspca_dev, 0x000a, 0x005c);
2185 
2186 	cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2187 	cit_write_reg(gspca_dev, 0x0004, 0x012f);
2188 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
2189 	cit_write_reg(gspca_dev, 0x0000, 0x0127);
2190 	cit_write_reg(gspca_dev, 0x00fb, 0x012e);
2191 	cit_write_reg(gspca_dev, 0x0000, 0x0130);
2192 	cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2193 	cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2194 	cit_write_reg(gspca_dev, 0xd055, 0x0124);
2195 	cit_write_reg(gspca_dev, 0x000c, 0x0127);
2196 	cit_write_reg(gspca_dev, 0x0009, 0x012e);
2197 	cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2198 
2199 	cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2200 	cit_write_reg(gspca_dev, 0x0012, 0x012f);
2201 	cit_write_reg(gspca_dev, 0xd141, 0x0124);
2202 	cit_write_reg(gspca_dev, 0x0008, 0x0127);
2203 	cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2204 	cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2205 	cit_write_reg(gspca_dev, 0x002a, 0x012d);
2206 	cit_write_reg(gspca_dev, 0x0000, 0x012f);
2207 	cit_write_reg(gspca_dev, 0xd145, 0x0124);
2208 	cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2209 	cit_model4_Packet1(gspca_dev, 0x0034, 0x0000);
2210 
2211 	switch (gspca_dev->pixfmt.width) {
2212 	case 128: /* 128x96 */
2213 		cit_write_reg(gspca_dev, 0x0070, 0x0119);
2214 		cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2215 		cit_write_reg(gspca_dev, 0x0039, 0x010a);
2216 		cit_write_reg(gspca_dev, 0x0001, 0x0102);
2217 		cit_write_reg(gspca_dev, 0x0028, 0x0103);
2218 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
2219 		cit_write_reg(gspca_dev, 0x001e, 0x0105);
2220 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2221 		cit_write_reg(gspca_dev, 0x0016, 0x012f);
2222 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2223 		cit_write_reg(gspca_dev, 0x000a, 0x0127);
2224 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2225 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2226 		cit_write_reg(gspca_dev, 0x0014, 0x012d);
2227 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2228 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2229 		cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2230 		cit_write_reg(gspca_dev, 0x001a, 0x0130);
2231 		cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2232 		cit_write_reg(gspca_dev, 0x005a, 0x012d);
2233 		cit_write_reg(gspca_dev, 0x9545, 0x0124);
2234 		cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2235 		cit_write_reg(gspca_dev, 0x0018, 0x012e);
2236 		cit_write_reg(gspca_dev, 0x0043, 0x0130);
2237 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2238 		cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2239 		cit_write_reg(gspca_dev, 0xd055, 0x0124);
2240 		cit_write_reg(gspca_dev, 0x001c, 0x0127);
2241 		cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2242 		cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2243 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2244 		cit_write_reg(gspca_dev, 0x0032, 0x012f);
2245 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2246 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2247 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2248 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2249 		cit_write_reg(gspca_dev, 0x0036, 0x012d);
2250 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2251 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2252 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2253 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2254 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
2255 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2256 		cit_write_reg(gspca_dev, 0x0017, 0x0127);
2257 		cit_write_reg(gspca_dev, 0x0013, 0x012e);
2258 		cit_write_reg(gspca_dev, 0x0031, 0x0130);
2259 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2260 		cit_write_reg(gspca_dev, 0x0017, 0x012d);
2261 		cit_write_reg(gspca_dev, 0x0078, 0x012f);
2262 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2263 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2264 		cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2265 		sd->sof_len = 2;
2266 		break;
2267 	case 160: /* 160x120 */
2268 		cit_write_reg(gspca_dev, 0x0038, 0x0119);
2269 		cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2270 		cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2271 		cit_write_reg(gspca_dev, 0x0001, 0x0102);
2272 		cit_write_reg(gspca_dev, 0x0028, 0x0103);
2273 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
2274 		cit_write_reg(gspca_dev, 0x001e, 0x0105);
2275 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2276 		cit_write_reg(gspca_dev, 0x0016, 0x012f);
2277 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2278 		cit_write_reg(gspca_dev, 0x000b, 0x0127);
2279 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2280 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2281 		cit_write_reg(gspca_dev, 0x0014, 0x012d);
2282 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2283 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2284 		cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2285 		cit_write_reg(gspca_dev, 0x001a, 0x0130);
2286 		cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2287 		cit_write_reg(gspca_dev, 0x005a, 0x012d);
2288 		cit_write_reg(gspca_dev, 0x9545, 0x0124);
2289 		cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2290 		cit_write_reg(gspca_dev, 0x0018, 0x012e);
2291 		cit_write_reg(gspca_dev, 0x0043, 0x0130);
2292 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2293 		cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2294 		cit_write_reg(gspca_dev, 0xd055, 0x0124);
2295 		cit_write_reg(gspca_dev, 0x001c, 0x0127);
2296 		cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2297 		cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2298 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2299 		cit_write_reg(gspca_dev, 0x0032, 0x012f);
2300 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2301 		cit_write_reg(gspca_dev, 0x0025, 0x0127);
2302 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2303 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2304 		cit_write_reg(gspca_dev, 0x0036, 0x012d);
2305 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2306 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2307 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2308 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2309 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
2310 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2311 		cit_write_reg(gspca_dev, 0x0048, 0x0127);
2312 		cit_write_reg(gspca_dev, 0x0035, 0x012e);
2313 		cit_write_reg(gspca_dev, 0x00d0, 0x0130);
2314 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2315 		cit_write_reg(gspca_dev, 0x0048, 0x012d);
2316 		cit_write_reg(gspca_dev, 0x0090, 0x012f);
2317 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2318 		cit_write_reg(gspca_dev, 0x0001, 0x0127);
2319 		cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2320 		sd->sof_len = 2;
2321 		break;
2322 	case 176: /* 176x144 */
2323 		cit_write_reg(gspca_dev, 0x0038, 0x0119);
2324 		cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2325 		cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2326 		cit_write_reg(gspca_dev, 0x0001, 0x0102);
2327 		cit_write_reg(gspca_dev, 0x002c, 0x0103);
2328 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
2329 		cit_write_reg(gspca_dev, 0x0024, 0x0105);
2330 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2331 		cit_write_reg(gspca_dev, 0x0016, 0x012f);
2332 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2333 		cit_write_reg(gspca_dev, 0x0007, 0x0127);
2334 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2335 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2336 		cit_write_reg(gspca_dev, 0x0014, 0x012d);
2337 		cit_write_reg(gspca_dev, 0x0001, 0x012f);
2338 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2339 		cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2340 		cit_write_reg(gspca_dev, 0x001a, 0x0130);
2341 		cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2342 		cit_write_reg(gspca_dev, 0x005e, 0x012d);
2343 		cit_write_reg(gspca_dev, 0x9545, 0x0124);
2344 		cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2345 		cit_write_reg(gspca_dev, 0x0018, 0x012e);
2346 		cit_write_reg(gspca_dev, 0x0049, 0x0130);
2347 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2348 		cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2349 		cit_write_reg(gspca_dev, 0xd055, 0x0124);
2350 		cit_write_reg(gspca_dev, 0x001c, 0x0127);
2351 		cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2352 		cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2353 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2354 		cit_write_reg(gspca_dev, 0x0032, 0x012f);
2355 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2356 		cit_write_reg(gspca_dev, 0x0028, 0x0127);
2357 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2358 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2359 		cit_write_reg(gspca_dev, 0x0036, 0x012d);
2360 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2361 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2362 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2363 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2364 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
2365 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2366 		cit_write_reg(gspca_dev, 0x0010, 0x0127);
2367 		cit_write_reg(gspca_dev, 0x0013, 0x012e);
2368 		cit_write_reg(gspca_dev, 0x002a, 0x0130);
2369 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2370 		cit_write_reg(gspca_dev, 0x0010, 0x012d);
2371 		cit_write_reg(gspca_dev, 0x006d, 0x012f);
2372 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2373 		cit_write_reg(gspca_dev, 0x0001, 0x0127);
2374 		cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2375 		/* TESTME HDG: this does not seem right
2376 		   (it is 2 for all other resolutions) */
2377 		sd->sof_len = 10;
2378 		break;
2379 	case 320: /* 320x240 */
2380 		cit_write_reg(gspca_dev, 0x0070, 0x0119);
2381 		cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2382 		cit_write_reg(gspca_dev, 0x0039, 0x010a);
2383 		cit_write_reg(gspca_dev, 0x0001, 0x0102);
2384 		cit_write_reg(gspca_dev, 0x0028, 0x0103);
2385 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
2386 		cit_write_reg(gspca_dev, 0x001e, 0x0105);
2387 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2388 		cit_write_reg(gspca_dev, 0x0016, 0x012f);
2389 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2390 		cit_write_reg(gspca_dev, 0x000a, 0x0127);
2391 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2392 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2393 		cit_write_reg(gspca_dev, 0x0014, 0x012d);
2394 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2395 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2396 		cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2397 		cit_write_reg(gspca_dev, 0x001a, 0x0130);
2398 		cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2399 		cit_write_reg(gspca_dev, 0x005a, 0x012d);
2400 		cit_write_reg(gspca_dev, 0x9545, 0x0124);
2401 		cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2402 		cit_write_reg(gspca_dev, 0x0018, 0x012e);
2403 		cit_write_reg(gspca_dev, 0x0043, 0x0130);
2404 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2405 		cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2406 		cit_write_reg(gspca_dev, 0xd055, 0x0124);
2407 		cit_write_reg(gspca_dev, 0x001c, 0x0127);
2408 		cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2409 		cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2410 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2411 		cit_write_reg(gspca_dev, 0x0032, 0x012f);
2412 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2413 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2414 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2415 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2416 		cit_write_reg(gspca_dev, 0x0036, 0x012d);
2417 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2418 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2419 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2420 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2421 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
2422 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2423 		cit_write_reg(gspca_dev, 0x0017, 0x0127);
2424 		cit_write_reg(gspca_dev, 0x0013, 0x012e);
2425 		cit_write_reg(gspca_dev, 0x0031, 0x0130);
2426 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2427 		cit_write_reg(gspca_dev, 0x0017, 0x012d);
2428 		cit_write_reg(gspca_dev, 0x0078, 0x012f);
2429 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2430 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2431 		cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2432 		sd->sof_len = 2;
2433 		break;
2434 	case 352: /* 352x288 */
2435 		cit_write_reg(gspca_dev, 0x0070, 0x0119);
2436 		cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2437 		cit_write_reg(gspca_dev, 0x0039, 0x010a);
2438 		cit_write_reg(gspca_dev, 0x0001, 0x0102);
2439 		cit_write_reg(gspca_dev, 0x002c, 0x0103);
2440 		cit_write_reg(gspca_dev, 0x0000, 0x0104);
2441 		cit_write_reg(gspca_dev, 0x0024, 0x0105);
2442 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2443 		cit_write_reg(gspca_dev, 0x0016, 0x012f);
2444 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2445 		cit_write_reg(gspca_dev, 0x0006, 0x0127);
2446 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2447 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2448 		cit_write_reg(gspca_dev, 0x0014, 0x012d);
2449 		cit_write_reg(gspca_dev, 0x0002, 0x012f);
2450 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2451 		cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2452 		cit_write_reg(gspca_dev, 0x001a, 0x0130);
2453 		cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2454 		cit_write_reg(gspca_dev, 0x005e, 0x012d);
2455 		cit_write_reg(gspca_dev, 0x9545, 0x0124);
2456 		cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2457 		cit_write_reg(gspca_dev, 0x0018, 0x012e);
2458 		cit_write_reg(gspca_dev, 0x0049, 0x0130);
2459 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2460 		cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2461 		cit_write_reg(gspca_dev, 0xd055, 0x0124);
2462 		cit_write_reg(gspca_dev, 0x001c, 0x0127);
2463 		cit_write_reg(gspca_dev, 0x00cf, 0x012e);
2464 		cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2465 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2466 		cit_write_reg(gspca_dev, 0x0032, 0x012f);
2467 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2468 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2469 		cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2470 		cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2471 		cit_write_reg(gspca_dev, 0x0036, 0x012d);
2472 		cit_write_reg(gspca_dev, 0x0008, 0x012f);
2473 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2474 		cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2475 		cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2476 		cit_write_reg(gspca_dev, 0x001e, 0x012f);
2477 		cit_write_reg(gspca_dev, 0xd141, 0x0124);
2478 		cit_write_reg(gspca_dev, 0x0010, 0x0127);
2479 		cit_write_reg(gspca_dev, 0x0013, 0x012e);
2480 		cit_write_reg(gspca_dev, 0x0025, 0x0130);
2481 		cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2482 		cit_write_reg(gspca_dev, 0x0010, 0x012d);
2483 		cit_write_reg(gspca_dev, 0x0048, 0x012f);
2484 		cit_write_reg(gspca_dev, 0xd145, 0x0124);
2485 		cit_write_reg(gspca_dev, 0x0000, 0x0127);
2486 		cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2487 		sd->sof_len = 2;
2488 		break;
2489 	}
2490 
2491 	cit_model4_Packet1(gspca_dev, 0x0038, 0x0004);
2492 
2493 	return 0;
2494 }
2495 
2496 static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev)
2497 {
2498 	const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2499 	int i, clock_div;
2500 
2501 	clock_div = cit_get_clock_div(gspca_dev);
2502 	if (clock_div < 0)
2503 		return clock_div;
2504 
2505 	cit_write_reg(gspca_dev, 0x0003, 0x0133);
2506 	cit_write_reg(gspca_dev, 0x0000, 0x0117);
2507 	cit_write_reg(gspca_dev, 0x0008, 0x0123);
2508 	cit_write_reg(gspca_dev, 0x0000, 0x0100);
2509 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
2510 	/* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */
2511 	cit_write_reg(gspca_dev, 0x0000, 0x0133);
2512 	cit_write_reg(gspca_dev, 0x0000, 0x0123);
2513 	cit_write_reg(gspca_dev, 0x0001, 0x0117);
2514 	cit_write_reg(gspca_dev, 0x0040, 0x0108);
2515 	cit_write_reg(gspca_dev, 0x0019, 0x012c);
2516 	cit_write_reg(gspca_dev, 0x0060, 0x0116);
2517 	/* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */
2518 
2519 	cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
2520 
2521 	cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2522 	cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */
2523 	cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2524 	cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2525 	cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2526 	cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2527 	cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2528 	cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2529 	cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2530 
2531 	switch (gspca_dev->pixfmt.width) {
2532 	case 160: /* 160x120 */
2533 		cit_write_reg(gspca_dev, 0x0024, 0x010b);
2534 		cit_write_reg(gspca_dev, 0x0089, 0x0119);
2535 		cit_write_reg(gspca_dev, 0x000a, 0x011b);
2536 		cit_write_reg(gspca_dev, 0x0003, 0x011e);
2537 		cit_write_reg(gspca_dev, 0x0007, 0x0104);
2538 		cit_write_reg(gspca_dev, 0x0009, 0x011a);
2539 		cit_write_reg(gspca_dev, 0x008b, 0x011c);
2540 		cit_write_reg(gspca_dev, 0x0008, 0x0118);
2541 		cit_write_reg(gspca_dev, 0x0000, 0x0132);
2542 		break;
2543 	case 320: /* 320x240 */
2544 		cit_write_reg(gspca_dev, 0x0028, 0x010b);
2545 		cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2546 		cit_write_reg(gspca_dev, 0x0006, 0x011b);
2547 		cit_write_reg(gspca_dev, 0x0000, 0x011e);
2548 		cit_write_reg(gspca_dev, 0x000e, 0x0104);
2549 		cit_write_reg(gspca_dev, 0x0004, 0x011a);
2550 		cit_write_reg(gspca_dev, 0x003f, 0x011c);
2551 		cit_write_reg(gspca_dev, 0x000c, 0x0118);
2552 		cit_write_reg(gspca_dev, 0x0000, 0x0132);
2553 		break;
2554 	}
2555 
2556 	cit_model3_Packet1(gspca_dev, 0x0019, 0x0031);
2557 	cit_model3_Packet1(gspca_dev, 0x001a, 0x0003);
2558 	cit_model3_Packet1(gspca_dev, 0x001b, 0x0038);
2559 	cit_model3_Packet1(gspca_dev, 0x001c, 0x0000);
2560 	cit_model3_Packet1(gspca_dev, 0x0024, 0x0001);
2561 	cit_model3_Packet1(gspca_dev, 0x0027, 0x0001);
2562 	cit_model3_Packet1(gspca_dev, 0x002a, 0x0004);
2563 	cit_model3_Packet1(gspca_dev, 0x0035, 0x000b);
2564 	cit_model3_Packet1(gspca_dev, 0x003f, 0x0001);
2565 	cit_model3_Packet1(gspca_dev, 0x0044, 0x0000);
2566 	cit_model3_Packet1(gspca_dev, 0x0054, 0x0000);
2567 	cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000);
2568 	cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001);
2569 	cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001);
2570 	cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000);
2571 	cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0);
2572 
2573 	cit_write_reg(gspca_dev, compression, 0x0109);
2574 	cit_write_reg(gspca_dev, clock_div, 0x0111);
2575 
2576 /*	if (sd->input_index) { */
2577 	if (rca_input) {
2578 		for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2579 			if (rca_initdata[i][0])
2580 				cit_read_reg(gspca_dev, rca_initdata[i][2], 0);
2581 			else
2582 				cit_write_reg(gspca_dev, rca_initdata[i][1],
2583 					      rca_initdata[i][2]);
2584 		}
2585 	}
2586 
2587 	return 0;
2588 }
2589 
2590 /* -- start the camera -- */
2591 static int sd_start(struct gspca_dev *gspca_dev)
2592 {
2593 	struct sd *sd = (struct sd *) gspca_dev;
2594 	int packet_size;
2595 
2596 	packet_size = cit_get_packet_size(gspca_dev);
2597 	if (packet_size < 0)
2598 		return packet_size;
2599 
2600 	switch (sd->model) {
2601 	case CIT_MODEL0:
2602 		cit_start_model0(gspca_dev);
2603 		break;
2604 	case CIT_MODEL1:
2605 		cit_start_model1(gspca_dev);
2606 		break;
2607 	case CIT_MODEL2:
2608 		cit_start_model2(gspca_dev);
2609 		break;
2610 	case CIT_MODEL3:
2611 		cit_start_model3(gspca_dev);
2612 		break;
2613 	case CIT_MODEL4:
2614 		cit_start_model4(gspca_dev);
2615 		break;
2616 	case CIT_IBM_NETCAM_PRO:
2617 		cit_start_ibm_netcam_pro(gspca_dev);
2618 		break;
2619 	}
2620 
2621 	/* Program max isoc packet size */
2622 	cit_write_reg(gspca_dev, packet_size >> 8, 0x0106);
2623 	cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107);
2624 
2625 	cit_restart_stream(gspca_dev);
2626 
2627 	return 0;
2628 }
2629 
2630 static int sd_isoc_init(struct gspca_dev *gspca_dev)
2631 {
2632 	struct usb_interface_cache *intfc;
2633 	struct usb_host_interface *alt;
2634 	int max_packet_size;
2635 
2636 	switch (gspca_dev->pixfmt.width) {
2637 	case 160:
2638 		max_packet_size = 450;
2639 		break;
2640 	case 176:
2641 		max_packet_size = 600;
2642 		break;
2643 	default:
2644 		max_packet_size = 1022;
2645 		break;
2646 	}
2647 
2648 	intfc = gspca_dev->dev->actconfig->intf_cache[0];
2649 
2650 	if (intfc->num_altsetting < 2)
2651 		return -ENODEV;
2652 
2653 	alt = &intfc->altsetting[1];
2654 
2655 	if (alt->desc.bNumEndpoints < 1)
2656 		return -ENODEV;
2657 
2658 	/* Start isoc bandwidth "negotiation" at max isoc bandwidth */
2659 	alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
2660 
2661 	return 0;
2662 }
2663 
2664 static int sd_isoc_nego(struct gspca_dev *gspca_dev)
2665 {
2666 	int ret, packet_size, min_packet_size;
2667 	struct usb_host_interface *alt;
2668 
2669 	switch (gspca_dev->pixfmt.width) {
2670 	case 160:
2671 		min_packet_size = 200;
2672 		break;
2673 	case 176:
2674 		min_packet_size = 266;
2675 		break;
2676 	default:
2677 		min_packet_size = 400;
2678 		break;
2679 	}
2680 
2681 	/*
2682 	 * Existence of altsetting and endpoint was verified in sd_isoc_init()
2683 	 */
2684 	alt = &gspca_dev->dev->actconfig->intf_cache[0]->altsetting[1];
2685 	packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
2686 	if (packet_size <= min_packet_size)
2687 		return -EIO;
2688 
2689 	packet_size -= 100;
2690 	if (packet_size < min_packet_size)
2691 		packet_size = min_packet_size;
2692 	alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
2693 
2694 	ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
2695 	if (ret < 0)
2696 		pr_err("set alt 1 err %d\n", ret);
2697 
2698 	return ret;
2699 }
2700 
2701 static void sd_stopN(struct gspca_dev *gspca_dev)
2702 {
2703 	cit_write_reg(gspca_dev, 0x0000, 0x010c);
2704 }
2705 
2706 static void sd_stop0(struct gspca_dev *gspca_dev)
2707 {
2708 	struct sd *sd = (struct sd *) gspca_dev;
2709 
2710 	if (!gspca_dev->present)
2711 		return;
2712 
2713 	switch (sd->model) {
2714 	case CIT_MODEL0:
2715 		/* HDG windows does this, but it causes the cams autogain to
2716 		   restart from a gain of 0, which does not look good when
2717 		   changing resolutions. */
2718 		/* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2719 		cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */
2720 		break;
2721 	case CIT_MODEL1:
2722 		cit_send_FF_04_02(gspca_dev);
2723 		cit_read_reg(gspca_dev, 0x0100, 0);
2724 		cit_write_reg(gspca_dev, 0x81, 0x0100);	/* LED Off */
2725 		break;
2726 	case CIT_MODEL2:
2727 		v4l2_ctrl_grab(sd->lighting, false);
2728 		/* Fall through! */
2729 	case CIT_MODEL4:
2730 		cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2731 
2732 		cit_write_reg(gspca_dev, 0x0080, 0x0100);	/* LED Off */
2733 		cit_write_reg(gspca_dev, 0x0020, 0x0111);
2734 		cit_write_reg(gspca_dev, 0x00a0, 0x0111);
2735 
2736 		cit_model2_Packet1(gspca_dev, 0x0030, 0x0002);
2737 
2738 		cit_write_reg(gspca_dev, 0x0020, 0x0111);
2739 		cit_write_reg(gspca_dev, 0x0000, 0x0112);
2740 		break;
2741 	case CIT_MODEL3:
2742 		cit_write_reg(gspca_dev, 0x0006, 0x012c);
2743 		cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
2744 		cit_read_reg(gspca_dev, 0x0116, 0);
2745 		cit_write_reg(gspca_dev, 0x0064, 0x0116);
2746 		cit_read_reg(gspca_dev, 0x0115, 0);
2747 		cit_write_reg(gspca_dev, 0x0003, 0x0115);
2748 		cit_write_reg(gspca_dev, 0x0008, 0x0123);
2749 		cit_write_reg(gspca_dev, 0x0000, 0x0117);
2750 		cit_write_reg(gspca_dev, 0x0000, 0x0112);
2751 		cit_write_reg(gspca_dev, 0x0080, 0x0100);
2752 		break;
2753 	case CIT_IBM_NETCAM_PRO:
2754 		cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff);
2755 		cit_write_reg(gspca_dev, 0x0006, 0x012c);
2756 		cit_write_reg(gspca_dev, 0x0000, 0x0116);
2757 		/* HDG windows does this, but I cannot get the camera
2758 		   to restart with this without redoing the entire init
2759 		   sequence which makes switching modes really slow */
2760 		/* cit_write_reg(gspca_dev, 0x0006, 0x0115); */
2761 		cit_write_reg(gspca_dev, 0x0008, 0x0123);
2762 		cit_write_reg(gspca_dev, 0x0000, 0x0117);
2763 		cit_write_reg(gspca_dev, 0x0003, 0x0133);
2764 		cit_write_reg(gspca_dev, 0x0000, 0x0111);
2765 		/* HDG windows does this, but I get a green picture when
2766 		   restarting the stream after this */
2767 		/* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2768 		cit_write_reg(gspca_dev, 0x00c0, 0x0100);
2769 		break;
2770 	}
2771 
2772 #if IS_ENABLED(CONFIG_INPUT)
2773 	/* If the last button state is pressed, release it now! */
2774 	if (sd->button_state) {
2775 		input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
2776 		input_sync(gspca_dev->input_dev);
2777 		sd->button_state = 0;
2778 	}
2779 #endif
2780 }
2781 
2782 static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
2783 {
2784 	struct sd *sd = (struct sd *) gspca_dev;
2785 	u8 byte3 = 0, byte4 = 0;
2786 	int i;
2787 
2788 	switch (sd->model) {
2789 	case CIT_MODEL0:
2790 	case CIT_MODEL1:
2791 	case CIT_MODEL3:
2792 	case CIT_IBM_NETCAM_PRO:
2793 		switch (gspca_dev->pixfmt.width) {
2794 		case 160: /* 160x120 */
2795 			byte3 = 0x02;
2796 			byte4 = 0x0a;
2797 			break;
2798 		case 176: /* 176x144 */
2799 			byte3 = 0x02;
2800 			byte4 = 0x0e;
2801 			break;
2802 		case 320: /* 320x240 */
2803 			byte3 = 0x02;
2804 			byte4 = 0x08;
2805 			break;
2806 		case 352: /* 352x288 */
2807 			byte3 = 0x02;
2808 			byte4 = 0x00;
2809 			break;
2810 		case 640:
2811 			byte3 = 0x03;
2812 			byte4 = 0x08;
2813 			break;
2814 		}
2815 
2816 		/* These have a different byte3 */
2817 		if (sd->model <= CIT_MODEL1)
2818 			byte3 = 0x00;
2819 
2820 		for (i = 0; i < len; i++) {
2821 			/* For this model the SOF always starts at offset 0
2822 			   so no need to search the entire frame */
2823 			if (sd->model == CIT_MODEL0 && sd->sof_read != i)
2824 				break;
2825 
2826 			switch (sd->sof_read) {
2827 			case 0:
2828 				if (data[i] == 0x00)
2829 					sd->sof_read++;
2830 				break;
2831 			case 1:
2832 				if (data[i] == 0xff)
2833 					sd->sof_read++;
2834 				else if (data[i] == 0x00)
2835 					sd->sof_read = 1;
2836 				else
2837 					sd->sof_read = 0;
2838 				break;
2839 			case 2:
2840 				if (data[i] == byte3)
2841 					sd->sof_read++;
2842 				else if (data[i] == 0x00)
2843 					sd->sof_read = 1;
2844 				else
2845 					sd->sof_read = 0;
2846 				break;
2847 			case 3:
2848 				if (data[i] == byte4) {
2849 					sd->sof_read = 0;
2850 					return data + i + (sd->sof_len - 3);
2851 				}
2852 				if (byte3 == 0x00 && data[i] == 0xff)
2853 					sd->sof_read = 2;
2854 				else if (data[i] == 0x00)
2855 					sd->sof_read = 1;
2856 				else
2857 					sd->sof_read = 0;
2858 				break;
2859 			}
2860 		}
2861 		break;
2862 	case CIT_MODEL2:
2863 	case CIT_MODEL4:
2864 		/* TESTME we need to find a longer sof signature to avoid
2865 		   false positives */
2866 		for (i = 0; i < len; i++) {
2867 			switch (sd->sof_read) {
2868 			case 0:
2869 				if (data[i] == 0x00)
2870 					sd->sof_read++;
2871 				break;
2872 			case 1:
2873 				sd->sof_read = 0;
2874 				if (data[i] == 0xff) {
2875 					if (i >= 4)
2876 						gspca_dbg(gspca_dev, D_FRAM,
2877 							  "header found at offset: %d: %02x %02x 00 %3ph\n\n",
2878 							  i - 1,
2879 							  data[i - 4],
2880 							  data[i - 3],
2881 							  &data[i]);
2882 					else
2883 						gspca_dbg(gspca_dev, D_FRAM,
2884 							  "header found at offset: %d: 00 %3ph\n\n",
2885 							  i - 1,
2886 							  &data[i]);
2887 					return data + i + (sd->sof_len - 1);
2888 				}
2889 				break;
2890 			}
2891 		}
2892 		break;
2893 	}
2894 	return NULL;
2895 }
2896 
2897 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2898 			u8 *data, int len)
2899 {
2900 	struct sd *sd = (struct sd *) gspca_dev;
2901 	unsigned char *sof;
2902 
2903 	sof = cit_find_sof(gspca_dev, data, len);
2904 	if (sof) {
2905 		int n;
2906 
2907 		/* finish decoding current frame */
2908 		n = sof - data;
2909 		if (n > sd->sof_len)
2910 			n -= sd->sof_len;
2911 		else
2912 			n = 0;
2913 		gspca_frame_add(gspca_dev, LAST_PACKET,
2914 				data, n);
2915 		gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
2916 		len -= sof - data;
2917 		data = sof;
2918 	}
2919 
2920 	gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
2921 }
2922 
2923 #if IS_ENABLED(CONFIG_INPUT)
2924 static void cit_check_button(struct gspca_dev *gspca_dev)
2925 {
2926 	int new_button_state;
2927 	struct sd *sd = (struct sd *)gspca_dev;
2928 
2929 	switch (sd->model) {
2930 	case CIT_MODEL3:
2931 	case CIT_IBM_NETCAM_PRO:
2932 		break;
2933 	default: /* TEST ME unknown if this works on other models too */
2934 		return;
2935 	}
2936 
2937 	/* Read the button state */
2938 	cit_read_reg(gspca_dev, 0x0113, 0);
2939 	new_button_state = !gspca_dev->usb_buf[0];
2940 
2941 	/* Tell the cam we've seen the button press, notice that this
2942 	   is a nop (iow the cam keeps reporting pressed) until the
2943 	   button is actually released. */
2944 	if (new_button_state)
2945 		cit_write_reg(gspca_dev, 0x01, 0x0113);
2946 
2947 	if (sd->button_state != new_button_state) {
2948 		input_report_key(gspca_dev->input_dev, KEY_CAMERA,
2949 				 new_button_state);
2950 		input_sync(gspca_dev->input_dev);
2951 		sd->button_state = new_button_state;
2952 	}
2953 }
2954 #endif
2955 
2956 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
2957 {
2958 	struct gspca_dev *gspca_dev =
2959 		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
2960 	struct sd *sd = (struct sd *)gspca_dev;
2961 
2962 	gspca_dev->usb_err = 0;
2963 
2964 	if (!gspca_dev->streaming)
2965 		return 0;
2966 
2967 	if (sd->stop_on_control_change)
2968 		sd_stopN(gspca_dev);
2969 	switch (ctrl->id) {
2970 	case V4L2_CID_BRIGHTNESS:
2971 		cit_set_brightness(gspca_dev, ctrl->val);
2972 		break;
2973 	case V4L2_CID_CONTRAST:
2974 		cit_set_contrast(gspca_dev, ctrl->val);
2975 		break;
2976 	case V4L2_CID_HUE:
2977 		cit_set_hue(gspca_dev, ctrl->val);
2978 		break;
2979 	case V4L2_CID_HFLIP:
2980 		cit_set_hflip(gspca_dev, ctrl->val);
2981 		break;
2982 	case V4L2_CID_SHARPNESS:
2983 		cit_set_sharpness(gspca_dev, ctrl->val);
2984 		break;
2985 	case V4L2_CID_BACKLIGHT_COMPENSATION:
2986 		cit_set_lighting(gspca_dev, ctrl->val);
2987 		break;
2988 	}
2989 	if (sd->stop_on_control_change)
2990 		cit_restart_stream(gspca_dev);
2991 	return gspca_dev->usb_err;
2992 }
2993 
2994 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
2995 	.s_ctrl = sd_s_ctrl,
2996 };
2997 
2998 static int sd_init_controls(struct gspca_dev *gspca_dev)
2999 {
3000 	struct sd *sd = (struct sd *)gspca_dev;
3001 	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
3002 	bool has_brightness;
3003 	bool has_contrast;
3004 	bool has_hue;
3005 	bool has_sharpness;
3006 	bool has_lighting;
3007 	bool has_hflip;
3008 
3009 	has_brightness = has_contrast = has_hue =
3010 		has_sharpness = has_hflip = has_lighting = false;
3011 	switch (sd->model) {
3012 	case CIT_MODEL0:
3013 		has_contrast = has_hflip = true;
3014 		break;
3015 	case CIT_MODEL1:
3016 		has_brightness = has_contrast =
3017 			has_sharpness = has_lighting = true;
3018 		break;
3019 	case CIT_MODEL2:
3020 		has_brightness = has_hue = has_lighting = true;
3021 		break;
3022 	case CIT_MODEL3:
3023 		has_brightness = has_contrast = has_sharpness = true;
3024 		break;
3025 	case CIT_MODEL4:
3026 		has_brightness = has_hue = true;
3027 		break;
3028 	case CIT_IBM_NETCAM_PRO:
3029 		has_brightness = has_hue =
3030 			has_sharpness = has_hflip = has_lighting = true;
3031 		break;
3032 	}
3033 	gspca_dev->vdev.ctrl_handler = hdl;
3034 	v4l2_ctrl_handler_init(hdl, 5);
3035 	if (has_brightness)
3036 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3037 			V4L2_CID_BRIGHTNESS, 0, 63, 1, 32);
3038 	if (has_contrast)
3039 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3040 			V4L2_CID_CONTRAST, 0, 20, 1, 10);
3041 	if (has_hue)
3042 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3043 			V4L2_CID_HUE, 0, 127, 1, 63);
3044 	if (has_sharpness)
3045 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3046 			V4L2_CID_SHARPNESS, 0, 6, 1, 3);
3047 	if (has_lighting)
3048 		sd->lighting = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3049 			V4L2_CID_BACKLIGHT_COMPENSATION, 0, 2, 1, 1);
3050 	if (has_hflip)
3051 		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
3052 			V4L2_CID_HFLIP, 0, 1, 1, 0);
3053 
3054 	if (hdl->error) {
3055 		pr_err("Could not initialize controls\n");
3056 		return hdl->error;
3057 	}
3058 	return 0;
3059 }
3060 
3061 /* sub-driver description */
3062 static const struct sd_desc sd_desc = {
3063 	.name = MODULE_NAME,
3064 	.config = sd_config,
3065 	.init = sd_init,
3066 	.init_controls = sd_init_controls,
3067 	.start = sd_start,
3068 	.stopN = sd_stopN,
3069 	.stop0 = sd_stop0,
3070 	.pkt_scan = sd_pkt_scan,
3071 #if IS_ENABLED(CONFIG_INPUT)
3072 	.dq_callback = cit_check_button,
3073 	.other_input = 1,
3074 #endif
3075 };
3076 
3077 static const struct sd_desc sd_desc_isoc_nego = {
3078 	.name = MODULE_NAME,
3079 	.config = sd_config,
3080 	.init = sd_init,
3081 	.init_controls = sd_init_controls,
3082 	.start = sd_start,
3083 	.isoc_init = sd_isoc_init,
3084 	.isoc_nego = sd_isoc_nego,
3085 	.stopN = sd_stopN,
3086 	.stop0 = sd_stop0,
3087 	.pkt_scan = sd_pkt_scan,
3088 #if IS_ENABLED(CONFIG_INPUT)
3089 	.dq_callback = cit_check_button,
3090 	.other_input = 1,
3091 #endif
3092 };
3093 
3094 /* -- module initialisation -- */
3095 static const struct usb_device_id device_table[] = {
3096 	{ USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 },
3097 	{ USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 },
3098 	{ USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3099 	{ USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 },
3100 	{ USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3101 	{ USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3102 	{ USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3103 	{}
3104 };
3105 MODULE_DEVICE_TABLE(usb, device_table);
3106 
3107 /* -- device connect -- */
3108 static int sd_probe(struct usb_interface *intf,
3109 			const struct usb_device_id *id)
3110 {
3111 	const struct sd_desc *desc = &sd_desc;
3112 
3113 	switch (id->driver_info) {
3114 	case CIT_MODEL0:
3115 	case CIT_MODEL1:
3116 		if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
3117 			return -ENODEV;
3118 		break;
3119 	case CIT_MODEL2:
3120 	case CIT_MODEL4:
3121 		if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3122 			return -ENODEV;
3123 		break;
3124 	case CIT_MODEL3:
3125 		if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3126 			return -ENODEV;
3127 		/* FIXME this likely applies to all model3 cams and probably
3128 		   to other models too. */
3129 		if (ibm_netcam_pro)
3130 			desc = &sd_desc_isoc_nego;
3131 		break;
3132 	}
3133 
3134 	return gspca_dev_probe2(intf, id, desc, sizeof(struct sd), THIS_MODULE);
3135 }
3136 
3137 static struct usb_driver sd_driver = {
3138 	.name = MODULE_NAME,
3139 	.id_table = device_table,
3140 	.probe = sd_probe,
3141 	.disconnect = gspca_disconnect,
3142 #ifdef CONFIG_PM
3143 	.suspend = gspca_suspend,
3144 	.resume = gspca_resume,
3145 	.reset_resume = gspca_resume,
3146 #endif
3147 };
3148 
3149 module_usb_driver(sd_driver);
3150