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