?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correcting code style for the rest
[microdia.git] / microdia-dev.c
blob69dce8d69e497c162e21301f74b8c61963893edc
1 /**
2 * @file microdia-dev.c
3 * @author Nicolas VIVIEN
4 * @date 2008-02-01
5 * @version v0.0.0
6 *
7 * @brief Driver for Microdia USB video camera
8 *
9 * @note Copyright (C) Nicolas VIVIEN
10 *
11 * @par Licences
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28 #include <linux/errno.h>
29 #include <linux/string.h>
30 #include <stdarg.h>
31
32 #include "microdia.h"
33 #include "sn9c20x.h"
34 #include "ov7670.h"
35 #include "ov965x.h"
36 #include "mt9vx11.h"
37 #include "ov7660.h"
38
39 int dev_microdia_init_camera(struct usb_microdia *dev)
40 {
41 return 0;
42 }
43
44 int dev_microdia_camera_on(struct usb_microdia *dev)
45 {
46 int ret = -1;
47 struct usb_device *udev = dev->udev;
48
49 ret = usb_set_interface(udev, 0, 8);
50
51 if (ret < 0)
52 UDIA_ERROR("usb_set_interface failed !\n");
53
54 return ret;
55 }
56
57 int dev_microdia_camera_off(struct usb_microdia *dev)
58 {
59 int ret = -1;
60 struct usb_device *udev = dev->udev;
61
62 ret = usb_set_interface(udev, 0, 0);
63
64 if (ret < 0)
65 UDIA_ERROR("usb_set_interface failed !\n");
66
67 return 0;
68 }
69
70 int dev_microdia_camera_settings(struct usb_microdia *dev)
71 {
72 dev_microdia_camera_set_contrast(dev);
73 dev_microdia_camera_set_brightness(dev);
74 dev_microdia_camera_set_gamma(dev);
75 dev_microdia_camera_set_exposure(dev);
76 dev_microdia_camera_set_hvflip(dev);
77 dev_microdia_camera_set_sharpness(dev);
78 dev_microdia_camera_set_rgb_gain(dev);
79 dev_microdia_camera_set_auto_exposure(dev);
80 dev_microdia_camera_set_auto_whitebalance(dev);
81 return 0;
82 }
83
84 int dev_microdia_camera_set_contrast(struct usb_microdia *dev)
85 {
86 int ret = -ENODEV;
87 if (dev && dev->set_contrast)
88 ret = dev->set_contrast(dev);
89 return ret;
90 }
91
92 int dev_microdia_camera_set_brightness(struct usb_microdia *dev)
93 {
94 int ret = -ENODEV;
95 if (dev && dev->set_brightness)
96 ret = dev->set_brightness(dev);
97 return ret;
98 }
99
100 int dev_microdia_camera_set_gamma(struct usb_microdia *dev)
101 {
102 int ret = -ENODEV;
103 if (dev && dev->set_gamma)
104 ret = dev->set_gamma(dev);
105 return ret;
106 }
107
108 int dev_microdia_camera_set_exposure(struct usb_microdia *dev)
109 {
110 if (dev->set_exposure != NULL)
111 return dev->set_exposure(dev);
112
113 return 0;
114 }
115
116 int dev_microdia_camera_set_hvflip(struct usb_microdia *dev)
117 {
118 int ret = -ENODEV;
119 if (dev && dev->set_hvflip)
120 ret = dev->set_hvflip(dev);
121
122 return ret;
123 }
124
125 int dev_microdia_camera_set_sharpness(struct usb_microdia *dev)
126 {
127 int ret = -ENODEV;
128 if (dev && dev->set_sharpness)
129 ret = dev->set_sharpness(dev);
130
131 return ret;
132 }
133
134 int dev_microdia_camera_set_rgb_gain(struct usb_microdia *dev)
135 {
136 int ret = -ENODEV;
137 if (dev && dev->set_rgb_gain)
138 ret = dev->set_rgb_gain(dev);
139
140 return ret;
141 }
142
143 int dev_microdia_camera_set_auto_exposure(struct usb_microdia *dev)
144 {
145 int ret = -ENODEV;
146 if (dev && dev->set_auto_exposure)
147 ret = dev->set_auto_exposure(dev);
148
149 return ret;
150 }
151
152 int dev_microdia_camera_set_auto_whitebalance(struct usb_microdia *dev)
153 {
154 int ret = -ENODEV;
155 if (dev && dev->set_auto_whitebalance)
156 ret = dev->set_auto_whitebalance(dev);
157
158 return ret;
159 }
160
161
162 /**
163 * @brief From UsbSnoop-plugin-parsed.log
164 *
165 * @param dev
166 *
167 * @returns
168 */
169 int dev_microdia_initialize_device(struct usb_microdia *dev)
170 {
171 int ret = -ENODEV;
172
173 if (dev && dev->initialize)
174 ret = dev->initialize(dev);
175
176 return ret;
177 }
178
179 /**
180 * @brief From init-physical-replug.log
181 *
182 * @param dev
183 *
184 * @returns 0
185 *
186 * @author psnel
187 *
188 * For SN9C201 with MI1300.
189 *
190 */
191 int microdia_6240_initialize(struct usb_microdia *dev)
192 {
193 int ret = 0;
194 __u8 buf;
195
196 UDIA_INFO("Initializing camera...\n");
197
198 ret = usb_microdia_control_read(dev, 0x130d, &buf, 1); /* URB 5 0x81 */
199 UDIA_INFO("...init: read %x, ret = %d\n", buf, ret);
200
201 ret += usb_microdia_control_read(dev, 0x1040, &buf, 1); /* URB 6 0xe4 */
202 UDIA_INFO("...init: read %x, ret = %d\n", buf, ret);
203
204 buf = 0x00;
205 ret += usb_microdia_control_write(dev, 0x10c8, &buf, 1); /* URB 7 */
206 UDIA_INFO("...init: write %x, ret = %d\n", buf, ret);
207
208 /* Interrupt going down (URB 8) */
209
210 buf = 0x80;
211 ret += usb_microdia_control_write(dev, 0x1020, &buf, 1); /* URB 9 */
212 UDIA_INFO("...init: write %x, ret = %d\n", buf, ret);
213
214 if (ret < 4) {
215 UDIA_ERROR("One or more errors occured during initialization!\n");
216 return -1;
217 }
218
219 return 0;
220 }
221
222 /**
223 * @brief From start.log (14 jun 2008)
224 *
225 * @param dev
226 *
227 * @returns 0
228 *
229 * @author psnel
230 *
231 * For SN9C201 with MI1300.
232 *
233 */
234 int microdia_6240_start_stream(struct usb_microdia *dev)
235 {
236 int ret = 0;
237 int i;
238 __u16 reg;
239 __u8 buf;
240 __u8 buf24[24];
241 __u8 buf64[64];
242 __u8 buf1100[64] = { 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
243 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
244 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
245 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
246 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
247 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
248 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
249 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54
250 };
251 UDIA_INFO("Starting camera data stream...\n");
252
253 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
254 // URB 10 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 8
255 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
256 reg = 0x1066;
257 buf = 0x00;
258 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 12 */
259 if (ret < 0)
260 goto err;
261
262 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
263 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
264
265 reg = 0x1007;
266 buf = 0x20;
267 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 14 */
268 if (ret < 0)
269 goto err;
270 reg = 0x1006;
271 buf = 0x00;
272 ret = usb_microdia_control_write(dev, reg, &buf, 1);
273 if (ret < 0)
274 goto err;
275 reg = 0x1000;
276 buf = 0x78;
277 ret = usb_microdia_control_write(dev, reg, &buf, 1);
278 if (ret < 0)
279 goto err;
280
281 reg = 0x1001;
282 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* cf */
283 if (ret < 0)
284 goto err;
285
286 reg = 0x1001;
287 buf = 0xc7;
288 ret = usb_microdia_control_write(dev, reg, &buf, 1);
289 if (ret < 0)
290 goto err;
291 reg = 0x1002;
292 buf = 0x18;
293 ret = usb_microdia_control_write(dev, reg, &buf, 1);
294 if (ret < 0)
295 goto err;
296
297 reg = 0x1007;
298 ret = usb_microdia_control_read(dev, reg, buf24, 7); /* URB 20 << 20 00 ff 81 00 00 00 */
299 if (ret < 0)
300 goto err;
301
302 reg = 0x1006;
303 buf24[0] = 0x80; buf24[1] = 0xa0;
304 ret = usb_microdia_control_write(dev, reg, buf24, 2);
305 if (ret < 0)
306 goto err;
307 reg = 0x1061;
308 buf = 0x01;
309 ret = usb_microdia_control_write(dev, reg, &buf, 1);
310 if (ret < 0)
311 goto err;
312 reg = 0x1020;
313 buf = 0x80;
314 ret = usb_microdia_control_write(dev, reg, &buf, 1);
315 if (ret < 0)
316 goto err;
317 reg = 0x1067;
318 buf24[0] = 0x40; buf24[1] = 0x30; buf24[2] = 0x20; buf24[3] = 0x10;
319 buf24[4] = 0x08;
320 ret = usb_microdia_control_write(dev, reg, buf24, 5);
321 if (ret < 0)
322 goto err;
323 reg = 0x10c0;
324 buf24[0] = 0x80; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
325 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
326 buf24[8] = 0x03;
327 ret = usb_microdia_control_write(dev, reg, buf24, 9);
328 if (ret < 0)
329 goto err;
330 reg = 0x10e0;
331 buf = 0x45;
332 ret = usb_microdia_control_write(dev, reg, &buf, 1);
333 if (ret < 0)
334 goto err;
335 reg = 0x10f5;
336 buf = 0x60;
337 ret = usb_microdia_control_write(dev, reg, &buf, 1);
338 if (ret < 0)
339 goto err;
340 reg = 0x10f8;
341 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00;
342 ret = usb_microdia_control_write(dev, reg, buf24, 3);
343 if (ret < 0)
344 goto err;
345 reg = 0x10fb;
346 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
347 buf24[4] = 0x00;
348 ret = usb_microdia_control_write(dev, reg, buf24, 5);
349 if (ret < 0)
350 goto err;
351 reg = 0x1188;
352 buf24[0] = 0x06; buf24[1] = 0x4c; buf24[2] = 0x08;
353 ret = usb_microdia_control_write(dev, reg, buf24, 3);
354 if (ret < 0)
355 goto err;
356
357 reg = 0x118b;
358 buf24[0] = 0x00; buf24[1] = 0x20; buf24[2] = 0x20; buf24[3] = 0x20;
359 buf24[4] = 0x20; buf24[5] = 0x00; buf24[6] = 0x24; buf24[7] = 0x3b;
360 buf24[8] = 0x4f; buf24[9] = 0x61; buf24[10] = 0x71; buf24[11] = 0x80;
361 buf24[12] = 0x8f; buf24[13] = 0x9d; buf24[14] = 0xab; buf24[15] = 0xb8;
362
363 buf24[16] = 0xc4; buf24[17] = 0xd1; buf24[18] = 0xdd; buf24[19] = 0xe9;
364 buf24[20] = 0xf4; buf24[21] = 0xff;
365 ret = usb_microdia_control_write(dev, reg, buf24, 22); /* URB 30 */
366 if (ret < 0)
367 goto err;
368
369 reg = 0x11a1;
370 buf24[0] = 0x00; buf24[1] = 0x00;
371 ret = usb_microdia_control_write(dev, reg, buf24, 2);
372 if (ret < 0)
373 goto err;
374
375 reg = 0x11b7;
376 buf24[0] = 0x60; buf24[1] = 0x28; buf24[2] = 0x00; buf24[3] = 0x08;
377 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
378 buf24[8] = 0x00;
379 ret = usb_microdia_control_write(dev, reg, buf24, 9);
380 if (ret < 0)
381 goto err;
382
383 reg = 0x11b8;
384 buf = 0x38;
385 ret = usb_microdia_control_write(dev, reg, &buf, 1);
386 if (ret < 0)
387 goto err;
388
389 reg = 0x1000;
390 buf = 0x78;
391 ret = usb_microdia_control_write(dev, reg, &buf, 1);
392 if (ret < 0)
393 goto err;
394
395 reg = 0x10c0;
396 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
397 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
398 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 35..90 --> */
399 if (ret < 0)
400 goto err;
401
402 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
403 if (ret < 0)
404 goto err;
405 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
406 if (ret < 0)
407 goto err;
408
409 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
410 buf24[4] = 0x01; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
411 ret = usb_microdia_control_write(dev, reg, buf24, 8);
412 if (ret < 0)
413 goto err;
414
415 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
416 if (ret < 0)
417 goto err;
418 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
419 if (ret < 0)
420 goto err;
421
422 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
423 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
424 ret = usb_microdia_control_write(dev, reg, buf24, 8);
425 if (ret < 0)
426 goto err;
427
428 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
429 if (ret < 0)
430 goto err;
431 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
432 if (ret < 0)
433 goto err;
434
435 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x01; buf24[3] = 0x00;
436 buf24[4] = 0x0e; buf24[5] = 0x00; buf24[6] = 0x14; buf24[7] = 0x10;
437 ret = usb_microdia_control_write(dev, reg, buf24, 8);
438 if (ret < 0)
439 goto err;
440
441 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* URB 45 << d0 */
442 if (ret < 0)
443 goto err;
444 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
445 if (ret < 0)
446 goto err;
447
448 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x03; buf24[3] = 0x03;
449 buf24[4] = 0xc1; buf24[5] = 0x05; buf24[6] = 0x01; buf24[7] = 0x10;
450 ret = usb_microdia_control_write(dev, reg, buf24, 8);
451 if (ret < 0)
452 goto err;
453
454 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
455 if (ret < 0)
456 goto err;
457 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
458 if (ret < 0)
459 goto err;
460
461 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
462 buf24[4] = 0x83; buf24[5] = 0x00; buf24[6] = 0x06; buf24[7] = 0x10;
463 ret = usb_microdia_control_write(dev, reg, buf24, 8);
464 if (ret < 0)
465 goto err;
466
467 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
468 if (ret < 0)
469 goto err;
470 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
471 if (ret < 0)
472 goto err;
473
474 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
475 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
476 ret = usb_microdia_control_write(dev, reg, buf24, 8);
477 if (ret < 0)
478 goto err;
479
480 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
481 if (ret < 0)
482 goto err;
483 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
484 if (ret < 0)
485 goto err;
486
487 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x00;
488 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
489 ret = usb_microdia_control_write(dev, reg, buf24, 8);
490 if (ret < 0)
491 goto err;
492
493 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
494 if (ret < 0)
495 goto err;
496 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
497 if (ret < 0)
498 goto err;
499
500 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x0b; buf24[3] = 0x00;
501 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
502 ret = usb_microdia_control_write(dev, reg, buf24, 8);
503 if (ret < 0)
504 goto err;
505
506 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
507 if (ret < 0)
508 goto err;
509 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
510 if (ret < 0)
511 goto err;
512
513 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x11; buf24[3] = 0x00;
514 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
515 ret = usb_microdia_control_write(dev, reg, buf24, 8);
516 if (ret < 0)
517 goto err;
518
519 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
520 if (ret < 0)
521 goto err;
522 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
523 if (ret < 0)
524 goto err;
525
526 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x1e; buf24[3] = 0x80;
527 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
528 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 65 */
529 if (ret < 0)
530 goto err;
531
532 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
533 if (ret < 0)
534 goto err;
535 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
536 if (ret < 0)
537 goto err;
538
539 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
540 buf24[4] = 0x05; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
541 ret = usb_microdia_control_write(dev, reg, buf24, 8);
542 if (ret < 0)
543 goto err;
544
545 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
546 if (ret < 0)
547 goto err;
548 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
549 if (ret < 0)
550 goto err;
551
552 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
553 buf24[4] = 0x08; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
554 ret = usb_microdia_control_write(dev, reg, buf24, 8);
555 if (ret < 0)
556 goto err;
557
558 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
559 if (ret < 0)
560 goto err;
561 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
562 if (ret < 0)
563 goto err;
564
565 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
566 buf24[4] = 0x14; buf24[5] = 0x00; buf24[6] = 0x08; buf24[7] = 0x10;
567 ret = usb_microdia_control_write(dev, reg, buf24, 8);
568 if (ret < 0)
569 goto err;
570
571 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
572 if (ret < 0)
573 goto err;
574 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
575 if (ret < 0)
576 goto err;
577
578 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
579 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
580 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 77 */
581 if (ret < 0)
582 goto err;
583
584 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 94 */
585 if (ret < 0)
586 goto err;
587
588 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x5f; buf24[3] = 0x89;
589 buf24[4] = 0x04; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
590 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 79 */
591 if (ret < 0)
592 goto err;
593
594 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
595 if (ret < 0)
596 goto err;
597 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
598 if (ret < 0)
599 goto err;
600
601 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x60; buf24[3] = 0x00;
602 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
603 ret = usb_microdia_control_write(dev, reg, buf24, 8);
604 if (ret < 0)
605 goto err;
606
607 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
608 if (ret < 0)
609 goto err;
610 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
611 if (ret < 0)
612 goto err;
613
614 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x62; buf24[3] = 0x04;
615 buf24[4] = 0x98; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
616 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 85 */
617 if (ret < 0)
618 goto err;
619
620 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
621 if (ret < 0)
622 goto err;
623 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
624 if (ret < 0)
625 goto err;
626
627 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x68; buf24[3] = 0x00;
628 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
629 ret = usb_microdia_control_write(dev, reg, buf24, 8);
630 if (ret < 0)
631 goto err;
632
633 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
634 if (ret < 0)
635 goto err;
636 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
637 if (ret < 0)
638 goto err;
639 /* <-- 10c0 */
640 reg = 0x10c1;
641 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* URB 91 // << 5d*/
642 if (ret < 0)
643 goto err;
644 buf = 0x50;
645 ret = usb_microdia_control_write(dev, reg, &buf, 1);
646 if (ret < 0)
647 goto err;
648
649 reg = 0x10c0;
650 buf24[0] = 0x90; buf24[1] = 0x50; buf24[2] = 0x00; buf24[3] = 0x00;
651 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
652 for (i = 93; i <= 108; i++) {
653 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 93..108 */
654 if (ret < 0)
655 goto err;
656 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 9c */
657 if (ret < 0)
658 goto err;
659 }
660 ret = usb_microdia_control_write(dev, reg, buf24, 8);
661 if (ret < 0)
662 goto err;
663
664 buf24[0] = 0x92; /* change only 1st value */
665 for (i = 110; i <= 126; i++) {
666 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 110..126 */
667 if (ret < 0)
668 goto err;
669 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 9e */
670 if (ret < 0)
671 goto err;
672 }
673
674 reg = 0x10c2;
675 ret = usb_microdia_control_read(dev, reg, buf24, 5); /* << ff ff ff ff ff */
676 if (ret < 0)
677 goto err;
678
679 reg = 0x10c1;
680 buf = 0x5d;
681 ret = usb_microdia_control_write(dev, reg, &buf, 1);
682 if (ret < 0)
683 goto err;
684
685 reg = 0x10e0;
686 buf = 0x47;
687 ret = usb_microdia_control_write(dev, reg, &buf, 1);
688 if (ret < 0)
689 goto err;
690 buf = 0x07;
691 ret = usb_microdia_control_write(dev, reg, &buf, 1);
692 if (ret < 0)
693 goto err;
694
695 reg = 0x1001;
696 buf = 0xc6;
697 ret = usb_microdia_control_write(dev, reg, &buf, 1);
698 if (ret < 0)
699 goto err;
700 buf = 0xc4;
701 ret = usb_microdia_control_write(dev, reg, &buf, 1);
702 if (ret < 0)
703 goto err;
704 buf = 0x44;
705 ret = usb_microdia_control_write(dev, reg, &buf, 1);
706 if (ret < 0)
707 goto err;
708
709 reg = 0x1189;
710 buf = 0x0c;
711 ret = usb_microdia_control_write(dev, reg, &buf, 1);
712 if (ret < 0)
713 goto err;
714
715 buf = 0x00;
716 reg = 0x11bc;
717 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 135..138 */
718 if (ret < 0)
719 goto err;
720 reg = 0x11bd;
721 ret = usb_microdia_control_write(dev, reg, &buf, 1);
722 if (ret < 0)
723 goto err;
724 reg = 0x11be;
725 ret = usb_microdia_control_write(dev, reg, &buf, 1);
726 if (ret < 0)
727 goto err;
728 reg = 0x11bf;
729 ret = usb_microdia_control_write(dev, reg, &buf, 1);
730 if (ret < 0)
731 goto err;
732
733 reg = 0x10c0;
734 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
735 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
736 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 139 */
737 if (ret < 0)
738 goto err;
739
740 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
741 if (ret < 0)
742 goto err;
743 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
744 if (ret < 0)
745 goto err;
746
747 reg = 0x1180;
748 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
749 buf24[4] = 0x28; buf24[5] = 0x3c;
750 ret = usb_microdia_control_write(dev, reg, buf24, 6); /* URB 142 */
751 if (ret < 0)
752 goto err;
753
754 reg = 0x10fb;
755 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
756 buf24[4] = 0x00;
757 ret = usb_microdia_control_write(dev, reg, buf24, 5);
758 if (ret < 0)
759 goto err;
760
761 reg = 0x1189;
762 buf = 0x0c;
763 ret = usb_microdia_control_write(dev, reg, &buf, 1);
764 if (ret < 0)
765 goto err;
766
767 reg = 0x11a1;
768 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
769 ret = usb_microdia_control_write(dev, reg, buf24, 4);
770 if (ret < 0)
771 goto err;
772
773 reg = 0x11ab;
774 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
775 ret = usb_microdia_control_write(dev, reg, buf24, 4);
776 if (ret < 0)
777 goto err;
778
779 reg = 0x1000;
780 buf = 0x7c;
781 ret = usb_microdia_control_write(dev, reg, &buf, 1);
782 if (ret < 0)
783 goto err;
784
785 reg = 0x1002;
786 buf = 0x1c;
787 for (i = 148; i <= 149; i++) {
788 ret = usb_microdia_control_write(dev, reg, &buf, 1);
789 if (ret < 0)
790 goto err;
791 }
792
793 reg = 0x11b8;
794 buf = 0x38;
795 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 150 */
796 if (ret < 0)
797 goto err;
798
799 reg = 0x118a;
800 buf = 0x05;
801 ret = usb_microdia_control_write(dev, reg, &buf, 1);
802 if (ret < 0)
803 goto err;
804
805 reg = 0x0395;
806 buf = 0x05;
807 ret = usb_microdia_control_write(dev, reg, &buf, 1);
808 if (ret < 0)
809 goto err;
810
811 reg = 0x11b8;
812 buf = 0x78;
813 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 153..163 */
814 if (ret < 0)
815 goto err;
816 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 38 */
817 if (ret < 0)
818 goto err;
819 buf = 0x79;
820 ret = usb_microdia_control_write(dev, reg, &buf, 1);
821 if (ret < 0)
822 goto err;
823 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 39 */
824 if (ret < 0)
825 goto err;
826 buf = 0x7a;
827 ret = usb_microdia_control_write(dev, reg, &buf, 1);
828 if (ret < 0)
829 goto err;
830 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 3a */
831 if (ret < 0)
832 goto err;
833 buf = 0x7b;
834 ret = usb_microdia_control_write(dev, reg, &buf, 1);
835 if (ret < 0)
836 goto err;
837 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << bb */
838 if (ret < 0)
839 goto err;
840 buf = 0xfc;
841 ret = usb_microdia_control_write(dev, reg, &buf, 1);
842 if (ret < 0)
843 goto err;
844 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 3c */
845 if (ret < 0)
846 goto err;
847 buf = 0x78;
848 ret = usb_microdia_control_write(dev, reg, &buf, 1);
849 if (ret < 0)
850 goto err;
851 /* <-- 0x11b8 */
852 reg = 0x10c0;
853 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
854 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
855 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 164..169 */
856 if (ret < 0)
857 goto err;
858
859 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
860 if (ret < 0)
861 goto err;
862 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
863 if (ret < 0)
864 goto err;
865
866 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
867 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
868 ret = usb_microdia_control_write(dev, reg, buf24, 8);
869 if (ret < 0)
870 goto err;
871
872 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
873 if (ret < 0)
874 goto err;
875 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
876 if (ret < 0)
877 goto err;
878 /* <-- 0x10c0 */
879 reg = 0x11ba;
880 buf = 0x0a;
881 ret = usb_microdia_control_write(dev, reg, &buf, 1);
882 if (ret < 0)
883 goto err;
884
885 reg = 0x118b;
886 buf = 0x0a;
887 ret = usb_microdia_control_write(dev, reg, &buf, 1);
888 if (ret < 0)
889 goto err;
890
891 reg = 0x10f7;
892 buf = 0x07;
893 ret = usb_microdia_control_write(dev, reg, &buf, 1);
894 if (ret < 0)
895 goto err;
896
897 reg = 0x10f8;
898 buf = 0x14;
899 ret = usb_microdia_control_write(dev, reg, &buf, 1);
900 if (ret < 0)
901 goto err;
902 reg = 0x10fa;
903 buf = 0xff;
904 ret = usb_microdia_control_write(dev, reg, &buf, 1);
905 if (ret < 0)
906 goto err;
907 reg = 0x10f9;
908 buf = 0x00;
909 ret = usb_microdia_control_write(dev, reg, &buf, 1);
910 if (ret < 0)
911 goto err;
912 reg = 0x10f9;
913 ret = usb_microdia_control_write(dev, reg, &buf, 1);
914 if (ret < 0)
915 goto err;
916
917 reg = 0x11ba;
918 buf = 0x0a;
919 ret = usb_microdia_control_write(dev, reg, &buf, 1);
920 if (ret < 0)
921 goto err;
922
923 reg = 0x11bc;
924 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x00;
925 ret = usb_microdia_control_write(dev, reg, buf24, 4);
926 if (ret < 0)
927 goto err;
928
929 reg = 0x11c0;
930 for (i = 0; i < 48; i++)
931 buf64[i] = 0; /* zeroes */
932 ret = usb_microdia_control_write(dev, reg, buf64, 48); /* URB 195 */
933 if (ret < 0)
934 goto err;
935
936 reg = 0x10c0;
937 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
938 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
939 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 200 */
940 if (ret < 0)
941 goto err;
942
943 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
944 if (ret < 0)
945 goto err;
946 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
947 if (ret < 0)
948 goto err;
949
950 reg = 0x1180;
951 buf = 0x02;
952 ret = usb_microdia_control_write(dev, reg, &buf, 1);
953 if (ret < 0)
954 goto err;
955
956 reg = 0x10c0;
957 /*
958 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
959 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
960 */
961 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 204..206 */
962 if (ret < 0)
963 goto err;
964
965 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
966 if (ret < 0)
967 goto err;
968 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
969 if (ret < 0)
970 goto err;
971
972 reg = 0x1182;
973 buf = 0x02;
974 ret = usb_microdia_control_write(dev, reg, &buf, 1);
975 if (ret < 0)
976 goto err;
977
978 reg = 0x10c0;
979 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x03;
980 buf24[4] = 0xe8; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
981 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 208..224 */
982 if (ret < 0)
983 goto err;
984
985 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
986 if (ret < 0)
987 goto err;
988 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
989 if (ret < 0)
990 goto err;
991
992 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
993 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
994 ret = usb_microdia_control_write(dev, reg, buf24, 8);
995 if (ret < 0)
996 goto err;
997
998 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
999 if (ret < 0)
1000 goto err;
1001 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1002 if (ret < 0)
1003 goto err;
1004
1005 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
1006 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1007 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 214 */
1008 if (ret < 0)
1009 goto err;
1010
1011 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1012 if (ret < 0)
1013 goto err;
1014 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1015 if (ret < 0)
1016 goto err;
1017
1018 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
1019 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1020 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1021 if (ret < 0)
1022 goto err;
1023
1024 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1025 if (ret < 0)
1026 goto err;
1027 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1028 if (ret < 0)
1029 goto err;
1030
1031 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
1032 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1033 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1034 if (ret < 0)
1035 goto err;
1036
1037 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1038 if (ret < 0)
1039 goto err;
1040
1041 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1042 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1043 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1044 if (ret < 0)
1045 goto err;
1046
1047 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1048 if (ret < 0)
1049 goto err;
1050 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1051 if (ret < 0)
1052 goto err;
1053
1054 reg = 0x11a5;
1055 buf24[0] = 0x2d; buf24[1] = 0x2d; buf24[2] = 0x3a; buf24[3] = 0x05;
1056 buf24[4] = 0x04; buf24[5] = 0x3f;
1057 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1058 if (ret < 0)
1059 goto err;
1060 reg = 0x11af;
1061 buf24[0] = 0x28; buf24[1] = 0xd8; buf24[2] = 0x14; buf24[3] = 0xec;
1062 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1063 if (ret < 0)
1064 goto err;
1065 reg = 0x11b3;
1066 buf24[0] = 0x32; buf24[1] = 0xdd; buf24[2] = 0x2d; buf24[3] = 0xdd;
1067 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1068 if (ret < 0)
1069 goto err;
1070
1071 reg = 0x10c0;
1072 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1073 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1074 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 232..242 */
1075 if (ret < 0)
1076 goto err;
1077
1078 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1079 if (ret < 0)
1080 goto err;
1081 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1082 if (ret < 0)
1083 goto err;
1084
1085 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2c; buf24[3] = 0x00;
1086 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x1d; buf24[7] = 0x10;
1087 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1088 if (ret < 0)
1089 goto err;
1090
1091 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1092 if (ret < 0)
1093 goto err;
1094 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1095 if (ret < 0)
1096 goto err;
1097
1098 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x30; buf24[3] = 0x00;
1099 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1100 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1101 if (ret < 0)
1102 goto err;
1103
1104 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1105 if (ret < 0)
1106 goto err;
1107
1108 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1109 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1110 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1111 if (ret < 0)
1112 goto err;
1113
1114 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1115 if (ret < 0)
1116 goto err;
1117 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1118 if (ret < 0)
1119 goto err;
1120
1121 reg = 0x10e0;
1122 buf = 0x07;
1123 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1124 if (ret < 0)
1125 goto err;
1126 buf = 0x27;
1127 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1128 if (ret < 0)
1129 goto err;
1130
1131 reg = 0x1100;
1132 ret = usb_microdia_control_write(dev, reg, buf1100, 64); /* URB 249 (see also 509/510) */
1133 if (ret < 0)
1134 goto err;
1135
1136 reg = 0x1140; /* 00000000: */
1137 buf64[0] = 0x0d; buf64[1] = 0x11; buf64[2] = 0x11; buf64[3] = 0x15;
1138 buf64[4] = 0x11; buf64[5] = 0x15; buf64[6] = 0x26; buf64[7] = 0x15;
1139 buf64[8] = 0x15; buf64[9] = 0x26; buf64[10] = 0x54; buf64[11] = 0x36;
1140 buf64[12] = 0x2e; buf64[13] = 0x36; buf64[14] = 0x54; buf64[15] = 0x54; /* 00000010: .. 00000030: 0x54 */
1141 for (i = 16; i <= 63; i++)
1142 buf64[i] = 0x54;
1143 ret = usb_microdia_control_write(dev, reg, buf64, 64); /* URB 250 */
1144 if (ret < 0)
1145 goto err;
1146
1147 reg = 0x10e0;
1148 buf = 0x07;
1149 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1150 if (ret < 0)
1151 goto err;
1152 buf = 0x0b;
1153 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1154 if (ret < 0)
1155 goto err;
1156
1157 reg = 0x1189;
1158 buf = 0x0c;
1159 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1160 if (ret < 0)
1161 goto err;
1162
1163 buf = 0x00;
1164 reg = 0x11bc;
1165 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 254..257 */
1166 if (ret < 0)
1167 goto err;
1168 reg = 0x11bd;
1169 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1170 if (ret < 0)
1171 goto err;
1172 reg = 0x11be;
1173 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1174 if (ret < 0)
1175 goto err;
1176 reg = 0x11bf;
1177 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1178 if (ret < 0)
1179 goto err;
1180
1181 reg = 0x1180;
1182 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
1183 buf24[4] = 0x28; buf24[5] = 0x3c;
1184 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1185 if (ret < 0)
1186 goto err;
1187
1188 reg = 0x10fb;
1189 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1190 buf24[4] = 0x00;
1191 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1192 if (ret < 0)
1193 goto err;
1194
1195 reg = 0x1189;
1196 buf = 0x0c;
1197 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1198 if (ret < 0)
1199 goto err;
1200
1201 reg = 0x11a1;
1202 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
1203 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1204 if (ret < 0)
1205 goto err;
1206 reg = 0x11ab;
1207 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
1208 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1209 if (ret < 0)
1210 goto err;
1211
1212 reg = 0x1061;
1213 buf = 0x03;
1214 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1215 if (ret < 0)
1216 goto err;
1217 reg = 0x11ba;
1218 buf = 0x0a;
1219 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1220 if (ret < 0)
1221 goto err;
1222 reg = 0x11b9;
1223 buf = 0x00;
1224 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1225 if (ret < 0)
1226 goto err;
1227 reg = 0x11ba;
1228 buf = 0x0b;
1229 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1230 if (ret < 0)
1231 goto err;
1232 reg = 0x1061;
1233 buf = 0x01;
1234 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1235 if (ret < 0)
1236 goto err;
1237 reg = 0x1000;
1238 buf = 0x7c;
1239 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1240 if (ret < 0)
1241 goto err;
1242 reg = 0x1002;
1243 buf = 0x1c;
1244 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1245 if (ret < 0)
1246 goto err;
1247 buf = 0x1c;
1248 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1249 if (ret < 0)
1250 goto err;
1251 reg = 0x11b8;
1252 buf = 0x78;
1253 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1254 if (ret < 0)
1255 goto err;
1256 reg = 0x118a;
1257 buf = 0x05;
1258 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1259 if (ret < 0)
1260 goto err;
1261 reg = 0x0395;
1262 buf = 0x05;
1263 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1264 if (ret < 0)
1265 goto err;
1266
1267 reg = 0x11b8;
1268 buf = 0x78;
1269 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 274..284 */
1270 if (ret < 0)
1271 goto err;
1272 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
1273 if (ret < 0)
1274 goto err;
1275 buf = 0x79;
1276 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1277 if (ret < 0)
1278 goto err;
1279 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
1280 if (ret < 0)
1281 goto err;
1282 buf = 0x7a;
1283 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1284 if (ret < 0)
1285 goto err;
1286 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
1287 if (ret < 0)
1288 goto err;
1289 buf = 0x7b;
1290 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1291 if (ret < 0)
1292 goto err;
1293 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
1294 if (ret < 0)
1295 goto err;
1296 buf = 0xfc;
1297 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1298 if (ret < 0)
1299 goto err;
1300 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
1301 if (ret < 0)
1302 goto err;
1303 buf = 0x78;
1304 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1305 if (ret < 0)
1306 goto err;
1307 /* // <-- 0x11b8 */
1308 reg = 0x10c0;
1309 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
1310 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1311 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 285..295 */
1312 if (ret < 0)
1313 goto err;
1314
1315 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1316 if (ret < 0)
1317 goto err;
1318 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1319 if (ret < 0)
1320 goto err;
1321
1322 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1323 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1324 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1325 if (ret < 0)
1326 goto err;
1327
1328 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1329 if (ret < 0)
1330 goto err;
1331 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1332 if (ret < 0)
1333 goto err;
1334
1335 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
1336 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1337 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1338 if (ret < 0)
1339 goto err;
1340
1341 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1342 if (ret < 0)
1343 goto err;
1344
1345 buf24[0] = 0xa2; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
1346 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1347 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1348 if (ret < 0)
1349 goto err;
1350
1351 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a2 */
1352 if (ret < 0)
1353 goto err;
1354 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a6 */
1355 if (ret < 0)
1356 goto err;
1357 /* // <-- 0x10c0 */
1358 reg = 0x10c2;
1359 ret = usb_microdia_control_read(dev, reg, buf24, 5); /* URB 296 // << 00 00 00 84 31 */
1360 if (ret < 0)
1361 goto err;
1362
1363 reg = 0x1061;
1364 buf = 0x03;
1365 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1366 if (ret < 0)
1367 goto err;
1368 buf = 0x01;
1369 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1370 if (ret < 0)
1371 goto err;
1372
1373 reg = 0x10c0;
1374 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1375 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1376 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1377 if (ret < 0)
1378 goto err;
1379
1380 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1381 if (ret < 0)
1382 goto err;
1383 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1384 if (ret < 0)
1385 goto err;
1386
1387 reg = 0x1000;
1388 buf = 0x3c;
1389 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1390 if (ret < 0)
1391 goto err;
1392 reg = 0x11b8;
1393 buf = 0x68;
1394 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1395 if (ret < 0)
1396 goto err;
1397 reg = 0x1007;
1398 buf = 0xa0;
1399 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1400 if (ret < 0)
1401 goto err;
1402 reg = 0x1006;
1403 buf = 0xa0;
1404 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1405 if (ret < 0)
1406 goto err;
1407
1408 reg = 0x1000;
1409 buf24[0] = 0x98; buf24[1] = 0xef; buf24[2] = 0x11;
1410 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1411 if (ret < 0)
1412 goto err;
1413
1414 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1415 // URB 307 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 0
1416 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1417 */
1418
1419 reg = 0x1066;
1420 buf = 0x00;
1421 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1422 if (ret < 0)
1423 goto err;
1424
1425 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1426 // URB 310 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 8
1427 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1428 */
1429 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 312 */
1430 if (ret < 0)
1431 goto err;
1432
1433 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1434 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1435 */
1436
1437 reg = 0x1007;
1438 buf = 0xa0;
1439 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 314 */
1440 if (ret < 0)
1441 goto err;
1442 reg = 0x1006;
1443 buf = 0x80;
1444 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1445 if (ret < 0)
1446 goto err;
1447 reg = 0x1000;
1448 buf = 0x78;
1449 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1450 if (ret < 0)
1451 goto err;
1452 reg = 0x1001;
1453 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << ef */
1454 if (ret < 0)
1455 goto err;
1456 buf = 0xc7;
1457 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1458 if (ret < 0)
1459 goto err;
1460 reg = 0x1002;
1461 buf = 0x18;
1462 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1463 if (ret < 0)
1464 goto err;
1465
1466 reg = 0x1007;
1467 ret = usb_microdia_control_read(dev, reg, buf24, 7); /* URB 320 // << a0 00 ff 81 00 00 00 */
1468 if (ret < 0)
1469 goto err;
1470 reg = 0x1006;
1471 buf24[0] = 0x80; buf24[1] = 0xa0;
1472 ret = usb_microdia_control_write(dev, reg, buf24, 2);
1473 if (ret < 0)
1474 goto err;
1475
1476 reg = 0x1061;
1477 buf = 0x01;
1478 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1479 if (ret < 0)
1480 goto err;
1481 reg = 0x1020;
1482 buf = 0x80;
1483 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1484 if (ret < 0)
1485 goto err;
1486
1487 reg = 0x1067;
1488 buf24[0] = 0x40; buf24[1] = 0x30; buf24[2] = 0x20; buf24[3] = 0x10;
1489 buf24[4] = 0x08;
1490 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1491 if (ret < 0)
1492 goto err;
1493
1494 reg = 0x10c0;
1495 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1496 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1497 buf24[8] = 0x03;
1498 ret = usb_microdia_control_write(dev, reg, buf24, 9);
1499 if (ret < 0)
1500 goto err;
1501
1502 reg = 0x10e0;
1503 /* // 00000000: */
1504 buf = 0x45;
1505 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1506 if (ret < 0)
1507 goto err;
1508 reg = 0x10f5;
1509 buf = 0x60;
1510 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1511 if (ret < 0)
1512 goto err;
1513
1514 reg = 0x10f8;
1515 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00;
1516 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1517 if (ret < 0)
1518 goto err;
1519
1520 reg = 0x10fb;
1521 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1522 buf24[4] = 0x00;
1523 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1524 if (ret < 0)
1525 goto err;
1526
1527 reg = 0x1188;
1528 buf24[0] = 0x06; buf24[1] = 0x4c; buf24[2] = 0x08;
1529 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1530 if (ret < 0)
1531 goto err;
1532
1533 reg = 0x118b;
1534 /* // 00000000: */
1535 buf24[0] = 0x00; buf24[1] = 0x20; buf24[2] = 0x20; buf24[3] = 0x20;
1536 buf24[4] = 0x20; buf24[5] = 0x00; buf24[6] = 0x24; buf24[7] = 0x3b;
1537 buf24[8] = 0x4f; buf24[9] = 0x61; buf24[10] = 0x71; buf24[11] = 0x80;
1538 buf24[12] = 0x8f; buf24[13] = 0x9d; buf24[14] = 0xab; buf24[15] = 0xb8;
1539 /* // 00000010: */
1540 buf24[16] = 0xc4; buf24[17] = 0xd1; buf24[18] = 0xdd; buf24[19] = 0xe9;
1541 buf24[20] = 0xf4; buf24[21] = 0xff;
1542 ret = usb_microdia_control_write(dev, reg, buf24, 22); /* URB 330 */
1543 if (ret < 0)
1544 goto err;
1545
1546 reg = 0x11a1;
1547 buf24[0] = 0x00; buf24[1] = 0x00;
1548 ret = usb_microdia_control_write(dev, reg, buf24, 2);
1549 if (ret < 0)
1550 goto err;
1551
1552 reg = 0x11b7;
1553 buf24[0] = 0x60; buf24[1] = 0x28; buf24[2] = 0x00; buf24[3] = 0x08;
1554 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
1555 buf24[8] = 0x00;
1556 ret = usb_microdia_control_write(dev, reg, buf24, 9);
1557 if (ret < 0)
1558 goto err;
1559
1560 reg = 0x11b8;
1561 buf = 0x38;
1562 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1563 if (ret < 0)
1564 goto err;
1565 reg = 0x1000;
1566 buf = 0x78;
1567 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1568 if (ret < 0)
1569 goto err;
1570
1571 reg = 0x10c0;
1572 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1573 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1574 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 335..390 */
1575 if (ret < 0)
1576 goto err;
1577
1578 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1579 if (ret < 0)
1580 goto err;
1581 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1582 if (ret < 0)
1583 goto err;
1584
1585 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1586 buf24[4] = 0x01; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1587 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1588 if (ret < 0)
1589 goto err;
1590
1591 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1592 if (ret < 0)
1593 goto err;
1594 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1595 if (ret < 0)
1596 goto err;
1597
1598 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1599 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1600 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1601 if (ret < 0)
1602 goto err;
1603
1604 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1605 if (ret < 0)
1606 goto err;
1607 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1608 if (ret < 0)
1609 goto err;
1610
1611 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x01; buf24[3] = 0x00;
1612 buf24[4] = 0x0e; buf24[5] = 0x00; buf24[6] = 0x14; buf24[7] = 0x10;
1613 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 344 */
1614 if (ret < 0)
1615 goto err;
1616
1617 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1618 if (ret < 0)
1619 goto err;
1620 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1621 if (ret < 0)
1622 goto err;
1623
1624 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x03; buf24[3] = 0x03;
1625 buf24[4] = 0xc1; buf24[5] = 0x05; buf24[6] = 0x01; buf24[7] = 0x10;
1626 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1627 if (ret < 0)
1628 goto err;
1629
1630 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1631 if (ret < 0)
1632 goto err;
1633 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1634 if (ret < 0)
1635 goto err;
1636
1637 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1638 buf24[4] = 0x83; buf24[5] = 0x00; buf24[6] = 0x06; buf24[7] = 0x10;
1639 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1640 if (ret < 0)
1641 goto err;
1642
1643 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1644 if (ret < 0)
1645 goto err;
1646 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1647 if (ret < 0)
1648 goto err;
1649
1650 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1651 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1652 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1653 if (ret < 0)
1654 goto err;
1655
1656 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1657 if (ret < 0)
1658 goto err;
1659 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1660 if (ret < 0)
1661 goto err;
1662
1663 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x00;
1664 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1665 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 356 */
1666 if (ret < 0)
1667 goto err;
1668
1669 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1670 if (ret < 0)
1671 goto err;
1672 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1673 if (ret < 0)
1674 goto err;
1675
1676 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x0b; buf24[3] = 0x00;
1677 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1678 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1679 if (ret < 0)
1680 goto err;
1681
1682 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1683 if (ret < 0)
1684 goto err;
1685 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1686 if (ret < 0)
1687 goto err;
1688
1689 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x11; buf24[3] = 0x00;
1690 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1691 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1692 if (ret < 0)
1693 goto err;
1694
1695 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1696 if (ret < 0)
1697 goto err;
1698 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1699 if (ret < 0)
1700 goto err;
1701
1702 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x1e; buf24[3] = 0x80;
1703 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1704 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 365 */
1705 if (ret < 0)
1706 goto err;
1707
1708 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1709 if (ret < 0)
1710 goto err;
1711 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1712 if (ret < 0)
1713 goto err;
1714
1715 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
1716 buf24[4] = 0x05; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1717 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1718 if (ret < 0)
1719 goto err;
1720
1721 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1722 if (ret < 0)
1723 goto err;
1724 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1725 if (ret < 0)
1726 goto err;
1727
1728 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
1729 buf24[4] = 0x08; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1730 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1731 if (ret < 0)
1732 goto err;
1733
1734 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1735 if (ret < 0)
1736 goto err;
1737 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1738 if (ret < 0)
1739 goto err;
1740
1741 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
1742 buf24[4] = 0x14; buf24[5] = 0x00; buf24[6] = 0x08; buf24[7] = 0x10;
1743 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1744 if (ret < 0)
1745 goto err;
1746
1747 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1748 if (ret < 0)
1749 goto err;
1750 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1751 if (ret < 0)
1752 goto err;
1753
1754 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
1755 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1756 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 377 */
1757 if (ret < 0)
1758 goto err;
1759
1760 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1761 if (ret < 0)
1762 goto err;
1763
1764 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x5f; buf24[3] = 0x89;
1765 buf24[4] = 0x04; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1766 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1767 if (ret < 0)
1768 goto err;
1769
1770 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
1771 if (ret < 0)
1772 goto err;
1773 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
1774 if (ret < 0)
1775 goto err;
1776
1777 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x60; buf24[3] = 0x00;
1778 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1779 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1780 if (ret < 0)
1781 goto err;
1782
1783 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
1784 if (ret < 0)
1785 goto err;
1786 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
1787 if (ret < 0)
1788 goto err;
1789
1790 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x62; buf24[3] = 0x04;
1791 buf24[4] = 0x98; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1792 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 385 */
1793 if (ret < 0)
1794 goto err;
1795
1796 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
1797 if (ret < 0)
1798 goto err;
1799 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
1800 if (ret < 0)
1801 goto err;
1802
1803 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x68; buf24[3] = 0x00;
1804 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1805 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1806 if (ret < 0)
1807 goto err;
1808
1809 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
1810 if (ret < 0)
1811 goto err;
1812 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
1813 if (ret < 0)
1814 goto err;
1815 /* <-- 0x10c0 */
1816 reg = 0x10e0;
1817 buf = 0x47;
1818 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 391 */
1819 if (ret < 0)
1820 goto err;
1821 buf = 0x07;
1822 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1823 if (ret < 0)
1824 goto err;
1825
1826 reg = 0x1001;
1827 buf = 0xc6;
1828 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1829 if (ret < 0)
1830 goto err;
1831 buf = 0xc4;
1832 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1833 if (ret < 0)
1834 goto err;
1835 buf = 0x44;
1836 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1837 if (ret < 0)
1838 goto err;
1839
1840 reg = 0x1189;
1841 buf = 0x0c;
1842 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1843 if (ret < 0)
1844 goto err;
1845
1846 buf = 0x00;
1847 reg = 0x11bc;
1848 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 397..400 */
1849 if (ret < 0)
1850 goto err;
1851 reg = 0x11bd;
1852 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1853 if (ret < 0)
1854 goto err;
1855 reg = 0x11be;
1856 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1857 if (ret < 0)
1858 goto err;
1859 reg = 0x11bf;
1860 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1861 if (ret < 0)
1862 goto err;
1863
1864 reg = 0x10c0;
1865 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
1866 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1867 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 401 */
1868 if (ret < 0)
1869 goto err;
1870
1871 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1872 if (ret < 0)
1873 goto err;
1874 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1875 if (ret < 0)
1876 goto err;
1877
1878 reg = 0x1180;
1879 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
1880 buf24[4] = 0x28; buf24[5] = 0x3c;
1881 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1882 if (ret < 0)
1883 goto err;
1884 reg = 0x10fb;
1885 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1886 buf24[4] = 0x00;
1887 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1888 if (ret < 0)
1889 goto err;
1890
1891 reg = 0x1189;
1892 buf = 0x0c;
1893 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1894 if (ret < 0)
1895 goto err;
1896
1897 reg = 0x11a1;
1898 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
1899 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1900 if (ret < 0)
1901 goto err;
1902 reg = 0x11ab;
1903 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
1904 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1905 if (ret < 0)
1906 goto err;
1907
1908 reg = 0x1000;
1909 buf = 0x7c;
1910 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1911 if (ret < 0)
1912 goto err;
1913
1914 reg = 0x1002;
1915 buf = 0x1c;
1916 for (i = 410; i <= 411; i++) {
1917 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1918 if (ret < 0)
1919 goto err;
1920 }
1921
1922 reg = 0x11b8;
1923 buf = 0x38;
1924 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1925 if (ret < 0)
1926 goto err;
1927 reg = 0x118a;
1928 buf = 0x05;
1929 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1930 if (ret < 0)
1931 goto err;
1932 reg = 0x0395;
1933 buf = 0x05;
1934 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1935 if (ret < 0)
1936 goto err;
1937
1938 reg = 0x11b8;
1939 buf = 0x78;
1940 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 415..425 */
1941 if (ret < 0)
1942 goto err;
1943 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
1944 if (ret < 0)
1945 goto err;
1946 buf = 0x79;
1947 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1948 if (ret < 0)
1949 goto err;
1950 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
1951 if (ret < 0)
1952 goto err;
1953 buf = 0x7a;
1954 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1955 if (ret < 0)
1956 goto err;
1957 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
1958 if (ret < 0)
1959 goto err;
1960 buf = 0x7b;
1961 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1962 if (ret < 0)
1963 goto err;
1964 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
1965 if (ret < 0)
1966 goto err;
1967 buf = 0xfc;
1968 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1969 if (ret < 0)
1970 goto err;
1971 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
1972 if (ret < 0)
1973 goto err;
1974 buf = 0x78;
1975 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1976 if (ret < 0)
1977 goto err;
1978 /* // <-- 0x11b8 */
1979 reg = 0x10c0;
1980
1981 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
1982 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1983 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 426..431 */
1984 if (ret < 0)
1985 goto err;
1986
1987 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1988 if (ret < 0)
1989 goto err;
1990 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1991 if (ret < 0)
1992 goto err;
1993
1994 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1995 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1996 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1997 if (ret < 0)
1998 goto err;
1999
2000 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2001 if (ret < 0)
2002 goto err;
2003 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2004 if (ret < 0)
2005 goto err;
2006 /* // <-- 0x10c0 */
2007 reg = 0x11ba;
2008 buf = 0x0a;
2009 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2010 if (ret < 0)
2011 goto err;
2012
2013 reg = 0x118b;
2014 buf = 0x0a;
2015 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2016 if (ret < 0)
2017 goto err;
2018
2019 reg = 0x10f7;
2020 buf = 0x07;
2021 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2022 if (ret < 0)
2023 goto err;
2024
2025 reg = 0x10f8;
2026 buf = 0x14;
2027 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2028 if (ret < 0)
2029 goto err;
2030 reg = 0x10fa;
2031 buf = 0xff;
2032 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2033 if (ret < 0)
2034 goto err;
2035
2036 reg = 0x10f9;
2037 buf = 0x00;
2038 for (i = 453; i < 454; i++) {
2039 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2040 if (ret < 0)
2041 goto err;
2042 }
2043
2044 reg = 0x11ba;
2045 buf = 0x0a;
2046 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2047 if (ret < 0)
2048 goto err;
2049
2050 reg = 0x11bc;
2051 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x00;
2052 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2053 if (ret < 0)
2054 goto err;
2055
2056 reg = 0x11c0;
2057 for (i = 0; i < 48; i++)
2058 buf64[i] = 0; /* // zeroes */
2059 ret = usb_microdia_control_write(dev, reg, buf64, 48); /* URB 457 */
2060 if (ret < 0)
2061 goto err;
2062
2063 reg = 0x10c0;
2064 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
2065 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2066 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 462 */
2067 if (ret < 0)
2068 goto err;
2069
2070 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2071 if (ret < 0)
2072 goto err;
2073 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2074 if (ret < 0)
2075 goto err;
2076
2077 reg = 0x1180;
2078 buf = 0x02;
2079 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2080 if (ret < 0)
2081 goto err;
2082
2083 reg = 0x10c0;
2084 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
2085 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2086 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 466 */
2087 if (ret < 0)
2088 goto err;
2089
2090 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2091 if (ret < 0)
2092 goto err;
2093 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2094 if (ret < 0)
2095 goto err;
2096
2097 reg = 0x1182;
2098 buf = 0x02;
2099 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2100 if (ret < 0)
2101 goto err;
2102
2103 reg = 0x10c0;
2104 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2105 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2106 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 470..483 */
2107 if (ret < 0)
2108 goto err;
2109
2110 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2111 if (ret < 0)
2112 goto err;
2113 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2114 if (ret < 0)
2115 goto err;
2116
2117 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
2118 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
2119 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2120 if (ret < 0)
2121 goto err;
2122
2123 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
2124 if (ret < 0)
2125 goto err;
2126 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2127 if (ret < 0)
2128 goto err;
2129
2130 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
2131 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
2132 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2133 if (ret < 0)
2134 goto err;
2135
2136 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
2137 if (ret < 0)
2138 goto err;
2139 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2140 if (ret < 0)
2141 goto err;
2142
2143 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
2144 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2145 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 479 */
2146 if (ret < 0)
2147 goto err;
2148
2149 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2150 if (ret < 0)
2151 goto err;
2152
2153 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2154 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2155 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2156 if (ret < 0)
2157 goto err;
2158
2159 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2160 if (ret < 0)
2161 goto err;
2162 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2163 if (ret < 0)
2164 goto err;
2165 /* // <-- 0x10c0 */
2166 reg = 0x11a5;
2167 buf24[0] = 0x2d; buf24[1] = 0x2d; buf24[2] = 0x3a; buf24[3] = 0x05;
2168 buf24[4] = 0x04; buf24[5] = 0x3f;
2169 ret = usb_microdia_control_write(dev, reg, buf24, 6);
2170 if (ret < 0)
2171 goto err;
2172 reg = 0x11af;
2173 buf24[0] = 0x28; buf24[1] = 0xd8; buf24[2] = 0x14; buf24[3] = 0xec;
2174 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2175 if (ret < 0)
2176 goto err;
2177 reg = 0x11b3;
2178 buf24[0] = 0x32; buf24[1] = 0xdd; buf24[2] = 0x2d; buf24[3] = 0xdd;
2179 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2180 if (ret < 0)
2181 goto err;
2182
2183 reg = 0x10c0;
2184 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2185 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2186 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 491..502 */
2187 if (ret < 0)
2188 goto err;
2189
2190 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2191 if (ret < 0)
2192 goto err;
2193 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2194 if (ret < 0)
2195 goto err;
2196
2197 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2c; buf24[3] = 0x00;
2198 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x1d; buf24[7] = 0x10;
2199 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2200 if (ret < 0)
2201 goto err;
2202
2203 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 495: d0 */
2204 if (ret < 0)
2205 goto err;
2206 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 496: d0 */
2207 if (ret < 0)
2208 goto err;
2209 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2210 if (ret < 0)
2211 goto err;
2212
2213 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x30; buf24[3] = 0x00;
2214 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2215 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2216 if (ret < 0)
2217 goto err;
2218
2219 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2220 if (ret < 0)
2221 goto err;
2222
2223 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2224 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2225 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2226 if (ret < 0)
2227 goto err;
2228
2229 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2230 if (ret < 0)
2231 goto err;
2232 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2233 if (ret < 0)
2234 goto err;
2235 /* // <-- 0x10c0 */
2236 reg = 0x10e0;
2237 buf = 0x07;
2238 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2239 if (ret < 0)
2240 goto err;
2241 buf = 0x27;
2242 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2243 if (ret < 0)
2244 goto err;
2245
2246 reg = 0x1100;
2247 ret = usb_microdia_control_write(dev, reg, buf1100, 64); /* URB 509 (see also 249/250) */
2248 if (ret < 0)
2249 goto err;
2250
2251 reg = 0x1140;
2252 /* 00000000: */
2253 buf64[0] = 0x0d; buf64[1] = 0x11; buf64[2] = 0x11; buf64[3] = 0x15;
2254 buf64[4] = 0x11; buf64[5] = 0x15; buf64[6] = 0x26; buf64[7] = 0x15;
2255 buf64[8] = 0x15; buf64[9] = 0x26; buf64[10] = 0x54; buf64[11] = 0x36;
2256 buf64[12] = 0x2e; buf64[13] = 0x36; buf64[14] = 0x54; buf64[15] = 0x54;
2257 /* 00000010: .. 00000030: 0x54 */
2258 for (i = 16; i <= 63; i++)
2259 buf64[i] = 0x54;
2260 ret = usb_microdia_control_write(dev, reg, buf64, 64); /* URB 510 */
2261 if (ret < 0)
2262 goto err;
2263
2264 reg = 0x10e0;
2265 buf = 0x07;
2266 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2267 if (ret < 0)
2268 goto err;
2269 buf = 0x0b;
2270 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2271 if (ret < 0)
2272 goto err;
2273
2274 reg = 0x1189;
2275 buf = 0x0c;
2276 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2277 if (ret < 0)
2278 goto err;
2279
2280 buf = 0x00;
2281 reg = 0x11bc;
2282 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 514..517 */
2283 if (ret < 0)
2284 goto err;
2285 reg = 0x11bd;
2286 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2287 if (ret < 0)
2288 goto err;
2289 reg = 0x11be;
2290 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2291 if (ret < 0)
2292 goto err;
2293 reg = 0x11bf;
2294 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2295 if (ret < 0)
2296 goto err;
2297
2298 reg = 0x1180;
2299 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
2300 buf24[4] = 0x28; buf24[5] = 0x3c;
2301 ret = usb_microdia_control_write(dev, reg, buf24, 6);
2302
2303 reg = 0x10fb;
2304 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
2305 buf24[4] = 0x00;
2306 ret = usb_microdia_control_write(dev, reg, buf24, 5);
2307
2308 reg = 0x1189;
2309 buf = 0x0c;
2310 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2311 if (ret < 0)
2312 goto err;
2313
2314 reg = 0x11a1;
2315 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
2316 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2317
2318 reg = 0x11ab;
2319 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
2320 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2321
2322 reg = 0x1061;
2323 buf = 0x03;
2324 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2325 if (ret < 0)
2326 goto err;
2327 reg = 0x11ba;
2328 buf = 0x0a;
2329 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2330 if (ret < 0)
2331 goto err;
2332 reg = 0x11b9;
2333 buf = 0x00;
2334 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2335 if (ret < 0)
2336 goto err;
2337 reg = 0x11ba;
2338 buf = 0x0b;
2339 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2340 if (ret < 0)
2341 goto err;
2342 reg = 0x1061;
2343 buf = 0x01;
2344 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2345 if (ret < 0)
2346 goto err;
2347 reg = 0x1000;
2348 buf = 0x7c;
2349 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2350 if (ret < 0)
2351 goto err;
2352
2353 reg = 0x1002;
2354 buf = 0x1c;
2355 for (i = 529; i <= 530; i++) {
2356 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2357 if (ret < 0)
2358 goto err;
2359 }
2360
2361 reg = 0x11b8;
2362 buf = 0x78;
2363 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2364 if (ret < 0)
2365 goto err;
2366 reg = 0x118a;
2367 buf = 0x05;
2368 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2369 if (ret < 0)
2370 goto err;
2371 reg = 0x0395;
2372 buf = 0x05;
2373 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2374 if (ret < 0)
2375 goto err;
2376
2377 reg = 0x11b8;
2378 buf = 0x78;
2379 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 534..544 */
2380 if (ret < 0)
2381 goto err;
2382 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
2383 if (ret < 0)
2384 goto err;
2385 buf = 0x79;
2386 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2387 if (ret < 0)
2388 goto err;
2389 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
2390 if (ret < 0)
2391 goto err;
2392 buf = 0x7a;
2393 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2394 if (ret < 0)
2395 goto err;
2396 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
2397 if (ret < 0)
2398 goto err;
2399 buf = 0x7b;
2400 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2401 if (ret < 0)
2402 goto err;
2403 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
2404 if (ret < 0)
2405 goto err;
2406 buf = 0xfc;
2407 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2408 if (ret < 0)
2409 goto err;
2410 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
2411 if (ret < 0)
2412 goto err;
2413 buf = 0x78;
2414 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2415 if (ret < 0)
2416 goto err;
2417 /* // <-- 0x11b8 */
2418 reg = 0x10c0;
2419 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
2420 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2421 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 545..555 */
2422 if (ret < 0)
2423 goto err;
2424
2425 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2426 if (ret < 0)
2427 goto err;
2428 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2429 if (ret < 0)
2430 goto err;
2431
2432 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
2433 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2434 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2435 if (ret < 0)
2436 goto err;
2437
2438 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2439 if (ret < 0)
2440 goto err;
2441 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2442 if (ret < 0)
2443 goto err;
2444
2445 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
2446 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2447 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2448 if (ret < 0)
2449 goto err;
2450
2451 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2452 if (ret < 0)
2453 goto err;
2454
2455 buf24[0] = 0xa2; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
2456 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2457 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2458 if (ret < 0)
2459 goto err;
2460
2461 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a2 */
2462 if (ret < 0)
2463 goto err;
2464 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a6 */
2465 if (ret < 0)
2466 goto err;
2467 /* // <-- 0x10c0 */
2468 reg = 0x10c2;
2469 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x84;
2470 buf24[4] = 0x31;
2471 ret = usb_microdia_control_write(dev, reg, buf24, 5);
2472 if (ret < 0)
2473 goto err;
2474
2475 reg = 0x1061;
2476 buf = 0x03;
2477 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 557 */
2478 if (ret < 0)
2479 goto err;
2480
2481 /* UNKNOWN -- URB_FUNCTION_RESET_PIPE:
2482 // UNKNOWN -- URB_FUNCTION_RESET_PIPE:
2483 // UNKNOWN -- URB_FUNCTION_GET_CURRENT_FRAME_NUMBER:
2484 // UNKNOWN -- URB_FUNCTION_GET_CURRENT_FRAME_NUMBER:
2485 // URB 560 >>> SENDING ISO REQUEST
2486 */
2487 UDIA_INFO("...start function completed without errors.\n");
2488 return ret;
2489 err:
2490 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
2491 return ret;
2492 }
2493
2494 /**
2495 * @brief From stop-close-amcap.log
2496 *
2497 * @param dev
2498 *
2499 * @returns 0
2500 *
2501 * @author psnel
2502 *
2503 * For SN9C201 with MI1300. Comments from parser-usbsnoop(updated_13Mar2008).pl output
2504 *
2505 */
2506 int microdia_6240_stop_stream(struct usb_microdia *dev)
2507 {
2508 int ret = 0;
2509 __u8 buf[8];
2510
2511 UDIA_INFO("Stopping camera...\n");
2512
2513 buf[0] = 0x01;
2514 ret = usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 25319 */
2515 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2516
2517 buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00;
2518 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
2519 ret += usb_microdia_control_write(dev, 0x10c0, buf, 8); /* URB 25320 */
2520 UDIA_INFO("...stop: write buf[8], ret = %d\n", ret);
2521
2522 ret += usb_microdia_control_read(dev, 0x10c0, buf, 1); /* URB 25321 << b0 */
2523 UDIA_INFO("...stop: read %x, ret = %d\n", buf[0], ret);
2524
2525 ret += usb_microdia_control_read(dev, 0x10c0, buf, 1); /* URB 25322 << b4 */
2526 UDIA_INFO("...stop: read %x, ret = %d\n", buf[0], ret);
2527
2528 buf[0] = 0x3c;
2529 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 25323 */
2530 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2531
2532 buf[0] = 0x68;
2533 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 25324 */
2534 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2535
2536 buf[0] = 0xa0;
2537 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 25325 */
2538 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2539
2540 buf[0] = 0xa0;
2541 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 25326 */
2542 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2543
2544 buf[0] = 0x98; buf[1] = 0xef; buf[2] = 0x11;
2545 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 25327 */
2546 UDIA_INFO("...stop: write buf[3], ret = %d\n", ret);
2547
2548 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: (URB 5009)
2549 // URB 25328 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 0
2550 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: (URB 25329)
2551 */
2552
2553 buf[0] = 0x00;
2554 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 25330 */
2555 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2556
2557 if (ret < 19) {
2558 UDIA_ERROR("One ore more errors occured during stop sequence !\n");
2559 return -1;
2560 }
2561
2562 return 0;
2563 }
2564
2565 /**
2566 * @brief From init.sequence.log
2567 *
2568 * @param dev
2569 *
2570 * @returns 0
2571 *
2572 * @author GWater
2573 *
2574 * For SN9C201 with SOI968.
2575 * Tests showed this function is actually unnecessary.
2576 * Nevertheless the reads may give us valuable values we don't know about yet.
2577 */
2578 int microdia_624e_initialize(struct usb_microdia *dev)
2579 {
2580 __u8 buf;
2581
2582 usb_microdia_control_read(dev, 0x130d, &buf, 1);
2583 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2584
2585 return 0;
2586 }
2587
2588 /**
2589 * @brief From UsbSnoop-plugin-parsed.log
2590 *
2591 * @param dev
2592 *
2593 * @returns
2594 */
2595 int microdia_624f_initialize(struct usb_microdia *dev)
2596 {
2597 /* Do nothing here */
2598 return 0;
2599 }
2600
2601 /**
2602 * @brief From UsbSnoop-plugin-parsed.log
2603 *
2604 * @param dev
2605 *
2606 * @returns
2607 */
2608 int microdia_6260_initialize(struct usb_microdia *dev)
2609 {
2610 __u8 buf;
2611
2612 usb_microdia_control_read(dev, 0x130d, &buf, 1);
2613 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2614 buf = 0x00;
2615 usb_microdia_control_write(dev, 0x10c8, &buf, 1);
2616 usb_microdia_control_read(dev, 0x100a, &buf, 1);
2617 buf = 0x04;
2618 usb_microdia_control_write(dev, 0x100a, &buf, 1);
2619 usb_microdia_control_read(dev, 0x100b, &buf, 1);
2620 buf = 0x04;
2621 usb_microdia_control_write(dev, 0x100b, &buf, 1);
2622 usb_microdia_control_read(dev, 0x1001, &buf, 1);
2623 buf = 0xc7;
2624 usb_microdia_control_write(dev, 0x1001, &buf, 1);
2625 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2626 buf = 0x00;
2627 usb_microdia_control_write(dev, 0x1040, &buf, 1);
2628 usb_microdia_control_read(dev, 0x1045, &buf, 1);
2629 buf = 0x04;
2630 usb_microdia_control_write(dev, 0x1045, &buf, 1);
2631 usb_microdia_control_read(dev, 0x1046, &buf, 1);
2632 buf = 0x10;
2633 usb_microdia_control_write(dev, 0x1046, &buf, 1);
2634 buf = 0x14;
2635 usb_microdia_control_write(dev, 0x1045, &buf, 1);
2636 buf = 0x01;
2637 usb_microdia_control_write(dev, 0x1040, &buf, 1);
2638 buf = 0x80;
2639 usb_microdia_control_write(dev, 0x1020, &buf, 1);
2640
2641 return 0;
2642 }
2643
2644 /**
2645 * @brief From 6 init-logs
2646 *
2647 * @param dev
2648 *
2649 * @returns 0 (ok) or -1 (error)
2650 *
2651 * @author Comer352l
2652 *
2653 * Windows driver versions: 5.5.8.12 and 5.7.23.000
2654 * Windows versions: 2000 and XP
2655 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
2656 *
2657 * Comments behind read oprations contain HEX-values that appeared in the logs
2658 */
2659 int microdia_6270_initialize(struct usb_microdia *dev)
2660 {
2661 /* int actual; */
2662 int ret = 0;
2663 int retSP = 0;
2664 int retASS = 0;
2665 __u8 buf[8];
2666 __u8 buf_0395[1];
2667 __u8 buf_1000[5];
2668 __u8 buf_1060[2];
2669 __u8 buf_11b8[1];
2670
2671 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81,0x85,0x04,0x8b,0x02,... */
2672
2673 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4,0xc4,0xa4,0x44,... */
2674
2675 /*
2676 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
2677 * buf[0]=0x00;
2678 * usb_microdia_control_write(dev, 0x10c8, buf, 1);
2679 */
2680
2681 ret += usb_microdia_control_read(dev, 0x118a, buf, 1); /* URB 7 0x05,0x7b,0x01,0x04,... */
2682
2683 ret += usb_microdia_control_read(dev, 0x0395, buf_0395, 1); /* URB 8 0xc2,0x82,0x38,0x98,0x04,... */
2684 /* => this value will be rewritten to 0x118a and 0x0395 later (URBs 81+82) */
2685
2686 buf[0] = 0x05;
2687 ret += usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 9 */
2688
2689 ret += usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 10 */
2690
2691 ret += usb_microdia_control_read(dev, 0x11b8, buf_11b8, 1); /* URB 11 0xa0,0x00,0x24,... */
2692 /* => this value will be rewritten to 0x11b8 later (URB 83) */
2693
2694 buf[0] = 0x10;
2695 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 12 */
2696
2697 ret += usb_microdia_control_read(dev, 0x1000, buf_1000, 5); /* URB 13 0x30 0xCF 0x00 0x03 (0x02 or 0x00) */
2698 /* => these values will be rewritten to 0x1000 later (URB 84) */
2699
2700 buf[0] = 0x70; buf[1] = 0x00; buf[2] = 0x18; buf[3] = 0x00; buf[4] = 0x00;
2701 ret += usb_microdia_control_write(dev, 0x1000, buf, 5); /* URB 14 */
2702
2703 ret += usb_microdia_control_read(dev, 0x1060, buf_1060, 2); /* URB 15 0x08 0x00 (always ???) */
2704 /* => this value will be rewritten to 0x1060 later (URB 85) */
2705
2706 buf[0] = 0x00; buf[1] = 0x03;
2707 ret += usb_microdia_control_write(dev, 0x1060, buf, 2); /* URB 16 */
2708
2709 /* initialize I2C registers to avoid getting no ACK at first I2C operation: */
2710 ret += sn9c20x_initialize_i2c(dev, SN9C20X_I2C_2WIRE, MT9V011_I2C_SLAVE_ADDRESS);
2711
2712 /* enable I2C communication (bit 0) */
2713 buf[0] = 0x21; /* THE OLD DRIVER 5.5.8.12 WRITES 0x5d */
2714 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 17 */
2715
2716 /* probe sensor model: */
2717 retSP = mt9vx11_sensor_probe(dev); /* substitutes URBs 18-48 */
2718 if ((retSP == 0) && (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS))
2719 /* switch (back) to IFP address space: */
2720 retASS = mt9v111_select_address_space(dev, MT9V111_ADDRESSSPACE_IFP);
2721
2722 ret += usb_microdia_control_write(dev, 0x118a, buf_0395, 1); /* URB 81 => write value read with URB 8 */
2723
2724 ret += usb_microdia_control_write(dev, 0x0395, buf_0395, 1); /* URB 82 => write value read with URB 8 */
2725
2726 ret += usb_microdia_control_write(dev, 0x11b8, buf_11b8, 1); /* URB 83 => write value read with URB 11 */
2727
2728 ret += usb_microdia_control_write(dev, 0x1000, buf_1000, 5); /* URB 84 => write value read with URB 13 */
2729
2730 ret += usb_microdia_control_write(dev, 0x1060, buf_1060, 2); /* URB 85 => write value read with URB 15; (always 08 00 ???) */
2731
2732 /* USB-interrupt-message: doesn't work yet (returns error -110) */
2733 /* usb_interrupt_msg(dev->udev, usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr), dev->int_in_buffer, dev->int_in_size, &actual, 1000); // URB 86 */
2734
2735 /*
2736 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
2737 * wbuf[0]=0x80;
2738 * usb_microdia_control_write(dev, 0x1020, wbuf, 1);
2739 */
2740
2741 if ((retSP != 0) || (retASS != 0) || (ret < 33)) {
2742 if (ret < 33)
2743 UDIA_INFO("One ore more errors occured during initialization !\n");
2744 return -1;
2745 } else {
2746 return 0;
2747 }
2748 }
2749
2750
2751 /**
2752 * @brief From UsbSnoop-plugin-parsed.log
2753 *
2754 * @param dev
2755 *
2756 * @returns
2757 */
2758 int microdia_627b_initialize(struct usb_microdia *dev)
2759 {
2760 /*int actual;*/
2761 int ret;
2762 int retI2C;
2763 __u16 reg;
2764 __u8 buf[32];
2765 __u8 reg0395[1];
2766 __u8 reg11b8[1];
2767 __u8 reg1000[5];
2768 __u8 reg1060[2];
2769
2770 reg = 0x130d;
2771 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 5 */
2772 if (ret < 0)
2773 goto err;
2774 reg = 0x1040;
2775 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 6 */
2776 if (ret < 0)
2777 goto err;
2778
2779 reg = 0x118a;
2780 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 7 */
2781 if (ret < 0)
2782 goto err;
2783 reg = 0x0395;
2784 ret = usb_microdia_control_read(dev, reg, reg0395, 1); /* URB 8 */
2785 if (ret < 0)
2786 goto err;
2787
2788 reg = 0x118a;
2789 buf[0] = 0x05;
2790 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 9 */
2791 if (ret < 0)
2792 goto err;
2793 reg = 0x0395;
2794 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 10 */
2795 if (ret < 0)
2796 goto err;
2797
2798 reg = 0x11b8;
2799 ret = usb_microdia_control_read(dev, reg, reg11b8, 1); /* URB 11 */
2800 if (ret < 0)
2801 goto err;
2802
2803 reg = 0x11b8;
2804 buf[0] = 0x10;
2805 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 12 */
2806 if (ret < 0)
2807 goto err;
2808 reg = 0x1000;
2809 ret = usb_microdia_control_read(dev, reg, reg1000, 5); /* URB 13 */
2810 if (ret < 0)
2811 goto err;
2812
2813 reg = 0x1000;
2814 buf[0] = 0x70; buf[1] = 0x00; buf[2] = 0x18; buf[3] = 0x00; buf[4] = 0x00;
2815 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 14 */
2816 if (ret < 0)
2817 goto err;
2818
2819 reg = 0x1060;
2820 ret = usb_microdia_control_read(dev, reg, reg1060, 2); /* URB 15 */
2821 if (ret < 0)
2822 goto err;
2823
2824 reg = 0x1060;
2825 buf[0] = 0x00; buf[1] = 0x03;
2826 ret = usb_microdia_control_write(dev, reg, buf, 2); /* URB 16 */
2827 if (ret < 0)
2828 goto err;
2829
2830 reg = 0x10c8;
2831 buf[0] = 0x21;
2832 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 17 */
2833 if (ret < 0)
2834 goto err;
2835
2836 retI2C = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
2837 OV7660_CTL_PID, dev->sensor_flags, buf); /* URBs 18-29 */
2838 if (retI2C < 0) {
2839 /* 2nd try... */
2840 reg = 0x10c8;
2841 buf[0] = 0x21;
2842 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 30 */
2843 if (ret < 0)
2844 goto err;
2845
2846 retI2C = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
2847 OV7660_CTL_PID, dev->sensor_flags, buf); /* URBs 31-35 */
2848 }
2849 if (retI2C < 0)
2850 UDIA_ERROR("Read of sensor register 0x0a failed.");
2851
2852 reg = 0x118a;
2853 buf[0] = 0xa6;
2854 ret = usb_microdia_control_write(dev, reg, reg0395, 1); /* URB 36 */
2855 if (ret < 0)
2856 goto err;
2857 reg = 0x0395;
2858 ret = usb_microdia_control_write(dev, reg, reg0395, 1); /* URB 37 */
2859 if (ret < 0)
2860 goto err;
2861
2862 reg = 0x11b8;
2863 buf[0] = 0x06;
2864 ret = usb_microdia_control_write(dev, reg, reg11b8, 1); /* URB 38 */
2865 if (ret < 0)
2866 goto err;
2867
2868 reg = 0x1000;
2869 buf[0] = 0x30; buf[1] = 0xcf; buf[2] = 0x00; buf[3] = 0x03; buf[4] = 0x02;
2870 ret = usb_microdia_control_write(dev, reg, reg1000, 5); /* URB 39 */
2871 if (ret < 0)
2872 goto err;
2873
2874 reg = 0x1060;
2875 buf[0] = 0x08; buf[1] = 0x00;
2876 ret = usb_microdia_control_write(dev, reg, reg1060, 2); /* URB 40 */
2877 if (ret < 0)
2878 goto err;
2879
2880 /*
2881 //URB 41
2882 ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000);
2883 */
2884
2885 return ret;
2886 err:
2887 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
2888 return ret;
2889 }
2890
2891 /**
2892 * @brief From init-start-stop-log (made by Víctor M. Hernández Rocamora)
2893 *
2894 * @param dev
2895 *
2896 * @returns 0 (ok) or -1 (error)
2897 *
2898 * @author Comer352l
2899 *
2900 * USB-Logger: SniffUSB 2.0
2901 *
2902 * Comments behind read oprations contain HEX-values that appeared in the log
2903 */
2904 int microdia_627f_initialize(struct usb_microdia *dev)
2905 {
2906 __u8 buf[1];
2907 int ret = 0;
2908
2909 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81 */
2910
2911 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4 */
2912
2913 buf[0] = 0x00;
2914 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 7 */
2915
2916 buf[0] = 0x80;
2917 ret += usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 8 */
2918
2919 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 9 0x0f */
2920
2921 buf[0] = 0x1f;
2922 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 10 */
2923
2924 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 11 0x1f */
2925
2926 buf[0] = 0x0f;
2927 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 12 */
2928
2929 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 13 0x0f */
2930
2931 buf[0] = 0x1f;
2932 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 14 */
2933
2934 if (ret < 10) {
2935 UDIA_INFO("One ore more errors occured during initialization !\n");
2936 return -1;
2937 }
2938 return 0;
2939 }
2940
2941 /**
2942 * @brief From UsbSnoop-plugin-parsed.log
2943 *
2944 * @param dev
2945 *
2946 * @returns 0 (OK) or <0 (Error)
2947 *
2948 * @author Vincent, Kuzja
2949 */
2950 int microdia_6288_initialize(struct usb_microdia *dev)
2951 {
2952
2953 int ret;
2954 __u16 reg;
2955 __u8 buf[2];
2956
2957 reg = 0x130d ;
2958 ret = usb_microdia_control_read(dev, reg, buf, 1);
2959 if (ret < 0)
2960 goto err;
2961
2962 reg = 0x1040 ;
2963 ret = usb_microdia_control_read(dev, reg, buf, 1);
2964 if (ret < 0)
2965 goto err;
2966
2967 if (ret < 0)
2968 return ret;
2969 else
2970 return 0;
2971 err:
2972 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
2973 return ret;
2974 }
2975
2976 /**
2977 * @brief From UsbSnoop-plugin-parsed.log
2978 *
2979 * @param dev
2980 *
2981 * @returns 0 if all OK
2982 *
2983 * Function to initialize Microdia 6128 webcam
2984 * Bridge SN9C325 + OM6802 CMOS sensor
2985 * note: comments are my observations so they could be wrong
2986 */
2987 int microdia_6128_initialize(struct usb_microdia *dev)
2988 {
2989 int ret = 0;
2990 __u8 buf[2];
2991
2992 UDIA_INFO("Initializing camera...\n");
2993
2994 buf[0] = 0x01;
2995 ret += usb_microdia_control_write(dev, 0xf1, buf, 1);
2996 ret += usb_microdia_control_read(dev, 0x00, buf, 1); // read reg 0x00 must write 0x00 in buf[0]
2997 ret += usb_microdia_control_write(dev, 0xf1, buf, 1);
2998 ret += usb_microdia_control_read(dev, 0x00, buf, 1); // get cam ID, must read 0x12
2999
3000 if(buf[0] != 0x12){
3001 UDIA_ERROR("Microdia 6128 is not connected or working !!!\n");
3002 return -ENODEV;
3003 }
3004
3005 buf[0] = 0x29; buf[1] = 0x70; // Configure GPIO
3006 ret += usb_microdia_control_write(dev, 0x01, buf, 2);
3007
3008 buf[0] = 0x01;
3009 ret += usb_microdia_control_write(dev, 0xf1, buf, 1); // Maybe wakeup
3010
3011 buf[0] = 0x0e;
3012 ret += usb_microdia_control_write(dev, 0x01, buf, 1); // Command to initialize cam
3013
3014 if(ret != 8)
3015 UDIA_DEBUG("Some read or writes were not successful in initialization !\n");
3016
3017 /* Device is initialized and ready */
3018 UDIA_INFO("Microdia USB2.0 Camera is ready\n");
3019
3020 return 0;
3021 }
3022
3023
3024 int dev_microdia_start_stream(struct usb_microdia *dev)
3025 {
3026 int ret = -ENODEV;
3027 if (dev && dev->start_stream)
3028 ret = dev->start_stream(dev);
3029
3030 return ret;
3031 }
3032
3033 /**
3034 * @brief From start.htm
3035 *
3036 * @param dev
3037 *
3038 * @returns 0
3039 *
3040 * @author GWater
3041 *
3042 * For SN9C201 with MI1310.
3043 * This function has not been tested yet.
3044 */
3045 int microdia_6242_start_stream(struct usb_microdia *dev)
3046 {
3047 int i = -1;
3048 __u8 buf[48];
3049
3050 __u8 urb10[24] = {
3051 0x01, 0x18, 0x00, 0x30, 0x00, 0x09, 0x00, 0xed,
3052 0x0f, 0xda, 0x0f, 0x3a, 0x00, 0x3a, 0x00, 0xd0,
3053 0x0f, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x60, 0x0a};
3054
3055 __u8 urb13[11] = {
3056 0x02, 0x00, 0x02, 0x00, 0x50, 0x78, 0x00, 0x00,
3057 0x07, 0xc0, 0x0a};
3058
3059 __u8 urb14[22] = {
3060 0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x24, 0x3b,
3061 0x4f, 0x61, 0x71, 0x80, 0x8f, 0x9d, 0xab, 0xb8,
3062 0xc4, 0xd1, 0xdd, 0xe9, 0xf4, 0xff};
3063
3064 __u8 qtable1[64] = {
3065 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3066 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3067 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3068 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
3069 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
3070 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
3071 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
3072 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54};
3073
3074 __u8 qtable2[64] = {
3075 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
3076 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
3077 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3078 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3079 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3080 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3081 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3082 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54};
3083
3084 __u8 first10c0[7][3] = {
3085 {0x0d, 0x00, 0x08},
3086 {0x0d, 0x00, 0x09},
3087 {0x0d, 0x00, 0x08},
3088 {0xf0, 0x00, 0x01},
3089 {0x3a, 0x73, 0x00},
3090 {0x06, 0x30, 0x8c},
3091 {0xf0, 0x00, 0x00}
3092 };
3093
3094 __u8 second10c0a[2][5] = {
3095 {0x01, 0x00, 0x0e, 0x00, 0x14},
3096 {0x03, 0x03, 0xc4, 0x05, 0x14}
3097 };
3098
3099 __u8 second10c0b[3] =
3100 {0xc8, 0x00, 0x03};
3101
3102 __u8 third10c0[4][3] = {
3103 {0x0a, 0x00, 0x01},
3104 {0x06, 0x00, 0x29},
3105 {0x05, 0x00, 0x72},
3106 {0x20, 0x00, 0x00}
3107 };
3108
3109 __u8 fourth10c0a[3][3] = {
3110 {0x20, 0x00, 0x00},
3111 {0x09, 0x01, 0x90},
3112 {0x0d, 0x80, 0x08}
3113 };
3114
3115 __u8 fourth10c0b[2][5] = {
3116 {0x2b, 0x01, 0x88, 0x01, 0x88},
3117 {0x2d, 0x01, 0x88, 0x01, 0x88}
3118 };
3119
3120 __u8 fifth10c0[4][3] = {
3121 {0x0a, 0x00, 0x01},
3122 {0x06, 0x00, 0x29},
3123 {0x05, 0x00, 0x72}
3124 };
3125
3126 /* interrupt down */
3127
3128 buf[0] = 0x00;
3129 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1 */
3130
3131 /* interrupt up */
3132 /* interrupt down */
3133
3134 buf[0] = 0x60;
3135 usb_microdia_control_write(dev, 0x1007, buf, 1);
3136
3137 buf[0] = 0x00;
3138 usb_microdia_control_write(dev, 0x1006, buf, 1);
3139
3140 buf[0] = 0x78;
3141 usb_microdia_control_write(dev, 0x1000, buf, 1);
3142
3143 buf[0] = 0xc7;
3144 usb_microdia_control_write(dev, 0x1001, buf, 1);
3145
3146 buf[0] = 0x1c;
3147 usb_microdia_control_write(dev, 0x1002, buf, 1);
3148
3149 buf[0] = 0x01;
3150 usb_microdia_control_write(dev, 0x1061, buf, 1);
3151
3152 buf[0] = 0x80;
3153 usb_microdia_control_write(dev, 0x1020, buf, 1);
3154
3155 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
3156 buf[3] = 0x10; buf[4] = 0x08;
3157 usb_microdia_control_write(dev, 0x1067, buf, 5);
3158
3159 buf[0] = 0xb0; buf[1] = dev->sensor_slave_address; buf[2] = 0x0d;
3160 buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00;
3161 buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03;
3162 usb_microdia_control_write(dev, 0x10c0, buf, 9);
3163
3164 usb_microdia_control_write(dev, 0x10e0, urb10, 24); /* URB 10 */
3165
3166 buf[0] = 0x00; buf[1] = 0x00; buf[3] = 0x00;
3167 usb_microdia_control_write(dev, 0x10f8, buf, 3);
3168
3169 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00;
3170 buf[3] = 0xe0; buf[4] = 0x03;
3171 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3172
3173 usb_microdia_control_write(dev, 0x1180, urb13, 11);
3174
3175 usb_microdia_control_write(dev, 0x118b, urb14, 22);
3176
3177 buf[0] = 0x00; buf[1] = 0x00;
3178 usb_microdia_control_write(dev, 0x11a1, buf, 2);
3179
3180 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00;
3181 buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00;
3182 buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00;
3183 usb_microdia_control_write(dev, 0x11b7, buf, 9);
3184
3185 buf[0] = 0x30;
3186 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3187
3188 buf[0] = 0x78;
3189 usb_microdia_control_write(dev, 0x1000, buf, 1);
3190
3191 for (i = 0; i < 7; i++)
3192 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3193 first10c0[i][0], dev->sensor_flags, &first10c0[i][1]); /* URB 9-48 */
3194
3195 buf[0] = 0x60;
3196 usb_microdia_control_write(dev, 0x1007, buf, 1);
3197
3198 buf[0] = 0x00;
3199 usb_microdia_control_write(dev, 0x1006, buf, 1);
3200
3201 buf[0] = 0x03;
3202 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 50 */
3203
3204 buf[0] = 0x03;
3205 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3206
3207 buf[0] = 0xc6;
3208 usb_microdia_control_write(dev, 0x1001, buf, 1);
3209
3210 buf[0] = 0xc4;
3211 usb_microdia_control_write(dev, 0x1001, buf, 1);
3212
3213 buf[0] = 0x44;
3214 usb_microdia_control_write(dev, 0x1001, buf, 1);
3215
3216 buf[0] = 0x80;
3217 usb_microdia_control_write(dev, 0x1189, buf, 1);
3218
3219 buf[0] = 0x00;
3220 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3221
3222 buf[0] = 0x00;
3223 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3224
3225 buf[0] = 0x00;
3226 usb_microdia_control_write(dev, 0x11be, buf, 1);
3227
3228 buf[0] = 0x00;
3229 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3230
3231 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3232 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
3233
3234 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3235 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
3236
3237 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3238 0x09, dev->sensor_flags, NULL);
3239
3240 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3241 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3242
3243 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
3244 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3245 usb_microdia_control_write(dev, 0x1180, buf, 6);
3246
3247 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3248 buf[3] = 0xf0; buf[4] = 0x00;
3249 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 70 */
3250
3251 buf[0] = 0x8c;
3252 usb_microdia_control_write(dev, 0x1189, buf, 1);
3253
3254 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3255 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3256
3257 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3258 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3259
3260 buf[0] = 0x78;
3261 usb_microdia_control_write(dev, 0x1000, buf, 1);
3262
3263 buf[0] = 0x18;
3264 usb_microdia_control_write(dev, 0x1002, buf, 1);
3265
3266 buf[0] = 0x18;
3267 usb_microdia_control_write(dev, 0x1002, buf, 1);
3268
3269 buf[0] = 0x38;
3270 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3271
3272 buf[0] = 0x02;
3273 usb_microdia_control_write(dev, 0x118a, buf, 1);
3274
3275 buf[0] = 0x02;
3276 usb_microdia_control_write(dev, 0x0395, buf, 1);
3277
3278 buf[0] = 0x78;
3279 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 80 */
3280 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3281
3282 buf[0] = 0xf9;
3283 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3284 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3285
3286 buf[0] = 0xfa;
3287 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3288 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3289
3290 buf[0] = 0x7b;
3291 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3292 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3293
3294 buf[0] = 0x7c;
3295 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3296 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3297
3298 buf[0] = 0x7b;
3299 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 90 */
3300
3301 for (i = 0; i < 4; i++)
3302 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3303 third10c0[i][0], dev->sensor_flags, &third10c0[i][1]); /* URB 97-106 */
3304
3305 buf[0] = 0x06;
3306 usb_microdia_control_write(dev, 0x1180, buf, 1);
3307
3308 for (i = 0; i < 3; i++)
3309 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3310 fourth10c0a[i][0], dev->sensor_flags, &fourth10c0a[i][1]);
3311
3312 for (i = 0; i < 2; i++)
3313 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3314 fourth10c0b[i][0], dev->sensor_flags, &fourth10c0b[i][1]);
3315
3316 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3317 0x33, dev->sensor_flags, NULL);
3318
3319 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3320 first10c0[0][0], dev->sensor_flags, &first10c0[0][1]);
3321
3322 buf[0] = 0x0a;
3323 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3324
3325 buf[0] = 0x10;
3326 usb_microdia_control_write(dev, 0x118b, buf, 1);
3327
3328 buf[0] = 0x05;
3329 usb_microdia_control_write(dev, 0x10f7, buf, 1);
3330
3331 buf[0] = 0x14;
3332 usb_microdia_control_write(dev, 0x10f8, buf, 1);
3333
3334 buf[0] = 0xff;
3335 usb_microdia_control_write(dev, 0x10fa, buf, 1);
3336
3337 buf[0] = 0x00;
3338 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3339
3340 buf[0] = 0x00;
3341 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3342
3343 buf[0] = 0x0a;
3344 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3345
3346 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
3347 usb_microdia_control_write(dev, 0x11bc, buf, 4);
3348
3349 /* Set whole array buf to 0x00 */
3350 memset(buf, 0x00, 48);
3351 usb_microdia_control_write(dev, 0x11c0, buf, 48);
3352
3353 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a;
3354 buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
3355 usb_microdia_control_write(dev, 0x11a5, buf, 6);
3356
3357 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
3358 usb_microdia_control_write(dev, 0x11af, buf, 4);
3359
3360 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
3361 usb_microdia_control_write(dev, 0x11b3, buf, 4);
3362
3363 buf[0] = 0x07;
3364 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3365
3366 buf[0] = 0x01;
3367 usb_microdia_control_write(dev, 0x1061, buf, 1);
3368
3369 buf[0] = 0x27;
3370 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3371
3372 usb_microdia_control_write(dev, 0x1100, qtable1, 64);
3373
3374 usb_microdia_control_write(dev, 0x1140, qtable2, 64); /* URB 150 */
3375
3376 buf[0] = 0x07;
3377 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3378
3379 buf[0] = 0x03;
3380 usb_microdia_control_write(dev, 0x1061, buf, 1);
3381
3382 buf[0] = 0x0b;
3383 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3384
3385 buf[0] = 0x8c;
3386 usb_microdia_control_write(dev, 0x1189, buf, 1);
3387
3388 buf[0] = 0x00;
3389 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3390
3391 buf[0] = 0x00;
3392 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3393
3394 buf[0] = 0x00;
3395 usb_microdia_control_write(dev, 0x11be, buf, 1);
3396
3397 buf[0] = 0x00;
3398 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3399
3400 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3401 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
3402
3403 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3404 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
3405
3406 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3407 0x09, dev->sensor_flags, NULL);
3408
3409 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3410 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3411
3412 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
3413 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3414 usb_microdia_control_write(dev, 0x1180, buf, 6);
3415
3416 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3417 buf[3] = 0xf0; buf[4] = 0x00;
3418 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3419
3420 buf[0] = 0x8c;
3421 usb_microdia_control_write(dev, 0x1189, buf, 1);
3422
3423 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3424 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 170 */
3425
3426 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3427 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3428
3429 buf[0] = 0x03;
3430 usb_microdia_control_write(dev, 0x1061, buf, 1);
3431
3432 buf[0] = 0x0a;
3433 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3434
3435 buf[0] = 0x00;
3436 usb_microdia_control_write(dev, 0x11b9, buf, 1);
3437
3438 buf[0] = 0x0b;
3439 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3440
3441 buf[0] = 0x01;
3442 usb_microdia_control_write(dev, 0x1061, buf, 1);
3443
3444 buf[0] = 0x78;
3445 usb_microdia_control_write(dev, 0x1000, buf, 1);
3446
3447 buf[0] = 0x18;
3448 usb_microdia_control_write(dev, 0x1002, buf, 1);
3449
3450 buf[0] = 0x18;
3451 usb_microdia_control_write(dev, 0x1002, buf, 1);
3452
3453 buf[0] = 0x7b;
3454 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 180 */
3455
3456 buf[0] = 0x02;
3457 usb_microdia_control_write(dev, 0x118a, buf, 1);
3458
3459 buf[0] = 0x02;
3460 usb_microdia_control_write(dev, 0x0395, buf, 1);
3461
3462 buf[0] = 0x78;
3463 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3464 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3465
3466 buf[0] = 0xf9;
3467 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3468 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3469
3470 buf[0] = 0xfa;
3471 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3472 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3473
3474 buf[0] = 0x7b;
3475 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3476 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 190 */
3477
3478 buf[0] = 0x7c;
3479 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3480 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3481
3482 buf[0] = 0x7b;
3483 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3484
3485 for (i = 0; i < 3; i++)
3486 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3487 fifth10c0[i][0], dev->sensor_flags, &fifth10c0[i][1]); /* URB 200-205 */
3488
3489 sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2,
3490 0x00, dev->sensor_flags, buf);
3491 /* __u8 result[2] = {buf[3], buf[4]}; */
3492
3493 buf[0] = 0x03;
3494 usb_microdia_control_write(dev, 0x1061, buf, 1);
3495
3496 return 0;
3497 }
3498
3499
3500 /**
3501 * @brief From startstream.log
3502 *
3503 * @param dev
3504 *
3505 * @returns 0
3506 *
3507 * @author GWater
3508 *
3509 * For SN9C201 with SOI968.
3510 * This is function triggers a working stream of image data and a glowing LED.
3511 */
3512 int microdia_624e_start_stream(struct usb_microdia *dev)
3513 {
3514 int i = -1;
3515 __u8 buf[48];
3516
3517 __u8 urb10[24] =
3518 {0x47, 0x18, 0x00, 0x30, 0x00, 0x09, 0x00, 0xed,
3519 0x0f, 0xda, 0x0f, 0x3a, 0x00, 0x3a, 0x00, 0xd0,
3520 0x0f, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x60, 0x0a};
3521
3522 __u8 urb14[22] =
3523 {0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x24, 0x3b,
3524 0x4f, 0x61, 0x71, 0x80, 0x8f, 0x9d, 0xab, 0xb8,
3525 0xc4, 0xd1, 0xdd, 0xe9, 0xf4, 0xff};
3526
3527 __u8 qtable1[64] =
3528 {0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3529 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3530 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3531 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
3532 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
3533 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
3534 0x4f, 0x53, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
3535 0x64, 0x5c, 0x53, 0x64, 0x4b, 0x53, 0x58, 0x53};
3536
3537 __u8 qtable2[64] =
3538 {0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
3539 0x15, 0x26, 0x53, 0x36, 0x2e, 0x36, 0x53, 0x53,
3540 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3541 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3542 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3543 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3544 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3545 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53};
3546
3547 __u8 first10c0[20][2] = {
3548 {0x12, 0x80}, {0x12, 0x00}, {0x0c, 0x00}, {0x0f, 0x1f},
3549 {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00}, {0x33, 0x08},
3550 {0x35, 0x8c}, {0x36, 0x0c}, {0x37, 0x04}, {0x45, 0x04},
3551 {0x47, 0xff}, {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20},
3552 {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x4e}, {0x13, 0x88} };
3553
3554 __u8 second10c0a[2] =
3555 {0x12, 0x40};
3556 __u8 second10c0b[5] =
3557 {0x17, 0x13, 0x63, 0x01, 0x79}; /* 4 bytes */
3558 __u8 second10c0c[2] =
3559 {0x1b, 0x00}; /* 0 bytes */
3560 __u8 second10c0d[2][2] = {
3561 {0x32, 0x24},
3562 {0x03, 0x00} };
3563
3564 __u8 third10c0a[5][2] = {
3565 {0x11, 0x40},
3566 {0x2a, 0x10},
3567 {0x2b, 0xe0},
3568 {0x10, 0x32},
3569 {0x00, 0x00} };
3570 __u8 third10c0b[3] =
3571 {0x01, 0x80, 0x80}; /* 2 bytes */
3572
3573 __u8 read10c0[4] =
3574 {0x0a, 0x0b, 0x1c, 0x1d}; /* these are four addresses */
3575
3576 /* interrupt down */
3577
3578 buf[0] = 0x00;
3579 usb_microdia_control_write(dev, 0x1066, buf, 1);
3580
3581 /* interrupt up and down */
3582
3583 buf[0] = 0x78;
3584 usb_microdia_control_write(dev, 0x1000, buf, 1);
3585
3586 buf[0] = 0xc7;
3587 usb_microdia_control_write(dev, 0x1001, buf, 1);
3588
3589 buf[0] = 0x1c;
3590 usb_microdia_control_write(dev, 0x1002, buf, 1);
3591
3592 buf[0] = 0xa0; buf[1] = 0xa0;
3593 usb_microdia_control_write(dev, 0x1006, buf, 2);
3594
3595 buf[0] = 0x01;
3596 usb_microdia_control_write(dev, 0x1061, buf, 1);
3597
3598 buf[0] = 0x80;
3599 usb_microdia_control_write(dev, 0x1020, buf, 1);
3600
3601 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
3602 buf[3] = 0x10; buf[4] = 0x08;
3603 usb_microdia_control_write(dev, 0x1067, buf, 5);
3604
3605 buf[0] = 0x92; buf[1] = dev->sensor_slave_address; buf[2] = 0x00;
3606 buf[3] = 0x00; buf[4] = 0x1d; buf[5] = 0x00;
3607 buf[6] = 0xa2; buf[7] = 0x10; buf[8] = 0x03;
3608 usb_microdia_control_write(dev, 0x10c0, buf, 9);
3609
3610 usb_microdia_control_write(dev, 0x10e0, urb10, 24);
3611
3612 buf[0] = 0x00; buf[1] = 0x00; buf[3] = 0x00;
3613 usb_microdia_control_write(dev, 0x10f8, buf, 3);
3614
3615 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3616 buf[3] = 0xf0; buf[4] = 0x00;
3617 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3618
3619 buf[0] = 0x8a; buf[1] = 0xcc; buf[2] = 0x08;
3620 usb_microdia_control_write(dev, 0x1188, buf, 3);
3621
3622 usb_microdia_control_write(dev, 0x118b, urb14, 22);
3623
3624 buf[0] = 0x00; buf[1] = 0x00;
3625 usb_microdia_control_write(dev, 0x11a1, buf, 2);
3626
3627 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00;
3628 buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x40;
3629 buf[6] = 0x01; buf[7] = 0xf0; buf[8] = 0x00;
3630 usb_microdia_control_write(dev, 0x11b7, buf, 9);
3631
3632 buf[0] = 0x30;
3633 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3634
3635 buf[0] = 0x78;
3636 usb_microdia_control_write(dev, 0x1000, buf, 1);
3637
3638 for (i = 0; i < 20; i++)
3639 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3640 first10c0[i][0], dev->sensor_flags, &first10c0[i][1]);
3641
3642 buf[0] = 0x47;
3643 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3644
3645 buf[0] = 0x07;
3646 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3647
3648 buf[0] = 0xc6;
3649 usb_microdia_control_write(dev, 0x1001, buf, 1);
3650
3651 buf[0] = 0xc4;
3652 usb_microdia_control_write(dev, 0x1001, buf, 1);
3653
3654 buf[0] = 0x44;
3655 usb_microdia_control_write(dev, 0x1001, buf, 1);
3656
3657 buf[0] = 0x8c;
3658 usb_microdia_control_write(dev, 0x1189, buf, 1);
3659
3660 buf[0] = 0x00;
3661 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3662
3663 buf[0] = 0x00;
3664 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3665
3666 buf[0] = 0x00;
3667 usb_microdia_control_write(dev, 0x11be, buf, 1);
3668
3669 buf[0] = 0x00;
3670 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3671
3672
3673 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3674 second10c0a[0], dev->sensor_flags, &second10c0a[1]);
3675
3676 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3677 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3678
3679 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3680 second10c0c[0], dev->sensor_flags, &second10c0c[1]);
3681
3682 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3683 second10c0d[0][0], dev->sensor_flags, &second10c0d[0][1]);
3684
3685 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3686 second10c0d[1][0], dev->sensor_flags, &second10c0d[1][1]);
3687
3688 buf[0] = 0x3c; buf[1] = 0x00; buf[2] = 0x0b;
3689 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3690 usb_microdia_control_write(dev, 0x1180, buf, 6);
3691
3692 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3693 buf[3] = 0xf0; buf[4] = 0x00;
3694 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3695
3696 buf[0] = 0x8c;
3697 usb_microdia_control_write(dev, 0x1189, buf, 1);
3698
3699 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3700 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3701
3702 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3703 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3704
3705 buf[0] = 0x7c;
3706 usb_microdia_control_write(dev, 0x1000, buf, 1);
3707
3708 buf[0] = 0x1c;
3709 usb_microdia_control_write(dev, 0x1002, buf, 1);
3710
3711 buf[0] = 0x1c;
3712 usb_microdia_control_write(dev, 0x1002, buf, 1);
3713
3714 buf[0] = 0x38;
3715 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3716
3717 buf[0] = 0x05;
3718 usb_microdia_control_write(dev, 0x118a, buf, 1);
3719
3720 buf[0] = 0x05;
3721 usb_microdia_control_write(dev, 0x0395, buf, 1);
3722
3723 buf[0] = 0x78;
3724 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3725 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3726
3727 buf[0] = 0xf9;
3728 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3729 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3730
3731 buf[0] = 0x7a;
3732 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3733 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3734
3735 buf[0] = 0x7b;
3736 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3737 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3738
3739 buf[0] = 0x7c;
3740 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3741 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3742
3743 buf[0] = 0xfd;
3744 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3745 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3746
3747 buf[0] = 0xfe;
3748 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3749 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3750
3751 buf[0] = 0x7f;
3752 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3753 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3754
3755 buf[0] = 0x7a;
3756 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3757
3758 for (i = 0; i < 5; i++)
3759 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3760 third10c0a[i][0], dev->sensor_flags, &third10c0a[i][1]);
3761
3762 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3763 third10c0b[0], dev->sensor_flags, &third10c0b[1]);
3764
3765 buf[0] = 0x0a;
3766 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3767
3768 buf[0] = 0x0a;
3769 usb_microdia_control_write(dev, 0x118b, buf, 1);
3770
3771 buf[0] = 0x07;
3772 usb_microdia_control_write(dev, 0x10f7, buf, 1);
3773
3774 buf[0] = 0x14;
3775 usb_microdia_control_write(dev, 0x10f8, buf, 1);
3776
3777 buf[0] = 0xff;
3778 usb_microdia_control_write(dev, 0x10fa, buf, 1);
3779
3780 buf[0] = 0x00;
3781 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3782
3783 buf[0] = 0x00;
3784 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3785
3786 buf[0] = 0x0e;
3787 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3788
3789 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
3790 usb_microdia_control_write(dev, 0x11bc, buf, 4);
3791
3792 /* Set whole buf to 0x00 */
3793 memset(buf, 0, 48);
3794 usb_microdia_control_write(dev, 0x11c0, buf, 48);
3795 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a;
3796 buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
3797 usb_microdia_control_write(dev, 0x11a5, buf, 6);
3798
3799 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
3800 usb_microdia_control_write(dev, 0x11af, buf, 4);
3801
3802 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
3803 usb_microdia_control_write(dev, 0x11b3, buf, 4);
3804
3805 buf[0] = 0x07;
3806 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3807
3808 buf[0] = 0x01;
3809 usb_microdia_control_write(dev, 0x1061, buf, 1);
3810
3811 buf[0] = 0x27;
3812 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3813
3814 usb_microdia_control_write(dev, 0x1100, qtable1, 64);
3815
3816 usb_microdia_control_write(dev, 0x1140, qtable2, 64);
3817
3818 buf[0] = 0x07;
3819 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3820
3821 buf[0] = 0x03;
3822 usb_microdia_control_write(dev, 0x1061, buf, 1);
3823
3824 buf[0] = 0x0b;
3825 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3826
3827 buf[0] = 0x8c;
3828 usb_microdia_control_write(dev, 0x1189, buf, 1);
3829
3830 buf[0] = 0x00;
3831 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3832
3833 buf[0] = 0x00;
3834 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3835
3836 buf[0] = 0x00;
3837 usb_microdia_control_write(dev, 0x11be, buf, 1);
3838
3839 buf[0] = 0x00;
3840 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3841
3842 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3843 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3844
3845 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3846 second10c0c[0], dev->sensor_flags, &second10c0c[1]);
3847
3848 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3849 second10c0d[0][0], dev->sensor_flags, &second10c0d[0][1]);
3850
3851 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3852 second10c0d[1][0], dev->sensor_flags, &second10c0d[1][1]);
3853
3854 buf[0] = 0x3c; buf[1] = 0x00; buf[2] = 0x0b;
3855 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3856 usb_microdia_control_write(dev, 0x1180, buf, 6);
3857
3858 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3859 buf[3] = 0xf0; buf[4] = 0x00;
3860 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3861
3862 buf[0] = 0x8c;
3863 usb_microdia_control_write(dev, 0x1189, buf, 1);
3864
3865 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3866 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3867
3868 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3869 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3870
3871 buf[0] = 0x03;
3872 usb_microdia_control_write(dev, 0x1061, buf, 1);
3873
3874 buf[0] = 0x0e;
3875 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3876
3877 buf[0] = 0x00;
3878 usb_microdia_control_write(dev, 0x11b9, buf, 1);
3879
3880 buf[0] = 0x0f;
3881 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3882
3883 buf[0] = 0x01;
3884 usb_microdia_control_write(dev, 0x1061, buf, 1);
3885
3886 buf[0] = 0x7c;
3887 usb_microdia_control_write(dev, 0x1000, buf, 1);
3888
3889 buf[0] = 0x1c;
3890 usb_microdia_control_write(dev, 0x1002, buf, 1);
3891
3892 buf[0] = 0x1c;
3893 usb_microdia_control_write(dev, 0x1002, buf, 1);
3894
3895 buf[0] = 0x7a;
3896 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3897
3898 buf[0] = 0x05;
3899 usb_microdia_control_write(dev, 0x118a, buf, 1);
3900
3901 buf[0] = 0x05;
3902 usb_microdia_control_write(dev, 0x0395, buf, 1);
3903
3904 buf[0] = 0x78;
3905 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3906 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3907
3908 buf[0] = 0xf9;
3909 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3910 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3911
3912 buf[0] = 0x7a;
3913 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3914 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3915
3916 buf[0] = 0x7b;
3917 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3918 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3919
3920 buf[0] = 0x7c;
3921 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3922 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3923
3924 buf[0] = 0x7d;
3925 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3926 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3927
3928 buf[0] = 0xfe;
3929 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3930 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3931
3932 buf[0] = 0x7f;
3933 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3934 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3935
3936 buf[0] = 0x7a;
3937 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3938
3939 for (i = 0; i < 3; i++)
3940 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3941 third10c0a[i][0], dev->sensor_flags, &third10c0a[i][1]);
3942
3943 for (i = 0; i < 4; i++)
3944 sn9c20x_read_i2c_data(dev, dev->sensor_slave_address,
3945 1, read10c0[i], dev->sensor_flags, buf);
3946
3947 buf[0] = 0x03;
3948 usb_microdia_control_write(dev, 0x1061, buf, 1);
3949
3950 buf[0] = 0xa0;
3951 usb_microdia_control_write(dev, 0x1007, buf, 1);
3952
3953 buf[0] = 0x80;
3954 usb_microdia_control_write(dev, 0x1006, buf, 1);
3955
3956 return 0;
3957 }
3958
3959
3960 int microdia_624f_start_stream(struct usb_microdia *dev)
3961 {
3962 int ret;
3963 __u8 last_11b8[1];
3964 __u8 eeprom_slave_id = 0x50;
3965 __u8 eeprom_flags = SN9C20X_I2C_2WIRE;
3966 __u16 command;
3967 __u8 buf[64];
3968 __u8 unknown1[9] = { dev->sensor_flags, dev->sensor_slave_address,
3969 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
3970
3971 buf[0] = 0x20;
3972 command = 0x1007;
3973 ret = usb_microdia_control_write(dev, command, buf, 1);
3974 if (ret < 0)
3975 goto err;
3976
3977 buf[0] = 0x00;
3978 command = 0x1006;
3979 ret = usb_microdia_control_write(dev, command, buf, 1);
3980 if (ret < 0)
3981 goto err;
3982
3983 buf[0] = 0x78;
3984 command = 0x1000;
3985 ret = usb_microdia_control_write(dev, command, buf, 1);
3986 if (ret < 0)
3987 goto err;
3988
3989 buf[0] = 0xc7;
3990 command = 0x1001;
3991 ret = usb_microdia_control_write(dev, command, buf, 1);
3992 if (ret < 0)
3993 goto err;
3994
3995 buf[0] = 0x1c;
3996 command = 0x1002;
3997 ret = usb_microdia_control_write(dev, command, buf, 1);
3998 if (ret < 0)
3999 goto err;
4000
4001 buf[0] = 0x01;
4002 command = 0x1061;
4003 ret = usb_microdia_control_write(dev, command, buf, 1);
4004 if (ret < 0)
4005 goto err;
4006
4007 buf[0] = 0x80;
4008 command = 0x1020;
4009 ret = usb_microdia_control_write(dev, command, buf, 1);
4010 if (ret < 0)
4011 goto err;
4012
4013 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
4014 buf[3] = 0x10; buf[4] = 0x08;
4015 command = 0x1067;
4016 ret = usb_microdia_control_write(dev, command, buf, 5);
4017 if (ret < 0)
4018 goto err;
4019
4020 /* this is the same register as the I2C write, not sure why
4021 * we're writing 9 bytes -- the SN9C102 docs say all writes
4022 * must be 8 bytes, but we don't have docs for SN9C20x */
4023 command = 0x10c0;
4024 ret = usb_microdia_control_write(dev, command, unknown1, 9);
4025 if (ret < 0)
4026 goto err;
4027
4028 buf[0] = 0x44; buf[23] = 0x0a;
4029 command = 0x10e0;
4030 ret = usb_microdia_control_write(dev, command, buf, 1);
4031 if (ret < 0)
4032 goto err;
4033
4034 buf[0] = 0x60;
4035 command = 0x10f5;
4036 ret = usb_microdia_control_write(dev, command, buf, 1);
4037 if (ret < 0)
4038 goto err;
4039
4040 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
4041 command = 0x10f8;
4042 ret = usb_microdia_control_write(dev, command, buf, 3);
4043 if (ret < 0)
4044 goto err;
4045
4046 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
4047 buf[3] = 0xf0; buf[4] = 0x00;
4048 command = 0x10fb;
4049 ret = usb_microdia_control_write(dev, command, buf, 5);
4050 if (ret < 0)
4051 goto err;
4052
4053 buf[0] = 0x87; buf[1] = 0xcc; buf[2] = 0x08;
4054 command = 0x1188;
4055 ret = usb_microdia_control_write(dev, command, buf, 3);
4056 if (ret < 0)
4057 goto err;
4058
4059 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
4060 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
4061 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
4062 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
4063 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
4064 buf[20] = 0xf4; buf[21] = 0xff;
4065 command = 0x118b;
4066 ret = usb_microdia_control_write(dev, command, buf, 22);
4067 if (ret < 0)
4068 goto err;
4069
4070 buf[0] = 0x00; buf[1] = 0x00;
4071 command = 0x11a1;
4072 ret = usb_microdia_control_write(dev, command, buf, 2);
4073 if (ret < 0)
4074 goto err;
4075
4076 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x08;
4077 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
4078 buf[8] = 0x00;
4079 command = 0x11b7;
4080 ret = usb_microdia_control_write(dev, command, buf, 9);
4081 if (ret < 0)
4082 goto err;
4083
4084 buf[0] = 0x30;
4085 command = 0x11b8;
4086 ret = usb_microdia_control_write(dev, command, buf, 1);
4087 if (ret < 0)
4088 goto err;
4089
4090 buf[0] = 0x78;
4091 command = 0x1000;
4092 ret = usb_microdia_control_write(dev, command, buf, 1);
4093 if (ret < 0)
4094 goto err;
4095
4096 /* reset all SCCB registers to their default values */
4097 buf[0] = OV965X_COM7_SCCB_RESET;
4098 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_COM7,
4099 dev->sensor_flags, buf);
4100 if (ret < 0)
4101 goto err;
4102
4103 buf[0] = 0x7f; /* 0x7f AGC setting */
4104 buf[1] = 0xe0; /* blue gain setting */
4105 buf[2] = 0x90; /* red gain setting */
4106 buf[3] = OV965X_VREF_VSTOP_LOW3(0x04) | OV965X_VREF_VSTART_LOW3(0x02);
4107 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_GAIN,
4108 dev->sensor_flags, buf);
4109 if (ret < 0)
4110 goto err;
4111
4112 /*
4113 this write appears to be unnecessary since we issued
4114 the reset above and the spec says that 0x00 is the default
4115 for all 4 of the registers we're writing to here
4116 */
4117 memset(buf, 0, 4);
4118 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_COM1,
4119 dev->sensor_flags, buf);
4120 if (ret < 0)
4121 goto err;
4122
4123 /* first byte still 0, not sure why, RAVE default is 0x00 too */
4124 buf[0] = 0;
4125 buf[1] = OV965X_COM2_OUTPUT_DRIVE_CAP_2X;
4126 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, OV965X_CTL_RAVE,
4127 dev->sensor_flags, buf);
4128 if (ret < 0)
4129 goto err;
4130
4131 buf[0] = 0x00; buf[1] = 0x00;
4132 /* not sure why we're setting bit 5 below, spec says it's reserved */
4133 buf[2] = OV965X_COM5_15FPS_48MHZ_RGB | 0x20;
4134 /* likewise, spec says 4 & 6 are reserved */
4135 buf[3] = OV965X_COM6_TIMING_RESET_ON_FMT_CHANGE | 0x50;
4136 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_COM3,
4137 dev->sensor_flags, buf);
4138 if (ret < 0)
4139 goto err;
4140
4141 buf[0] = 0xff; /* AEC bits 2-9 */
4142 buf[1] = OV965X_CLKRC_INPUT_CLK_NO_SCALE;
4143 buf[2] = OV965X_COM7_OUTPUT_RAW_RGB;
4144 buf[3] = OV965X_COM8_FAST_AGC_AEC | OV965X_COM8_AEC_STEP_SIZE_NOLIMIT |
4145 /*OV965X_COM8_AGC_ENABLE |*/ OV965X_COM8_AEC_ENABLE | OV965X_COM8_AWB_ENABLE;
4146 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_AECH,
4147 dev->sensor_flags, buf);
4148 if (ret < 0)
4149 goto err;
4150
4151 buf[0] = OV965X_COM9_MAX_AGC_8X | OV965X_COM9_RELAX_EXPOSURE_TIMING |
4152 OV965X_COM9_DROP_VSYNC_ON_FRAME_DROP |
4153 OV965X_COM9_DROP_FRAME_ON_BIG_AEC;
4154 buf[1] = 0x00;
4155 buf[2] = 0x07; /* hmm, spec says this is reserved */
4156 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3, OV965X_CTL_COM9,
4157 dev->sensor_flags, buf);
4158 if (ret < 0)
4159 goto err;
4160
4161 /* this is supposed to be reserved too */
4162 buf[0] = 0x04; buf[1] = 0x00;
4163 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, OV965X_CTL_MVFP,
4164 dev->sensor_flags, buf);
4165 if (ret < 0)
4166 goto err;
4167
4168 buf[0] = 0x78; /* this is the default! */
4169 buf[1] = 0x68; /* this is the default! */
4170 buf[2] = 0xd4; /* this is the default! */
4171 buf[3] = 0x80; /* this is the default! */
4172 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_AEW,
4173 dev->sensor_flags, buf);
4174 if (ret < 0)
4175 goto err;
4176
4177 buf[0] = OV965X_BIAS_SUBTRACT;
4178 buf[1] = OV965X_Gr_COM_BYPASS_ANALOG_BLC | OV965X_Gr_COM_BYPASS_REGULATOR;
4179 buf[2] = 0x00; buf[3] = 0x00;
4180 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_GbBIAS,
4181 dev->sensor_flags, buf);
4182 if (ret < 0)
4183 goto err;
4184
4185 buf[0] = OV965X_BIAS_SUBTRACT;
4186 buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
4187 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_RBIAS,
4188 dev->sensor_flags, buf);
4189 if (ret < 0)
4190 goto err;
4191
4192 buf[0] = 0x08; /* HSYNC rising edge start */
4193 buf[1] = 0x30; /* HSYNC rising edge end */
4194 buf[2] = OV965X_HREF_EDGE_OFT_TO_DATA_OUT(2) | OV965X_HREF_HSTART_LOW3(6)
4195 | OV965X_HREF_HSTOP_LOW3(4);
4196 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3, OV965X_CTL_HSYST,
4197 dev->sensor_flags, buf);
4198 if (ret < 0)
4199 goto err;
4200
4201 /* the docs say all 4 of these bytes are reserved */
4202 buf[0] = 0xe2; buf[1] = 0xbf; buf[2] = 0x81; buf[3] = 0xf9;
4203 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_CHLF,
4204 dev->sensor_flags, buf);
4205 if (ret < 0)
4206 goto err;
4207
4208 /* the docs say these 2 bytes are reserved */
4209 buf[0] = 0x00; buf[1] = 0x93;
4210 buf[2] = 0x50; /* bits 4 and 6 are supposedly reserved */
4211 buf[3] = OV965X_TSLB_OUTPUT_SEQ_UYVY | OV965X_TSLB_DIGITAL_BLC_ENABLE;
4212 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_ADC,
4213 dev->sensor_flags, buf);
4214 if (ret < 0)
4215 goto err;
4216
4217 buf[0] = OV965X_COM11_MANUAL_BANDING_FILTER;
4218 buf[1] = 0x73; /* these bits all reserved */
4219 buf[2] = OV965X_COM13_ENABLE_COLOR_MATRIX | OV965X_COM13_DELAY_Y_CHANNEL
4220 | OV965X_COM13_OUTPUT_DELAY(1);
4221 buf[3] = OV965X_COM14_YUV_EDGE_ENHANCE
4222 | OV965X_COM14_EDGE_ENHANCE_FACTOR_DBL
4223 | 0x0b; /* these last bits supposedly reserved */
4224 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_COM11,
4225 dev->sensor_flags, buf);
4226 if (ret < 0)
4227 goto err;
4228
4229 buf[0] = OV965X_EDGE_EDGE_ENHANCE_LOW4(8)
4230 | OV965X_EDGE_EDGE_ENHANCE_FACTOR(8);
4231 buf[1] = OV965X_COM15_OUTPUT_RANGE_O0_TO_FF | 0x01; /* bit reserved */
4232 buf[2] = 0x00; buf[3] = 0x08; /* this bit supposedly reserved */
4233 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_EDGE,
4234 dev->sensor_flags, buf);
4235 if (ret < 0)
4236 goto err;
4237
4238 buf[0] = 0x00;
4239 /* OV9653 control register 0x43 is reserved, according to the docs */
4240 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x43,
4241 dev->sensor_flags, buf); /* 'Dummy'-write */
4242 if (ret < 0)
4243 goto err;
4244
4245 buf[0] = 0x80; buf[1] = 0x80; buf[2] = 0x40; buf[3] = 0x00;
4246 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_MANU,
4247 dev->sensor_flags, buf);
4248 if (ret < 0)
4249 goto err;
4250
4251 buf[0] = 0x0a;
4252 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DBLV,
4253 dev->sensor_flags, buf);
4254 if (ret < 0)
4255 goto err;
4256
4257 buf[0] = 0x06; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x00;
4258 /* OV9653 control register 0x8b is reserved, according to the docs */
4259 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x8b,
4260 dev->sensor_flags, buf);
4261 if (ret < 0)
4262 goto err;
4263
4264 buf[0] = 0xdf;
4265 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DBLC1,
4266 dev->sensor_flags, buf);
4267 if (ret < 0)
4268 goto err;
4269
4270 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x88; buf[3] = 0x88;
4271 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_DM_LNL,
4272 dev->sensor_flags, buf);
4273 if (ret < 0)
4274 goto err;
4275
4276 buf[0] = 0x04;
4277 /* control reg 0x96 reserved, according to docs */
4278 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, 0x96,
4279 dev->sensor_flags, buf);
4280 if (ret < 0)
4281 goto err;
4282
4283 buf[0] = 0x80;
4284 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_COM26,
4285 dev->sensor_flags, buf);
4286 if (ret < 0)
4287 goto err;
4288
4289 buf[0] = 0x80; buf[1] = 0xb8; buf[2] = 0x92; buf[3] = 0x0a;
4290 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_ACOM2,
4291 dev->sensor_flags, buf);
4292 if (ret < 0)
4293 goto err;
4294
4295 /* reserved, according to docs */
4296 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0xac,
4297 dev->sensor_flags, NULL);
4298 if (ret < 0)
4299 goto err;
4300
4301 buf[0] = 0x1b; buf[1] = 0xbb; buf[2] = 0x05; buf[3] = 0x7d;
4302 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_HSTART,
4303 dev->sensor_flags, buf);
4304 if (ret < 0)
4305 goto err;
4306
4307 buf[0] = 0x00;
4308 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_PSHIFT,
4309 dev->sensor_flags, buf);
4310 if (ret < 0)
4311 goto err;
4312
4313 /* now for some reason it switches to these two reads and
4314 * then back to the long init sequence */
4315 command = 0x10c1;
4316 ret = usb_microdia_control_read(dev, command, buf, 1); /* reads 30 */
4317 if (ret < 0)
4318 goto err;
4319 /* msg("Should read 0x30, read: %x", buf[0]); */
4320
4321 command = 0x10c1;
4322 buf[0] = eeprom_slave_id;
4323 ret = usb_microdia_control_write(dev, command, buf, 1);
4324 if (ret < 0)
4325 goto err;
4326
4327 /* TRY TO READ FROM EEPROM: */
4328 ret = sn9c20x_read_i2c_data(dev, eeprom_slave_id, 1, 0x00, eeprom_flags, buf);
4329 if (ret < 0) {
4330 UDIA_INFO("No EEPROM found\n");
4331 } else {
4332 UDIA_INFO("Read from EEPROM successful\n");
4333 /* returns 0xff -- don't know what we're supposed to do w/ that info */
4334 /* msg("Read from eeprom, should read 0xff, read: %x", buf[0]); */
4335 }
4336
4337 command = 0x10c1;
4338 buf[0] = dev->sensor_slave_address;
4339 ret = usb_microdia_control_write(dev, command, buf, 1);
4340 if (ret < 0)
4341 goto err;
4342
4343 command = 0x10e0;
4344 buf[0] = 0x47;
4345 ret = usb_microdia_control_write(dev, command, buf, 1);
4346 if (ret < 0)
4347 goto err;
4348
4349 command = 0x10e0;
4350 buf[0] = 0x07;
4351 ret = usb_microdia_control_write(dev, command, buf, 1);
4352 if (ret < 0)
4353 goto err;
4354
4355 command = 0x1001;
4356 buf[0] = 0xc6;
4357 ret = usb_microdia_control_write(dev, command, buf, 1);
4358 if (ret < 0)
4359 goto err;
4360
4361 command = 0x1001;
4362 buf[0] = 0xc4;
4363 ret = usb_microdia_control_write(dev, command, buf, 1);
4364 if (ret < 0)
4365 goto err;
4366
4367 command = 0x1001;
4368 buf[0] = 0x44;
4369 ret = usb_microdia_control_write(dev, command, buf, 1);
4370 if (ret < 0)
4371 goto err;
4372
4373 command = 0x1189;
4374 buf[0] = 0x8c;
4375 ret = usb_microdia_control_write(dev, command, buf, 1);
4376 if (ret < 0)
4377 goto err;
4378
4379 command = 0x11bc;
4380 buf[0] = 0x40;
4381 ret = usb_microdia_control_write(dev, command, buf, 1);
4382 if (ret < 0)
4383 goto err;
4384
4385 command = 0x11bd;
4386 buf[0] = 0x01;
4387 ret = usb_microdia_control_write(dev, command, buf, 1);
4388 if (ret < 0)
4389 goto err;
4390
4391 command = 0x11be;
4392 buf[0] = 0xf0;
4393 ret = usb_microdia_control_write(dev, command, buf, 1);
4394 if (ret < 0)
4395 goto err;
4396
4397 command = 0x11bf;
4398 buf[0] = 0x00;
4399 ret = usb_microdia_control_write(dev, command, buf, 1);
4400 if (ret < 0)
4401 goto err;
4402
4403 buf[0] = 0x45;
4404 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_COM7,
4405 dev->sensor_flags, buf);
4406 if (ret < 0)
4407 goto err;
4408
4409 buf[0] = 0x36;
4410 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_VREF,
4411 dev->sensor_flags, buf);
4412 if (ret < 0)
4413 goto err;
4414
4415 buf[0] = 0x24; buf[1] = 0xc5; buf[2] = 0x00; buf[3] = 0x3c;
4416 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, OV965X_CTL_HSTART,
4417 dev->sensor_flags, buf);
4418 if (ret < 0)
4419 goto err;
4420
4421 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, OV965X_CTL_PSHIFT,
4422 dev->sensor_flags, NULL);
4423 if (ret < 0)
4424 goto err;
4425
4426 buf[0] = 0x84;
4427 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_HREF,
4428 dev->sensor_flags, buf);
4429 if (ret < 0)
4430 goto err;
4431
4432 command = 0x1180;
4433 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x07; buf[3] = 0x00;
4434 buf[4] = 0x28; buf[5] = 0x3c;
4435 ret = usb_microdia_control_write(dev, command, buf, 6);
4436 if (ret < 0)
4437 goto err;
4438
4439 command = 0x10fb;
4440 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
4441 buf[4] = 0x00;
4442 ret = usb_microdia_control_write(dev, command, buf, 5);
4443 if (ret < 0)
4444 goto err;
4445
4446 command = 0x1189;
4447 buf[0] = 0x8c;
4448 ret = usb_microdia_control_write(dev, command, buf, 1);
4449 if (ret < 0)
4450 goto err;
4451
4452 command = 0x11a1;
4453 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
4454 ret = usb_microdia_control_write(dev, command, buf, 4);
4455 if (ret < 0)
4456 goto err;
4457
4458 command = 0x11ab;
4459 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
4460 ret = usb_microdia_control_write(dev, command, buf, 4);
4461 if (ret < 0)
4462 goto err;
4463
4464 command = 0x1000;
4465 buf[0] = 0x78;
4466 ret = usb_microdia_control_write(dev, command, buf, 1);
4467 if (ret < 0)
4468 goto err;
4469
4470 command = 0x1002;
4471 buf[0] = 0x18;
4472 ret = usb_microdia_control_write(dev, command, buf, 1);
4473 if (ret < 0)
4474 goto err;
4475
4476 command = 0x1002;
4477 buf[0] = 0x18;
4478 ret = usb_microdia_control_write(dev, command, buf, 1);
4479 if (ret < 0)
4480 goto err;
4481
4482 /* urb 297 */
4483 command = 0x11b8;
4484 buf[0] = 0x38;
4485 ret = usb_microdia_control_write(dev, command, buf, 1);
4486 if (ret < 0)
4487 goto err;
4488
4489 command = 0x118a;
4490 buf[0] = 0x04;
4491 ret = usb_microdia_control_write(dev, command, buf, 1);
4492 if (ret < 0)
4493 goto err;
4494
4495 command = 0x0395;
4496 buf[0] = 0x04;
4497 ret = usb_microdia_control_write(dev, command, buf, 1);
4498 if (ret < 0)
4499 goto err;
4500
4501 command = 0x11b8;
4502 buf[0] = 0x78;
4503 ret = usb_microdia_control_write(dev, command, buf, 1);
4504 if (ret < 0)
4505 goto err;
4506 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x38 */
4507 if (ret < 0)
4508 goto err;
4509 if (buf[0] == 0x38)
4510 buf[0] = 0x79;
4511 else if (buf[0] == 0xb8)
4512 buf[0] = 0xf9;
4513 ret = usb_microdia_control_write(dev, command, buf, 1);
4514 if (ret < 0)
4515 goto err;
4516 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x39 */
4517 if (ret < 0)
4518 goto err;
4519 if (buf[0] == 0x39)
4520 buf[0] = 0x7a;
4521 else if (buf[0] == 0xb9)
4522 buf[0] = 0xfa;
4523 ret = usb_microdia_control_write(dev, command, buf, 1);
4524 if (ret < 0)
4525 goto err;
4526 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x3a */
4527 if (ret < 0)
4528 goto err;
4529 if (buf[0] == 0x3a)
4530 buf[0] = 0x7b;
4531 else if (buf[0] == 0xba)
4532 buf[0] = 0xfb;
4533 ret = usb_microdia_control_write(dev, command, buf, 1);
4534 if (ret < 0)
4535 goto err;
4536 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x3b */
4537 if (ret < 0)
4538 goto err;
4539 if (buf[0] == 0x3b)
4540 buf[0] = 0x7c;
4541 else if (buf[0] == 0xbb)
4542 buf[0] = 0xfc;
4543 ret = usb_microdia_control_write(dev, command, buf, 1);
4544 if (ret < 0)
4545 goto err;
4546 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x3c */
4547 if (ret < 0)
4548 goto err;
4549 last_11b8[0] = buf[0];
4550 buf[0] = last_11b8[0] & 0xf0; /* 0xf0 or 0x70 */
4551 buf[0] = buf[0] | 0x0a; /* => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 5 READS/WRITES */
4552 ret = usb_microdia_control_write(dev, command, buf, 1);
4553 if (ret < 0)
4554 goto err;
4555
4556 buf[0] = 0x80;
4557 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_CLKRC,
4558 dev->sensor_flags, buf);
4559 if (ret < 0)
4560 goto err;
4561
4562 /* urb 331 */
4563 buf[0] = 0x00;
4564 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_EXHCH,
4565 dev->sensor_flags, buf);
4566 if (ret < 0)
4567 goto err;
4568
4569 buf[0] = 0x00;
4570 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_EXHCL,
4571 dev->sensor_flags, buf);
4572 if (ret < 0)
4573 goto err;
4574
4575 buf[0] = 0x00;
4576 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DM_LNL,
4577 dev->sensor_flags, buf);
4578 if (ret < 0)
4579 goto err;
4580
4581 /* urb 347 */
4582 buf[0] = 0x00;
4583 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DM_LNH,
4584 dev->sensor_flags, buf);
4585 if (ret < 0)
4586 goto err;
4587
4588 buf[0] = 0x04;
4589 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_MVFP,
4590 dev->sensor_flags, buf);
4591 if (ret < 0)
4592 goto err;
4593
4594 /* is it really necessary to do this same write again?; 627f does this, too */
4595 buf[0] = 0x04;
4596 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_MVFP,
4597 dev->sensor_flags, buf);
4598 if (ret < 0)
4599 goto err;
4600
4601 /* urb 365 */
4602 command = 0x1182;
4603 buf[0] = 0x07;
4604 ret = usb_microdia_control_write(dev, command, buf, 1);
4605 if (ret < 0)
4606 goto err;
4607
4608 buf[0] = 0x7c;
4609 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_AECH,
4610 dev->sensor_flags, buf);
4611 if (ret < 0)
4612 goto err;
4613
4614 buf[0] = 0x03;
4615 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_COM1,
4616 dev->sensor_flags, buf);
4617 if (ret < 0)
4618 goto err;
4619
4620 /* urb 379 */
4621 buf[0] = 0x00;
4622 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_AECHM,
4623 dev->sensor_flags, buf);
4624 if (ret < 0)
4625 goto err;
4626
4627 buf[0] = 0x00;
4628 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_ADVFL,
4629 dev->sensor_flags, buf);
4630 if (ret < 0)
4631 goto err;
4632
4633 /* urb 391 */
4634 buf[0] = 0x00;
4635 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_ADVFH,
4636 dev->sensor_flags, buf);
4637 if (ret < 0)
4638 goto err;
4639
4640 /* urb 397 */
4641 buf[0] = 0x00;
4642 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_GAIN,
4643 dev->sensor_flags, buf);
4644 if (ret < 0)
4645 goto err;
4646
4647 /* urb 403 */
4648 buf[0] = 0x78; /*buf[1] = 0x78;*/
4649 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_BLUE,
4650 dev->sensor_flags, buf);
4651 if (ret < 0)
4652 goto err;
4653 /* urb 409 */
4654 buf[0] = 0x78;
4655 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_RED,
4656 dev->sensor_flags, buf);
4657 if (ret < 0)
4658 goto err;
4659 /* 627f does the last two writes at once (2 byte write to OV965X_CTL_BLUE) */
4660
4661 /* urb 423 */
4662 command = 0x11ba;
4663 buf[0] = 0x0a;
4664 ret = usb_microdia_control_write(dev, command, buf, 1);
4665 if (ret < 0)
4666 goto err;
4667
4668 if (dev->webcam_model == CAMERA_MODEL(USB_0C45_VID, USB_627F_PID))
4669 buf[0] = 0x0e;
4670 else /* 624f */
4671 buf[0] = 0x00;
4672 command = 0x118b;
4673 ret = usb_microdia_control_write(dev, command, buf, 1);
4674 if (ret < 0)
4675 goto err;
4676
4677 command = 0x10f7;
4678 buf[0] = 0x05;
4679 ret = usb_microdia_control_write(dev, command, buf, 1);
4680 if (ret < 0)
4681 goto err;
4682
4683 command = 0x10f8;
4684 buf[0] = 0x14;
4685 ret = usb_microdia_control_write(dev, command, buf, 1);
4686 if (ret < 0)
4687 goto err;
4688
4689 /* urb 463 */
4690 command = 0x10fa;
4691 buf[0] = 0xff;
4692 ret = usb_microdia_control_write(dev, command, buf, 1);
4693 if (ret < 0)
4694 goto err;
4695
4696 command = 0x10f9;
4697 buf[0] = 0x00;
4698 ret = usb_microdia_control_write(dev, command, buf, 1);
4699 if (ret < 0)
4700 goto err;
4701
4702 /* urb 467 */
4703 command = 0x10f9;
4704 buf[0] = 0x00;
4705 ret = usb_microdia_control_write(dev, command, buf, 1);
4706 if (ret < 0)
4707 goto err;
4708
4709 command = 0x11ba;
4710 buf[0] = 0x0e;
4711 ret = usb_microdia_control_write(dev, command, buf, 1);
4712 if (ret < 0)
4713 goto err;
4714
4715 /* memset(buf, 0, 4); */
4716 command = 0x11bc;
4717 buf[0] = 0x80; buf[1] = 0x02; buf[2] = 0xe0; buf[3] = 0x01;
4718 ret = usb_microdia_control_write(dev, command, buf, 4);
4719 if (ret < 0)
4720 goto err;
4721
4722 command = 0x11c0;
4723 if (dev->webcam_model == CAMERA_MODEL(USB_0C45_VID, USB_627F_PID)) {
4724 buf[0] = 0x19; buf[1] = 0x31; buf[2] = 0x44; buf[3] = 0x50;
4725 buf[4] = 0x52; buf[5] = 0x56; buf[6] = 0x5b; buf[7] = 0x61;
4726 buf[8] = 0x65; buf[9] = 0x6a; buf[10] = 0x6c; buf[11] = 0x6e;
4727 buf[12] = 0x70; buf[13] = 0x72; buf[14] = 0x74; buf[15] = 0x76;
4728 buf[16] = 0x1a; buf[17] = 0x31; buf[18] = 0x44; buf[19] = 0x51;
4729 buf[20] = 0x54; buf[21] = 0x57; buf[22] = 0x5c; buf[23] = 0x61;
4730 buf[24] = 0x66; buf[25] = 0x6b; buf[26] = 0x6d; buf[27] = 0x6f;
4731 buf[28] = 0x71; buf[29] = 0x73; buf[30] = 0x75; buf[31] = 0x76;
4732 buf[32] = 0x1b; buf[33] = 0x32; buf[34] = 0x44; buf[35] = 0x50;
4733 buf[36] = 0x50; buf[37] = 0x54; buf[38] = 0x59; buf[39] = 0x5e;
4734 buf[40] = 0x63; buf[41] = 0x67; buf[42] = 0x6a; buf[43] = 0x6c;
4735 buf[44] = 0x6e; buf[45] = 0x70; buf[46] = 0x72; buf[47] = 0x73;
4736 } else /* 624f */ {
4737 buf[0] = 0x10; buf[1] = 0x21; buf[2] = 0x34; buf[3] = 0x40;
4738 buf[4] = 0x47; buf[5] = 0x4F; buf[6] = 0x57; buf[7] = 0x5F;
4739 buf[8] = 0x64; buf[9] = 0x68; buf[10] = 0x6D; buf[11] = 0x73;
4740 buf[12] = 0x79; buf[13] = 0x80; buf[14] = 0x89; buf[15] = 0x97;
4741 buf[16] = 0x0D; buf[17] = 0x1C; buf[18] = 0x2A; buf[19] = 0x33;
4742 buf[20] = 0x38; buf[21] = 0x3D; buf[22] = 0x44; buf[23] = 0x4A;
4743 buf[24] = 0x4E; buf[25] = 0x52; buf[26] = 0x56; buf[27] = 0x5B;
4744 buf[28] = 0x61; buf[29] = 0x68; buf[30] = 0x6F; buf[31] = 0x7A;
4745 buf[32] = 0x0D; buf[33] = 0x1A; buf[34] = 0x2A; buf[35] = 0x31;
4746 buf[36] = 0x36; buf[37] = 0x3B; buf[38] = 0x41; buf[39] = 0x47;
4747 buf[40] = 0x4A; buf[41] = 0x4E; buf[42] = 0x53; buf[43] = 0x58;
4748 buf[44] = 0x5D; buf[45] = 0x64; buf[46] = 0x6B; buf[47] = 0x76;
4749 }
4750 ret = usb_microdia_control_write(dev, command, buf, 48);
4751
4752 /* urb 483 */
4753 command = 0x11a5;
4754 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
4755 buf[4] = 0x04; buf[5] = 0x3f;
4756 ret = usb_microdia_control_write(dev, command, buf, 6);
4757 if (ret < 0)
4758 goto err;
4759
4760 /* urb 485 */
4761 command = 0x11af;
4762 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
4763 ret = usb_microdia_control_write(dev, command, buf, 4);
4764 if (ret < 0)
4765 goto err;
4766
4767 command = 0x11b3;
4768 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
4769 ret = usb_microdia_control_write(dev, command, buf, 4);
4770 if (ret < 0)
4771 goto err;
4772
4773 /* urb 489 */
4774 command = 0x10e0;
4775 buf[0] = 0x07;
4776 ret = usb_microdia_control_write(dev, command, buf, 1);
4777 if (ret < 0)
4778 goto err;
4779
4780 command = 0x1061;
4781 buf[0] = 0x01;
4782 ret = usb_microdia_control_write(dev, command, buf, 1);
4783 if (ret < 0)
4784 goto err;
4785
4786 command = 0x10e0;
4787 buf[0] = 0x27;
4788 ret = usb_microdia_control_write(dev, command, buf, 1);
4789 if (ret < 0)
4790 goto err;
4791
4792
4793 /* //////////////////////////////////////////////////////////////////// */
4794 /* urb 495 */
4795 command = 0x1100;
4796 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
4797 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
4798 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
4799 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
4800 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
4801 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
4802 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
4803 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
4804 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
4805 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
4806 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
4807 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
4808 buf[48] = 0x4f; buf[49] = 0x54; buf[50] = 0x58; buf[51] = 0x58;
4809 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
4810 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x54; buf[59] = 0x64;
4811 buf[60] = 0x4b; buf[61] = 0x54; buf[62] = 0x58; buf[63] = 0x54;
4812 ret = usb_microdia_control_write(dev, command, buf, 64);
4813 if (ret < 0)
4814 goto err;
4815
4816 command = 0x1140;
4817 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
4818 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
4819 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x54; buf[11] = 0x36;
4820 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x54; buf[15] = 0x54;
4821 buf[16] = 0x54; buf[17] = 0x54; buf[18] = 0x54; buf[19] = 0x54;
4822 buf[20] = 0x54; buf[21] = 0x54; buf[22] = 0x54; buf[23] = 0x54;
4823 buf[24] = 0x54; buf[25] = 0x54; buf[26] = 0x54; buf[27] = 0x54;
4824 buf[28] = 0x54; buf[29] = 0x54; buf[30] = 0x54; buf[31] = 0x54;
4825 buf[32] = 0x54; buf[33] = 0x54; buf[34] = 0x54; buf[35] = 0x54;
4826 buf[36] = 0x54; buf[37] = 0x54; buf[38] = 0x54; buf[39] = 0x54;
4827 buf[40] = 0x54; buf[41] = 0x54; buf[42] = 0x54; buf[43] = 0x54;
4828 buf[44] = 0x54; buf[45] = 0x54; buf[46] = 0x54; buf[47] = 0x54;
4829 buf[48] = 0x54; buf[49] = 0x54; buf[50] = 0x54; buf[51] = 0x54;
4830 buf[52] = 0x54; buf[53] = 0x54; buf[54] = 0x54; buf[55] = 0x54;
4831 buf[56] = 0x54; buf[57] = 0x54; buf[58] = 0x54; buf[59] = 0x54;
4832 buf[60] = 0x54; buf[61] = 0x54; buf[62] = 0x54; buf[63] = 0x54;
4833 ret = usb_microdia_control_write(dev, command, buf, 64);
4834 if (ret < 0)
4835 goto err;
4836
4837 /* urb 499 */
4838 command = 0x10e0;
4839 buf[0] = 0x07;
4840 ret = usb_microdia_control_write(dev, command, buf, 1);
4841 if (ret < 0)
4842 goto err;
4843
4844 command = 0x1061;
4845 buf[0] = 0x03;
4846 ret = usb_microdia_control_write(dev, command, buf, 1);
4847 if (ret < 0)
4848 goto err;
4849
4850 /* urb 503 */
4851 command = 0x10e0;
4852 buf[0] = 0x0b;
4853 ret = usb_microdia_control_write(dev, command, buf, 1);
4854 if (ret < 0)
4855 goto err;
4856
4857 command = 0x1189;
4858 buf[0] = 0x8c;
4859 ret = usb_microdia_control_write(dev, command, buf, 1);
4860 if (ret < 0)
4861 goto err;
4862
4863 buf[0] = 0x40;
4864 command = 0x11bc;
4865 ret = usb_microdia_control_write(dev, command, buf, 1);
4866 if (ret < 0)
4867 goto err;
4868
4869 buf[0] = 0x01;
4870 command = 0x11bd;
4871 ret = usb_microdia_control_write(dev, command, buf, 1);
4872 if (ret < 0)
4873 goto err;
4874
4875 buf[0] = 0xf0;
4876 command = 0x11be;
4877 ret = usb_microdia_control_write(dev, command, buf, 1);
4878 if (ret < 0)
4879 goto err;
4880
4881 buf[0] = 0x00;
4882 command = 0x11bf;
4883 ret = usb_microdia_control_write(dev, command, buf, 1);
4884 if (ret < 0)
4885 goto err;
4886
4887 /* urb 515 */
4888 command = 0x1180;
4889 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x07; buf[3] = 0x00;
4890 buf[4] = 0x28; buf[5] = 0x3c;
4891 ret = usb_microdia_control_write(dev, command, buf, 6);
4892 if (ret < 0)
4893 goto err;
4894
4895 command = 0x10fb;
4896 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
4897 buf[4] = 0x00;
4898 ret = usb_microdia_control_write(dev, command, buf, 5);
4899 if (ret < 0)
4900 goto err;
4901
4902 command = 0x1189;
4903 buf[0] = 0x8c;
4904 ret = usb_microdia_control_write(dev, command, buf, 1);
4905 if (ret < 0)
4906 goto err;
4907
4908 command = 0x11a1;
4909 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
4910 ret = usb_microdia_control_write(dev, command, buf, 4);
4911 if (ret < 0)
4912 goto err;
4913
4914 /* 523 */
4915 command = 0x11ab;
4916 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
4917 ret = usb_microdia_control_write(dev, command, buf, 4);
4918 if (ret < 0)
4919 goto err;
4920
4921 command = 0x1061;
4922 buf[0] = 0x03;
4923 ret = usb_microdia_control_write(dev, command, buf, 1);
4924 if (ret < 0)
4925 goto err;
4926
4927 command = 0x11ba;
4928 buf[0] = 0x0e;
4929 ret = usb_microdia_control_write(dev, command, buf, 1);
4930 if (ret < 0)
4931 goto err;
4932
4933 command = 0x11b9;
4934 buf[0] = 0x00;
4935 ret = usb_microdia_control_write(dev, command, buf, 1);
4936 if (ret < 0)
4937 goto err;
4938
4939 command = 0x11ba;
4940 buf[0] = 0x0f;
4941 ret = usb_microdia_control_write(dev, command, buf, 1);
4942 if (ret < 0)
4943 goto err;
4944
4945 command = 0x1061;
4946 buf[0] = 0x01;
4947 ret = usb_microdia_control_write(dev, command, buf, 1);
4948 if (ret < 0)
4949 goto err;
4950
4951 command = 0x1000;
4952 buf[0] = 0x78;
4953 ret = usb_microdia_control_write(dev, command, buf, 1);
4954 if (ret < 0)
4955 goto err;
4956
4957 command = 0x1002;
4958 buf[0] = 0x18;
4959 ret = usb_microdia_control_write(dev, command, buf, 1);
4960 if (ret < 0)
4961 goto err;
4962
4963 /* urb 539 */
4964 command = 0x1002;
4965 buf[0] = 0x18;
4966 ret = usb_microdia_control_write(dev, command, buf, 1);
4967 if (ret < 0)
4968 goto err;
4969
4970 command = 0x11b8;
4971 buf[0] = 0x7a;
4972 ret = usb_microdia_control_write(dev, command, buf, 1);
4973 if (ret < 0)
4974 goto err;
4975
4976 command = 0x118a;
4977 buf[0] = 0x04;
4978 ret = usb_microdia_control_write(dev, command, buf, 1);
4979 if (ret < 0)
4980 goto err;
4981
4982 /* urb 545 */
4983 command = 0x0395;
4984 buf[0] = 0x04;
4985 ret = usb_microdia_control_write(dev, command, buf, 1);
4986 if (ret < 0)
4987 goto err;
4988
4989 command = 0x11b8;
4990 if (last_11b8[0] == 0x3c)
4991 buf[0] = 0x78;
4992 else if (last_11b8[0] == 0xbc)
4993 buf[0] = 0xf8;
4994 ret = usb_microdia_control_write(dev, command, buf, 1);
4995 if (ret < 0)
4996 goto err;
4997 ret = usb_microdia_control_read(dev, command, buf, 1); /* 624f: 0xb8 627f: 0x38 */
4998 if (ret < 0)
4999 goto err;
5000 if (buf[0] == 0x38)
5001 buf[0] = 0x79;
5002 else if (buf[0] == 0xb8)
5003 buf[0] = 0xf9;
5004 ret = usb_microdia_control_write(dev, command, buf, 1);
5005 if (ret < 0)
5006 goto err;
5007 ret = usb_microdia_control_read(dev, command, buf, 1); /* 624f: 0xb9 627f: 0x39 */
5008 if (ret < 0)
5009 goto err;
5010 if (buf[0] == 0x39)
5011 buf[0] = 0x7a;
5012 else if (buf[0] == 0xb9)
5013 buf[0] = 0xfa;
5014 ret = usb_microdia_control_write(dev, command, buf, 1);
5015 if (ret < 0)
5016 goto err;
5017 ret = usb_microdia_control_read(dev, command, buf, 1); /* 0x3a */
5018 if (ret < 0)
5019 goto err;
5020 if (buf[0] == 0x3a)
5021 buf[0] = 0x7b;
5022 else if (buf[0] == 0xba)
5023 buf[0] = 0xfb;
5024 ret = usb_microdia_control_write(dev, command, buf, 1);
5025 if (ret < 0)
5026 goto err;
5027 ret = usb_microdia_control_read(dev, command, buf, 1); /* 624f: 0x3b 627f: 0xbb */
5028 if (ret < 0)
5029 goto err;
5030 if (buf[0] == 0x3b)
5031 buf[0] = 0x7c;
5032 else if (buf[0] == 0xbb)
5033 buf[0] = 0xfc;
5034
5035 ret = usb_microdia_control_write(dev, command, buf, 1);
5036 if (ret < 0)
5037 goto err;
5038
5039 ret = usb_microdia_control_read(dev, command, buf, 1); /* 624f: 0x3c 627f: 0xbc */
5040 if (ret < 0)
5041 goto err;
5042
5043 buf[0] = buf[0] & 0xf0; /* 0xf0 or 0x70 */
5044
5045 /* THIS VALUE SEEMS TO DEPEND ON WHAT WAS
5046 READ/WRITTEN IN THE LAST 5 READS/WRITES */
5047 if (dev->webcam_model == CAMERA_MODEL(USB_0C45_VID, USB_627F_PID))
5048 buf[0] = buf[0] | 0x09;
5049 else /* 624f */
5050 buf[0] = buf[0] | 0x08;
5051 ret = usb_microdia_control_write(dev, command, buf, 1);
5052 if (ret < 0)
5053 goto err;
5054
5055 buf[0] = 0x80;
5056 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_CLKRC,
5057 dev->sensor_flags, buf);
5058 if (ret < 0)
5059 goto err;
5060
5061 buf[0] = 0x00;
5062 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_EXHCH,
5063 dev->sensor_flags, buf);
5064 if (ret < 0)
5065 goto err;
5066
5067 /* urb 581 */
5068 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_EXHCL,
5069 dev->sensor_flags, buf);
5070 if (ret < 0)
5071 goto err;
5072
5073 /* urb 587 */
5074 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DM_LNL,
5075 dev->sensor_flags, buf);
5076 if (ret < 0)
5077 goto err;
5078
5079 /* urb 593 */
5080 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, OV965X_CTL_DM_LNH,
5081 dev->sensor_flags, buf);
5082 if (ret < 0)
5083 goto err;
5084
5085 command = 0x1061;
5086 buf[0] = 0x03;
5087 ret = usb_microdia_control_write(dev, command, buf, 1);
5088 if (ret < 0)
5089 goto err;
5090
5091 return 0;
5092
5093 err:
5094 UDIA_ERROR("start stream: command %x failed (%d)!\n", command, ret);
5095 return ret;
5096 }
5097
5098 int microdia_6260_start_stream(struct usb_microdia *dev)
5099 {
5100 int ret;
5101 __u8 buf[32];
5102
5103 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
5104 buf[0] = 0x1f;
5105 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
5106 buf[0] = 0x00;
5107 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
5108 buf[0] = 0x20;
5109 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
5110 buf[0] = 0x00;
5111 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
5112 buf[0] = 0x78;
5113 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
5114 buf[0] = 0xc7;
5115 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
5116 buf[0] = 0x18;
5117 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
5118 buf[0] = 0x01;
5119 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
5120 buf[0] = 0x80;
5121 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
5122
5123 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10;
5124 buf[4] = 0x08;
5125 ret = usb_microdia_control_write(dev, 0x1067, buf, 5);
5126
5127 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
5128 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
5129 buf[8] = 0x03;
5130 ret = usb_microdia_control_write(dev, 0x10c0, buf, 9);
5131
5132 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
5133 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
5134 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
5135 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
5136 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
5137 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
5138 ret = usb_microdia_control_write(dev, 0x10e0, buf, 24);
5139
5140 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
5141 ret = usb_microdia_control_write(dev, 0x10f8, buf, 3);
5142
5143 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
5144 buf[4] = 0x00;
5145 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
5146
5147 buf[0] = 0x8a; buf[1] = 0x8c; buf[2] = 0x08;
5148 ret = usb_microdia_control_write(dev, 0x1188, buf, 3);
5149
5150 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
5151 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
5152 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
5153 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
5154 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
5155 buf[20] = 0xf4; buf[21] = 0xff;
5156 ret = usb_microdia_control_write(dev, 0x118b, buf, 22);
5157
5158 buf[0] = 0x00; buf[1] = 0x00;
5159 ret = usb_microdia_control_write(dev, 0x11a1, buf, 2);
5160
5161 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x00;
5162 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
5163 buf[8] = 0x00;
5164 ret = usb_microdia_control_write(dev, 0x11b7, buf, 9);
5165
5166 buf[0] = 0x78;
5167 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
5168
5169 buf[0] = 0x38;
5170 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5171
5172 ret = ov7670_initialise(dev);
5173
5174 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1, 0x3b, dev->sensor_flags, buf);
5175 ret = usb_microdia_control_read(dev, 0x10c1, buf, 1);
5176 buf[0] = 0x50;
5177 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
5178
5179 /* TRY TO READ FROM EEPROM: */
5180 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, dev->sensor_flags, buf);
5181 if (ret < 0)
5182 UDIA_INFO("No EEPROM found\n");
5183 else
5184 UDIA_INFO("Read from EEPROM successful\n");
5185
5186 buf[0] = 0x21;
5187 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
5188 buf[0] = 0x45;
5189 ret = usb_microdia_control_write(dev, 0x10e0, buf, 1);
5190 buf[0] = 0xc6;
5191 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
5192 buf[0] = 0xc4;
5193 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
5194
5195 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
5196 buf[4] = 0x50; buf[5] = 0x3c;
5197 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
5198
5199 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
5200 buf[4] = 0x01;
5201 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
5202
5203 buf[0] = 0x80;
5204 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
5205
5206 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
5207 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
5208
5209 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
5210 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
5211 buf[0] = 0x78;
5212 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
5213 buf[0] = 0x10;
5214 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
5215 buf[0] = 0x00;
5216 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
5217 buf[0] = 0x38;
5218 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5219 buf[0] = 0x04;
5220 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
5221 buf[0] = 0x04;
5222 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
5223 buf[0] = 0x78;
5224 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5225 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5226 buf[0] = 0xf9;
5227 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5228 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5229 buf[0] = 0xfa;
5230 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5231 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5232 buf[0] = 0x7b;
5233 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5234 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5235 buf[0] = 0x7c;
5236 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5237 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5238 buf[0] = 0x7d;
5239 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5240 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5241 buf[0] = 0x7b;
5242 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5243
5244 /* OV7670 Intialise Part 2 */
5245 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
5246 buf[4] = 0x50; buf[5] = 0x3c;
5247 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
5248
5249 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
5250 buf[4] = 0x01;
5251 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
5252
5253 buf[0] = 0x80;
5254 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
5255
5256 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
5257 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
5258
5259 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
5260 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
5261
5262 buf[0] = 0x03;
5263 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
5264 buf[0] = 0x01;
5265 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
5266 buf[0] = 0x78;
5267 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
5268 buf[0] = 0x00;
5269 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
5270 buf[0] = 0x00;
5271 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
5272 buf[0] = 0x7b;
5273 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5274 buf[0] = 0x04;
5275 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
5276 buf[0] = 0x04;
5277 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
5278 buf[0] = 0x78;
5279 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5280 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5281 buf[0] = 0x79;
5282 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5283 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5284 buf[0] = 0x7a;
5285 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5286 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5287 buf[0] = 0x7b;
5288 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5289 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5290 buf[0] = 0x7c;
5291 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5292 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5293 buf[0] = 0x7d;
5294 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5295 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
5296 buf[0] = 0xfa;
5297 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
5298
5299 /* OV7670 Initialisation Part 3 Goes Here */
5300 buf[0] = 0x03;
5301 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
5302
5303 return ret;
5304 }
5305
5306 /**
5307 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
5308 *
5309 * @param dev
5310 *
5311 * @returns 0 (ok) or -1 (error)
5312 *
5313 * @author Comer352l
5314 *
5315 * Windows driver versions: 5.7.23.000
5316 * Windows versions: 2000 and XP
5317 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
5318 * All logs were made using AMCAP with 640x480, RGB24
5319 */
5320 int microdia_6270_start_stream(struct usb_microdia *dev)
5321 {
5322 __u8 buf[64];
5323 __u8 last_11b8[1];
5324 int k;
5325 int retI2C;
5326
5327 /* Check if sensor slave address is valid: */
5328 if ((dev->sensor_slave_address != MT9V111_I2C_SLAVE_ADDRESS) && (dev->sensor_slave_address != MT9V011_I2C_SLAVE_ADDRESS)) {
5329 UDIA_INFO("microdia_6270_start_stream(): Invalid sensor slave address !\n");
5330 return -1;
5331 }
5332
5333 /* <= INTERRUPT COMING BACK (URB 1953) */
5334 /* SWITCH TO ALTERNATE SETTINGS 8 (URB 1954) // NOT IN ALEX'S LOG */
5335 /* => INTERRUPT GOING DOWN (URB 1955) */
5336
5337 buf[0] = 0x00;
5338 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1956 */
5339
5340 /* <= INTERRUPT COMING BACK (URB 1955) */
5341 /* => INTERRUPT GOING DOWN (URB 1957) */
5342
5343 buf[0] = 0x78;
5344 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1958 */
5345 buf[0] = 0xc7;
5346 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 1959 */
5347 buf[0] = 0x18;
5348 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 1960 */
5349 buf[0] = 0x01;
5350 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 1961 */
5351 buf[0] = 0x80;
5352 usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 1962 */
5353 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
5354 usb_microdia_control_write(dev, 0x1067, buf, 5); /* URB 1963 */
5355
5356 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5357 /* STRANGE I2C MESSAGE: */
5358 /* - 9 bytes */
5359 /* - byte 8 = 0x00 at first start + first cycle */
5360 /* - procedure not complete: no wait/check for ack/error, no readout of 0x10c2 */
5361 /* - dummy writes at first cycle and read at second cycle, but there are many I2C messages in the meantime, so this should not work */
5362 /* */
5363 /* AT FIRST START + FIRST CYCLE: */
5364 buf[0] = 0x80; buf[1] = dev->sensor_slave_address; buf[2] = 0x00; buf[3] = 0x00;
5365 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x03;
5366 /* AT ALL FURTHER STARTS + FIRST CYCLE: */
5367 /* MT9V111: I2C MESSAGE => IFP Register 0x33: Auto exposure */
5368 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x33; buf[3] = 0x00; */
5369 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
5370 /* MT9V011: ????????????????????????? */
5371 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x07; buf[3] = 0x00; */
5372 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
5373 /* ALWAYS AT 2nd AND FURTHER CYCLES: */
5374 /* MT9V111: */
5375 /* buf[0] = 0xa2; buf[1] = 0x5c; buf[2] = 0x00; buf[3] = 0x36; */
5376 /* buf[4] = 0x00; buf[5] = 0x82; buf[6] = 0x3a; buf[7] = 0x10; buf[8] = 0x03; */
5377 /* => buf[3] to buf[6] simply contain bytes read with URB 2215 */
5378 /* MT9V011: */
5379 /* buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00; */
5380 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
5381 usb_microdia_control_write(dev, 0x10c0, buf, 9); /* URB 1964 */
5382 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5383
5384 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
5385 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
5386 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
5387 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
5388 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
5389 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
5390 usb_microdia_control_write(dev, 0x10e0, buf, 24); /* URB 1965 */
5391 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
5392 usb_microdia_control_write(dev, 0x10f8, buf, 3); /* URB 1966 */
5393 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5394 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 1967 */
5395 buf[0] = 0x06; buf[1] = 0x0c; buf[2] = 0x08;
5396 usb_microdia_control_write(dev, 0x1188, buf, 3); /* URB 1968 */
5397 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
5398 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
5399 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
5400 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
5401 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
5402 buf[20] = 0xf4; buf[21] = 0xff;
5403 usb_microdia_control_write(dev, 0x118b, buf, 22); /* URB 1969 */
5404 buf[0] = 0x00; buf[1] = 0x00;
5405 usb_microdia_control_write(dev, 0x11a1, buf, 2); /* URB 1970 */
5406 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08;
5407 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
5408 buf[8] = 0x00;
5409 usb_microdia_control_write(dev, 0x11b7, buf, 9); /* URB 1971 */
5410 buf[0] = 0x38;
5411 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 1972 */
5412 buf[0] = 0x78;
5413 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1973 */
5414
5415 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5416 /* I2C MESSAGES */
5417 retI2C = 0;
5418 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5419 /* Write to IFP register 0x0d: Color Correction Register 8 */
5420 buf[0] = 0x00; buf[1] = 0x01;
5421 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1974-1976 */
5422 /* Write to IFP register 0x0d: Color Correction Register 8 */
5423 buf[0] = 0x00; buf[1] = 0x00; /* ??? */
5424 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1977-1979 */
5425 /* Writes to IFP registers 0x01: Register Address Space Selection */
5426 /* 0x02: Color Correction Register 1 */
5427 buf[0] = 0x00; buf[1] = 0x01; /* select IFP address space */
5428 buf[2] = 0x00; buf[3] = 0x16; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5429 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1980-1982 */
5430 /* Writes to IFP registers 0x03: Color Correction Register 3 */
5431 /* 0x04: Color Correction Register 4 */
5432 buf[0] = 0x01; buf[1] = 0xe1; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5433 buf[2] = 0x02; buf[3] = 0x81; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5434 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1983-1985 */
5435 /* Writes to IFP registers 0x05: Aperture Correction (Sharpening) */
5436 /* 0x06: Operating Mode Control */
5437 buf[0] = 0x00; buf[1] = 0x04; /* 100% sharpening, no automatic sharpness reduction at low light // AT FIRST START + FIRST CYCLE: 0x00 0x00: no sharpening */
5438 buf[2] = 0x00; buf[3] = 0x00; /* stop AWB at the current values, no on-the-fly defect correction, no auto exposure, + RESREVED option */
5439 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 1986-1988 */
5440 /* Writes to IFP registers 0x07: Image Flow Processor Soft Reset */
5441 /* 0x08: Output Format Control */
5442 buf[0] = 0x30; buf[1] = 0x02; /* reset // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5443 buf[2] = 0x04; buf[3] = 0x80; /* bypass entire image processing, raw 8+2 Bayer data output directly */
5444 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 1989-1991 */
5445 /* "Dummy" write to IFP Register 0x11: Color Correction Register 12 */
5446 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 1992-1993 */
5447 /* Write to register 0x01: Register address space selection */
5448 /* Write to sensor register 0x02: Column Start */
5449 buf[0] = 0x00; buf[1] = 0x04; /* select sensor address space */
5450 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
5451 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1994-1996 */
5452 /* Writes to sensor registers 0x03: Window Height */
5453 /* 0x04: Window Width */
5454 buf[0] = 0x01; buf[1] = 0xe6; /* 486 */
5455 buf[2] = 0x02; buf[3] = 0x86; /* 646 */
5456 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1997-1999 */
5457 /* Writes to sensor registers 0x05: Horizontal Blanking */
5458 /* 0x06: Vertical Blanking */
5459 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5460 buf[2] = 0x00; buf[3] = 0x00; /* 0 rows */
5461 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 2000-2002 */
5462 /* Writes to sensor registers 0x07: Output Control */
5463 /* 0x08: Row Start */
5464 buf[0] = 0x30; buf[1] = 0x02; /* normal operation + chip enable + RESERVED options */
5465 buf[2] = 0x00; buf[3] = 0x08; /* row 8 */
5466 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 2003-2005 */
5467 /* "Dummy" write to sensor Register 0x11: UNDOCUMENTED */
5468 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 2006-2007 */
5469 /* Writes to sensor registers 0x0c: Shutter Delay */
5470 /* 0x0d: Reset (Soft) (from MT9V011 datasheet) */
5471 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
5472 buf[2] = 0x00; buf[3] = 0x00; /* return to normal operation */
5473 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf); /* URBs 2008-2010 */
5474 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
5475 /* 0x0f: UNDOCUMENTED */
5476 buf[0] = 0x00; buf[1] = 0x00;
5477 buf[2] = 0x00; buf[3] = 0x00;
5478 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf); /* URBs 2011-2013 */
5479 /* Writes to sensor registers 0x10: UNDOCUMENTED */
5480 /* 0x11: UNDOCUMENTED */
5481 buf[0] = 0x00; buf[1] = 0x00;
5482 buf[2] = 0x00; buf[3] = 0x00;
5483 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf); /* URBs 2014-2016 */
5484 /* Writes to sensor registers 0x12: 2X Zoom Col Start => 0x1e bit 0 must be set to activate zoom */
5485 /* 0x13: 2X Zoom Row Start => 0x1e bit 0 must be set to activate zoom */
5486 buf[0] = 0x00; buf[1] = 0xb0; /* column 176 */
5487 buf[2] = 0x00; buf[3] = 0x7c; /* row 124 */
5488 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf); /* URBs 2017-2018 */
5489 /* Writes to sensor registers 0x14: UNDOCUMENTED */
5490 /* 0x15: UNDOCUMENTED */
5491 buf[0] = 0x00; buf[1] = 0x00;
5492 buf[2] = 0x00; buf[3] = 0x00;
5493 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf); /* URBs 2019-2021 */
5494 /* Writes to sensor registers 0x16: UNDOCUMENTED */
5495 /* 0x17: UNDOCUMENTED */
5496 buf[0] = 0x00; buf[1] = 0x00;
5497 buf[2] = 0x00; buf[3] = 0x00;
5498 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf); /* URBs 2022-2024 */
5499 /* Writes to sensor registers 0x18: UNDOCUMENTED */
5500 /* 0x19: UNDOCUMENTED */
5501 buf[0] = 0x00; buf[1] = 0x00;
5502 buf[2] = 0x00; buf[3] = 0x00;
5503 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf); /* URBs 2025-2027 */
5504 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
5505 /* 0x1b: UNDOCUMENTED */
5506 buf[0] = 0x00; buf[1] = 0x00;
5507 buf[2] = 0x00; buf[3] = 0x00;
5508 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf); /* URBs 2028-2030 */
5509 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
5510 /* 0x1d: UNDOCUMENTED */
5511 buf[0] = 0x00; buf[1] = 0x00;
5512 buf[2] = 0x00; buf[3] = 0x00;
5513 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf); /* URBs 2031-2033 */
5514 /* Write to sensor register 0x30: RESERVED */
5515 buf[0] = 0x00; buf[1] = 0x00;
5516 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x30, dev->sensor_flags, buf); /* URBs 2034-2036 */
5517 /* Write to sensor register 0x20: Read Mode */
5518 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
5519 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2037-2039 */
5520 /* Writes to sensor registers 0x30: RESERVED */
5521 /* 0x31: RESERVED */
5522 buf[0] = 0x00; buf[1] = 0x05;
5523 buf[2] = 0x00; buf[3] = 0x00;
5524 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x30, dev->sensor_flags, buf); /* URBs 2040-2042 */
5525 /* "Dummy" write to sensor Register 0x34: RESERVED */
5526 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x34, dev->sensor_flags, NULL); /* URBs 2043-2044 */
5527 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5528 /* Write to sensor register 0x07: Output Control */
5529 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
5530 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
5531 /* Write to sensor register 0x0d: Soft Reset */
5532 buf[0] = 0x00; buf[1] = 0x01; /* reset */
5533 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
5534 /* Write to sensor register 0x0d: Soft Reset */
5535 buf[0] = 0x00; buf[1] = 0x00; /* resume operation */
5536 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
5537 /* Writes to sensor registers 0x01: Row start */
5538 /* 0x02: Column Start */
5539 buf[0] = 0x00; buf[1] = 0x08; /* start with row 8 */
5540 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
5541 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf);
5542 /* Writes to sensor registers 0x03: Window Height */
5543 /* 0x04: Window Width */
5544 buf[0] = 0x01; buf[1] = 0xe1; /* 481 */
5545 buf[2] = 0x02; buf[3] = 0x81; /* 641 */
5546 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf);
5547 /* Writes to sensor registers 0x05: Horizontal Blanking */
5548 /* 0x06: Vertical Blanking */
5549 buf[0] = 0x00; buf[1] = 0x83; /* 131 columns (pixel clocks) */
5550 buf[2] = 0x00; buf[3] = 0x06; /* 6 rows */
5551 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf);
5552 /* Write to sensor register 0x0d: Soft Reset */
5553 buf[0] = 0x00; buf[1] = 0x02; /* UNKNOWN */
5554 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
5555 /* Writes to sensor registers 0x0a: Pixel Clock Speed */
5556 /* 0x0b: Frame Restart */
5557 buf[0] = 0x00; buf[1] = 0x00; /* default */
5558 buf[2] = 0x00; buf[3] = 0x00; /* (has no effect/no restart) */
5559 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0a, dev->sensor_flags, buf);
5560 /* Writes to sensor registers 0x0c: Shutter Delay */
5561 /* 0x0d: Soft Reset */
5562 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
5563 buf[2] = 0x00; buf[3] = 0x00; /* resume operation */
5564 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf);
5565 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
5566 /* 0x0f: UNDOCUMENTED */
5567 buf[0] = 0x00; buf[1] = 0x00;
5568 buf[2] = 0x00; buf[3] = 0x00;
5569 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf);
5570 /* Writes to sensor registers 0x10: UNDOCUMENTED */
5571 /* 0x11: UNDOCUMENTED */
5572 buf[0] = 0x00; buf[1] = 0x00;
5573 buf[2] = 0x00; buf[3] = 0x00;
5574 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf);
5575 /* Writes to sensor registers 0x12: 2X Zoom Column Start (from MT9V111 datasheet) */
5576 /* 0x13: 2X Zoom Row Start (from MT9V111 datasheet) */
5577 buf[0] = 0x00; buf[1] = 0x00; /* column 0 => bit0 of reg 0x1e must be set to activate zoom */
5578 buf[2] = 0x00; buf[3] = 0x00; /* row 0 => bit0 of reg 0x1e must be set to activate zoom */
5579 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf);
5580 /* Writes to sensor registers 0x14: UNDOCUMENTED */
5581 /* 0x15: UNDOCUMENTED */
5582 buf[0] = 0x00; buf[1] = 0x00;
5583 buf[2] = 0x00; buf[3] = 0x00;
5584 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf);
5585 /* Writes to sensor registers 0x16: UNDOCUMENTED */
5586 /* 0x17: UNDOCUMENTED */
5587 buf[0] = 0x00; buf[1] = 0x00;
5588 buf[2] = 0x00; buf[3] = 0x00;
5589 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf);
5590 /* Writes to sensor registers 0x18: UNDOCUMENTED */
5591 /* 0x19: UNDOCUMENTED */
5592 buf[0] = 0x00; buf[1] = 0x00;
5593 buf[2] = 0x00; buf[3] = 0x00;
5594 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf);
5595 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
5596 /* 0x1b: UNDOCUMENTED */
5597 buf[0] = 0x00; buf[1] = 0x00;
5598 buf[2] = 0x00; buf[3] = 0x00;
5599 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf);
5600 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
5601 /* 0x1d: UNDOCUMENTED */
5602 buf[0] = 0x00; buf[1] = 0x00;
5603 buf[2] = 0x00; buf[3] = 0x00;
5604 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf);
5605 /* Write to sensor register 0x32: RESERVED */
5606 buf[0] = 0x00; buf[1] = 0x00;
5607 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x32, dev->sensor_flags, buf);
5608 /* Writes to sensor registers 0x20: Read Mode */
5609 /* 0x21: RESERVED */
5610 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad frames) + UNDOCUMENTED */
5611 buf[2] = 0x00; buf[3] = 0x00;
5612 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x20, dev->sensor_flags, buf);
5613 /* Writes to sensor registers 0x22: RESERVED */
5614 /* 0x23: UNDOCUMENTED */
5615 buf[0] = 0x00; buf[1] = 0x00;
5616 buf[2] = 0x00; buf[3] = 0x00;
5617 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x22, dev->sensor_flags, buf);
5618 /* Writes to sensor registers 0x24: UNDOCUMENTED */
5619 /* 0x25: UNDOCUMENTED */
5620 buf[0] = 0x00; buf[1] = 0x00;
5621 buf[2] = 0x00; buf[3] = 0x00;
5622 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x24, dev->sensor_flags, buf);
5623 /* Writes to sensor registers 0x26: UNDOCUMENTED */
5624 /* 0x27: RESERVED */
5625 buf[0] = 0x00; buf[1] = 0x00;
5626 buf[2] = 0x00; buf[3] = 0x24;
5627 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x26, dev->sensor_flags, buf);
5628 /* "Dummy" write to sensor Register 0x30: RESERVED */
5629 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x30, dev->sensor_flags, NULL);
5630 /* Writes to sensor registers 0x2f: RESERVED */
5631 /* 0x30: RESERVED */
5632 buf[0] = 0xf7; buf[1] = 0xb0;
5633 buf[2] = 0x00; buf[3] = 0x05;
5634 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2f, dev->sensor_flags, buf);
5635 /* Writes to sensor registers 0x31: RESERVED */
5636 /* 0x32: RESERVED */
5637 buf[0] = 0x00; buf[1] = 0x00;
5638 buf[2] = 0x00; buf[3] = 0x00;
5639 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x31, dev->sensor_flags, buf);
5640 /* Writes to sensor registers 0x33: RESERVED */
5641 /* 0x34: RESERVED */
5642 buf[0] = 0x00; buf[1] = 0x00;
5643 buf[2] = 0x01; buf[3] = 0x00;
5644 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x33, dev->sensor_flags, buf);
5645 /* "Dummy" write to sensor Register 0x3b: RESERVED */
5646 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x3b, dev->sensor_flags, NULL);
5647 /* Write to sensor register 0x3d: RESERVED */
5648 buf[0] = 0x06; buf[1] = 0x8f;
5649 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x3d, dev->sensor_flags, buf);
5650 /* Writes to sensor registers 0x40: RESERVED */
5651 /* 0x41: RESERVED */
5652 buf[0] = 0x01; buf[1] = 0xe0;
5653 buf[2] = 0x00; buf[3] = 0xd1;
5654 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x40, dev->sensor_flags, buf);
5655 /* Write to sensor register 0x44: UNDOCUMENTED */
5656 buf[0] = 0x00; buf[1] = 0x82;
5657 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x44, dev->sensor_flags, buf);
5658 /* Writes to sensor registers 0x5a: RESERVED */
5659 /* 0x5b: RESERVED */
5660 buf[0] = 0x00; buf[1] = 0x00;
5661 buf[2] = 0x00; buf[3] = 0x00;
5662 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5a, dev->sensor_flags, buf);
5663 /* Writes to sensor registers 0x5c: RESERVED */
5664 /* 0x5d: RESERVED */
5665 buf[0] = 0x00; buf[1] = 0x00;
5666 buf[2] = 0x00; buf[3] = 0x00;
5667 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5c, dev->sensor_flags, buf);
5668 /* Writes to sensor registers 0x5e: RESERVED */
5669 /* 0x5f: RESERVED */
5670 buf[0] = 0x00; buf[1] = 0x00;
5671 buf[2] = 0xa3; buf[3] = 0x1d;
5672 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5e, dev->sensor_flags, buf);
5673 /* "Dummy" write to sensor Register 0x68: UNDOCUMENTED */
5674 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x68, dev->sensor_flags, NULL);
5675 /* Write to sensor register 0x62: RESERVED */
5676 buf[0] = 0x06; buf[1] = 0x11;
5677 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x62, dev->sensor_flags, buf);
5678 }
5679 if (retI2C < 0) {
5680 UDIA_INFO("1 or more errors occured in I2C-message-block 1 !\n");
5681 return -1;
5682 }
5683 /* END OF I2C MESSAGES */
5684 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5685
5686 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5687 buf[0] = 0x40;
5688 usb_microdia_control_write(dev, 0x1007, buf, 8);
5689 buf[0] = 0x40;
5690 usb_microdia_control_write(dev, 0x1006, buf, 8);
5691 }
5692
5693
5694 /* *** TEMPORARY SWITCH TO SLAVE ADDRESS 0x50, I2C READ ATTEMPT: */
5695 /* - WE CURRENTLY KNOW NO 6270 CAM THAT IS SUCCESSFULLY READ HERE */
5696 /* - IF READ FAILS, THIS IS NEVER DONE AGAIN (IN NEXT CYCLE OR FURTHER STARTS) */
5697 usb_microdia_control_read(dev, 0x10c1, buf, 1); /* returns 0x5c */
5698 buf[0] = 0x50;
5699 usb_microdia_control_write(dev, 0x10c1, buf, 1);
5700 retI2C = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, SN9C20X_I2C_2WIRE, buf);
5701 if (retI2C >= 0)
5702 UDIA_INFO("Read of address 0x00 from slave 0x50 successful:\n=> Please report this to microdia@googlegroups.com (http:/* groups.google.com/group/microdia) !\n");
5703 buf[0] = 0x5c;
5704 usb_microdia_control_write(dev, 0x10c1, buf, 1);
5705
5706
5707 buf[0] = 0x47; /* ALEX: 0x44 */
5708 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2045 */
5709 buf[0] = 0x47; /* ALEX: 0x04 */
5710 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2046 */
5711 buf[0] = 0xc6;
5712 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2047 */
5713 buf[0] = 0xc4;
5714 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2048 */
5715 buf[0] = 0x84; /* ALEX: 0xc0 */
5716 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2049 */
5717 /* ALEX:
5718 buf[0] = 0x40;
5719 usb_microdia_control_write(dev, 0x1001, buf, 1);
5720 */
5721
5722 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5723 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5724 /* I2C MESSAGES */
5725 retI2C = 0;
5726 /* Writes to sensor registers 0x02: Column Start */
5727 /* 0x03: Window Height */
5728 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
5729 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
5730 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2050-2052 */
5731 /* Writes to sensor registers 0x04: Window Width */
5732 /* 0x05: Horizontal Blanking */
5733 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
5734 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
5735 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2053-2055 */
5736 /* Writes to sensor registers 0x06: Vertical Blanking */
5737 /* 0x07: Output Control */
5738 buf[0] = 0x00; buf[1] = 0x00; /* 0 rows */
5739 buf[2] = 0x30; buf[3] = 0x02; /* normal operation + chip enable + RESERVED options */
5740 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2056-2058 */
5741 /* Write to sensor register 0x0e: UNDOCUMENTED */
5742 buf[0] = 0x00; buf[1] = 0x08;
5743 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2059-2061 */
5744 if (retI2C < 0) {
5745 UDIA_INFO("1 or more errors occured in I2C-message-block 2 !\n");
5746 return -1;
5747 }
5748 /* END OF I2C MESSAGES */
5749 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5750 }
5751
5752 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
5753 buf[4] = 0x28; buf[5] = 0x3c;
5754 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2062 */
5755 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5756 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2063 */
5757 buf[0] = 0x0c;
5758 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2064 */
5759 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
5760 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2065 */
5761 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
5762 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2066 */
5763 buf[0] = 0x78; /* ALEX: 0x7c */
5764 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2067 */
5765 buf[0] = 0x18; /* ALEX: 0x1c */
5766 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2068 */
5767 buf[0] = 0x18; /* ALEX: 0x1c */
5768 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2069 */
5769 buf[0] = 0x38;
5770 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2070 */
5771 buf[0] = 0x04;
5772 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2071 */
5773 buf[0] = 0x04;
5774 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2072 */
5775
5776 buf[0] = 0x78;
5777 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2073 */
5778 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2074 // 0x38 */
5779 if (buf[0] == 0x38)
5780 buf[0] = 0x79;
5781 else if (buf[0] == 0xb8)
5782 buf[0] = 0xf9;
5783 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2075 */
5784 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2076 // 0xb9 */
5785 if (buf[0] == 0x39)
5786 buf[0] = 0x7a;
5787 else if (buf[0] == 0xb9)
5788 buf[0] = 0xfa;
5789 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2077 */
5790 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2078 */
5791 if (buf[0] == 0x3a)
5792 buf[0] = 0x7b;
5793 else if (buf[0] == 0xba)
5794 buf[0] = 0xfb;
5795 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2079 */
5796 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2080 // 0x3b */
5797 if (buf[0] == 0x3b)
5798 buf[0] = 0x7c;
5799 else if (buf[0] == 0xbb)
5800 buf[0] = 0xfc;
5801 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2081 */
5802 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2082 // 0x3c */
5803 if (buf[0] == 0x3c)
5804 buf[0] = 0x7d;
5805 else if (buf[0] == 0xbc)
5806 buf[0] = 0xfd;
5807 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2083 */
5808 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2084 // 0x3d */
5809 last_11b8[0] = buf[0];
5810 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5811 if (buf[0] == 0x3d)
5812 buf[0] = 0x7e;
5813 else if (buf[0] == 0xbd)
5814 buf[0] = 0xfe;
5815 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2085 */
5816 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2086 */
5817 if (buf[0] == 0x3e)
5818 buf[0] = 0x7f;
5819 else if (buf[0] == 0xbe)
5820 buf[0] = 0xff;
5821 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2087 */
5822 usb_microdia_control_read(dev, 0x11b8, last_11b8, 1); /* URB 2088 */
5823 }
5824 buf[0] = last_11b8[0] & 0xf0; /* 0xf0 or 0x70 */
5825 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
5826 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
5827
5828
5829 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5830 /* I2C MESSAGES */
5831 retI2C = 0;
5832 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5833 /* Write to sensor register 0x06: Vertical Blanking */
5834 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
5835 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2090-2092 */
5836 /* Write to sensor register 0x05: Horizontal Blanking */
5837 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
5838 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2093-2095 */
5839 /* Write to sensor register 0x20: Read Mode */
5840 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
5841 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2096-2098 */
5842 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5843 /* Write to sensor register 0x0a: Pixel Clock Speed */
5844 buf[0] = 0x00; buf[1] = 0x00; /* default */
5845 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0a, dev->sensor_flags, buf);
5846 /* Write to sensor register 0x06: Vertical Blanking */
5847 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
5848 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
5849 /* Write to sensor register 0x05: Horizontal Blanking */
5850 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
5851 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
5852 /* Write to sensor register 0x20: Read Mode */
5853 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
5854 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
5855 }
5856 if (retI2C < 0) {
5857 UDIA_INFO("1 or more errors occured in I2C-message-block 3 !\n");
5858 return -1;
5859 }
5860 /* END OF I2C MESSAGES */
5861 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5862
5863
5864 buf[0] = 0x02;
5865 usb_microdia_control_write(dev, 0x1180, buf, 1); /* URB 2099 */
5866
5867 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5868 /* I2C MESSAGE */
5869 retI2C = 0;
5870 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5871 /* Write to sensor register 0x20: Read Mode */
5872 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
5873 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2100-2102 */
5874 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5875 /* Write to sensor register 0x20: Read Mode */
5876 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
5877 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
5878 }
5879 if (retI2C < 0) {
5880 UDIA_INFO("1 or more errors occured in I2C-message-block 4 !\n");
5881 return -1;
5882 }
5883 /* END OF I2C MESSAGES */
5884 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5885
5886
5887 buf[0] = 0x02;
5888 usb_microdia_control_write(dev, 0x1182, buf, 1); /* URB 2103 */
5889
5890
5891 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5892 /* I2C MESSAGES */
5893 retI2C = 0;
5894 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5895 /* Write to sensor register 0x09: Shutter Width */
5896 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
5897 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf); /* URBs 2104-2106 */
5898 /* Write to sensor register 0x2b: Green 1 Gain */
5899 /* 0x2c: Blue Gain */
5900 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
5901 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
5902 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf); /* URBs 2107-2109 */
5903 /* Write to sensor register 0x2d: Red Gain */
5904 /* 0x2e: Green 2 Gain */
5905 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
5906 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
5907 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf); /* URBs 2110-2112 */
5908 /* "Dummy" write to sensor Register 0x33: RESERVED */
5909 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL); /* URBs 2113-2114 */
5910 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5911 /* Write to sensor register 0x09: Shutter Width */
5912 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
5913 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf);
5914 /* Write to sensor register 0x07: Output Control */
5915 buf[0] = 0x00; buf[1] = 0x03; /* dont update changes until bit0=0, chip enable, normal operation */
5916 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
5917 /* Write to sensor register 0x2b: Green 1 Gain */
5918 /* 0x2c: Blue Gain */
5919 buf[0] = 0x00; buf[1] = 0x33; /* 51*0.03125*1 = 1.59375 */
5920 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
5921 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf);
5922 /* Write to sensor register 0x2d: Red Gain */
5923 /* 0x2e: Green 2 Gain */
5924 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
5925 buf[2] = 0x00; buf[3] = 0x33; /* 51*0.03125*1 = 1.59375 */
5926 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf);
5927 /* "Dummy" write to sensor Register 0x33: RESERVED */
5928 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL);
5929 /* Write to sensor register 0x07: Output Control */
5930 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
5931 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
5932 }
5933 if (retI2C < 0) {
5934 UDIA_INFO("1 or more errors occured in I2C-message-block 5 !\n");
5935 return -1;
5936 }
5937 /* END OF I2C MESSAGES */
5938 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5939
5940 buf[0] = 0x0a;
5941 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2119 */
5942
5943 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5944 buf[0] = 0x14;
5945 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5946 buf[0] = 0x0a;
5947 usb_microdia_control_write(dev, 0x118b, buf, 1); /* URB 2124 */
5948
5949 buf[0] = 0x07;
5950 usb_microdia_control_write(dev, 0x10f7, buf, 1); /* URB 2135 */
5951
5952 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5953 buf[0] = 0x01;
5954 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5955 buf[0] = 0x14;
5956 usb_microdia_control_write(dev, 0x10f8, buf, 1); /* URB 2138 */
5957
5958 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5959 buf[0] = 0x0a;
5960 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5961 buf[0] = 0xff;
5962 usb_microdia_control_write(dev, 0x10fa, buf, 1); /* URB 2139 */
5963
5964 buf[0] = 0x00;
5965 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2140 */
5966 buf[0] = 0x00;
5967 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2141 */
5968 buf[0] = 0x0a;
5969 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2142 */
5970 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5971 usb_microdia_control_write(dev, 0x11bc, buf, 4); /* URB 2143 */
5972 for (k = 0; k < 48; k++)
5973 buf[k] = 0x00;
5974 usb_microdia_control_write(dev, 0x11c0, buf, 48); /* URB 2144 */
5975
5976 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
5977 buf[4] = 0x04; buf[5] = 0x3f;
5978 usb_microdia_control_write(dev, 0x11a5, buf, 6); /* URB 2149 */
5979
5980 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5981 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
5982 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5983 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
5984 }
5985 usb_microdia_control_write(dev, 0x11af, buf, 4); /* URB 2150 */
5986
5987 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
5988 usb_microdia_control_write(dev, 0x11b3, buf, 4); /* URB 2151 */
5989 buf[0] = 0x47; /* ALEX: 0x04 */
5990 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2152 */
5991 buf[0] = 0x01;
5992 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2153 */
5993 buf[0] = 0x67; /* ALEX: 0x24 */
5994 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2154 */
5995 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
5996 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
5997 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
5998 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
5999 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
6000 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
6001 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
6002 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
6003 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
6004 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
6005 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
6006 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
6007 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
6008 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
6009 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
6010 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
6011 usb_microdia_control_write(dev, 0x1100, buf, 64); /* URB 2155 */
6012 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
6013 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
6014 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
6015 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
6016 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
6017 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
6018 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
6019 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
6020 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
6021 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
6022 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
6023 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
6024 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
6025 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
6026 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
6027 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
6028 usb_microdia_control_write(dev, 0x1140, buf, 64); /* URB 2156 */
6029 buf[0] = 0x47; /* ALEX: 0x04 */
6030 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2157 */
6031 buf[0] = 0x03;
6032 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2158 */
6033 buf[0] = 0x4b; /* ALEX: 0x08 */
6034 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2159 */
6035
6036 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
6037 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
6038 /* I2C MESSAGES */
6039 retI2C = 0;
6040 /* Writes to sensor registers 0x02: Column Start */
6041 /* 0x03: Window Hight */
6042 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
6043 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
6044 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2160-2162 */
6045 /* Writes to sensor registers 0x04: Window Width */
6046 /* 0x05: Horizontal Blanking */
6047 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
6048 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) */
6049 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2163-2165 */
6050 /* Writes to sensor registers 0x06: Vertical Blanking */
6051 /* 0x07: Output Control */
6052 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
6053 buf[2] = 0x30; buf[3] = 0x02; /* RESERVED options */
6054 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2166-2167 */
6055 /* Writes to sensor register 0x0e: UNDOCUMENTED */
6056 buf[0] = 0x00; buf[1] = 0x08;
6057 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2168-2170 */
6058 if (retI2C < 0) {
6059 UDIA_INFO("1 or more errors occured in I2C-message-block 6 !\n");
6060 return -1;
6061 }
6062 /* END OF I2C MESSAGES */
6063 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
6064 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
6065 buf[0] = 0x40;
6066 usb_microdia_control_write(dev, 0x1007, buf, 1);
6067 buf[0] = 0x40;
6068 usb_microdia_control_write(dev, 0x1006, buf, 1);
6069 }
6070
6071
6072 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
6073 buf[4] = 0x28; buf[5] = 0x3c;
6074 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2171 */
6075 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6076 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2172 */
6077 buf[0] = 0x0c;
6078 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2173 */
6079 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
6080 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2174 */
6081 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
6082 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2175 */
6083 buf[0] = 0x03;
6084 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2176 */
6085 buf[0] = 0x0a;
6086 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2177 */
6087 buf[0] = 0x00;
6088 usb_microdia_control_write(dev, 0x11b9, buf, 1); /* URB 2178 */
6089 buf[0] = 0x0b;
6090 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2179 */
6091 buf[0] = 0x01;
6092 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2180 */
6093 buf[0] = 0x78; /* ALEX: 0x7c */
6094 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2181 */
6095 buf[0] = 0x18; /* ALEX: 0x1c */
6096 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2182 */
6097 buf[0] = 0x18; /* ALEX: 0x1c */
6098 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2183 */
6099 buf[0] = 0x7d; /* ALEX: 0xfc */
6100 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2184 */
6101 buf[0] = 0x04;
6102 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2185 */
6103 buf[0] = 0x04;
6104 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2186 */
6105
6106 if ((last_11b8[0] == 0x3d) || (last_11b8[0] == 0x3f))
6107 buf[0] = 0x78;
6108 else if ((last_11b8[0] == 0xbd) || (last_11b8[0] == 0xbf))
6109 buf[0] = 0xf8;
6110 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2187 */
6111 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2188 // 0x38 */
6112 if (buf[0] == 0x38)
6113 buf[0] = 0x79;
6114 else if (buf[0] == 0xb8)
6115 buf[0] = 0xf9;
6116 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2189 */
6117 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2190 // 0xb9 */
6118 if (buf[0] == 0x39)
6119 buf[0] = 0x7a;
6120 else if (buf[0] == 0xb9)
6121 buf[0] = 0xfa;
6122 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2191 */
6123 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2192 // 0xba */
6124 if (buf[0] == 0x3a)
6125 buf[0] = 0x7b;
6126 else if (buf[0] == 0xba)
6127 buf[0] = 0xfb;
6128 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2193 */
6129 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2194 // 0x3b */
6130 if (buf[0] == 0x3b)
6131 buf[0] = 0x7c;
6132 else if (buf[0] == 0xbb)
6133 buf[0] = 0xfc;
6134 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2195 */
6135 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2196 // 0x3c */
6136 if (buf[0] == 0x3c)
6137 buf[0] = 0x7d;
6138 else if (buf[0] == 0xbc)
6139 buf[0] = 0xfd;
6140 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2197 */
6141 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2198 // 0x3d */
6142 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
6143 if (buf[0] == 0x3d)
6144 buf[0] = 0x7e;
6145 else if (buf[0] == 0xbd)
6146 buf[0] = 0xfe;
6147 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2199 */
6148 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2200 */
6149 if (buf[0] == 0x3e)
6150 buf[0] = 0x7f;
6151 else if (buf[0] == 0xbe)
6152 buf[0] = 0xff;
6153 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2201 */
6154 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2202 */
6155 }
6156 buf[0] = buf[0] & 0xf0; /* 0xf0 or 0x70 */
6157 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
6158 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
6159
6160 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
6161 /* I2C MESSAGES */
6162 retI2C = 0;
6163 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
6164 /* Write to sensor register 0x06: Vertical Blanking */
6165 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
6166 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2204-2206 */
6167 /* Write to sensor register 0x05: Horizontal Blanking */
6168 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
6169 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2207-2209 */
6170 /* Read of sensor register 0x36: Chip Version (mirror of reg0xff) */
6171 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x36, dev->sensor_flags, buf); /* URBs 2211-2215 // 0x82 0x3a */
6172 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
6173 /* Write to sensor register 0x0a: Pixel Clock Speed */
6174 buf[0] = 0x00; buf[1] = 0x00; /* default */
6175 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
6176 /* Write to sensor register 0x06: Vertical Blanking */
6177 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
6178 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
6179 /* Write to sensor register 0x05: Horizontal Blanking */
6180 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
6181 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
6182 /* Read of sensor register 0x00: Chip Version (=reg0xff) */
6183 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x00, dev->sensor_flags, buf); /* 0x82 0x43 */
6184 }
6185 if (retI2C < 0) {
6186 UDIA_INFO("1 or more errors occured in I2C-message-block 7 !\n");
6187 return -1;
6188 }
6189 /* END OF I2C MESSAGES */
6190 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
6191
6192
6193 buf[0] = 0x03;
6194 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2216 */
6195
6196
6197 /*** NOW DRIVER DOES STOP-SEQUENCE
6198 - WITHOUT WRITES TO 0x1007 AND 0x1006 (URBs 3544-3550) => MT9V111
6199 - WRITING 0x40 INSTEAD OF 0x60 TO 0x1007 AND 0x1006 => MT9V011
6200 ***/
6201 /*** 2nd, 3rd, ... CYCLE: ALL MESSAGES (URBs 1953 - URBs 2216) ARE REPEATED ***/
6202 /*** ----- WE DON'T DO THIS, IT SEEMS TO BE UNNECESSARY ----- ***/
6203
6204 /* Setup IFP registers for AE and AWB (new, not in the logs): */
6205 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
6206 mt9v111_setup_autoexposure(dev);
6207 mt9v111_setup_autowhitebalance(dev);
6208 mt9v111_set_autocorrections(dev, 1);
6209 }
6210
6211 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
6212 buf[0] = 0x20;
6213 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
6214 buf[0] = 0x60;
6215 usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 2489 */
6216 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
6217 buf[0] = 0x00;
6218 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
6219 buf[0] = 0x40;
6220 usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 2490 */
6221 /* => These two writes seem to cause the cam to start sending isochronus USB messages */
6222
6223 return 0;
6224 }
6225
6226 int microdia_627b_start_stream(struct usb_microdia *dev)
6227 {
6228 int ret;
6229 /* int actual; */
6230 __u16 reg;
6231 __u8 buf[64];
6232
6233 buf[0] = 0x00; /** Will have to be set for every single interrupt. */
6234 /*
6235 ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 43
6236 */
6237
6238 reg = 0x1066;
6239 buf[0] = 0x00;
6240 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 44 */
6241 if (ret < 0)
6242 goto err;
6243
6244 /*
6245 //ret = usb_set_interface(dev->udev, 0, 8);
6246 //if(ret < 0) goto err;
6247
6248 //buf[0] = 0x00; // Will have to be set for every single interrupt
6249 //ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 45
6250 */
6251
6252 reg = 0x1000;
6253 buf[0] = 0x78;
6254 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 46 */
6255 if (ret < 0)
6256 goto err;
6257
6258 reg = 0x1001;
6259 buf[0] = 0xc7;
6260 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 47 */
6261 if (ret < 0)
6262 goto err;
6263
6264 reg = 0x1002;
6265 buf[0] = 0x18;
6266 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 48 */
6267 if (ret < 0)
6268 goto err;
6269
6270 reg = 0x1061;
6271 buf[0] = 0x01;
6272 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 49 */
6273 if (ret < 0)
6274 goto err;
6275
6276 reg = 0x1020;
6277 buf[0] = 0x80;
6278 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 50 */
6279 if (ret < 0)
6280 goto err;
6281
6282 reg = 0x1067;
6283 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
6284 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 51 */
6285 if (ret < 0)
6286 goto err;
6287
6288 reg = 0x10c0;
6289 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
6290 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
6291 buf[8] = 0x03;
6292 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 52 */
6293 if (ret < 0)
6294 goto err;
6295
6296 /* transferbufferlength is 18, but data is 24 bytes long, what to do ? */
6297 reg = 0x10e0;
6298 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30; buf[4] = 0x00;
6299 buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed; buf[8] = 0x0f; buf[9] = 0xda;
6300 buf[10] = 0x0f; buf[11] = 0x3a; buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00;
6301 buf[15] = 0xd0; buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
6302 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
6303 ret = usb_microdia_control_write(dev, reg, buf, 24); /* URB 53 */
6304 if (ret < 0)
6305 goto err;
6306
6307 reg = 0x10f8;
6308 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
6309 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 54 */
6310 if (ret < 0)
6311 goto err;
6312
6313 reg = 0x10fb;
6314 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6315 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 55 */
6316 if (ret < 0)
6317 goto err;
6318
6319 reg = 0x1188;
6320 buf[0] = 0x86; buf[1] = 0x8c; buf[2] = 0x08;
6321 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 56 */
6322 if (ret < 0)
6323 goto err;
6324
6325 reg = 0x118b;
6326 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20; buf[4] = 0x20;
6327 buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b; buf[8] = 0x4f; buf[9] = 0x61;
6328 buf[10] = 0x71; buf[11] = 0x80; buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab;
6329 buf[15] = 0xb8; buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
6330 buf[20] = 0xf4; buf[21] = 0xff;
6331 ret = usb_microdia_control_write(dev, reg, buf, 22); /* URB 57 */
6332 if (ret < 0)
6333 goto err;
6334
6335 reg = 0x11a1;
6336 buf[0] = 0x00; buf[1] = 0x00;
6337 ret = usb_microdia_control_write(dev, reg, buf, 2); /* URB 58 */
6338 if (ret < 0)
6339 goto err;
6340
6341 reg = 0x11b7;
6342 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08; buf[4] = 0x00;
6343 buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0; buf[8] = 0x00;
6344 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 59 */
6345 if (ret < 0)
6346 goto err;
6347
6348 reg = 0x11b8;
6349 buf[0] = 0x38;
6350 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 60 */
6351 if (ret < 0)
6352 goto err;
6353
6354 reg = 0x1000;
6355 buf[0] = 0x78;
6356 ret = usb_microdia_control_write(dev, reg, buf, 1);
6357 if (ret < 0)
6358 goto err;
6359
6360 buf[0] = 0x80;
6361 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6362 OV7660_CTL_COM7, dev->sensor_flags, buf);
6363 if (ret < 0)
6364 goto errI2C;
6365
6366 buf[0] = 0x01; buf[1] = 0x74; buf[2] = 0x92; buf[3] = 0x00;
6367 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6368 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6369 if (ret < 0)
6370 goto errI2C;
6371
6372 buf[0] = 0x00; buf[1] = 0x7d; buf[2] = 0x62; buf[3] = 0x00;
6373 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6374 OV7660_CTL_COM1, dev->sensor_flags, buf);
6375 if (ret < 0)
6376 goto errI2C;
6377
6378 buf[0] = 0x83; buf[1] = 0x01;
6379 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6380 OV7660_CTL_RAVE, dev->sensor_flags, buf);
6381 if (ret < 0)
6382 goto errI2C;
6383
6384 buf[0] = 0x00; buf[1] = 0x08; buf[2] = 0x04; buf[3] = 0x62;
6385 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6386 OV7660_CTL_COM3, dev->sensor_flags, buf);
6387 if (ret < 0)
6388 goto errI2C;
6389
6390 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x05; buf[3] = 0xf8;
6391 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6392 OV7660_CTL_AECH, dev->sensor_flags, buf);
6393 if (ret < 0)
6394 goto errI2C;
6395
6396 buf[0] = 0x2e; buf[1] = 0x00; buf[2] = 0x02;
6397 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
6398 OV7660_CTL_COM9, dev->sensor_flags, buf);
6399 if (ret < 0)
6400 goto errI2C;
6401
6402 buf[0] = 0x10; buf[1] = 0x60; buf[2] = 0x02; buf[3] = 0x7b;
6403 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6404 OV7660_CTL_HSTART, dev->sensor_flags, buf);
6405 if (ret < 0)
6406 goto errI2C;
6407
6408 buf[0] = 0x06;
6409 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6410 OV7660_CTL_PSHFT, dev->sensor_flags, buf);
6411 if (ret < 0)
6412 goto errI2C;
6413
6414 buf[0] = 0x01; buf[1] = 0x0e;
6415 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6416 OV7660_CTL_MVFP, dev->sensor_flags, buf);
6417 if (ret < 0)
6418 goto errI2C;
6419
6420 buf[0] = 0x07; buf[1] = 0x07; buf[2] = 0x07; buf[3] = 0x07;
6421 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6422 OV7660_CTL_BOS, dev->sensor_flags, buf);
6423 if (ret < 0)
6424 goto errI2C;
6425
6426 buf[0] = 0x68; buf[1] = 0x58; buf[2] = 0xd4; buf[3] = 0x80;
6427 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6428 OV7660_CTL_AEW, dev->sensor_flags, buf);
6429 if (ret < 0)
6430 goto errI2C;
6431
6432 buf[0] = 0x80; buf[1] = 0x3c; buf[2] = 0x00; buf[3] = 0x00;
6433 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6434 OV7660_CTL_GbBIAS, dev->sensor_flags, buf);
6435 if (ret < 0)
6436 goto errI2C;
6437
6438 buf[0] = 0x80; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x62;
6439 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6440 OV7660_CTL_RBIAS, dev->sensor_flags, buf);
6441 if (ret < 0)
6442 goto errI2C;
6443
6444 buf[0] = 0x08; buf[1] = 0x30; buf[2] = 0xb4;
6445 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
6446 OV7660_CTL_HSYST, dev->sensor_flags, buf);
6447 if (ret < 0)
6448 goto errI2C;
6449
6450 buf[0] = 0x00; buf[1] = 0x07; buf[2] = 0x84; buf[3] = 0x00;
6451 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6452 OV7660_CTL_CHLF, dev->sensor_flags, buf);
6453 if (ret < 0)
6454 goto errI2C;
6455
6456 buf[0] = 0x0c; buf[1] = 0x02; buf[2] = 0x43; buf[3] = 0x00;
6457 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6458 OV7660_CTL_ADC, dev->sensor_flags, buf);
6459 if (ret < 0)
6460 goto errI2C;
6461
6462 buf[0] = 0x02; buf[1] = 0x6c; buf[2] = 0x19; buf[3] = 0x0e;
6463 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6464 OV7660_CTL_COM11, dev->sensor_flags, buf);
6465 if (ret < 0)
6466 goto errI2C;
6467
6468 buf[0] = 0x41; buf[1] = 0xc1; buf[2] = 0x22; buf[3] = 0x08;
6469 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6470 OV7660_CTL_EDGE, dev->sensor_flags, buf);
6471 if (ret < 0)
6472 goto errI2C;
6473
6474 /* "Dummy" write */
6475 reg = 0x43; /* RSVD 0x43 is Reserved */
6476 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
6477 reg, dev->sensor_flags, NULL);
6478 if (ret < 0)
6479 goto errI2C;
6480
6481 reg = 0x43; /* RSVD 0x43 is Reserved */
6482 buf[0] = 0xf0; buf[1] = 0x10; buf[2] = 0x78; buf[3] = 0xa8;
6483 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
6484 dev->sensor_flags, buf);
6485 if (ret < 0)
6486 goto errI2C;
6487
6488 reg = 0x47; /* RSVD 0x47 is Reserved */
6489 buf[0] = 0x60; buf[1] = 0x80; buf[2] = 0x00; buf[3] = 0x00;
6490 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
6491 dev->sensor_flags, buf);
6492 if (ret < 0)
6493 goto errI2C;
6494
6495 reg = 0x4b; /* RSVD 0x4b is Reserved */
6496 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
6497 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
6498 dev->sensor_flags, buf);
6499 if (ret < 0)
6500 goto errI2C;
6501
6502 /* "Dummy" write */
6503 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
6504 OV7660_CTL_MTX1, dev->sensor_flags, NULL);
6505 if (ret < 0)
6506 goto errI2C;
6507
6508 reg = 0x59; /* RSVD 0x59 is Reserved */
6509 buf[0] = 0xba; buf[1] = 0x9a; buf[2] = 0x22; buf[3] = 0xb9;
6510 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6511 reg, dev->sensor_flags, buf);
6512 if (ret < 0)
6513 goto errI2C;
6514
6515 reg = 0x5d; /* RSVD 0x5d is Reserved */
6516 buf[0] = 0x9b; buf[1] = 0x10; buf[2] = 0xf0; buf[3] = 0x05;
6517 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6518 reg, dev->sensor_flags, buf);
6519 if (ret < 0)
6520 goto errI2C;
6521
6522 reg = 0x61; /* RSVD 0x61 is Reserved */
6523 buf[0] = 0x60;
6524 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6525 reg, dev->sensor_flags, buf);
6526 if (ret < 0)
6527 goto errI2C;
6528
6529 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x30;
6530 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6531 OV7660_CTL_LCC1, dev->sensor_flags, buf);
6532 if (ret < 0)
6533 goto errI2C;
6534
6535 buf[0] = 0x00;
6536 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6537 OV7660_CTL_LCC5, dev->sensor_flags, buf);
6538 if (ret < 0)
6539 goto errI2C;
6540
6541 buf[0] = 0x80; buf[1] = 0x7a; buf[2] = 0x90; buf[3] = 0x80;
6542 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6543 OV7660_CTL_MANU, dev->sensor_flags, buf);
6544 if (ret < 0)
6545 goto errI2C;
6546
6547 buf[0] = 0x0a;
6548 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6549 OV7660_CTL_DBLV, dev->sensor_flags, buf);
6550 if (ret < 0)
6551 goto errI2C;
6552
6553 reg = 0x8b; /* RSVD 0x8b is Reserved */
6554 buf[0] = 0x99; buf[1] = 0x99; buf[2] = 0xcf;
6555 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3, reg,
6556 dev->sensor_flags, buf);
6557 if (ret < 0)
6558 goto errI2C;
6559
6560 buf[0] = 0x00; buf[1] = 0x00;
6561 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6562 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
6563 if (ret < 0)
6564 goto errI2C;
6565
6566 reg = 0x1007;
6567 buf[0] = 0x40;
6568 ret = usb_microdia_control_write(dev, reg, buf, 1);
6569 if (ret < 0)
6570 goto err;
6571
6572 reg = 0x1006;
6573 buf[0] = 0x00;
6574 ret = usb_microdia_control_write(dev, reg, buf, 1);
6575 if (ret < 0)
6576 goto err;
6577
6578 reg = 0x10c1;
6579 ret = usb_microdia_control_read(dev, reg, buf, 1);
6580 if (ret < 0)
6581 goto err;
6582
6583 reg = 0x10c1;
6584 buf[0] = 0x50;
6585 ret = usb_microdia_control_write(dev, reg, buf, 1);
6586 if (ret < 0)
6587 goto err;
6588
6589 /* TRY TO READ FROM EEPROM: */
6590 reg = 0x00;
6591 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, reg, SN9C20X_I2C_2WIRE, buf);
6592 if (ret < 0)
6593 UDIA_INFO("No EEPROM found\n");
6594 else
6595 UDIA_INFO("Read from EEPROM successful\n");
6596
6597 reg = 0x10c1;
6598 buf[0] = 0x21;
6599 ret = usb_microdia_control_write(dev, reg, buf, 1);
6600 if (ret < 0)
6601 goto err;
6602
6603 reg = 0x10e0;
6604 buf[0] = 0x47;
6605 ret = usb_microdia_control_write(dev, reg, buf, 1);
6606 if (ret < 0)
6607 goto err;
6608
6609 reg = 0x10e0;
6610 buf[0] = 0x47;
6611 ret = usb_microdia_control_write(dev, reg, buf, 1);
6612 if (ret < 0)
6613 goto err;
6614
6615 reg = 0x1001;
6616 buf[0] = 0xc6;
6617 ret = usb_microdia_control_write(dev, reg, buf, 1);
6618 if (ret < 0)
6619 goto err;
6620
6621 reg = 0x1001;
6622 buf[0] = 0xc4;
6623 ret = usb_microdia_control_write(dev, reg, buf, 1);
6624 if (ret < 0)
6625 goto err;
6626
6627 reg = 0x1001;
6628 buf[0] = 0x84;
6629 ret = usb_microdia_control_write(dev, reg, buf, 1);
6630 if (ret < 0)
6631 goto err;
6632
6633 buf[0] = 0x08;
6634 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6635 OV7660_CTL_VREF, dev->sensor_flags, buf);
6636 if (ret < 0)
6637 goto errI2C;
6638
6639 buf[0] = 0x10; buf[1] = 0x61; buf[2] = 0x02; buf[3] = 0x7a;
6640 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
6641 OV7660_CTL_HSTART, dev->sensor_flags, buf);
6642 if (ret < 0)
6643 goto errI2C;
6644
6645 /* "Dummy" write: */
6646 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
6647 OV7660_CTL_PSHFT, dev->sensor_flags, NULL);
6648 if (ret < 0)
6649 goto errI2C;
6650
6651 buf[0] = 0x84;
6652 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6653 OV7660_CTL_HREF, dev->sensor_flags, buf);
6654 if (ret < 0)
6655 goto errI2C;
6656
6657 buf[0] = 0x84;
6658 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6659 OV7660_CTL_HREF, dev->sensor_flags, buf);
6660 if (ret < 0)
6661 goto errI2C;
6662
6663 buf[0] = 0x84;
6664 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6665 OV7660_CTL_HREF, dev->sensor_flags, buf);
6666 if (ret < 0)
6667 goto errI2C;
6668
6669 buf[0] = 0x84;
6670 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6671 OV7660_CTL_HREF, dev->sensor_flags, buf);
6672 if (ret < 0)
6673 goto errI2C;
6674
6675 buf[0] = 0x84;
6676 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6677 OV7660_CTL_HREF, dev->sensor_flags, buf);
6678 if (ret < 0)
6679 goto errI2C;
6680
6681 reg = 0x1180;
6682 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
6683 buf[5] = 0x3c;
6684 ret = usb_microdia_control_write(dev, reg, buf, 6);
6685 if (ret < 0)
6686 goto err;
6687
6688 reg = 0x10fb;
6689 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6690 ret = usb_microdia_control_write(dev, reg, buf, 5);
6691 if (ret < 0)
6692 goto err;
6693
6694 reg = 0x1189;
6695 buf[0] = 0x8c;
6696 ret = usb_microdia_control_write(dev, reg, buf, 1);
6697 if (ret < 0)
6698 goto err;
6699
6700 reg = 0x11a1;
6701 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
6702 ret = usb_microdia_control_write(dev, reg, buf, 4);
6703 if (ret < 0)
6704 goto err;
6705
6706 reg = 0x11ab;
6707 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
6708 ret = usb_microdia_control_write(dev, reg, buf, 4);
6709 if (ret < 0)
6710 goto err;
6711
6712 reg = 0x1000;
6713 buf[0] = 0x78;
6714 ret = usb_microdia_control_write(dev, reg, buf, 1);
6715 if (ret < 0)
6716 goto err;
6717
6718 reg = 0x1002;
6719 buf[0] = 0x18;
6720 ret = usb_microdia_control_write(dev, reg, buf, 1);
6721 if (ret < 0)
6722 goto err;
6723
6724 reg = 0x1002;
6725 buf[0] = 0x18;
6726 ret = usb_microdia_control_write(dev, reg, buf, 1);
6727 if (ret < 0)
6728 goto err;
6729
6730 reg = 0x11b8;
6731 buf[0] = 0x38;
6732 ret = usb_microdia_control_write(dev, reg, buf, 1);
6733 if (ret < 0)
6734 goto err;
6735
6736 reg = 0x118a;
6737 buf[0] = 0x04;
6738 ret = usb_microdia_control_write(dev, reg, buf, 1);
6739 if (ret < 0)
6740 goto err;
6741
6742 reg = 0x0395;
6743 buf[0] = 0x04;
6744 ret = usb_microdia_control_write(dev, reg, buf, 1);
6745 if (ret < 0)
6746 goto err;
6747
6748 reg = 0x11b8;
6749 buf[0] = 0x78;
6750 ret = usb_microdia_control_write(dev, reg, buf, 1);
6751 if (ret < 0)
6752 goto err;
6753 ret = usb_microdia_control_read(dev, reg, buf, 1);
6754 if (ret < 0)
6755 goto err;
6756
6757 reg = 0x11b8;
6758 buf[0] = 0xf9;
6759 ret = usb_microdia_control_write(dev, reg, buf, 1);
6760 if (ret < 0)
6761 goto err;
6762 ret = usb_microdia_control_read(dev, reg, buf, 1);
6763 if (ret < 0)
6764 goto err;
6765
6766 reg = 0x11b8;
6767 buf[0] = 0xfa;
6768 ret = usb_microdia_control_write(dev, reg, buf, 1);
6769 if (ret < 0)
6770 goto err;
6771 ret = usb_microdia_control_read(dev, reg, buf, 1);
6772 if (ret < 0)
6773 goto err;
6774
6775 reg = 0x11b8;
6776 buf[0] = 0x7b;
6777 ret = usb_microdia_control_write(dev, reg, buf, 1);
6778 if (ret < 0)
6779 goto err;
6780 ret = usb_microdia_control_read(dev, reg, buf, 1);
6781 if (ret < 0)
6782 goto err;
6783
6784 reg = 0x11b8;
6785 buf[0] = 0x7c;
6786 ret = usb_microdia_control_write(dev, reg, buf, 1);
6787 if (ret < 0)
6788 goto err;
6789 ret = usb_microdia_control_read(dev, reg, buf, 1);
6790 if (ret < 0)
6791 goto err;
6792
6793 reg = 0x11b8;
6794 buf[0] = 0x7d;
6795 ret = usb_microdia_control_write(dev, reg, buf, 1);
6796 if (ret < 0)
6797 goto err;
6798 ret = usb_microdia_control_read(dev, reg, buf, 1);
6799 if (ret < 0)
6800 goto err;
6801
6802 reg = 0x11b8;
6803 buf[0] = 0x7b;
6804 ret = usb_microdia_control_write(dev, reg, buf, 1);
6805 if (ret < 0)
6806 goto err;
6807
6808 /*
6809 //ret = usb_microdia_control_read(dev, reg, buf, 1);
6810 //if(ret < 0) goto err;
6811 */
6812
6813 buf[0] = 0x40;
6814 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6815 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
6816 if (ret < 0)
6817 goto errI2C;
6818
6819 buf[0] = 0x00;
6820 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6821 OV7660_CTL_EXHCH, dev->sensor_flags, buf);
6822 if (ret < 0)
6823 goto errI2C;
6824
6825 buf[0] = 0x00;
6826 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6827 OV7660_CTL_EXHCL, dev->sensor_flags, buf);
6828 if (ret < 0)
6829 goto errI2C;
6830
6831 buf[0] = 0x00;
6832 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6833 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
6834 if (ret < 0)
6835 goto errI2C;
6836
6837 buf[0] = 0x00;
6838 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6839 OV7660_CTL_DM_LNH, dev->sensor_flags, buf);
6840 if (ret < 0)
6841 goto errI2C;
6842
6843 buf[0] = 0x01;
6844 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6845 OV7660_CTL_MVFP, dev->sensor_flags, buf);
6846 if (ret < 0)
6847 goto errI2C;
6848
6849 buf[0] = 0x01;
6850 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6851 OV7660_CTL_MVFP, dev->sensor_flags, buf);
6852 if (ret < 0)
6853 goto errI2C;
6854
6855 buf[0] = 0x08;
6856 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6857 OV7660_CTL_VREF, dev->sensor_flags, buf);
6858 if (ret < 0)
6859 goto errI2C;
6860
6861 buf[0] = 0x00;
6862 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6863 OV7660_CTL_VREF, dev->sensor_flags, buf);
6864 if (ret < 0)
6865 goto errI2C;
6866
6867 buf[0] = 0x7f;
6868 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6869 OV7660_CTL_AECH, dev->sensor_flags, buf);
6870 if (ret < 0)
6871 goto errI2C;
6872
6873 buf[0] = 0x00;
6874 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6875 OV7660_CTL_COM1, dev->sensor_flags, buf);
6876 if (ret < 0)
6877 goto errI2C;
6878
6879 buf[0] = 0x00;
6880 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6881 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6882 if (ret < 0)
6883 goto errI2C;
6884
6885 buf[0] = 0x00;
6886 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6887 OV7660_CTL_ADVFH, dev->sensor_flags, buf);
6888 if (ret < 0)
6889 goto errI2C;
6890
6891 buf[0] = 0x00;
6892 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6893 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6894 if (ret < 0)
6895 goto errI2C;
6896
6897 buf[0] = 0x78; buf[1] = 0x78;
6898 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6899 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6900 if (ret < 0)
6901 goto errI2C;
6902
6903 reg = 0x11ba;
6904 buf[0] = 0x0a;
6905 ret = usb_microdia_control_write(dev, reg, buf, 1);
6906 if (ret < 0)
6907 goto err;
6908
6909 reg = 0x118b;
6910 buf[0] = 0x0c;
6911 ret = usb_microdia_control_write(dev, reg, buf, 1);
6912 if (ret < 0)
6913 goto err;
6914
6915 reg = 0x10f7;
6916 buf[0] = 0x05;
6917 ret = usb_microdia_control_write(dev, reg, buf, 1);
6918 if (ret < 0)
6919 goto err;
6920
6921 reg = 0x10f8;
6922 buf[0] = 0x14;
6923 ret = usb_microdia_control_write(dev, reg, buf, 1);
6924 if (ret < 0)
6925 goto err;
6926
6927 reg = 0x10fa;
6928 buf[0] = 0xff;
6929 ret = usb_microdia_control_write(dev, reg, buf, 1);
6930 if (ret < 0)
6931 goto err;
6932
6933 reg = 0x10f9;
6934 buf[0] = 0x00;
6935 ret = usb_microdia_control_write(dev, reg, buf, 1);
6936 if (ret < 0)
6937 goto err;
6938
6939 reg = 0x10f9;
6940 buf[0] = 0x00;
6941 ret = usb_microdia_control_write(dev, reg, buf, 1);
6942 if (ret < 0)
6943 goto err;
6944
6945 reg = 0x11ba;
6946 buf[0] = 0x0a;
6947 ret = usb_microdia_control_write(dev, reg, buf, 1);
6948 if (ret < 0)
6949 goto err;
6950
6951 reg = 0x11bc;
6952 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
6953 ret = usb_microdia_control_write(dev, reg, buf, 4);
6954 if (ret < 0)
6955 goto err;
6956
6957 reg = 0x11c0;
6958 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00;
6959 buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00; buf[9] = 0x00;
6960 buf[10] = 0x00; buf[11] = 0x00; buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00;
6961 buf[15] = 0x00; buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
6962 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00; buf[24] = 0x00;
6963 buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00; buf[28] = 0x00; buf[29] = 0x00;
6964 buf[30] = 0x00; buf[31] = 0x00; buf[32] = 0x00;
6965 ret = usb_microdia_control_write(dev, reg, buf, 33);
6966 if (ret < 0)
6967 goto err;
6968 /* transferbufferlength was only 30 ? */
6969
6970 reg = 0x11a5;
6971 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05; buf[4] = 0x04;
6972 buf[5] = 0x3f;
6973 ret = usb_microdia_control_write(dev, reg, buf, 6);
6974 if (ret < 0)
6975 goto err;
6976
6977 reg = 0x11af;
6978 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
6979 ret = usb_microdia_control_write(dev, reg, buf, 4);
6980 if (ret < 0)
6981 goto err;
6982
6983 reg = 0x11b3;
6984 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
6985 ret = usb_microdia_control_write(dev, reg, buf, 4);
6986 if (ret < 0)
6987 goto err;
6988
6989 reg = 0x10e0;
6990 buf[0] = 0x47;
6991 ret = usb_microdia_control_write(dev, reg, buf, 1);
6992 if (ret < 0)
6993 goto err;
6994
6995 reg = 0x1061;
6996 buf[0] = 0x01;
6997 ret = usb_microdia_control_write(dev, reg, buf, 1);
6998 if (ret < 0)
6999 goto err;
7000
7001 reg = 0x10e0;
7002 buf[0] = 0x67;
7003 ret = usb_microdia_control_write(dev, reg, buf, 1);
7004 if (ret < 0)
7005 goto err;
7006
7007 reg = 0x1100;
7008 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d; buf[4] = 0x08;
7009 buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d; buf[8] = 0x0d; buf[9] = 0x0d;
7010 buf[10] = 0x11; buf[11] = 0x0d; buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15;
7011 buf[15] = 0x21; buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
7012 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d; buf[24] = 0x19;
7013 buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a; buf[28] = 0x32; buf[29] = 0x32;
7014 buf[30] = 0x2e; buf[31] = 0x2a; buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36;
7015 buf[35] = 0x3a; buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
7016 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e; buf[44] = 0x43;
7017 buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47; buf[48] = 0x4f; buf[49] = 0x53;
7018 buf[50] = 0x58; buf[51] = 0x58; buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f;
7019 buf[55] = 0x60; buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
7020 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
7021 ret = usb_microdia_control_write(dev, reg, buf, 64);
7022 if (ret < 0)
7023 goto err;
7024 /* transferbufferlength is only 40 ? */
7025
7026 reg = 0x1140;
7027 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15; buf[4] = 0x11;
7028 buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15; buf[8] = 0x15; buf[9] = 0x26;
7029 buf[10] = 0x53; buf[11] = 0x36; buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53;
7030 buf[15] = 0x53; buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
7031 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53; buf[24] = 0x53;
7032 buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53; buf[28] = 0x53; buf[29] = 0x53;
7033 buf[30] = 0x53; buf[31] = 0x53; buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53;
7034 buf[35] = 0x53; buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
7035 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53; buf[44] = 0x53;
7036 buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53; buf[48] = 0x53; buf[49] = 0x53;
7037 buf[50] = 0x53; buf[51] = 0x53; buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53;
7038 buf[55] = 0x53; buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
7039 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
7040 ret = usb_microdia_control_write(dev, reg, buf, 64);
7041 if (ret < 0)
7042 goto err;
7043 /* transferbufferlength is only 40 ? */
7044
7045 reg = 0x10e0;
7046 buf[0] = 0x47;
7047 ret = usb_microdia_control_write(dev, reg, buf, 1);
7048 if (ret < 0)
7049 goto err;
7050
7051 reg = 0x1061;
7052 buf[0] = 0x03;
7053 ret = usb_microdia_control_write(dev, reg, buf, 1);
7054 if (ret < 0)
7055 goto err;
7056
7057 reg = 0x10e0;
7058 buf[0] = 0x4b;
7059 ret = usb_microdia_control_write(dev, reg, buf, 1);
7060 if (ret < 0)
7061 goto err;
7062
7063 buf[0] = 0x08;
7064 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7065 OV7660_CTL_VREF, dev->sensor_flags, buf);
7066 if (ret < 0)
7067 goto errI2C;
7068
7069 reg = 0x1180;
7070 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
7071 buf[5] = 0x3c;
7072 ret = usb_microdia_control_write(dev, reg, buf, 6);
7073 if (ret < 0)
7074 goto err;
7075
7076 reg = 0x10fb;
7077 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
7078 ret = usb_microdia_control_write(dev, reg, buf, 5);
7079 if (ret < 0)
7080 goto err;
7081
7082 reg = 0x1189;
7083 buf[0] = 0x8c;
7084 ret = usb_microdia_control_write(dev, reg, buf, 1);
7085 if (ret < 0)
7086 goto err;
7087
7088 reg = 0x11a1;
7089 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
7090 ret = usb_microdia_control_write(dev, reg, buf, 4);
7091 if (ret < 0)
7092 goto err;
7093
7094 reg = 0x11ab;
7095 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
7096 ret = usb_microdia_control_write(dev, reg, buf, 4);
7097 if (ret < 0)
7098 goto err;
7099
7100 reg = 0x1061;
7101 buf[0] = 0x03;
7102 ret = usb_microdia_control_write(dev, reg, buf, 1);
7103 if (ret < 0)
7104 goto err;
7105
7106 reg = 0x11ba;
7107 buf[0] = 0x0a;
7108 ret = usb_microdia_control_write(dev, reg, buf, 1);
7109 if (ret < 0)
7110 goto err;
7111
7112 reg = 0x11b9;
7113 buf[0] = 0x00;
7114 ret = usb_microdia_control_write(dev, reg, buf, 1);
7115 if (ret < 0)
7116 goto err;
7117
7118 reg = 0x11ba;
7119 buf[0] = 0x0b;
7120 ret = usb_microdia_control_write(dev, reg, buf, 1);
7121 if (ret < 0)
7122 goto err;
7123
7124 reg = 0x1061;
7125 buf[0] = 0x01;
7126 ret = usb_microdia_control_write(dev, reg, buf, 1);
7127 if (ret < 0)
7128 goto err;
7129
7130 reg = 0x1000;
7131 buf[0] = 0x78;
7132 ret = usb_microdia_control_write(dev, reg, buf, 1);
7133 if (ret < 0)
7134 goto err;
7135
7136 reg = 0x1002;
7137 buf[0] = 0x18;
7138 ret = usb_microdia_control_write(dev, reg, buf, 1);
7139 if (ret < 0)
7140 goto err;
7141
7142 reg = 0x1002;
7143 buf[0] = 0x18;
7144 ret = usb_microdia_control_write(dev, reg, buf, 1);
7145 if (ret < 0)
7146 goto err;
7147
7148 reg = 0x11b8;
7149 buf[0] = 0x7b;
7150 ret = usb_microdia_control_write(dev, reg, buf, 1);
7151 if (ret < 0)
7152 goto err;
7153
7154 reg = 0x118a;
7155 buf[0] = 0x04;
7156 ret = usb_microdia_control_write(dev, reg, buf, 1);
7157 if (ret < 0)
7158 goto err;
7159
7160 reg = 0x0395;
7161 buf[0] = 0x04;
7162 ret = usb_microdia_control_write(dev, reg, buf, 1);
7163 if (ret < 0)
7164 goto err;
7165
7166 reg = 0x11b8;
7167 buf[0] = 0x78;
7168 ret = usb_microdia_control_write(dev, reg, buf, 1);
7169 if (ret < 0)
7170 goto err;
7171 ret = usb_microdia_control_read(dev, reg, buf, 1);
7172 if (ret < 0)
7173 goto err;
7174
7175 reg = 0x11b8;
7176 buf[0] = 0xf9;
7177 ret = usb_microdia_control_write(dev, reg, buf, 1);
7178 if (ret < 0)
7179 goto err;
7180 ret = usb_microdia_control_read(dev, reg, buf, 1);
7181 if (ret < 0)
7182 goto err;
7183
7184 reg = 0x11b8;
7185 buf[0] = 0xfa;
7186 ret = usb_microdia_control_write(dev, reg, buf, 1);
7187 if (ret < 0)
7188 goto err;
7189 ret = usb_microdia_control_read(dev, reg, buf, 1);
7190 if (ret < 0)
7191 goto err;
7192
7193 reg = 0x11b8;
7194 buf[0] = 0x7b;
7195 ret = usb_microdia_control_write(dev, reg, buf, 1);
7196 if (ret < 0)
7197 goto err;
7198 ret = usb_microdia_control_read(dev, reg, buf, 1);
7199 if (ret < 0)
7200 goto err;
7201
7202 reg = 0x11b8;
7203 buf[0] = 0x7c;
7204 ret = usb_microdia_control_write(dev, reg, buf, 1);
7205 if (ret < 0)
7206 goto err;
7207 ret = usb_microdia_control_read(dev, reg, buf, 1);
7208 if (ret < 0)
7209 goto err;
7210
7211 reg = 0x11b8;
7212 buf[0] = 0x7d;
7213 ret = usb_microdia_control_write(dev, reg, buf, 1);
7214 if (ret < 0)
7215 goto err;
7216 ret = usb_microdia_control_read(dev, reg, buf, 1);
7217 if (ret < 0)
7218 goto err;
7219
7220 reg = 0x11b8;
7221 buf[0] = 0x7b;
7222 ret = usb_microdia_control_write(dev, reg, buf, 1);
7223 if (ret < 0)
7224 goto err;
7225
7226 buf[0] = 0x40;
7227 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7228 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
7229 if (ret < 0)
7230 goto errI2C;
7231
7232 buf[0] = 0x00;
7233 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7234 OV7660_CTL_EXHCH, dev->sensor_flags, buf);
7235 if (ret < 0)
7236 goto errI2C;
7237
7238 buf[0] = 0x00;
7239 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7240 OV7660_CTL_EXHCL, dev->sensor_flags, buf);
7241 if (ret < 0)
7242 goto errI2C;
7243
7244 buf[0] = 0x00;
7245 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7246 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
7247 if (ret < 0)
7248 goto errI2C;
7249
7250 buf[0] = 0x00;
7251 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7252 OV7660_CTL_DM_LNH, dev->sensor_flags, buf);
7253 if (ret < 0)
7254 goto errI2C;
7255
7256 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
7257 OV7660_CTL_PID, dev->sensor_flags, buf);
7258 if (ret < 0)
7259 goto errI2C;
7260
7261 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
7262 OV7660_CTL_VER, dev->sensor_flags, buf);
7263 if (ret < 0)
7264 goto errI2C;
7265
7266 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
7267 OV7660_CTL_MIDH, dev->sensor_flags, buf);
7268 if (ret < 0)
7269 goto errI2C;
7270
7271 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
7272 OV7660_CTL_MIDL, dev->sensor_flags, buf);
7273 if (ret < 0)
7274 goto errI2C;
7275
7276 reg = 0x1061;
7277 buf[0] = 0x03;
7278 ret = usb_microdia_control_write(dev, reg, buf, 1);
7279 if (ret < 0)
7280 goto err;
7281
7282 reg = 0x1007;
7283 buf[0] = 0x60;
7284 ret = usb_microdia_control_write(dev, reg, buf, 1);
7285 if (ret < 0)
7286 goto err;
7287
7288 reg = 0x1006;
7289 buf[0] = 0x00;
7290 ret = usb_microdia_control_write(dev, reg, buf, 1);
7291 if (ret < 0)
7292 goto err;
7293
7294 reg = 0x1007;
7295 buf[0] = 0x60;
7296 ret = usb_microdia_control_write(dev, reg, buf, 1);
7297 if (ret < 0)
7298 goto err;
7299
7300 reg = 0x1006;
7301 buf[0] = 0x00;
7302 ret = usb_microdia_control_write(dev, reg, buf, 1);
7303 if (ret < 0)
7304 goto err;
7305
7306 buf[0] = 0x7f;
7307 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7308 OV7660_CTL_AECH, dev->sensor_flags, buf);
7309 if (ret < 0)
7310 goto errI2C;
7311
7312 buf[0] = 0x01;
7313 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7314 OV7660_CTL_COM1, dev->sensor_flags, buf);
7315 if (ret < 0)
7316 goto errI2C;
7317
7318 buf[0] = 0x13;
7319 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7320 OV7660_CTL_GAIN, dev->sensor_flags, buf);
7321 if (ret < 0)
7322 goto errI2C;
7323
7324 buf[0] = 0x00; buf[1] = 0x01;
7325 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7326 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
7327 if (ret < 0)
7328 goto errI2C;
7329
7330 buf[0] = 0x1e;
7331 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
7332 OV7660_CTL_GAIN, dev->sensor_flags, buf);
7333 if (ret < 0)
7334 goto errI2C;
7335
7336 buf[0] = 0x50; buf[1] = 0x60;
7337 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7338 OV7660_CTL_BLUE, dev->sensor_flags, buf);
7339 if (ret < 0)
7340 goto errI2C;
7341
7342 buf[0] = 0xfc; buf[1] = 0x04;
7343 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7344 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
7345 if (ret < 0)
7346 goto errI2C;
7347
7348 buf[0] = 0x1f; buf[1] = 0x00;
7349 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7350 OV7660_CTL_GAIN, dev->sensor_flags, buf);
7351 if (ret < 0)
7352 goto errI2C;
7353
7354 buf[0] = 0x48; buf[1] = 0x58;
7355 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7356 OV7660_CTL_BLUE, dev->sensor_flags, buf);
7357 if (ret < 0)
7358 goto errI2C;
7359
7360 buf[0] = 0xf6; buf[1] = 0x0b;
7361 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7362 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
7363 if (ret < 0)
7364 goto errI2C;
7365
7366 reg = 0x1006;
7367 buf[0] = 0x40;
7368 ret = usb_microdia_control_write(dev, reg, buf, 1);
7369 if (ret < 0)
7370 goto err;
7371
7372 buf[0] = 0x50; buf[1] = 0x60;
7373 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
7374 OV7660_CTL_BLUE, dev->sensor_flags, buf);
7375 if (ret < 0)
7376 goto errI2C;
7377
7378 return ret;
7379 err:
7380 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
7381 return ret;
7382
7383 errI2C:
7384 UDIA_ERROR("r/w in sensor register %x failed (%d)!\n", reg, ret);
7385 return ret;
7386
7387 }
7388
7389 /**
7390 * @brief From UsbSnoop-plugin-parsed.log
7391 *
7392 * @param dev
7393 *
7394 * @returns 0 (OK) or <0 (Error)
7395 *
7396 * @author Vincent, Kuzja
7397 */
7398 int microdia_6288_start_stream(struct usb_microdia *dev)
7399 {
7400 int ret;
7401 __u16 reg;
7402 __u8 buf[64];
7403
7404
7405
7406 reg = 0x1066 ;
7407 buf[0] = 0x00;
7408 ret = usb_microdia_control_write(dev, reg, buf, 1);
7409 if (ret < 0)
7410 goto err;
7411
7412 reg = 0x1000 ;
7413 buf[0] = 0x78;
7414 ret = usb_microdia_control_write(dev, reg, buf, 1);
7415 if (ret < 0)
7416 goto err;
7417
7418 reg = 0x1001 ;
7419 buf[0] = 0xc7;
7420 ret = usb_microdia_control_write(dev, reg, buf, 1);
7421 if (ret < 0)
7422 goto err;
7423
7424 reg = 0x1002 ;
7425 buf[0] = 0x1c;
7426 ret = usb_microdia_control_write(dev, reg, buf, 1);
7427 if (ret < 0)
7428 goto err;
7429
7430 reg = 0x1061 ;
7431 buf[0] = 0x01;
7432 ret = usb_microdia_control_write(dev, reg, buf, 1);
7433 if (ret < 0)
7434 goto err;
7435
7436 reg = 0x1020 ;
7437 buf[0] = 0x80;
7438 ret = usb_microdia_control_write(dev, reg, buf, 1);
7439 if (ret < 0)
7440 goto err;
7441
7442 reg = 0x1067 ;
7443 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
7444 buf[3] = 0x10; buf[4] = 0x08;
7445 ret = usb_microdia_control_write(dev, reg, buf, 5);
7446 if (ret < 0)
7447 goto err;
7448
7449 reg = 0x10c0 ;
7450 buf[0] = 0x80; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x03;
7451 ret = usb_microdia_control_write(dev, reg, buf, 9);
7452 if (ret < 0)
7453 goto err;
7454
7455 reg = 0x10e0 ;
7456 buf[0] = 0x44; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
7457 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
7458 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
7459 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
7460 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
7461 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
7462 ret = usb_microdia_control_write(dev, reg, buf, 24);
7463 if (ret < 0)
7464 goto err;
7465
7466 reg = 0x10f8 ;
7467 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
7468 ret = usb_microdia_control_write(dev, reg, buf, 3);
7469 if (ret < 0)
7470 goto err;
7471
7472 reg = 0x10fb ;
7473 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
7474 ret = usb_microdia_control_write(dev, reg, buf, 5);
7475 if (ret < 0)
7476 goto err;
7477
7478 reg = 0x1188 ;
7479 buf[0] = 0x86; buf[1] = 0xcc; buf[2] = 0x08;
7480 ret = usb_microdia_control_write(dev, reg, buf, 3);
7481 if (ret < 0)
7482 goto err;
7483
7484 reg = 0x118b ;
7485 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
7486 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
7487 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
7488 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
7489 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
7490 buf[20] = 0xf4; buf[21] = 0xff;
7491 ret = usb_microdia_control_write(dev, reg, buf, 22);
7492 if (ret < 0)
7493 goto err;
7494
7495 reg = 0x11a1 ;
7496 buf[0] = 0x00; buf[1] = 0x00;
7497 ret = usb_microdia_control_write(dev, reg, buf, 2);
7498 if (ret < 0)
7499 goto err;
7500
7501 reg = 0x11b7 ;
7502 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x08;
7503 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
7504 buf[8] = 0x00;
7505 ret = usb_microdia_control_write(dev, reg, buf, 9);
7506 if (ret < 0)
7507 goto err;
7508
7509 reg = 0x11b8 ;
7510 buf[0] = 0x30;
7511 ret = usb_microdia_control_write(dev, reg, buf, 1);
7512 if (ret < 0)
7513 goto err;
7514
7515 reg = 0x1000 ;
7516 buf[0] = 0x78;
7517 ret = usb_microdia_control_write(dev, reg, buf, 1);
7518 if (ret < 0)
7519 goto err;
7520
7521 reg = 0x10c0 ;
7522 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7523 ret = usb_microdia_control_write(dev, reg, buf, 8);
7524 if (ret < 0)
7525 goto err;
7526
7527 reg = 0x10c0 ;
7528 ret = usb_microdia_control_read(dev, reg, buf, 1);
7529 if (ret < 0)
7530 goto err;
7531
7532 reg = 0x10c0 ;
7533 ret = usb_microdia_control_read(dev, reg, buf, 1);
7534 if (ret < 0)
7535 goto err;
7536
7537 reg = 0x10c0 ;
7538 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7539 ret = usb_microdia_control_write(dev, reg, buf, 8);
7540 if (ret < 0)
7541 goto err;
7542
7543 reg = 0x10c0 ;
7544 ret = usb_microdia_control_read(dev, reg, buf, 1);
7545 if (ret < 0)
7546 goto err;
7547
7548 reg = 0x10c0 ;
7549 ret = usb_microdia_control_read(dev, reg, buf, 1);
7550 if (ret < 0)
7551 goto err;
7552
7553 reg = 0x10c0 ;
7554 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7555 ret = usb_microdia_control_write(dev, reg, buf, 8);
7556 if (ret < 0)
7557 goto err;
7558
7559 reg = 0x10c0 ;
7560 ret = usb_microdia_control_read(dev, reg, buf, 1);
7561 if (ret < 0)
7562 goto err;
7563
7564 reg = 0x10c0 ;
7565 ret = usb_microdia_control_read(dev, reg, buf, 1);
7566 if (ret < 0)
7567 goto err;
7568
7569 reg = 0x10c0 ;
7570 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0e; buf[3] = 0x61; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7571 ret = usb_microdia_control_write(dev, reg, buf, 8);
7572 if (ret < 0)
7573 goto err;
7574
7575 reg = 0x10c0 ;
7576 ret = usb_microdia_control_read(dev, reg, buf, 1);
7577 if (ret < 0)
7578 goto err;
7579
7580 reg = 0x10c0 ;
7581 ret = usb_microdia_control_read(dev, reg, buf, 1);
7582 if (ret < 0)
7583 goto err;
7584
7585 reg = 0x10c0 ;
7586 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7587 ret = usb_microdia_control_write(dev, reg, buf, 8);
7588 if (ret < 0)
7589 goto err;
7590
7591 reg = 0x10c0 ;
7592 ret = usb_microdia_control_read(dev, reg, buf, 1);
7593 if (ret < 0)
7594 goto err;
7595
7596 reg = 0x10c0 ;
7597 ret = usb_microdia_control_read(dev, reg, buf, 1);
7598 if (ret < 0)
7599 goto err;
7600
7601 reg = 0x10c0 ;
7602 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x13; buf[3] = 0xb8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7603 ret = usb_microdia_control_write(dev, reg, buf, 8);
7604 if (ret < 0)
7605 goto err;
7606
7607 reg = 0x10c0 ;
7608 ret = usb_microdia_control_read(dev, reg, buf, 1);
7609 if (ret < 0)
7610 goto err;
7611
7612 reg = 0x10c0 ;
7613 ret = usb_microdia_control_read(dev, reg, buf, 1);
7614 if (ret < 0)
7615 goto err;
7616
7617 reg = 0x10c0 ;
7618 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x14; buf[3] = 0x3e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7619 ret = usb_microdia_control_write(dev, reg, buf, 8);
7620 if (ret < 0)
7621 goto err;
7622
7623 reg = 0x10c0 ;
7624 ret = usb_microdia_control_read(dev, reg, buf, 1);
7625 if (ret < 0)
7626 goto err;
7627
7628 reg = 0x10c0 ;
7629 ret = usb_microdia_control_read(dev, reg, buf, 1);
7630 if (ret < 0)
7631 goto err;
7632
7633 reg = 0x10c0 ;
7634 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x16; buf[3] = 0x24; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7635 ret = usb_microdia_control_write(dev, reg, buf, 8);
7636 if (ret < 0)
7637 goto err;
7638
7639 reg = 0x10c0 ;
7640 ret = usb_microdia_control_read(dev, reg, buf, 1);
7641 if (ret < 0)
7642 goto err;
7643
7644 reg = 0x10c0 ;
7645 ret = usb_microdia_control_read(dev, reg, buf, 1);
7646 if (ret < 0)
7647 goto err;
7648
7649 reg = 0x10c0 ;
7650 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7651 ret = usb_microdia_control_write(dev, reg, buf, 8);
7652 if (ret < 0)
7653 goto err;
7654
7655 reg = 0x10c0 ;
7656 ret = usb_microdia_control_read(dev, reg, buf, 1);
7657 if (ret < 0)
7658 goto err;
7659
7660 reg = 0x10c0 ;
7661 ret = usb_microdia_control_read(dev, reg, buf, 1);
7662 if (ret < 0)
7663 goto err;
7664
7665 reg = 0x10c0 ;
7666 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7667 ret = usb_microdia_control_write(dev, reg, buf, 8);
7668 if (ret < 0)
7669 goto err;
7670
7671 reg = 0x10c0 ;
7672 ret = usb_microdia_control_read(dev, reg, buf, 1);
7673 if (ret < 0)
7674 goto err;
7675
7676 reg = 0x10c0 ;
7677 ret = usb_microdia_control_read(dev, reg, buf, 1);
7678 if (ret < 0)
7679 goto err;
7680
7681 reg = 0x10c0 ;
7682 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7683 ret = usb_microdia_control_write(dev, reg, buf, 8);
7684 if (ret < 0)
7685 goto err;
7686
7687 reg = 0x10c0 ;
7688 ret = usb_microdia_control_read(dev, reg, buf, 1);
7689 if (ret < 0)
7690 goto err;
7691
7692 reg = 0x10c0 ;
7693 ret = usb_microdia_control_read(dev, reg, buf, 1);
7694 if (ret < 0)
7695 goto err;
7696
7697 reg = 0x10c0 ;
7698 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x27; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7699 ret = usb_microdia_control_write(dev, reg, buf, 8);
7700 if (ret < 0)
7701 goto err;
7702
7703 reg = 0x10c0 ;
7704 ret = usb_microdia_control_read(dev, reg, buf, 1);
7705 if (ret < 0)
7706 goto err;
7707
7708 reg = 0x10c0 ;
7709 ret = usb_microdia_control_read(dev, reg, buf, 1);
7710 if (ret < 0)
7711 goto err;
7712
7713 reg = 0x10c0 ;
7714 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x28; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7715 ret = usb_microdia_control_write(dev, reg, buf, 8);
7716 if (ret < 0)
7717 goto err;
7718
7719 reg = 0x10c0 ;
7720 ret = usb_microdia_control_read(dev, reg, buf, 1);
7721 if (ret < 0)
7722 goto err;
7723
7724 reg = 0x10c0 ;
7725 ret = usb_microdia_control_read(dev, reg, buf, 1);
7726 if (ret < 0)
7727 goto err;
7728
7729 reg = 0x10c0 ;
7730 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x29; buf[3] = 0x15; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7731 ret = usb_microdia_control_write(dev, reg, buf, 8);
7732 if (ret < 0)
7733 goto err;
7734
7735 reg = 0x10c0 ;
7736 ret = usb_microdia_control_read(dev, reg, buf, 1);
7737 if (ret < 0)
7738 goto err;
7739
7740 reg = 0x10c0 ;
7741 ret = usb_microdia_control_read(dev, reg, buf, 1);
7742 if (ret < 0)
7743 goto err;
7744
7745 reg = 0x10c0 ;
7746 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2c; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7747 ret = usb_microdia_control_write(dev, reg, buf, 8);
7748 if (ret < 0)
7749 goto err;
7750
7751 reg = 0x10c0 ;
7752 ret = usb_microdia_control_read(dev, reg, buf, 1);
7753 if (ret < 0)
7754 goto err;
7755
7756 reg = 0x10c0 ;
7757 ret = usb_microdia_control_read(dev, reg, buf, 1);
7758 if (ret < 0)
7759 goto err;
7760
7761 reg = 0x10c0 ;
7762 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7763 ret = usb_microdia_control_write(dev, reg, buf, 8);
7764 if (ret < 0)
7765 goto err;
7766
7767 reg = 0x10c0 ;
7768 ret = usb_microdia_control_read(dev, reg, buf, 1);
7769 if (ret < 0)
7770 goto err;
7771
7772 reg = 0x10c0 ;
7773 ret = usb_microdia_control_read(dev, reg, buf, 1);
7774 if (ret < 0)
7775 goto err;
7776
7777 reg = 0x10c0 ;
7778 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x34; buf[3] = 0x3d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7779 ret = usb_microdia_control_write(dev, reg, buf, 8);
7780 if (ret < 0)
7781 goto err;
7782
7783 reg = 0x10c0 ;
7784 ret = usb_microdia_control_read(dev, reg, buf, 1);
7785 if (ret < 0)
7786 goto err;
7787
7788 reg = 0x10c0 ;
7789 ret = usb_microdia_control_read(dev, reg, buf, 1);
7790 if (ret < 0)
7791 goto err;
7792
7793 reg = 0x10c0 ;
7794 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x35; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7795 ret = usb_microdia_control_write(dev, reg, buf, 8);
7796 if (ret < 0)
7797 goto err;
7798
7799 reg = 0x10c0 ;
7800 ret = usb_microdia_control_read(dev, reg, buf, 1);
7801 if (ret < 0)
7802 goto err;
7803
7804 reg = 0x10c0 ;
7805 ret = usb_microdia_control_read(dev, reg, buf, 1);
7806 if (ret < 0)
7807 goto err;
7808
7809 reg = 0x10c0 ;
7810 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x36; buf[3] = 0xf8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7811 ret = usb_microdia_control_write(dev, reg, buf, 8);
7812 if (ret < 0)
7813 goto err;
7814
7815 reg = 0x10c0 ;
7816 ret = usb_microdia_control_read(dev, reg, buf, 1);
7817 if (ret < 0)
7818 goto err;
7819
7820 reg = 0x10c0 ;
7821 ret = usb_microdia_control_read(dev, reg, buf, 1);
7822 if (ret < 0)
7823 goto err;
7824
7825 reg = 0x10c0 ;
7826 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x38; buf[3] = 0x12; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7827 ret = usb_microdia_control_write(dev, reg, buf, 8);
7828 if (ret < 0)
7829 goto err;
7830
7831 reg = 0x10c0 ;
7832 ret = usb_microdia_control_read(dev, reg, buf, 1);
7833 if (ret < 0)
7834 goto err;
7835
7836 reg = 0x10c0 ;
7837 ret = usb_microdia_control_read(dev, reg, buf, 1);
7838 if (ret < 0)
7839 goto err;
7840
7841 reg = 0x10c0 ;
7842 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x39; buf[3] = 0x57; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7843 ret = usb_microdia_control_write(dev, reg, buf, 8);
7844 if (ret < 0)
7845 goto err;
7846
7847 reg = 0x10c0 ;
7848 ret = usb_microdia_control_read(dev, reg, buf, 1);
7849 if (ret < 0)
7850 goto err;
7851
7852 reg = 0x10c0 ;
7853 ret = usb_microdia_control_read(dev, reg, buf, 1);
7854 if (ret < 0)
7855 goto err;
7856
7857 reg = 0x10c0 ;
7858 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7859 ret = usb_microdia_control_write(dev, reg, buf, 8);
7860 if (ret < 0)
7861 goto err;
7862
7863 reg = 0x10c0 ;
7864 ret = usb_microdia_control_read(dev, reg, buf, 1);
7865 if (ret < 0)
7866 goto err;
7867
7868 reg = 0x10c0 ;
7869 ret = usb_microdia_control_read(dev, reg, buf, 1);
7870 if (ret < 0)
7871 goto err;
7872
7873 reg = 0x10c0 ;
7874 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3b; buf[3] = 0xcc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7875 ret = usb_microdia_control_write(dev, reg, buf, 8);
7876 if (ret < 0)
7877 goto err;
7878
7879 reg = 0x10c0 ;
7880 ret = usb_microdia_control_read(dev, reg, buf, 1);
7881 if (ret < 0)
7882 goto err;
7883
7884 reg = 0x10c0 ;
7885 ret = usb_microdia_control_read(dev, reg, buf, 1);
7886 if (ret < 0)
7887 goto err;
7888
7889 reg = 0x10c0 ;
7890 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3c; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7891 ret = usb_microdia_control_write(dev, reg, buf, 8);
7892 if (ret < 0)
7893 goto err;
7894
7895 reg = 0x10c0 ;
7896 ret = usb_microdia_control_read(dev, reg, buf, 1);
7897 if (ret < 0)
7898 goto err;
7899
7900 reg = 0x10c0 ;
7901 ret = usb_microdia_control_read(dev, reg, buf, 1);
7902 if (ret < 0)
7903 goto err;
7904
7905 reg = 0x10c0 ;
7906 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3d; buf[3] = 0x19; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7907 ret = usb_microdia_control_write(dev, reg, buf, 8);
7908 if (ret < 0)
7909 goto err;
7910
7911 reg = 0x10c0 ;
7912 ret = usb_microdia_control_read(dev, reg, buf, 1);
7913 if (ret < 0)
7914 goto err;
7915
7916 reg = 0x10c0 ;
7917 ret = usb_microdia_control_read(dev, reg, buf, 1);
7918 if (ret < 0)
7919 goto err;
7920
7921 reg = 0x10c0 ;
7922 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3e; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7923 ret = usb_microdia_control_write(dev, reg, buf, 8);
7924 if (ret < 0)
7925 goto err;
7926
7927 reg = 0x10c0 ;
7928 ret = usb_microdia_control_read(dev, reg, buf, 1);
7929 if (ret < 0)
7930 goto err;
7931
7932 reg = 0x10c0 ;
7933 ret = usb_microdia_control_read(dev, reg, buf, 1);
7934 if (ret < 0)
7935 goto err;
7936
7937 reg = 0x10c0 ;
7938 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3f; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7939 ret = usb_microdia_control_write(dev, reg, buf, 8);
7940 if (ret < 0)
7941 goto err;
7942
7943 reg = 0x10c0 ;
7944 ret = usb_microdia_control_read(dev, reg, buf, 1);
7945 if (ret < 0)
7946 goto err;
7947
7948 reg = 0x10c0 ;
7949 ret = usb_microdia_control_read(dev, reg, buf, 1);
7950 if (ret < 0)
7951 goto err;
7952
7953 reg = 0x10c0 ;
7954 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x41; buf[3] = 0x40; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7955 ret = usb_microdia_control_write(dev, reg, buf, 8);
7956 if (ret < 0)
7957 goto err;
7958
7959 reg = 0x10c0 ;
7960 ret = usb_microdia_control_read(dev, reg, buf, 1);
7961 if (ret < 0)
7962 goto err;
7963
7964 reg = 0x10c0 ;
7965 ret = usb_microdia_control_read(dev, reg, buf, 1);
7966 if (ret < 0)
7967 goto err;
7968
7969 reg = 0x10c0 ;
7970 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x42; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7971 ret = usb_microdia_control_write(dev, reg, buf, 8);
7972 if (ret < 0)
7973 goto err;
7974
7975 reg = 0x10c0 ;
7976 ret = usb_microdia_control_read(dev, reg, buf, 1);
7977 if (ret < 0)
7978 goto err;
7979
7980 reg = 0x10c0 ;
7981 ret = usb_microdia_control_read(dev, reg, buf, 1);
7982 if (ret < 0)
7983 goto err;
7984
7985 reg = 0x10c0 ;
7986 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x45; buf[3] = 0x46; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7987 ret = usb_microdia_control_write(dev, reg, buf, 8);
7988 if (ret < 0)
7989 goto err;
7990
7991 reg = 0x10c0 ;
7992 ret = usb_microdia_control_read(dev, reg, buf, 1);
7993 if (ret < 0)
7994 goto err;
7995
7996 reg = 0x10c0 ;
7997 ret = usb_microdia_control_read(dev, reg, buf, 1);
7998 if (ret < 0)
7999 goto err;
8000
8001 reg = 0x10c0 ;
8002 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x46; buf[3] = 0x62; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8003 ret = usb_microdia_control_write(dev, reg, buf, 8);
8004 if (ret < 0)
8005 goto err;
8006
8007 reg = 0x10c0 ;
8008 ret = usb_microdia_control_read(dev, reg, buf, 1);
8009 if (ret < 0)
8010 goto err;
8011
8012 reg = 0x10c0 ;
8013 ret = usb_microdia_control_read(dev, reg, buf, 1);
8014 if (ret < 0)
8015 goto err;
8016
8017 reg = 0x10c0 ;
8018 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x47; buf[3] = 0x2a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8019 ret = usb_microdia_control_write(dev, reg, buf, 8);
8020 if (ret < 0)
8021 goto err;
8022
8023 reg = 0x10c0 ;
8024 ret = usb_microdia_control_read(dev, reg, buf, 1);
8025 if (ret < 0)
8026 goto err;
8027
8028 reg = 0x10c0 ;
8029 ret = usb_microdia_control_read(dev, reg, buf, 1);
8030 if (ret < 0)
8031 goto err;
8032
8033 reg = 0x10c0 ;
8034 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x48; buf[3] = 0x3c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8035 ret = usb_microdia_control_write(dev, reg, buf, 8);
8036 if (ret < 0)
8037 goto err;
8038
8039 reg = 0x10c0 ;
8040 ret = usb_microdia_control_read(dev, reg, buf, 1);
8041 if (ret < 0)
8042 goto err;
8043
8044 reg = 0x10c0 ;
8045 ret = usb_microdia_control_read(dev, reg, buf, 1);
8046 if (ret < 0)
8047 goto err;
8048
8049 reg = 0x10c0 ;
8050 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4a; buf[3] = 0xf0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8051 ret = usb_microdia_control_write(dev, reg, buf, 8);
8052 if (ret < 0)
8053 goto err;
8054
8055 reg = 0x10c0 ;
8056 ret = usb_microdia_control_read(dev, reg, buf, 1);
8057 if (ret < 0)
8058 goto err;
8059
8060 reg = 0x10c0 ;
8061 ret = usb_microdia_control_read(dev, reg, buf, 1);
8062 if (ret < 0)
8063 goto err;
8064
8065 reg = 0x10c0 ;
8066 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4b; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8067 ret = usb_microdia_control_write(dev, reg, buf, 8);
8068 if (ret < 0)
8069 goto err;
8070
8071 reg = 0x10c0 ;
8072 ret = usb_microdia_control_read(dev, reg, buf, 1);
8073 if (ret < 0)
8074 goto err;
8075
8076 reg = 0x10c0 ;
8077 ret = usb_microdia_control_read(dev, reg, buf, 1);
8078 if (ret < 0)
8079 goto err;
8080
8081 reg = 0x10c0 ;
8082 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4c; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8083 ret = usb_microdia_control_write(dev, reg, buf, 8);
8084 if (ret < 0)
8085 goto err;
8086
8087 reg = 0x10c0 ;
8088 ret = usb_microdia_control_read(dev, reg, buf, 1);
8089 if (ret < 0)
8090 goto err;
8091
8092 reg = 0x10c0 ;
8093 ret = usb_microdia_control_read(dev, reg, buf, 1);
8094 if (ret < 0)
8095 goto err;
8096
8097 reg = 0x10c0 ;
8098 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4d; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8099 ret = usb_microdia_control_write(dev, reg, buf, 8);
8100 if (ret < 0)
8101 goto err;
8102
8103 reg = 0x10c0 ;
8104 ret = usb_microdia_control_read(dev, reg, buf, 1);
8105 if (ret < 0)
8106 goto err;
8107
8108 reg = 0x10c0 ;
8109 ret = usb_microdia_control_read(dev, reg, buf, 1);
8110 if (ret < 0)
8111 goto err;
8112
8113 reg = 0x10c0 ;
8114 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4e; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8115 ret = usb_microdia_control_write(dev, reg, buf, 8);
8116 if (ret < 0)
8117 goto err;
8118
8119 reg = 0x10c0 ;
8120 ret = usb_microdia_control_read(dev, reg, buf, 1);
8121 if (ret < 0)
8122 goto err;
8123
8124 reg = 0x10c0 ;
8125 ret = usb_microdia_control_read(dev, reg, buf, 1);
8126 if (ret < 0)
8127 goto err;
8128
8129 reg = 0x10c0 ;
8130 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x69; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8131 ret = usb_microdia_control_write(dev, reg, buf, 8);
8132 if (ret < 0)
8133 goto err;
8134
8135 reg = 0x10c0 ;
8136 ret = usb_microdia_control_read(dev, reg, buf, 1);
8137 if (ret < 0)
8138 goto err;
8139
8140 reg = 0x10c0 ;
8141 ret = usb_microdia_control_read(dev, reg, buf, 1);
8142 if (ret < 0)
8143 goto err;
8144
8145 reg = 0x10c0 ;
8146 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6c; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8147 ret = usb_microdia_control_write(dev, reg, buf, 8);
8148 if (ret < 0)
8149 goto err;
8150
8151 reg = 0x10c0 ;
8152 ret = usb_microdia_control_read(dev, reg, buf, 1);
8153 if (ret < 0)
8154 goto err;
8155
8156 reg = 0x10c0 ;
8157 ret = usb_microdia_control_read(dev, reg, buf, 1);
8158 if (ret < 0)
8159 goto err;
8160
8161 reg = 0x10c0 ;
8162 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6f; buf[3] = 0x9e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8163 ret = usb_microdia_control_write(dev, reg, buf, 8);
8164 if (ret < 0)
8165 goto err;
8166
8167 reg = 0x10c0 ;
8168 ret = usb_microdia_control_read(dev, reg, buf, 1);
8169 if (ret < 0)
8170 goto err;
8171
8172 reg = 0x10c0 ;
8173 ret = usb_microdia_control_read(dev, reg, buf, 1);
8174 if (ret < 0)
8175 goto err;
8176
8177 reg = 0x10c0 ;
8178 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x70; buf[3] = 0x05; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8179 ret = usb_microdia_control_write(dev, reg, buf, 8);
8180 if (ret < 0)
8181 goto err;
8182
8183 reg = 0x10c0 ;
8184 ret = usb_microdia_control_read(dev, reg, buf, 1);
8185 if (ret < 0)
8186 goto err;
8187
8188 reg = 0x10c0 ;
8189 ret = usb_microdia_control_read(dev, reg, buf, 1);
8190 if (ret < 0)
8191 goto err;
8192
8193 reg = 0x10c0 ;
8194 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x71; buf[3] = 0x78; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8195 ret = usb_microdia_control_write(dev, reg, buf, 8);
8196 if (ret < 0)
8197 goto err;
8198
8199 reg = 0x10c0 ;
8200 ret = usb_microdia_control_read(dev, reg, buf, 1);
8201 if (ret < 0)
8202 goto err;
8203
8204 reg = 0x10c0 ;
8205 ret = usb_microdia_control_read(dev, reg, buf, 1);
8206 if (ret < 0)
8207 goto err;
8208
8209 reg = 0x10c0 ;
8210 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x77; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8211 ret = usb_microdia_control_write(dev, reg, buf, 8);
8212 if (ret < 0)
8213 goto err;
8214
8215 reg = 0x10c0 ;
8216 ret = usb_microdia_control_read(dev, reg, buf, 1);
8217 if (ret < 0)
8218 goto err;
8219
8220 reg = 0x10c0 ;
8221 ret = usb_microdia_control_read(dev, reg, buf, 1);
8222 if (ret < 0)
8223 goto err;
8224
8225 reg = 0x10c0 ;
8226 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8a; buf[3] = 0x23; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8227 ret = usb_microdia_control_write(dev, reg, buf, 8);
8228 if (ret < 0)
8229 goto err;
8230
8231 reg = 0x10c0 ;
8232 ret = usb_microdia_control_read(dev, reg, buf, 1);
8233 if (ret < 0)
8234 goto err;
8235
8236 reg = 0x10c0 ;
8237 ret = usb_microdia_control_read(dev, reg, buf, 1);
8238 if (ret < 0)
8239 goto err;
8240
8241 reg = 0x10c0 ;
8242 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8c; buf[3] = 0x0d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8243 ret = usb_microdia_control_write(dev, reg, buf, 8);
8244 if (ret < 0)
8245 goto err;
8246
8247 reg = 0x10c0 ;
8248 ret = usb_microdia_control_read(dev, reg, buf, 1);
8249 if (ret < 0)
8250 goto err;
8251
8252 reg = 0x10c0 ;
8253 ret = usb_microdia_control_read(dev, reg, buf, 1);
8254 if (ret < 0)
8255 goto err;
8256
8257 reg = 0x10c0 ;
8258 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x90; buf[3] = 0x7e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8259 ret = usb_microdia_control_write(dev, reg, buf, 8);
8260 if (ret < 0)
8261 goto err;
8262
8263 reg = 0x10c0 ;
8264 ret = usb_microdia_control_read(dev, reg, buf, 1);
8265 if (ret < 0)
8266 goto err;
8267
8268 reg = 0x10c0 ;
8269 ret = usb_microdia_control_read(dev, reg, buf, 1);
8270 if (ret < 0)
8271 goto err;
8272
8273 reg = 0x10c0 ;
8274 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x91; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8275 ret = usb_microdia_control_write(dev, reg, buf, 8);
8276 if (ret < 0)
8277 goto err;
8278
8279 reg = 0x10c0 ;
8280 ret = usb_microdia_control_read(dev, reg, buf, 1);
8281 if (ret < 0)
8282 goto err;
8283
8284 reg = 0x10c0 ;
8285 ret = usb_microdia_control_read(dev, reg, buf, 1);
8286 if (ret < 0)
8287 goto err;
8288
8289 reg = 0x10c0 ;
8290 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x9f; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8291 ret = usb_microdia_control_write(dev, reg, buf, 8);
8292 if (ret < 0)
8293 goto err;
8294
8295 reg = 0x10c0 ;
8296 ret = usb_microdia_control_read(dev, reg, buf, 1);
8297 if (ret < 0)
8298 goto err;
8299
8300 reg = 0x10c0 ;
8301 ret = usb_microdia_control_read(dev, reg, buf, 1);
8302 if (ret < 0)
8303 goto err;
8304
8305 reg = 0x10c0 ;
8306 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa0; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8307 ret = usb_microdia_control_write(dev, reg, buf, 8);
8308 if (ret < 0)
8309 goto err;
8310
8311 reg = 0x10c0 ;
8312 ret = usb_microdia_control_read(dev, reg, buf, 1);
8313 if (ret < 0)
8314 goto err;
8315
8316 reg = 0x10c0 ;
8317 ret = usb_microdia_control_read(dev, reg, buf, 1);
8318 if (ret < 0)
8319 goto err;
8320
8321 reg = 0x10c0 ;
8322 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa4; buf[3] = 0x50; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8323 ret = usb_microdia_control_write(dev, reg, buf, 8);
8324 if (ret < 0)
8325 goto err;
8326
8327 reg = 0x10c0 ;
8328 ret = usb_microdia_control_read(dev, reg, buf, 1);
8329 if (ret < 0)
8330 goto err;
8331
8332 reg = 0x10c0 ;
8333 ret = usb_microdia_control_read(dev, reg, buf, 1);
8334 if (ret < 0)
8335 goto err;
8336
8337 reg = 0x10c0 ;
8338 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa5; buf[3] = 0x68; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8339 ret = usb_microdia_control_write(dev, reg, buf, 8);
8340 if (ret < 0)
8341 goto err;
8342
8343 reg = 0x10c0 ;
8344 ret = usb_microdia_control_read(dev, reg, buf, 1);
8345 if (ret < 0)
8346 goto err;
8347
8348 reg = 0x10c0 ;
8349 ret = usb_microdia_control_read(dev, reg, buf, 1);
8350 if (ret < 0)
8351 goto err;
8352
8353 reg = 0x10c0 ;
8354 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa6; buf[3] = 0x60; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8355 ret = usb_microdia_control_write(dev, reg, buf, 8);
8356 if (ret < 0)
8357 goto err;
8358
8359 reg = 0x10c0 ;
8360 ret = usb_microdia_control_read(dev, reg, buf, 1);
8361 if (ret < 0)
8362 goto err;
8363
8364 reg = 0x10c0 ;
8365 ret = usb_microdia_control_read(dev, reg, buf, 1);
8366 if (ret < 0)
8367 goto err;
8368
8369 reg = 0x10c0 ;
8370 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa8; buf[3] = 0xc1; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8371 ret = usb_microdia_control_write(dev, reg, buf, 8);
8372 if (ret < 0)
8373 goto err;
8374
8375 reg = 0x10c0 ;
8376 ret = usb_microdia_control_read(dev, reg, buf, 1);
8377 if (ret < 0)
8378 goto err;
8379
8380 reg = 0x10c0 ;
8381 ret = usb_microdia_control_read(dev, reg, buf, 1);
8382 if (ret < 0)
8383 goto err;
8384
8385 reg = 0x10c0 ;
8386 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa9; buf[3] = 0xfa; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8387 ret = usb_microdia_control_write(dev, reg, buf, 8);
8388 if (ret < 0)
8389 goto err;
8390
8391 reg = 0x10c0 ;
8392 ret = usb_microdia_control_read(dev, reg, buf, 1);
8393 if (ret < 0)
8394 goto err;
8395
8396 reg = 0x10c0 ;
8397 ret = usb_microdia_control_read(dev, reg, buf, 1);
8398 if (ret < 0)
8399 goto err;
8400
8401 reg = 0x10c0 ;
8402 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaa; buf[3] = 0x92; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8403 ret = usb_microdia_control_write(dev, reg, buf, 8);
8404 if (ret < 0)
8405 goto err;
8406
8407 reg = 0x10c0 ;
8408 ret = usb_microdia_control_read(dev, reg, buf, 1);
8409 if (ret < 0)
8410 goto err;
8411
8412 reg = 0x10c0 ;
8413 ret = usb_microdia_control_read(dev, reg, buf, 1);
8414 if (ret < 0)
8415 goto err;
8416
8417 reg = 0x10c0 ;
8418 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xab; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8419 ret = usb_microdia_control_write(dev, reg, buf, 8);
8420 if (ret < 0)
8421 goto err;
8422
8423 reg = 0x10c0 ;
8424 ret = usb_microdia_control_read(dev, reg, buf, 1);
8425 if (ret < 0)
8426 goto err;
8427
8428 reg = 0x10c0 ;
8429 ret = usb_microdia_control_read(dev, reg, buf, 1);
8430 if (ret < 0)
8431 goto err;
8432
8433 reg = 0x10c0 ;
8434 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xac; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8435 ret = usb_microdia_control_write(dev, reg, buf, 8);
8436 if (ret < 0)
8437 goto err;
8438
8439 reg = 0x10c0 ;
8440 ret = usb_microdia_control_read(dev, reg, buf, 1);
8441 if (ret < 0)
8442 goto err;
8443
8444 reg = 0x10c0 ;
8445 ret = usb_microdia_control_read(dev, reg, buf, 1);
8446 if (ret < 0)
8447 goto err;
8448
8449 reg = 0x10c0 ;
8450 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xad; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8451 ret = usb_microdia_control_write(dev, reg, buf, 8);
8452 if (ret < 0)
8453 goto err;
8454
8455 reg = 0x10c0 ;
8456 ret = usb_microdia_control_read(dev, reg, buf, 1);
8457 if (ret < 0)
8458 goto err;
8459
8460 reg = 0x10c0 ;
8461 ret = usb_microdia_control_read(dev, reg, buf, 1);
8462 if (ret < 0)
8463 goto err;
8464
8465 reg = 0x10c0 ;
8466 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xae; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8467 ret = usb_microdia_control_write(dev, reg, buf, 8);
8468 if (ret < 0)
8469 goto err;
8470
8471 reg = 0x10c0 ;
8472 ret = usb_microdia_control_read(dev, reg, buf, 1);
8473 if (ret < 0)
8474 goto err;
8475
8476 reg = 0x10c0 ;
8477 ret = usb_microdia_control_read(dev, reg, buf, 1);
8478 if (ret < 0)
8479 goto err;
8480
8481 reg = 0x10c0 ;
8482 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaf; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8483 ret = usb_microdia_control_write(dev, reg, buf, 8);
8484 if (ret < 0)
8485 goto err;
8486
8487 reg = 0x10c0 ;
8488 ret = usb_microdia_control_read(dev, reg, buf, 1);
8489 if (ret < 0)
8490 goto err;
8491
8492 reg = 0x10c0 ;
8493 ret = usb_microdia_control_read(dev, reg, buf, 1);
8494 if (ret < 0)
8495 goto err;
8496
8497 reg = 0x10c0 ;
8498 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb2; buf[3] = 0xf2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8499 ret = usb_microdia_control_write(dev, reg, buf, 8);
8500 if (ret < 0)
8501 goto err;
8502
8503 reg = 0x10c0 ;
8504 ret = usb_microdia_control_read(dev, reg, buf, 1);
8505 if (ret < 0)
8506 goto err;
8507
8508 reg = 0x10c0 ;
8509 ret = usb_microdia_control_read(dev, reg, buf, 1);
8510 if (ret < 0)
8511 goto err;
8512
8513 reg = 0x10c0 ;
8514 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb3; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8515 ret = usb_microdia_control_write(dev, reg, buf, 8);
8516 if (ret < 0)
8517 goto err;
8518
8519 reg = 0x10c0 ;
8520 ret = usb_microdia_control_read(dev, reg, buf, 1);
8521 if (ret < 0)
8522 goto err;
8523
8524 reg = 0x10c0 ;
8525 ret = usb_microdia_control_read(dev, reg, buf, 1);
8526 if (ret < 0)
8527 goto err;
8528
8529 reg = 0x10c0 ;
8530 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb4; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8531 ret = usb_microdia_control_write(dev, reg, buf, 8);
8532 if (ret < 0)
8533 goto err;
8534
8535 reg = 0x10c0 ;
8536 ret = usb_microdia_control_read(dev, reg, buf, 1);
8537 if (ret < 0)
8538 goto err;
8539
8540 reg = 0x10c0 ;
8541 ret = usb_microdia_control_read(dev, reg, buf, 1);
8542 if (ret < 0)
8543 goto err;
8544
8545 reg = 0x10c0 ;
8546 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb5; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8547 ret = usb_microdia_control_write(dev, reg, buf, 8);
8548 if (ret < 0)
8549 goto err;
8550
8551 reg = 0x10c0 ;
8552 ret = usb_microdia_control_read(dev, reg, buf, 1);
8553 if (ret < 0)
8554 goto err;
8555
8556 reg = 0x10c0 ;
8557 ret = usb_microdia_control_read(dev, reg, buf, 1);
8558 if (ret < 0)
8559 goto err;
8560
8561 reg = 0x10c0 ;
8562 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb6; buf[3] = 0xaf; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8563 ret = usb_microdia_control_write(dev, reg, buf, 8);
8564 if (ret < 0)
8565 goto err;
8566
8567 reg = 0x10c0 ;
8568 ret = usb_microdia_control_read(dev, reg, buf, 1);
8569 if (ret < 0)
8570 goto err;
8571
8572 reg = 0x10c0 ;
8573 ret = usb_microdia_control_read(dev, reg, buf, 1);
8574 if (ret < 0)
8575 goto err;
8576
8577 reg = 0x10c0 ;
8578 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbb; buf[3] = 0xae; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8579 ret = usb_microdia_control_write(dev, reg, buf, 8);
8580 if (ret < 0)
8581 goto err;
8582
8583 reg = 0x10c0 ;
8584 ret = usb_microdia_control_read(dev, reg, buf, 1);
8585 if (ret < 0)
8586 goto err;
8587
8588 reg = 0x10c0 ;
8589 ret = usb_microdia_control_read(dev, reg, buf, 1);
8590 if (ret < 0)
8591 goto err;
8592
8593 reg = 0x10c0 ;
8594 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbc; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8595 ret = usb_microdia_control_write(dev, reg, buf, 8);
8596 if (ret < 0)
8597 goto err;
8598
8599 reg = 0x10c0 ;
8600 ret = usb_microdia_control_read(dev, reg, buf, 1);
8601 if (ret < 0)
8602 goto err;
8603
8604 reg = 0x10c0 ;
8605 ret = usb_microdia_control_read(dev, reg, buf, 1);
8606 if (ret < 0)
8607 goto err;
8608
8609 reg = 0x10c0 ;
8610 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbd; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8611 ret = usb_microdia_control_write(dev, reg, buf, 8);
8612 if (ret < 0)
8613 goto err;
8614
8615 reg = 0x10c0 ;
8616 ret = usb_microdia_control_read(dev, reg, buf, 1);
8617 if (ret < 0)
8618 goto err;
8619
8620 reg = 0x10c0 ;
8621 ret = usb_microdia_control_read(dev, reg, buf, 1);
8622 if (ret < 0)
8623 goto err;
8624
8625 reg = 0x10c0 ;
8626 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbe; buf[3] = 0x3b; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8627 ret = usb_microdia_control_write(dev, reg, buf, 8);
8628 if (ret < 0)
8629 goto err;
8630
8631 reg = 0x10c0 ;
8632 ret = usb_microdia_control_read(dev, reg, buf, 1);
8633 if (ret < 0)
8634 goto err;
8635
8636 reg = 0x10c0 ;
8637 ret = usb_microdia_control_read(dev, reg, buf, 1);
8638 if (ret < 0)
8639 goto err;
8640
8641 reg = 0x10c0 ;
8642 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbf; buf[3] = 0x3a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8643 ret = usb_microdia_control_write(dev, reg, buf, 8);
8644 if (ret < 0)
8645 goto err;
8646
8647 reg = 0x10c0 ;
8648 ret = usb_microdia_control_read(dev, reg, buf, 1);
8649 if (ret < 0)
8650 goto err;
8651
8652 reg = 0x10c0 ;
8653 ret = usb_microdia_control_read(dev, reg, buf, 1);
8654 if (ret < 0)
8655 goto err;
8656
8657 reg = 0x10c0 ;
8658 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc0; buf[3] = 0xe2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8659 ret = usb_microdia_control_write(dev, reg, buf, 8);
8660 if (ret < 0)
8661 goto err;
8662
8663 reg = 0x10c0 ;
8664 ret = usb_microdia_control_read(dev, reg, buf, 1);
8665 if (ret < 0)
8666 goto err;
8667
8668 reg = 0x10c0 ;
8669 ret = usb_microdia_control_read(dev, reg, buf, 1);
8670 if (ret < 0)
8671 goto err;
8672
8673 reg = 0x10c0 ;
8674 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc1; buf[3] = 0xc8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8675 ret = usb_microdia_control_write(dev, reg, buf, 8);
8676 if (ret < 0)
8677 goto err;
8678
8679 reg = 0x10c0 ;
8680 ret = usb_microdia_control_read(dev, reg, buf, 1);
8681 if (ret < 0)
8682 goto err;
8683
8684 reg = 0x10c0 ;
8685 ret = usb_microdia_control_read(dev, reg, buf, 1);
8686 if (ret < 0)
8687 goto err;
8688
8689 reg = 0x10c0 ;
8690 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc2; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8691 ret = usb_microdia_control_write(dev, reg, buf, 8);
8692 if (ret < 0)
8693 goto err;
8694
8695 reg = 0x10c0 ;
8696 ret = usb_microdia_control_read(dev, reg, buf, 1);
8697 if (ret < 0)
8698 goto err;
8699
8700 reg = 0x10c0 ;
8701 ret = usb_microdia_control_read(dev, reg, buf, 1);
8702 if (ret < 0)
8703 goto err;
8704
8705 reg = 0x10c0 ;
8706 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc4; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8707 ret = usb_microdia_control_write(dev, reg, buf, 8);
8708 if (ret < 0)
8709 goto err;
8710
8711 reg = 0x10c0 ;
8712 ret = usb_microdia_control_read(dev, reg, buf, 1);
8713 if (ret < 0)
8714 goto err;
8715
8716 reg = 0x10c0 ;
8717 ret = usb_microdia_control_read(dev, reg, buf, 1);
8718 if (ret < 0)
8719 goto err;
8720
8721 reg = 0x10c0 ;
8722 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc6; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8723 ret = usb_microdia_control_write(dev, reg, buf, 8);
8724 if (ret < 0)
8725 goto err;
8726
8727 reg = 0x10c0 ;
8728 ret = usb_microdia_control_read(dev, reg, buf, 1);
8729 if (ret < 0)
8730 goto err;
8731
8732 reg = 0x10c0 ;
8733 ret = usb_microdia_control_read(dev, reg, buf, 1);
8734 if (ret < 0)
8735 goto err;
8736
8737 reg = 0x10c0 ;
8738 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc7; buf[3] = 0x81; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8739 ret = usb_microdia_control_write(dev, reg, buf, 8);
8740 if (ret < 0)
8741 goto err;
8742
8743 reg = 0x10c0 ;
8744 ret = usb_microdia_control_read(dev, reg, buf, 1);
8745 if (ret < 0)
8746 goto err;
8747
8748 reg = 0x10c0 ;
8749 ret = usb_microdia_control_read(dev, reg, buf, 1);
8750 if (ret < 0)
8751 goto err;
8752
8753 reg = 0x10c0 ;
8754 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc9; buf[3] = 0xe0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8755 ret = usb_microdia_control_write(dev, reg, buf, 8);
8756 if (ret < 0)
8757 goto err;
8758
8759 reg = 0x10c0 ;
8760 ret = usb_microdia_control_read(dev, reg, buf, 1);
8761 if (ret < 0)
8762 goto err;
8763
8764 reg = 0x10c0 ;
8765 ret = usb_microdia_control_read(dev, reg, buf, 1);
8766 if (ret < 0)
8767 goto err;
8768
8769 reg = 0x10c0 ;
8770 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xca; buf[3] = 0xe8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8771 ret = usb_microdia_control_write(dev, reg, buf, 8);
8772 if (ret < 0)
8773 goto err;
8774
8775 reg = 0x10c0 ;
8776 ret = usb_microdia_control_read(dev, reg, buf, 1);
8777 if (ret < 0)
8778 goto err;
8779
8780 reg = 0x10c0 ;
8781 ret = usb_microdia_control_read(dev, reg, buf, 1);
8782 if (ret < 0)
8783 goto err;
8784
8785 reg = 0x10c0 ;
8786 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcc; buf[3] = 0xd8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8787 ret = usb_microdia_control_write(dev, reg, buf, 8);
8788 if (ret < 0)
8789 goto err;
8790
8791 reg = 0x10c0 ;
8792 ret = usb_microdia_control_read(dev, reg, buf, 1);
8793 if (ret < 0)
8794 goto err;
8795
8796 reg = 0x10c0 ;
8797 ret = usb_microdia_control_read(dev, reg, buf, 1);
8798 if (ret < 0)
8799 goto err;
8800
8801 reg = 0x10c0 ;
8802 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcd; buf[3] = 0x93; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8803 ret = usb_microdia_control_write(dev, reg, buf, 8);
8804 if (ret < 0)
8805 goto err;
8806
8807 reg = 0x10c0 ;
8808 ret = usb_microdia_control_read(dev, reg, buf, 1);
8809 if (ret < 0)
8810 goto err;
8811
8812 reg = 0x10c0 ;
8813 ret = usb_microdia_control_read(dev, reg, buf, 1);
8814 if (ret < 0)
8815 goto err;
8816
8817 reg = 0x10c1 ;
8818 ret = usb_microdia_control_read(dev, reg, buf, 1);
8819 if (ret < 0)
8820 goto err;
8821
8822 reg = 0x10c1 ;
8823 buf[0] = 0x50;
8824 ret = usb_microdia_control_write(dev, reg, buf, 1);
8825 if (ret < 0)
8826 goto err;
8827
8828 reg = 0x10c0 ;
8829 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8830 ret = usb_microdia_control_write(dev, reg, buf, 8);
8831 if (ret < 0)
8832 goto err;
8833
8834 reg = 0x10c0 ;
8835 ret = usb_microdia_control_read(dev, reg, buf, 1);
8836 if (ret < 0)
8837 goto err;
8838
8839 reg = 0x10c0 ;
8840 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8841 ret = usb_microdia_control_write(dev, reg, buf, 8);
8842 if (ret < 0)
8843 goto err;
8844
8845 reg = 0x10c0 ;
8846 ret = usb_microdia_control_read(dev, reg, buf, 1);
8847 if (ret < 0)
8848 goto err;
8849
8850 reg = 0x10c0 ;
8851 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8852 ret = usb_microdia_control_write(dev, reg, buf, 8);
8853 if (ret < 0)
8854 goto err;
8855
8856 reg = 0x10c0 ;
8857 ret = usb_microdia_control_read(dev, reg, buf, 1);
8858 if (ret < 0)
8859 goto err;
8860
8861 reg = 0x10c0 ;
8862 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8863 ret = usb_microdia_control_write(dev, reg, buf, 8);
8864 if (ret < 0)
8865 goto err;
8866
8867 reg = 0x10c0 ;
8868 ret = usb_microdia_control_read(dev, reg, buf, 1);
8869 if (ret < 0)
8870 goto err;
8871
8872 reg = 0x10c0 ;
8873 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8874 ret = usb_microdia_control_write(dev, reg, buf, 8);
8875 if (ret < 0)
8876 goto err;
8877
8878 reg = 0x10c0 ;
8879 ret = usb_microdia_control_read(dev, reg, buf, 1);
8880 if (ret < 0)
8881 goto err;
8882
8883 reg = 0x10c0 ;
8884 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8885 ret = usb_microdia_control_write(dev, reg, buf, 8);
8886 if (ret < 0)
8887 goto err;
8888
8889 reg = 0x10c0 ;
8890 ret = usb_microdia_control_read(dev, reg, buf, 1);
8891 if (ret < 0)
8892 goto err;
8893
8894 reg = 0x10c0 ;
8895 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8896 ret = usb_microdia_control_write(dev, reg, buf, 8);
8897 if (ret < 0)
8898 goto err;
8899
8900 reg = 0x10c0 ;
8901 ret = usb_microdia_control_read(dev, reg, buf, 1);
8902 if (ret < 0)
8903 goto err;
8904
8905 reg = 0x10c0 ;
8906 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8907 ret = usb_microdia_control_write(dev, reg, buf, 8);
8908 if (ret < 0)
8909 goto err;
8910
8911 reg = 0x10c0 ;
8912 ret = usb_microdia_control_read(dev, reg, buf, 1);
8913 if (ret < 0)
8914 goto err;
8915
8916 reg = 0x10c0 ;
8917 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8918 ret = usb_microdia_control_write(dev, reg, buf, 8);
8919 if (ret < 0)
8920 goto err;
8921
8922 reg = 0x10c0 ;
8923 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8924 ret = usb_microdia_control_write(dev, reg, buf, 8);
8925 if (ret < 0)
8926 goto err;
8927
8928 reg = 0x10c0 ;
8929 ret = usb_microdia_control_read(dev, reg, buf, 1);
8930 if (ret < 0)
8931 goto err;
8932
8933 reg = 0x10c0 ;
8934 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8935 ret = usb_microdia_control_write(dev, reg, buf, 8);
8936 if (ret < 0)
8937 goto err;
8938
8939 reg = 0x10c0 ;
8940 ret = usb_microdia_control_read(dev, reg, buf, 1);
8941 if (ret < 0)
8942 goto err;
8943
8944 reg = 0x10c0 ;
8945 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8946 ret = usb_microdia_control_write(dev, reg, buf, 8);
8947 if (ret < 0)
8948 goto err;
8949
8950 reg = 0x10c0 ;
8951 ret = usb_microdia_control_read(dev, reg, buf, 1);
8952 if (ret < 0)
8953 goto err;
8954
8955 reg = 0x10c0 ;
8956 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8957 ret = usb_microdia_control_write(dev, reg, buf, 8);
8958 if (ret < 0)
8959 goto err;
8960
8961 reg = 0x10c0 ;
8962 ret = usb_microdia_control_read(dev, reg, buf, 1);
8963 if (ret < 0)
8964 goto err;
8965
8966 reg = 0x10c0 ;
8967 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8968 ret = usb_microdia_control_write(dev, reg, buf, 8);
8969 if (ret < 0)
8970 goto err;
8971
8972 reg = 0x10c0 ;
8973 ret = usb_microdia_control_read(dev, reg, buf, 1);
8974 if (ret < 0)
8975 goto err;
8976
8977 reg = 0x10c0 ;
8978 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8979 ret = usb_microdia_control_write(dev, reg, buf, 8);
8980 if (ret < 0)
8981 goto err;
8982
8983 reg = 0x10c0 ;
8984 ret = usb_microdia_control_read(dev, reg, buf, 1);
8985 if (ret < 0)
8986 goto err;
8987
8988 reg = 0x10c0 ;
8989 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8990 ret = usb_microdia_control_write(dev, reg, buf, 8);
8991 if (ret < 0)
8992 goto err;
8993
8994 reg = 0x10c0 ;
8995 ret = usb_microdia_control_read(dev, reg, buf, 1);
8996 if (ret < 0)
8997 goto err;
8998
8999 reg = 0x10c0 ;
9000 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9001 ret = usb_microdia_control_write(dev, reg, buf, 8);
9002 if (ret < 0)
9003 goto err;
9004
9005 reg = 0x10c0 ;
9006 ret = usb_microdia_control_read(dev, reg, buf, 1);
9007 if (ret < 0)
9008 goto err;
9009
9010 reg = 0x10c0 ;
9011 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9012 ret = usb_microdia_control_write(dev, reg, buf, 8);
9013 if (ret < 0)
9014 goto err;
9015
9016 reg = 0x10c2 ;
9017 ret = usb_microdia_control_read(dev, reg, buf, 5);
9018 if (ret < 0)
9019 goto err;
9020
9021 reg = 0x10c1 ;
9022 buf[0] = 0x30;
9023 ret = usb_microdia_control_write(dev, reg, buf, 1);
9024 if (ret < 0)
9025 goto err;
9026
9027 reg = 0x10e0 ;
9028 buf[0] = 0x47;
9029 ret = usb_microdia_control_write(dev, reg, buf, 1);
9030 if (ret < 0)
9031 goto err;
9032
9033 reg = 0x10e0 ;
9034 buf[0] = 0x47;
9035 ret = usb_microdia_control_write(dev, reg, buf, 1);
9036 if (ret < 0)
9037 goto err;
9038
9039 reg = 0x1001 ;
9040 buf[0] = 0xc6;
9041 ret = usb_microdia_control_write(dev, reg, buf, 1);
9042 if (ret < 0)
9043 goto err;
9044
9045 reg = 0x1001 ;
9046 buf[0] = 0xc4;
9047 ret = usb_microdia_control_write(dev, reg, buf, 1);
9048 if (ret < 0)
9049 goto err;
9050
9051 reg = 0x1001 ;
9052 buf[0] = 0x84;
9053 ret = usb_microdia_control_write(dev, reg, buf, 1);
9054 if (ret < 0)
9055 goto err;
9056
9057 reg = 0x1189 ;
9058 buf[0] = 0xcc;
9059 ret = usb_microdia_control_write(dev, reg, buf, 1);
9060 if (ret < 0)
9061 goto err;
9062
9063 reg = 0x11bc ;
9064 buf[0] = 0x00;
9065 ret = usb_microdia_control_write(dev, reg, buf, 1);
9066 if (ret < 0)
9067 goto err;
9068
9069 reg = 0x11bd ;
9070 buf[0] = 0x00;
9071 ret = usb_microdia_control_write(dev, reg, buf, 1);
9072 if (ret < 0)
9073 goto err;
9074
9075 reg = 0x11be ;
9076 buf[0] = 0x00;
9077 ret = usb_microdia_control_write(dev, reg, buf, 1);
9078 if (ret < 0)
9079 goto err;
9080
9081 reg = 0x11bf ;
9082 buf[0] = 0x00;
9083 ret = usb_microdia_control_write(dev, reg, buf, 1);
9084 if (ret < 0)
9085 goto err;
9086
9087 reg = 0x10c0 ;
9088 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9089 ret = usb_microdia_control_write(dev, reg, buf, 8);
9090 if (ret < 0)
9091 goto err;
9092
9093 reg = 0x10c0 ;
9094 ret = usb_microdia_control_read(dev, reg, buf, 1);
9095 if (ret < 0)
9096 goto err;
9097
9098 reg = 0x10c0 ;
9099 ret = usb_microdia_control_read(dev, reg, buf, 1);
9100 if (ret < 0)
9101 goto err;
9102
9103 reg = 0x10c0 ;
9104 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
9105 ret = usb_microdia_control_write(dev, reg, buf, 8);
9106 if (ret < 0)
9107 goto err;
9108
9109 reg = 0x10c0 ;
9110 ret = usb_microdia_control_read(dev, reg, buf, 1);
9111 if (ret < 0)
9112 goto err;
9113
9114 reg = 0x10c0 ;
9115 ret = usb_microdia_control_read(dev, reg, buf, 1);
9116 if (ret < 0)
9117 goto err;
9118
9119 reg = 0x10c0 ;
9120 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9121 ret = usb_microdia_control_write(dev, reg, buf, 8);
9122 if (ret < 0)
9123 goto err;
9124
9125 reg = 0x10c0 ;
9126 ret = usb_microdia_control_read(dev, reg, buf, 1);
9127 if (ret < 0)
9128 goto err;
9129
9130 reg = 0x10c0 ;
9131 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9132 ret = usb_microdia_control_write(dev, reg, buf, 8);
9133 if (ret < 0)
9134 goto err;
9135
9136 reg = 0x10c0 ;
9137 ret = usb_microdia_control_read(dev, reg, buf, 1);
9138 if (ret < 0)
9139 goto err;
9140
9141 reg = 0x10c0 ;
9142 ret = usb_microdia_control_read(dev, reg, buf, 1);
9143 if (ret < 0)
9144 goto err;
9145
9146 reg = 0x1180 ;
9147 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x50; buf[5] = 0x78;
9148 ret = usb_microdia_control_write(dev, reg, buf, 6);
9149 if (ret < 0)
9150 goto err;
9151
9152 reg = 0x10fb ;
9153 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
9154 ret = usb_microdia_control_write(dev, reg, buf, 5);
9155 if (ret < 0)
9156 goto err;
9157
9158 reg = 0x1189 ;
9159 buf[0] = 0xdc;
9160 ret = usb_microdia_control_write(dev, reg, buf, 1);
9161 if (ret < 0)
9162 goto err;
9163
9164 reg = 0x1189 ;
9165 buf[0] = 0xd0;
9166 ret = usb_microdia_control_write(dev, reg, buf, 1);
9167 if (ret < 0)
9168 goto err;
9169
9170 reg = 0x11a1 ;
9171 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
9172 ret = usb_microdia_control_write(dev, reg, buf, 4);
9173 if (ret < 0)
9174 goto err;
9175
9176 reg = 0x11ab ;
9177 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
9178 ret = usb_microdia_control_write(dev, reg, buf, 4);
9179 if (ret < 0)
9180 goto err;
9181
9182 reg = 0x1000 ;
9183 buf[0] = 0x78;
9184 ret = usb_microdia_control_write(dev, reg, buf, 1);
9185 if (ret < 0)
9186 goto err;
9187
9188 reg = 0x1002 ;
9189 buf[0] = 0x18;
9190 ret = usb_microdia_control_write(dev, reg, buf, 1);
9191 if (ret < 0)
9192 goto err;
9193
9194 reg = 0x1002 ;
9195 buf[0] = 0x08;
9196 ret = usb_microdia_control_write(dev, reg, buf, 1);
9197 if (ret < 0)
9198 goto err;
9199
9200 reg = 0x11b8 ;
9201 buf[0] = 0x38;
9202 ret = usb_microdia_control_write(dev, reg, buf, 1);
9203 if (ret < 0)
9204 goto err;
9205
9206 reg = 0x118a ;
9207 buf[0] = 0x02;
9208 ret = usb_microdia_control_write(dev, reg, buf, 1);
9209 if (ret < 0)
9210 goto err;
9211
9212 reg = 0x0395 ;
9213 buf[0] = 0x02;
9214 ret = usb_microdia_control_write(dev, reg, buf, 1);
9215 if (ret < 0)
9216 goto err;
9217
9218 reg = 0x11b8 ;
9219 buf[0] = 0x78;
9220 ret = usb_microdia_control_write(dev, reg, buf, 1);
9221 if (ret < 0)
9222 goto err;
9223
9224 reg = 0x11b8 ;
9225 ret = usb_microdia_control_read(dev, reg, buf, 1);
9226 if (ret < 0)
9227 goto err;
9228
9229 reg = 0x11b8 ;
9230 buf[0] = 0xf9;
9231 ret = usb_microdia_control_write(dev, reg, buf, 1);
9232 if (ret < 0)
9233 goto err;
9234
9235 reg = 0x11b8 ;
9236 ret = usb_microdia_control_read(dev, reg, buf, 1);
9237 if (ret < 0)
9238 goto err;
9239
9240 reg = 0x11b8 ;
9241 buf[0] = 0x7a;
9242 ret = usb_microdia_control_write(dev, reg, buf, 1);
9243 if (ret < 0)
9244 goto err;
9245
9246 reg = 0x11b8 ;
9247 ret = usb_microdia_control_read(dev, reg, buf, 1);
9248 if (ret < 0)
9249 goto err;
9250
9251 reg = 0x11b8 ;
9252 buf[0] = 0x7b;
9253 ret = usb_microdia_control_write(dev, reg, buf, 1);
9254 if (ret < 0)
9255 goto err;
9256
9257 reg = 0x11b8 ;
9258 ret = usb_microdia_control_read(dev, reg, buf, 1);
9259 if (ret < 0)
9260 goto err;
9261
9262 reg = 0x11b8 ;
9263 buf[0] = 0x7c;
9264 ret = usb_microdia_control_write(dev, reg, buf, 1);
9265 if (ret < 0)
9266 goto err;
9267
9268 reg = 0x11b8 ;
9269 ret = usb_microdia_control_read(dev, reg, buf, 1);
9270 if (ret < 0)
9271 goto err;
9272
9273 reg = 0x11b8 ;
9274 buf[0] = 0xfd;
9275 ret = usb_microdia_control_write(dev, reg, buf, 1);
9276 if (ret < 0)
9277 goto err;
9278
9279 reg = 0x11b8 ;
9280 ret = usb_microdia_control_read(dev, reg, buf, 1);
9281 if (ret < 0)
9282 goto err;
9283
9284 reg = 0x11b8 ;
9285 buf[0] = 0xfa;
9286 ret = usb_microdia_control_write(dev, reg, buf, 1);
9287 if (ret < 0)
9288 goto err;
9289
9290 reg = 0x10c0 ;
9291 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9292 ret = usb_microdia_control_write(dev, reg, buf, 8);
9293 if (ret < 0)
9294 goto err;
9295
9296 reg = 0x10c0 ;
9297 ret = usb_microdia_control_read(dev, reg, buf, 1);
9298 if (ret < 0)
9299 goto err;
9300
9301 reg = 0x10c0 ;
9302 ret = usb_microdia_control_read(dev, reg, buf, 1);
9303 if (ret < 0)
9304 goto err;
9305
9306 reg = 0x10c0 ;
9307 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9308 ret = usb_microdia_control_write(dev, reg, buf, 8);
9309 if (ret < 0)
9310 goto err;
9311
9312 reg = 0x10c0 ;
9313 ret = usb_microdia_control_read(dev, reg, buf, 1);
9314 if (ret < 0)
9315 goto err;
9316
9317 reg = 0x10c0 ;
9318 ret = usb_microdia_control_read(dev, reg, buf, 1);
9319 if (ret < 0)
9320 goto err;
9321
9322 reg = 0x10c0 ;
9323 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9324 ret = usb_microdia_control_write(dev, reg, buf, 8);
9325 if (ret < 0)
9326 goto err;
9327
9328 reg = 0x10c0 ;
9329 ret = usb_microdia_control_read(dev, reg, buf, 1);
9330 if (ret < 0)
9331 goto err;
9332
9333 reg = 0x10c0 ;
9334 ret = usb_microdia_control_read(dev, reg, buf, 1);
9335 if (ret < 0)
9336 goto err;
9337
9338 reg = 0x10c0 ;
9339 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9340 ret = usb_microdia_control_write(dev, reg, buf, 8);
9341 if (ret < 0)
9342 goto err;
9343
9344 reg = 0x10c0 ;
9345 ret = usb_microdia_control_read(dev, reg, buf, 1);
9346 if (ret < 0)
9347 goto err;
9348
9349 reg = 0x10c0 ;
9350 ret = usb_microdia_control_read(dev, reg, buf, 1);
9351 if (ret < 0)
9352 goto err;
9353
9354 reg = 0x10c0 ;
9355 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9356 ret = usb_microdia_control_write(dev, reg, buf, 8);
9357 if (ret < 0)
9358 goto err;
9359
9360 reg = 0x10c0 ;
9361 ret = usb_microdia_control_read(dev, reg, buf, 1);
9362 if (ret < 0)
9363 goto err;
9364
9365 reg = 0x10c0 ;
9366 ret = usb_microdia_control_read(dev, reg, buf, 1);
9367 if (ret < 0)
9368 goto err;
9369
9370 reg = 0x10c0 ;
9371 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9372 ret = usb_microdia_control_write(dev, reg, buf, 8);
9373 if (ret < 0)
9374 goto err;
9375
9376 reg = 0x10c0 ;
9377 ret = usb_microdia_control_read(dev, reg, buf, 1);
9378 if (ret < 0)
9379 goto err;
9380
9381 reg = 0x10c0 ;
9382 ret = usb_microdia_control_read(dev, reg, buf, 1);
9383 if (ret < 0)
9384 goto err;
9385
9386 reg = 0x10c0 ;
9387 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9388 ret = usb_microdia_control_write(dev, reg, buf, 8);
9389 if (ret < 0)
9390 goto err;
9391
9392 reg = 0x10c0 ;
9393 ret = usb_microdia_control_read(dev, reg, buf, 1);
9394 if (ret < 0)
9395 goto err;
9396
9397 reg = 0x10c0 ;
9398 ret = usb_microdia_control_read(dev, reg, buf, 1);
9399 if (ret < 0)
9400 goto err;
9401
9402 reg = 0x1182 ;
9403 buf[0] = 0x01;
9404 ret = usb_microdia_control_write(dev, reg, buf, 1);
9405 if (ret < 0)
9406 goto err;
9407
9408 reg = 0x10c0 ;
9409 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x7d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9410 ret = usb_microdia_control_write(dev, reg, buf, 8);
9411 if (ret < 0)
9412 goto err;
9413
9414 reg = 0x10c0 ;
9415 ret = usb_microdia_control_read(dev, reg, buf, 1);
9416 if (ret < 0)
9417 goto err;
9418
9419 reg = 0x10c0 ;
9420 ret = usb_microdia_control_read(dev, reg, buf, 1);
9421 if (ret < 0)
9422 goto err;
9423
9424 reg = 0x10c0 ;
9425 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9426 ret = usb_microdia_control_write(dev, reg, buf, 8);
9427 if (ret < 0)
9428 goto err;
9429
9430 reg = 0x10c0 ;
9431 ret = usb_microdia_control_read(dev, reg, buf, 1);
9432 if (ret < 0)
9433 goto err;
9434
9435 reg = 0x10c0 ;
9436 ret = usb_microdia_control_read(dev, reg, buf, 1);
9437 if (ret < 0)
9438 goto err;
9439
9440 reg = 0x10c0 ;
9441 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9442 ret = usb_microdia_control_write(dev, reg, buf, 8);
9443 if (ret < 0)
9444 goto err;
9445
9446 reg = 0x10c0 ;
9447 ret = usb_microdia_control_read(dev, reg, buf, 1);
9448 if (ret < 0)
9449 goto err;
9450
9451 reg = 0x10c0 ;
9452 ret = usb_microdia_control_read(dev, reg, buf, 1);
9453 if (ret < 0)
9454 goto err;
9455
9456 reg = 0x10c0 ;
9457 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9458 ret = usb_microdia_control_write(dev, reg, buf, 8);
9459 if (ret < 0)
9460 goto err;
9461
9462 reg = 0x10c0 ;
9463 ret = usb_microdia_control_read(dev, reg, buf, 1);
9464 if (ret < 0)
9465 goto err;
9466
9467 reg = 0x10c0 ;
9468 ret = usb_microdia_control_read(dev, reg, buf, 1);
9469 if (ret < 0)
9470 goto err;
9471
9472 reg = 0x10c0 ;
9473 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9474 ret = usb_microdia_control_write(dev, reg, buf, 8);
9475 if (ret < 0)
9476 goto err;
9477
9478 reg = 0x10c0 ;
9479 ret = usb_microdia_control_read(dev, reg, buf, 1);
9480 if (ret < 0)
9481 goto err;
9482
9483 reg = 0x10c0 ;
9484 ret = usb_microdia_control_read(dev, reg, buf, 1);
9485 if (ret < 0)
9486 goto err;
9487
9488 reg = 0x10c0 ;
9489 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9490 ret = usb_microdia_control_write(dev, reg, buf, 8);
9491 if (ret < 0)
9492 goto err;
9493
9494 reg = 0x10c0 ;
9495 ret = usb_microdia_control_read(dev, reg, buf, 1);
9496 if (ret < 0)
9497 goto err;
9498
9499 reg = 0x10c0 ;
9500 ret = usb_microdia_control_read(dev, reg, buf, 1);
9501 if (ret < 0)
9502 goto err;
9503
9504 reg = 0x10c0 ;
9505 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9506 ret = usb_microdia_control_write(dev, reg, buf, 8);
9507 if (ret < 0)
9508 goto err;
9509
9510 reg = 0x10c0 ;
9511 ret = usb_microdia_control_read(dev, reg, buf, 1);
9512 if (ret < 0)
9513 goto err;
9514
9515 reg = 0x10c0 ;
9516 ret = usb_microdia_control_read(dev, reg, buf, 1);
9517 if (ret < 0)
9518 goto err;
9519
9520 reg = 0x10c0 ;
9521 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9522 ret = usb_microdia_control_write(dev, reg, buf, 8);
9523 if (ret < 0)
9524 goto err;
9525
9526 reg = 0x10c0 ;
9527 ret = usb_microdia_control_read(dev, reg, buf, 1);
9528 if (ret < 0)
9529 goto err;
9530
9531 reg = 0x10c0 ;
9532 ret = usb_microdia_control_read(dev, reg, buf, 1);
9533 if (ret < 0)
9534 goto err;
9535
9536 reg = 0x11ba ;
9537 buf[0] = 0x0a;
9538 ret = usb_microdia_control_write(dev, reg, buf, 1);
9539 if (ret < 0)
9540 goto err;
9541
9542 reg = 0x118b ;
9543 buf[0] = 0x10;
9544 ret = usb_microdia_control_write(dev, reg, buf, 1);
9545 if (ret < 0)
9546 goto err;
9547
9548 reg = 0x10f7;
9549 buf[0] = 0x05;
9550 ret = usb_microdia_control_write(dev, reg, buf, 1);
9551 if (ret < 0)
9552 goto err;
9553
9554 reg = 0x10f8 ;
9555 buf[0] = 0x14;
9556 ret = usb_microdia_control_write(dev, reg, buf, 1);
9557 if (ret < 0)
9558 goto err;
9559
9560 reg = 0x10fa ;
9561 buf[0] = 0xff;
9562 ret = usb_microdia_control_write(dev, reg, buf, 1);
9563 if (ret < 0)
9564 goto err;
9565
9566 reg = 0x10f9 ;
9567 buf[0] = 0x00;
9568 ret = usb_microdia_control_write(dev, reg, buf, 1);
9569 if (ret < 0)
9570 goto err;
9571
9572 reg = 0x10f9 ;
9573 buf[0] = 0x00;
9574 ret = usb_microdia_control_write(dev, reg, buf, 1);
9575 if (ret < 0)
9576 goto err;
9577
9578 reg = 0x11ba ;
9579 buf[0] = 0x0a;
9580 ret = usb_microdia_control_write(dev, reg, buf, 1);
9581 if (ret < 0)
9582 goto err;
9583
9584 reg = 0x11bc ;
9585 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
9586 ret = usb_microdia_control_write(dev, reg, buf, 4);
9587 if (ret < 0)
9588 goto err;
9589
9590 reg = 0x11c0;
9591 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
9592 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
9593 buf[8] = 0x00; buf[9] = 0x00; buf[10] = 0x00; buf[11] = 0x00;
9594 buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00; buf[15] = 0x00;
9595 buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
9596 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00;
9597 buf[24] = 0x00; buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00;
9598 buf[28] = 0x00; buf[29] = 0x00; buf[30] = 0x00; buf[31] = 0x00;
9599 buf[32] = 0x00; buf[33] = 0x00; buf[34] = 0x00; buf[35] = 0x00;
9600 buf[36] = 0x00; buf[37] = 0x00; buf[38] = 0x00; buf[39] = 0x00;
9601 buf[40] = 0x00; buf[41] = 0x00; buf[42] = 0x00; buf[43] = 0x00;
9602 buf[44] = 0x00; buf[45] = 0x00; buf[46] = 0x00; buf[47] = 0x00;
9603 ret = usb_microdia_control_write(dev, reg, buf, 48);
9604 if (ret < 0)
9605 goto err;
9606
9607 reg = 0x11a5 ;
9608 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
9609 buf[4] = 0x04; buf[5] = 0x3f;
9610 ret = usb_microdia_control_write(dev, reg, buf, 6);
9611 if (ret < 0)
9612 goto err;
9613
9614 reg = 0x11af ;
9615 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
9616 ret = usb_microdia_control_write(dev, reg, buf, 4);
9617 if (ret < 0)
9618 goto err;
9619
9620 reg = 0x11b3 ;
9621 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
9622 ret = usb_microdia_control_write(dev, reg, buf, 4);
9623 if (ret < 0)
9624 goto err;
9625
9626 reg = 0x10e0 ;
9627 buf[0] = 0x47;
9628 ret = usb_microdia_control_write(dev, reg, buf, 1);
9629 if (ret < 0)
9630 goto err;
9631
9632 reg = 0x1061 ;
9633 buf[0] = 0x01;
9634 ret = usb_microdia_control_write(dev, reg, buf, 1);
9635 if (ret < 0)
9636 goto err;
9637
9638 reg = 0x10e0 ;
9639 buf[0] = 0x67;
9640 ret = usb_microdia_control_write(dev, reg, buf, 1);
9641 if (ret < 0)
9642 goto err;
9643
9644 reg = 0x1100 ;
9645 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
9646 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
9647 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
9648 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
9649 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
9650 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
9651 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
9652 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
9653 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
9654 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
9655 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
9656 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
9657 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
9658 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
9659 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
9660 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
9661 ret = usb_microdia_control_write(dev, reg, buf, 64);
9662 if (ret < 0)
9663 goto err;
9664
9665 reg = 0x1140 ;
9666 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
9667 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
9668 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
9669 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
9670 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
9671 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
9672 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
9673 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
9674 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
9675 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
9676 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
9677 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
9678 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
9679 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
9680 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
9681 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
9682 ret = usb_microdia_control_write(dev, reg, buf, 64);
9683 if (ret < 0)
9684 goto err;
9685
9686 reg = 0x10e0 ;
9687 buf[0] = 0x47;
9688 ret = usb_microdia_control_write(dev, reg, buf, 1);
9689 if (ret < 0)
9690 goto err;
9691
9692 reg = 0x1061 ;
9693 buf[0] = 0x03;
9694 ret = usb_microdia_control_write(dev, reg, buf, 1);
9695 if (ret < 0)
9696 goto err;
9697
9698 reg = 0x10e0 ;
9699 buf[0] = 0x4b;
9700 ret = usb_microdia_control_write(dev, reg, buf, 1);
9701 if (ret < 0)
9702 goto err;
9703
9704 reg = 0x1189 ;
9705 buf[0] = 0xd0;
9706 ret = usb_microdia_control_write(dev, reg, buf, 1);
9707 if (ret < 0)
9708 goto err;
9709
9710 reg = 0x11bc ;
9711 buf[0] = 0x00;
9712 ret = usb_microdia_control_write(dev, reg, buf, 1);
9713 if (ret < 0)
9714 goto err;
9715
9716 reg = 0x11bd ;
9717 buf[0] = 0x00;
9718 ret = usb_microdia_control_write(dev, reg, buf, 1);
9719 if (ret < 0)
9720 goto err;
9721
9722 reg = 0x11be ;
9723 buf[0] = 0x00;
9724 ret = usb_microdia_control_write(dev, reg, buf, 1);
9725 if (ret < 0)
9726 goto err;
9727
9728 reg = 0x11bf ;
9729 buf[0] = 0x00;
9730 ret = usb_microdia_control_write(dev, reg, buf, 1);
9731 if (ret < 0)
9732 goto err;
9733
9734 reg = 0x10c0 ;
9735 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9736 ret = usb_microdia_control_write(dev, reg, buf, 8);
9737 if (ret < 0)
9738 goto err;
9739
9740 reg = 0x10c0 ;
9741 ret = usb_microdia_control_read(dev, reg, buf, 1);
9742 if (ret < 0)
9743 goto err;
9744
9745 reg = 0x10c0 ;
9746 ret = usb_microdia_control_read(dev, reg, buf, 1);
9747 if (ret < 0)
9748 goto err;
9749
9750 reg = 0x10c0 ;
9751 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
9752 ret = usb_microdia_control_write(dev, reg, buf, 8);
9753 if (ret < 0)
9754 goto err;
9755
9756 reg = 0x10c0 ;
9757 ret = usb_microdia_control_read(dev, reg, buf, 1);
9758 if (ret < 0)
9759 goto err;
9760
9761 reg = 0x10c0 ;
9762 ret = usb_microdia_control_read(dev, reg, buf, 1);
9763 if (ret < 0)
9764 goto err;
9765
9766 reg = 0x10c0 ;
9767 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9768 ret = usb_microdia_control_write(dev, reg, buf, 8);
9769 if (ret < 0)
9770 goto err;
9771
9772 reg = 0x10c0 ;
9773 ret = usb_microdia_control_read(dev, reg, buf, 1);
9774 if (ret < 0)
9775 goto err;
9776
9777 reg = 0x10c0 ;
9778 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9779 ret = usb_microdia_control_write(dev, reg, buf, 8);
9780 if (ret < 0)
9781 goto err;
9782
9783 reg = 0x10c0 ;
9784 ret = usb_microdia_control_read(dev, reg, buf, 1);
9785 if (ret < 0)
9786 goto err;
9787
9788 reg = 0x10c0 ;
9789 ret = usb_microdia_control_read(dev, reg, buf, 1);
9790 if (ret < 0)
9791 goto err;
9792
9793 reg = 0x1180 ;
9794 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
9795 buf[4] = 0x50; buf[5] = 0x78;
9796 ret = usb_microdia_control_write(dev, reg, buf, 6);
9797 if (ret < 0)
9798 goto err;
9799
9800 reg = 0x10fb ;
9801 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
9802 buf[4] = 0x00;
9803 ret = usb_microdia_control_write(dev, reg, buf, 5);
9804 if (ret < 0)
9805 goto err;
9806
9807 reg = 0x1189 ;
9808 buf[0] = 0xd0;
9809 ret = usb_microdia_control_write(dev, reg, buf, 1);
9810 if (ret < 0)
9811 goto err;
9812
9813 reg = 0x11a1 ;
9814 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
9815 ret = usb_microdia_control_write(dev, reg, buf, 4);
9816 if (ret < 0)
9817 goto err;
9818
9819 reg = 0x11ab ;
9820 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
9821 ret = usb_microdia_control_write(dev, reg, buf, 4);
9822 if (ret < 0)
9823 goto err;
9824
9825 reg = 0x1061 ;
9826 buf[0] = 0x03;
9827 ret = usb_microdia_control_write(dev, reg, buf, 1);
9828 if (ret < 0)
9829 goto err;
9830
9831 reg = 0x11ba ;
9832 buf[0] = 0x0a;
9833 ret = usb_microdia_control_write(dev, reg, buf, 1);
9834 if (ret < 0)
9835 goto err;
9836
9837 reg = 0x11b9 ;
9838 buf[0] = 0x00;
9839 ret = usb_microdia_control_write(dev, reg, buf, 1);
9840 if (ret < 0)
9841 goto err;
9842
9843 reg = 0x11ba ;
9844 buf[0] = 0x0b;
9845 ret = usb_microdia_control_write(dev, reg, buf, 1);
9846 if (ret < 0)
9847 goto err;
9848
9849 reg = 0x1061 ;
9850 buf[0] = 0x01;
9851 ret = usb_microdia_control_write(dev, reg, buf, 1);
9852 if (ret < 0)
9853 goto err;
9854
9855 reg = 0x1000 ;
9856 buf[0] = 0x78;
9857 ret = usb_microdia_control_write(dev, reg, buf, 1);
9858 if (ret < 0)
9859 goto err;
9860
9861 reg = 0x1002 ;
9862 buf[0] = 0x08;
9863 ret = usb_microdia_control_write(dev, reg, buf, 1);
9864 if (ret < 0)
9865 goto err;
9866
9867 reg = 0x1002 ;
9868 buf[0] = 0x08;
9869 ret = usb_microdia_control_write(dev, reg, buf, 1);
9870 if (ret < 0)
9871 goto err;
9872
9873 reg = 0x11b8 ;
9874 buf[0] = 0xfa;
9875 ret = usb_microdia_control_write(dev, reg, buf, 1);
9876 if (ret < 0)
9877 goto err;
9878
9879 reg = 0x118a ;
9880 buf[0] = 0x02;
9881 ret = usb_microdia_control_write(dev, reg, buf, 1);
9882 if (ret < 0)
9883 goto err;
9884
9885 reg = 0x0395 ;
9886 buf[0] = 0x02;
9887 ret = usb_microdia_control_write(dev, reg, buf, 1);
9888 if (ret < 0)
9889 goto err;
9890
9891 reg = 0x11b8 ;
9892 buf[0] = 0xf8;
9893 ret = usb_microdia_control_write(dev, reg, buf, 1);
9894 if (ret < 0)
9895 goto err;
9896
9897 reg = 0x11b8 ;
9898 ret = usb_microdia_control_read(dev, reg, buf, 1);
9899 if (ret < 0)
9900 goto err;
9901
9902 reg = 0x11b8 ;
9903 buf[0] = 0xf9;
9904 ret = usb_microdia_control_write(dev, reg, buf, 1);
9905 if (ret < 0)
9906 goto err;
9907
9908 reg = 0x11b8 ;
9909 ret = usb_microdia_control_read(dev, reg, buf, 1);
9910 if (ret < 0)
9911 goto err;
9912
9913 reg = 0x11b8 ;
9914 buf[0] = 0x7a;
9915 ret = usb_microdia_control_write(dev, reg, buf, 1);
9916 if (ret < 0)
9917 goto err;
9918
9919 reg = 0x11b8 ;
9920 ret = usb_microdia_control_read(dev, reg, buf, 1);
9921 if (ret < 0)
9922 goto err;
9923
9924 reg = 0x11b8 ;
9925 buf[0] = 0x7b;
9926 ret = usb_microdia_control_write(dev, reg, buf, 1);
9927 if (ret < 0)
9928 goto err;
9929
9930 reg = 0x11b8 ;
9931 ret = usb_microdia_control_read(dev, reg, buf, 1);
9932 if (ret < 0)
9933 goto err;
9934
9935 reg = 0x11b8 ;
9936 buf[0] = 0x7c;
9937 ret = usb_microdia_control_write(dev, reg, buf, 1);
9938 if (ret < 0)
9939 goto err;
9940
9941 reg = 0x11b8 ;
9942 ret = usb_microdia_control_read(dev, reg, buf, 1);
9943 if (ret < 0)
9944 goto err;
9945
9946 reg = 0x11b8 ;
9947 buf[0] = 0xfd;
9948 ret = usb_microdia_control_write(dev, reg, buf, 1);
9949 if (ret < 0)
9950 goto err;
9951
9952 reg = 0x11b8 ;
9953 ret = usb_microdia_control_read(dev, reg, buf, 1);
9954 if (ret < 0)
9955 goto err;
9956
9957 reg = 0x11b8 ;
9958 buf[0] = 0xfa;
9959 ret = usb_microdia_control_write(dev, reg, buf, 1);
9960 if (ret < 0)
9961 goto err;
9962
9963 reg = 0x10c0 ;
9964 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9965 ret = usb_microdia_control_write(dev, reg, buf, 8);
9966 if (ret < 0)
9967 goto err;
9968
9969 reg = 0x10c0 ;
9970 ret = usb_microdia_control_read(dev, reg, buf, 1);
9971 if (ret < 0)
9972 goto err;
9973
9974 reg = 0x10c0 ;
9975 ret = usb_microdia_control_read(dev, reg, buf, 1);
9976 if (ret < 0)
9977 goto err;
9978
9979 reg = 0x10c0 ;
9980 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9981 ret = usb_microdia_control_write(dev, reg, buf, 8);
9982 if (ret < 0)
9983 goto err;
9984
9985 reg = 0x10c0 ;
9986 ret = usb_microdia_control_read(dev, reg, buf, 1);
9987 if (ret < 0)
9988 goto err;
9989
9990 reg = 0x10c0 ;
9991 ret = usb_microdia_control_read(dev, reg, buf, 1);
9992 if (ret < 0)
9993 goto err;
9994
9995 reg = 0x10c0 ;
9996 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x70; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9997 ret = usb_microdia_control_write(dev, reg, buf, 8);
9998 if (ret < 0)
9999 goto err;
10000
10001 reg = 0x10c0 ;
10002 ret = usb_microdia_control_read(dev, reg, buf, 1);
10003 if (ret < 0)
10004 goto err;
10005
10006 reg = 0x10c0 ;
10007 ret = usb_microdia_control_read(dev, reg, buf, 1);
10008 if (ret < 0)
10009 goto err;
10010
10011 reg = 0x10c0 ;
10012 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10013 ret = usb_microdia_control_write(dev, reg, buf, 8);
10014 if (ret < 0)
10015 goto err;
10016
10017 reg = 0x10c0 ;
10018 ret = usb_microdia_control_read(dev, reg, buf, 1);
10019 if (ret < 0)
10020 goto err;
10021
10022 reg = 0x10c0 ;
10023 ret = usb_microdia_control_read(dev, reg, buf, 1);
10024 if (ret < 0)
10025 goto err;
10026
10027 reg = 0x10c0 ;
10028 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10029 ret = usb_microdia_control_write(dev, reg, buf, 8);
10030 if (ret < 0)
10031 goto err;
10032
10033 reg = 0x10c0 ;
10034 ret = usb_microdia_control_read(dev, reg, buf, 1);
10035 if (ret < 0)
10036 goto err;
10037
10038 reg = 0x10c0 ;
10039 ret = usb_microdia_control_read(dev, reg, buf, 1);
10040 if (ret < 0)
10041 goto err;
10042
10043 reg = 0x10c0 ;
10044 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10045 ret = usb_microdia_control_write(dev, reg, buf, 8);
10046 if (ret < 0)
10047 goto err;
10048
10049 reg = 0x10c0 ;
10050 ret = usb_microdia_control_read(dev, reg, buf, 1);
10051 if (ret < 0)
10052 goto err;
10053
10054 reg = 0x10c0 ;
10055 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10056 ret = usb_microdia_control_write(dev, reg, buf, 8);
10057 if (ret < 0)
10058 goto err;
10059
10060 reg = 0x10c0 ;
10061 ret = usb_microdia_control_read(dev, reg, buf, 1);
10062 if (ret < 0)
10063 goto err;
10064
10065 reg = 0x10c2 ;
10066 ret = usb_microdia_control_read(dev, reg, buf, 5);
10067 if (ret < 0)
10068 goto err;
10069
10070 reg = 0x10c0 ;
10071 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10072 ret = usb_microdia_control_write(dev, reg, buf, 8);
10073 if (ret < 0)
10074 goto err;
10075
10076 reg = 0x10c0 ;
10077 ret = usb_microdia_control_read(dev, reg, buf, 1);
10078 if (ret < 0)
10079 goto err;
10080
10081 reg = 0x10c0 ;
10082 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10083 ret = usb_microdia_control_write(dev, reg, buf, 8);
10084 if (ret < 0)
10085 goto err;
10086
10087 reg = 0x10c0 ;
10088 ret = usb_microdia_control_read(dev, reg, buf, 1);
10089 if (ret < 0)
10090 goto err;
10091
10092 reg = 0x10c2 ;
10093 ret = usb_microdia_control_read(dev, reg, buf, 5);
10094 if (ret < 0)
10095 goto err;
10096
10097 reg = 0x10c0 ;
10098 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1c; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10099 ret = usb_microdia_control_write(dev, reg, buf, 8);
10100 if (ret < 0)
10101 goto err;
10102
10103 reg = 0x10c0 ;
10104 ret = usb_microdia_control_read(dev, reg, buf, 1);
10105 if (ret < 0)
10106 goto err;
10107
10108 reg = 0x10c0 ;
10109 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10110 ret = usb_microdia_control_write(dev, reg, buf, 8);
10111 if (ret < 0)
10112 goto err;
10113
10114 reg = 0x10c0 ;
10115 ret = usb_microdia_control_read(dev, reg, buf, 1);
10116 if (ret < 0)
10117 goto err;
10118
10119 reg = 0x10c2 ;
10120 ret = usb_microdia_control_read(dev, reg, buf, 5);
10121 if (ret < 0)
10122 goto err;
10123
10124 reg = 0x10c0 ;
10125 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10126 ret = usb_microdia_control_write(dev, reg, buf, 8);
10127 if (ret < 0)
10128 goto err;
10129
10130 reg = 0x10c0 ;
10131 ret = usb_microdia_control_read(dev, reg, buf, 1);
10132 if (ret < 0)
10133 goto err;
10134
10135 reg = 0x10c0 ;
10136 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10137 ret = usb_microdia_control_write(dev, reg, buf, 8);
10138 if (ret < 0)
10139 goto err;
10140
10141 reg = 0x10c0 ;
10142 ret = usb_microdia_control_read(dev, reg, buf, 1);
10143 if (ret < 0)
10144 goto err;
10145
10146 reg = 0x10c2 ;
10147 ret = usb_microdia_control_read(dev, reg, buf, 5);
10148 if (ret < 0)
10149 goto err;
10150
10151 reg = 0x1061 ;
10152 buf[0] = 0x03;
10153 ret = usb_microdia_control_write(dev, reg, buf, 1);
10154 if (ret < 0)
10155 goto err;
10156
10157 reg = 0x1007 ;
10158 buf[0] = 0x20;
10159 ret = usb_microdia_control_write(dev, reg, buf, 1);
10160 if (ret < 0)
10161 goto err;
10162
10163 reg = 0x1006 ;
10164 buf[0] = 0x00;
10165 ret = usb_microdia_control_write(dev, reg, buf, 1);
10166 if (ret < 0)
10167 goto err;
10168
10169 reg = 0x10c0 ;
10170 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10171 ret = usb_microdia_control_write(dev, reg, buf, 8);
10172 if (ret < 0)
10173 goto err;
10174
10175 reg = 0x10c0 ;
10176 ret = usb_microdia_control_read(dev, reg, buf, 1);
10177 if (ret < 0)
10178 goto err;
10179
10180 reg = 0x10c0 ;
10181 ret = usb_microdia_control_read(dev, reg, buf, 1);
10182 if (ret < 0)
10183 goto err;
10184
10185 reg = 0x10c0 ;
10186 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10187 ret = usb_microdia_control_write(dev, reg, buf, 8);
10188 if (ret < 0)
10189 goto err;
10190
10191 reg = 0x10c0 ;
10192 ret = usb_microdia_control_read(dev, reg, buf, 1);
10193 if (ret < 0)
10194 goto err;
10195
10196 reg = 0x10c0 ;
10197 ret = usb_microdia_control_read(dev, reg, buf, 1);
10198 if (ret < 0)
10199 goto err;
10200
10201 reg = 0x10c0 ;
10202 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10203 ret = usb_microdia_control_write(dev, reg, buf, 8);
10204 if (ret < 0)
10205 goto err;
10206
10207 reg = 0x10c0 ;
10208 ret = usb_microdia_control_read(dev, reg, buf, 1);
10209 if (ret < 0)
10210 goto err;
10211
10212 reg = 0x10c0 ;
10213 ret = usb_microdia_control_read(dev, reg, buf, 1);
10214 if (ret < 0)
10215 goto err;
10216
10217 reg = 0x10c0 ;
10218 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x36; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10219 ret = usb_microdia_control_write(dev, reg, buf, 8);
10220 if (ret < 0)
10221 goto err;
10222
10223 reg = 0x10c0 ;
10224 ret = usb_microdia_control_read(dev, reg, buf, 1);
10225 if (ret < 0)
10226 goto err;
10227
10228 reg = 0x10c0 ;
10229 ret = usb_microdia_control_read(dev, reg, buf, 1);
10230 if (ret < 0)
10231 goto err;
10232
10233 reg = 0x10c0 ;
10234 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10235 ret = usb_microdia_control_write(dev, reg, buf, 8);
10236 if (ret < 0)
10237 goto err;
10238
10239 reg = 0x10c0 ;
10240 ret = usb_microdia_control_read(dev, reg, buf, 1);
10241 if (ret < 0)
10242 goto err;
10243
10244 reg = 0x10c0 ;
10245 ret = usb_microdia_control_read(dev, reg, buf, 1);
10246 if (ret < 0)
10247 goto err;
10248
10249 reg = 0x10c0 ;
10250 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
10251 ret = usb_microdia_control_write(dev, reg, buf, 8);
10252 if (ret < 0)
10253 goto err;
10254
10255 reg = 0x10c0 ;
10256 ret = usb_microdia_control_read(dev, reg, buf, 1);
10257 if (ret < 0)
10258 goto err;
10259
10260 reg = 0x10c0 ;
10261 ret = usb_microdia_control_read(dev, reg, buf, 1);
10262 if (ret < 0)
10263 goto err;
10264
10265 reg = 0x10c0 ;
10266 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
10267 ret = usb_microdia_control_write(dev, reg, buf, 8);
10268 if (ret < 0)
10269 goto err;
10270
10271 reg = 0x10c0 ;
10272 ret = usb_microdia_control_read(dev, reg, buf, 1);
10273 if (ret < 0)
10274 goto err;
10275
10276 reg = 0x10c0 ;
10277 ret = usb_microdia_control_read(dev, reg, buf, 1);
10278 if (ret < 0)
10279 goto err;
10280
10281 reg = 0x10c0 ;
10282 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x94; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10283 ret = usb_microdia_control_write(dev, reg, buf, 8);
10284 if (ret < 0)
10285 goto err;
10286
10287 reg = 0x10c0 ;
10288 ret = usb_microdia_control_read(dev, reg, buf, 1);
10289 if (ret < 0)
10290 goto err;
10291
10292 reg = 0x10c0 ;
10293 ret = usb_microdia_control_read(dev, reg, buf, 1);
10294 if (ret < 0)
10295 goto err;
10296
10297 reg = 0x10c0 ;
10298 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x8d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10299 ret = usb_microdia_control_write(dev, reg, buf, 8);
10300 if (ret < 0)
10301 goto err;
10302
10303 reg = 0x10c0 ;
10304 ret = usb_microdia_control_read(dev, reg, buf, 1);
10305 if (ret < 0)
10306 goto err;
10307
10308 reg = 0x10c0 ;
10309 ret = usb_microdia_control_read(dev, reg, buf, 1);
10310 if (ret < 0)
10311 goto err;
10312
10313 reg = 0x10c0 ;
10314 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x09; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
10315 ret = usb_microdia_control_write(dev, reg, buf, 8);
10316 if (ret < 0)
10317 goto err;
10318
10319 reg = 0x10c0 ;
10320 ret = usb_microdia_control_read(dev, reg, buf, 1);
10321 if (ret < 0)
10322 goto err;
10323
10324 reg = 0x10c0 ;
10325 ret = usb_microdia_control_read(dev, reg, buf, 1);
10326 if (ret < 0)
10327 goto err;
10328
10329 reg = 0x10c0 ;
10330 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x95; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10331 ret = usb_microdia_control_write(dev, reg, buf, 8);
10332 if (ret < 0)
10333 goto err;
10334
10335 reg = 0x10c0 ;
10336 ret = usb_microdia_control_read(dev, reg, buf, 1);
10337 if (ret < 0)
10338 goto err;
10339
10340 reg = 0x10c0 ;
10341 ret = usb_microdia_control_read(dev, reg, buf, 1);
10342 if (ret < 0)
10343 goto err;
10344
10345 reg = 0x10c0 ;
10346 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10347 ret = usb_microdia_control_write(dev, reg, buf, 8);
10348 if (ret < 0)
10349 goto err;
10350
10351 reg = 0x10c0 ;
10352 ret = usb_microdia_control_read(dev, reg, buf, 1);
10353 if (ret < 0)
10354 goto err;
10355
10356 reg = 0x10c0 ;
10357 ret = usb_microdia_control_read(dev, reg, buf, 1);
10358 if (ret < 0)
10359 goto err;
10360
10361 reg = 0x10c0 ;
10362 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
10363 ret = usb_microdia_control_write(dev, reg, buf, 8);
10364 if (ret < 0)
10365 goto err;
10366
10367 reg = 0x10c0 ;
10368 ret = usb_microdia_control_read(dev, reg, buf, 1);
10369 if (ret < 0)
10370 goto err;
10371
10372 reg = 0x10c0 ;
10373 ret = usb_microdia_control_read(dev, reg, buf, 1);
10374 if (ret < 0)
10375 goto err;
10376
10377 reg = 0x10c0 ;
10378 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x96; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10379 ret = usb_microdia_control_write(dev, reg, buf, 8);
10380 if (ret < 0)
10381 goto err;
10382
10383 reg = 0x10c0 ;
10384 ret = usb_microdia_control_read(dev, reg, buf, 1);
10385 if (ret < 0)
10386 goto err;
10387
10388 reg = 0x10c0 ;
10389 ret = usb_microdia_control_read(dev, reg, buf, 1);
10390 if (ret < 0)
10391 goto err;
10392
10393 reg = 0x10c0 ;
10394 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10395 ret = usb_microdia_control_write(dev, reg, buf, 8);
10396 if (ret < 0)
10397 goto err;
10398
10399 reg = 0x10c0 ;
10400 ret = usb_microdia_control_read(dev, reg, buf, 1);
10401 if (ret < 0)
10402 goto err;
10403
10404 reg = 0x10c0 ;
10405 ret = usb_microdia_control_read(dev, reg, buf, 1);
10406 if (ret < 0)
10407 goto err;
10408
10409 reg = 0x10c0 ;
10410 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
10411 ret = usb_microdia_control_write(dev, reg, buf, 8);
10412 if (ret < 0)
10413 goto err;
10414
10415 reg = 0x10c0 ;
10416 ret = usb_microdia_control_read(dev, reg, buf, 1);
10417 if (ret < 0)
10418 goto err;
10419
10420 reg = 0x10c0 ;
10421 ret = usb_microdia_control_read(dev, reg, buf, 1);
10422 if (ret < 0)
10423 goto err;
10424
10425 reg = 0x1007 ;
10426 buf[0] = 0x20;
10427 ret = usb_microdia_control_write(dev, reg, buf, 1);
10428 if (ret < 0)
10429 goto err;
10430
10431 reg = 0x1006 ;
10432 buf[0] = 0x20;
10433 ret = usb_microdia_control_write(dev, reg, buf, 1);
10434 if (ret < 0)
10435 goto err;
10436
10437
10438
10439
10440 /* END OF MICRODIA 6288 START STREAM */
10441
10442 return 0;
10443 err:
10444 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
10445 return ret;
10446 }
10447
10448 /**
10449 * @brief From UsbSnoop-plugin-parsed.log
10450 *
10451 * @param dev
10452 *
10453 * @returns 0 if all OK
10454 *
10455 * this function starts video stream Microdia 6128 webcam
10456 * Bridge SN9C325 + OM6802 CMOS sensor
10457 * note: comments are my observations so they could be wrong
10458 */
10459 int microdia_6128_start_stream(struct usb_microdia *dev)
10460 {
10461 int i;
10462 int ret = 0;
10463 __u8 buf[8];
10464
10465 __u8 data_15[] = {
10466 0x00, 0x1a, 0x34, 0x27, 0x20, 0xa0, 0x34, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00
10467 };
10468
10469 __u8 data_17[] = {
10470 0x08, 0x22, 0x44, 0x63, 0x7d, 0x92, 0xa3, 0xaf, 0xbc, 0xc4, 0xcd, 0xd5, 0xdc, 0xe1, 0xe8, 0xef,
10471 0xf7
10472 };
10473
10474 __u8 data_21[] = {
10475 0x15, 0x00, 0x2b, 0x00, 0x08, 0x00, 0xeb, 0x0f, 0xd7, 0x0f, 0x43, 0x00, 0x3d, 0x00, 0xca, 0x0f,
10476 0xf7, 0x0f, 0x0c, 0x00, 0x00
10477 };
10478
10479 __u8 qtable_1[] = {
10480 0x06, 0x04, 0x04, 0x06, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x08, 0x06, 0x06, 0x08, 0x0a, 0x10,
10481 0x0a, 0x0a, 0x08, 0x08, 0x0a, 0x13, 0x0e, 0x0e, 0x0c, 0x10, 0x17, 0x13, 0x17, 0x17, 0x15, 0x13,
10482 0x15, 0x15, 0x19, 0x1b, 0x23, 0x1f, 0x19, 0x1b, 0x21, 0x1b, 0x15, 0x15, 0x1f, 0x2b, 0x1f, 0x21,
10483 0x25, 0x27, 0x29, 0x29, 0x29, 0x17, 0x1d, 0x2d, 0x2f, 0x2b, 0x27, 0x2f, 0x23, 0x27, 0x29, 0x27
10484 };
10485
10486
10487 __u8 qtable_2[] = {
10488 0x06, 0x08, 0x08, 0x0a, 0x08, 0x0a, 0x12, 0x0a, 0x0a, 0x12, 0x27, 0x19, 0x15, 0x19, 0x27, 0x27,
10489 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
10490 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
10491 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
10492 };
10493
10494 __u8 om6802_sensor[][8] = {
10495 {0xa0, dev->sensor_slave_address, 0xd6, 0x02, 0x00, 0x00, 0x00, 0x10},
10496 {0xa0, dev->sensor_slave_address, 0xae, 0xe2, 0x00, 0x00, 0x00, 0x10},
10497 {0xa0, dev->sensor_slave_address, 0xdf, 0x6d, 0x00, 0x00, 0x00, 0x10}, // Enter factory mode
10498 {0xa0, dev->sensor_slave_address, 0xdd, 0x18, 0x00, 0x00, 0x00, 0x10}, // RGB, uyvy1,Raw RGB, n/1/2, n/clp
10499 {0xa0, dev->sensor_slave_address, 0x5a, 0xc0, 0x00, 0x00, 0x00, 0x10},
10500 {0xa0, dev->sensor_slave_address, 0xfb, 0x11, 0x00, 0x00, 0x00, 0x10},
10501 {0xa0, dev->sensor_slave_address, 0xf0, 0x03, 0x00, 0x00, 0x00, 0x10},
10502 {0xa0, dev->sensor_slave_address, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x10},
10503 {0xa0, dev->sensor_slave_address, 0xe4, 0xff, 0x00, 0x00, 0x00, 0x10},
10504 {0xa0, dev->sensor_slave_address, 0xfb, 0xee, 0x00, 0x00, 0x00, 0x10},
10505 {0xa0, dev->sensor_slave_address, 0x5d, 0x80, 0x00, 0x00, 0x00, 0x10},
10506 {0xa0, dev->sensor_slave_address, 0x71, 0x84, 0x00, 0x00, 0x00, 0x10},
10507 {0xa0, dev->sensor_slave_address, 0x72, 0x00, 0x00, 0x00, 0x00, 0x10},
10508 {0xa0, dev->sensor_slave_address, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
10509 {0xa0, dev->sensor_slave_address, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
10510 {0xa0, dev->sensor_slave_address, 0x71, 0x18, 0x00, 0x00, 0x00, 0x10},
10511 {0xa0, dev->sensor_slave_address, 0x72, 0x04, 0x00, 0x00, 0x00, 0x10},
10512 {0xa0, dev->sensor_slave_address, 0x68, 0xde, 0x00, 0x00, 0x00, 0x10},
10513 {0xa0, dev->sensor_slave_address, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10}, // 18
10514 {0xa0, dev->sensor_slave_address, 0x68, 0x80, 0x00, 0x00, 0x00, 0x10},
10515 {0xa0, dev->sensor_slave_address, 0x69, 0x00, 0x00, 0x00, 0x00, 0x10},
10516 {0, 0, 0, 0, 0, 0, 0, 0} // Terminating string
10517 };
10518
10519 buf[0] = 0x00;
10520 ret += usb_microdia_control_write(dev, 0xf1, buf, 1); // Reset cam
10521
10522 buf[0] = 0x23;
10523 ret += usb_microdia_control_write(dev, 0x01, buf, 1); // Sensor off, video off, clk 12MHz
10524
10525 ret += usb_microdia_control_read(dev, 0x00, buf, 1); // Check if cam is working, must write 0x12 in buf[0]
10526
10527 if(buf[0] != 0x12){
10528 UDIA_ERROR("Microdia 6128 webcam not connected or working !!!\n");
10529 return -ENODEV;
10530 }
10531
10532 ret += usb_microdia_control_read(dev, 0x01, buf, 1); // Must read 23
10533
10534 if(buf[0] != 0x23){
10535 UDIA_ERROR("Microdia 6128 webcam is not initialized !!!\n");
10536 return -ENODEV;
10537 }
10538
10539 buf[0] = 0x23; buf[1] = 0x72;
10540 ret += usb_microdia_control_write(dev, 0x01, buf, 2); // Configure GPIO
10541
10542 buf[0] = 0x34; buf[1] = 0x27; buf[2] = 0x20; buf[3] = 0xa0; buf[4] = 0x34;
10543 ret += usb_microdia_control_write(dev, 0x05, buf, 5);
10544
10545 buf[0] = 0x44; buf[1] = 0x45; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00;
10546 ret += usb_microdia_control_write(dev, 0x17, buf, 5);
10547
10548 buf[0] = 0x08; buf[1] = 0x40; buf[2] = 0x20; buf[3] = 0x00; buf[4] = 0x00;
10549 ret += usb_microdia_control_write(dev, 0x9a, buf, 5);
10550
10551 buf[0] = 0x60; buf[1] = 0x00; buf[2] = 0x00;
10552 ret += usb_microdia_control_write(dev, 0xd4, buf, 3);
10553 ret += usb_microdia_control_write(dev, 0x03, data_15, 15);
10554
10555 buf[0] = 0x73;
10556 ret += usb_microdia_control_write(dev, 0x02, buf, 1);
10557
10558 buf[0] = 0x64;
10559 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10560
10561 buf[0] = 0x22; buf[1] = 0x62;
10562 ret += usb_microdia_control_write(dev, 0x01, &buf[0], 1);
10563 ret += usb_microdia_control_write(dev, 0x01, &buf[1], 1);
10564
10565 buf[0] = 0x64;
10566 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10567 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10568
10569 buf[0] = 0x42; // Sensor on, clk 24MHz, video off
10570 ret += usb_microdia_control_write(dev, 0x01, buf, 1);
10571 ret += usb_microdia_control_write(dev, 0x01, buf, 1);
10572
10573 // Sensor stuff
10574 for (i = 0; i < 2; i++){
10575 ret += usb_microdia_control_write(dev, 0x08, om6802_sensor[i], 8);
10576 msleep(1);
10577 }
10578
10579 buf[0] = 0x71;
10580 ret += usb_microdia_control_write(dev, 0x02, buf, 1);
10581
10582 // Sensor stuff
10583 for (i = 2; i < 11; i++){
10584 ret += usb_microdia_control_write(dev, 0x08, om6802_sensor[i], 8);
10585 msleep(1);
10586 }
10587
10588 buf[0] = 0x71;
10589 ret += usb_microdia_control_write(dev, 0x02, buf, 1);
10590 ret += usb_microdia_control_write(dev, 0x02, buf, 1); // URB 1780
10591
10592 buf[0] = 0x28;
10593 ret += usb_microdia_control_write(dev, 0x15, buf, 1);
10594
10595 buf[0] = 0x1e;
10596 ret += usb_microdia_control_write(dev, 0x16, buf, 1);
10597
10598 buf[0] = 0x51;
10599 ret += usb_microdia_control_write(dev, 0x12, buf, 1);
10600
10601 buf[0] = 0x01;
10602 ret += usb_microdia_control_write(dev, 0x13, buf, 1);
10603
10604 buf[0] = 0x45;
10605 ret += usb_microdia_control_write(dev, 0x18, buf, 1);
10606
10607 buf[0] = 0x6a;
10608 ret += usb_microdia_control_write(dev, 0xd2, buf, 1);
10609
10610 buf[0] = 0x50;
10611 ret += usb_microdia_control_write(dev, 0xd3, buf, 1);
10612
10613 buf[0] = 0x00;
10614 ret += usb_microdia_control_write(dev, 0xc6, buf, 1);
10615 ret += usb_microdia_control_write(dev, 0xc7, buf, 1);
10616
10617 buf[0] = 0x50;
10618 ret += usb_microdia_control_write(dev, 0xc8, buf, 1);
10619
10620 buf[0] = 0x3c;
10621 ret += usb_microdia_control_write(dev, 0xc9, buf, 1);
10622
10623 buf[0] = 0x45;
10624 ret += usb_microdia_control_write(dev, 0x18, buf, 1);
10625
10626 buf[0] = 0x64;
10627 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10628
10629 buf[0] = 0x20;
10630 ret += usb_microdia_control_write(dev, 0x05, buf, 1);
10631 ret += usb_microdia_control_write(dev, 0x07, buf, 1);
10632 ret += usb_microdia_control_write(dev, 0x06, buf, 1);
10633
10634 buf[0] = 0x00;
10635 ret += usb_microdia_control_write(dev, 0x14, buf, 1);
10636
10637 ret += usb_microdia_control_write(dev, 0x20, data_17, 17);
10638 ret += usb_microdia_control_write(dev, 0x20, data_17, 17);
10639
10640 for (i = 0; i < 8; ++i) // writing the same buffer 8 times, why ??
10641 ret += usb_microdia_control_write(dev, 0x84, data_21, 21);
10642
10643 data_21[0] = 0x16; data_21[10] = 40; data_21[12] = 0x3f;
10644 ret += usb_microdia_control_write(dev, 0x84, data_21, 21);
10645
10646 buf[0] = 0x08;
10647 ret += usb_microdia_control_write(dev, 0x9a, buf, 1);
10648
10649 buf[0] = 0x10;
10650 ret += usb_microdia_control_write(dev, 0x99, buf, 1);
10651
10652 ret += usb_microdia_control_write(dev, 0x84, data_21, 21); // URB 1811
10653
10654 buf[0] = 0x20;
10655 ret += usb_microdia_control_write(dev, 0x05, buf, 1);
10656 ret += usb_microdia_control_write(dev, 0x07, buf, 1);
10657 ret += usb_microdia_control_write(dev, 0x06, buf, 1);
10658
10659 // Sensor Stuff
10660 for (i = 11; i < 15; i++){
10661 ret += usb_microdia_control_write(dev, 0x08, om6802_sensor[i], 8);
10662 msleep(1);
10663 }
10664
10665 buf[0] = 0x34;
10666 ret += usb_microdia_control_write(dev, 0x05, buf, 1);
10667 buf[0] = 0x27;
10668 ret += usb_microdia_control_write(dev, 0x06, buf, 1);
10669
10670 buf[0] = buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
10671 ret += usb_microdia_control_write(dev, 0xc0, buf, 6);
10672
10673 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
10674 ret += usb_microdia_control_write(dev, 0xca, buf, 4);
10675
10676 buf[0] = 0x1e; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xe7;
10677 ret += usb_microdia_control_write(dev, 0xce, buf, 4);
10678
10679 buf[0] = 0x42;
10680 ret += usb_microdia_control_write(dev, 0x01, buf, 1);
10681
10682 buf[0] = 0x64;
10683 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10684
10685 // Sensor Stuff
10686 for (i = 15; i < 19; i++){
10687 ret += usb_microdia_control_write(dev, 0x08, om6802_sensor[i], 8);
10688 msleep(1);
10689 }
10690
10691 buf[0] = 0x28;
10692 ret += usb_microdia_control_write(dev, 0x05, buf, 1);
10693
10694 buf[0] = 0x54;
10695 ret += usb_microdia_control_write(dev, 0x06, buf, 1);
10696
10697 // This changes the mode (VGA = 0 , CIF = 1)
10698 // buf = 0x40 | 0x05 | (mode << 4) 45 or 55
10699 buf[0] = 0x45;
10700 ret += usb_microdia_control_write(dev, 0x18, buf, 1);
10701
10702 // This is the Q table
10703 ret += usb_microdia_control_write(dev, 0x0100, qtable_1, 64); // first time
10704 ret += usb_microdia_control_write(dev, 0x0140, qtable_2, 64); // second time
10705
10706 // mode: VGA = 0, CIF = 1
10707 // buf = 0x05 | (mode << 4) 05 or 15
10708 buf[0] = 0x05;
10709 ret += usb_microdia_control_write(dev, 0x18, buf, 1);
10710
10711 buf[0] = 0x71;
10712 ret += usb_microdia_control_write(dev, 0x02, buf, 1);
10713 ret += usb_microdia_control_write(dev, 0x02, buf, 1);
10714
10715 buf[0] = 0x42; // Sensor on, Video disabled, clk 24MHz
10716 ret += usb_microdia_control_write(dev, 0x01, buf, 1);
10717
10718 buf[0] = 0x64;
10719 ret += usb_microdia_control_write(dev, 0x17, buf, 1);
10720
10721 // Command to start streaming
10722 // Sensor on, clk 24MHz, video enabled
10723 buf[0] = 0x46;
10724 ret += usb_microdia_control_write(dev, 0x01, buf, 1);
10725
10726 // When the device reads 46 from reg 0x01 it means that
10727 // camera is streaming
10728 ret += usb_microdia_control_read(dev, 0x01, buf, 1); // Must read 0x46
10729
10730 if (ret != 624)
10731 UDIA_DEBUG("Some read or write were not successful in Start Stream\n");
10732
10733 return 0;
10734 }
10735
10736
10737 int dev_microdia_stop_stream(struct usb_microdia *dev)
10738 {
10739 int ret = -ENODEV;
10740 if (dev && dev->stop_stream)
10741 ret = dev->stop_stream(dev);
10742
10743 return ret;
10744 }
10745
10746 /**
10747 * @brief From stop.htm
10748 *
10749 * @param dev
10750 *
10751 * @returns 0
10752 *
10753 * @author GWater
10754 *
10755 * For SN9C201 with MI1310.
10756 * This function has not been tested yet.
10757 */
10758 int microdia_6242_stop_stream(struct usb_microdia *dev)
10759 {
10760 __u8 buf[3];
10761
10762 __u8 only10c0[3] = {0x0d, 0x00, 0x00};
10763
10764 buf[0] = 0x01;
10765 usb_microdia_control_write(dev, 0x1061, buf, 1);
10766
10767 buf[0] = 0x60;
10768 usb_microdia_control_write(dev, 0x1007, buf, 1);
10769
10770 buf[0] = 0x00;
10771 usb_microdia_control_write(dev, 0x1006, buf, 1);
10772
10773 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
10774 only10c0[0], dev->sensor_flags, &only10c0[1]);
10775
10776 buf[0] = 0x38;
10777 usb_microdia_control_write(dev, 0x1000, buf, 1);
10778
10779 buf[0] = 0x6b;
10780 usb_microdia_control_write(dev, 0x11b8, buf, 1);
10781
10782 buf[0] = 0x60;
10783 usb_microdia_control_write(dev, 0x1007, buf, 1);
10784
10785 buf[0] = 0x20;
10786 usb_microdia_control_write(dev, 0x1006, buf, 1);
10787
10788
10789 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
10790 usb_microdia_control_write(dev, 0x1000, buf, 3);
10791
10792 /**
10793 * After the select alternate setting 0 is actually another transfer:
10794 * buf[0] = 0x00;
10795 * usb_microdia_control_write(dev, 0x1066, buf, 1);
10796 */
10797
10798 return 0;
10799 }
10800
10801
10802 /**
10803 * @brief From stopstream.log
10804 *
10805 * @param dev
10806 *
10807 * @returns 0
10808 *
10809 * @author GWater
10810 *
10811 * For SN9C201 with SOI968.
10812 * I don't whether the function really stops the stream.
10813 * Nevertheless the LED on the webcam now stops glowing.
10814 * The function is very similar to "microdia_624f_stop_stream".
10815 */
10816 int microdia_624e_stop_stream(struct usb_microdia *dev)
10817 {
10818 __u8 buf[3];
10819
10820 buf[0] = 0x01;
10821 usb_microdia_control_write(dev, 0x1061, buf, 1);
10822
10823 /* Next two writes added because it works better.
10824 * The LED stops glowing and I think the stream does too.
10825 * 0x20 = 0b00100000 which is the minimal of what the
10826 * other stopstreams have in common.
10827 */
10828 buf[0] = 0x20;
10829 usb_microdia_control_write(dev, 0x1007, buf, 1);
10830
10831 buf[0] = 0x20;
10832 usb_microdia_control_write(dev, 0x1006, buf, 1);
10833
10834 buf[0] = 0x3c;
10835 usb_microdia_control_write(dev, 0x1000, buf, 1);
10836
10837 buf[0] = 0x6a;
10838 usb_microdia_control_write(dev, 0x11b8, buf, 1);
10839
10840 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
10841 usb_microdia_control_write(dev, 0x1000, buf, 3);
10842
10843 usb_microdia_control_read(dev, 0x1066, buf, 1);
10844
10845 return 0;
10846 }
10847
10848
10849 int microdia_624f_stop_stream(struct usb_microdia *dev)
10850 {
10851 int ret;
10852 __u16 command;
10853 __u8 buf[3];
10854
10855 buf[0] = 0x02;
10856 command = 0x1066;
10857 ret = usb_microdia_control_write(dev, command, buf, 1);
10858 if (ret < 0)
10859 goto err;
10860
10861 buf[0] = 0x01;
10862 command = 0x1061;
10863 ret = usb_microdia_control_write(dev, command, buf, 1);
10864 if (ret < 0)
10865 goto err;
10866
10867 buf[0] = 0x38;
10868 command = 0x1000;
10869 ret = usb_microdia_control_write(dev, command, buf, 1);
10870 if (ret < 0)
10871 goto err;
10872
10873 buf[0] = 0x6a;
10874 command = 0x11b8;
10875 ret = usb_microdia_control_write(dev, command, buf, 1);
10876 if (ret < 0)
10877 goto err;
10878
10879 buf[0] = 0x20;
10880 command = 0x1007;
10881 ret = usb_microdia_control_write(dev, command, buf, 1);
10882 if (ret < 0)
10883 goto err;
10884
10885 buf[0] = 0x20;
10886 command = 0x1006;
10887 ret = usb_microdia_control_write(dev, command, buf, 1);
10888 if (ret < 0)
10889 goto err;
10890
10891 buf[0] = 0x98;
10892 buf[1] = 0xe7;
10893 buf[2] = 0x11;
10894 command = 0x1000;
10895 ret = usb_microdia_control_write(dev, command, buf, 3);
10896 if (ret < 0)
10897 goto err;
10898
10899 command = 0x1045;
10900 ret = usb_microdia_control_read(dev, command, buf, 1);
10901 if (ret < 0)
10902 goto err;
10903
10904 buf[0] = 0x0f;
10905 ret = usb_microdia_control_write(dev, command, buf, 1);
10906 if (ret < 0)
10907 goto err;
10908
10909 return ret;
10910
10911 err:
10912 UDIA_ERROR("command %x failed (%d)!\n", command, ret);
10913 return ret;
10914 }
10915
10916 int microdia_6260_stop_stream(struct usb_microdia *dev)
10917 {
10918 int ret;
10919 __u8 buf[32];
10920
10921 buf[0] = 0x01;
10922 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
10923 buf[0] = 0x38;
10924 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
10925 buf[0] = 0x6b;
10926 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
10927 buf[0] = 0x20;
10928 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
10929 buf[0] = 0x20;
10930 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
10931
10932 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
10933 ret = usb_microdia_control_write(dev, 0x1000, buf, 3);
10934
10935 buf[0] = 0x00;
10936 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
10937 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
10938 buf[0] = 0x0f;
10939 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
10940 buf[0] = 0x00;
10941 ret = usb_microdia_control_write(dev, 0x10c8, buf, 1);
10942 buf[0] = 0x80;
10943 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
10944
10945 return ret;
10946 }
10947
10948 /**
10949 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
10950 *
10951 * @param dev
10952 *
10953 * @returns 0 (ok) or -1 (error)
10954 *
10955 * @author Comer352l
10956 *
10957 * Windows driver version: 5.7.23.000
10958 * Windows versions: 2000 and XP
10959 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
10960 * All logs were made using AMCAP with 640x480, RGB24
10961 */
10962 int microdia_6270_stop_stream(struct usb_microdia *dev)
10963 {
10964 int ret = 0;
10965 int retI2C = 0;
10966 __u8 buf[3];
10967
10968 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
10969 buf[0] = 0x20;
10970 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
10971 buf[0] = 0x20;
10972 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
10973 /* => These two writes seem to cause the cam to stop sending isochronus USB messages */
10974 }
10975 buf[0] = 0x01;
10976 ret += usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 3544 */
10977 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
10978 buf[0] = 0x60;
10979 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
10980 buf[0] = 0x60;
10981 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
10982 }
10983 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
10984 /* Write to sensor register 0x07: Output Control */
10985 buf[0] = 0x00; buf[1] = 0x00; /* stop sensor readout, normal operation */
10986 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
10987 }
10988 buf[0] = 0x38; /* ALEX: 0x3c */
10989 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 3545 */
10990 buf[0] = 0x6d; /* ALEX: 0xec; FRANK: also 0x6c */
10991 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 3546 */
10992 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
10993 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 3547 */
10994
10995 /* INTERRUPT COMMING BACK (URB 2227) */
10996 /* SELECT ALTERNATE SETTINGS (URB 3548) */
10997 /* INTERRUPT GOING DOWN (URB 3549) */
10998
10999 buf[0] = 0x00;
11000 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 3550 */
11001
11002 if (ret < 9) {
11003 UDIA_INFO("One ore more errors occured while stopping stream !\n");
11004 return -1;
11005 } else {
11006 return 0;
11007 }
11008 }
11009
11010 int microdia_627b_stop_stream(struct usb_microdia *dev)
11011 {
11012 int ret = 0;
11013 __u16 reg;
11014 __u8 buf[3];
11015
11016 reg = 0x1007;
11017 buf[0] = 0x60;
11018 ret = usb_microdia_control_write(dev, reg, buf, 1);
11019 if (ret < 0)
11020 goto err;
11021
11022 reg = 0x1006;
11023 buf[0] = 0x20;
11024 ret = usb_microdia_control_write(dev, reg, buf, 1);
11025 if (ret < 0)
11026 goto err;
11027
11028 /*
11029 //reg = 0x1007;
11030 //buf[0] = 0x60;
11031 //ret = usb_microdia_control_write(dev, reg, buf, 1);
11032 //if(ret < 0) goto err;
11033
11034 //reg = 0x1006;
11035 //buf[0] = 0x20;
11036 //ret = usb_microdia_control_write(dev, reg, buf, 1);
11037 //if(ret < 0) goto err;
11038 */
11039
11040 reg = 0x1061;
11041 buf[0] = 0x01;
11042 ret = usb_microdia_control_write(dev, reg, buf, 1);
11043 if (ret < 0)
11044 goto err;
11045
11046 /*
11047 //reg = 0x1007;
11048 //buf[0] = 0x60;
11049 //ret = usb_microdia_control_write(dev, reg, buf, 1);
11050 //if(ret < 0) goto err;
11051
11052 //reg = 0x1006;
11053 //buf[0] = 0x20;
11054 //ret = usb_microdia_control_write(dev, reg, buf, 1);
11055 //if(ret < 0) goto err;
11056 */
11057
11058 reg = 0x1000;
11059 buf[0] = 0x38;
11060 ret = usb_microdia_control_write(dev, reg, buf, 1);
11061 if (ret < 0)
11062 goto err;
11063
11064 reg = 0x11b8;
11065 buf[0] = 0x6b;
11066 ret = usb_microdia_control_write(dev, reg, buf, 1);
11067 if (ret < 0)
11068 goto err;
11069
11070 reg = 0x1000;
11071 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
11072 ret = usb_microdia_control_write(dev, reg, buf, 3);
11073 if (ret < 0)
11074 goto err;
11075
11076 reg = 0x1066;
11077 buf[0] = 0x00;
11078 ret = usb_microdia_control_write(dev, reg, buf, 1);
11079 if (ret < 0)
11080 goto err;
11081
11082 return ret;
11083 err:
11084 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
11085 return ret;
11086 }
11087
11088 /**
11089 * @brief From UsbSnoop-plugin-parsed.log
11090 *
11091 * @param dev
11092 *
11093 * @returns 0 (OK) or <0 (Error)
11094 *
11095 * @author Vincent, Kuzja
11096 */
11097 int microdia_6288_stop_stream(struct usb_microdia *dev)
11098 {
11099 int ret = 0;
11100 __u16 reg;
11101 __u8 buf[8];
11102
11103 reg = 0x1061 ;
11104 buf[0] = 0x01;
11105 ret = usb_microdia_control_write(dev, reg, buf, 1);
11106 if (ret < 0)
11107 goto err;
11108
11109 reg = 0x1000 ;
11110 buf[0] = 0x38;
11111 ret = usb_microdia_control_write(dev, reg, buf, 1);
11112 if (ret < 0)
11113 goto err;
11114
11115 reg = 0x11b8 ;
11116 buf[0] = 0xe9;
11117 ret = usb_microdia_control_write(dev, reg, buf, 1);
11118 if (ret < 0)
11119 goto err;
11120
11121 reg = 0x1007 ;
11122 buf[0] = 0x20;
11123 ret = usb_microdia_control_write(dev, reg, buf, 1);
11124 if (ret < 0)
11125 goto err;
11126
11127 reg = 0x1006 ;
11128 buf[0] = 0x20;
11129 ret = usb_microdia_control_write(dev, reg, buf, 1);
11130 if (ret < 0)
11131 goto err;
11132
11133 reg = 0x1000 ;
11134 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
11135 ret = usb_microdia_control_write(dev, reg, buf, 3);
11136 if (ret < 0)
11137 goto err;
11138
11139 reg = 0x1066 ;
11140 buf[0] = 0x00;
11141 ret = usb_microdia_control_write(dev, reg, buf, 1);
11142 if (ret < 0)
11143 goto err;
11144
11145 return 0;
11146 err:
11147 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
11148 return ret;
11149 }
11150
11151 /**
11152 * @brief From UsbSnoop-plugin-parsed.log
11153 *
11154 * @param dev
11155 *
11156 * @returns 0 if all OK
11157 *
11158 * This function stops the video stream for microdia 6128
11159 * Bridge SN9C325 + OM6802 CMOS sensor
11160 * note: comments are my observations so they could be wrong
11161 */
11162 int microdia_6128_stop_stream(struct usb_microdia *dev)
11163 {
11164 int ret = 0;
11165 __u8 data;
11166
11167 ret += usb_microdia_control_read(dev, 0x00, &data, 1);
11168
11169 // Stop stream command
11170 data = 0x00;
11171 ret += usb_microdia_control_write(dev, 0x01, &data, 1);
11172
11173 data = 0x00;
11174 ret += usb_microdia_control_write(dev, 0xf1, &data, 1);
11175
11176 data = 0x01;
11177 ret += usb_microdia_control_write(dev, 0xf1, &data, 1);
11178
11179 if(ret != 4)
11180 UDIA_DEBUG("Some read or write were not successful in Stop Stream\n");
11181
11182 return 0;
11183 }
11184
11185
11186
11187 int microdia_624f_set_exposure(struct usb_microdia *dev)
11188 {
11189 int ret = 0;
11190 __u8 v1 = (dev->vsettings.exposure >> 4) & 0xff;
11191 __u8 v2 = dev->vsettings.exposure >> 12;
11192
11193 ret |= sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, 0x2d,
11194 dev->sensor_flags, &v1);
11195
11196 ret |= sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1, 0x2e,
11197 dev->sensor_flags, &v2);
11198
11199 return ret;
11200 }
11201
11202 int microdia_624f_flip_detect(struct usb_microdia *dev)
11203 {
11204 int ret = 0;
11205 __u8 val;
11206
11207 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
11208 if (ret < 0)
11209 return -EAGAIN;
11210 if (val & 0x01)
11211 dev->vsettings.vflip = 1;
11212 else
11213 dev->vsettings.vflip = 0;
11214 return ret;
11215 }
11216
11217 int microdia_6260_flip_detect(struct usb_microdia *dev)
11218 {
11219 const __u8 flip_bit = 0x01;
11220 int ret = 0;
11221 __u8 val;
11222 static __u8 flip_reg = flip_bit;
11223 __u8 vflip;
11224
11225 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
11226 if (ret < 0)
11227 return -EAGAIN;
11228 if (flip_reg != (val & flip_bit)) {
11229 if (val & flip_bit)
11230 vflip = 0;
11231 else
11232 vflip = 1;
11233 ret = ov7670_auto_flip(dev, vflip);
11234 flip_reg = (val & flip_bit);
11235 }
11236
11237 return ret;
11238 }
Microdia : webcam kernel driver, for USB webcams with vendor id 0c45