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