projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] gspca: Fix coding style issues
[deliverable/linux.git] / drivers / media / video / gspca / xirlink_cit.c
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 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 err("Failed to read a register (index 0x%04X, error %d)",
818 index, res);
819 return res;
820 }
821
822 PDEBUG(D_PROBE,
823 "Register %04x value: %02x %02x %02x %02x %02x %02x %02x %02x",
824 index,
825 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7]);
826
827 return 0;
828 }
829
830 /*
831 * cit_send_FF_04_02()
832 *
833 * This procedure sends magic 3-command prefix to the camera.
834 * The purpose of this prefix is not known.
835 *
836 * History:
837 * 1/2/00 Created.
838 */
839 static void cit_send_FF_04_02(struct gspca_dev *gspca_dev)
840 {
841 cit_write_reg(gspca_dev, 0x00FF, 0x0127);
842 cit_write_reg(gspca_dev, 0x0004, 0x0124);
843 cit_write_reg(gspca_dev, 0x0002, 0x0124);
844 }
845
846 static void cit_send_00_04_06(struct gspca_dev *gspca_dev)
847 {
848 cit_write_reg(gspca_dev, 0x0000, 0x0127);
849 cit_write_reg(gspca_dev, 0x0004, 0x0124);
850 cit_write_reg(gspca_dev, 0x0006, 0x0124);
851 }
852
853 static void cit_send_x_00(struct gspca_dev *gspca_dev, unsigned short x)
854 {
855 cit_write_reg(gspca_dev, x, 0x0127);
856 cit_write_reg(gspca_dev, 0x0000, 0x0124);
857 }
858
859 static void cit_send_x_00_05(struct gspca_dev *gspca_dev, unsigned short x)
860 {
861 cit_send_x_00(gspca_dev, x);
862 cit_write_reg(gspca_dev, 0x0005, 0x0124);
863 }
864
865 static void cit_send_x_00_05_02(struct gspca_dev *gspca_dev, unsigned short x)
866 {
867 cit_write_reg(gspca_dev, x, 0x0127);
868 cit_write_reg(gspca_dev, 0x0000, 0x0124);
869 cit_write_reg(gspca_dev, 0x0005, 0x0124);
870 cit_write_reg(gspca_dev, 0x0002, 0x0124);
871 }
872
873 static void cit_send_x_01_00_05(struct gspca_dev *gspca_dev, u16 x)
874 {
875 cit_write_reg(gspca_dev, x, 0x0127);
876 cit_write_reg(gspca_dev, 0x0001, 0x0124);
877 cit_write_reg(gspca_dev, 0x0000, 0x0124);
878 cit_write_reg(gspca_dev, 0x0005, 0x0124);
879 }
880
881 static void cit_send_x_00_05_02_01(struct gspca_dev *gspca_dev, u16 x)
882 {
883 cit_write_reg(gspca_dev, x, 0x0127);
884 cit_write_reg(gspca_dev, 0x0000, 0x0124);
885 cit_write_reg(gspca_dev, 0x0005, 0x0124);
886 cit_write_reg(gspca_dev, 0x0002, 0x0124);
887 cit_write_reg(gspca_dev, 0x0001, 0x0124);
888 }
889
890 static void cit_send_x_00_05_02_08_01(struct gspca_dev *gspca_dev, u16 x)
891 {
892 cit_write_reg(gspca_dev, x, 0x0127);
893 cit_write_reg(gspca_dev, 0x0000, 0x0124);
894 cit_write_reg(gspca_dev, 0x0005, 0x0124);
895 cit_write_reg(gspca_dev, 0x0002, 0x0124);
896 cit_write_reg(gspca_dev, 0x0008, 0x0124);
897 cit_write_reg(gspca_dev, 0x0001, 0x0124);
898 }
899
900 static void cit_Packet_Format1(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
901 {
902 cit_send_x_01_00_05(gspca_dev, 0x0088);
903 cit_send_x_00_05(gspca_dev, fkey);
904 cit_send_x_00_05_02_08_01(gspca_dev, val);
905 cit_send_x_00_05(gspca_dev, 0x0088);
906 cit_send_x_00_05_02_01(gspca_dev, fkey);
907 cit_send_x_00_05(gspca_dev, 0x0089);
908 cit_send_x_00(gspca_dev, fkey);
909 cit_send_00_04_06(gspca_dev);
910 cit_read_reg(gspca_dev, 0x0126);
911 cit_send_FF_04_02(gspca_dev);
912 }
913
914 static void cit_PacketFormat2(struct gspca_dev *gspca_dev, u16 fkey, u16 val)
915 {
916 cit_send_x_01_00_05(gspca_dev, 0x0088);
917 cit_send_x_00_05(gspca_dev, fkey);
918 cit_send_x_00_05_02(gspca_dev, val);
919 }
920
921 static void cit_model2_Packet2(struct gspca_dev *gspca_dev)
922 {
923 cit_write_reg(gspca_dev, 0x00ff, 0x012d);
924 cit_write_reg(gspca_dev, 0xfea3, 0x0124);
925 }
926
927 static void cit_model2_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
928 {
929 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
930 cit_write_reg(gspca_dev, 0x00ff, 0x012e);
931 cit_write_reg(gspca_dev, v1, 0x012f);
932 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
933 cit_write_reg(gspca_dev, 0xc719, 0x0124);
934 cit_write_reg(gspca_dev, v2, 0x0127);
935
936 cit_model2_Packet2(gspca_dev);
937 }
938
939 /*
940 * cit_model3_Packet1()
941 *
942 * 00_0078_012d
943 * 00_0097_012f
944 * 00_d141_0124
945 * 00_0096_0127
946 * 00_fea8_0124
947 */
948 static void cit_model3_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
949 {
950 cit_write_reg(gspca_dev, 0x0078, 0x012d);
951 cit_write_reg(gspca_dev, v1, 0x012f);
952 cit_write_reg(gspca_dev, 0xd141, 0x0124);
953 cit_write_reg(gspca_dev, v2, 0x0127);
954 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
955 }
956
957 static void cit_model4_Packet1(struct gspca_dev *gspca_dev, u16 v1, u16 v2)
958 {
959 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
960 cit_write_reg(gspca_dev, v1, 0x012f);
961 cit_write_reg(gspca_dev, 0xd141, 0x0124);
962 cit_write_reg(gspca_dev, v2, 0x0127);
963 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
964 }
965
966 static void cit_model4_BrightnessPacket(struct gspca_dev *gspca_dev, u16 val)
967 {
968 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
969 cit_write_reg(gspca_dev, 0x0026, 0x012f);
970 cit_write_reg(gspca_dev, 0xd141, 0x0124);
971 cit_write_reg(gspca_dev, val, 0x0127);
972 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
973 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
974 cit_write_reg(gspca_dev, 0x0038, 0x012d);
975 cit_write_reg(gspca_dev, 0x0004, 0x012f);
976 cit_write_reg(gspca_dev, 0xd145, 0x0124);
977 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
978 }
979
980 /* this function is called at probe time */
981 static int sd_config(struct gspca_dev *gspca_dev,
982 const struct usb_device_id *id)
983 {
984 struct sd *sd = (struct sd *) gspca_dev;
985 struct cam *cam;
986
987 sd->model = id->driver_info;
988 if (sd->model == CIT_MODEL3 && ibm_netcam_pro)
989 sd->model = CIT_IBM_NETCAM_PRO;
990
991 cam = &gspca_dev->cam;
992 switch (sd->model) {
993 case CIT_MODEL0:
994 cam->cam_mode = model0_mode;
995 cam->nmodes = ARRAY_SIZE(model0_mode);
996 cam->reverse_alts = 1;
997 gspca_dev->ctrl_dis = ~((1 << SD_CONTRAST) | (1 << SD_HFLIP));
998 sd->sof_len = 4;
999 break;
1000 case CIT_MODEL1:
1001 cam->cam_mode = cif_yuv_mode;
1002 cam->nmodes = ARRAY_SIZE(cif_yuv_mode);
1003 cam->reverse_alts = 1;
1004 gspca_dev->ctrl_dis = (1 << SD_HUE) | (1 << SD_HFLIP);
1005 sd->sof_len = 4;
1006 break;
1007 case CIT_MODEL2:
1008 cam->cam_mode = model2_mode + 1; /* no 160x120 */
1009 cam->nmodes = 3;
1010 gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
1011 (1 << SD_SHARPNESS) |
1012 (1 << SD_HFLIP);
1013 break;
1014 case CIT_MODEL3:
1015 cam->cam_mode = vga_yuv_mode;
1016 cam->nmodes = ARRAY_SIZE(vga_yuv_mode);
1017 gspca_dev->ctrl_dis = (1 << SD_HUE) |
1018 (1 << SD_LIGHTING) |
1019 (1 << SD_HFLIP);
1020 sd->stop_on_control_change = 1;
1021 sd->sof_len = 4;
1022 break;
1023 case CIT_MODEL4:
1024 cam->cam_mode = model2_mode;
1025 cam->nmodes = ARRAY_SIZE(model2_mode);
1026 gspca_dev->ctrl_dis = (1 << SD_CONTRAST) |
1027 (1 << SD_SHARPNESS) |
1028 (1 << SD_LIGHTING) |
1029 (1 << SD_HFLIP);
1030 break;
1031 case CIT_IBM_NETCAM_PRO:
1032 cam->cam_mode = vga_yuv_mode;
1033 cam->nmodes = 2; /* no 640 x 480 */
1034 cam->input_flags = V4L2_IN_ST_VFLIP;
1035 gspca_dev->ctrl_dis = ~(1 << SD_CONTRAST);
1036 sd->stop_on_control_change = 1;
1037 sd->sof_len = 4;
1038 break;
1039 }
1040
1041 sd->brightness = BRIGHTNESS_DEFAULT;
1042 sd->contrast = CONTRAST_DEFAULT;
1043 sd->hue = HUE_DEFAULT;
1044 sd->sharpness = SHARPNESS_DEFAULT;
1045 sd->lighting = LIGHTING_DEFAULT;
1046 sd->hflip = HFLIP_DEFAULT;
1047
1048 return 0;
1049 }
1050
1051 static int cit_init_model0(struct gspca_dev *gspca_dev)
1052 {
1053 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1054 cit_write_reg(gspca_dev, 0x0001, 0x0112); /* turn on autogain ? */
1055 cit_write_reg(gspca_dev, 0x0000, 0x0400);
1056 cit_write_reg(gspca_dev, 0x0001, 0x0400);
1057 cit_write_reg(gspca_dev, 0x0000, 0x0420);
1058 cit_write_reg(gspca_dev, 0x0001, 0x0420);
1059 cit_write_reg(gspca_dev, 0x000d, 0x0409);
1060 cit_write_reg(gspca_dev, 0x0002, 0x040a);
1061 cit_write_reg(gspca_dev, 0x0018, 0x0405);
1062 cit_write_reg(gspca_dev, 0x0008, 0x0435);
1063 cit_write_reg(gspca_dev, 0x0026, 0x040b);
1064 cit_write_reg(gspca_dev, 0x0007, 0x0437);
1065 cit_write_reg(gspca_dev, 0x0015, 0x042f);
1066 cit_write_reg(gspca_dev, 0x002b, 0x0439);
1067 cit_write_reg(gspca_dev, 0x0026, 0x043a);
1068 cit_write_reg(gspca_dev, 0x0008, 0x0438);
1069 cit_write_reg(gspca_dev, 0x001e, 0x042b);
1070 cit_write_reg(gspca_dev, 0x0041, 0x042c);
1071
1072 return 0;
1073 }
1074
1075 static int cit_init_ibm_netcam_pro(struct gspca_dev *gspca_dev)
1076 {
1077 cit_read_reg(gspca_dev, 0x128);
1078 cit_write_reg(gspca_dev, 0x0003, 0x0133);
1079 cit_write_reg(gspca_dev, 0x0000, 0x0117);
1080 cit_write_reg(gspca_dev, 0x0008, 0x0123);
1081 cit_write_reg(gspca_dev, 0x0000, 0x0100);
1082 cit_read_reg(gspca_dev, 0x0116);
1083 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1084 cit_write_reg(gspca_dev, 0x0002, 0x0112);
1085 cit_write_reg(gspca_dev, 0x0000, 0x0133);
1086 cit_write_reg(gspca_dev, 0x0000, 0x0123);
1087 cit_write_reg(gspca_dev, 0x0001, 0x0117);
1088 cit_write_reg(gspca_dev, 0x0040, 0x0108);
1089 cit_write_reg(gspca_dev, 0x0019, 0x012c);
1090 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1091 cit_write_reg(gspca_dev, 0x0002, 0x0115);
1092 cit_write_reg(gspca_dev, 0x000b, 0x0115);
1093
1094 cit_write_reg(gspca_dev, 0x0078, 0x012d);
1095 cit_write_reg(gspca_dev, 0x0001, 0x012f);
1096 cit_write_reg(gspca_dev, 0xd141, 0x0124);
1097 cit_write_reg(gspca_dev, 0x0079, 0x012d);
1098 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
1099 cit_write_reg(gspca_dev, 0xcd41, 0x0124);
1100 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
1101 cit_read_reg(gspca_dev, 0x0126);
1102
1103 cit_model3_Packet1(gspca_dev, 0x0000, 0x0000);
1104 cit_model3_Packet1(gspca_dev, 0x0000, 0x0001);
1105 cit_model3_Packet1(gspca_dev, 0x000b, 0x0000);
1106 cit_model3_Packet1(gspca_dev, 0x000c, 0x0008);
1107 cit_model3_Packet1(gspca_dev, 0x000d, 0x003a);
1108 cit_model3_Packet1(gspca_dev, 0x000e, 0x0060);
1109 cit_model3_Packet1(gspca_dev, 0x000f, 0x0060);
1110 cit_model3_Packet1(gspca_dev, 0x0010, 0x0008);
1111 cit_model3_Packet1(gspca_dev, 0x0011, 0x0004);
1112 cit_model3_Packet1(gspca_dev, 0x0012, 0x0028);
1113 cit_model3_Packet1(gspca_dev, 0x0013, 0x0002);
1114 cit_model3_Packet1(gspca_dev, 0x0014, 0x0000);
1115 cit_model3_Packet1(gspca_dev, 0x0015, 0x00fb);
1116 cit_model3_Packet1(gspca_dev, 0x0016, 0x0002);
1117 cit_model3_Packet1(gspca_dev, 0x0017, 0x0037);
1118 cit_model3_Packet1(gspca_dev, 0x0018, 0x0036);
1119 cit_model3_Packet1(gspca_dev, 0x001e, 0x0000);
1120 cit_model3_Packet1(gspca_dev, 0x001f, 0x0008);
1121 cit_model3_Packet1(gspca_dev, 0x0020, 0x00c1);
1122 cit_model3_Packet1(gspca_dev, 0x0021, 0x0034);
1123 cit_model3_Packet1(gspca_dev, 0x0022, 0x0034);
1124 cit_model3_Packet1(gspca_dev, 0x0025, 0x0002);
1125 cit_model3_Packet1(gspca_dev, 0x0028, 0x0022);
1126 cit_model3_Packet1(gspca_dev, 0x0029, 0x000a);
1127 cit_model3_Packet1(gspca_dev, 0x002b, 0x0000);
1128 cit_model3_Packet1(gspca_dev, 0x002c, 0x0000);
1129 cit_model3_Packet1(gspca_dev, 0x002d, 0x00ff);
1130 cit_model3_Packet1(gspca_dev, 0x002e, 0x00ff);
1131 cit_model3_Packet1(gspca_dev, 0x002f, 0x00ff);
1132 cit_model3_Packet1(gspca_dev, 0x0030, 0x00ff);
1133 cit_model3_Packet1(gspca_dev, 0x0031, 0x00ff);
1134 cit_model3_Packet1(gspca_dev, 0x0032, 0x0007);
1135 cit_model3_Packet1(gspca_dev, 0x0033, 0x0005);
1136 cit_model3_Packet1(gspca_dev, 0x0037, 0x0040);
1137 cit_model3_Packet1(gspca_dev, 0x0039, 0x0000);
1138 cit_model3_Packet1(gspca_dev, 0x003a, 0x0000);
1139 cit_model3_Packet1(gspca_dev, 0x003b, 0x0001);
1140 cit_model3_Packet1(gspca_dev, 0x003c, 0x0000);
1141 cit_model3_Packet1(gspca_dev, 0x0040, 0x000c);
1142 cit_model3_Packet1(gspca_dev, 0x0041, 0x00fb);
1143 cit_model3_Packet1(gspca_dev, 0x0042, 0x0002);
1144 cit_model3_Packet1(gspca_dev, 0x0043, 0x0000);
1145 cit_model3_Packet1(gspca_dev, 0x0045, 0x0000);
1146 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
1147 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
1148 cit_model3_Packet1(gspca_dev, 0x0048, 0x0000);
1149 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
1150 cit_model3_Packet1(gspca_dev, 0x004a, 0x00ff);
1151 cit_model3_Packet1(gspca_dev, 0x004b, 0x00ff);
1152 cit_model3_Packet1(gspca_dev, 0x004c, 0x00ff);
1153 cit_model3_Packet1(gspca_dev, 0x004f, 0x0000);
1154 cit_model3_Packet1(gspca_dev, 0x0050, 0x0000);
1155 cit_model3_Packet1(gspca_dev, 0x0051, 0x0002);
1156 cit_model3_Packet1(gspca_dev, 0x0055, 0x0000);
1157 cit_model3_Packet1(gspca_dev, 0x0056, 0x0000);
1158 cit_model3_Packet1(gspca_dev, 0x0057, 0x0000);
1159 cit_model3_Packet1(gspca_dev, 0x0058, 0x0002);
1160 cit_model3_Packet1(gspca_dev, 0x0059, 0x0000);
1161 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016);
1162 cit_model3_Packet1(gspca_dev, 0x005d, 0x0022);
1163 cit_model3_Packet1(gspca_dev, 0x005e, 0x003c);
1164 cit_model3_Packet1(gspca_dev, 0x005f, 0x0050);
1165 cit_model3_Packet1(gspca_dev, 0x0060, 0x0044);
1166 cit_model3_Packet1(gspca_dev, 0x0061, 0x0005);
1167 cit_model3_Packet1(gspca_dev, 0x006a, 0x007e);
1168 cit_model3_Packet1(gspca_dev, 0x006f, 0x0000);
1169 cit_model3_Packet1(gspca_dev, 0x0072, 0x001b);
1170 cit_model3_Packet1(gspca_dev, 0x0073, 0x0005);
1171 cit_model3_Packet1(gspca_dev, 0x0074, 0x000a);
1172 cit_model3_Packet1(gspca_dev, 0x0075, 0x001b);
1173 cit_model3_Packet1(gspca_dev, 0x0076, 0x002a);
1174 cit_model3_Packet1(gspca_dev, 0x0077, 0x003c);
1175 cit_model3_Packet1(gspca_dev, 0x0078, 0x0050);
1176 cit_model3_Packet1(gspca_dev, 0x007b, 0x0000);
1177 cit_model3_Packet1(gspca_dev, 0x007c, 0x0011);
1178 cit_model3_Packet1(gspca_dev, 0x007d, 0x0024);
1179 cit_model3_Packet1(gspca_dev, 0x007e, 0x0043);
1180 cit_model3_Packet1(gspca_dev, 0x007f, 0x005a);
1181 cit_model3_Packet1(gspca_dev, 0x0084, 0x0020);
1182 cit_model3_Packet1(gspca_dev, 0x0085, 0x0033);
1183 cit_model3_Packet1(gspca_dev, 0x0086, 0x000a);
1184 cit_model3_Packet1(gspca_dev, 0x0087, 0x0030);
1185 cit_model3_Packet1(gspca_dev, 0x0088, 0x0070);
1186 cit_model3_Packet1(gspca_dev, 0x008b, 0x0008);
1187 cit_model3_Packet1(gspca_dev, 0x008f, 0x0000);
1188 cit_model3_Packet1(gspca_dev, 0x0090, 0x0006);
1189 cit_model3_Packet1(gspca_dev, 0x0091, 0x0028);
1190 cit_model3_Packet1(gspca_dev, 0x0092, 0x005a);
1191 cit_model3_Packet1(gspca_dev, 0x0093, 0x0082);
1192 cit_model3_Packet1(gspca_dev, 0x0096, 0x0014);
1193 cit_model3_Packet1(gspca_dev, 0x0097, 0x0020);
1194 cit_model3_Packet1(gspca_dev, 0x0098, 0x0000);
1195 cit_model3_Packet1(gspca_dev, 0x00b0, 0x0046);
1196 cit_model3_Packet1(gspca_dev, 0x00b1, 0x0000);
1197 cit_model3_Packet1(gspca_dev, 0x00b2, 0x0000);
1198 cit_model3_Packet1(gspca_dev, 0x00b3, 0x0004);
1199 cit_model3_Packet1(gspca_dev, 0x00b4, 0x0007);
1200 cit_model3_Packet1(gspca_dev, 0x00b6, 0x0002);
1201 cit_model3_Packet1(gspca_dev, 0x00b7, 0x0004);
1202 cit_model3_Packet1(gspca_dev, 0x00bb, 0x0000);
1203 cit_model3_Packet1(gspca_dev, 0x00bc, 0x0001);
1204 cit_model3_Packet1(gspca_dev, 0x00bd, 0x0000);
1205 cit_model3_Packet1(gspca_dev, 0x00bf, 0x0000);
1206 cit_model3_Packet1(gspca_dev, 0x00c0, 0x00c8);
1207 cit_model3_Packet1(gspca_dev, 0x00c1, 0x0014);
1208 cit_model3_Packet1(gspca_dev, 0x00c2, 0x0001);
1209 cit_model3_Packet1(gspca_dev, 0x00c3, 0x0000);
1210 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0004);
1211 cit_model3_Packet1(gspca_dev, 0x00cb, 0x00bf);
1212 cit_model3_Packet1(gspca_dev, 0x00cc, 0x00bf);
1213 cit_model3_Packet1(gspca_dev, 0x00cd, 0x00bf);
1214 cit_model3_Packet1(gspca_dev, 0x00ce, 0x0000);
1215 cit_model3_Packet1(gspca_dev, 0x00cf, 0x0020);
1216 cit_model3_Packet1(gspca_dev, 0x00d0, 0x0040);
1217 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1218 cit_model3_Packet1(gspca_dev, 0x00d1, 0x00bf);
1219 cit_model3_Packet1(gspca_dev, 0x00d2, 0x00bf);
1220 cit_model3_Packet1(gspca_dev, 0x00d3, 0x00bf);
1221 cit_model3_Packet1(gspca_dev, 0x00ea, 0x0008);
1222 cit_model3_Packet1(gspca_dev, 0x00eb, 0x0000);
1223 cit_model3_Packet1(gspca_dev, 0x00ec, 0x00e8);
1224 cit_model3_Packet1(gspca_dev, 0x00ed, 0x0001);
1225 cit_model3_Packet1(gspca_dev, 0x00ef, 0x0022);
1226 cit_model3_Packet1(gspca_dev, 0x00f0, 0x0000);
1227 cit_model3_Packet1(gspca_dev, 0x00f2, 0x0028);
1228 cit_model3_Packet1(gspca_dev, 0x00f4, 0x0002);
1229 cit_model3_Packet1(gspca_dev, 0x00f5, 0x0000);
1230 cit_model3_Packet1(gspca_dev, 0x00fa, 0x0000);
1231 cit_model3_Packet1(gspca_dev, 0x00fb, 0x0001);
1232 cit_model3_Packet1(gspca_dev, 0x00fc, 0x0000);
1233 cit_model3_Packet1(gspca_dev, 0x00fd, 0x0000);
1234 cit_model3_Packet1(gspca_dev, 0x00fe, 0x0000);
1235 cit_model3_Packet1(gspca_dev, 0x00ff, 0x0000);
1236
1237 cit_model3_Packet1(gspca_dev, 0x00be, 0x0003);
1238 cit_model3_Packet1(gspca_dev, 0x00c8, 0x0000);
1239 cit_model3_Packet1(gspca_dev, 0x00c9, 0x0020);
1240 cit_model3_Packet1(gspca_dev, 0x00ca, 0x0040);
1241 cit_model3_Packet1(gspca_dev, 0x0053, 0x0001);
1242 cit_model3_Packet1(gspca_dev, 0x0082, 0x000e);
1243 cit_model3_Packet1(gspca_dev, 0x0083, 0x0020);
1244 cit_model3_Packet1(gspca_dev, 0x0034, 0x003c);
1245 cit_model3_Packet1(gspca_dev, 0x006e, 0x0055);
1246 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005);
1247 cit_model3_Packet1(gspca_dev, 0x0063, 0x0008);
1248 cit_model3_Packet1(gspca_dev, 0x0066, 0x000a);
1249 cit_model3_Packet1(gspca_dev, 0x0067, 0x0006);
1250 cit_model3_Packet1(gspca_dev, 0x006b, 0x0010);
1251 cit_model3_Packet1(gspca_dev, 0x005a, 0x0001);
1252 cit_model3_Packet1(gspca_dev, 0x005b, 0x000a);
1253 cit_model3_Packet1(gspca_dev, 0x0023, 0x0006);
1254 cit_model3_Packet1(gspca_dev, 0x0026, 0x0004);
1255 cit_model3_Packet1(gspca_dev, 0x0036, 0x0069);
1256 cit_model3_Packet1(gspca_dev, 0x0038, 0x0064);
1257 cit_model3_Packet1(gspca_dev, 0x003d, 0x0003);
1258 cit_model3_Packet1(gspca_dev, 0x003e, 0x0001);
1259 cit_model3_Packet1(gspca_dev, 0x00b8, 0x0014);
1260 cit_model3_Packet1(gspca_dev, 0x00b9, 0x0014);
1261 cit_model3_Packet1(gspca_dev, 0x00e6, 0x0004);
1262 cit_model3_Packet1(gspca_dev, 0x00e8, 0x0001);
1263
1264 return 0;
1265 }
1266
1267 /* this function is called at probe and resume time */
1268 static int sd_init(struct gspca_dev *gspca_dev)
1269 {
1270 struct sd *sd = (struct sd *) gspca_dev;
1271
1272 switch (sd->model) {
1273 case CIT_MODEL0:
1274 cit_init_model0(gspca_dev);
1275 sd_stop0(gspca_dev);
1276 break;
1277 case CIT_MODEL1:
1278 case CIT_MODEL2:
1279 case CIT_MODEL3:
1280 case CIT_MODEL4:
1281 break; /* All is done in sd_start */
1282 case CIT_IBM_NETCAM_PRO:
1283 cit_init_ibm_netcam_pro(gspca_dev);
1284 sd_stop0(gspca_dev);
1285 break;
1286 }
1287 return 0;
1288 }
1289
1290 static int cit_set_brightness(struct gspca_dev *gspca_dev)
1291 {
1292 struct sd *sd = (struct sd *) gspca_dev;
1293 int i;
1294
1295 switch (sd->model) {
1296 case CIT_MODEL0:
1297 case CIT_IBM_NETCAM_PRO:
1298 /* No (known) brightness control for these */
1299 break;
1300 case CIT_MODEL1:
1301 /* Model 1: Brightness range 0 - 63 */
1302 cit_Packet_Format1(gspca_dev, 0x0031, sd->brightness);
1303 cit_Packet_Format1(gspca_dev, 0x0032, sd->brightness);
1304 cit_Packet_Format1(gspca_dev, 0x0033, sd->brightness);
1305 break;
1306 case CIT_MODEL2:
1307 /* Model 2: Brightness range 0x60 - 0xee */
1308 /* Scale 0 - 63 to 0x60 - 0xee */
1309 i = 0x60 + sd->brightness * 2254 / 1000;
1310 cit_model2_Packet1(gspca_dev, 0x001a, i);
1311 break;
1312 case CIT_MODEL3:
1313 /* Model 3: Brightness range 'i' in [0x0C..0x3F] */
1314 i = sd->brightness;
1315 if (i < 0x0c)
1316 i = 0x0c;
1317 cit_model3_Packet1(gspca_dev, 0x0036, i);
1318 break;
1319 case CIT_MODEL4:
1320 /* Model 4: Brightness range 'i' in [0x04..0xb4] */
1321 /* Scale 0 - 63 to 0x04 - 0xb4 */
1322 i = 0x04 + sd->brightness * 2794 / 1000;
1323 cit_model4_BrightnessPacket(gspca_dev, i);
1324 break;
1325 }
1326
1327 return 0;
1328 }
1329
1330 static int cit_set_contrast(struct gspca_dev *gspca_dev)
1331 {
1332 struct sd *sd = (struct sd *) gspca_dev;
1333
1334 switch (sd->model) {
1335 case CIT_MODEL0: {
1336 int i;
1337 /* gain 0-15, 0-20 -> 0-15 */
1338 i = sd->contrast * 1000 / 1333;
1339 cit_write_reg(gspca_dev, i, 0x0422);
1340 /* gain 0-31, may not be lower then 0x0422, 0-20 -> 0-31 */
1341 i = sd->contrast * 2000 / 1333;
1342 cit_write_reg(gspca_dev, i, 0x0423);
1343 /* gain 0-127, may not be lower then 0x0423, 0-20 -> 0-63 */
1344 i = sd->contrast * 4000 / 1333;
1345 cit_write_reg(gspca_dev, i, 0x0424);
1346 /* gain 0-127, may not be lower then 0x0424, , 0-20 -> 0-127 */
1347 i = sd->contrast * 8000 / 1333;
1348 cit_write_reg(gspca_dev, i, 0x0425);
1349 break;
1350 }
1351 case CIT_MODEL2:
1352 case CIT_MODEL4:
1353 /* These models do not have this control. */
1354 break;
1355 case CIT_MODEL1:
1356 {
1357 /* Scale 0 - 20 to 15 - 0 */
1358 int i, new_contrast = (20 - sd->contrast) * 1000 / 1333;
1359 for (i = 0; i < cit_model1_ntries; i++) {
1360 cit_Packet_Format1(gspca_dev, 0x0014, new_contrast);
1361 cit_send_FF_04_02(gspca_dev);
1362 }
1363 break;
1364 }
1365 case CIT_MODEL3:
1366 { /* Preset hardware values */
1367 static const struct {
1368 unsigned short cv1;
1369 unsigned short cv2;
1370 unsigned short cv3;
1371 } cv[7] = {
1372 { 0x05, 0x05, 0x0f }, /* Minimum */
1373 { 0x04, 0x04, 0x16 },
1374 { 0x02, 0x03, 0x16 },
1375 { 0x02, 0x08, 0x16 },
1376 { 0x01, 0x0c, 0x16 },
1377 { 0x01, 0x0e, 0x16 },
1378 { 0x01, 0x10, 0x16 } /* Maximum */
1379 };
1380 int i = sd->contrast / 3;
1381 cit_model3_Packet1(gspca_dev, 0x0067, cv[i].cv1);
1382 cit_model3_Packet1(gspca_dev, 0x005b, cv[i].cv2);
1383 cit_model3_Packet1(gspca_dev, 0x005c, cv[i].cv3);
1384 break;
1385 }
1386 case CIT_IBM_NETCAM_PRO:
1387 cit_model3_Packet1(gspca_dev, 0x005b, sd->contrast + 1);
1388 break;
1389 }
1390 return 0;
1391 }
1392
1393 static int cit_set_hue(struct gspca_dev *gspca_dev)
1394 {
1395 struct sd *sd = (struct sd *) gspca_dev;
1396
1397 switch (sd->model) {
1398 case CIT_MODEL0:
1399 case CIT_MODEL1:
1400 case CIT_IBM_NETCAM_PRO:
1401 /* No hue control for these models */
1402 break;
1403 case CIT_MODEL2:
1404 cit_model2_Packet1(gspca_dev, 0x0024, sd->hue);
1405 /* cit_model2_Packet1(gspca_dev, 0x0020, sat); */
1406 break;
1407 case CIT_MODEL3: {
1408 /* Model 3: Brightness range 'i' in [0x05..0x37] */
1409 /* TESTME according to the ibmcam driver this does not work */
1410 if (0) {
1411 /* Scale 0 - 127 to 0x05 - 0x37 */
1412 int i = 0x05 + sd->hue * 1000 / 2540;
1413 cit_model3_Packet1(gspca_dev, 0x007e, i);
1414 }
1415 break;
1416 }
1417 case CIT_MODEL4:
1418 /* HDG: taken from ibmcam, setting the color gains does not
1419 * really belong here.
1420 *
1421 * I am not sure r/g/b_gain variables exactly control gain
1422 * of those channels. Most likely they subtly change some
1423 * very internal image processing settings in the camera.
1424 * In any case, here is what they do, and feel free to tweak:
1425 *
1426 * r_gain: seriously affects red gain
1427 * g_gain: seriously affects green gain
1428 * b_gain: seriously affects blue gain
1429 * hue: changes average color from violet (0) to red (0xFF)
1430 */
1431 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
1432 cit_write_reg(gspca_dev, 0x001e, 0x012f);
1433 cit_write_reg(gspca_dev, 0xd141, 0x0124);
1434 cit_write_reg(gspca_dev, 160, 0x0127); /* Green gain */
1435 cit_write_reg(gspca_dev, 160, 0x012e); /* Red gain */
1436 cit_write_reg(gspca_dev, 160, 0x0130); /* Blue gain */
1437 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
1438 cit_write_reg(gspca_dev, sd->hue, 0x012d); /* Hue */
1439 cit_write_reg(gspca_dev, 0xf545, 0x0124);
1440 break;
1441 }
1442 return 0;
1443 }
1444
1445 static int cit_set_sharpness(struct gspca_dev *gspca_dev)
1446 {
1447 struct sd *sd = (struct sd *) gspca_dev;
1448
1449 switch (sd->model) {
1450 case CIT_MODEL0:
1451 case CIT_MODEL2:
1452 case CIT_MODEL4:
1453 case CIT_IBM_NETCAM_PRO:
1454 /* These models do not have this control */
1455 break;
1456 case CIT_MODEL1: {
1457 int i;
1458 const unsigned short sa[] = {
1459 0x11, 0x13, 0x16, 0x18, 0x1a, 0x8, 0x0a };
1460
1461 for (i = 0; i < cit_model1_ntries; i++)
1462 cit_PacketFormat2(gspca_dev, 0x0013, sa[sd->sharpness]);
1463 break;
1464 }
1465 case CIT_MODEL3:
1466 { /*
1467 * "Use a table of magic numbers.
1468 * This setting doesn't really change much.
1469 * But that's how Windows does it."
1470 */
1471 static const struct {
1472 unsigned short sv1;
1473 unsigned short sv2;
1474 unsigned short sv3;
1475 unsigned short sv4;
1476 } sv[7] = {
1477 { 0x00, 0x00, 0x05, 0x14 }, /* Smoothest */
1478 { 0x01, 0x04, 0x05, 0x14 },
1479 { 0x02, 0x04, 0x05, 0x14 },
1480 { 0x03, 0x04, 0x05, 0x14 },
1481 { 0x03, 0x05, 0x05, 0x14 },
1482 { 0x03, 0x06, 0x05, 0x14 },
1483 { 0x03, 0x07, 0x05, 0x14 } /* Sharpest */
1484 };
1485 cit_model3_Packet1(gspca_dev, 0x0060, sv[sd->sharpness].sv1);
1486 cit_model3_Packet1(gspca_dev, 0x0061, sv[sd->sharpness].sv2);
1487 cit_model3_Packet1(gspca_dev, 0x0062, sv[sd->sharpness].sv3);
1488 cit_model3_Packet1(gspca_dev, 0x0063, sv[sd->sharpness].sv4);
1489 break;
1490 }
1491 }
1492 return 0;
1493 }
1494
1495 /*
1496 * cit_set_lighting()
1497 *
1498 * Camera model 1:
1499 * We have 3 levels of lighting conditions: 0=Bright, 1=Medium, 2=Low.
1500 *
1501 * Camera model 2:
1502 * We have 16 levels of lighting, 0 for bright light and up to 15 for
1503 * low light. But values above 5 or so are useless because camera is
1504 * not really capable to produce anything worth viewing at such light.
1505 * This setting may be altered only in certain camera state.
1506 *
1507 * Low lighting forces slower FPS.
1508 *
1509 * History:
1510 * 1/5/00 Created.
1511 * 2/20/00 Added support for Model 2 cameras.
1512 */
1513 static void cit_set_lighting(struct gspca_dev *gspca_dev)
1514 {
1515 struct sd *sd = (struct sd *) gspca_dev;
1516
1517 switch (sd->model) {
1518 case CIT_MODEL0:
1519 case CIT_MODEL2:
1520 case CIT_MODEL3:
1521 case CIT_MODEL4:
1522 case CIT_IBM_NETCAM_PRO:
1523 break;
1524 case CIT_MODEL1: {
1525 int i;
1526 for (i = 0; i < cit_model1_ntries; i++)
1527 cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
1528 break;
1529 }
1530 }
1531 }
1532
1533 static void cit_set_hflip(struct gspca_dev *gspca_dev)
1534 {
1535 struct sd *sd = (struct sd *) gspca_dev;
1536
1537 switch (sd->model) {
1538 case CIT_MODEL0:
1539 if (sd->hflip)
1540 cit_write_reg(gspca_dev, 0x0020, 0x0115);
1541 else
1542 cit_write_reg(gspca_dev, 0x0040, 0x0115);
1543 break;
1544 case CIT_MODEL1:
1545 case CIT_MODEL2:
1546 case CIT_MODEL3:
1547 case CIT_MODEL4:
1548 case CIT_IBM_NETCAM_PRO:
1549 break;
1550 }
1551 }
1552
1553 static int cit_restart_stream(struct gspca_dev *gspca_dev)
1554 {
1555 struct sd *sd = (struct sd *) gspca_dev;
1556
1557 switch (sd->model) {
1558 case CIT_MODEL0:
1559 case CIT_MODEL1:
1560 case CIT_MODEL3:
1561 case CIT_IBM_NETCAM_PRO:
1562 cit_write_reg(gspca_dev, 0x0001, 0x0114);
1563 /* Fall through */
1564 case CIT_MODEL2:
1565 case CIT_MODEL4:
1566 cit_write_reg(gspca_dev, 0x00c0, 0x010c); /* Go! */
1567 usb_clear_halt(gspca_dev->dev, gspca_dev->urb[0]->pipe);
1568 /* This happens repeatedly while streaming with the ibm netcam
1569 pro and the ibmcam driver did it for model3 after changing
1570 settings, but it does not seem to have any effect. */
1571 /* cit_write_reg(gspca_dev, 0x0001, 0x0113); */
1572 break;
1573 }
1574
1575 sd->sof_read = 0;
1576
1577 return 0;
1578 }
1579
1580 static int cit_get_packet_size(struct gspca_dev *gspca_dev)
1581 {
1582 struct usb_host_interface *alt;
1583 struct usb_interface *intf;
1584
1585 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
1586 alt = usb_altnum_to_altsetting(intf, gspca_dev->alt);
1587 if (!alt) {
1588 err("Couldn't get altsetting");
1589 return -EIO;
1590 }
1591
1592 return le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
1593 }
1594
1595 /* Calculate the clockdiv giving us max fps given the available bandwidth */
1596 static int cit_get_clock_div(struct gspca_dev *gspca_dev)
1597 {
1598 int clock_div = 7; /* 0=30 1=25 2=20 3=15 4=12 5=7.5 6=6 7=3fps ?? */
1599 int fps[8] = { 30, 25, 20, 15, 12, 8, 6, 3 };
1600 int packet_size;
1601
1602 packet_size = cit_get_packet_size(gspca_dev);
1603 if (packet_size < 0)
1604 return packet_size;
1605
1606 while (clock_div > 3 &&
1607 1000 * packet_size >
1608 gspca_dev->width * gspca_dev->height *
1609 fps[clock_div - 1] * 3 / 2)
1610 clock_div--;
1611
1612 PDEBUG(D_PROBE,
1613 "PacketSize: %d, res: %dx%d -> using clockdiv: %d (%d fps)",
1614 packet_size, gspca_dev->width, gspca_dev->height, clock_div,
1615 fps[clock_div]);
1616
1617 return clock_div;
1618 }
1619
1620 static int cit_start_model0(struct gspca_dev *gspca_dev)
1621 {
1622 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
1623 int clock_div;
1624
1625 clock_div = cit_get_clock_div(gspca_dev);
1626 if (clock_div < 0)
1627 return clock_div;
1628
1629 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* turn on led */
1630 cit_write_reg(gspca_dev, 0x0003, 0x0438);
1631 cit_write_reg(gspca_dev, 0x001e, 0x042b);
1632 cit_write_reg(gspca_dev, 0x0041, 0x042c);
1633 cit_write_reg(gspca_dev, 0x0008, 0x0436);
1634 cit_write_reg(gspca_dev, 0x0024, 0x0403);
1635 cit_write_reg(gspca_dev, 0x002c, 0x0404);
1636 cit_write_reg(gspca_dev, 0x0002, 0x0426);
1637 cit_write_reg(gspca_dev, 0x0014, 0x0427);
1638
1639 switch (gspca_dev->width) {
1640 case 160: /* 160x120 */
1641 cit_write_reg(gspca_dev, 0x0004, 0x010b);
1642 cit_write_reg(gspca_dev, 0x0001, 0x010a);
1643 cit_write_reg(gspca_dev, 0x0010, 0x0102);
1644 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1645 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1646 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1647 break;
1648
1649 case 176: /* 176x144 */
1650 cit_write_reg(gspca_dev, 0x0006, 0x010b);
1651 cit_write_reg(gspca_dev, 0x0000, 0x010a);
1652 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1653 cit_write_reg(gspca_dev, 0x00b0, 0x0103);
1654 cit_write_reg(gspca_dev, 0x0000, 0x0104);
1655 cit_write_reg(gspca_dev, 0x0090, 0x0105);
1656 break;
1657
1658 case 320: /* 320x240 */
1659 cit_write_reg(gspca_dev, 0x0008, 0x010b);
1660 cit_write_reg(gspca_dev, 0x0004, 0x010a);
1661 cit_write_reg(gspca_dev, 0x0005, 0x0102);
1662 cit_write_reg(gspca_dev, 0x00a0, 0x0103);
1663 cit_write_reg(gspca_dev, 0x0010, 0x0104);
1664 cit_write_reg(gspca_dev, 0x0078, 0x0105);
1665 break;
1666 }
1667
1668 cit_write_reg(gspca_dev, compression, 0x0109);
1669 cit_write_reg(gspca_dev, clock_div, 0x0111);
1670
1671 return 0;
1672 }
1673
1674 static int cit_start_model1(struct gspca_dev *gspca_dev)
1675 {
1676 struct sd *sd = (struct sd *) gspca_dev;
1677 int i, clock_div;
1678
1679 clock_div = cit_get_clock_div(gspca_dev);
1680 if (clock_div < 0)
1681 return clock_div;
1682
1683 cit_read_reg(gspca_dev, 0x0128);
1684 cit_read_reg(gspca_dev, 0x0100);
1685 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1686 cit_read_reg(gspca_dev, 0x0100);
1687 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
1688 cit_read_reg(gspca_dev, 0x0100);
1689 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1690 cit_write_reg(gspca_dev, 0x01, 0x0108);
1691
1692 cit_write_reg(gspca_dev, 0x03, 0x0112);
1693 cit_read_reg(gspca_dev, 0x0115);
1694 cit_write_reg(gspca_dev, 0x06, 0x0115);
1695 cit_read_reg(gspca_dev, 0x0116);
1696 cit_write_reg(gspca_dev, 0x44, 0x0116);
1697 cit_read_reg(gspca_dev, 0x0116);
1698 cit_write_reg(gspca_dev, 0x40, 0x0116);
1699 cit_read_reg(gspca_dev, 0x0115);
1700 cit_write_reg(gspca_dev, 0x0e, 0x0115);
1701 cit_write_reg(gspca_dev, 0x19, 0x012c);
1702
1703 cit_Packet_Format1(gspca_dev, 0x00, 0x1e);
1704 cit_Packet_Format1(gspca_dev, 0x39, 0x0d);
1705 cit_Packet_Format1(gspca_dev, 0x39, 0x09);
1706 cit_Packet_Format1(gspca_dev, 0x3b, 0x00);
1707 cit_Packet_Format1(gspca_dev, 0x28, 0x22);
1708 cit_Packet_Format1(gspca_dev, 0x27, 0x00);
1709 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1710 cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1711
1712 for (i = 0; i < cit_model1_ntries; i++)
1713 cit_Packet_Format1(gspca_dev, 0x2c, 0x00);
1714
1715 for (i = 0; i < cit_model1_ntries; i++)
1716 cit_Packet_Format1(gspca_dev, 0x30, 0x14);
1717
1718 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1719 cit_PacketFormat2(gspca_dev, 0x01, 0xe1);
1720 cit_PacketFormat2(gspca_dev, 0x02, 0xcd);
1721 cit_PacketFormat2(gspca_dev, 0x03, 0xcd);
1722 cit_PacketFormat2(gspca_dev, 0x04, 0xfa);
1723 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1724 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1725
1726 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1727 cit_PacketFormat2(gspca_dev, 0x0a, 0x37);
1728 cit_PacketFormat2(gspca_dev, 0x0b, 0xb8);
1729 cit_PacketFormat2(gspca_dev, 0x0c, 0xf3);
1730 cit_PacketFormat2(gspca_dev, 0x0d, 0xe3);
1731 cit_PacketFormat2(gspca_dev, 0x0e, 0x0d);
1732 cit_PacketFormat2(gspca_dev, 0x0f, 0xf2);
1733 cit_PacketFormat2(gspca_dev, 0x10, 0xd5);
1734 cit_PacketFormat2(gspca_dev, 0x11, 0xba);
1735 cit_PacketFormat2(gspca_dev, 0x12, 0x53);
1736 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1737 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1738
1739 cit_PacketFormat2(gspca_dev, 0x39, 0x02);
1740 cit_PacketFormat2(gspca_dev, 0x16, 0x00);
1741 cit_PacketFormat2(gspca_dev, 0x17, 0x28);
1742 cit_PacketFormat2(gspca_dev, 0x18, 0x7d);
1743 cit_PacketFormat2(gspca_dev, 0x19, 0xbe);
1744 cit_PacketFormat2(gspca_dev, 0x3f, 0xff);
1745 cit_PacketFormat2(gspca_dev, 0x39, 0x00);
1746
1747 for (i = 0; i < cit_model1_ntries; i++)
1748 cit_Packet_Format1(gspca_dev, 0x00, 0x18);
1749 for (i = 0; i < cit_model1_ntries; i++)
1750 cit_Packet_Format1(gspca_dev, 0x13, 0x18);
1751 for (i = 0; i < cit_model1_ntries; i++)
1752 cit_Packet_Format1(gspca_dev, 0x14, 0x06);
1753
1754 /* TESTME These are handled through controls
1755 KEEP until someone can test leaving this out is ok */
1756 if (0) {
1757 /* This is default brightness */
1758 for (i = 0; i < cit_model1_ntries; i++)
1759 cit_Packet_Format1(gspca_dev, 0x31, 0x37);
1760 for (i = 0; i < cit_model1_ntries; i++)
1761 cit_Packet_Format1(gspca_dev, 0x32, 0x46);
1762 for (i = 0; i < cit_model1_ntries; i++)
1763 cit_Packet_Format1(gspca_dev, 0x33, 0x55);
1764 }
1765
1766 cit_Packet_Format1(gspca_dev, 0x2e, 0x04);
1767 for (i = 0; i < cit_model1_ntries; i++)
1768 cit_Packet_Format1(gspca_dev, 0x2d, 0x04);
1769 for (i = 0; i < cit_model1_ntries; i++)
1770 cit_Packet_Format1(gspca_dev, 0x29, 0x80);
1771 cit_Packet_Format1(gspca_dev, 0x2c, 0x01);
1772 cit_Packet_Format1(gspca_dev, 0x30, 0x17);
1773 cit_Packet_Format1(gspca_dev, 0x39, 0x08);
1774 for (i = 0; i < cit_model1_ntries; i++)
1775 cit_Packet_Format1(gspca_dev, 0x34, 0x00);
1776
1777 cit_write_reg(gspca_dev, 0x00, 0x0101);
1778 cit_write_reg(gspca_dev, 0x00, 0x010a);
1779
1780 switch (gspca_dev->width) {
1781 case 128: /* 128x96 */
1782 cit_write_reg(gspca_dev, 0x80, 0x0103);
1783 cit_write_reg(gspca_dev, 0x60, 0x0105);
1784 cit_write_reg(gspca_dev, 0x0c, 0x010b);
1785 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1786 cit_write_reg(gspca_dev, 0x0b, 0x011d);
1787 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1788 cit_write_reg(gspca_dev, 0x00, 0x0129);
1789 break;
1790 case 176: /* 176x144 */
1791 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1792 cit_write_reg(gspca_dev, 0x8f, 0x0105);
1793 cit_write_reg(gspca_dev, 0x06, 0x010b);
1794 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1795 cit_write_reg(gspca_dev, 0x0d, 0x011d);
1796 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1797 cit_write_reg(gspca_dev, 0x03, 0x0129);
1798 break;
1799 case 352: /* 352x288 */
1800 cit_write_reg(gspca_dev, 0xb0, 0x0103);
1801 cit_write_reg(gspca_dev, 0x90, 0x0105);
1802 cit_write_reg(gspca_dev, 0x02, 0x010b);
1803 cit_write_reg(gspca_dev, 0x04, 0x011b); /* Same everywhere */
1804 cit_write_reg(gspca_dev, 0x05, 0x011d);
1805 cit_write_reg(gspca_dev, 0x00, 0x011e); /* Same everywhere */
1806 cit_write_reg(gspca_dev, 0x00, 0x0129);
1807 break;
1808 }
1809
1810 cit_write_reg(gspca_dev, 0xff, 0x012b);
1811
1812 /* TESTME These are handled through controls
1813 KEEP until someone can test leaving this out is ok */
1814 if (0) {
1815 /* This is another brightness - don't know why */
1816 for (i = 0; i < cit_model1_ntries; i++)
1817 cit_Packet_Format1(gspca_dev, 0x31, 0xc3);
1818 for (i = 0; i < cit_model1_ntries; i++)
1819 cit_Packet_Format1(gspca_dev, 0x32, 0xd2);
1820 for (i = 0; i < cit_model1_ntries; i++)
1821 cit_Packet_Format1(gspca_dev, 0x33, 0xe1);
1822
1823 /* Default contrast */
1824 for (i = 0; i < cit_model1_ntries; i++)
1825 cit_Packet_Format1(gspca_dev, 0x14, 0x0a);
1826
1827 /* Default sharpness */
1828 for (i = 0; i < cit_model1_ntries2; i++)
1829 cit_PacketFormat2(gspca_dev, 0x13, 0x1a);
1830
1831 /* Default lighting conditions */
1832 cit_Packet_Format1(gspca_dev, 0x0027, sd->lighting);
1833 }
1834
1835 /* Assorted init */
1836 switch (gspca_dev->width) {
1837 case 128: /* 128x96 */
1838 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1839 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1840 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1841 cit_write_reg(gspca_dev, 0x36, 0x0102);
1842 cit_write_reg(gspca_dev, 0x1a, 0x0104);
1843 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1844 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1845 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1846 break;
1847 case 176: /* 176x144 */
1848 cit_Packet_Format1(gspca_dev, 0x2b, 0x1e);
1849 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1850 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1851 cit_write_reg(gspca_dev, 0x04, 0x0102);
1852 cit_write_reg(gspca_dev, 0x02, 0x0104);
1853 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1854 cit_write_reg(gspca_dev, 0x2b, 0x011c);
1855 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1856 break;
1857 case 352: /* 352x288 */
1858 cit_Packet_Format1(gspca_dev, 0x2b, 0x1f);
1859 cit_write_reg(gspca_dev, 0xc9, 0x0119); /* Same everywhere */
1860 cit_write_reg(gspca_dev, 0x80, 0x0109); /* Same everywhere */
1861 cit_write_reg(gspca_dev, 0x08, 0x0102);
1862 cit_write_reg(gspca_dev, 0x01, 0x0104);
1863 cit_write_reg(gspca_dev, 0x04, 0x011a); /* Same everywhere */
1864 cit_write_reg(gspca_dev, 0x2f, 0x011c);
1865 cit_write_reg(gspca_dev, 0x23, 0x012a); /* Same everywhere */
1866 break;
1867 }
1868
1869 cit_write_reg(gspca_dev, 0x01, 0x0100); /* LED On */
1870 cit_write_reg(gspca_dev, clock_div, 0x0111);
1871
1872 return 0;
1873 }
1874
1875 static int cit_start_model2(struct gspca_dev *gspca_dev)
1876 {
1877 struct sd *sd = (struct sd *) gspca_dev;
1878 int clock_div = 0;
1879
1880 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */
1881 cit_read_reg(gspca_dev, 0x0116);
1882 cit_write_reg(gspca_dev, 0x0060, 0x0116);
1883 cit_write_reg(gspca_dev, 0x0002, 0x0112);
1884 cit_write_reg(gspca_dev, 0x00bc, 0x012c);
1885 cit_write_reg(gspca_dev, 0x0008, 0x012b);
1886 cit_write_reg(gspca_dev, 0x0000, 0x0108);
1887 cit_write_reg(gspca_dev, 0x0001, 0x0133);
1888 cit_write_reg(gspca_dev, 0x0001, 0x0102);
1889 switch (gspca_dev->width) {
1890 case 176: /* 176x144 */
1891 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1892 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1893 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */
1894 cit_write_reg(gspca_dev, 0x00b9, 0x010a); /* Unique to this mode */
1895 cit_write_reg(gspca_dev, 0x0038, 0x0119); /* Unique to this mode */
1896 /* TESTME HDG: this does not seem right
1897 (it is 2 for all other resolutions) */
1898 sd->sof_len = 10;
1899 break;
1900 case 320: /* 320x240 */
1901 cit_write_reg(gspca_dev, 0x0028, 0x0103); /* Unique to this mode */
1902 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1903 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */
1904 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1905 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1906 sd->sof_len = 2;
1907 break;
1908 /* case VIDEOSIZE_352x240: */
1909 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1910 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1911 cit_write_reg(gspca_dev, 0x001e, 0x0105); /* 320x240, 352x240 */
1912 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1913 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1914 sd->sof_len = 2;
1915 break;
1916 case 352: /* 352x288 */
1917 cit_write_reg(gspca_dev, 0x002c, 0x0103); /* All except 320x240 */
1918 cit_write_reg(gspca_dev, 0x0000, 0x0104); /* Same */
1919 cit_write_reg(gspca_dev, 0x0024, 0x0105); /* 176x144, 352x288 */
1920 cit_write_reg(gspca_dev, 0x0039, 0x010a); /* All except 176x144 */
1921 cit_write_reg(gspca_dev, 0x0070, 0x0119); /* All except 176x144 */
1922 sd->sof_len = 2;
1923 break;
1924 }
1925
1926 cit_write_reg(gspca_dev, 0x0000, 0x0100); /* LED on */
1927
1928 switch (gspca_dev->width) {
1929 case 176: /* 176x144 */
1930 cit_write_reg(gspca_dev, 0x0050, 0x0111);
1931 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
1932 break;
1933 case 320: /* 320x240 */
1934 case 352: /* 352x288 */
1935 cit_write_reg(gspca_dev, 0x0040, 0x0111);
1936 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
1937 break;
1938 }
1939 cit_write_reg(gspca_dev, 0x009b, 0x010f);
1940 cit_write_reg(gspca_dev, 0x00bb, 0x010f);
1941
1942 /*
1943 * Hardware settings, may affect CMOS sensor; not user controls!
1944 * -------------------------------------------------------------
1945 * 0x0004: no effect
1946 * 0x0006: hardware effect
1947 * 0x0008: no effect
1948 * 0x000a: stops video stream, probably important h/w setting
1949 * 0x000c: changes color in hardware manner (not user setting)
1950 * 0x0012: changes number of colors (does not affect speed)
1951 * 0x002a: no effect
1952 * 0x002c: hardware setting (related to scan lines)
1953 * 0x002e: stops video stream, probably important h/w setting
1954 */
1955 cit_model2_Packet1(gspca_dev, 0x000a, 0x005c);
1956 cit_model2_Packet1(gspca_dev, 0x0004, 0x0000);
1957 cit_model2_Packet1(gspca_dev, 0x0006, 0x00fb);
1958 cit_model2_Packet1(gspca_dev, 0x0008, 0x0000);
1959 cit_model2_Packet1(gspca_dev, 0x000c, 0x0009);
1960 cit_model2_Packet1(gspca_dev, 0x0012, 0x000a);
1961 cit_model2_Packet1(gspca_dev, 0x002a, 0x0000);
1962 cit_model2_Packet1(gspca_dev, 0x002c, 0x0000);
1963 cit_model2_Packet1(gspca_dev, 0x002e, 0x0008);
1964
1965 /*
1966 * Function 0x0030 pops up all over the place. Apparently
1967 * it is a hardware control register, with every bit assigned to
1968 * do something.
1969 */
1970 cit_model2_Packet1(gspca_dev, 0x0030, 0x0000);
1971
1972 /*
1973 * Magic control of CMOS sensor. Only lower values like
1974 * 0-3 work, and picture shifts left or right. Don't change.
1975 */
1976 switch (gspca_dev->width) {
1977 case 176: /* 176x144 */
1978 cit_model2_Packet1(gspca_dev, 0x0014, 0x0002);
1979 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1980 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
1981 clock_div = 6;
1982 break;
1983 case 320: /* 320x240 */
1984 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009);
1985 cit_model2_Packet1(gspca_dev, 0x0016, 0x0005); /* Horizontal shift */
1986 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Another hardware setting */
1987 clock_div = 8;
1988 break;
1989 /* case VIDEOSIZE_352x240: */
1990 /* This mode doesn't work as Windows programs it; changed to work */
1991 cit_model2_Packet1(gspca_dev, 0x0014, 0x0009); /* Windows sets this to 8 */
1992 cit_model2_Packet1(gspca_dev, 0x0016, 0x0003); /* Horizontal shift */
1993 cit_model2_Packet1(gspca_dev, 0x0018, 0x0044); /* Windows sets this to 0x0045 */
1994 clock_div = 10;
1995 break;
1996 case 352: /* 352x288 */
1997 cit_model2_Packet1(gspca_dev, 0x0014, 0x0003);
1998 cit_model2_Packet1(gspca_dev, 0x0016, 0x0002); /* Horizontal shift */
1999 cit_model2_Packet1(gspca_dev, 0x0018, 0x004a); /* Another hardware setting */
2000 clock_div = 16;
2001 break;
2002 }
2003
2004 /* TESTME These are handled through controls
2005 KEEP until someone can test leaving this out is ok */
2006 if (0)
2007 cit_model2_Packet1(gspca_dev, 0x001a, 0x005a);
2008
2009 /*
2010 * We have our own frame rate setting varying from 0 (slowest) to 6
2011 * (fastest). The camera model 2 allows frame rate in range [0..0x1F]
2012 # where 0 is also the slowest setting. However for all practical
2013 # reasons high settings make no sense because USB is not fast enough
2014 # to support high FPS. Be aware that the picture datastream will be
2015 # severely disrupted if you ask for frame rate faster than allowed
2016 # for the video size - see below:
2017 *
2018 * Allowable ranges (obtained experimentally on OHCI, K6-3, 450 MHz):
2019 * -----------------------------------------------------------------
2020 * 176x144: [6..31]
2021 * 320x240: [8..31]
2022 * 352x240: [10..31]
2023 * 352x288: [16..31] I have to raise lower threshold for stability...
2024 *
2025 * As usual, slower FPS provides better sensitivity.
2026 */
2027 cit_model2_Packet1(gspca_dev, 0x001c, clock_div);
2028
2029 /*
2030 * This setting does not visibly affect pictures; left it here
2031 * because it was present in Windows USB data stream. This function
2032 * does not allow arbitrary values and apparently is a bit mask, to
2033 * be activated only at appropriate time. Don't change it randomly!
2034 */
2035 switch (gspca_dev->width) {
2036 case 176: /* 176x144 */
2037 cit_model2_Packet1(gspca_dev, 0x0026, 0x00c2);
2038 break;
2039 case 320: /* 320x240 */
2040 cit_model2_Packet1(gspca_dev, 0x0026, 0x0044);
2041 break;
2042 /* case VIDEOSIZE_352x240: */
2043 cit_model2_Packet1(gspca_dev, 0x0026, 0x0046);
2044 break;
2045 case 352: /* 352x288 */
2046 cit_model2_Packet1(gspca_dev, 0x0026, 0x0048);
2047 break;
2048 }
2049
2050 /* FIXME this cannot be changed while streaming, so we
2051 should report a grabbed flag for this control. */
2052 cit_model2_Packet1(gspca_dev, 0x0028, sd->lighting);
2053 /* color balance rg2 */
2054 cit_model2_Packet1(gspca_dev, 0x001e, 0x002f);
2055 /* saturation */
2056 cit_model2_Packet1(gspca_dev, 0x0020, 0x0034);
2057 /* color balance yb */
2058 cit_model2_Packet1(gspca_dev, 0x0022, 0x00a0);
2059
2060 /* Hardware control command */
2061 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2062
2063 return 0;
2064 }
2065
2066 static int cit_start_model3(struct gspca_dev *gspca_dev)
2067 {
2068 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2069 int i, clock_div = 0;
2070
2071 /* HDG not in ibmcam driver, added to see if it helps with
2072 auto-detecting between model3 and ibm netcamera pro */
2073 cit_read_reg(gspca_dev, 0x128);
2074
2075 cit_write_reg(gspca_dev, 0x0000, 0x0100);
2076 cit_read_reg(gspca_dev, 0x0116);
2077 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2078 cit_write_reg(gspca_dev, 0x0002, 0x0112);
2079 cit_write_reg(gspca_dev, 0x0000, 0x0123);
2080 cit_write_reg(gspca_dev, 0x0001, 0x0117);
2081 cit_write_reg(gspca_dev, 0x0040, 0x0108);
2082 cit_write_reg(gspca_dev, 0x0019, 0x012c);
2083 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2084 cit_write_reg(gspca_dev, 0x0002, 0x0115);
2085 cit_write_reg(gspca_dev, 0x0003, 0x0115);
2086 cit_read_reg(gspca_dev, 0x0115);
2087 cit_write_reg(gspca_dev, 0x000b, 0x0115);
2088
2089 /* TESTME HDG not in ibmcam driver, added to see if it helps with
2090 auto-detecting between model3 and ibm netcamera pro */
2091 if (0) {
2092 cit_write_reg(gspca_dev, 0x0078, 0x012d);
2093 cit_write_reg(gspca_dev, 0x0001, 0x012f);
2094 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2095 cit_write_reg(gspca_dev, 0x0079, 0x012d);
2096 cit_write_reg(gspca_dev, 0x00ff, 0x0130);
2097 cit_write_reg(gspca_dev, 0xcd41, 0x0124);
2098 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2099 cit_read_reg(gspca_dev, 0x0126);
2100 }
2101
2102 cit_model3_Packet1(gspca_dev, 0x000a, 0x0040);
2103 cit_model3_Packet1(gspca_dev, 0x000b, 0x00f6);
2104 cit_model3_Packet1(gspca_dev, 0x000c, 0x0002);
2105 cit_model3_Packet1(gspca_dev, 0x000d, 0x0020);
2106 cit_model3_Packet1(gspca_dev, 0x000e, 0x0033);
2107 cit_model3_Packet1(gspca_dev, 0x000f, 0x0007);
2108 cit_model3_Packet1(gspca_dev, 0x0010, 0x0000);
2109 cit_model3_Packet1(gspca_dev, 0x0011, 0x0070);
2110 cit_model3_Packet1(gspca_dev, 0x0012, 0x0030);
2111 cit_model3_Packet1(gspca_dev, 0x0013, 0x0000);
2112 cit_model3_Packet1(gspca_dev, 0x0014, 0x0001);
2113 cit_model3_Packet1(gspca_dev, 0x0015, 0x0001);
2114 cit_model3_Packet1(gspca_dev, 0x0016, 0x0001);
2115 cit_model3_Packet1(gspca_dev, 0x0017, 0x0001);
2116 cit_model3_Packet1(gspca_dev, 0x0018, 0x0000);
2117 cit_model3_Packet1(gspca_dev, 0x001e, 0x00c3);
2118 cit_model3_Packet1(gspca_dev, 0x0020, 0x0000);
2119 cit_model3_Packet1(gspca_dev, 0x0028, 0x0010);
2120 cit_model3_Packet1(gspca_dev, 0x0029, 0x0054);
2121 cit_model3_Packet1(gspca_dev, 0x002a, 0x0013);
2122 cit_model3_Packet1(gspca_dev, 0x002b, 0x0007);
2123 cit_model3_Packet1(gspca_dev, 0x002d, 0x0028);
2124 cit_model3_Packet1(gspca_dev, 0x002e, 0x0000);
2125 cit_model3_Packet1(gspca_dev, 0x0031, 0x0000);
2126 cit_model3_Packet1(gspca_dev, 0x0032, 0x0000);
2127 cit_model3_Packet1(gspca_dev, 0x0033, 0x0000);
2128 cit_model3_Packet1(gspca_dev, 0x0034, 0x0000);
2129 cit_model3_Packet1(gspca_dev, 0x0035, 0x0038);
2130 cit_model3_Packet1(gspca_dev, 0x003a, 0x0001);
2131 cit_model3_Packet1(gspca_dev, 0x003c, 0x001e);
2132 cit_model3_Packet1(gspca_dev, 0x003f, 0x000a);
2133 cit_model3_Packet1(gspca_dev, 0x0041, 0x0000);
2134 cit_model3_Packet1(gspca_dev, 0x0046, 0x003f);
2135 cit_model3_Packet1(gspca_dev, 0x0047, 0x0000);
2136 cit_model3_Packet1(gspca_dev, 0x0050, 0x0005);
2137 cit_model3_Packet1(gspca_dev, 0x0052, 0x001a);
2138 cit_model3_Packet1(gspca_dev, 0x0053, 0x0003);
2139 cit_model3_Packet1(gspca_dev, 0x005a, 0x006b);
2140 cit_model3_Packet1(gspca_dev, 0x005d, 0x001e);
2141 cit_model3_Packet1(gspca_dev, 0x005e, 0x0030);
2142 cit_model3_Packet1(gspca_dev, 0x005f, 0x0041);
2143 cit_model3_Packet1(gspca_dev, 0x0064, 0x0008);
2144 cit_model3_Packet1(gspca_dev, 0x0065, 0x0015);
2145 cit_model3_Packet1(gspca_dev, 0x0068, 0x000f);
2146 cit_model3_Packet1(gspca_dev, 0x0079, 0x0000);
2147 cit_model3_Packet1(gspca_dev, 0x007a, 0x0000);
2148 cit_model3_Packet1(gspca_dev, 0x007c, 0x003f);
2149 cit_model3_Packet1(gspca_dev, 0x0082, 0x000f);
2150 cit_model3_Packet1(gspca_dev, 0x0085, 0x0000);
2151 cit_model3_Packet1(gspca_dev, 0x0099, 0x0000);
2152 cit_model3_Packet1(gspca_dev, 0x009b, 0x0023);
2153 cit_model3_Packet1(gspca_dev, 0x009c, 0x0022);
2154 cit_model3_Packet1(gspca_dev, 0x009d, 0x0096);
2155 cit_model3_Packet1(gspca_dev, 0x009e, 0x0096);
2156 cit_model3_Packet1(gspca_dev, 0x009f, 0x000a);
2157
2158 switch (gspca_dev->width) {
2159 case 160:
2160 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2161 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2162 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2163 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2164 cit_write_reg(gspca_dev, 0x0024, 0x010b); /* Differs everywhere */
2165 cit_write_reg(gspca_dev, 0x00a9, 0x0119);
2166 cit_write_reg(gspca_dev, 0x0016, 0x011b);
2167 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2168 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2169 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2170 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2171 cit_write_reg(gspca_dev, 0x0018, 0x0102);
2172 cit_write_reg(gspca_dev, 0x0004, 0x0104);
2173 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2174 cit_write_reg(gspca_dev, 0x0028, 0x011c);
2175 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2176 cit_write_reg(gspca_dev, 0x0000, 0x0118);
2177 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2178 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2179 cit_write_reg(gspca_dev, compression, 0x0109);
2180 clock_div = 3;
2181 break;
2182 case 320:
2183 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2184 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2185 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2186 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2187 cit_write_reg(gspca_dev, 0x0028, 0x010b); /* Differs everywhere */
2188 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same */
2189 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2190 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2191 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2192 /* 4 commands from 160x120 skipped */
2193 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2194 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2195 cit_write_reg(gspca_dev, compression, 0x0109);
2196 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2197 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2198 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2199 cit_write_reg(gspca_dev, 0x0010, 0x0104);
2200 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2201 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2202 cit_write_reg(gspca_dev, 0x001c, 0x0118);
2203 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2204 clock_div = 5;
2205 break;
2206 case 640:
2207 cit_write_reg(gspca_dev, 0x00f0, 0x0105);
2208 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2209 cit_write_reg(gspca_dev, 0x0038, 0x010b); /* Differs everywhere */
2210 cit_write_reg(gspca_dev, 0x00d9, 0x0119); /* Same on 320x240, 640x480 */
2211 cit_write_reg(gspca_dev, 0x0006, 0x011b); /* Same on 320x240, 640x480 */
2212 cit_write_reg(gspca_dev, 0x0004, 0x011d); /* NC */
2213 cit_write_reg(gspca_dev, 0x0003, 0x011e); /* Same on 160x120, 640x480 */
2214 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2215 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2216 cit_write_reg(gspca_dev, 0x0021, 0x0102); /* Same on 320x240, 640x480 */
2217 cit_write_reg(gspca_dev, 0x0016, 0x0104); /* NC */
2218 cit_write_reg(gspca_dev, 0x0004, 0x011a); /* Same on 320x240, 640x480 */
2219 cit_write_reg(gspca_dev, 0x003f, 0x011c); /* Same on 320x240, 640x480 */
2220 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2221 cit_write_reg(gspca_dev, 0x001c, 0x0118); /* Same on 320x240, 640x480 */
2222 cit_model3_Packet1(gspca_dev, 0x0021, 0x0001); /* Same */
2223 cit_write_reg(gspca_dev, compression, 0x0109);
2224 cit_write_reg(gspca_dev, 0x0040, 0x0101);
2225 cit_write_reg(gspca_dev, 0x0040, 0x0103);
2226 cit_write_reg(gspca_dev, 0x0000, 0x0132); /* Same on 320x240, 640x480 */
2227 clock_div = 7;
2228 break;
2229 }
2230
2231 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e); /* Hue */
2232 cit_model3_Packet1(gspca_dev, 0x0036, 0x0011); /* Brightness */
2233 cit_model3_Packet1(gspca_dev, 0x0060, 0x0002); /* Sharpness */
2234 cit_model3_Packet1(gspca_dev, 0x0061, 0x0004); /* Sharpness */
2235 cit_model3_Packet1(gspca_dev, 0x0062, 0x0005); /* Sharpness */
2236 cit_model3_Packet1(gspca_dev, 0x0063, 0x0014); /* Sharpness */
2237 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */
2238 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */
2239 cit_model3_Packet1(gspca_dev, 0x0067, 0x0001); /* Contrast */
2240 cit_model3_Packet1(gspca_dev, 0x005b, 0x000c); /* Contrast */
2241 cit_model3_Packet1(gspca_dev, 0x005c, 0x0016); /* Contrast */
2242 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2243 cit_model3_Packet1(gspca_dev, 0x002c, 0x0003); /* Was 1, broke 640x480 */
2244 cit_model3_Packet1(gspca_dev, 0x002f, 0x002a);
2245 cit_model3_Packet1(gspca_dev, 0x0030, 0x0029);
2246 cit_model3_Packet1(gspca_dev, 0x0037, 0x0002);
2247 cit_model3_Packet1(gspca_dev, 0x0038, 0x0059);
2248 cit_model3_Packet1(gspca_dev, 0x003d, 0x002e);
2249 cit_model3_Packet1(gspca_dev, 0x003e, 0x0028);
2250 cit_model3_Packet1(gspca_dev, 0x0078, 0x0005);
2251 cit_model3_Packet1(gspca_dev, 0x007b, 0x0011);
2252 cit_model3_Packet1(gspca_dev, 0x007d, 0x004b);
2253 cit_model3_Packet1(gspca_dev, 0x007f, 0x0022);
2254 cit_model3_Packet1(gspca_dev, 0x0080, 0x000c);
2255 cit_model3_Packet1(gspca_dev, 0x0081, 0x000b);
2256 cit_model3_Packet1(gspca_dev, 0x0083, 0x00fd);
2257 cit_model3_Packet1(gspca_dev, 0x0086, 0x000b);
2258 cit_model3_Packet1(gspca_dev, 0x0087, 0x000b);
2259 cit_model3_Packet1(gspca_dev, 0x007e, 0x000e);
2260 cit_model3_Packet1(gspca_dev, 0x0096, 0x00a0); /* Red sharpness */
2261 cit_model3_Packet1(gspca_dev, 0x0097, 0x0096); /* Blue sharpness */
2262 cit_model3_Packet1(gspca_dev, 0x0098, 0x000b);
2263
2264 /* FIXME we should probably use cit_get_clock_div() here (in
2265 combination with isoc negotiation using the programmable isoc size)
2266 like with the IBM netcam pro). */
2267 cit_write_reg(gspca_dev, clock_div, 0x0111); /* Clock Divider */
2268
2269 switch (gspca_dev->width) {
2270 case 160:
2271 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2272 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2273 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2274 cit_model3_Packet1(gspca_dev, 0x0040, 0x000a);
2275 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2276 break;
2277 case 320:
2278 cit_model3_Packet1(gspca_dev, 0x001f, 0x0000); /* Same */
2279 cit_model3_Packet1(gspca_dev, 0x0039, 0x001f); /* Same */
2280 cit_model3_Packet1(gspca_dev, 0x003b, 0x003c); /* Same */
2281 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2282 cit_model3_Packet1(gspca_dev, 0x0051, 0x000b);
2283 break;
2284 case 640:
2285 cit_model3_Packet1(gspca_dev, 0x001f, 0x0002); /* !Same */
2286 cit_model3_Packet1(gspca_dev, 0x0039, 0x003e); /* !Same */
2287 cit_model3_Packet1(gspca_dev, 0x0040, 0x0008);
2288 cit_model3_Packet1(gspca_dev, 0x0051, 0x000a);
2289 break;
2290 }
2291
2292 /* if (sd->input_index) { */
2293 if (rca_input) {
2294 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2295 if (rca_initdata[i][0])
2296 cit_read_reg(gspca_dev, rca_initdata[i][2]);
2297 else
2298 cit_write_reg(gspca_dev, rca_initdata[i][1],
2299 rca_initdata[i][2]);
2300 }
2301 }
2302
2303 return 0;
2304 }
2305
2306 static int cit_start_model4(struct gspca_dev *gspca_dev)
2307 {
2308 struct sd *sd = (struct sd *) gspca_dev;
2309
2310 cit_write_reg(gspca_dev, 0x0000, 0x0100);
2311 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2312 cit_write_reg(gspca_dev, 0x00bc, 0x012c);
2313 cit_write_reg(gspca_dev, 0x0080, 0x012b);
2314 cit_write_reg(gspca_dev, 0x0000, 0x0108);
2315 cit_write_reg(gspca_dev, 0x0001, 0x0133);
2316 cit_write_reg(gspca_dev, 0x009b, 0x010f);
2317 cit_write_reg(gspca_dev, 0x00bb, 0x010f);
2318 cit_model4_Packet1(gspca_dev, 0x0038, 0x0000);
2319 cit_model4_Packet1(gspca_dev, 0x000a, 0x005c);
2320
2321 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2322 cit_write_reg(gspca_dev, 0x0004, 0x012f);
2323 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2324 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2325 cit_write_reg(gspca_dev, 0x00fb, 0x012e);
2326 cit_write_reg(gspca_dev, 0x0000, 0x0130);
2327 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2328 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2329 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2330 cit_write_reg(gspca_dev, 0x000c, 0x0127);
2331 cit_write_reg(gspca_dev, 0x0009, 0x012e);
2332 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2333
2334 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2335 cit_write_reg(gspca_dev, 0x0012, 0x012f);
2336 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2337 cit_write_reg(gspca_dev, 0x0008, 0x0127);
2338 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2339 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2340 cit_write_reg(gspca_dev, 0x002a, 0x012d);
2341 cit_write_reg(gspca_dev, 0x0000, 0x012f);
2342 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2343 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2344 cit_model4_Packet1(gspca_dev, 0x0034, 0x0000);
2345
2346 switch (gspca_dev->width) {
2347 case 128: /* 128x96 */
2348 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2349 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2350 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2351 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2352 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2353 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2354 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2355 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2356 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2357 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2358 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2359 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2360 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2361 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2362 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2363 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2364 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2365 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2366 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2367 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2368 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2369 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2370 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2371 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2372 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2373 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2374 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2375 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2376 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2377 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2378 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2379 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2380 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2381 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2382 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2383 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2384 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2385 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2386 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2387 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2388 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2389 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2390 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2391 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2392 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2393 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2394 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2395 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2396 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2397 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2398 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2399 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2400 sd->sof_len = 2;
2401 break;
2402 case 160: /* 160x120 */
2403 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2404 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2405 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2406 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2407 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2408 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2409 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2410 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2411 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2412 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2413 cit_write_reg(gspca_dev, 0x000b, 0x0127);
2414 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2415 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2416 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2417 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2418 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2419 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2420 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2421 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2422 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2423 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2424 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2425 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2426 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2427 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2428 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2429 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2430 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2431 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2432 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2433 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2434 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2435 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2436 cit_write_reg(gspca_dev, 0x0025, 0x0127);
2437 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2438 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2439 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2440 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2441 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2442 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2443 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2444 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2445 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2446 cit_write_reg(gspca_dev, 0x0048, 0x0127);
2447 cit_write_reg(gspca_dev, 0x0035, 0x012e);
2448 cit_write_reg(gspca_dev, 0x00d0, 0x0130);
2449 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2450 cit_write_reg(gspca_dev, 0x0048, 0x012d);
2451 cit_write_reg(gspca_dev, 0x0090, 0x012f);
2452 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2453 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2454 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2455 sd->sof_len = 2;
2456 break;
2457 case 176: /* 176x144 */
2458 cit_write_reg(gspca_dev, 0x0038, 0x0119);
2459 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2460 cit_write_reg(gspca_dev, 0x00b9, 0x010a);
2461 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2462 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2463 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2464 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2465 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2466 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2467 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2468 cit_write_reg(gspca_dev, 0x0007, 0x0127);
2469 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2470 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2471 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2472 cit_write_reg(gspca_dev, 0x0001, 0x012f);
2473 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2474 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2475 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2476 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2477 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2478 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2479 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2480 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2481 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2482 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2483 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2484 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2485 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2486 cit_write_reg(gspca_dev, 0x00c7, 0x012e);
2487 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2488 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2489 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2490 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2491 cit_write_reg(gspca_dev, 0x0028, 0x0127);
2492 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2493 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2494 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2495 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2496 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2497 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2498 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2499 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2500 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2501 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2502 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2503 cit_write_reg(gspca_dev, 0x002a, 0x0130);
2504 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2505 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2506 cit_write_reg(gspca_dev, 0x006d, 0x012f);
2507 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2508 cit_write_reg(gspca_dev, 0x0001, 0x0127);
2509 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2510 /* TESTME HDG: this does not seem right
2511 (it is 2 for all other resolutions) */
2512 sd->sof_len = 10;
2513 break;
2514 case 320: /* 320x240 */
2515 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2516 cit_write_reg(gspca_dev, 0x00d0, 0x0111);
2517 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2518 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2519 cit_write_reg(gspca_dev, 0x0028, 0x0103);
2520 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2521 cit_write_reg(gspca_dev, 0x001e, 0x0105);
2522 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2523 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2524 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2525 cit_write_reg(gspca_dev, 0x000a, 0x0127);
2526 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2527 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2528 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2529 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2530 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2531 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2532 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2533 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2534 cit_write_reg(gspca_dev, 0x005a, 0x012d);
2535 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2536 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2537 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2538 cit_write_reg(gspca_dev, 0x0043, 0x0130);
2539 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2540 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2541 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2542 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2543 cit_write_reg(gspca_dev, 0x00eb, 0x012e);
2544 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2545 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2546 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2547 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2548 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2549 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2550 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2551 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2552 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2553 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2554 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2555 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2556 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2557 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2558 cit_write_reg(gspca_dev, 0x0017, 0x0127);
2559 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2560 cit_write_reg(gspca_dev, 0x0031, 0x0130);
2561 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2562 cit_write_reg(gspca_dev, 0x0017, 0x012d);
2563 cit_write_reg(gspca_dev, 0x0078, 0x012f);
2564 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2565 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2566 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2567 sd->sof_len = 2;
2568 break;
2569 case 352: /* 352x288 */
2570 cit_write_reg(gspca_dev, 0x0070, 0x0119);
2571 cit_write_reg(gspca_dev, 0x00c0, 0x0111);
2572 cit_write_reg(gspca_dev, 0x0039, 0x010a);
2573 cit_write_reg(gspca_dev, 0x0001, 0x0102);
2574 cit_write_reg(gspca_dev, 0x002c, 0x0103);
2575 cit_write_reg(gspca_dev, 0x0000, 0x0104);
2576 cit_write_reg(gspca_dev, 0x0024, 0x0105);
2577 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2578 cit_write_reg(gspca_dev, 0x0016, 0x012f);
2579 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2580 cit_write_reg(gspca_dev, 0x0006, 0x0127);
2581 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2582 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2583 cit_write_reg(gspca_dev, 0x0014, 0x012d);
2584 cit_write_reg(gspca_dev, 0x0002, 0x012f);
2585 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2586 cit_write_reg(gspca_dev, 0x00aa, 0x012e);
2587 cit_write_reg(gspca_dev, 0x001a, 0x0130);
2588 cit_write_reg(gspca_dev, 0x8a0a, 0x0124);
2589 cit_write_reg(gspca_dev, 0x005e, 0x012d);
2590 cit_write_reg(gspca_dev, 0x9545, 0x0124);
2591 cit_write_reg(gspca_dev, 0x00aa, 0x0127);
2592 cit_write_reg(gspca_dev, 0x0018, 0x012e);
2593 cit_write_reg(gspca_dev, 0x0049, 0x0130);
2594 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2595 cit_write_reg(gspca_dev, 0x00aa, 0x012f);
2596 cit_write_reg(gspca_dev, 0xd055, 0x0124);
2597 cit_write_reg(gspca_dev, 0x001c, 0x0127);
2598 cit_write_reg(gspca_dev, 0x00cf, 0x012e);
2599 cit_write_reg(gspca_dev, 0xaa28, 0x0124);
2600 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2601 cit_write_reg(gspca_dev, 0x0032, 0x012f);
2602 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2603 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2604 cit_write_reg(gspca_dev, 0x00aa, 0x0130);
2605 cit_write_reg(gspca_dev, 0x82a8, 0x0124);
2606 cit_write_reg(gspca_dev, 0x0036, 0x012d);
2607 cit_write_reg(gspca_dev, 0x0008, 0x012f);
2608 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2609 cit_write_reg(gspca_dev, 0xfffa, 0x0124);
2610 cit_write_reg(gspca_dev, 0x00aa, 0x012d);
2611 cit_write_reg(gspca_dev, 0x001e, 0x012f);
2612 cit_write_reg(gspca_dev, 0xd141, 0x0124);
2613 cit_write_reg(gspca_dev, 0x0010, 0x0127);
2614 cit_write_reg(gspca_dev, 0x0013, 0x012e);
2615 cit_write_reg(gspca_dev, 0x0025, 0x0130);
2616 cit_write_reg(gspca_dev, 0x8a28, 0x0124);
2617 cit_write_reg(gspca_dev, 0x0010, 0x012d);
2618 cit_write_reg(gspca_dev, 0x0048, 0x012f);
2619 cit_write_reg(gspca_dev, 0xd145, 0x0124);
2620 cit_write_reg(gspca_dev, 0x0000, 0x0127);
2621 cit_write_reg(gspca_dev, 0xfea8, 0x0124);
2622 sd->sof_len = 2;
2623 break;
2624 }
2625
2626 cit_model4_Packet1(gspca_dev, 0x0038, 0x0004);
2627
2628 return 0;
2629 }
2630
2631 static int cit_start_ibm_netcam_pro(struct gspca_dev *gspca_dev)
2632 {
2633 const unsigned short compression = 0; /* 0=none, 7=best frame rate */
2634 int i, clock_div;
2635
2636 clock_div = cit_get_clock_div(gspca_dev);
2637 if (clock_div < 0)
2638 return clock_div;
2639
2640 cit_write_reg(gspca_dev, 0x0003, 0x0133);
2641 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2642 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2643 cit_write_reg(gspca_dev, 0x0000, 0x0100);
2644 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2645 /* cit_write_reg(gspca_dev, 0x0002, 0x0112); see sd_stop0 */
2646 cit_write_reg(gspca_dev, 0x0000, 0x0133);
2647 cit_write_reg(gspca_dev, 0x0000, 0x0123);
2648 cit_write_reg(gspca_dev, 0x0001, 0x0117);
2649 cit_write_reg(gspca_dev, 0x0040, 0x0108);
2650 cit_write_reg(gspca_dev, 0x0019, 0x012c);
2651 cit_write_reg(gspca_dev, 0x0060, 0x0116);
2652 /* cit_write_reg(gspca_dev, 0x000b, 0x0115); see sd_stop0 */
2653
2654 cit_model3_Packet1(gspca_dev, 0x0049, 0x0000);
2655
2656 cit_write_reg(gspca_dev, 0x0000, 0x0101); /* Same on 160x120, 320x240 */
2657 cit_write_reg(gspca_dev, 0x003a, 0x0102); /* Hstart */
2658 cit_write_reg(gspca_dev, 0x00a0, 0x0103); /* Same on 160x120, 320x240 */
2659 cit_write_reg(gspca_dev, 0x0078, 0x0105); /* Same on 160x120, 320x240 */
2660 cit_write_reg(gspca_dev, 0x0000, 0x010a); /* Same */
2661 cit_write_reg(gspca_dev, 0x0002, 0x011d); /* Same on 160x120, 320x240 */
2662 cit_write_reg(gspca_dev, 0x0000, 0x0129); /* Same */
2663 cit_write_reg(gspca_dev, 0x00fc, 0x012b); /* Same */
2664 cit_write_reg(gspca_dev, 0x0022, 0x012a); /* Same */
2665
2666 switch (gspca_dev->width) {
2667 case 160: /* 160x120 */
2668 cit_write_reg(gspca_dev, 0x0024, 0x010b);
2669 cit_write_reg(gspca_dev, 0x0089, 0x0119);
2670 cit_write_reg(gspca_dev, 0x000a, 0x011b);
2671 cit_write_reg(gspca_dev, 0x0003, 0x011e);
2672 cit_write_reg(gspca_dev, 0x0007, 0x0104);
2673 cit_write_reg(gspca_dev, 0x0009, 0x011a);
2674 cit_write_reg(gspca_dev, 0x008b, 0x011c);
2675 cit_write_reg(gspca_dev, 0x0008, 0x0118);
2676 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2677 break;
2678 case 320: /* 320x240 */
2679 cit_write_reg(gspca_dev, 0x0028, 0x010b);
2680 cit_write_reg(gspca_dev, 0x00d9, 0x0119);
2681 cit_write_reg(gspca_dev, 0x0006, 0x011b);
2682 cit_write_reg(gspca_dev, 0x0000, 0x011e);
2683 cit_write_reg(gspca_dev, 0x000e, 0x0104);
2684 cit_write_reg(gspca_dev, 0x0004, 0x011a);
2685 cit_write_reg(gspca_dev, 0x003f, 0x011c);
2686 cit_write_reg(gspca_dev, 0x000c, 0x0118);
2687 cit_write_reg(gspca_dev, 0x0000, 0x0132);
2688 break;
2689 }
2690
2691 cit_model3_Packet1(gspca_dev, 0x0019, 0x0031);
2692 cit_model3_Packet1(gspca_dev, 0x001a, 0x0003);
2693 cit_model3_Packet1(gspca_dev, 0x001b, 0x0038);
2694 cit_model3_Packet1(gspca_dev, 0x001c, 0x0000);
2695 cit_model3_Packet1(gspca_dev, 0x0024, 0x0001);
2696 cit_model3_Packet1(gspca_dev, 0x0027, 0x0001);
2697 cit_model3_Packet1(gspca_dev, 0x002a, 0x0004);
2698 cit_model3_Packet1(gspca_dev, 0x0035, 0x000b);
2699 cit_model3_Packet1(gspca_dev, 0x003f, 0x0001);
2700 cit_model3_Packet1(gspca_dev, 0x0044, 0x0000);
2701 cit_model3_Packet1(gspca_dev, 0x0054, 0x0000);
2702 cit_model3_Packet1(gspca_dev, 0x00c4, 0x0000);
2703 cit_model3_Packet1(gspca_dev, 0x00e7, 0x0001);
2704 cit_model3_Packet1(gspca_dev, 0x00e9, 0x0001);
2705 cit_model3_Packet1(gspca_dev, 0x00ee, 0x0000);
2706 cit_model3_Packet1(gspca_dev, 0x00f3, 0x00c0);
2707
2708 cit_write_reg(gspca_dev, compression, 0x0109);
2709 cit_write_reg(gspca_dev, clock_div, 0x0111);
2710
2711 /* if (sd->input_index) { */
2712 if (rca_input) {
2713 for (i = 0; i < ARRAY_SIZE(rca_initdata); i++) {
2714 if (rca_initdata[i][0])
2715 cit_read_reg(gspca_dev, rca_initdata[i][2]);
2716 else
2717 cit_write_reg(gspca_dev, rca_initdata[i][1],
2718 rca_initdata[i][2]);
2719 }
2720 }
2721
2722 return 0;
2723 }
2724
2725 /* -- start the camera -- */
2726 static int sd_start(struct gspca_dev *gspca_dev)
2727 {
2728 struct sd *sd = (struct sd *) gspca_dev;
2729 int packet_size;
2730
2731 packet_size = cit_get_packet_size(gspca_dev);
2732 if (packet_size < 0)
2733 return packet_size;
2734
2735 switch (sd->model) {
2736 case CIT_MODEL0:
2737 cit_start_model0(gspca_dev);
2738 break;
2739 case CIT_MODEL1:
2740 cit_start_model1(gspca_dev);
2741 break;
2742 case CIT_MODEL2:
2743 cit_start_model2(gspca_dev);
2744 break;
2745 case CIT_MODEL3:
2746 cit_start_model3(gspca_dev);
2747 break;
2748 case CIT_MODEL4:
2749 cit_start_model4(gspca_dev);
2750 break;
2751 case CIT_IBM_NETCAM_PRO:
2752 cit_start_ibm_netcam_pro(gspca_dev);
2753 break;
2754 }
2755
2756 cit_set_brightness(gspca_dev);
2757 cit_set_contrast(gspca_dev);
2758 cit_set_hue(gspca_dev);
2759 cit_set_sharpness(gspca_dev);
2760 cit_set_lighting(gspca_dev);
2761 cit_set_hflip(gspca_dev);
2762
2763 /* Program max isoc packet size */
2764 cit_write_reg(gspca_dev, packet_size >> 8, 0x0106);
2765 cit_write_reg(gspca_dev, packet_size & 0xff, 0x0107);
2766
2767 cit_restart_stream(gspca_dev);
2768
2769 return 0;
2770 }
2771
2772 static int sd_isoc_nego(struct gspca_dev *gspca_dev)
2773 {
2774 int ret, packet_size;
2775 struct usb_host_interface *alt;
2776
2777 alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
2778 packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
2779 packet_size -= 100;
2780 if (packet_size < 300)
2781 return -EIO;
2782 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(packet_size);
2783
2784 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
2785 if (ret < 0)
2786 err("set alt 1 err %d", ret);
2787
2788 return ret;
2789 }
2790
2791 static void sd_stopN(struct gspca_dev *gspca_dev)
2792 {
2793 cit_write_reg(gspca_dev, 0x0000, 0x010c);
2794 }
2795
2796 static void sd_stop0(struct gspca_dev *gspca_dev)
2797 {
2798 struct sd *sd = (struct sd *) gspca_dev;
2799 struct usb_host_interface *alt;
2800
2801 /* We cannot use gspca_dev->present here as that is not set when
2802 sd_init gets called and we get called from sd_init */
2803 if (!gspca_dev->dev)
2804 return;
2805
2806 alt = &gspca_dev->dev->config->intf_cache[0]->altsetting[1];
2807
2808 switch (sd->model) {
2809 case CIT_MODEL0:
2810 /* HDG windows does this, but it causes the cams autogain to
2811 restart from a gain of 0, which does not look good when
2812 changing resolutions. */
2813 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2814 cit_write_reg(gspca_dev, 0x00c0, 0x0100); /* LED Off */
2815 break;
2816 case CIT_MODEL1:
2817 cit_send_FF_04_02(gspca_dev);
2818 cit_read_reg(gspca_dev, 0x0100);
2819 cit_write_reg(gspca_dev, 0x81, 0x0100); /* LED Off */
2820 break;
2821 case CIT_MODEL2:
2822 case CIT_MODEL4:
2823 cit_model2_Packet1(gspca_dev, 0x0030, 0x0004);
2824
2825 cit_write_reg(gspca_dev, 0x0080, 0x0100); /* LED Off */
2826 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2827 cit_write_reg(gspca_dev, 0x00a0, 0x0111);
2828
2829 cit_model2_Packet1(gspca_dev, 0x0030, 0x0002);
2830
2831 cit_write_reg(gspca_dev, 0x0020, 0x0111);
2832 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2833 break;
2834 case CIT_MODEL3:
2835 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2836 cit_model3_Packet1(gspca_dev, 0x0046, 0x0000);
2837 cit_read_reg(gspca_dev, 0x0116);
2838 cit_write_reg(gspca_dev, 0x0064, 0x0116);
2839 cit_read_reg(gspca_dev, 0x0115);
2840 cit_write_reg(gspca_dev, 0x0003, 0x0115);
2841 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2842 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2843 cit_write_reg(gspca_dev, 0x0000, 0x0112);
2844 cit_write_reg(gspca_dev, 0x0080, 0x0100);
2845 break;
2846 case CIT_IBM_NETCAM_PRO:
2847 cit_model3_Packet1(gspca_dev, 0x0049, 0x00ff);
2848 cit_write_reg(gspca_dev, 0x0006, 0x012c);
2849 cit_write_reg(gspca_dev, 0x0000, 0x0116);
2850 /* HDG windows does this, but I cannot get the camera
2851 to restart with this without redoing the entire init
2852 sequence which makes switching modes really slow */
2853 /* cit_write_reg(gspca_dev, 0x0006, 0x0115); */
2854 cit_write_reg(gspca_dev, 0x0008, 0x0123);
2855 cit_write_reg(gspca_dev, 0x0000, 0x0117);
2856 cit_write_reg(gspca_dev, 0x0003, 0x0133);
2857 cit_write_reg(gspca_dev, 0x0000, 0x0111);
2858 /* HDG windows does this, but I get a green picture when
2859 restarting the stream after this */
2860 /* cit_write_reg(gspca_dev, 0x0000, 0x0112); */
2861 cit_write_reg(gspca_dev, 0x00c0, 0x0100);
2862
2863 /* Start isoc bandwidth "negotiation" at max isoc bandwith
2864 next stream start */
2865 alt->endpoint[0].desc.wMaxPacketSize = cpu_to_le16(1022);
2866 break;
2867 }
2868 }
2869
2870 static u8 *cit_find_sof(struct gspca_dev *gspca_dev, u8 *data, int len)
2871 {
2872 struct sd *sd = (struct sd *) gspca_dev;
2873 u8 byte3 = 0, byte4 = 0;
2874 int i;
2875
2876 switch (sd->model) {
2877 case CIT_MODEL0:
2878 case CIT_MODEL1:
2879 case CIT_MODEL3:
2880 case CIT_IBM_NETCAM_PRO:
2881 switch (gspca_dev->width) {
2882 case 160: /* 160x120 */
2883 byte3 = 0x02;
2884 byte4 = 0x0a;
2885 break;
2886 case 176: /* 176x144 */
2887 byte3 = 0x02;
2888 byte4 = 0x0e;
2889 break;
2890 case 320: /* 320x240 */
2891 byte3 = 0x02;
2892 byte4 = 0x08;
2893 break;
2894 case 352: /* 352x288 */
2895 byte3 = 0x02;
2896 byte4 = 0x00;
2897 break;
2898 case 640:
2899 byte3 = 0x03;
2900 byte4 = 0x08;
2901 break;
2902 }
2903
2904 /* These have a different byte3 */
2905 if (sd->model <= CIT_MODEL1)
2906 byte3 = 0x00;
2907
2908 for (i = 0; i < len; i++) {
2909 /* For this model the SOF always starts at offset 0
2910 so no need to search the entire frame */
2911 if (sd->model == CIT_MODEL0 && sd->sof_read != i)
2912 break;
2913
2914 switch (sd->sof_read) {
2915 case 0:
2916 if (data[i] == 0x00)
2917 sd->sof_read++;
2918 break;
2919 case 1:
2920 if (data[i] == 0xff)
2921 sd->sof_read++;
2922 else if (data[i] == 0x00)
2923 sd->sof_read = 1;
2924 else
2925 sd->sof_read = 0;
2926 break;
2927 case 2:
2928 if (data[i] == byte3)
2929 sd->sof_read++;
2930 else if (data[i] == 0x00)
2931 sd->sof_read = 1;
2932 else
2933 sd->sof_read = 0;
2934 break;
2935 case 3:
2936 if (data[i] == byte4) {
2937 sd->sof_read = 0;
2938 return data + i + (sd->sof_len - 3);
2939 }
2940 if (byte3 == 0x00 && data[i] == 0xff)
2941 sd->sof_read = 2;
2942 else if (data[i] == 0x00)
2943 sd->sof_read = 1;
2944 else
2945 sd->sof_read = 0;
2946 break;
2947 }
2948 }
2949 break;
2950 case CIT_MODEL2:
2951 case CIT_MODEL4:
2952 /* TESTME we need to find a longer sof signature to avoid
2953 false positives */
2954 for (i = 0; i < len; i++) {
2955 switch (sd->sof_read) {
2956 case 0:
2957 if (data[i] == 0x00)
2958 sd->sof_read++;
2959 break;
2960 case 1:
2961 sd->sof_read = 0;
2962 if (data[i] == 0xff) {
2963 if (i >= 4)
2964 PDEBUG(D_FRAM,
2965 "header found at offset: %d: %02x %02x 00 %02x %02x %02x\n",
2966 i - 1,
2967 data[i - 4],
2968 data[i - 3],
2969 data[i],
2970 data[i + 1],
2971 data[i + 2]);
2972 else
2973 PDEBUG(D_FRAM,
2974 "header found at offset: %d: 00 %02x %02x %02x\n",
2975 i - 1,
2976 data[i],
2977 data[i + 1],
2978 data[i + 2]);
2979 return data + i + (sd->sof_len - 1);
2980 }
2981 break;
2982 }
2983 }
2984 break;
2985 }
2986 return NULL;
2987 }
2988
2989 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
2990 u8 *data, int len)
2991 {
2992 struct sd *sd = (struct sd *) gspca_dev;
2993 unsigned char *sof;
2994
2995 sof = cit_find_sof(gspca_dev, data, len);
2996 if (sof) {
2997 int n;
2998
2999 /* finish decoding current frame */
3000 n = sof - data;
3001 if (n > sd->sof_len)
3002 n -= sd->sof_len;
3003 else
3004 n = 0;
3005 gspca_frame_add(gspca_dev, LAST_PACKET,
3006 data, n);
3007 gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
3008 len -= sof - data;
3009 data = sof;
3010 }
3011
3012 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
3013 }
3014
3015 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
3016 {
3017 struct sd *sd = (struct sd *) gspca_dev;
3018
3019 sd->brightness = val;
3020 if (gspca_dev->streaming) {
3021 if (sd->stop_on_control_change)
3022 sd_stopN(gspca_dev);
3023 cit_set_brightness(gspca_dev);
3024 if (sd->stop_on_control_change)
3025 cit_restart_stream(gspca_dev);
3026 }
3027
3028 return 0;
3029 }
3030
3031 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
3032 {
3033 struct sd *sd = (struct sd *) gspca_dev;
3034
3035 *val = sd->brightness;
3036
3037 return 0;
3038 }
3039
3040 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
3041 {
3042 struct sd *sd = (struct sd *) gspca_dev;
3043
3044 sd->contrast = val;
3045 if (gspca_dev->streaming) {
3046 if (sd->stop_on_control_change)
3047 sd_stopN(gspca_dev);
3048 cit_set_contrast(gspca_dev);
3049 if (sd->stop_on_control_change)
3050 cit_restart_stream(gspca_dev);
3051 }
3052
3053 return 0;
3054 }
3055
3056 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
3057 {
3058 struct sd *sd = (struct sd *) gspca_dev;
3059
3060 *val = sd->contrast;
3061
3062 return 0;
3063 }
3064
3065 static int sd_sethue(struct gspca_dev *gspca_dev, __s32 val)
3066 {
3067 struct sd *sd = (struct sd *) gspca_dev;
3068
3069 sd->hue = val;
3070 if (gspca_dev->streaming) {
3071 if (sd->stop_on_control_change)
3072 sd_stopN(gspca_dev);
3073 cit_set_hue(gspca_dev);
3074 if (sd->stop_on_control_change)
3075 cit_restart_stream(gspca_dev);
3076 }
3077 return 0;
3078 }
3079
3080 static int sd_gethue(struct gspca_dev *gspca_dev, __s32 *val)
3081 {
3082 struct sd *sd = (struct sd *) gspca_dev;
3083
3084 *val = sd->hue;
3085
3086 return 0;
3087 }
3088
3089 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
3090 {
3091 struct sd *sd = (struct sd *) gspca_dev;
3092
3093 sd->sharpness = val;
3094 if (gspca_dev->streaming) {
3095 if (sd->stop_on_control_change)
3096 sd_stopN(gspca_dev);
3097 cit_set_sharpness(gspca_dev);
3098 if (sd->stop_on_control_change)
3099 cit_restart_stream(gspca_dev);
3100 }
3101 return 0;
3102 }
3103
3104 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
3105 {
3106 struct sd *sd = (struct sd *) gspca_dev;
3107
3108 *val = sd->sharpness;
3109
3110 return 0;
3111 }
3112
3113 static int sd_setlighting(struct gspca_dev *gspca_dev, __s32 val)
3114 {
3115 struct sd *sd = (struct sd *) gspca_dev;
3116
3117 sd->lighting = val;
3118 if (gspca_dev->streaming) {
3119 if (sd->stop_on_control_change)
3120 sd_stopN(gspca_dev);
3121 cit_set_lighting(gspca_dev);
3122 if (sd->stop_on_control_change)
3123 cit_restart_stream(gspca_dev);
3124 }
3125 return 0;
3126 }
3127
3128 static int sd_getlighting(struct gspca_dev *gspca_dev, __s32 *val)
3129 {
3130 struct sd *sd = (struct sd *) gspca_dev;
3131
3132 *val = sd->lighting;
3133
3134 return 0;
3135 }
3136
3137 static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val)
3138 {
3139 struct sd *sd = (struct sd *) gspca_dev;
3140
3141 sd->hflip = val;
3142 if (gspca_dev->streaming) {
3143 if (sd->stop_on_control_change)
3144 sd_stopN(gspca_dev);
3145 cit_set_hflip(gspca_dev);
3146 if (sd->stop_on_control_change)
3147 cit_restart_stream(gspca_dev);
3148 }
3149 return 0;
3150 }
3151
3152 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val)
3153 {
3154 struct sd *sd = (struct sd *) gspca_dev;
3155
3156 *val = sd->hflip;
3157
3158 return 0;
3159 }
3160
3161
3162 /* sub-driver description */
3163 static const struct sd_desc sd_desc = {
3164 .name = MODULE_NAME,
3165 .ctrls = sd_ctrls,
3166 .nctrls = ARRAY_SIZE(sd_ctrls),
3167 .config = sd_config,
3168 .init = sd_init,
3169 .start = sd_start,
3170 .stopN = sd_stopN,
3171 .stop0 = sd_stop0,
3172 .pkt_scan = sd_pkt_scan,
3173 };
3174
3175 static const struct sd_desc sd_desc_isoc_nego = {
3176 .name = MODULE_NAME,
3177 .ctrls = sd_ctrls,
3178 .nctrls = ARRAY_SIZE(sd_ctrls),
3179 .config = sd_config,
3180 .init = sd_init,
3181 .start = sd_start,
3182 .isoc_nego = sd_isoc_nego,
3183 .stopN = sd_stopN,
3184 .stop0 = sd_stop0,
3185 .pkt_scan = sd_pkt_scan,
3186 };
3187
3188 /* -- module initialisation -- */
3189 static const __devinitdata struct usb_device_id device_table[] = {
3190 { USB_DEVICE_VER(0x0545, 0x8080, 0x0001, 0x0001), .driver_info = CIT_MODEL0 },
3191 { USB_DEVICE_VER(0x0545, 0x8080, 0x0002, 0x0002), .driver_info = CIT_MODEL1 },
3192 { USB_DEVICE_VER(0x0545, 0x8080, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3193 { USB_DEVICE_VER(0x0545, 0x8080, 0x0301, 0x0301), .driver_info = CIT_MODEL3 },
3194 { USB_DEVICE_VER(0x0545, 0x8002, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3195 { USB_DEVICE_VER(0x0545, 0x800c, 0x030a, 0x030a), .driver_info = CIT_MODEL2 },
3196 { USB_DEVICE_VER(0x0545, 0x800d, 0x030a, 0x030a), .driver_info = CIT_MODEL4 },
3197 {}
3198 };
3199 MODULE_DEVICE_TABLE(usb, device_table);
3200
3201 /* -- device connect -- */
3202 static int sd_probe(struct usb_interface *intf,
3203 const struct usb_device_id *id)
3204 {
3205 const struct sd_desc *desc = &sd_desc;
3206
3207 switch (id->driver_info) {
3208 case CIT_MODEL0:
3209 case CIT_MODEL1:
3210 if (intf->cur_altsetting->desc.bInterfaceNumber != 2)
3211 return -ENODEV;
3212 break;
3213 case CIT_MODEL2:
3214 case CIT_MODEL4:
3215 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3216 return -ENODEV;
3217 break;
3218 case CIT_MODEL3:
3219 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
3220 return -ENODEV;
3221 /* FIXME this likely applies to all model3 cams and probably
3222 to other models too. */
3223 if (ibm_netcam_pro)
3224 desc = &sd_desc_isoc_nego;
3225 break;
3226 }
3227
3228 return gspca_dev_probe2(intf, id, desc, sizeof(struct sd), THIS_MODULE);
3229 }
3230
3231 static struct usb_driver sd_driver = {
3232 .name = MODULE_NAME,
3233 .id_table = device_table,
3234 .probe = sd_probe,
3235 .disconnect = gspca_disconnect,
3236 #ifdef CONFIG_PM
3237 .suspend = gspca_suspend,
3238 .resume = gspca_resume,
3239 #endif
3240 };
3241
3242 /* -- module insert / remove -- */
3243 static int __init sd_mod_init(void)
3244 {
3245 return usb_register(&sd_driver);
3246 }
3247 static void __exit sd_mod_exit(void)
3248 {
3249 usb_deregister(&sd_driver);
3250 }
3251
3252 module_init(sd_mod_init);
3253 module_exit(sd_mod_exit);
Linux kernel - Deliverables
This page took 0.147717 seconds and 5 git commands to generate.