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