?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change 624f to support bayer format
[microdia.git] / microdia-dev.c
blobd05aadaafc12d58745a27e803365ff7f2b1958cd
1 /**
2 * @file microdia-dev.c
3 * @author Nicolas VIVIEN
4 * @date 2008-02-01
5 *
6 * @brief Device specific functions
7 *
8 * @note Copyright (C) Nicolas VIVIEN
9 *
10 * @par Licences
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <stdarg.h>
30
31 #include "microdia.h"
32 #include "sn9c20x.h"
33 #include "ov7670.h"
34 #include "ov965x.h"
35 #include "mt9vx11.h"
36 #include "ov7660.h"
37
38 /**
39 * @brief Set USB-bandwidth to maximum
40 *
41 * @param dev Pointer to device structure
42 *
43 * @returns 0 or negative error value
44 */
45 int dev_microdia_camera_on(struct usb_microdia *dev)
46 {
47 int ret = -1;
48 struct usb_device *udev = dev->udev;
49
50 ret = usb_set_interface(udev, 0, 8);
51
52 if (ret < 0)
53 UDIA_ERROR("usb_set_interface failed !\n");
54
55 return ret;
56 }
57
58 /**
59 * @brief Set USB-bandwidth to minimum
60 *
61 * @param dev Pointer to device structure
62 *
63 * @returns 0 or negative error value
64 */
65 int dev_microdia_camera_off(struct usb_microdia *dev)
66 {
67 int ret = -1;
68 struct usb_device *udev = dev->udev;
69
70 ret = usb_set_interface(udev, 0, 0);
71
72 if (ret < 0)
73 UDIA_ERROR("usb_set_interface failed !\n");
74
75 return 0;
76 }
77
78 /**
79 * @brief Wrapper function for camera-setting functions
80 *
81 * @param dev Pointer to device structure
82 *
83 * @returns 0
84 */
85 int dev_microdia_camera_settings(struct usb_microdia *dev)
86 {
87 dev_microdia_camera_set_contrast(dev);
88 dev_microdia_camera_set_brightness(dev);
89 dev_microdia_camera_set_gamma(dev);
90 dev_microdia_camera_set_exposure(dev);
91 dev_microdia_camera_set_hvflip(dev);
92 dev_microdia_camera_set_sharpness(dev);
93 dev_microdia_camera_set_rgb_gain(dev);
94 dev_microdia_camera_set_auto_exposure(dev);
95 dev_microdia_camera_set_auto_whitebalance(dev);
96 return 0;
97 }
98
99 /**
100 * @brief Wrapper function for device-specific contrast functions
101 *
102 * @param dev Pointer to device structure
103 *
104 * @returns 0 or negative error value
105 *
106 * This will execute a function determined by the array #cameras and
107 * the function find_camera().
108 *
109 */
110 int dev_microdia_camera_set_contrast(struct usb_microdia *dev)
111 {
112 int ret = -ENODEV;
113 if (dev && dev->set_contrast)
114 ret = dev->set_contrast(dev);
115 return ret;
116 }
117
118 /**
119 * @brief Wrapper function for device-specific brightness functions
120 *
121 * @param dev Pointer to device structure
122 *
123 * @returns 0 or negative error value
124 *
125 * This will execute a function determined by the array #cameras and
126 * the function find_camera().
127 *
128 */
129 int dev_microdia_camera_set_brightness(struct usb_microdia *dev)
130 {
131 int ret = -ENODEV;
132 if (dev && dev->set_brightness)
133 ret = dev->set_brightness(dev);
134 return ret;
135 }
136
137 /**
138 * @brief Wrapper function for device-specific gamma functions
139 *
140 * @param dev Pointer to device structure
141 *
142 * @returns 0 or negative error value
143 *
144 * This will execute a function determined by the array #cameras and
145 * the function find_camera().
146 *
147 */
148 int dev_microdia_camera_set_gamma(struct usb_microdia *dev)
149 {
150 int ret = -ENODEV;
151 if (dev && dev->set_gamma)
152 ret = dev->set_gamma(dev);
153 return ret;
154 }
155
156 /**
157 * @brief Wrapper function for device-specific exposure functions
158 *
159 * @param dev Pointer to device structure
160 *
161 * @returns 0 or negative error value
162 *
163 * This will execute a function determined by the array #cameras and
164 * the function find_camera().
165 *
166 */
167 int dev_microdia_camera_set_exposure(struct usb_microdia *dev)
168 {
169 if (dev->set_exposure != NULL)
170 return dev->set_exposure(dev);
171
172 return 0;
173 }
174
175 /**
176 * @brief Wrapper function for device-specific hvflip functions
177 *
178 * @param dev Pointer to device structure
179 *
180 * @returns 0 or negative error value
181 *
182 * This will execute a function determined by the array #cameras and
183 * the function find_camera().
184 *
185 */
186 int dev_microdia_camera_set_hvflip(struct usb_microdia *dev)
187 {
188 int ret = -ENODEV;
189 if (dev && dev->set_hvflip)
190 ret = dev->set_hvflip(dev);
191
192 return ret;
193 }
194
195 /**
196 * @brief Wrapper function for device-specific sharpness functions
197 *
198 * @param dev Pointer to device structure
199 *
200 * @returns 0 or negative error value
201 *
202 * This will execute a function determined by the array #cameras and
203 * the function find_camera().
204 *
205 */
206 int dev_microdia_camera_set_sharpness(struct usb_microdia *dev)
207 {
208 int ret = -ENODEV;
209 if (dev && dev->set_sharpness)
210 ret = dev->set_sharpness(dev);
211
212 return ret;
213 }
214
215 /**
216 * @brief Wrapper function for device-specific rgb-gain functions
217 *
218 * @param dev Pointer to device structure
219 *
220 * @returns 0 or negative error value
221 *
222 * This will execute a function determined by the array #cameras and
223 * the function find_camera().
224 *
225 */
226 int dev_microdia_camera_set_rgb_gain(struct usb_microdia *dev)
227 {
228 int ret = -ENODEV;
229 if (dev && dev->set_rgb_gain)
230 ret = dev->set_rgb_gain(dev);
231
232 return ret;
233 }
234
235 /**
236 * @brief Wrapper function for device-specific auto-exposure functions
237 *
238 * @param dev Pointer to device structure
239 *
240 * @returns 0 or negative error value
241 *
242 * This will execute a function determined by the array #cameras and
243 * the function find_camera().
244 *
245 */
246 int dev_microdia_camera_set_auto_exposure(struct usb_microdia *dev)
247 {
248 int ret = -ENODEV;
249 if (dev && dev->set_auto_exposure)
250 ret = dev->set_auto_exposure(dev);
251
252 return ret;
253 }
254
255 /**
256 * @brief Wrapper function for device-specific auto-whitebalance functions
257 *
258 * @param dev Pointer to device structure
259 *
260 * @returns 0 or negative error value
261 *
262 * This will execute a function determined by the array #cameras and
263 * the function find_camera().
264 *
265 */
266 int dev_microdia_camera_set_auto_whitebalance(struct usb_microdia *dev)
267 {
268 int ret = -ENODEV;
269 if (dev && dev->set_auto_whitebalance)
270 ret = dev->set_auto_whitebalance(dev);
271
272 return ret;
273 }
274
275
276 /**
277 * @brief Wrapper function for device-specific initialization functions
278 *
279 * @param dev Pointer to device structure
280 *
281 * @returns 0 or negative error value
282 *
283 * This will execute a function determined by the array #cameras and
284 * the function find_camera().
285 *
286 */
287 int dev_microdia_initialize_device(struct usb_microdia *dev)
288 {
289 int ret = -ENODEV;
290
291 if (dev && dev->initialize)
292 ret = dev->initialize(dev);
293
294 return ret;
295 }
296
297 /**
298 * @brief From init-physical-replug.log
299 *
300 * @param dev
301 *
302 * @returns 0
303 *
304 * @author psnel
305 *
306 * For SN9C201 with MI1300.
307 *
308 */
309 int microdia_6240_initialize(struct usb_microdia *dev)
310 {
311 return 0;
312 }
313
314 /**
315 * @brief From start.log (14 jun 2008)
316 *
317 * @param dev
318 *
319 * @returns 0
320 *
321 * @author psnel
322 *
323 * For SN9C201 with MI1300.
324 *
325 */
326 int microdia_6240_start_stream(struct usb_microdia *dev)
327 {
328 int ret = 0;
329 int i;
330 __u16 reg;
331 __u8 value[1];
332
333 /* Setup the bridge registers */
334 static __u16 bridge6240_init[][2] = {
335 {0x0395, 0x05},
336 {0x1000, 0x7c},
337 {0x1001, 0x44},
338 {0x1002, 0x1c},
339 {0x1006, 0x80},
340 {0x1007, 0xa0},
341 {0x1020, 0x80},
342 {0x1061, 0x03},
343 {0x1066, 0x01},
344 {0x1067, 0x40},
345 {0x1068, 0x30},
346 {0x1069, 0x20},
347 {0x106a, 0x10},
348 {0x106b, 0x08},
349 {0x1070, 0x10},
350 {0x1071, 0x08},
351 {0x10e0, 0x07},
352 {0x10f5, 0x60},
353 {0x10f7, 0x07},
354 {0x10f8, 0x14},
355 {0x10f9, 0x00},
356 {0x10fa, 0xff},
357 {0x1100, 0x0d},
358 {0x1101, 0x08},
359 {0x1102, 0x08},
360 {0x1103, 0x0d},
361 {0x1104, 0x08},
362 {0x1105, 0x08},
363 {0x1106, 0x0d},
364 {0x1107, 0x0d},
365 {0x1108, 0x0d},
366 {0x1109, 0x0d},
367 {0x110a, 0x11},
368 {0x110b, 0x0d},
369 {0x110c, 0x0d},
370 {0x110d, 0x11},
371 {0x110e, 0x15},
372 {0x110f, 0x21},
373 {0x1110, 0x15},
374 {0x1111, 0x15},
375 {0x1112, 0x11},
376 {0x1113, 0x11},
377 {0x1114, 0x15},
378 {0x1115, 0x2a},
379 {0x1116, 0x1d},
380 {0x1117, 0x1d},
381 {0x1118, 0x19},
382 {0x1119, 0x21},
383 {0x111a, 0x32},
384 {0x111b, 0x2a},
385 {0x111c, 0x32},
386 {0x111d, 0x32},
387 {0x111e, 0x2e},
388 {0x111f, 0x2a},
389 {0x1120, 0x2e},
390 {0x1121, 0x2e},
391 {0x1122, 0x36},
392 {0x1123, 0x3a},
393 {0x1124, 0x4b},
394 {0x1125, 0x43},
395 {0x1126, 0x36},
396 {0x1127, 0x3a},
397 {0x1128, 0x47},
398 {0x1129, 0x3a},
399 {0x112b, 0x2e},
400 {0x112c, 0x43},
401 {0x112d, 0x5c},
402 {0x112e, 0x43},
403 {0x112f, 0x47},
404 {0x1130, 0x4f},
405 {0x1131, 0x54},
406 {0x1132, 0x58},
407 {0x1133, 0x58},
408 {0x1134, 0x58},
409 {0x1135, 0x32},
410 {0x1136, 0x3f},
411 {0x1137, 0x60},
412 {0x1138, 0x64},
413 {0x1139, 0x5c},
414 {0x113a, 0x54},
415 {0x113b, 0x64},
416 {0x113c, 0x4b},
417 {0x113d, 0x54},
418 {0x113e, 0x58},
419 {0x113f, 0x54},
420 {0x1140, 0x0d},
421 {0x1141, 0x11},
422 {0x1142, 0x11},
423 {0x1143, 0x15},
424 {0x1144, 0x11},
425 {0x1145, 0x15},
426 {0x1146, 0x26},
427 {0x1147, 0x15},
428 {0x1148, 0x15},
429 {0x1149, 0x26},
430 {0x114a, 0x54},
431 {0x114b, 0x36},
432 {0x114c, 0x2e},
433 {0x114d, 0x36},
434 {0x114e, 0x54},
435 {0x114f, 0x54},
436 {0x1150, 0x54},
437 {0x1151, 0x54},
438 {0x1152, 0x54},
439 {0x1153, 0x54},
440 {0x1154, 0x54},
441 {0x1155, 0x54},
442 {0x1156, 0x54},
443 {0x1157, 0x54},
444 {0x1158, 0x54},
445 {0x1159, 0x54},
446 {0x115a, 0x54},
447 {0x115b, 0x54},
448 {0x115c, 0x54},
449 {0x115d, 0x54},
450 {0x115e, 0x54},
451 {0x115f, 0x54},
452 {0x1160, 0x54},
453 {0x1161, 0x54},
454 {0x1162, 0x54},
455 {0x1163, 0x54},
456 {0x1164, 0x54},
457 {0x1165, 0x54},
458 {0x1166, 0x54},
459 {0x1167, 0x54},
460 {0x1168, 0x54},
461 {0x1169, 0x54},
462 {0x116a, 0x54},
463 {0x116b, 0x54},
464 {0x116c, 0x54},
465 {0x116d, 0x54},
466 {0x116e, 0x54},
467 {0x116f, 0x54},
468 {0x1170, 0x54},
469 {0x1171, 0x54},
470 {0x1172, 0x54},
471 {0x1173, 0x54},
472 {0x1174, 0x54},
473 {0x1175, 0x54},
474 {0x1176, 0x54},
475 {0x1177, 0x54},
476 {0x1178, 0x54},
477 {0x1179, 0x54},
478 {0x117a, 0x54},
479 {0x117b, 0x54},
480 {0x117c, 0x54},
481 {0x117d, 0x54},
482 {0x117e, 0x54},
483 {0x117f, 0x54},
484 {0x1180, 0x02},
485 {0x1181, 0x00},
486 {0x1182, 0x02},
487 {0x1183, 0x00},
488 {0x1184, 0x28},
489 {0x1185, 0x3c},
490 {0x1188, 0x06},
491 {0x118a, 0x05},
492 {0x118b, 0x0a},
493 {0x118c, 0x20},
494 {0x118d, 0x20},
495 {0x118e, 0x20},
496 {0x118f, 0x20},
497 {0x1190, 0x00},
498 {0x1191, 0x24},
499 {0x1192, 0x3b},
500 {0x1193, 0x4f},
501 {0x1194, 0x61},
502 {0x1195, 0x71},
503 {0x1196, 0x80},
504 {0x1197, 0x8f},
505 {0x1198, 0x9d},
506 {0x1199, 0xab},
507 {0x119a, 0xab},
508 {0x119b, 0xb8},
509 {0x119c, 0xc4},
510 {0x119d, 0xd1},
511 {0x119e, 0xdd},
512 {0x119f, 0xe9},
513 {0x11a0, 0xff},
514 {0x11a1, 0x00},
515 {0x11a2, 0x00},
516 {0x11a3, 0x6a},
517 {0x11a4, 0x50},
518 {0x11a5, 0x2d},
519 {0x11a6, 0x2d},
520 {0x11a7, 0x3a},
521 {0x11a8, 0x05},
522 {0x11a9, 0x04},
523 {0x11aa, 0x3f},
524 {0x11ab, 0x00},
525 {0x11ac, 0x00},
526 {0x11ad, 0x50},
527 {0x11ae, 0x3c},
528 {0x11af, 0x28},
529 {0x11b0, 0xd8},
530 {0x11b1, 0x14},
531 {0x11b2, 0xec},
532 {0x11b3, 0x32},
533 {0x11b4, 0xdd},
534 {0x11b5, 0x2d},
535 {0x11b6, 0xdd},
536 {0x11b7, 0x60},
537 {0x11b8, 0x78},
538 {0x11b9, 0x00},
539 {0x11ba, 0x0b},
540 {0x11bb, 0x00},
541 {0x11bc, 0x00},
542 {0x11bd, 0x00},
543 {0x11be, 0x00},
544 {0x11bf, 0x00},
545 {0x11c0, 0x00},
546 {0x11c1, 0x00},
547 {0x11c2, 0x00},
548 {0x11c3, 0x00},
549 {0x11c4, 0x00},
550 {0x11c5, 0x00},
551 {0x11c6, 0x00},
552 {0x11c7, 0x00},
553 {0x11c8, 0x00},
554 {0x11c9, 0x00},
555 {0x11ca, 0x00},
556 {0x11cb, 0x00},
557 {0x11cc, 0x00},
558 {0x11cd, 0x00},
559 {0x11ce, 0x00},
560 {0x11cf, 0x00},
561 {0x11d0, 0x00},
562 {0x11d1, 0x00},
563 {0x11d2, 0x00},
564 {0x11d3, 0x00},
565 {0x11d4, 0x00},
566 {0x11d5, 0x00},
567 {0x11d6, 0x00},
568 {0x11d7, 0x00},
569 {0x11d8, 0x00},
570 {0x11d9, 0x00},
571 {0x11da, 0x00},
572 {0x11db, 0x00},
573 {0x11dc, 0x00},
574 {0x11dd, 0x00},
575 {0x11de, 0x00},
576 {0x11df, 0x00},
577 {0x11e0, 0x0b},
578 {0x11e1, 0x00},
579 {0x11e2, 0x00},
580 {0x11e3, 0x00},
581 {0x11e4, 0x00},
582 {0x11e5, 0x00},
583 {0x11e6, 0x00},
584 {0x11e7, 0x00},
585 {0x11e8, 0x00},
586 {0x11e9, 0x00},
587 {0x11ea, 0x00},
588 {0x11eb, 0x00},
589 {0x11ec, 0x00},
590 {0x11ed, 0x00},
591 {0x11ee, 0x00},
592 {0x11ef, 0x00},
593 {0x11fb, 0x00},
594 {0x11fc, 0xa0},
595 {0x11fd, 0x00},
596 {0x11fe, 0xf0},
597 {0x11ff, 0x00},
598 {0x1200, 0xf4},
599 {0x1201, 0xff},
600 };
601
602 static __u8 mi1300_init[][2] = {
603 {0x00, 0x00},
604 {0x01, 0x00},
605 {0x02, 0x0e},
606 {0x03, 0x03},
607 {0x04, 0xc1},
608 {0x05, 0x00},
609 {0x06, 0x13},
610 {0x07, 0xf2},
611 {0x08, 0x02},
612 {0x09, 0x00},
613 {0x0a, 0x00},
614 {0x0b, 0x00},
615 {0x0c, 0x00},
616 {0x0d, 0x00},
617 {0x0e, 0x00},
618 {0x11, 0x00},
619 {0x12, 0x00},
620 {0x1e, 0x80},
621 {0x1f, 0x00},
622 {0x20, 0x11},
623 {0x21, 0x1d},
624 {0x2b, 0x00},
625 {0x2c, 0x00},
626 {0x2d, 0x1d},
627 {0x2e, 0x00},
628 {0x2f, 0x1d},
629 {0x30, 0x10},
630 {0x5f, 0x89},
631 {0x60, 0x00},
632 {0x61, 0x00},
633 {0x62, 0x00},
634 {0x63, 0x98},
635 {0x64, 0x00},
636 {0x65, 0x00},
637 {0x68, 0x00},
638 {0x69, 0x00},
639 };
640
641 /* initialize SN9C201 for 6240 */
642 for (i = 0; i < ARRAY_SIZE(bridge6240_init); i++) {
643 reg = bridge6240_init[i][0];
644 value[0] = bridge6240_init[i][1];
645 ret = usb_microdia_control_write(dev, reg, value, 1);
646 if (ret < 0) {
647 UDIA_INFO("6240 Bridge: Inititialization Error (%d) on array line %d\n", ret, i);
648 break;
649 }
650 }
651
652 /* initialize the Bridge to I2C interface */
653 ret = sn9c20x_i2c_initialize(dev);
654
655 /* initialize the Sensor MI 1300 */
656 for (i = 0; i < ARRAY_SIZE(mi1300_init); i++) {
657 reg = mi1300_init[i][0];
658 value[0] = mi1300_init[i][1];
659 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
660 reg, dev->sensor_flags, value);
661 if (ret < 0) {
662 UDIA_INFO("Sensor MI 1300: Inititialization Error (%d) on array line %d\n", ret, i);
663 break;
664 }
665 }
666
667 UDIA_INFO("...start function completed without errors.\n");
668 return ret;
669 }
670
671 /**
672 * @brief From stop-close-amcap.log
673 *
674 * @param dev
675 *
676 * @returns 0
677 *
678 * @author psnel
679 *
680 * For SN9C201 with MI1300. Comments from parser-usbsnoop(updated_13Mar2008).pl output
681 *
682 */
683 int microdia_6240_stop_stream(struct usb_microdia *dev)
684 {
685 int ret = 0;
686 int i;
687 __u16 reg;
688 __u8 value[1];
689
690 static __u8 mi1300_stop[][2] = {
691 {0x07, 0x00},
692 {0x08, 0x00},
693 };
694
695 static __u16 bridge6240_stop[][2] = {
696 {0x1061, 0x01},
697 {0x1000, 0x3c},
698 {0x11b8, 0x68},
699 {0x1007, 0xa0},
700 {0x1006, 0xa0},
701 {0x1000, 0x98},
702 {0x1001, 0xef},
703 {0x1002, 0x11},
704 {0x1066, 0x00},
705 };
706
707 UDIA_INFO("Stopping camera...\n");
708
709 for (i = 0; i < ARRAY_SIZE(mi1300_stop); i++) {
710 reg = mi1300_stop[i][0];
711 value[0] = mi1300_stop[i][1];
712 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
713 reg, dev->sensor_flags, value);
714 if (ret < 0) {
715 UDIA_INFO("Sensor MI 1300: Stop Sequence Error (%d) on array line %d\n", ret, i);
716 break;
717 }
718 }
719
720 for (i = 0; i < ARRAY_SIZE(bridge6240_stop); i++) {
721 reg = bridge6240_stop[i][0];
722 value[0] = bridge6240_stop[i][1];
723 ret = usb_microdia_control_write(dev, reg, value, 1);
724 if (ret < 0) {
725 UDIA_INFO("6240 Bridge: Stop Sequence Error (%d) on array line %d\n", ret, i);
726 break;
727 }
728 }
729
730 return 0;
731 }
732
733 /**
734 * @brief From init.sequence.log
735 *
736 * @param dev
737 *
738 * @returns 0
739 *
740 * @author GWater
741 *
742 * For SN9C201 with SOI968.
743 * Tests showed this function is actually unnecessary.
744 * Nevertheless the reads may give us valuable values we don't know about yet.
745 */
746 int microdia_624e_initialize(struct usb_microdia *dev)
747 {
748 __u8 buf;
749
750 usb_microdia_control_read(dev, 0x130d, &buf, 1);
751 usb_microdia_control_read(dev, 0x1040, &buf, 1);
752
753 return 0;
754 }
755
756 /**
757 * @brief From UsbSnoop-plugin-parsed.log
758 *
759 * @param dev
760 *
761 * @returns
762 */
763 int microdia_624f_initialize(struct usb_microdia *dev)
764 {
765 /* Do nothing here */
766 return 0;
767 }
768
769 /**
770 * @brief From UsbSnoop-plugin-parsed.log
771 *
772 * @param dev
773 *
774 * @returns
775 */
776 int microdia_6260_initialize(struct usb_microdia *dev)
777 {
778 int ret = 0;
779 int i;
780 __u16 reg;
781 __u8 value[1];
782
783 static __u16 bridge6260_init[][2] = {
784 {0x10c8, 0x00},
785 {0x100a, 0x04},
786 {0x100b, 0x04},
787 {0x1001, 0xc7},
788 {0x1040, 0x00},
789 {0x1045, 0x04},
790 {0x1046, 0x10},
791 {0x1045, 0x14},
792 {0x1040, 0x01},
793 {0x1020, 0x80},
794 };
795
796 for (i = 0; i < ARRAY_SIZE(bridge6260_init); i++) {
797 reg = bridge6260_init[i][0];
798 value[0] = bridge6260_init[i][1];
799 ret = usb_microdia_control_write(dev, reg, value, 1);
800 if (ret < 0) {
801 UDIA_INFO("6260 Bridge: Init Sequence Error (%d) on array line %d\n", ret, i);
802 break;
803 }
804 }
805
806 return 0;
807 }
808
809 /**
810 * @brief From 6 init-logs
811 *
812 * @param dev
813 *
814 * @returns 0 (ok) or -1 (error)
815 *
816 * @author Comer352l
817 *
818 * Windows driver versions: 5.5.8.12 and 5.7.23.000
819 * Windows versions: 2000 and XP
820 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
821 *
822 * Comments behind read oprations contain HEX-values that appeared in the logs
823 */
824 int microdia_6270_initialize(struct usb_microdia *dev)
825 {
826 /* int actual; */
827 int ret = 0;
828 int retSP = 0;
829 int retASS = 0;
830 __u8 buf[8];
831 __u8 buf_0395[1];
832 __u8 buf_1000[5];
833 __u8 buf_1060[2];
834 __u8 buf_11b8[1];
835
836 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81,0x85,0x04,0x8b,0x02,... */
837
838 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4,0xc4,0xa4,0x44,... */
839
840 /*
841 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
842 * buf[0]=0x00;
843 * usb_microdia_control_write(dev, 0x10c8, buf, 1);
844 */
845
846 ret += usb_microdia_control_read(dev, 0x118a, buf, 1); /* URB 7 0x05,0x7b,0x01,0x04,... */
847
848 ret += usb_microdia_control_read(dev, 0x0395, buf_0395, 1); /* URB 8 0xc2,0x82,0x38,0x98,0x04,... */
849 /* => this value will be rewritten to 0x118a and 0x0395 later (URBs 81+82) */
850
851 buf[0] = 0x05;
852 ret += usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 9 */
853
854 ret += usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 10 */
855
856 ret += usb_microdia_control_read(dev, 0x11b8, buf_11b8, 1); /* URB 11 0xa0,0x00,0x24,... */
857 /* => this value will be rewritten to 0x11b8 later (URB 83) */
858
859 buf[0] = 0x10;
860 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 12 */
861
862 ret += usb_microdia_control_read(dev, 0x1000, buf_1000, 5); /* URB 13 0x30 0xCF 0x00 0x03 (0x02 or 0x00) */
863 /* => these values will be rewritten to 0x1000 later (URB 84) */
864
865 buf[0] = 0x70; buf[1] = 0x00; buf[2] = 0x18; buf[3] = 0x00; buf[4] = 0x00;
866 ret += usb_microdia_control_write(dev, 0x1000, buf, 5); /* URB 14 */
867
868 ret += usb_microdia_control_read(dev, 0x1060, buf_1060, 2); /* URB 15 0x08 0x00 (always ???) */
869 /* => this value will be rewritten to 0x1060 later (URB 85) */
870
871 buf[0] = 0x00; buf[1] = 0x03;
872 ret += usb_microdia_control_write(dev, 0x1060, buf, 2); /* URB 16 */
873
874 /* initialize I2C registers to avoid getting no ACK at first I2C operation: */
875 ret += sn9c20x_i2c_initialize(dev);
876
877 /* enable I2C communication (bit 0) */
878 buf[0] = 0x21; /* THE OLD DRIVER 5.5.8.12 WRITES 0x5d */
879 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 17 */
880
881 /* probe sensor model: */
882 retSP = mt9vx11_sensor_probe(dev); /* substitutes URBs 18-48 */
883 if ((retSP == 0) && (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS))
884 /* switch (back) to IFP address space: */
885 retASS = mt9v111_select_address_space(dev, MT9V111_ADDRESSSPACE_IFP);
886
887 ret += usb_microdia_control_write(dev, 0x118a, buf_0395, 1); /* URB 81 => write value read with URB 8 */
888
889 ret += usb_microdia_control_write(dev, 0x0395, buf_0395, 1); /* URB 82 => write value read with URB 8 */
890
891 ret += usb_microdia_control_write(dev, 0x11b8, buf_11b8, 1); /* URB 83 => write value read with URB 11 */
892
893 ret += usb_microdia_control_write(dev, 0x1000, buf_1000, 5); /* URB 84 => write value read with URB 13 */
894
895 ret += usb_microdia_control_write(dev, 0x1060, buf_1060, 2); /* URB 85 => write value read with URB 15; (always 08 00 ???) */
896
897 /* USB-interrupt-message: doesn't work yet (returns error -110) */
898 /* 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 */
899
900 /*
901 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
902 * wbuf[0]=0x80;
903 * usb_microdia_control_write(dev, 0x1020, wbuf, 1);
904 */
905
906 if ((retSP != 0) || (retASS != 0) || (ret < 33)) {
907 if (ret < 33)
908 UDIA_INFO("One ore more errors occured during initialization !\n");
909 return -1;
910 } else {
911 return 0;
912 }
913 }
914
915
916 /**
917 * @brief From UsbSnoop-plugin-parsed.log
918 *
919 * @param dev
920 *
921 * @returns
922 */
923 int microdia_627b_initialize(struct usb_microdia *dev)
924 {
925 /* Apparently we don't need to write anything here */
926 return 0;
927 }
928
929 /**
930 * @brief From init-start-stop-log (made by Víctor M. Hernández Rocamora)
931 *
932 * @param dev
933 *
934 * @returns 0 (ok) or -1 (error)
935 *
936 * @author Comer352l
937 *
938 * USB-Logger: SniffUSB 2.0
939 *
940 * Comments behind read oprations contain HEX-values that appeared in the log
941 */
942 int microdia_627f_initialize(struct usb_microdia *dev)
943 {
944 __u8 buf[1];
945 int ret = 0;
946
947 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81 */
948
949 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4 */
950
951 buf[0] = 0x00;
952 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 7 */
953
954 buf[0] = 0x80;
955 ret += usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 8 */
956
957 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 9 0x0f */
958
959 buf[0] = 0x1f;
960 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 10 */
961
962 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 11 0x1f */
963
964 buf[0] = 0x0f;
965 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 12 */
966
967 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 13 0x0f */
968
969 buf[0] = 0x1f;
970 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 14 */
971
972 if (ret < 10) {
973 UDIA_INFO("One ore more errors occured during initialization !\n");
974 return -1;
975 }
976 return 0;
977 }
978
979 /**
980 * @brief From UsbSnoop-plugin-parsed.log
981 *
982 * @param dev
983 *
984 * @returns 0 (OK) or <0 (Error)
985 *
986 * @author Vincent, Kuzja
987 */
988 int microdia_6288_initialize(struct usb_microdia *dev)
989 {
990
991 int ret;
992 __u16 reg;
993 __u8 buf[2];
994
995 reg = 0x130d ;
996 ret = usb_microdia_control_read(dev, reg, buf, 1);
997 if (ret < 0)
998 goto err;
999
1000 reg = 0x1040 ;
1001 ret = usb_microdia_control_read(dev, reg, buf, 1);
1002 if (ret < 0)
1003 goto err;
1004
1005 if (ret < 0)
1006 return ret;
1007 else
1008 return 0;
1009 err:
1010 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
1011 return ret;
1012 }
1013
1014 /**
1015 * @brief Wrapper function for device-specific startstream functions
1016 *
1017 * @param dev Pointer to device structure
1018 *
1019 * @returns 0
1020 *
1021 * This will execute a function determined by the array #cameras and
1022 * the function find_camera().
1023 *
1024 */
1025 int dev_microdia_start_stream(struct usb_microdia *dev)
1026 {
1027 int ret = -ENODEV;
1028 if (dev && dev->start_stream)
1029 ret = dev->start_stream(dev);
1030
1031 return ret;
1032 }
1033
1034 /**
1035 * @brief From start.htm
1036 *
1037 * @param dev
1038 *
1039 * @returns 0
1040 *
1041 * @author GWater
1042 *
1043 * For SN9C201 with MI1310.
1044 */
1045 int microdia_6242_start_stream(struct usb_microdia *dev)
1046 {
1047 int i = -1;
1048 __u8 buf[48];
1049
1050 __u8 urb10[24] = {
1051 0x01, 0x18, 0x00, 0x30, 0x00, 0x09, 0x00, 0xed,
1052 0x0f, 0xda, 0x0f, 0x3a, 0x00, 0x3a, 0x00, 0xd0,
1053 0x0f, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x60, 0x0a};
1054
1055 __u8 urb13[11] = {
1056 0x02, 0x00, 0x02, 0x00, 0x50, 0x78, 0x00, 0x00,
1057 0x07};
1058
1059 __u8 urb14[22] = {
1060 0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x24, 0x3b,
1061 0x4f, 0x61, 0x71, 0x80, 0x8f, 0x9d, 0xab, 0xb8,
1062 0xc4, 0xd1, 0xdd, 0xe9, 0xf4, 0xff};
1063
1064 __u8 qtable1[64] = {
1065 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
1066 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
1067 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
1068 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
1069 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
1070 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
1071 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
1072 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54};
1073
1074 __u8 qtable2[64] = {
1075 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
1076 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
1077 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1078 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1079 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1080 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1081 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1082 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54};
1083
1084 __u8 first10c0[7][3] = {
1085 {0x0d, 0x00, 0x08},
1086 {0x0d, 0x00, 0x09},
1087 {0x0d, 0x00, 0x08},
1088 {0xf0, 0x00, 0x01},
1089 {0x3a, 0x73, 0x00},
1090 {0x06, 0x30, 0x8c},
1091 {0xf0, 0x00, 0x00}
1092 };
1093
1094 __u8 second10c0a[2][5] = {
1095 {0x01, 0x00, 0x0e, 0x00, 0x14},
1096 {0x03, 0x03, 0xc4, 0x05, 0x14}
1097 };
1098
1099 __u8 second10c0b[3] =
1100 {0xc8, 0x00, 0x03};
1101
1102 __u8 third10c0[4][3] = {
1103 {0x0a, 0x00, 0x01},
1104 {0x06, 0x00, 0x29},
1105 {0x05, 0x00, 0x72},
1106 {0x20, 0x00, 0x00}
1107 };
1108
1109 __u8 fourth10c0a[3][3] = {
1110 {0x20, 0x00, 0x00},
1111 {0x09, 0x01, 0x90},
1112 {0x0d, 0x80, 0x08}
1113 };
1114
1115 __u8 fourth10c0b[2][5] = {
1116 {0x2b, 0x01, 0x88, 0x01, 0x88},
1117 {0x2d, 0x01, 0x88, 0x01, 0x88}
1118 };
1119
1120 __u8 fifth10c0[4][3] = {
1121 {0x0a, 0x00, 0x01},
1122 {0x06, 0x00, 0x29},
1123 {0x05, 0x00, 0x72}
1124 };
1125
1126 /* interrupt down */
1127
1128 buf[0] = 0x00;
1129 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1 */
1130
1131 /* interrupt up */
1132 /* interrupt down */
1133
1134 buf[0] = 0x60;
1135 usb_microdia_control_write(dev, 0x1007, buf, 1);
1136
1137 buf[0] = 0x00;
1138 usb_microdia_control_write(dev, 0x1006, buf, 1);
1139
1140 buf[0] = 0x78;
1141 usb_microdia_control_write(dev, 0x1000, buf, 1);
1142
1143 buf[0] = 0xc7;
1144 usb_microdia_control_write(dev, 0x1001, buf, 1);
1145
1146 buf[0] = 0x1c;
1147 usb_microdia_control_write(dev, 0x1002, buf, 1);
1148
1149 buf[0] = 0x01;
1150 usb_microdia_control_write(dev, 0x1061, buf, 1);
1151
1152 buf[0] = 0x80;
1153 usb_microdia_control_write(dev, 0x1020, buf, 1);
1154
1155 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
1156 buf[3] = 0x10; buf[4] = 0x08;
1157 usb_microdia_control_write(dev, 0x1067, buf, 5);
1158
1159 buf[0] = 0xb0; buf[1] = dev->sensor_slave_address; buf[2] = 0x0d;
1160 buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00;
1161 buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03;
1162 usb_microdia_control_write(dev, 0x10c0, buf, 9);
1163
1164 usb_microdia_control_write(dev, 0x10e0, urb10, 24); /* URB 10 */
1165
1166 buf[0] = 0x00; buf[1] = 0x00; buf[3] = 0x00;
1167 usb_microdia_control_write(dev, 0x10f8, buf, 3);
1168
1169 usb_microdia_control_write(dev, 0x1180, urb13, 9);
1170
1171 buf[0] = 0x0a;
1172 usb_microdia_control_write(dev, 0x118a, buf, 1);
1173
1174 usb_microdia_control_write(dev, 0x118b, urb14, 22);
1175
1176 buf[0] = 0x00; buf[1] = 0x00;
1177 usb_microdia_control_write(dev, 0x11a1, buf, 2);
1178
1179 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00;
1180 buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00;
1181 buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00;
1182 usb_microdia_control_write(dev, 0x11b7, buf, 9);
1183
1184 buf[0] = 0x30;
1185 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1186
1187 buf[0] = 0x78;
1188 usb_microdia_control_write(dev, 0x1000, buf, 1);
1189
1190 for (i = 0; i < 7; i++)
1191 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1192 first10c0[i][0], dev->sensor_flags, &first10c0[i][1]); /* URB 9-48 */
1193
1194 buf[0] = 0x60;
1195 usb_microdia_control_write(dev, 0x1007, buf, 1);
1196
1197 buf[0] = 0x00;
1198 usb_microdia_control_write(dev, 0x1006, buf, 1);
1199
1200 buf[0] = 0x03;
1201 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 50 */
1202
1203 buf[0] = 0x03;
1204 usb_microdia_control_write(dev, 0x10e0, buf, 1);
1205
1206 buf[0] = 0xc6;
1207 usb_microdia_control_write(dev, 0x1001, buf, 1);
1208
1209 buf[0] = 0xc4;
1210 usb_microdia_control_write(dev, 0x1001, buf, 1);
1211
1212 buf[0] = 0x44;
1213 usb_microdia_control_write(dev, 0x1001, buf, 1);
1214
1215 buf[0] = 0x00;
1216 usb_microdia_control_write(dev, 0x11bc, buf, 1);
1217
1218 buf[0] = 0x00;
1219 usb_microdia_control_write(dev, 0x11bd, buf, 1);
1220
1221 buf[0] = 0x00;
1222 usb_microdia_control_write(dev, 0x11be, buf, 1);
1223
1224 buf[0] = 0x00;
1225 usb_microdia_control_write(dev, 0x11bf, buf, 1);
1226
1227 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
1228 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
1229
1230 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
1231 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
1232
1233 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
1234 0x09, dev->sensor_flags, NULL);
1235
1236 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1237 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
1238
1239 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
1240 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
1241 usb_microdia_control_write(dev, 0x1180, buf, 6);
1242
1243 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
1244 usb_microdia_control_write(dev, 0x11a1, buf, 4);
1245
1246 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
1247 usb_microdia_control_write(dev, 0x11ab, buf, 4);
1248
1249 buf[0] = 0x78;
1250 usb_microdia_control_write(dev, 0x1000, buf, 1);
1251
1252 buf[0] = 0x18;
1253 usb_microdia_control_write(dev, 0x1002, buf, 1);
1254
1255 buf[0] = 0x18;
1256 usb_microdia_control_write(dev, 0x1002, buf, 1);
1257
1258 buf[0] = 0x38;
1259 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1260
1261 buf[0] = 0x02;
1262 usb_microdia_control_write(dev, 0x118a, buf, 1);
1263
1264 buf[0] = 0x02;
1265 usb_microdia_control_write(dev, 0x0395, buf, 1);
1266
1267 buf[0] = 0x78;
1268 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 80 */
1269 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1270
1271 buf[0] = 0xf9;
1272 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1273 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1274
1275 buf[0] = 0xfa;
1276 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1277 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1278
1279 buf[0] = 0x7b;
1280 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1281 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1282
1283 buf[0] = 0x7c;
1284 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1285 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1286
1287 buf[0] = 0x7b;
1288 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 90 */
1289
1290 for (i = 0; i < 4; i++)
1291 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1292 third10c0[i][0], dev->sensor_flags, &third10c0[i][1]); /* URB 97-106 */
1293
1294 buf[0] = 0x06;
1295 usb_microdia_control_write(dev, 0x1180, buf, 1);
1296
1297 for (i = 0; i < 3; i++)
1298 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1299 fourth10c0a[i][0], dev->sensor_flags, &fourth10c0a[i][1]);
1300
1301 for (i = 0; i < 2; i++)
1302 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
1303 fourth10c0b[i][0], dev->sensor_flags, &fourth10c0b[i][1]);
1304
1305 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
1306 0x33, dev->sensor_flags, NULL);
1307
1308 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1309 first10c0[0][0], dev->sensor_flags, &first10c0[0][1]);
1310
1311 buf[0] = 0x0a;
1312 usb_microdia_control_write(dev, 0x11ba, buf, 1);
1313
1314 buf[0] = 0x10;
1315 usb_microdia_control_write(dev, 0x118b, buf, 1);
1316
1317 buf[0] = 0x05;
1318 usb_microdia_control_write(dev, 0x10f7, buf, 1);
1319
1320 buf[0] = 0x14;
1321 usb_microdia_control_write(dev, 0x10f8, buf, 1);
1322
1323 buf[0] = 0xff;
1324 usb_microdia_control_write(dev, 0x10fa, buf, 1);
1325
1326 buf[0] = 0x00;
1327 usb_microdia_control_write(dev, 0x10f9, buf, 1);
1328
1329 buf[0] = 0x00;
1330 usb_microdia_control_write(dev, 0x10f9, buf, 1);
1331
1332 buf[0] = 0x0a;
1333 usb_microdia_control_write(dev, 0x11ba, buf, 1);
1334
1335 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
1336 usb_microdia_control_write(dev, 0x11bc, buf, 4);
1337
1338 /* Set whole array buf to 0x00 */
1339 memset(buf, 0x00, 48);
1340 usb_microdia_control_write(dev, 0x11c0, buf, 48);
1341
1342 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a;
1343 buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
1344 usb_microdia_control_write(dev, 0x11a5, buf, 6);
1345
1346 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
1347 usb_microdia_control_write(dev, 0x11af, buf, 4);
1348
1349 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
1350 usb_microdia_control_write(dev, 0x11b3, buf, 4);
1351
1352 buf[0] = 0x07;
1353 usb_microdia_control_write(dev, 0x10e0, buf, 1);
1354
1355 buf[0] = 0x01;
1356 usb_microdia_control_write(dev, 0x1061, buf, 1);
1357
1358 buf[0] = 0x27;
1359 usb_microdia_control_write(dev, 0x10e0, buf, 1);
1360
1361 usb_microdia_control_write(dev, 0x1100, qtable1, 64);
1362
1363 usb_microdia_control_write(dev, 0x1140, qtable2, 64); /* URB 150 */
1364
1365 buf[0] = 0x07;
1366 usb_microdia_control_write(dev, 0x10e0, buf, 1);
1367
1368 buf[0] = 0x03;
1369 usb_microdia_control_write(dev, 0x1061, buf, 1);
1370
1371 buf[0] = 0x0b;
1372 usb_microdia_control_write(dev, 0x10e0, buf, 1);
1373
1374 buf[0] = 0x00;
1375 usb_microdia_control_write(dev, 0x11bc, buf, 1);
1376
1377 buf[0] = 0x00;
1378 usb_microdia_control_write(dev, 0x11bd, buf, 1);
1379
1380 buf[0] = 0x00;
1381 usb_microdia_control_write(dev, 0x11be, buf, 1);
1382
1383 buf[0] = 0x00;
1384 usb_microdia_control_write(dev, 0x11bf, buf, 1);
1385
1386 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
1387 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
1388
1389 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
1390 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
1391
1392 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
1393 0x09, dev->sensor_flags, NULL);
1394
1395 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1396 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
1397
1398 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
1399 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
1400 usb_microdia_control_write(dev, 0x1180, buf, 6);
1401
1402 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
1403 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 170 */
1404
1405 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
1406 usb_microdia_control_write(dev, 0x11ab, buf, 4);
1407
1408 buf[0] = 0x03;
1409 usb_microdia_control_write(dev, 0x1061, buf, 1);
1410
1411 buf[0] = 0x0a;
1412 usb_microdia_control_write(dev, 0x11ba, buf, 1);
1413
1414 buf[0] = 0x00;
1415 usb_microdia_control_write(dev, 0x11b9, buf, 1);
1416
1417 buf[0] = 0x0b;
1418 usb_microdia_control_write(dev, 0x11ba, buf, 1);
1419
1420 buf[0] = 0x01;
1421 usb_microdia_control_write(dev, 0x1061, buf, 1);
1422
1423 buf[0] = 0x78;
1424 usb_microdia_control_write(dev, 0x1000, buf, 1);
1425
1426 buf[0] = 0x18;
1427 usb_microdia_control_write(dev, 0x1002, buf, 1);
1428
1429 buf[0] = 0x18;
1430 usb_microdia_control_write(dev, 0x1002, buf, 1);
1431
1432 buf[0] = 0x7b;
1433 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 180 */
1434
1435 buf[0] = 0x02;
1436 usb_microdia_control_write(dev, 0x118a, buf, 1);
1437
1438 buf[0] = 0x02;
1439 usb_microdia_control_write(dev, 0x0395, buf, 1);
1440
1441 buf[0] = 0x78;
1442 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1443 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1444
1445 buf[0] = 0xf9;
1446 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1447 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1448
1449 buf[0] = 0xfa;
1450 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1451 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1452
1453 buf[0] = 0x7b;
1454 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1455 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 190 */
1456
1457 buf[0] = 0x7c;
1458 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1459 usb_microdia_control_read(dev, 0x11b8, buf, 1);
1460
1461 buf[0] = 0x7b;
1462 usb_microdia_control_write(dev, 0x11b8, buf, 1);
1463
1464 for (i = 0; i < 3; i++)
1465 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
1466 fifth10c0[i][0], dev->sensor_flags, &fifth10c0[i][1]); /* URB 200-205 */
1467
1468 sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2,
1469 0x00, dev->sensor_flags, buf);
1470 /* __u8 result[2] = {buf[3], buf[4]}; */
1471
1472 buf[0] = 0x03;
1473 usb_microdia_control_write(dev, 0x1061, buf, 1);
1474
1475 return 0;
1476 }
1477
1478
1479 /**
1480 * @brief From startstream.log
1481 *
1482 * @param dev
1483 *
1484 * @returns 0
1485 *
1486 * @author GWater
1487 *
1488 * For SN9C201 with SOI968.
1489 * This is function triggers a working stream of image data and a glowing LED.
1490 */
1491 int microdia_624e_start_stream(struct usb_microdia *dev)
1492 {
1493 int ret, i;
1494 __u8 unknown1[9] = { dev->sensor_flags, dev->sensor_slave_address,
1495 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
1496
1497 __u16 reg;
1498 __u8 value;
1499
1500 __u16 regs[][2] = {
1501 {0x1066, 0x00},
1502 {0x1000, 0x7c},
1503 {0x1001, 0x44},
1504 {0x1002, 0x1c},
1505 {0x1006, 0x80},
1506 {0x1007, 0xa0},
1507 {0x1061, 0x03},
1508 {0x1020, 0x80},
1509 {0x1067, 0x40},
1510 {0x1068, 0x30},
1511 {0x1069, 0x20},
1512 {0x106a, 0x10},
1513 {0x106b, 0x08},
1514 {0x10e0, 0x0b},
1515 {0x10f6, 0x60},
1516 {0x10f7, 0x07},
1517 {0x10f8, 0x14},
1518 {0x10f9, 0x00},
1519 {0x10fa, 0xff},
1520 {0x1188, 0x8a},
1521 {0x118b, 0x0a},
1522 {0x118c, 0x20},
1523 {0x118d, 0x20},
1524 {0x118e, 0x20},
1525 {0x118f, 0x20},
1526 {0x1190, 0x00},
1527 {0x1191, 0x24},
1528 {0x1192, 0x3b},
1529 {0x1193, 0x4f},
1530 {0x1194, 0x61},
1531 {0x1195, 0x71},
1532 {0x1196, 0x80},
1533 {0x1197, 0x8f},
1534 {0x1198, 0x9d},
1535 {0x1199, 0xab},
1536 {0x119a, 0xb8},
1537 {0x119b, 0xc4},
1538 {0x119c, 0xd1},
1539 {0x119d, 0xdd},
1540 {0x119e, 0xe9},
1541 {0x119f, 0xf4},
1542 {0x11a0, 0xff},
1543 {0x11a1, 0x00},
1544 {0x11a2, 0x00},
1545 {0x11b7, 0x60},
1546 {0x11b8, 0x7a},
1547 {0x11b9, 0x00},
1548 {0x11ba, 0x0f},
1549 {0x11bb, 0x00},
1550 {0x11bc, 0x00},
1551 {0x11bd, 0x00},
1552 {0x11be, 0x00},
1553 {0x11bf, 0x00},
1554 {0x1180, 0x3c},
1555 {0x1181, 0x00},
1556 {0x1182, 0x0b},
1557 {0x1183, 0x00},
1558 {0x1184, 0x28},
1559 {0x1185, 0x3c},
1560 {0x11a1, 0x00},
1561 {0x11a2, 0x00},
1562 {0x11a3, 0x6a},
1563 {0x11a4, 0x50},
1564 {0x11ab, 0x00},
1565 {0x11ac, 0x00},
1566 {0x11ad, 0x50},
1567 {0x11ae, 0x3c},
1568 {0x118a, 0x05},
1569 {0x0395, 0x05},
1570 {0x11a5, 0x2d},
1571 {0x11a6, 0x2d},
1572 {0x11a7, 0x3a},
1573 {0x11a8, 0x05},
1574 {0x11a9, 0x04},
1575 {0x11aa, 0x3f},
1576 {0x11af, 0x28},
1577 {0x11b0, 0xd8},
1578 {0x11b1, 0x14},
1579 {0x11b2, 0xec},
1580 {0x11b3, 0x32},
1581 {0x11b4, 0xdd},
1582 {0x11b5, 0x2d},
1583 {0x11b6, 0xdd},
1584 };
1585
1586 __u8 reg_11c0[48];
1587
1588 __u8 qtable1[64] = {
1589 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
1590 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
1591 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
1592 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
1593 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
1594 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
1595 0x4f, 0x53, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
1596 0x64, 0x5c, 0x53, 0x64, 0x4b, 0x53, 0x58, 0x53
1597 };
1598
1599 __u8 qtable2[64] = {
1600 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
1601 0x15, 0x26, 0x53, 0x36, 0x2e, 0x36, 0x53, 0x53,
1602 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
1603 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
1604 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
1605 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
1606 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
1607 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53
1608 };
1609
1610
1611 for (i = 0; i < ARRAY_SIZE(regs); i++) {
1612 reg = regs[i][0];
1613 value = regs[i][1];
1614 ret = usb_microdia_control_write(dev, reg, &value, 1);
1615 if (ret < 0) {
1616 UDIA_INFO("Bridge Init Error (%d). line %d\n", ret, i);
1617 goto err;
1618 }
1619 }
1620
1621 memset(reg_11c0, 0x00, 48);
1622 ret = usb_microdia_control_write(dev, 0x11c0, reg_11c0, 48);
1623 if (ret < 0)
1624 goto err;
1625
1626 ret = usb_microdia_control_write(dev, 0x1100, qtable1, 64);
1627 if (ret < 0)
1628 goto err;
1629
1630 ret = usb_microdia_control_write(dev, 0x1140, qtable2, 64);
1631 if (ret < 0)
1632 goto err;
1633
1634 /* this is the same register as the I2C write, not sure why
1635 * we're writing 9 bytes -- the SN9C102 docs say all writes
1636 * must be 8 bytes, but we don't have docs for SN9C20x */
1637 ret = usb_microdia_control_write(dev, 0x10c0, unknown1, 9);
1638 if (ret < 0)
1639 goto err;
1640
1641 if (dev->sensor_init)
1642 dev->sensor_init(dev);
1643
1644 return 0;
1645
1646 err:
1647 UDIA_ERROR("start stream: failed (%d)!\n", ret);
1648 return ret;
1649 }
1650
1651 int microdia_624f_start_stream(struct usb_microdia *dev)
1652 {
1653 int ret, i;
1654 __u8 unknown1[9] = { dev->sensor_flags, dev->sensor_slave_address,
1655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
1656
1657 __u16 reg;
1658 __u8 value;
1659
1660 __u16 regs[][2] = {
1661 {0x1007, 0x20},
1662 {0x1006, 0x00},
1663 {0x1000, 0x78},
1664 {0x1001, 0x44},
1665 {0x1002, 0x1c},
1666 {0x1061, 0x01},
1667 {0x1020, 0x80},
1668 {0x1067, 0x40},
1669 {0x1068, 0x30},
1670 {0x1069, 0x20},
1671 {0x106a, 0x10},
1672 {0x106b, 0x08},
1673 {0x1188, 0x87},
1674 {0x11a1, 0x00},
1675 {0x11a2, 0x00},
1676 {0x11a3, 0x6a},
1677 {0x11a4, 0x50},
1678 {0x11ab, 0x00},
1679 {0x11ac, 0x00},
1680 {0x11ad, 0x50},
1681 {0x11ae, 0x3c},
1682 {0x118a, 0x04},
1683 {0x0395, 0x04},
1684 {0x11b8, 0x3a},
1685 {0x118b, 0x0e},
1686 {0x10f7, 0x05},
1687 {0x10f8, 0x14},
1688 {0x10fa, 0xff},
1689 {0x10f9, 0x00},
1690 {0x11ba, 0x0e},
1691 {0x11a5, 0x2d},
1692 {0x11a6, 0x2d},
1693 {0x11a7, 0x3a},
1694 {0x11a8, 0x05},
1695 {0x11a9, 0x04},
1696 {0x11aa, 0x3f},
1697 {0x11af, 0x28},
1698 {0x11b0, 0xd8},
1699 {0x11b1, 0x14},
1700 {0x11b2, 0xec},
1701 {0x11b3, 0x32},
1702 {0x11b4, 0xdd},
1703 {0x11b5, 0x32},
1704 {0x11b6, 0xdd},
1705 {0x10e0, 0x45},
1706 {0x11bc, 0x40},
1707 {0x11bd, 0x01},
1708 {0x11be, 0xf0},
1709 {0x11bf, 0x00},
1710 {0x1180, 0x02},
1711 {0x1181, 0x00},
1712 {0x1182, 0x07},
1713 {0x1183, 0x00},
1714 {0x1184, 0x28},
1715 {0x1185, 0x3c},
1716 {0x1061, 0x03},
1717 };
1718
1719 __u8 reg_11c0[48] = {
1720 0x10, 0x21, 0x34, 0x40, 0x47, 0x4f, 0x57, 0x5f,
1721 0x64, 0x68, 0x6d, 0x73, 0x79, 0x80, 0x89, 0x97,
1722 0x0d, 0x1c, 0x2a, 0x33, 0x38, 0x3d, 0x44, 0x4a,
1723 0x4e, 0x52, 0x56, 0x5b, 0x61, 0x68, 0x6f, 0x7a,
1724 0x0d, 0x1a, 0x2a, 0x31, 0x36, 0x3b, 0x41, 0x47,
1725 0x4a, 0x4e, 0x53, 0x58, 0x5d, 0x64, 0x6b, 0x76
1726 };
1727
1728 __u8 qtable1[64] = {
1729 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
1730 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
1731 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
1732 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
1733 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
1734 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
1735 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
1736 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54
1737 };
1738
1739 __u8 qtable2[64] = {
1740 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
1741 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
1742 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1743 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1744 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1745 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1746 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
1747 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54
1748 };
1749
1750 for (i = 0; i < ARRAY_SIZE(regs); i++) {
1751 reg = regs[i][0];
1752 value = regs[i][1];
1753 ret = usb_microdia_control_write(dev, reg, &value, 1);
1754 if (ret < 0) {
1755 UDIA_INFO("Bridge Init Error (%d). line %d\n", ret, i);
1756 goto err;
1757 }
1758 }
1759
1760 ret = usb_microdia_control_write(dev, 0x11c0, reg_11c0, 48);
1761 if (ret < 0)
1762 goto err;
1763
1764 ret = usb_microdia_control_write(dev, 0x1100, qtable1, 64);
1765 if (ret < 0)
1766 goto err;
1767
1768 ret = usb_microdia_control_write(dev, 0x1140, qtable2, 64);
1769 if (ret < 0)
1770 goto err;
1771
1772 /* this is the same register as the I2C write, not sure why
1773 * we're writing 9 bytes -- the SN9C102 docs say all writes
1774 * must be 8 bytes, but we don't have docs for SN9C20x */
1775 ret = usb_microdia_control_write(dev, 0x10c0, unknown1, 9);
1776 if (ret < 0)
1777 goto err;
1778
1779 if (dev->sensor_init)
1780 dev->sensor_init(dev);
1781
1782 return 0;
1783
1784 err:
1785 UDIA_ERROR("start stream: failed (%d)!\n", ret);
1786 return ret;
1787 }
1788
1789 /**
1790 * @brief Start stream from 6260 devices
1791 *
1792 * @param dev
1793 *
1794 * @returns 0 or negative error code
1795 *
1796 */
1797 int microdia_6260_start_stream(struct usb_microdia *dev)
1798 {
1799 int ret = 0;
1800 int i;
1801 __u16 reg;
1802 __u8 value[1];
1803 __u8 buf[32];
1804
1805 static __u16 bridge6260_start[][2] = {
1806 {0x1045, 0x1f},
1807 {0x1066, 0x00},
1808 {0x1007, 0x20},
1809 {0x1006, 0x00},
1810 {0x1000, 0x78},
1811 {0x1001, 0xc7},
1812 {0x1002, 0x18},
1813 {0x1061, 0x01},
1814 {0x1020, 0x80},
1815 {0x1067, 0x40},
1816 {0x1068, 0x30},
1817 {0x1069, 0x20},
1818 {0x106a, 0x10},
1819 {0x106b, 0x08},
1820 {0x10e0, 0x45},
1821 {0x10e1, 0x18},
1822 {0x10e2, 0x00},
1823 {0x10e3, 0x30},
1824 {0x10e4, 0x00},
1825 {0x10e5, 0x09},
1826 {0x10e6, 0x00},
1827 {0x10e7, 0xed},
1828 {0x10e8, 0x0f},
1829 {0x10e9, 0xda},
1830 {0x10ea, 0x0f},
1831 {0x10eb, 0x3a},
1832 {0x10ec, 0x00},
1833 {0x10ed, 0x3a},
1834 {0x10ee, 0x00},
1835 {0x10ef, 0xd0},
1836 {0x10d0, 0x0f},
1837 {0x10d1, 0xf7},
1838 {0x10d2, 0x0f},
1839 {0x10d3, 0x00},
1840 {0x10d4, 0x00},
1841 {0x10d5, 0x00},
1842 {0x10d6, 0x60},
1843 {0x10d7, 0x0a},
1844 {0x10f8, 0x00},
1845 {0x10f9, 0x00},
1846 {0x10fa, 0x00},
1847 {0x1188, 0x8a},
1848 {0x118a, 0x08},
1849 {0x118b, 0x00},
1850 {0x118c, 0x20},
1851 {0x118d, 0x20},
1852 {0x118e, 0x20},
1853 {0x118f, 0x20},
1854 {0x1190, 0x00},
1855 {0x1191, 0x24},
1856 {0x1192, 0x3b},
1857 {0x1193, 0x4f},
1858 {0x1194, 0x61},
1859 {0x1195, 0x71},
1860 {0x1196, 0x80},
1861 {0x1197, 0x8f},
1862 {0x1198, 0x9d},
1863 {0x1199, 0xab},
1864 {0x119a, 0xb8},
1865 {0x119b, 0xc4},
1866 {0x119c, 0xd1},
1867 {0x119d, 0xdd},
1868 {0x119e, 0xe9},
1869 {0x119f, 0xf4},
1870 {0x1200, 0xff},
1871 {0x11a1, 0x00},
1872 {0x11a2, 0x00},
1873 {0x11b7, 0x60},
1874 {0x11b8, 0x28},
1875 {0x11b9, 0x00},
1876 {0x11ba, 0x00},
1877 {0x11bb, 0x00},
1878 {0x11bc, 0x40},
1879 {0x11bd, 0x01},
1880 {0x11be, 0xf0},
1881 {0x11bf, 0x00},
1882 {0x1000, 0x78},
1883 {0x11b8, 0x38},
1884 {0x10e0, 0x45},
1885 {0x1001, 0xc6},
1886 {0x1001, 0xc4},
1887 {0x1180, 0x00},
1888 {0x1181, 0x00},
1889 {0x1182, 0x01},
1890 {0x1183, 0x00},
1891 {0x1184, 0x50},
1892 {0x1185, 0x3c},
1893 {0x11a1, 0x00},
1894 {0x11a2, 0x00},
1895 {0x11a3, 0xd5},
1896 {0x11a4, 0x50},
1897 {0x11ab, 0x00},
1898 {0x11ac, 0x00},
1899 {0x11ad, 0xa0},
1900 {0x11ae, 0x3c},
1901 {0x1000, 0x78},
1902 {0x1002, 0x10},
1903 {0x1002, 0x00},
1904 {0x11b8, 0x38},
1905 {0x118a, 0x04},
1906 {0x0395, 0x04},
1907 {0x11b8, 0x78},
1908 {0x11b8, 0xf9},
1909 {0x11b8, 0xfa},
1910 {0x11b8, 0x7b},
1911 {0x11b8, 0x7c},
1912 {0x11b8, 0x7d},
1913 {0x11b8, 0x7b},
1914 {0x1180, 0x00},
1915 {0x1181, 0x00},
1916 {0x1182, 0x01},
1917 {0x1183, 0x00},
1918 {0x1184, 0x50},
1919 {0x1185, 0x3c},
1920 {0x11a1, 0x00},
1921 {0x11a2, 0x00},
1922 {0x11a3, 0xd5},
1923 {0x11a4, 0x50},
1924 {0x11ab, 0x00},
1925 {0x11ab, 0x00},
1926 {0x11ab, 0xa0},
1927 {0x11ab, 0x3c},
1928 {0x1061, 0x03},
1929 {0x1061, 0x01},
1930 {0x1000, 0x78},
1931 {0x1002, 0x00},
1932 {0x1002, 0x00},
1933 {0x11b8, 0x7b},
1934 {0x118a, 0x04},
1935 {0x0395, 0x04},
1936 {0x11b8, 0x78},
1937 {0x11b8, 0x79},
1938 {0x11b8, 0x7a},
1939 {0x11b8, 0x7b},
1940 {0x11b8, 0x7c},
1941 {0x11b8, 0x7d},
1942 {0x11b8, 0xfa},
1943 {0x1061, 0x03},
1944 };
1945
1946 UDIA_INFO("Starting camera 0c45:6260...\n");
1947
1948 for (i = 0; i < ARRAY_SIZE(bridge6260_start); i++) {
1949 reg = bridge6260_start[i][0];
1950 value[0] = bridge6260_start[i][1];
1951 ret = usb_microdia_control_write(dev, reg, value, 1);
1952 if (ret < 0) {
1953 UDIA_INFO("camera 0c45:6260 Bridge: Start Sequence Error (%d) on array line %d\n", ret, i);
1954 break;
1955 }
1956 }
1957
1958 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
1959 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
1960 buf[8] = 0x03;
1961 ret = usb_microdia_control_write(dev, 0x10c0, buf, 9);
1962
1963 ret = ov7670_initialise(dev);
1964 if (ret < 0)
1965 return ret;
1966
1967 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1, 0x3b, dev->sensor_flags, buf);
1968 ret = usb_microdia_control_read(dev, 0x10c1, buf, 1);
1969 buf[0] = 0x50;
1970 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
1971
1972 /* TRY TO READ FROM EEPROM: */
1973 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, dev->sensor_flags, buf);
1974 if (ret < 0)
1975 UDIA_INFO("No EEPROM found\n");
1976 else
1977 UDIA_INFO("Read from EEPROM successful\n");
1978
1979 buf[0] = 0x21;
1980 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
1981
1982 return ret;
1983 }
1984
1985 /**
1986 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
1987 *
1988 * @param dev
1989 *
1990 * @returns 0 (ok) or -1 (error)
1991 *
1992 * @author Comer352l
1993 *
1994 * Windows driver versions: 5.7.23.000
1995 * Windows versions: 2000 and XP
1996 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
1997 * All logs were made using AMCAP with 640x480, RGB24
1998 */
1999 int microdia_6270_start_stream(struct usb_microdia *dev)
2000 {
2001 __u8 buf[64];
2002 __u8 last_11b8[1];
2003 int k;
2004 int retI2C;
2005
2006 /* Check if sensor slave address is valid: */
2007 if ((dev->sensor_slave_address != MT9V111_I2C_SLAVE_ADDRESS) && (dev->sensor_slave_address != MT9V011_I2C_SLAVE_ADDRESS)) {
2008 UDIA_INFO("microdia_6270_start_stream(): Invalid sensor slave address !\n");
2009 return -1;
2010 }
2011
2012 /* <= INTERRUPT COMING BACK (URB 1953) */
2013 /* SWITCH TO ALTERNATE SETTINGS 8 (URB 1954) // NOT IN ALEX'S LOG */
2014 /* => INTERRUPT GOING DOWN (URB 1955) */
2015
2016 buf[0] = 0x00;
2017 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1956 */
2018
2019 /* <= INTERRUPT COMING BACK (URB 1955) */
2020 /* => INTERRUPT GOING DOWN (URB 1957) */
2021
2022 buf[0] = 0x78;
2023 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1958 */
2024 buf[0] = 0xc7;
2025 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 1959 */
2026 buf[0] = 0x18;
2027 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 1960 */
2028 buf[0] = 0x01;
2029 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 1961 */
2030 buf[0] = 0x80;
2031 usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 1962 */
2032 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
2033 usb_microdia_control_write(dev, 0x1067, buf, 5); /* URB 1963 */
2034
2035 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2036 /* STRANGE I2C MESSAGE: */
2037 /* - 9 bytes */
2038 /* - byte 8 = 0x00 at first start + first cycle */
2039 /* - procedure not complete: no wait/check for ack/error, no readout of 0x10c2 */
2040 /* - dummy writes at first cycle and read at second cycle, but there are many I2C messages in the meantime, so this should not work */
2041 /* */
2042 /* AT FIRST START + FIRST CYCLE: */
2043 buf[0] = 0x80; buf[1] = dev->sensor_slave_address; buf[2] = 0x00; buf[3] = 0x00;
2044 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x03;
2045 /* AT ALL FURTHER STARTS + FIRST CYCLE: */
2046 /* MT9V111: I2C MESSAGE => IFP Register 0x33: Auto exposure */
2047 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x33; buf[3] = 0x00; */
2048 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
2049 /* MT9V011: ????????????????????????? */
2050 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x07; buf[3] = 0x00; */
2051 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
2052 /* ALWAYS AT 2nd AND FURTHER CYCLES: */
2053 /* MT9V111: */
2054 /* buf[0] = 0xa2; buf[1] = 0x5c; buf[2] = 0x00; buf[3] = 0x36; */
2055 /* buf[4] = 0x00; buf[5] = 0x82; buf[6] = 0x3a; buf[7] = 0x10; buf[8] = 0x03; */
2056 /* => buf[3] to buf[6] simply contain bytes read with URB 2215 */
2057 /* MT9V011: */
2058 /* buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00; */
2059 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
2060 usb_microdia_control_write(dev, 0x10c0, buf, 9); /* URB 1964 */
2061 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2062
2063 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
2064 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
2065 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
2066 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
2067 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
2068 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
2069 usb_microdia_control_write(dev, 0x10e0, buf, 24); /* URB 1965 */
2070 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
2071 usb_microdia_control_write(dev, 0x10f8, buf, 3); /* URB 1966 */
2072 buf[0] = 0x06;
2073 usb_microdia_control_write(dev, 0x1188, buf, 1); /* URB 1968 */
2074 buf[0] = 0x08;
2075 usb_microdia_control_write(dev, 0x118a, buf, 1);
2076 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
2077 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
2078 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
2079 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
2080 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
2081 buf[20] = 0xf4; buf[21] = 0xff;
2082 usb_microdia_control_write(dev, 0x118b, buf, 22); /* URB 1969 */
2083 buf[0] = 0x00; buf[1] = 0x00;
2084 usb_microdia_control_write(dev, 0x11a1, buf, 2); /* URB 1970 */
2085 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08;
2086 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
2087 buf[8] = 0x00;
2088 usb_microdia_control_write(dev, 0x11b7, buf, 9); /* URB 1971 */
2089 buf[0] = 0x38;
2090 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 1972 */
2091 buf[0] = 0x78;
2092 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1973 */
2093
2094 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2095 /* I2C MESSAGES */
2096 retI2C = 0;
2097 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2098 /* Write to IFP register 0x0d: Color Correction Register 8 */
2099 buf[0] = 0x00; buf[1] = 0x01;
2100 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1974-1976 */
2101 /* Write to IFP register 0x0d: Color Correction Register 8 */
2102 buf[0] = 0x00; buf[1] = 0x00; /* ??? */
2103 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1977-1979 */
2104 /* Writes to IFP registers 0x01: Register Address Space Selection */
2105 /* 0x02: Color Correction Register 1 */
2106 buf[0] = 0x00; buf[1] = 0x01; /* select IFP address space */
2107 buf[2] = 0x00; buf[3] = 0x16; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2108 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1980-1982 */
2109 /* Writes to IFP registers 0x03: Color Correction Register 3 */
2110 /* 0x04: Color Correction Register 4 */
2111 buf[0] = 0x01; buf[1] = 0xe1; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2112 buf[2] = 0x02; buf[3] = 0x81; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2113 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1983-1985 */
2114 /* Writes to IFP registers 0x05: Aperture Correction (Sharpening) */
2115 /* 0x06: Operating Mode Control */
2116 buf[0] = 0x00; buf[1] = 0x04; /* 100% sharpening, no automatic sharpness reduction at low light // AT FIRST START + FIRST CYCLE: 0x00 0x00: no sharpening */
2117 buf[2] = 0x00; buf[3] = 0x00; /* stop AWB at the current values, no on-the-fly defect correction, no auto exposure, + RESREVED option */
2118 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 1986-1988 */
2119 /* Writes to IFP registers 0x07: Image Flow Processor Soft Reset */
2120 /* 0x08: Output Format Control */
2121 buf[0] = 0x30; buf[1] = 0x02; /* reset // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2122 buf[2] = 0x04; buf[3] = 0x80; /* bypass entire image processing, raw 8+2 Bayer data output directly */
2123 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 1989-1991 */
2124 /* "Dummy" write to IFP Register 0x11: Color Correction Register 12 */
2125 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 1992-1993 */
2126 /* Write to register 0x01: Register address space selection */
2127 /* Write to sensor register 0x02: Column Start */
2128 buf[0] = 0x00; buf[1] = 0x04; /* select sensor address space */
2129 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
2130 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1994-1996 */
2131 /* Writes to sensor registers 0x03: Window Height */
2132 /* 0x04: Window Width */
2133 buf[0] = 0x01; buf[1] = 0xe6; /* 486 */
2134 buf[2] = 0x02; buf[3] = 0x86; /* 646 */
2135 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1997-1999 */
2136 /* Writes to sensor registers 0x05: Horizontal Blanking */
2137 /* 0x06: Vertical Blanking */
2138 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2139 buf[2] = 0x00; buf[3] = 0x00; /* 0 rows */
2140 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 2000-2002 */
2141 /* Writes to sensor registers 0x07: Output Control */
2142 /* 0x08: Row Start */
2143 buf[0] = 0x30; buf[1] = 0x02; /* normal operation + chip enable + RESERVED options */
2144 buf[2] = 0x00; buf[3] = 0x08; /* row 8 */
2145 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 2003-2005 */
2146 /* "Dummy" write to sensor Register 0x11: UNDOCUMENTED */
2147 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 2006-2007 */
2148 /* Writes to sensor registers 0x0c: Shutter Delay */
2149 /* 0x0d: Reset (Soft) (from MT9V011 datasheet) */
2150 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
2151 buf[2] = 0x00; buf[3] = 0x00; /* return to normal operation */
2152 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf); /* URBs 2008-2010 */
2153 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
2154 /* 0x0f: UNDOCUMENTED */
2155 buf[0] = 0x00; buf[1] = 0x00;
2156 buf[2] = 0x00; buf[3] = 0x00;
2157 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf); /* URBs 2011-2013 */
2158 /* Writes to sensor registers 0x10: UNDOCUMENTED */
2159 /* 0x11: UNDOCUMENTED */
2160 buf[0] = 0x00; buf[1] = 0x00;
2161 buf[2] = 0x00; buf[3] = 0x00;
2162 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf); /* URBs 2014-2016 */
2163 /* Writes to sensor registers 0x12: 2X Zoom Col Start => 0x1e bit 0 must be set to activate zoom */
2164 /* 0x13: 2X Zoom Row Start => 0x1e bit 0 must be set to activate zoom */
2165 buf[0] = 0x00; buf[1] = 0xb0; /* column 176 */
2166 buf[2] = 0x00; buf[3] = 0x7c; /* row 124 */
2167 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf); /* URBs 2017-2018 */
2168 /* Writes to sensor registers 0x14: UNDOCUMENTED */
2169 /* 0x15: UNDOCUMENTED */
2170 buf[0] = 0x00; buf[1] = 0x00;
2171 buf[2] = 0x00; buf[3] = 0x00;
2172 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf); /* URBs 2019-2021 */
2173 /* Writes to sensor registers 0x16: UNDOCUMENTED */
2174 /* 0x17: UNDOCUMENTED */
2175 buf[0] = 0x00; buf[1] = 0x00;
2176 buf[2] = 0x00; buf[3] = 0x00;
2177 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf); /* URBs 2022-2024 */
2178 /* Writes to sensor registers 0x18: UNDOCUMENTED */
2179 /* 0x19: UNDOCUMENTED */
2180 buf[0] = 0x00; buf[1] = 0x00;
2181 buf[2] = 0x00; buf[3] = 0x00;
2182 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf); /* URBs 2025-2027 */
2183 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
2184 /* 0x1b: UNDOCUMENTED */
2185 buf[0] = 0x00; buf[1] = 0x00;
2186 buf[2] = 0x00; buf[3] = 0x00;
2187 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf); /* URBs 2028-2030 */
2188 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
2189 /* 0x1d: UNDOCUMENTED */
2190 buf[0] = 0x00; buf[1] = 0x00;
2191 buf[2] = 0x00; buf[3] = 0x00;
2192 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf); /* URBs 2031-2033 */
2193 /* Write to sensor register 0x30: RESERVED */
2194 buf[0] = 0x00; buf[1] = 0x00;
2195 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x30, dev->sensor_flags, buf); /* URBs 2034-2036 */
2196 /* Write to sensor register 0x20: Read Mode */
2197 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
2198 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2037-2039 */
2199 /* Writes to sensor registers 0x30: RESERVED */
2200 /* 0x31: RESERVED */
2201 buf[0] = 0x00; buf[1] = 0x05;
2202 buf[2] = 0x00; buf[3] = 0x00;
2203 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x30, dev->sensor_flags, buf); /* URBs 2040-2042 */
2204 /* "Dummy" write to sensor Register 0x34: RESERVED */
2205 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x34, dev->sensor_flags, NULL); /* URBs 2043-2044 */
2206 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2207 /* Write to sensor register 0x07: Output Control */
2208 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
2209 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
2210 /* Write to sensor register 0x0d: Soft Reset */
2211 buf[0] = 0x00; buf[1] = 0x01; /* reset */
2212 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
2213 /* Write to sensor register 0x0d: Soft Reset */
2214 buf[0] = 0x00; buf[1] = 0x00; /* resume operation */
2215 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
2216 /* Writes to sensor registers 0x01: Row start */
2217 /* 0x02: Column Start */
2218 buf[0] = 0x00; buf[1] = 0x08; /* start with row 8 */
2219 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
2220 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf);
2221 /* Writes to sensor registers 0x03: Window Height */
2222 /* 0x04: Window Width */
2223 buf[0] = 0x01; buf[1] = 0xe1; /* 481 */
2224 buf[2] = 0x02; buf[3] = 0x81; /* 641 */
2225 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf);
2226 /* Writes to sensor registers 0x05: Horizontal Blanking */
2227 /* 0x06: Vertical Blanking */
2228 buf[0] = 0x00; buf[1] = 0x83; /* 131 columns (pixel clocks) */
2229 buf[2] = 0x00; buf[3] = 0x06; /* 6 rows */
2230 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf);
2231 /* Write to sensor register 0x0d: Soft Reset */
2232 buf[0] = 0x00; buf[1] = 0x02; /* UNKNOWN */
2233 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
2234 /* Writes to sensor registers 0x0a: Pixel Clock Speed */
2235 /* 0x0b: Frame Restart */
2236 buf[0] = 0x00; buf[1] = 0x00; /* default */
2237 buf[2] = 0x00; buf[3] = 0x00; /* (has no effect/no restart) */
2238 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0a, dev->sensor_flags, buf);
2239 /* Writes to sensor registers 0x0c: Shutter Delay */
2240 /* 0x0d: Soft Reset */
2241 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
2242 buf[2] = 0x00; buf[3] = 0x00; /* resume operation */
2243 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf);
2244 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
2245 /* 0x0f: UNDOCUMENTED */
2246 buf[0] = 0x00; buf[1] = 0x00;
2247 buf[2] = 0x00; buf[3] = 0x00;
2248 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf);
2249 /* Writes to sensor registers 0x10: UNDOCUMENTED */
2250 /* 0x11: UNDOCUMENTED */
2251 buf[0] = 0x00; buf[1] = 0x00;
2252 buf[2] = 0x00; buf[3] = 0x00;
2253 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf);
2254 /* Writes to sensor registers 0x12: 2X Zoom Column Start (from MT9V111 datasheet) */
2255 /* 0x13: 2X Zoom Row Start (from MT9V111 datasheet) */
2256 buf[0] = 0x00; buf[1] = 0x00; /* column 0 => bit0 of reg 0x1e must be set to activate zoom */
2257 buf[2] = 0x00; buf[3] = 0x00; /* row 0 => bit0 of reg 0x1e must be set to activate zoom */
2258 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf);
2259 /* Writes to sensor registers 0x14: UNDOCUMENTED */
2260 /* 0x15: UNDOCUMENTED */
2261 buf[0] = 0x00; buf[1] = 0x00;
2262 buf[2] = 0x00; buf[3] = 0x00;
2263 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf);
2264 /* Writes to sensor registers 0x16: UNDOCUMENTED */
2265 /* 0x17: UNDOCUMENTED */
2266 buf[0] = 0x00; buf[1] = 0x00;
2267 buf[2] = 0x00; buf[3] = 0x00;
2268 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf);
2269 /* Writes to sensor registers 0x18: UNDOCUMENTED */
2270 /* 0x19: UNDOCUMENTED */
2271 buf[0] = 0x00; buf[1] = 0x00;
2272 buf[2] = 0x00; buf[3] = 0x00;
2273 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf);
2274 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
2275 /* 0x1b: UNDOCUMENTED */
2276 buf[0] = 0x00; buf[1] = 0x00;
2277 buf[2] = 0x00; buf[3] = 0x00;
2278 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf);
2279 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
2280 /* 0x1d: UNDOCUMENTED */
2281 buf[0] = 0x00; buf[1] = 0x00;
2282 buf[2] = 0x00; buf[3] = 0x00;
2283 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf);
2284 /* Write to sensor register 0x32: RESERVED */
2285 buf[0] = 0x00; buf[1] = 0x00;
2286 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x32, dev->sensor_flags, buf);
2287 /* Writes to sensor registers 0x20: Read Mode */
2288 /* 0x21: RESERVED */
2289 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad frames) + UNDOCUMENTED */
2290 buf[2] = 0x00; buf[3] = 0x00;
2291 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x20, dev->sensor_flags, buf);
2292 /* Writes to sensor registers 0x22: RESERVED */
2293 /* 0x23: UNDOCUMENTED */
2294 buf[0] = 0x00; buf[1] = 0x00;
2295 buf[2] = 0x00; buf[3] = 0x00;
2296 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x22, dev->sensor_flags, buf);
2297 /* Writes to sensor registers 0x24: UNDOCUMENTED */
2298 /* 0x25: UNDOCUMENTED */
2299 buf[0] = 0x00; buf[1] = 0x00;
2300 buf[2] = 0x00; buf[3] = 0x00;
2301 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x24, dev->sensor_flags, buf);
2302 /* Writes to sensor registers 0x26: UNDOCUMENTED */
2303 /* 0x27: RESERVED */
2304 buf[0] = 0x00; buf[1] = 0x00;
2305 buf[2] = 0x00; buf[3] = 0x24;
2306 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x26, dev->sensor_flags, buf);
2307 /* "Dummy" write to sensor Register 0x30: RESERVED */
2308 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x30, dev->sensor_flags, NULL);
2309 /* Writes to sensor registers 0x2f: RESERVED */
2310 /* 0x30: RESERVED */
2311 buf[0] = 0xf7; buf[1] = 0xb0;
2312 buf[2] = 0x00; buf[3] = 0x05;
2313 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2f, dev->sensor_flags, buf);
2314 /* Writes to sensor registers 0x31: RESERVED */
2315 /* 0x32: RESERVED */
2316 buf[0] = 0x00; buf[1] = 0x00;
2317 buf[2] = 0x00; buf[3] = 0x00;
2318 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x31, dev->sensor_flags, buf);
2319 /* Writes to sensor registers 0x33: RESERVED */
2320 /* 0x34: RESERVED */
2321 buf[0] = 0x00; buf[1] = 0x00;
2322 buf[2] = 0x01; buf[3] = 0x00;
2323 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x33, dev->sensor_flags, buf);
2324 /* "Dummy" write to sensor Register 0x3b: RESERVED */
2325 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x3b, dev->sensor_flags, NULL);
2326 /* Write to sensor register 0x3d: RESERVED */
2327 buf[0] = 0x06; buf[1] = 0x8f;
2328 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x3d, dev->sensor_flags, buf);
2329 /* Writes to sensor registers 0x40: RESERVED */
2330 /* 0x41: RESERVED */
2331 buf[0] = 0x01; buf[1] = 0xe0;
2332 buf[2] = 0x00; buf[3] = 0xd1;
2333 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x40, dev->sensor_flags, buf);
2334 /* Write to sensor register 0x44: UNDOCUMENTED */
2335 buf[0] = 0x00; buf[1] = 0x82;
2336 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x44, dev->sensor_flags, buf);
2337 /* Writes to sensor registers 0x5a: RESERVED */
2338 /* 0x5b: RESERVED */
2339 buf[0] = 0x00; buf[1] = 0x00;
2340 buf[2] = 0x00; buf[3] = 0x00;
2341 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5a, dev->sensor_flags, buf);
2342 /* Writes to sensor registers 0x5c: RESERVED */
2343 /* 0x5d: RESERVED */
2344 buf[0] = 0x00; buf[1] = 0x00;
2345 buf[2] = 0x00; buf[3] = 0x00;
2346 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5c, dev->sensor_flags, buf);
2347 /* Writes to sensor registers 0x5e: RESERVED */
2348 /* 0x5f: RESERVED */
2349 buf[0] = 0x00; buf[1] = 0x00;
2350 buf[2] = 0xa3; buf[3] = 0x1d;
2351 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5e, dev->sensor_flags, buf);
2352 /* "Dummy" write to sensor Register 0x68: UNDOCUMENTED */
2353 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x68, dev->sensor_flags, NULL);
2354 /* Write to sensor register 0x62: RESERVED */
2355 buf[0] = 0x06; buf[1] = 0x11;
2356 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x62, dev->sensor_flags, buf);
2357 }
2358 if (retI2C < 0) {
2359 UDIA_INFO("1 or more errors occured in I2C-message-block 1 !\n");
2360 return -1;
2361 }
2362 /* END OF I2C MESSAGES */
2363 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2364
2365 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2366 buf[0] = 0x40;
2367 usb_microdia_control_write(dev, 0x1007, buf, 8);
2368 buf[0] = 0x40;
2369 usb_microdia_control_write(dev, 0x1006, buf, 8);
2370 }
2371
2372
2373 /* *** TEMPORARY SWITCH TO SLAVE ADDRESS 0x50, I2C READ ATTEMPT: */
2374 /* - WE CURRENTLY KNOW NO 6270 CAM THAT IS SUCCESSFULLY READ HERE */
2375 /* - IF READ FAILS, THIS IS NEVER DONE AGAIN (IN NEXT CYCLE OR FURTHER STARTS) */
2376 usb_microdia_control_read(dev, 0x10c1, buf, 1); /* returns 0x5c */
2377 buf[0] = 0x50;
2378 usb_microdia_control_write(dev, 0x10c1, buf, 1);
2379 retI2C = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, SN9C20X_I2C_2WIRE, buf);
2380 if (retI2C >= 0)
2381 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");
2382 buf[0] = 0x5c;
2383 usb_microdia_control_write(dev, 0x10c1, buf, 1);
2384
2385
2386 buf[0] = 0x47; /* ALEX: 0x44 */
2387 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2045 */
2388 buf[0] = 0x47; /* ALEX: 0x04 */
2389 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2046 */
2390 buf[0] = 0xc6;
2391 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2047 */
2392 buf[0] = 0xc4;
2393 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2048 */
2394 buf[0] = 0x84; /* ALEX: 0xc0 */
2395 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2049 */
2396 /* ALEX:
2397 buf[0] = 0x40;
2398 usb_microdia_control_write(dev, 0x1001, buf, 1);
2399 */
2400
2401 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2402 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2403 /* I2C MESSAGES */
2404 retI2C = 0;
2405 /* Writes to sensor registers 0x02: Column Start */
2406 /* 0x03: Window Height */
2407 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
2408 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
2409 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2050-2052 */
2410 /* Writes to sensor registers 0x04: Window Width */
2411 /* 0x05: Horizontal Blanking */
2412 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
2413 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
2414 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2053-2055 */
2415 /* Writes to sensor registers 0x06: Vertical Blanking */
2416 /* 0x07: Output Control */
2417 buf[0] = 0x00; buf[1] = 0x00; /* 0 rows */
2418 buf[2] = 0x30; buf[3] = 0x02; /* normal operation + chip enable + RESERVED options */
2419 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2056-2058 */
2420 /* Write to sensor register 0x0e: UNDOCUMENTED */
2421 buf[0] = 0x00; buf[1] = 0x08;
2422 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2059-2061 */
2423 if (retI2C < 0) {
2424 UDIA_INFO("1 or more errors occured in I2C-message-block 2 !\n");
2425 return -1;
2426 }
2427 /* END OF I2C MESSAGES */
2428 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2429 }
2430
2431 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
2432 buf[4] = 0x28; buf[5] = 0x3c;
2433 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2062 */
2434 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
2435 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2065 */
2436 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
2437 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2066 */
2438 buf[0] = 0x78; /* ALEX: 0x7c */
2439 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2067 */
2440 buf[0] = 0x18; /* ALEX: 0x1c */
2441 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2068 */
2442 buf[0] = 0x18; /* ALEX: 0x1c */
2443 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2069 */
2444 buf[0] = 0x38;
2445 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2070 */
2446 buf[0] = 0x04;
2447 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2071 */
2448 buf[0] = 0x04;
2449 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2072 */
2450
2451 buf[0] = 0x78;
2452 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2073 */
2453 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2074 // 0x38 */
2454 if (buf[0] == 0x38)
2455 buf[0] = 0x79;
2456 else if (buf[0] == 0xb8)
2457 buf[0] = 0xf9;
2458 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2075 */
2459 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2076 // 0xb9 */
2460 if (buf[0] == 0x39)
2461 buf[0] = 0x7a;
2462 else if (buf[0] == 0xb9)
2463 buf[0] = 0xfa;
2464 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2077 */
2465 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2078 */
2466 if (buf[0] == 0x3a)
2467 buf[0] = 0x7b;
2468 else if (buf[0] == 0xba)
2469 buf[0] = 0xfb;
2470 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2079 */
2471 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2080 // 0x3b */
2472 if (buf[0] == 0x3b)
2473 buf[0] = 0x7c;
2474 else if (buf[0] == 0xbb)
2475 buf[0] = 0xfc;
2476 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2081 */
2477 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2082 // 0x3c */
2478 if (buf[0] == 0x3c)
2479 buf[0] = 0x7d;
2480 else if (buf[0] == 0xbc)
2481 buf[0] = 0xfd;
2482 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2083 */
2483 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2084 // 0x3d */
2484 last_11b8[0] = buf[0];
2485 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2486 if (buf[0] == 0x3d)
2487 buf[0] = 0x7e;
2488 else if (buf[0] == 0xbd)
2489 buf[0] = 0xfe;
2490 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2085 */
2491 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2086 */
2492 if (buf[0] == 0x3e)
2493 buf[0] = 0x7f;
2494 else if (buf[0] == 0xbe)
2495 buf[0] = 0xff;
2496 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2087 */
2497 usb_microdia_control_read(dev, 0x11b8, last_11b8, 1); /* URB 2088 */
2498 }
2499 buf[0] = last_11b8[0] & 0xf0; /* 0xf0 or 0x70 */
2500 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
2501 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
2502
2503
2504 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2505 /* I2C MESSAGES */
2506 retI2C = 0;
2507 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2508 /* Write to sensor register 0x06: Vertical Blanking */
2509 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
2510 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2090-2092 */
2511 /* Write to sensor register 0x05: Horizontal Blanking */
2512 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
2513 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2093-2095 */
2514 /* Write to sensor register 0x20: Read Mode */
2515 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
2516 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2096-2098 */
2517 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2518 /* Write to sensor register 0x0a: Pixel Clock Speed */
2519 buf[0] = 0x00; buf[1] = 0x00; /* default */
2520 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0a, dev->sensor_flags, buf);
2521 /* Write to sensor register 0x06: Vertical Blanking */
2522 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
2523 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
2524 /* Write to sensor register 0x05: Horizontal Blanking */
2525 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
2526 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
2527 /* Write to sensor register 0x20: Read Mode */
2528 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
2529 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
2530 }
2531 if (retI2C < 0) {
2532 UDIA_INFO("1 or more errors occured in I2C-message-block 3 !\n");
2533 return -1;
2534 }
2535 /* END OF I2C MESSAGES */
2536 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2537
2538
2539 buf[0] = 0x02;
2540 usb_microdia_control_write(dev, 0x1180, buf, 1); /* URB 2099 */
2541
2542 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2543 /* I2C MESSAGE */
2544 retI2C = 0;
2545 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2546 /* Write to sensor register 0x20: Read Mode */
2547 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
2548 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2100-2102 */
2549 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2550 /* Write to sensor register 0x20: Read Mode */
2551 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
2552 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
2553 }
2554 if (retI2C < 0) {
2555 UDIA_INFO("1 or more errors occured in I2C-message-block 4 !\n");
2556 return -1;
2557 }
2558 /* END OF I2C MESSAGES */
2559 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2560
2561
2562 buf[0] = 0x02;
2563 usb_microdia_control_write(dev, 0x1182, buf, 1); /* URB 2103 */
2564
2565
2566 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2567 /* I2C MESSAGES */
2568 retI2C = 0;
2569 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2570 /* Write to sensor register 0x09: Shutter Width */
2571 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
2572 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf); /* URBs 2104-2106 */
2573 /* Write to sensor register 0x2b: Green 1 Gain */
2574 /* 0x2c: Blue Gain */
2575 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
2576 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
2577 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf); /* URBs 2107-2109 */
2578 /* Write to sensor register 0x2d: Red Gain */
2579 /* 0x2e: Green 2 Gain */
2580 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
2581 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
2582 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf); /* URBs 2110-2112 */
2583 /* "Dummy" write to sensor Register 0x33: RESERVED */
2584 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL); /* URBs 2113-2114 */
2585 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2586 /* Write to sensor register 0x09: Shutter Width */
2587 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
2588 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf);
2589 /* Write to sensor register 0x07: Output Control */
2590 buf[0] = 0x00; buf[1] = 0x03; /* dont update changes until bit0=0, chip enable, normal operation */
2591 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
2592 /* Write to sensor register 0x2b: Green 1 Gain */
2593 /* 0x2c: Blue Gain */
2594 buf[0] = 0x00; buf[1] = 0x33; /* 51*0.03125*1 = 1.59375 */
2595 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
2596 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf);
2597 /* Write to sensor register 0x2d: Red Gain */
2598 /* 0x2e: Green 2 Gain */
2599 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
2600 buf[2] = 0x00; buf[3] = 0x33; /* 51*0.03125*1 = 1.59375 */
2601 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf);
2602 /* "Dummy" write to sensor Register 0x33: RESERVED */
2603 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL);
2604 /* Write to sensor register 0x07: Output Control */
2605 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
2606 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
2607 }
2608 if (retI2C < 0) {
2609 UDIA_INFO("1 or more errors occured in I2C-message-block 5 !\n");
2610 return -1;
2611 }
2612 /* END OF I2C MESSAGES */
2613 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2614
2615 buf[0] = 0x0a;
2616 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2119 */
2617
2618 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
2619 buf[0] = 0x14;
2620 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
2621 buf[0] = 0x0a;
2622 usb_microdia_control_write(dev, 0x118b, buf, 1); /* URB 2124 */
2623
2624 buf[0] = 0x07;
2625 usb_microdia_control_write(dev, 0x10f7, buf, 1); /* URB 2135 */
2626
2627 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
2628 buf[0] = 0x01;
2629 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
2630 buf[0] = 0x14;
2631 usb_microdia_control_write(dev, 0x10f8, buf, 1); /* URB 2138 */
2632
2633 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
2634 buf[0] = 0x0a;
2635 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
2636 buf[0] = 0xff;
2637 usb_microdia_control_write(dev, 0x10fa, buf, 1); /* URB 2139 */
2638
2639 buf[0] = 0x00;
2640 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2140 */
2641 buf[0] = 0x00;
2642 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2141 */
2643 buf[0] = 0x0a;
2644 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2142 */
2645 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
2646 usb_microdia_control_write(dev, 0x11bc, buf, 4); /* URB 2143 */
2647 for (k = 0; k < 48; k++)
2648 buf[k] = 0x00;
2649 usb_microdia_control_write(dev, 0x11c0, buf, 48); /* URB 2144 */
2650
2651 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
2652 buf[4] = 0x04; buf[5] = 0x3f;
2653 usb_microdia_control_write(dev, 0x11a5, buf, 6); /* URB 2149 */
2654
2655 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2656 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
2657 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2658 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
2659 }
2660 usb_microdia_control_write(dev, 0x11af, buf, 4); /* URB 2150 */
2661
2662 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
2663 usb_microdia_control_write(dev, 0x11b3, buf, 4); /* URB 2151 */
2664 buf[0] = 0x47; /* ALEX: 0x04 */
2665 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2152 */
2666 buf[0] = 0x01;
2667 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2153 */
2668 buf[0] = 0x67; /* ALEX: 0x24 */
2669 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2154 */
2670 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
2671 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
2672 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
2673 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
2674 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
2675 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
2676 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
2677 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
2678 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
2679 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
2680 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
2681 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
2682 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
2683 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
2684 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
2685 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
2686 usb_microdia_control_write(dev, 0x1100, buf, 64); /* URB 2155 */
2687 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
2688 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
2689 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
2690 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
2691 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
2692 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
2693 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
2694 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
2695 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
2696 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
2697 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
2698 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
2699 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
2700 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
2701 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
2702 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
2703 usb_microdia_control_write(dev, 0x1140, buf, 64); /* URB 2156 */
2704 buf[0] = 0x47; /* ALEX: 0x04 */
2705 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2157 */
2706 buf[0] = 0x03;
2707 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2158 */
2708 buf[0] = 0x4b; /* ALEX: 0x08 */
2709 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2159 */
2710
2711 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2712 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2713 /* I2C MESSAGES */
2714 retI2C = 0;
2715 /* Writes to sensor registers 0x02: Column Start */
2716 /* 0x03: Window Hight */
2717 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
2718 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
2719 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2160-2162 */
2720 /* Writes to sensor registers 0x04: Window Width */
2721 /* 0x05: Horizontal Blanking */
2722 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
2723 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) */
2724 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2163-2165 */
2725 /* Writes to sensor registers 0x06: Vertical Blanking */
2726 /* 0x07: Output Control */
2727 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
2728 buf[2] = 0x30; buf[3] = 0x02; /* RESERVED options */
2729 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2166-2167 */
2730 /* Writes to sensor register 0x0e: UNDOCUMENTED */
2731 buf[0] = 0x00; buf[1] = 0x08;
2732 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2168-2170 */
2733 if (retI2C < 0) {
2734 UDIA_INFO("1 or more errors occured in I2C-message-block 6 !\n");
2735 return -1;
2736 }
2737 /* END OF I2C MESSAGES */
2738 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2739 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2740 buf[0] = 0x40;
2741 usb_microdia_control_write(dev, 0x1007, buf, 1);
2742 buf[0] = 0x40;
2743 usb_microdia_control_write(dev, 0x1006, buf, 1);
2744 }
2745
2746
2747 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
2748 buf[4] = 0x28; buf[5] = 0x3c;
2749 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2171 */
2750 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
2751 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2174 */
2752 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
2753 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2175 */
2754 buf[0] = 0x03;
2755 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2176 */
2756 buf[0] = 0x0a;
2757 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2177 */
2758 buf[0] = 0x00;
2759 usb_microdia_control_write(dev, 0x11b9, buf, 1); /* URB 2178 */
2760 buf[0] = 0x0b;
2761 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2179 */
2762 buf[0] = 0x01;
2763 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2180 */
2764 buf[0] = 0x78; /* ALEX: 0x7c */
2765 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2181 */
2766 buf[0] = 0x18; /* ALEX: 0x1c */
2767 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2182 */
2768 buf[0] = 0x18; /* ALEX: 0x1c */
2769 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2183 */
2770 buf[0] = 0x7d; /* ALEX: 0xfc */
2771 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2184 */
2772 buf[0] = 0x04;
2773 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2185 */
2774 buf[0] = 0x04;
2775 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2186 */
2776
2777 if ((last_11b8[0] == 0x3d) || (last_11b8[0] == 0x3f))
2778 buf[0] = 0x78;
2779 else if ((last_11b8[0] == 0xbd) || (last_11b8[0] == 0xbf))
2780 buf[0] = 0xf8;
2781 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2187 */
2782 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2188 // 0x38 */
2783 if (buf[0] == 0x38)
2784 buf[0] = 0x79;
2785 else if (buf[0] == 0xb8)
2786 buf[0] = 0xf9;
2787 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2189 */
2788 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2190 // 0xb9 */
2789 if (buf[0] == 0x39)
2790 buf[0] = 0x7a;
2791 else if (buf[0] == 0xb9)
2792 buf[0] = 0xfa;
2793 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2191 */
2794 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2192 // 0xba */
2795 if (buf[0] == 0x3a)
2796 buf[0] = 0x7b;
2797 else if (buf[0] == 0xba)
2798 buf[0] = 0xfb;
2799 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2193 */
2800 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2194 // 0x3b */
2801 if (buf[0] == 0x3b)
2802 buf[0] = 0x7c;
2803 else if (buf[0] == 0xbb)
2804 buf[0] = 0xfc;
2805 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2195 */
2806 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2196 // 0x3c */
2807 if (buf[0] == 0x3c)
2808 buf[0] = 0x7d;
2809 else if (buf[0] == 0xbc)
2810 buf[0] = 0xfd;
2811 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2197 */
2812 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2198 // 0x3d */
2813 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2814 if (buf[0] == 0x3d)
2815 buf[0] = 0x7e;
2816 else if (buf[0] == 0xbd)
2817 buf[0] = 0xfe;
2818 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2199 */
2819 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2200 */
2820 if (buf[0] == 0x3e)
2821 buf[0] = 0x7f;
2822 else if (buf[0] == 0xbe)
2823 buf[0] = 0xff;
2824 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2201 */
2825 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2202 */
2826 }
2827 buf[0] = buf[0] & 0xf0; /* 0xf0 or 0x70 */
2828 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
2829 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
2830
2831 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2832 /* I2C MESSAGES */
2833 retI2C = 0;
2834 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2835 /* Write to sensor register 0x06: Vertical Blanking */
2836 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
2837 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2204-2206 */
2838 /* Write to sensor register 0x05: Horizontal Blanking */
2839 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
2840 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2207-2209 */
2841 /* Read of sensor register 0x36: Chip Version (mirror of reg0xff) */
2842 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x36, dev->sensor_flags, buf); /* URBs 2211-2215 // 0x82 0x3a */
2843 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
2844 /* Write to sensor register 0x0a: Pixel Clock Speed */
2845 buf[0] = 0x00; buf[1] = 0x00; /* default */
2846 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
2847 /* Write to sensor register 0x06: Vertical Blanking */
2848 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
2849 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
2850 /* Write to sensor register 0x05: Horizontal Blanking */
2851 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
2852 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
2853 /* Read of sensor register 0x00: Chip Version (=reg0xff) */
2854 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x00, dev->sensor_flags, buf); /* 0x82 0x43 */
2855 }
2856 if (retI2C < 0) {
2857 UDIA_INFO("1 or more errors occured in I2C-message-block 7 !\n");
2858 return -1;
2859 }
2860 /* END OF I2C MESSAGES */
2861 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
2862
2863
2864 buf[0] = 0x03;
2865 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2216 */
2866
2867
2868 /*** NOW DRIVER DOES STOP-SEQUENCE
2869 - WITHOUT WRITES TO 0x1007 AND 0x1006 (URBs 3544-3550) => MT9V111
2870 - WRITING 0x40 INSTEAD OF 0x60 TO 0x1007 AND 0x1006 => MT9V011
2871 ***/
2872 /*** 2nd, 3rd, ... CYCLE: ALL MESSAGES (URBs 1953 - URBs 2216) ARE REPEATED ***/
2873 /*** ----- WE DON'T DO THIS, IT SEEMS TO BE UNNECESSARY ----- ***/
2874
2875 /* Setup IFP registers for AE and AWB (new, not in the logs): */
2876 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
2877 mt9v111_setup_autoexposure(dev);
2878 mt9v111_setup_autowhitebalance(dev);
2879 mt9v111_set_autocorrections(dev, 1);
2880 }
2881
2882 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
2883 buf[0] = 0x20;
2884 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
2885 buf[0] = 0x60;
2886 usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 2489 */
2887 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
2888 buf[0] = 0x00;
2889 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
2890 buf[0] = 0x40;
2891 usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 2490 */
2892 /* => These two writes seem to cause the cam to start sending isochronus USB messages */
2893
2894 return 0;
2895 }
2896
2897 /**
2898 * @brief Start stream from 627b devices
2899 *
2900 * @param dev
2901 *
2902 * @returns 0 or negative error code
2903 *
2904 */
2905 int microdia_627b_start_stream(struct usb_microdia *dev)
2906 {
2907 int ret;
2908 /* Initialize the Bridge Controller */
2909 ret = sn9c20x_initialize(dev);
2910 /* Initialize the I2C interface in the Bridge */
2911 ret = sn9c20x_i2c_initialize(dev);
2912 /* Finally, Initialize the Sensor array */
2913 if (dev->sensor_init)
2914 dev->sensor_init(dev);
2915 return ret;
2916 }
2917
2918 /**
2919 * @brief From UsbSnoop-plugin-parsed.log
2920 *
2921 * @param dev
2922 *
2923 * @returns 0 (OK) or <0 (Error)
2924 *
2925 * @author Vincent, Kuzja
2926 */
2927 int microdia_6288_start_stream(struct usb_microdia *dev)
2928 {
2929 int ret;
2930 __u16 reg;
2931 __u8 buf[64];
2932
2933
2934
2935 reg = 0x1066 ;
2936 buf[0] = 0x00;
2937 ret = usb_microdia_control_write(dev, reg, buf, 1);
2938 if (ret < 0)
2939 goto err;
2940
2941 reg = 0x1000 ;
2942 buf[0] = 0x78;
2943 ret = usb_microdia_control_write(dev, reg, buf, 1);
2944 if (ret < 0)
2945 goto err;
2946
2947 reg = 0x1001 ;
2948 buf[0] = 0xc7;
2949 ret = usb_microdia_control_write(dev, reg, buf, 1);
2950 if (ret < 0)
2951 goto err;
2952
2953 reg = 0x1002 ;
2954 buf[0] = 0x1c;
2955 ret = usb_microdia_control_write(dev, reg, buf, 1);
2956 if (ret < 0)
2957 goto err;
2958
2959 reg = 0x1061 ;
2960 buf[0] = 0x01;
2961 ret = usb_microdia_control_write(dev, reg, buf, 1);
2962 if (ret < 0)
2963 goto err;
2964
2965 reg = 0x1020 ;
2966 buf[0] = 0x80;
2967 ret = usb_microdia_control_write(dev, reg, buf, 1);
2968 if (ret < 0)
2969 goto err;
2970
2971 reg = 0x1067 ;
2972 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
2973 buf[3] = 0x10; buf[4] = 0x08;
2974 ret = usb_microdia_control_write(dev, reg, buf, 5);
2975 if (ret < 0)
2976 goto err;
2977
2978 reg = 0x10c0 ;
2979 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;
2980 ret = usb_microdia_control_write(dev, reg, buf, 9);
2981 if (ret < 0)
2982 goto err;
2983
2984 reg = 0x10e0 ;
2985 buf[0] = 0x44; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
2986 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
2987 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
2988 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
2989 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
2990 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
2991 ret = usb_microdia_control_write(dev, reg, buf, 24);
2992 if (ret < 0)
2993 goto err;
2994
2995 reg = 0x10f8 ;
2996 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
2997 ret = usb_microdia_control_write(dev, reg, buf, 3);
2998 if (ret < 0)
2999 goto err;
3000
3001 reg = 0x1188 ;
3002 buf[0] = 0x86;
3003 ret = usb_microdia_control_write(dev, reg, buf, 1);
3004 if (ret < 0)
3005 goto err;
3006
3007 reg = 0x118a ;
3008 buf[0] = 0x08;
3009 ret = usb_microdia_control_write(dev, reg, buf, 1);
3010 if (ret < 0)
3011 goto err;
3012
3013 reg = 0x118b ;
3014 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
3015 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
3016 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
3017 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
3018 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
3019 buf[20] = 0xf4; buf[21] = 0xff;
3020 ret = usb_microdia_control_write(dev, reg, buf, 22);
3021 if (ret < 0)
3022 goto err;
3023
3024 reg = 0x11a1 ;
3025 buf[0] = 0x00; buf[1] = 0x00;
3026 ret = usb_microdia_control_write(dev, reg, buf, 2);
3027 if (ret < 0)
3028 goto err;
3029
3030 reg = 0x11b7 ;
3031 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x08;
3032 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
3033 buf[8] = 0x00;
3034 ret = usb_microdia_control_write(dev, reg, buf, 9);
3035 if (ret < 0)
3036 goto err;
3037
3038 reg = 0x11b8 ;
3039 buf[0] = 0x30;
3040 ret = usb_microdia_control_write(dev, reg, buf, 1);
3041 if (ret < 0)
3042 goto err;
3043
3044 reg = 0x1000 ;
3045 buf[0] = 0x78;
3046 ret = usb_microdia_control_write(dev, reg, buf, 1);
3047 if (ret < 0)
3048 goto err;
3049
3050 reg = 0x10c0 ;
3051 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3052 ret = usb_microdia_control_write(dev, reg, buf, 8);
3053 if (ret < 0)
3054 goto err;
3055
3056 reg = 0x10c0 ;
3057 ret = usb_microdia_control_read(dev, reg, buf, 1);
3058 if (ret < 0)
3059 goto err;
3060
3061 reg = 0x10c0 ;
3062 ret = usb_microdia_control_read(dev, reg, buf, 1);
3063 if (ret < 0)
3064 goto err;
3065
3066 reg = 0x10c0 ;
3067 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3068 ret = usb_microdia_control_write(dev, reg, buf, 8);
3069 if (ret < 0)
3070 goto err;
3071
3072 reg = 0x10c0 ;
3073 ret = usb_microdia_control_read(dev, reg, buf, 1);
3074 if (ret < 0)
3075 goto err;
3076
3077 reg = 0x10c0 ;
3078 ret = usb_microdia_control_read(dev, reg, buf, 1);
3079 if (ret < 0)
3080 goto err;
3081
3082 reg = 0x10c0 ;
3083 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3084 ret = usb_microdia_control_write(dev, reg, buf, 8);
3085 if (ret < 0)
3086 goto err;
3087
3088 reg = 0x10c0 ;
3089 ret = usb_microdia_control_read(dev, reg, buf, 1);
3090 if (ret < 0)
3091 goto err;
3092
3093 reg = 0x10c0 ;
3094 ret = usb_microdia_control_read(dev, reg, buf, 1);
3095 if (ret < 0)
3096 goto err;
3097
3098 reg = 0x10c0 ;
3099 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0e; buf[3] = 0x61; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3100 ret = usb_microdia_control_write(dev, reg, buf, 8);
3101 if (ret < 0)
3102 goto err;
3103
3104 reg = 0x10c0 ;
3105 ret = usb_microdia_control_read(dev, reg, buf, 1);
3106 if (ret < 0)
3107 goto err;
3108
3109 reg = 0x10c0 ;
3110 ret = usb_microdia_control_read(dev, reg, buf, 1);
3111 if (ret < 0)
3112 goto err;
3113
3114 reg = 0x10c0 ;
3115 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3116 ret = usb_microdia_control_write(dev, reg, buf, 8);
3117 if (ret < 0)
3118 goto err;
3119
3120 reg = 0x10c0 ;
3121 ret = usb_microdia_control_read(dev, reg, buf, 1);
3122 if (ret < 0)
3123 goto err;
3124
3125 reg = 0x10c0 ;
3126 ret = usb_microdia_control_read(dev, reg, buf, 1);
3127 if (ret < 0)
3128 goto err;
3129
3130 reg = 0x10c0 ;
3131 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x13; buf[3] = 0xb8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3132 ret = usb_microdia_control_write(dev, reg, buf, 8);
3133 if (ret < 0)
3134 goto err;
3135
3136 reg = 0x10c0 ;
3137 ret = usb_microdia_control_read(dev, reg, buf, 1);
3138 if (ret < 0)
3139 goto err;
3140
3141 reg = 0x10c0 ;
3142 ret = usb_microdia_control_read(dev, reg, buf, 1);
3143 if (ret < 0)
3144 goto err;
3145
3146 reg = 0x10c0 ;
3147 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x14; buf[3] = 0x3e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3148 ret = usb_microdia_control_write(dev, reg, buf, 8);
3149 if (ret < 0)
3150 goto err;
3151
3152 reg = 0x10c0 ;
3153 ret = usb_microdia_control_read(dev, reg, buf, 1);
3154 if (ret < 0)
3155 goto err;
3156
3157 reg = 0x10c0 ;
3158 ret = usb_microdia_control_read(dev, reg, buf, 1);
3159 if (ret < 0)
3160 goto err;
3161
3162 reg = 0x10c0 ;
3163 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x16; buf[3] = 0x24; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3164 ret = usb_microdia_control_write(dev, reg, buf, 8);
3165 if (ret < 0)
3166 goto err;
3167
3168 reg = 0x10c0 ;
3169 ret = usb_microdia_control_read(dev, reg, buf, 1);
3170 if (ret < 0)
3171 goto err;
3172
3173 reg = 0x10c0 ;
3174 ret = usb_microdia_control_read(dev, reg, buf, 1);
3175 if (ret < 0)
3176 goto err;
3177
3178 reg = 0x10c0 ;
3179 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3180 ret = usb_microdia_control_write(dev, reg, buf, 8);
3181 if (ret < 0)
3182 goto err;
3183
3184 reg = 0x10c0 ;
3185 ret = usb_microdia_control_read(dev, reg, buf, 1);
3186 if (ret < 0)
3187 goto err;
3188
3189 reg = 0x10c0 ;
3190 ret = usb_microdia_control_read(dev, reg, buf, 1);
3191 if (ret < 0)
3192 goto err;
3193
3194 reg = 0x10c0 ;
3195 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3196 ret = usb_microdia_control_write(dev, reg, buf, 8);
3197 if (ret < 0)
3198 goto err;
3199
3200 reg = 0x10c0 ;
3201 ret = usb_microdia_control_read(dev, reg, buf, 1);
3202 if (ret < 0)
3203 goto err;
3204
3205 reg = 0x10c0 ;
3206 ret = usb_microdia_control_read(dev, reg, buf, 1);
3207 if (ret < 0)
3208 goto err;
3209
3210 reg = 0x10c0 ;
3211 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3212 ret = usb_microdia_control_write(dev, reg, buf, 8);
3213 if (ret < 0)
3214 goto err;
3215
3216 reg = 0x10c0 ;
3217 ret = usb_microdia_control_read(dev, reg, buf, 1);
3218 if (ret < 0)
3219 goto err;
3220
3221 reg = 0x10c0 ;
3222 ret = usb_microdia_control_read(dev, reg, buf, 1);
3223 if (ret < 0)
3224 goto err;
3225
3226 reg = 0x10c0 ;
3227 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x27; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3228 ret = usb_microdia_control_write(dev, reg, buf, 8);
3229 if (ret < 0)
3230 goto err;
3231
3232 reg = 0x10c0 ;
3233 ret = usb_microdia_control_read(dev, reg, buf, 1);
3234 if (ret < 0)
3235 goto err;
3236
3237 reg = 0x10c0 ;
3238 ret = usb_microdia_control_read(dev, reg, buf, 1);
3239 if (ret < 0)
3240 goto err;
3241
3242 reg = 0x10c0 ;
3243 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x28; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3244 ret = usb_microdia_control_write(dev, reg, buf, 8);
3245 if (ret < 0)
3246 goto err;
3247
3248 reg = 0x10c0 ;
3249 ret = usb_microdia_control_read(dev, reg, buf, 1);
3250 if (ret < 0)
3251 goto err;
3252
3253 reg = 0x10c0 ;
3254 ret = usb_microdia_control_read(dev, reg, buf, 1);
3255 if (ret < 0)
3256 goto err;
3257
3258 reg = 0x10c0 ;
3259 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x29; buf[3] = 0x15; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3260 ret = usb_microdia_control_write(dev, reg, buf, 8);
3261 if (ret < 0)
3262 goto err;
3263
3264 reg = 0x10c0 ;
3265 ret = usb_microdia_control_read(dev, reg, buf, 1);
3266 if (ret < 0)
3267 goto err;
3268
3269 reg = 0x10c0 ;
3270 ret = usb_microdia_control_read(dev, reg, buf, 1);
3271 if (ret < 0)
3272 goto err;
3273
3274 reg = 0x10c0 ;
3275 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2c; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3276 ret = usb_microdia_control_write(dev, reg, buf, 8);
3277 if (ret < 0)
3278 goto err;
3279
3280 reg = 0x10c0 ;
3281 ret = usb_microdia_control_read(dev, reg, buf, 1);
3282 if (ret < 0)
3283 goto err;
3284
3285 reg = 0x10c0 ;
3286 ret = usb_microdia_control_read(dev, reg, buf, 1);
3287 if (ret < 0)
3288 goto err;
3289
3290 reg = 0x10c0 ;
3291 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3292 ret = usb_microdia_control_write(dev, reg, buf, 8);
3293 if (ret < 0)
3294 goto err;
3295
3296 reg = 0x10c0 ;
3297 ret = usb_microdia_control_read(dev, reg, buf, 1);
3298 if (ret < 0)
3299 goto err;
3300
3301 reg = 0x10c0 ;
3302 ret = usb_microdia_control_read(dev, reg, buf, 1);
3303 if (ret < 0)
3304 goto err;
3305
3306 reg = 0x10c0 ;
3307 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x34; buf[3] = 0x3d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3308 ret = usb_microdia_control_write(dev, reg, buf, 8);
3309 if (ret < 0)
3310 goto err;
3311
3312 reg = 0x10c0 ;
3313 ret = usb_microdia_control_read(dev, reg, buf, 1);
3314 if (ret < 0)
3315 goto err;
3316
3317 reg = 0x10c0 ;
3318 ret = usb_microdia_control_read(dev, reg, buf, 1);
3319 if (ret < 0)
3320 goto err;
3321
3322 reg = 0x10c0 ;
3323 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x35; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3324 ret = usb_microdia_control_write(dev, reg, buf, 8);
3325 if (ret < 0)
3326 goto err;
3327
3328 reg = 0x10c0 ;
3329 ret = usb_microdia_control_read(dev, reg, buf, 1);
3330 if (ret < 0)
3331 goto err;
3332
3333 reg = 0x10c0 ;
3334 ret = usb_microdia_control_read(dev, reg, buf, 1);
3335 if (ret < 0)
3336 goto err;
3337
3338 reg = 0x10c0 ;
3339 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x36; buf[3] = 0xf8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3340 ret = usb_microdia_control_write(dev, reg, buf, 8);
3341 if (ret < 0)
3342 goto err;
3343
3344 reg = 0x10c0 ;
3345 ret = usb_microdia_control_read(dev, reg, buf, 1);
3346 if (ret < 0)
3347 goto err;
3348
3349 reg = 0x10c0 ;
3350 ret = usb_microdia_control_read(dev, reg, buf, 1);
3351 if (ret < 0)
3352 goto err;
3353
3354 reg = 0x10c0 ;
3355 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x38; buf[3] = 0x12; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3356 ret = usb_microdia_control_write(dev, reg, buf, 8);
3357 if (ret < 0)
3358 goto err;
3359
3360 reg = 0x10c0 ;
3361 ret = usb_microdia_control_read(dev, reg, buf, 1);
3362 if (ret < 0)
3363 goto err;
3364
3365 reg = 0x10c0 ;
3366 ret = usb_microdia_control_read(dev, reg, buf, 1);
3367 if (ret < 0)
3368 goto err;
3369
3370 reg = 0x10c0 ;
3371 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x39; buf[3] = 0x57; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3372 ret = usb_microdia_control_write(dev, reg, buf, 8);
3373 if (ret < 0)
3374 goto err;
3375
3376 reg = 0x10c0 ;
3377 ret = usb_microdia_control_read(dev, reg, buf, 1);
3378 if (ret < 0)
3379 goto err;
3380
3381 reg = 0x10c0 ;
3382 ret = usb_microdia_control_read(dev, reg, buf, 1);
3383 if (ret < 0)
3384 goto err;
3385
3386 reg = 0x10c0 ;
3387 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3388 ret = usb_microdia_control_write(dev, reg, buf, 8);
3389 if (ret < 0)
3390 goto err;
3391
3392 reg = 0x10c0 ;
3393 ret = usb_microdia_control_read(dev, reg, buf, 1);
3394 if (ret < 0)
3395 goto err;
3396
3397 reg = 0x10c0 ;
3398 ret = usb_microdia_control_read(dev, reg, buf, 1);
3399 if (ret < 0)
3400 goto err;
3401
3402 reg = 0x10c0 ;
3403 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3b; buf[3] = 0xcc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3404 ret = usb_microdia_control_write(dev, reg, buf, 8);
3405 if (ret < 0)
3406 goto err;
3407
3408 reg = 0x10c0 ;
3409 ret = usb_microdia_control_read(dev, reg, buf, 1);
3410 if (ret < 0)
3411 goto err;
3412
3413 reg = 0x10c0 ;
3414 ret = usb_microdia_control_read(dev, reg, buf, 1);
3415 if (ret < 0)
3416 goto err;
3417
3418 reg = 0x10c0 ;
3419 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3c; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3420 ret = usb_microdia_control_write(dev, reg, buf, 8);
3421 if (ret < 0)
3422 goto err;
3423
3424 reg = 0x10c0 ;
3425 ret = usb_microdia_control_read(dev, reg, buf, 1);
3426 if (ret < 0)
3427 goto err;
3428
3429 reg = 0x10c0 ;
3430 ret = usb_microdia_control_read(dev, reg, buf, 1);
3431 if (ret < 0)
3432 goto err;
3433
3434 reg = 0x10c0 ;
3435 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3d; buf[3] = 0x19; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3436 ret = usb_microdia_control_write(dev, reg, buf, 8);
3437 if (ret < 0)
3438 goto err;
3439
3440 reg = 0x10c0 ;
3441 ret = usb_microdia_control_read(dev, reg, buf, 1);
3442 if (ret < 0)
3443 goto err;
3444
3445 reg = 0x10c0 ;
3446 ret = usb_microdia_control_read(dev, reg, buf, 1);
3447 if (ret < 0)
3448 goto err;
3449
3450 reg = 0x10c0 ;
3451 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3e; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3452 ret = usb_microdia_control_write(dev, reg, buf, 8);
3453 if (ret < 0)
3454 goto err;
3455
3456 reg = 0x10c0 ;
3457 ret = usb_microdia_control_read(dev, reg, buf, 1);
3458 if (ret < 0)
3459 goto err;
3460
3461 reg = 0x10c0 ;
3462 ret = usb_microdia_control_read(dev, reg, buf, 1);
3463 if (ret < 0)
3464 goto err;
3465
3466 reg = 0x10c0 ;
3467 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3f; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3468 ret = usb_microdia_control_write(dev, reg, buf, 8);
3469 if (ret < 0)
3470 goto err;
3471
3472 reg = 0x10c0 ;
3473 ret = usb_microdia_control_read(dev, reg, buf, 1);
3474 if (ret < 0)
3475 goto err;
3476
3477 reg = 0x10c0 ;
3478 ret = usb_microdia_control_read(dev, reg, buf, 1);
3479 if (ret < 0)
3480 goto err;
3481
3482 reg = 0x10c0 ;
3483 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x41; buf[3] = 0x40; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3484 ret = usb_microdia_control_write(dev, reg, buf, 8);
3485 if (ret < 0)
3486 goto err;
3487
3488 reg = 0x10c0 ;
3489 ret = usb_microdia_control_read(dev, reg, buf, 1);
3490 if (ret < 0)
3491 goto err;
3492
3493 reg = 0x10c0 ;
3494 ret = usb_microdia_control_read(dev, reg, buf, 1);
3495 if (ret < 0)
3496 goto err;
3497
3498 reg = 0x10c0 ;
3499 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x42; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3500 ret = usb_microdia_control_write(dev, reg, buf, 8);
3501 if (ret < 0)
3502 goto err;
3503
3504 reg = 0x10c0 ;
3505 ret = usb_microdia_control_read(dev, reg, buf, 1);
3506 if (ret < 0)
3507 goto err;
3508
3509 reg = 0x10c0 ;
3510 ret = usb_microdia_control_read(dev, reg, buf, 1);
3511 if (ret < 0)
3512 goto err;
3513
3514 reg = 0x10c0 ;
3515 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x45; buf[3] = 0x46; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3516 ret = usb_microdia_control_write(dev, reg, buf, 8);
3517 if (ret < 0)
3518 goto err;
3519
3520 reg = 0x10c0 ;
3521 ret = usb_microdia_control_read(dev, reg, buf, 1);
3522 if (ret < 0)
3523 goto err;
3524
3525 reg = 0x10c0 ;
3526 ret = usb_microdia_control_read(dev, reg, buf, 1);
3527 if (ret < 0)
3528 goto err;
3529
3530 reg = 0x10c0 ;
3531 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x46; buf[3] = 0x62; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3532 ret = usb_microdia_control_write(dev, reg, buf, 8);
3533 if (ret < 0)
3534 goto err;
3535
3536 reg = 0x10c0 ;
3537 ret = usb_microdia_control_read(dev, reg, buf, 1);
3538 if (ret < 0)
3539 goto err;
3540
3541 reg = 0x10c0 ;
3542 ret = usb_microdia_control_read(dev, reg, buf, 1);
3543 if (ret < 0)
3544 goto err;
3545
3546 reg = 0x10c0 ;
3547 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x47; buf[3] = 0x2a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3548 ret = usb_microdia_control_write(dev, reg, buf, 8);
3549 if (ret < 0)
3550 goto err;
3551
3552 reg = 0x10c0 ;
3553 ret = usb_microdia_control_read(dev, reg, buf, 1);
3554 if (ret < 0)
3555 goto err;
3556
3557 reg = 0x10c0 ;
3558 ret = usb_microdia_control_read(dev, reg, buf, 1);
3559 if (ret < 0)
3560 goto err;
3561
3562 reg = 0x10c0 ;
3563 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x48; buf[3] = 0x3c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3564 ret = usb_microdia_control_write(dev, reg, buf, 8);
3565 if (ret < 0)
3566 goto err;
3567
3568 reg = 0x10c0 ;
3569 ret = usb_microdia_control_read(dev, reg, buf, 1);
3570 if (ret < 0)
3571 goto err;
3572
3573 reg = 0x10c0 ;
3574 ret = usb_microdia_control_read(dev, reg, buf, 1);
3575 if (ret < 0)
3576 goto err;
3577
3578 reg = 0x10c0 ;
3579 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4a; buf[3] = 0xf0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3580 ret = usb_microdia_control_write(dev, reg, buf, 8);
3581 if (ret < 0)
3582 goto err;
3583
3584 reg = 0x10c0 ;
3585 ret = usb_microdia_control_read(dev, reg, buf, 1);
3586 if (ret < 0)
3587 goto err;
3588
3589 reg = 0x10c0 ;
3590 ret = usb_microdia_control_read(dev, reg, buf, 1);
3591 if (ret < 0)
3592 goto err;
3593
3594 reg = 0x10c0 ;
3595 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4b; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3596 ret = usb_microdia_control_write(dev, reg, buf, 8);
3597 if (ret < 0)
3598 goto err;
3599
3600 reg = 0x10c0 ;
3601 ret = usb_microdia_control_read(dev, reg, buf, 1);
3602 if (ret < 0)
3603 goto err;
3604
3605 reg = 0x10c0 ;
3606 ret = usb_microdia_control_read(dev, reg, buf, 1);
3607 if (ret < 0)
3608 goto err;
3609
3610 reg = 0x10c0 ;
3611 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4c; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3612 ret = usb_microdia_control_write(dev, reg, buf, 8);
3613 if (ret < 0)
3614 goto err;
3615
3616 reg = 0x10c0 ;
3617 ret = usb_microdia_control_read(dev, reg, buf, 1);
3618 if (ret < 0)
3619 goto err;
3620
3621 reg = 0x10c0 ;
3622 ret = usb_microdia_control_read(dev, reg, buf, 1);
3623 if (ret < 0)
3624 goto err;
3625
3626 reg = 0x10c0 ;
3627 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4d; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3628 ret = usb_microdia_control_write(dev, reg, buf, 8);
3629 if (ret < 0)
3630 goto err;
3631
3632 reg = 0x10c0 ;
3633 ret = usb_microdia_control_read(dev, reg, buf, 1);
3634 if (ret < 0)
3635 goto err;
3636
3637 reg = 0x10c0 ;
3638 ret = usb_microdia_control_read(dev, reg, buf, 1);
3639 if (ret < 0)
3640 goto err;
3641
3642 reg = 0x10c0 ;
3643 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4e; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3644 ret = usb_microdia_control_write(dev, reg, buf, 8);
3645 if (ret < 0)
3646 goto err;
3647
3648 reg = 0x10c0 ;
3649 ret = usb_microdia_control_read(dev, reg, buf, 1);
3650 if (ret < 0)
3651 goto err;
3652
3653 reg = 0x10c0 ;
3654 ret = usb_microdia_control_read(dev, reg, buf, 1);
3655 if (ret < 0)
3656 goto err;
3657
3658 reg = 0x10c0 ;
3659 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x69; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3660 ret = usb_microdia_control_write(dev, reg, buf, 8);
3661 if (ret < 0)
3662 goto err;
3663
3664 reg = 0x10c0 ;
3665 ret = usb_microdia_control_read(dev, reg, buf, 1);
3666 if (ret < 0)
3667 goto err;
3668
3669 reg = 0x10c0 ;
3670 ret = usb_microdia_control_read(dev, reg, buf, 1);
3671 if (ret < 0)
3672 goto err;
3673
3674 reg = 0x10c0 ;
3675 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6c; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3676 ret = usb_microdia_control_write(dev, reg, buf, 8);
3677 if (ret < 0)
3678 goto err;
3679
3680 reg = 0x10c0 ;
3681 ret = usb_microdia_control_read(dev, reg, buf, 1);
3682 if (ret < 0)
3683 goto err;
3684
3685 reg = 0x10c0 ;
3686 ret = usb_microdia_control_read(dev, reg, buf, 1);
3687 if (ret < 0)
3688 goto err;
3689
3690 reg = 0x10c0 ;
3691 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6f; buf[3] = 0x9e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3692 ret = usb_microdia_control_write(dev, reg, buf, 8);
3693 if (ret < 0)
3694 goto err;
3695
3696 reg = 0x10c0 ;
3697 ret = usb_microdia_control_read(dev, reg, buf, 1);
3698 if (ret < 0)
3699 goto err;
3700
3701 reg = 0x10c0 ;
3702 ret = usb_microdia_control_read(dev, reg, buf, 1);
3703 if (ret < 0)
3704 goto err;
3705
3706 reg = 0x10c0 ;
3707 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x70; buf[3] = 0x05; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3708 ret = usb_microdia_control_write(dev, reg, buf, 8);
3709 if (ret < 0)
3710 goto err;
3711
3712 reg = 0x10c0 ;
3713 ret = usb_microdia_control_read(dev, reg, buf, 1);
3714 if (ret < 0)
3715 goto err;
3716
3717 reg = 0x10c0 ;
3718 ret = usb_microdia_control_read(dev, reg, buf, 1);
3719 if (ret < 0)
3720 goto err;
3721
3722 reg = 0x10c0 ;
3723 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x71; buf[3] = 0x78; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3724 ret = usb_microdia_control_write(dev, reg, buf, 8);
3725 if (ret < 0)
3726 goto err;
3727
3728 reg = 0x10c0 ;
3729 ret = usb_microdia_control_read(dev, reg, buf, 1);
3730 if (ret < 0)
3731 goto err;
3732
3733 reg = 0x10c0 ;
3734 ret = usb_microdia_control_read(dev, reg, buf, 1);
3735 if (ret < 0)
3736 goto err;
3737
3738 reg = 0x10c0 ;
3739 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x77; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3740 ret = usb_microdia_control_write(dev, reg, buf, 8);
3741 if (ret < 0)
3742 goto err;
3743
3744 reg = 0x10c0 ;
3745 ret = usb_microdia_control_read(dev, reg, buf, 1);
3746 if (ret < 0)
3747 goto err;
3748
3749 reg = 0x10c0 ;
3750 ret = usb_microdia_control_read(dev, reg, buf, 1);
3751 if (ret < 0)
3752 goto err;
3753
3754 reg = 0x10c0 ;
3755 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8a; buf[3] = 0x23; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3756 ret = usb_microdia_control_write(dev, reg, buf, 8);
3757 if (ret < 0)
3758 goto err;
3759
3760 reg = 0x10c0 ;
3761 ret = usb_microdia_control_read(dev, reg, buf, 1);
3762 if (ret < 0)
3763 goto err;
3764
3765 reg = 0x10c0 ;
3766 ret = usb_microdia_control_read(dev, reg, buf, 1);
3767 if (ret < 0)
3768 goto err;
3769
3770 reg = 0x10c0 ;
3771 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8c; buf[3] = 0x0d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3772 ret = usb_microdia_control_write(dev, reg, buf, 8);
3773 if (ret < 0)
3774 goto err;
3775
3776 reg = 0x10c0 ;
3777 ret = usb_microdia_control_read(dev, reg, buf, 1);
3778 if (ret < 0)
3779 goto err;
3780
3781 reg = 0x10c0 ;
3782 ret = usb_microdia_control_read(dev, reg, buf, 1);
3783 if (ret < 0)
3784 goto err;
3785
3786 reg = 0x10c0 ;
3787 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x90; buf[3] = 0x7e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3788 ret = usb_microdia_control_write(dev, reg, buf, 8);
3789 if (ret < 0)
3790 goto err;
3791
3792 reg = 0x10c0 ;
3793 ret = usb_microdia_control_read(dev, reg, buf, 1);
3794 if (ret < 0)
3795 goto err;
3796
3797 reg = 0x10c0 ;
3798 ret = usb_microdia_control_read(dev, reg, buf, 1);
3799 if (ret < 0)
3800 goto err;
3801
3802 reg = 0x10c0 ;
3803 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x91; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3804 ret = usb_microdia_control_write(dev, reg, buf, 8);
3805 if (ret < 0)
3806 goto err;
3807
3808 reg = 0x10c0 ;
3809 ret = usb_microdia_control_read(dev, reg, buf, 1);
3810 if (ret < 0)
3811 goto err;
3812
3813 reg = 0x10c0 ;
3814 ret = usb_microdia_control_read(dev, reg, buf, 1);
3815 if (ret < 0)
3816 goto err;
3817
3818 reg = 0x10c0 ;
3819 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x9f; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3820 ret = usb_microdia_control_write(dev, reg, buf, 8);
3821 if (ret < 0)
3822 goto err;
3823
3824 reg = 0x10c0 ;
3825 ret = usb_microdia_control_read(dev, reg, buf, 1);
3826 if (ret < 0)
3827 goto err;
3828
3829 reg = 0x10c0 ;
3830 ret = usb_microdia_control_read(dev, reg, buf, 1);
3831 if (ret < 0)
3832 goto err;
3833
3834 reg = 0x10c0 ;
3835 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa0; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3836 ret = usb_microdia_control_write(dev, reg, buf, 8);
3837 if (ret < 0)
3838 goto err;
3839
3840 reg = 0x10c0 ;
3841 ret = usb_microdia_control_read(dev, reg, buf, 1);
3842 if (ret < 0)
3843 goto err;
3844
3845 reg = 0x10c0 ;
3846 ret = usb_microdia_control_read(dev, reg, buf, 1);
3847 if (ret < 0)
3848 goto err;
3849
3850 reg = 0x10c0 ;
3851 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa4; buf[3] = 0x50; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3852 ret = usb_microdia_control_write(dev, reg, buf, 8);
3853 if (ret < 0)
3854 goto err;
3855
3856 reg = 0x10c0 ;
3857 ret = usb_microdia_control_read(dev, reg, buf, 1);
3858 if (ret < 0)
3859 goto err;
3860
3861 reg = 0x10c0 ;
3862 ret = usb_microdia_control_read(dev, reg, buf, 1);
3863 if (ret < 0)
3864 goto err;
3865
3866 reg = 0x10c0 ;
3867 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa5; buf[3] = 0x68; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3868 ret = usb_microdia_control_write(dev, reg, buf, 8);
3869 if (ret < 0)
3870 goto err;
3871
3872 reg = 0x10c0 ;
3873 ret = usb_microdia_control_read(dev, reg, buf, 1);
3874 if (ret < 0)
3875 goto err;
3876
3877 reg = 0x10c0 ;
3878 ret = usb_microdia_control_read(dev, reg, buf, 1);
3879 if (ret < 0)
3880 goto err;
3881
3882 reg = 0x10c0 ;
3883 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa6; buf[3] = 0x60; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3884 ret = usb_microdia_control_write(dev, reg, buf, 8);
3885 if (ret < 0)
3886 goto err;
3887
3888 reg = 0x10c0 ;
3889 ret = usb_microdia_control_read(dev, reg, buf, 1);
3890 if (ret < 0)
3891 goto err;
3892
3893 reg = 0x10c0 ;
3894 ret = usb_microdia_control_read(dev, reg, buf, 1);
3895 if (ret < 0)
3896 goto err;
3897
3898 reg = 0x10c0 ;
3899 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa8; buf[3] = 0xc1; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3900 ret = usb_microdia_control_write(dev, reg, buf, 8);
3901 if (ret < 0)
3902 goto err;
3903
3904 reg = 0x10c0 ;
3905 ret = usb_microdia_control_read(dev, reg, buf, 1);
3906 if (ret < 0)
3907 goto err;
3908
3909 reg = 0x10c0 ;
3910 ret = usb_microdia_control_read(dev, reg, buf, 1);
3911 if (ret < 0)
3912 goto err;
3913
3914 reg = 0x10c0 ;
3915 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa9; buf[3] = 0xfa; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3916 ret = usb_microdia_control_write(dev, reg, buf, 8);
3917 if (ret < 0)
3918 goto err;
3919
3920 reg = 0x10c0 ;
3921 ret = usb_microdia_control_read(dev, reg, buf, 1);
3922 if (ret < 0)
3923 goto err;
3924
3925 reg = 0x10c0 ;
3926 ret = usb_microdia_control_read(dev, reg, buf, 1);
3927 if (ret < 0)
3928 goto err;
3929
3930 reg = 0x10c0 ;
3931 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaa; buf[3] = 0x92; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3932 ret = usb_microdia_control_write(dev, reg, buf, 8);
3933 if (ret < 0)
3934 goto err;
3935
3936 reg = 0x10c0 ;
3937 ret = usb_microdia_control_read(dev, reg, buf, 1);
3938 if (ret < 0)
3939 goto err;
3940
3941 reg = 0x10c0 ;
3942 ret = usb_microdia_control_read(dev, reg, buf, 1);
3943 if (ret < 0)
3944 goto err;
3945
3946 reg = 0x10c0 ;
3947 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xab; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3948 ret = usb_microdia_control_write(dev, reg, buf, 8);
3949 if (ret < 0)
3950 goto err;
3951
3952 reg = 0x10c0 ;
3953 ret = usb_microdia_control_read(dev, reg, buf, 1);
3954 if (ret < 0)
3955 goto err;
3956
3957 reg = 0x10c0 ;
3958 ret = usb_microdia_control_read(dev, reg, buf, 1);
3959 if (ret < 0)
3960 goto err;
3961
3962 reg = 0x10c0 ;
3963 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xac; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3964 ret = usb_microdia_control_write(dev, reg, buf, 8);
3965 if (ret < 0)
3966 goto err;
3967
3968 reg = 0x10c0 ;
3969 ret = usb_microdia_control_read(dev, reg, buf, 1);
3970 if (ret < 0)
3971 goto err;
3972
3973 reg = 0x10c0 ;
3974 ret = usb_microdia_control_read(dev, reg, buf, 1);
3975 if (ret < 0)
3976 goto err;
3977
3978 reg = 0x10c0 ;
3979 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xad; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3980 ret = usb_microdia_control_write(dev, reg, buf, 8);
3981 if (ret < 0)
3982 goto err;
3983
3984 reg = 0x10c0 ;
3985 ret = usb_microdia_control_read(dev, reg, buf, 1);
3986 if (ret < 0)
3987 goto err;
3988
3989 reg = 0x10c0 ;
3990 ret = usb_microdia_control_read(dev, reg, buf, 1);
3991 if (ret < 0)
3992 goto err;
3993
3994 reg = 0x10c0 ;
3995 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xae; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
3996 ret = usb_microdia_control_write(dev, reg, buf, 8);
3997 if (ret < 0)
3998 goto err;
3999
4000 reg = 0x10c0 ;
4001 ret = usb_microdia_control_read(dev, reg, buf, 1);
4002 if (ret < 0)
4003 goto err;
4004
4005 reg = 0x10c0 ;
4006 ret = usb_microdia_control_read(dev, reg, buf, 1);
4007 if (ret < 0)
4008 goto err;
4009
4010 reg = 0x10c0 ;
4011 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaf; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4012 ret = usb_microdia_control_write(dev, reg, buf, 8);
4013 if (ret < 0)
4014 goto err;
4015
4016 reg = 0x10c0 ;
4017 ret = usb_microdia_control_read(dev, reg, buf, 1);
4018 if (ret < 0)
4019 goto err;
4020
4021 reg = 0x10c0 ;
4022 ret = usb_microdia_control_read(dev, reg, buf, 1);
4023 if (ret < 0)
4024 goto err;
4025
4026 reg = 0x10c0 ;
4027 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb2; buf[3] = 0xf2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4028 ret = usb_microdia_control_write(dev, reg, buf, 8);
4029 if (ret < 0)
4030 goto err;
4031
4032 reg = 0x10c0 ;
4033 ret = usb_microdia_control_read(dev, reg, buf, 1);
4034 if (ret < 0)
4035 goto err;
4036
4037 reg = 0x10c0 ;
4038 ret = usb_microdia_control_read(dev, reg, buf, 1);
4039 if (ret < 0)
4040 goto err;
4041
4042 reg = 0x10c0 ;
4043 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb3; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4044 ret = usb_microdia_control_write(dev, reg, buf, 8);
4045 if (ret < 0)
4046 goto err;
4047
4048 reg = 0x10c0 ;
4049 ret = usb_microdia_control_read(dev, reg, buf, 1);
4050 if (ret < 0)
4051 goto err;
4052
4053 reg = 0x10c0 ;
4054 ret = usb_microdia_control_read(dev, reg, buf, 1);
4055 if (ret < 0)
4056 goto err;
4057
4058 reg = 0x10c0 ;
4059 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb4; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4060 ret = usb_microdia_control_write(dev, reg, buf, 8);
4061 if (ret < 0)
4062 goto err;
4063
4064 reg = 0x10c0 ;
4065 ret = usb_microdia_control_read(dev, reg, buf, 1);
4066 if (ret < 0)
4067 goto err;
4068
4069 reg = 0x10c0 ;
4070 ret = usb_microdia_control_read(dev, reg, buf, 1);
4071 if (ret < 0)
4072 goto err;
4073
4074 reg = 0x10c0 ;
4075 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb5; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4076 ret = usb_microdia_control_write(dev, reg, buf, 8);
4077 if (ret < 0)
4078 goto err;
4079
4080 reg = 0x10c0 ;
4081 ret = usb_microdia_control_read(dev, reg, buf, 1);
4082 if (ret < 0)
4083 goto err;
4084
4085 reg = 0x10c0 ;
4086 ret = usb_microdia_control_read(dev, reg, buf, 1);
4087 if (ret < 0)
4088 goto err;
4089
4090 reg = 0x10c0 ;
4091 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb6; buf[3] = 0xaf; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4092 ret = usb_microdia_control_write(dev, reg, buf, 8);
4093 if (ret < 0)
4094 goto err;
4095
4096 reg = 0x10c0 ;
4097 ret = usb_microdia_control_read(dev, reg, buf, 1);
4098 if (ret < 0)
4099 goto err;
4100
4101 reg = 0x10c0 ;
4102 ret = usb_microdia_control_read(dev, reg, buf, 1);
4103 if (ret < 0)
4104 goto err;
4105
4106 reg = 0x10c0 ;
4107 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbb; buf[3] = 0xae; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4108 ret = usb_microdia_control_write(dev, reg, buf, 8);
4109 if (ret < 0)
4110 goto err;
4111
4112 reg = 0x10c0 ;
4113 ret = usb_microdia_control_read(dev, reg, buf, 1);
4114 if (ret < 0)
4115 goto err;
4116
4117 reg = 0x10c0 ;
4118 ret = usb_microdia_control_read(dev, reg, buf, 1);
4119 if (ret < 0)
4120 goto err;
4121
4122 reg = 0x10c0 ;
4123 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbc; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4124 ret = usb_microdia_control_write(dev, reg, buf, 8);
4125 if (ret < 0)
4126 goto err;
4127
4128 reg = 0x10c0 ;
4129 ret = usb_microdia_control_read(dev, reg, buf, 1);
4130 if (ret < 0)
4131 goto err;
4132
4133 reg = 0x10c0 ;
4134 ret = usb_microdia_control_read(dev, reg, buf, 1);
4135 if (ret < 0)
4136 goto err;
4137
4138 reg = 0x10c0 ;
4139 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbd; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4140 ret = usb_microdia_control_write(dev, reg, buf, 8);
4141 if (ret < 0)
4142 goto err;
4143
4144 reg = 0x10c0 ;
4145 ret = usb_microdia_control_read(dev, reg, buf, 1);
4146 if (ret < 0)
4147 goto err;
4148
4149 reg = 0x10c0 ;
4150 ret = usb_microdia_control_read(dev, reg, buf, 1);
4151 if (ret < 0)
4152 goto err;
4153
4154 reg = 0x10c0 ;
4155 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbe; buf[3] = 0x3b; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4156 ret = usb_microdia_control_write(dev, reg, buf, 8);
4157 if (ret < 0)
4158 goto err;
4159
4160 reg = 0x10c0 ;
4161 ret = usb_microdia_control_read(dev, reg, buf, 1);
4162 if (ret < 0)
4163 goto err;
4164
4165 reg = 0x10c0 ;
4166 ret = usb_microdia_control_read(dev, reg, buf, 1);
4167 if (ret < 0)
4168 goto err;
4169
4170 reg = 0x10c0 ;
4171 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbf; buf[3] = 0x3a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4172 ret = usb_microdia_control_write(dev, reg, buf, 8);
4173 if (ret < 0)
4174 goto err;
4175
4176 reg = 0x10c0 ;
4177 ret = usb_microdia_control_read(dev, reg, buf, 1);
4178 if (ret < 0)
4179 goto err;
4180
4181 reg = 0x10c0 ;
4182 ret = usb_microdia_control_read(dev, reg, buf, 1);
4183 if (ret < 0)
4184 goto err;
4185
4186 reg = 0x10c0 ;
4187 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc0; buf[3] = 0xe2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4188 ret = usb_microdia_control_write(dev, reg, buf, 8);
4189 if (ret < 0)
4190 goto err;
4191
4192 reg = 0x10c0 ;
4193 ret = usb_microdia_control_read(dev, reg, buf, 1);
4194 if (ret < 0)
4195 goto err;
4196
4197 reg = 0x10c0 ;
4198 ret = usb_microdia_control_read(dev, reg, buf, 1);
4199 if (ret < 0)
4200 goto err;
4201
4202 reg = 0x10c0 ;
4203 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc1; buf[3] = 0xc8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4204 ret = usb_microdia_control_write(dev, reg, buf, 8);
4205 if (ret < 0)
4206 goto err;
4207
4208 reg = 0x10c0 ;
4209 ret = usb_microdia_control_read(dev, reg, buf, 1);
4210 if (ret < 0)
4211 goto err;
4212
4213 reg = 0x10c0 ;
4214 ret = usb_microdia_control_read(dev, reg, buf, 1);
4215 if (ret < 0)
4216 goto err;
4217
4218 reg = 0x10c0 ;
4219 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc2; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4220 ret = usb_microdia_control_write(dev, reg, buf, 8);
4221 if (ret < 0)
4222 goto err;
4223
4224 reg = 0x10c0 ;
4225 ret = usb_microdia_control_read(dev, reg, buf, 1);
4226 if (ret < 0)
4227 goto err;
4228
4229 reg = 0x10c0 ;
4230 ret = usb_microdia_control_read(dev, reg, buf, 1);
4231 if (ret < 0)
4232 goto err;
4233
4234 reg = 0x10c0 ;
4235 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc4; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4236 ret = usb_microdia_control_write(dev, reg, buf, 8);
4237 if (ret < 0)
4238 goto err;
4239
4240 reg = 0x10c0 ;
4241 ret = usb_microdia_control_read(dev, reg, buf, 1);
4242 if (ret < 0)
4243 goto err;
4244
4245 reg = 0x10c0 ;
4246 ret = usb_microdia_control_read(dev, reg, buf, 1);
4247 if (ret < 0)
4248 goto err;
4249
4250 reg = 0x10c0 ;
4251 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc6; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4252 ret = usb_microdia_control_write(dev, reg, buf, 8);
4253 if (ret < 0)
4254 goto err;
4255
4256 reg = 0x10c0 ;
4257 ret = usb_microdia_control_read(dev, reg, buf, 1);
4258 if (ret < 0)
4259 goto err;
4260
4261 reg = 0x10c0 ;
4262 ret = usb_microdia_control_read(dev, reg, buf, 1);
4263 if (ret < 0)
4264 goto err;
4265
4266 reg = 0x10c0 ;
4267 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc7; buf[3] = 0x81; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4268 ret = usb_microdia_control_write(dev, reg, buf, 8);
4269 if (ret < 0)
4270 goto err;
4271
4272 reg = 0x10c0 ;
4273 ret = usb_microdia_control_read(dev, reg, buf, 1);
4274 if (ret < 0)
4275 goto err;
4276
4277 reg = 0x10c0 ;
4278 ret = usb_microdia_control_read(dev, reg, buf, 1);
4279 if (ret < 0)
4280 goto err;
4281
4282 reg = 0x10c0 ;
4283 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc9; buf[3] = 0xe0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4284 ret = usb_microdia_control_write(dev, reg, buf, 8);
4285 if (ret < 0)
4286 goto err;
4287
4288 reg = 0x10c0 ;
4289 ret = usb_microdia_control_read(dev, reg, buf, 1);
4290 if (ret < 0)
4291 goto err;
4292
4293 reg = 0x10c0 ;
4294 ret = usb_microdia_control_read(dev, reg, buf, 1);
4295 if (ret < 0)
4296 goto err;
4297
4298 reg = 0x10c0 ;
4299 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xca; buf[3] = 0xe8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4300 ret = usb_microdia_control_write(dev, reg, buf, 8);
4301 if (ret < 0)
4302 goto err;
4303
4304 reg = 0x10c0 ;
4305 ret = usb_microdia_control_read(dev, reg, buf, 1);
4306 if (ret < 0)
4307 goto err;
4308
4309 reg = 0x10c0 ;
4310 ret = usb_microdia_control_read(dev, reg, buf, 1);
4311 if (ret < 0)
4312 goto err;
4313
4314 reg = 0x10c0 ;
4315 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcc; buf[3] = 0xd8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4316 ret = usb_microdia_control_write(dev, reg, buf, 8);
4317 if (ret < 0)
4318 goto err;
4319
4320 reg = 0x10c0 ;
4321 ret = usb_microdia_control_read(dev, reg, buf, 1);
4322 if (ret < 0)
4323 goto err;
4324
4325 reg = 0x10c0 ;
4326 ret = usb_microdia_control_read(dev, reg, buf, 1);
4327 if (ret < 0)
4328 goto err;
4329
4330 reg = 0x10c0 ;
4331 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcd; buf[3] = 0x93; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4332 ret = usb_microdia_control_write(dev, reg, buf, 8);
4333 if (ret < 0)
4334 goto err;
4335
4336 reg = 0x10c0 ;
4337 ret = usb_microdia_control_read(dev, reg, buf, 1);
4338 if (ret < 0)
4339 goto err;
4340
4341 reg = 0x10c0 ;
4342 ret = usb_microdia_control_read(dev, reg, buf, 1);
4343 if (ret < 0)
4344 goto err;
4345
4346 reg = 0x10c1 ;
4347 ret = usb_microdia_control_read(dev, reg, buf, 1);
4348 if (ret < 0)
4349 goto err;
4350
4351 reg = 0x10c1 ;
4352 buf[0] = 0x50;
4353 ret = usb_microdia_control_write(dev, reg, buf, 1);
4354 if (ret < 0)
4355 goto err;
4356
4357 reg = 0x10c0 ;
4358 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4359 ret = usb_microdia_control_write(dev, reg, buf, 8);
4360 if (ret < 0)
4361 goto err;
4362
4363 reg = 0x10c0 ;
4364 ret = usb_microdia_control_read(dev, reg, buf, 1);
4365 if (ret < 0)
4366 goto err;
4367
4368 reg = 0x10c0 ;
4369 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4370 ret = usb_microdia_control_write(dev, reg, buf, 8);
4371 if (ret < 0)
4372 goto err;
4373
4374 reg = 0x10c0 ;
4375 ret = usb_microdia_control_read(dev, reg, buf, 1);
4376 if (ret < 0)
4377 goto err;
4378
4379 reg = 0x10c0 ;
4380 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4381 ret = usb_microdia_control_write(dev, reg, buf, 8);
4382 if (ret < 0)
4383 goto err;
4384
4385 reg = 0x10c0 ;
4386 ret = usb_microdia_control_read(dev, reg, buf, 1);
4387 if (ret < 0)
4388 goto err;
4389
4390 reg = 0x10c0 ;
4391 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4392 ret = usb_microdia_control_write(dev, reg, buf, 8);
4393 if (ret < 0)
4394 goto err;
4395
4396 reg = 0x10c0 ;
4397 ret = usb_microdia_control_read(dev, reg, buf, 1);
4398 if (ret < 0)
4399 goto err;
4400
4401 reg = 0x10c0 ;
4402 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4403 ret = usb_microdia_control_write(dev, reg, buf, 8);
4404 if (ret < 0)
4405 goto err;
4406
4407 reg = 0x10c0 ;
4408 ret = usb_microdia_control_read(dev, reg, buf, 1);
4409 if (ret < 0)
4410 goto err;
4411
4412 reg = 0x10c0 ;
4413 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4414 ret = usb_microdia_control_write(dev, reg, buf, 8);
4415 if (ret < 0)
4416 goto err;
4417
4418 reg = 0x10c0 ;
4419 ret = usb_microdia_control_read(dev, reg, buf, 1);
4420 if (ret < 0)
4421 goto err;
4422
4423 reg = 0x10c0 ;
4424 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4425 ret = usb_microdia_control_write(dev, reg, buf, 8);
4426 if (ret < 0)
4427 goto err;
4428
4429 reg = 0x10c0 ;
4430 ret = usb_microdia_control_read(dev, reg, buf, 1);
4431 if (ret < 0)
4432 goto err;
4433
4434 reg = 0x10c0 ;
4435 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4436 ret = usb_microdia_control_write(dev, reg, buf, 8);
4437 if (ret < 0)
4438 goto err;
4439
4440 reg = 0x10c0 ;
4441 ret = usb_microdia_control_read(dev, reg, buf, 1);
4442 if (ret < 0)
4443 goto err;
4444
4445 reg = 0x10c0 ;
4446 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4447 ret = usb_microdia_control_write(dev, reg, buf, 8);
4448 if (ret < 0)
4449 goto err;
4450
4451 reg = 0x10c0 ;
4452 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4453 ret = usb_microdia_control_write(dev, reg, buf, 8);
4454 if (ret < 0)
4455 goto err;
4456
4457 reg = 0x10c0 ;
4458 ret = usb_microdia_control_read(dev, reg, buf, 1);
4459 if (ret < 0)
4460 goto err;
4461
4462 reg = 0x10c0 ;
4463 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4464 ret = usb_microdia_control_write(dev, reg, buf, 8);
4465 if (ret < 0)
4466 goto err;
4467
4468 reg = 0x10c0 ;
4469 ret = usb_microdia_control_read(dev, reg, buf, 1);
4470 if (ret < 0)
4471 goto err;
4472
4473 reg = 0x10c0 ;
4474 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4475 ret = usb_microdia_control_write(dev, reg, buf, 8);
4476 if (ret < 0)
4477 goto err;
4478
4479 reg = 0x10c0 ;
4480 ret = usb_microdia_control_read(dev, reg, buf, 1);
4481 if (ret < 0)
4482 goto err;
4483
4484 reg = 0x10c0 ;
4485 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4486 ret = usb_microdia_control_write(dev, reg, buf, 8);
4487 if (ret < 0)
4488 goto err;
4489
4490 reg = 0x10c0 ;
4491 ret = usb_microdia_control_read(dev, reg, buf, 1);
4492 if (ret < 0)
4493 goto err;
4494
4495 reg = 0x10c0 ;
4496 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4497 ret = usb_microdia_control_write(dev, reg, buf, 8);
4498 if (ret < 0)
4499 goto err;
4500
4501 reg = 0x10c0 ;
4502 ret = usb_microdia_control_read(dev, reg, buf, 1);
4503 if (ret < 0)
4504 goto err;
4505
4506 reg = 0x10c0 ;
4507 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4508 ret = usb_microdia_control_write(dev, reg, buf, 8);
4509 if (ret < 0)
4510 goto err;
4511
4512 reg = 0x10c0 ;
4513 ret = usb_microdia_control_read(dev, reg, buf, 1);
4514 if (ret < 0)
4515 goto err;
4516
4517 reg = 0x10c0 ;
4518 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4519 ret = usb_microdia_control_write(dev, reg, buf, 8);
4520 if (ret < 0)
4521 goto err;
4522
4523 reg = 0x10c0 ;
4524 ret = usb_microdia_control_read(dev, reg, buf, 1);
4525 if (ret < 0)
4526 goto err;
4527
4528 reg = 0x10c0 ;
4529 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4530 ret = usb_microdia_control_write(dev, reg, buf, 8);
4531 if (ret < 0)
4532 goto err;
4533
4534 reg = 0x10c0 ;
4535 ret = usb_microdia_control_read(dev, reg, buf, 1);
4536 if (ret < 0)
4537 goto err;
4538
4539 reg = 0x10c0 ;
4540 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4541 ret = usb_microdia_control_write(dev, reg, buf, 8);
4542 if (ret < 0)
4543 goto err;
4544
4545 reg = 0x10c2 ;
4546 ret = usb_microdia_control_read(dev, reg, buf, 5);
4547 if (ret < 0)
4548 goto err;
4549
4550 reg = 0x10c1 ;
4551 buf[0] = 0x30;
4552 ret = usb_microdia_control_write(dev, reg, buf, 1);
4553 if (ret < 0)
4554 goto err;
4555
4556 reg = 0x10e0 ;
4557 buf[0] = 0x47;
4558 ret = usb_microdia_control_write(dev, reg, buf, 1);
4559 if (ret < 0)
4560 goto err;
4561
4562 reg = 0x10e0 ;
4563 buf[0] = 0x47;
4564 ret = usb_microdia_control_write(dev, reg, buf, 1);
4565 if (ret < 0)
4566 goto err;
4567
4568 reg = 0x1001 ;
4569 buf[0] = 0xc6;
4570 ret = usb_microdia_control_write(dev, reg, buf, 1);
4571 if (ret < 0)
4572 goto err;
4573
4574 reg = 0x1001 ;
4575 buf[0] = 0xc4;
4576 ret = usb_microdia_control_write(dev, reg, buf, 1);
4577 if (ret < 0)
4578 goto err;
4579
4580 reg = 0x1001 ;
4581 buf[0] = 0x84;
4582 ret = usb_microdia_control_write(dev, reg, buf, 1);
4583 if (ret < 0)
4584 goto err;
4585
4586 reg = 0x11bc ;
4587 buf[0] = 0x00;
4588 ret = usb_microdia_control_write(dev, reg, buf, 1);
4589 if (ret < 0)
4590 goto err;
4591
4592 reg = 0x11bd ;
4593 buf[0] = 0x00;
4594 ret = usb_microdia_control_write(dev, reg, buf, 1);
4595 if (ret < 0)
4596 goto err;
4597
4598 reg = 0x11be ;
4599 buf[0] = 0x00;
4600 ret = usb_microdia_control_write(dev, reg, buf, 1);
4601 if (ret < 0)
4602 goto err;
4603
4604 reg = 0x11bf ;
4605 buf[0] = 0x00;
4606 ret = usb_microdia_control_write(dev, reg, buf, 1);
4607 if (ret < 0)
4608 goto err;
4609
4610 reg = 0x10c0 ;
4611 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4612 ret = usb_microdia_control_write(dev, reg, buf, 8);
4613 if (ret < 0)
4614 goto err;
4615
4616 reg = 0x10c0 ;
4617 ret = usb_microdia_control_read(dev, reg, buf, 1);
4618 if (ret < 0)
4619 goto err;
4620
4621 reg = 0x10c0 ;
4622 ret = usb_microdia_control_read(dev, reg, buf, 1);
4623 if (ret < 0)
4624 goto err;
4625
4626 reg = 0x10c0 ;
4627 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
4628 ret = usb_microdia_control_write(dev, reg, buf, 8);
4629 if (ret < 0)
4630 goto err;
4631
4632 reg = 0x10c0 ;
4633 ret = usb_microdia_control_read(dev, reg, buf, 1);
4634 if (ret < 0)
4635 goto err;
4636
4637 reg = 0x10c0 ;
4638 ret = usb_microdia_control_read(dev, reg, buf, 1);
4639 if (ret < 0)
4640 goto err;
4641
4642 reg = 0x10c0 ;
4643 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4644 ret = usb_microdia_control_write(dev, reg, buf, 8);
4645 if (ret < 0)
4646 goto err;
4647
4648 reg = 0x10c0 ;
4649 ret = usb_microdia_control_read(dev, reg, buf, 1);
4650 if (ret < 0)
4651 goto err;
4652
4653 reg = 0x10c0 ;
4654 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4655 ret = usb_microdia_control_write(dev, reg, buf, 8);
4656 if (ret < 0)
4657 goto err;
4658
4659 reg = 0x10c0 ;
4660 ret = usb_microdia_control_read(dev, reg, buf, 1);
4661 if (ret < 0)
4662 goto err;
4663
4664 reg = 0x10c0 ;
4665 ret = usb_microdia_control_read(dev, reg, buf, 1);
4666 if (ret < 0)
4667 goto err;
4668
4669 reg = 0x1180 ;
4670 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x50; buf[5] = 0x78;
4671 ret = usb_microdia_control_write(dev, reg, buf, 6);
4672 if (ret < 0)
4673 goto err;
4674
4675 reg = 0x11a1 ;
4676 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
4677 ret = usb_microdia_control_write(dev, reg, buf, 4);
4678 if (ret < 0)
4679 goto err;
4680
4681 reg = 0x11ab ;
4682 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
4683 ret = usb_microdia_control_write(dev, reg, buf, 4);
4684 if (ret < 0)
4685 goto err;
4686
4687 reg = 0x1000 ;
4688 buf[0] = 0x78;
4689 ret = usb_microdia_control_write(dev, reg, buf, 1);
4690 if (ret < 0)
4691 goto err;
4692
4693 reg = 0x1002 ;
4694 buf[0] = 0x18;
4695 ret = usb_microdia_control_write(dev, reg, buf, 1);
4696 if (ret < 0)
4697 goto err;
4698
4699 reg = 0x1002 ;
4700 buf[0] = 0x08;
4701 ret = usb_microdia_control_write(dev, reg, buf, 1);
4702 if (ret < 0)
4703 goto err;
4704
4705 reg = 0x11b8 ;
4706 buf[0] = 0x38;
4707 ret = usb_microdia_control_write(dev, reg, buf, 1);
4708 if (ret < 0)
4709 goto err;
4710
4711 reg = 0x118a ;
4712 buf[0] = 0x02;
4713 ret = usb_microdia_control_write(dev, reg, buf, 1);
4714 if (ret < 0)
4715 goto err;
4716
4717 reg = 0x0395 ;
4718 buf[0] = 0x02;
4719 ret = usb_microdia_control_write(dev, reg, buf, 1);
4720 if (ret < 0)
4721 goto err;
4722
4723 reg = 0x11b8 ;
4724 buf[0] = 0x78;
4725 ret = usb_microdia_control_write(dev, reg, buf, 1);
4726 if (ret < 0)
4727 goto err;
4728
4729 reg = 0x11b8 ;
4730 ret = usb_microdia_control_read(dev, reg, buf, 1);
4731 if (ret < 0)
4732 goto err;
4733
4734 reg = 0x11b8 ;
4735 buf[0] = 0xf9;
4736 ret = usb_microdia_control_write(dev, reg, buf, 1);
4737 if (ret < 0)
4738 goto err;
4739
4740 reg = 0x11b8 ;
4741 ret = usb_microdia_control_read(dev, reg, buf, 1);
4742 if (ret < 0)
4743 goto err;
4744
4745 reg = 0x11b8 ;
4746 buf[0] = 0x7a;
4747 ret = usb_microdia_control_write(dev, reg, buf, 1);
4748 if (ret < 0)
4749 goto err;
4750
4751 reg = 0x11b8 ;
4752 ret = usb_microdia_control_read(dev, reg, buf, 1);
4753 if (ret < 0)
4754 goto err;
4755
4756 reg = 0x11b8 ;
4757 buf[0] = 0x7b;
4758 ret = usb_microdia_control_write(dev, reg, buf, 1);
4759 if (ret < 0)
4760 goto err;
4761
4762 reg = 0x11b8 ;
4763 ret = usb_microdia_control_read(dev, reg, buf, 1);
4764 if (ret < 0)
4765 goto err;
4766
4767 reg = 0x11b8 ;
4768 buf[0] = 0x7c;
4769 ret = usb_microdia_control_write(dev, reg, buf, 1);
4770 if (ret < 0)
4771 goto err;
4772
4773 reg = 0x11b8 ;
4774 ret = usb_microdia_control_read(dev, reg, buf, 1);
4775 if (ret < 0)
4776 goto err;
4777
4778 reg = 0x11b8 ;
4779 buf[0] = 0xfd;
4780 ret = usb_microdia_control_write(dev, reg, buf, 1);
4781 if (ret < 0)
4782 goto err;
4783
4784 reg = 0x11b8 ;
4785 ret = usb_microdia_control_read(dev, reg, buf, 1);
4786 if (ret < 0)
4787 goto err;
4788
4789 reg = 0x11b8 ;
4790 buf[0] = 0xfa;
4791 ret = usb_microdia_control_write(dev, reg, buf, 1);
4792 if (ret < 0)
4793 goto err;
4794
4795 reg = 0x10c0 ;
4796 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4797 ret = usb_microdia_control_write(dev, reg, buf, 8);
4798 if (ret < 0)
4799 goto err;
4800
4801 reg = 0x10c0 ;
4802 ret = usb_microdia_control_read(dev, reg, buf, 1);
4803 if (ret < 0)
4804 goto err;
4805
4806 reg = 0x10c0 ;
4807 ret = usb_microdia_control_read(dev, reg, buf, 1);
4808 if (ret < 0)
4809 goto err;
4810
4811 reg = 0x10c0 ;
4812 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4813 ret = usb_microdia_control_write(dev, reg, buf, 8);
4814 if (ret < 0)
4815 goto err;
4816
4817 reg = 0x10c0 ;
4818 ret = usb_microdia_control_read(dev, reg, buf, 1);
4819 if (ret < 0)
4820 goto err;
4821
4822 reg = 0x10c0 ;
4823 ret = usb_microdia_control_read(dev, reg, buf, 1);
4824 if (ret < 0)
4825 goto err;
4826
4827 reg = 0x10c0 ;
4828 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4829 ret = usb_microdia_control_write(dev, reg, buf, 8);
4830 if (ret < 0)
4831 goto err;
4832
4833 reg = 0x10c0 ;
4834 ret = usb_microdia_control_read(dev, reg, buf, 1);
4835 if (ret < 0)
4836 goto err;
4837
4838 reg = 0x10c0 ;
4839 ret = usb_microdia_control_read(dev, reg, buf, 1);
4840 if (ret < 0)
4841 goto err;
4842
4843 reg = 0x10c0 ;
4844 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4845 ret = usb_microdia_control_write(dev, reg, buf, 8);
4846 if (ret < 0)
4847 goto err;
4848
4849 reg = 0x10c0 ;
4850 ret = usb_microdia_control_read(dev, reg, buf, 1);
4851 if (ret < 0)
4852 goto err;
4853
4854 reg = 0x10c0 ;
4855 ret = usb_microdia_control_read(dev, reg, buf, 1);
4856 if (ret < 0)
4857 goto err;
4858
4859 reg = 0x10c0 ;
4860 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4861 ret = usb_microdia_control_write(dev, reg, buf, 8);
4862 if (ret < 0)
4863 goto err;
4864
4865 reg = 0x10c0 ;
4866 ret = usb_microdia_control_read(dev, reg, buf, 1);
4867 if (ret < 0)
4868 goto err;
4869
4870 reg = 0x10c0 ;
4871 ret = usb_microdia_control_read(dev, reg, buf, 1);
4872 if (ret < 0)
4873 goto err;
4874
4875 reg = 0x10c0 ;
4876 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4877 ret = usb_microdia_control_write(dev, reg, buf, 8);
4878 if (ret < 0)
4879 goto err;
4880
4881 reg = 0x10c0 ;
4882 ret = usb_microdia_control_read(dev, reg, buf, 1);
4883 if (ret < 0)
4884 goto err;
4885
4886 reg = 0x10c0 ;
4887 ret = usb_microdia_control_read(dev, reg, buf, 1);
4888 if (ret < 0)
4889 goto err;
4890
4891 reg = 0x10c0 ;
4892 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4893 ret = usb_microdia_control_write(dev, reg, buf, 8);
4894 if (ret < 0)
4895 goto err;
4896
4897 reg = 0x10c0 ;
4898 ret = usb_microdia_control_read(dev, reg, buf, 1);
4899 if (ret < 0)
4900 goto err;
4901
4902 reg = 0x10c0 ;
4903 ret = usb_microdia_control_read(dev, reg, buf, 1);
4904 if (ret < 0)
4905 goto err;
4906
4907 reg = 0x1182 ;
4908 buf[0] = 0x01;
4909 ret = usb_microdia_control_write(dev, reg, buf, 1);
4910 if (ret < 0)
4911 goto err;
4912
4913 reg = 0x10c0 ;
4914 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x7d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4915 ret = usb_microdia_control_write(dev, reg, buf, 8);
4916 if (ret < 0)
4917 goto err;
4918
4919 reg = 0x10c0 ;
4920 ret = usb_microdia_control_read(dev, reg, buf, 1);
4921 if (ret < 0)
4922 goto err;
4923
4924 reg = 0x10c0 ;
4925 ret = usb_microdia_control_read(dev, reg, buf, 1);
4926 if (ret < 0)
4927 goto err;
4928
4929 reg = 0x10c0 ;
4930 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4931 ret = usb_microdia_control_write(dev, reg, buf, 8);
4932 if (ret < 0)
4933 goto err;
4934
4935 reg = 0x10c0 ;
4936 ret = usb_microdia_control_read(dev, reg, buf, 1);
4937 if (ret < 0)
4938 goto err;
4939
4940 reg = 0x10c0 ;
4941 ret = usb_microdia_control_read(dev, reg, buf, 1);
4942 if (ret < 0)
4943 goto err;
4944
4945 reg = 0x10c0 ;
4946 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4947 ret = usb_microdia_control_write(dev, reg, buf, 8);
4948 if (ret < 0)
4949 goto err;
4950
4951 reg = 0x10c0 ;
4952 ret = usb_microdia_control_read(dev, reg, buf, 1);
4953 if (ret < 0)
4954 goto err;
4955
4956 reg = 0x10c0 ;
4957 ret = usb_microdia_control_read(dev, reg, buf, 1);
4958 if (ret < 0)
4959 goto err;
4960
4961 reg = 0x10c0 ;
4962 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4963 ret = usb_microdia_control_write(dev, reg, buf, 8);
4964 if (ret < 0)
4965 goto err;
4966
4967 reg = 0x10c0 ;
4968 ret = usb_microdia_control_read(dev, reg, buf, 1);
4969 if (ret < 0)
4970 goto err;
4971
4972 reg = 0x10c0 ;
4973 ret = usb_microdia_control_read(dev, reg, buf, 1);
4974 if (ret < 0)
4975 goto err;
4976
4977 reg = 0x10c0 ;
4978 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4979 ret = usb_microdia_control_write(dev, reg, buf, 8);
4980 if (ret < 0)
4981 goto err;
4982
4983 reg = 0x10c0 ;
4984 ret = usb_microdia_control_read(dev, reg, buf, 1);
4985 if (ret < 0)
4986 goto err;
4987
4988 reg = 0x10c0 ;
4989 ret = usb_microdia_control_read(dev, reg, buf, 1);
4990 if (ret < 0)
4991 goto err;
4992
4993 reg = 0x10c0 ;
4994 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
4995 ret = usb_microdia_control_write(dev, reg, buf, 8);
4996 if (ret < 0)
4997 goto err;
4998
4999 reg = 0x10c0 ;
5000 ret = usb_microdia_control_read(dev, reg, buf, 1);
5001 if (ret < 0)
5002 goto err;
5003
5004 reg = 0x10c0 ;
5005 ret = usb_microdia_control_read(dev, reg, buf, 1);
5006 if (ret < 0)
5007 goto err;
5008
5009 reg = 0x10c0 ;
5010 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5011 ret = usb_microdia_control_write(dev, reg, buf, 8);
5012 if (ret < 0)
5013 goto err;
5014
5015 reg = 0x10c0 ;
5016 ret = usb_microdia_control_read(dev, reg, buf, 1);
5017 if (ret < 0)
5018 goto err;
5019
5020 reg = 0x10c0 ;
5021 ret = usb_microdia_control_read(dev, reg, buf, 1);
5022 if (ret < 0)
5023 goto err;
5024
5025 reg = 0x10c0 ;
5026 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5027 ret = usb_microdia_control_write(dev, reg, buf, 8);
5028 if (ret < 0)
5029 goto err;
5030
5031 reg = 0x10c0 ;
5032 ret = usb_microdia_control_read(dev, reg, buf, 1);
5033 if (ret < 0)
5034 goto err;
5035
5036 reg = 0x10c0 ;
5037 ret = usb_microdia_control_read(dev, reg, buf, 1);
5038 if (ret < 0)
5039 goto err;
5040
5041 reg = 0x11ba ;
5042 buf[0] = 0x0a;
5043 ret = usb_microdia_control_write(dev, reg, buf, 1);
5044 if (ret < 0)
5045 goto err;
5046
5047 reg = 0x118b ;
5048 buf[0] = 0x10;
5049 ret = usb_microdia_control_write(dev, reg, buf, 1);
5050 if (ret < 0)
5051 goto err;
5052
5053 reg = 0x10f7;
5054 buf[0] = 0x05;
5055 ret = usb_microdia_control_write(dev, reg, buf, 1);
5056 if (ret < 0)
5057 goto err;
5058
5059 reg = 0x10f8 ;
5060 buf[0] = 0x14;
5061 ret = usb_microdia_control_write(dev, reg, buf, 1);
5062 if (ret < 0)
5063 goto err;
5064
5065 reg = 0x10fa ;
5066 buf[0] = 0xff;
5067 ret = usb_microdia_control_write(dev, reg, buf, 1);
5068 if (ret < 0)
5069 goto err;
5070
5071 reg = 0x10f9 ;
5072 buf[0] = 0x00;
5073 ret = usb_microdia_control_write(dev, reg, buf, 1);
5074 if (ret < 0)
5075 goto err;
5076
5077 reg = 0x10f9 ;
5078 buf[0] = 0x00;
5079 ret = usb_microdia_control_write(dev, reg, buf, 1);
5080 if (ret < 0)
5081 goto err;
5082
5083 reg = 0x11ba ;
5084 buf[0] = 0x0a;
5085 ret = usb_microdia_control_write(dev, reg, buf, 1);
5086 if (ret < 0)
5087 goto err;
5088
5089 reg = 0x11bc ;
5090 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5091 ret = usb_microdia_control_write(dev, reg, buf, 4);
5092 if (ret < 0)
5093 goto err;
5094
5095 reg = 0x11c0;
5096 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5097 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
5098 buf[8] = 0x00; buf[9] = 0x00; buf[10] = 0x00; buf[11] = 0x00;
5099 buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00; buf[15] = 0x00;
5100 buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
5101 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00;
5102 buf[24] = 0x00; buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00;
5103 buf[28] = 0x00; buf[29] = 0x00; buf[30] = 0x00; buf[31] = 0x00;
5104 buf[32] = 0x00; buf[33] = 0x00; buf[34] = 0x00; buf[35] = 0x00;
5105 buf[36] = 0x00; buf[37] = 0x00; buf[38] = 0x00; buf[39] = 0x00;
5106 buf[40] = 0x00; buf[41] = 0x00; buf[42] = 0x00; buf[43] = 0x00;
5107 buf[44] = 0x00; buf[45] = 0x00; buf[46] = 0x00; buf[47] = 0x00;
5108 ret = usb_microdia_control_write(dev, reg, buf, 48);
5109 if (ret < 0)
5110 goto err;
5111
5112 reg = 0x11a5 ;
5113 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
5114 buf[4] = 0x04; buf[5] = 0x3f;
5115 ret = usb_microdia_control_write(dev, reg, buf, 6);
5116 if (ret < 0)
5117 goto err;
5118
5119 reg = 0x11af ;
5120 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
5121 ret = usb_microdia_control_write(dev, reg, buf, 4);
5122 if (ret < 0)
5123 goto err;
5124
5125 reg = 0x11b3 ;
5126 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
5127 ret = usb_microdia_control_write(dev, reg, buf, 4);
5128 if (ret < 0)
5129 goto err;
5130
5131 reg = 0x10e0 ;
5132 buf[0] = 0x47;
5133 ret = usb_microdia_control_write(dev, reg, buf, 1);
5134 if (ret < 0)
5135 goto err;
5136
5137 reg = 0x1061 ;
5138 buf[0] = 0x01;
5139 ret = usb_microdia_control_write(dev, reg, buf, 1);
5140 if (ret < 0)
5141 goto err;
5142
5143 reg = 0x10e0 ;
5144 buf[0] = 0x67;
5145 ret = usb_microdia_control_write(dev, reg, buf, 1);
5146 if (ret < 0)
5147 goto err;
5148
5149 reg = 0x1100 ;
5150 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
5151 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
5152 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
5153 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
5154 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
5155 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
5156 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
5157 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
5158 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
5159 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
5160 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
5161 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
5162 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
5163 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
5164 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
5165 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
5166 ret = usb_microdia_control_write(dev, reg, buf, 64);
5167 if (ret < 0)
5168 goto err;
5169
5170 reg = 0x1140 ;
5171 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
5172 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
5173 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
5174 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
5175 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
5176 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
5177 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
5178 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
5179 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
5180 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
5181 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
5182 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
5183 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
5184 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
5185 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
5186 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
5187 ret = usb_microdia_control_write(dev, reg, buf, 64);
5188 if (ret < 0)
5189 goto err;
5190
5191 reg = 0x10e0 ;
5192 buf[0] = 0x47;
5193 ret = usb_microdia_control_write(dev, reg, buf, 1);
5194 if (ret < 0)
5195 goto err;
5196
5197 reg = 0x1061 ;
5198 buf[0] = 0x03;
5199 ret = usb_microdia_control_write(dev, reg, buf, 1);
5200 if (ret < 0)
5201 goto err;
5202
5203 reg = 0x10e0 ;
5204 buf[0] = 0x4b;
5205 ret = usb_microdia_control_write(dev, reg, buf, 1);
5206 if (ret < 0)
5207 goto err;
5208
5209 reg = 0x11bc ;
5210 buf[0] = 0x00;
5211 ret = usb_microdia_control_write(dev, reg, buf, 1);
5212 if (ret < 0)
5213 goto err;
5214
5215 reg = 0x11bd ;
5216 buf[0] = 0x00;
5217 ret = usb_microdia_control_write(dev, reg, buf, 1);
5218 if (ret < 0)
5219 goto err;
5220
5221 reg = 0x11be ;
5222 buf[0] = 0x00;
5223 ret = usb_microdia_control_write(dev, reg, buf, 1);
5224 if (ret < 0)
5225 goto err;
5226
5227 reg = 0x11bf ;
5228 buf[0] = 0x00;
5229 ret = usb_microdia_control_write(dev, reg, buf, 1);
5230 if (ret < 0)
5231 goto err;
5232
5233 reg = 0x10c0 ;
5234 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5235 ret = usb_microdia_control_write(dev, reg, buf, 8);
5236 if (ret < 0)
5237 goto err;
5238
5239 reg = 0x10c0 ;
5240 ret = usb_microdia_control_read(dev, reg, buf, 1);
5241 if (ret < 0)
5242 goto err;
5243
5244 reg = 0x10c0 ;
5245 ret = usb_microdia_control_read(dev, reg, buf, 1);
5246 if (ret < 0)
5247 goto err;
5248
5249 reg = 0x10c0 ;
5250 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
5251 ret = usb_microdia_control_write(dev, reg, buf, 8);
5252 if (ret < 0)
5253 goto err;
5254
5255 reg = 0x10c0 ;
5256 ret = usb_microdia_control_read(dev, reg, buf, 1);
5257 if (ret < 0)
5258 goto err;
5259
5260 reg = 0x10c0 ;
5261 ret = usb_microdia_control_read(dev, reg, buf, 1);
5262 if (ret < 0)
5263 goto err;
5264
5265 reg = 0x10c0 ;
5266 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5267 ret = usb_microdia_control_write(dev, reg, buf, 8);
5268 if (ret < 0)
5269 goto err;
5270
5271 reg = 0x10c0 ;
5272 ret = usb_microdia_control_read(dev, reg, buf, 1);
5273 if (ret < 0)
5274 goto err;
5275
5276 reg = 0x10c0 ;
5277 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5278 ret = usb_microdia_control_write(dev, reg, buf, 8);
5279 if (ret < 0)
5280 goto err;
5281
5282 reg = 0x10c0 ;
5283 ret = usb_microdia_control_read(dev, reg, buf, 1);
5284 if (ret < 0)
5285 goto err;
5286
5287 reg = 0x10c0 ;
5288 ret = usb_microdia_control_read(dev, reg, buf, 1);
5289 if (ret < 0)
5290 goto err;
5291
5292 reg = 0x1180 ;
5293 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
5294 buf[4] = 0x50; buf[5] = 0x78;
5295 ret = usb_microdia_control_write(dev, reg, buf, 6);
5296 if (ret < 0)
5297 goto err;
5298
5299 reg = 0x11a1 ;
5300 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
5301 ret = usb_microdia_control_write(dev, reg, buf, 4);
5302 if (ret < 0)
5303 goto err;
5304
5305 reg = 0x11ab ;
5306 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
5307 ret = usb_microdia_control_write(dev, reg, buf, 4);
5308 if (ret < 0)
5309 goto err;
5310
5311 reg = 0x1061 ;
5312 buf[0] = 0x03;
5313 ret = usb_microdia_control_write(dev, reg, buf, 1);
5314 if (ret < 0)
5315 goto err;
5316
5317 reg = 0x11ba ;
5318 buf[0] = 0x0a;
5319 ret = usb_microdia_control_write(dev, reg, buf, 1);
5320 if (ret < 0)
5321 goto err;
5322
5323 reg = 0x11b9 ;
5324 buf[0] = 0x00;
5325 ret = usb_microdia_control_write(dev, reg, buf, 1);
5326 if (ret < 0)
5327 goto err;
5328
5329 reg = 0x11ba ;
5330 buf[0] = 0x0b;
5331 ret = usb_microdia_control_write(dev, reg, buf, 1);
5332 if (ret < 0)
5333 goto err;
5334
5335 reg = 0x1061 ;
5336 buf[0] = 0x01;
5337 ret = usb_microdia_control_write(dev, reg, buf, 1);
5338 if (ret < 0)
5339 goto err;
5340
5341 reg = 0x1000 ;
5342 buf[0] = 0x78;
5343 ret = usb_microdia_control_write(dev, reg, buf, 1);
5344 if (ret < 0)
5345 goto err;
5346
5347 reg = 0x1002 ;
5348 buf[0] = 0x08;
5349 ret = usb_microdia_control_write(dev, reg, buf, 1);
5350 if (ret < 0)
5351 goto err;
5352
5353 reg = 0x1002 ;
5354 buf[0] = 0x08;
5355 ret = usb_microdia_control_write(dev, reg, buf, 1);
5356 if (ret < 0)
5357 goto err;
5358
5359 reg = 0x11b8 ;
5360 buf[0] = 0xfa;
5361 ret = usb_microdia_control_write(dev, reg, buf, 1);
5362 if (ret < 0)
5363 goto err;
5364
5365 reg = 0x118a ;
5366 buf[0] = 0x02;
5367 ret = usb_microdia_control_write(dev, reg, buf, 1);
5368 if (ret < 0)
5369 goto err;
5370
5371 reg = 0x0395 ;
5372 buf[0] = 0x02;
5373 ret = usb_microdia_control_write(dev, reg, buf, 1);
5374 if (ret < 0)
5375 goto err;
5376
5377 reg = 0x11b8 ;
5378 buf[0] = 0xf8;
5379 ret = usb_microdia_control_write(dev, reg, buf, 1);
5380 if (ret < 0)
5381 goto err;
5382
5383 reg = 0x11b8 ;
5384 ret = usb_microdia_control_read(dev, reg, buf, 1);
5385 if (ret < 0)
5386 goto err;
5387
5388 reg = 0x11b8 ;
5389 buf[0] = 0xf9;
5390 ret = usb_microdia_control_write(dev, reg, buf, 1);
5391 if (ret < 0)
5392 goto err;
5393
5394 reg = 0x11b8 ;
5395 ret = usb_microdia_control_read(dev, reg, buf, 1);
5396 if (ret < 0)
5397 goto err;
5398
5399 reg = 0x11b8 ;
5400 buf[0] = 0x7a;
5401 ret = usb_microdia_control_write(dev, reg, buf, 1);
5402 if (ret < 0)
5403 goto err;
5404
5405 reg = 0x11b8 ;
5406 ret = usb_microdia_control_read(dev, reg, buf, 1);
5407 if (ret < 0)
5408 goto err;
5409
5410 reg = 0x11b8 ;
5411 buf[0] = 0x7b;
5412 ret = usb_microdia_control_write(dev, reg, buf, 1);
5413 if (ret < 0)
5414 goto err;
5415
5416 reg = 0x11b8 ;
5417 ret = usb_microdia_control_read(dev, reg, buf, 1);
5418 if (ret < 0)
5419 goto err;
5420
5421 reg = 0x11b8 ;
5422 buf[0] = 0x7c;
5423 ret = usb_microdia_control_write(dev, reg, buf, 1);
5424 if (ret < 0)
5425 goto err;
5426
5427 reg = 0x11b8 ;
5428 ret = usb_microdia_control_read(dev, reg, buf, 1);
5429 if (ret < 0)
5430 goto err;
5431
5432 reg = 0x11b8 ;
5433 buf[0] = 0xfd;
5434 ret = usb_microdia_control_write(dev, reg, buf, 1);
5435 if (ret < 0)
5436 goto err;
5437
5438 reg = 0x11b8 ;
5439 ret = usb_microdia_control_read(dev, reg, buf, 1);
5440 if (ret < 0)
5441 goto err;
5442
5443 reg = 0x11b8 ;
5444 buf[0] = 0xfa;
5445 ret = usb_microdia_control_write(dev, reg, buf, 1);
5446 if (ret < 0)
5447 goto err;
5448
5449 reg = 0x10c0 ;
5450 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5451 ret = usb_microdia_control_write(dev, reg, buf, 8);
5452 if (ret < 0)
5453 goto err;
5454
5455 reg = 0x10c0 ;
5456 ret = usb_microdia_control_read(dev, reg, buf, 1);
5457 if (ret < 0)
5458 goto err;
5459
5460 reg = 0x10c0 ;
5461 ret = usb_microdia_control_read(dev, reg, buf, 1);
5462 if (ret < 0)
5463 goto err;
5464
5465 reg = 0x10c0 ;
5466 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5467 ret = usb_microdia_control_write(dev, reg, buf, 8);
5468 if (ret < 0)
5469 goto err;
5470
5471 reg = 0x10c0 ;
5472 ret = usb_microdia_control_read(dev, reg, buf, 1);
5473 if (ret < 0)
5474 goto err;
5475
5476 reg = 0x10c0 ;
5477 ret = usb_microdia_control_read(dev, reg, buf, 1);
5478 if (ret < 0)
5479 goto err;
5480
5481 reg = 0x10c0 ;
5482 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x70; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5483 ret = usb_microdia_control_write(dev, reg, buf, 8);
5484 if (ret < 0)
5485 goto err;
5486
5487 reg = 0x10c0 ;
5488 ret = usb_microdia_control_read(dev, reg, buf, 1);
5489 if (ret < 0)
5490 goto err;
5491
5492 reg = 0x10c0 ;
5493 ret = usb_microdia_control_read(dev, reg, buf, 1);
5494 if (ret < 0)
5495 goto err;
5496
5497 reg = 0x10c0 ;
5498 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5499 ret = usb_microdia_control_write(dev, reg, buf, 8);
5500 if (ret < 0)
5501 goto err;
5502
5503 reg = 0x10c0 ;
5504 ret = usb_microdia_control_read(dev, reg, buf, 1);
5505 if (ret < 0)
5506 goto err;
5507
5508 reg = 0x10c0 ;
5509 ret = usb_microdia_control_read(dev, reg, buf, 1);
5510 if (ret < 0)
5511 goto err;
5512
5513 reg = 0x10c0 ;
5514 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5515 ret = usb_microdia_control_write(dev, reg, buf, 8);
5516 if (ret < 0)
5517 goto err;
5518
5519 reg = 0x10c0 ;
5520 ret = usb_microdia_control_read(dev, reg, buf, 1);
5521 if (ret < 0)
5522 goto err;
5523
5524 reg = 0x10c0 ;
5525 ret = usb_microdia_control_read(dev, reg, buf, 1);
5526 if (ret < 0)
5527 goto err;
5528
5529 reg = 0x10c0 ;
5530 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5531 ret = usb_microdia_control_write(dev, reg, buf, 8);
5532 if (ret < 0)
5533 goto err;
5534
5535 reg = 0x10c0 ;
5536 ret = usb_microdia_control_read(dev, reg, buf, 1);
5537 if (ret < 0)
5538 goto err;
5539
5540 reg = 0x10c0 ;
5541 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5542 ret = usb_microdia_control_write(dev, reg, buf, 8);
5543 if (ret < 0)
5544 goto err;
5545
5546 reg = 0x10c0 ;
5547 ret = usb_microdia_control_read(dev, reg, buf, 1);
5548 if (ret < 0)
5549 goto err;
5550
5551 reg = 0x10c2 ;
5552 ret = usb_microdia_control_read(dev, reg, buf, 5);
5553 if (ret < 0)
5554 goto err;
5555
5556 reg = 0x10c0 ;
5557 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5558 ret = usb_microdia_control_write(dev, reg, buf, 8);
5559 if (ret < 0)
5560 goto err;
5561
5562 reg = 0x10c0 ;
5563 ret = usb_microdia_control_read(dev, reg, buf, 1);
5564 if (ret < 0)
5565 goto err;
5566
5567 reg = 0x10c0 ;
5568 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5569 ret = usb_microdia_control_write(dev, reg, buf, 8);
5570 if (ret < 0)
5571 goto err;
5572
5573 reg = 0x10c0 ;
5574 ret = usb_microdia_control_read(dev, reg, buf, 1);
5575 if (ret < 0)
5576 goto err;
5577
5578 reg = 0x10c2 ;
5579 ret = usb_microdia_control_read(dev, reg, buf, 5);
5580 if (ret < 0)
5581 goto err;
5582
5583 reg = 0x10c0 ;
5584 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1c; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5585 ret = usb_microdia_control_write(dev, reg, buf, 8);
5586 if (ret < 0)
5587 goto err;
5588
5589 reg = 0x10c0 ;
5590 ret = usb_microdia_control_read(dev, reg, buf, 1);
5591 if (ret < 0)
5592 goto err;
5593
5594 reg = 0x10c0 ;
5595 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5596 ret = usb_microdia_control_write(dev, reg, buf, 8);
5597 if (ret < 0)
5598 goto err;
5599
5600 reg = 0x10c0 ;
5601 ret = usb_microdia_control_read(dev, reg, buf, 1);
5602 if (ret < 0)
5603 goto err;
5604
5605 reg = 0x10c2 ;
5606 ret = usb_microdia_control_read(dev, reg, buf, 5);
5607 if (ret < 0)
5608 goto err;
5609
5610 reg = 0x10c0 ;
5611 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5612 ret = usb_microdia_control_write(dev, reg, buf, 8);
5613 if (ret < 0)
5614 goto err;
5615
5616 reg = 0x10c0 ;
5617 ret = usb_microdia_control_read(dev, reg, buf, 1);
5618 if (ret < 0)
5619 goto err;
5620
5621 reg = 0x10c0 ;
5622 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5623 ret = usb_microdia_control_write(dev, reg, buf, 8);
5624 if (ret < 0)
5625 goto err;
5626
5627 reg = 0x10c0 ;
5628 ret = usb_microdia_control_read(dev, reg, buf, 1);
5629 if (ret < 0)
5630 goto err;
5631
5632 reg = 0x10c2 ;
5633 ret = usb_microdia_control_read(dev, reg, buf, 5);
5634 if (ret < 0)
5635 goto err;
5636
5637 reg = 0x1061 ;
5638 buf[0] = 0x03;
5639 ret = usb_microdia_control_write(dev, reg, buf, 1);
5640 if (ret < 0)
5641 goto err;
5642
5643 reg = 0x1007 ;
5644 buf[0] = 0x20;
5645 ret = usb_microdia_control_write(dev, reg, buf, 1);
5646 if (ret < 0)
5647 goto err;
5648
5649 reg = 0x1006 ;
5650 buf[0] = 0x00;
5651 ret = usb_microdia_control_write(dev, reg, buf, 1);
5652 if (ret < 0)
5653 goto err;
5654
5655 reg = 0x10c0 ;
5656 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5657 ret = usb_microdia_control_write(dev, reg, buf, 8);
5658 if (ret < 0)
5659 goto err;
5660
5661 reg = 0x10c0 ;
5662 ret = usb_microdia_control_read(dev, reg, buf, 1);
5663 if (ret < 0)
5664 goto err;
5665
5666 reg = 0x10c0 ;
5667 ret = usb_microdia_control_read(dev, reg, buf, 1);
5668 if (ret < 0)
5669 goto err;
5670
5671 reg = 0x10c0 ;
5672 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5673 ret = usb_microdia_control_write(dev, reg, buf, 8);
5674 if (ret < 0)
5675 goto err;
5676
5677 reg = 0x10c0 ;
5678 ret = usb_microdia_control_read(dev, reg, buf, 1);
5679 if (ret < 0)
5680 goto err;
5681
5682 reg = 0x10c0 ;
5683 ret = usb_microdia_control_read(dev, reg, buf, 1);
5684 if (ret < 0)
5685 goto err;
5686
5687 reg = 0x10c0 ;
5688 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5689 ret = usb_microdia_control_write(dev, reg, buf, 8);
5690 if (ret < 0)
5691 goto err;
5692
5693 reg = 0x10c0 ;
5694 ret = usb_microdia_control_read(dev, reg, buf, 1);
5695 if (ret < 0)
5696 goto err;
5697
5698 reg = 0x10c0 ;
5699 ret = usb_microdia_control_read(dev, reg, buf, 1);
5700 if (ret < 0)
5701 goto err;
5702
5703 reg = 0x10c0 ;
5704 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x36; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5705 ret = usb_microdia_control_write(dev, reg, buf, 8);
5706 if (ret < 0)
5707 goto err;
5708
5709 reg = 0x10c0 ;
5710 ret = usb_microdia_control_read(dev, reg, buf, 1);
5711 if (ret < 0)
5712 goto err;
5713
5714 reg = 0x10c0 ;
5715 ret = usb_microdia_control_read(dev, reg, buf, 1);
5716 if (ret < 0)
5717 goto err;
5718
5719 reg = 0x10c0 ;
5720 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5721 ret = usb_microdia_control_write(dev, reg, buf, 8);
5722 if (ret < 0)
5723 goto err;
5724
5725 reg = 0x10c0 ;
5726 ret = usb_microdia_control_read(dev, reg, buf, 1);
5727 if (ret < 0)
5728 goto err;
5729
5730 reg = 0x10c0 ;
5731 ret = usb_microdia_control_read(dev, reg, buf, 1);
5732 if (ret < 0)
5733 goto err;
5734
5735 reg = 0x10c0 ;
5736 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
5737 ret = usb_microdia_control_write(dev, reg, buf, 8);
5738 if (ret < 0)
5739 goto err;
5740
5741 reg = 0x10c0 ;
5742 ret = usb_microdia_control_read(dev, reg, buf, 1);
5743 if (ret < 0)
5744 goto err;
5745
5746 reg = 0x10c0 ;
5747 ret = usb_microdia_control_read(dev, reg, buf, 1);
5748 if (ret < 0)
5749 goto err;
5750
5751 reg = 0x10c0 ;
5752 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
5753 ret = usb_microdia_control_write(dev, reg, buf, 8);
5754 if (ret < 0)
5755 goto err;
5756
5757 reg = 0x10c0 ;
5758 ret = usb_microdia_control_read(dev, reg, buf, 1);
5759 if (ret < 0)
5760 goto err;
5761
5762 reg = 0x10c0 ;
5763 ret = usb_microdia_control_read(dev, reg, buf, 1);
5764 if (ret < 0)
5765 goto err;
5766
5767 reg = 0x10c0 ;
5768 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x94; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5769 ret = usb_microdia_control_write(dev, reg, buf, 8);
5770 if (ret < 0)
5771 goto err;
5772
5773 reg = 0x10c0 ;
5774 ret = usb_microdia_control_read(dev, reg, buf, 1);
5775 if (ret < 0)
5776 goto err;
5777
5778 reg = 0x10c0 ;
5779 ret = usb_microdia_control_read(dev, reg, buf, 1);
5780 if (ret < 0)
5781 goto err;
5782
5783 reg = 0x10c0 ;
5784 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x8d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5785 ret = usb_microdia_control_write(dev, reg, buf, 8);
5786 if (ret < 0)
5787 goto err;
5788
5789 reg = 0x10c0 ;
5790 ret = usb_microdia_control_read(dev, reg, buf, 1);
5791 if (ret < 0)
5792 goto err;
5793
5794 reg = 0x10c0 ;
5795 ret = usb_microdia_control_read(dev, reg, buf, 1);
5796 if (ret < 0)
5797 goto err;
5798
5799 reg = 0x10c0 ;
5800 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x09; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
5801 ret = usb_microdia_control_write(dev, reg, buf, 8);
5802 if (ret < 0)
5803 goto err;
5804
5805 reg = 0x10c0 ;
5806 ret = usb_microdia_control_read(dev, reg, buf, 1);
5807 if (ret < 0)
5808 goto err;
5809
5810 reg = 0x10c0 ;
5811 ret = usb_microdia_control_read(dev, reg, buf, 1);
5812 if (ret < 0)
5813 goto err;
5814
5815 reg = 0x10c0 ;
5816 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x95; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5817 ret = usb_microdia_control_write(dev, reg, buf, 8);
5818 if (ret < 0)
5819 goto err;
5820
5821 reg = 0x10c0 ;
5822 ret = usb_microdia_control_read(dev, reg, buf, 1);
5823 if (ret < 0)
5824 goto err;
5825
5826 reg = 0x10c0 ;
5827 ret = usb_microdia_control_read(dev, reg, buf, 1);
5828 if (ret < 0)
5829 goto err;
5830
5831 reg = 0x10c0 ;
5832 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5833 ret = usb_microdia_control_write(dev, reg, buf, 8);
5834 if (ret < 0)
5835 goto err;
5836
5837 reg = 0x10c0 ;
5838 ret = usb_microdia_control_read(dev, reg, buf, 1);
5839 if (ret < 0)
5840 goto err;
5841
5842 reg = 0x10c0 ;
5843 ret = usb_microdia_control_read(dev, reg, buf, 1);
5844 if (ret < 0)
5845 goto err;
5846
5847 reg = 0x10c0 ;
5848 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
5849 ret = usb_microdia_control_write(dev, reg, buf, 8);
5850 if (ret < 0)
5851 goto err;
5852
5853 reg = 0x10c0 ;
5854 ret = usb_microdia_control_read(dev, reg, buf, 1);
5855 if (ret < 0)
5856 goto err;
5857
5858 reg = 0x10c0 ;
5859 ret = usb_microdia_control_read(dev, reg, buf, 1);
5860 if (ret < 0)
5861 goto err;
5862
5863 reg = 0x10c0 ;
5864 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x96; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5865 ret = usb_microdia_control_write(dev, reg, buf, 8);
5866 if (ret < 0)
5867 goto err;
5868
5869 reg = 0x10c0 ;
5870 ret = usb_microdia_control_read(dev, reg, buf, 1);
5871 if (ret < 0)
5872 goto err;
5873
5874 reg = 0x10c0 ;
5875 ret = usb_microdia_control_read(dev, reg, buf, 1);
5876 if (ret < 0)
5877 goto err;
5878
5879 reg = 0x10c0 ;
5880 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5881 ret = usb_microdia_control_write(dev, reg, buf, 8);
5882 if (ret < 0)
5883 goto err;
5884
5885 reg = 0x10c0 ;
5886 ret = usb_microdia_control_read(dev, reg, buf, 1);
5887 if (ret < 0)
5888 goto err;
5889
5890 reg = 0x10c0 ;
5891 ret = usb_microdia_control_read(dev, reg, buf, 1);
5892 if (ret < 0)
5893 goto err;
5894
5895 reg = 0x10c0 ;
5896 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
5897 ret = usb_microdia_control_write(dev, reg, buf, 8);
5898 if (ret < 0)
5899 goto err;
5900
5901 reg = 0x10c0 ;
5902 ret = usb_microdia_control_read(dev, reg, buf, 1);
5903 if (ret < 0)
5904 goto err;
5905
5906 reg = 0x10c0 ;
5907 ret = usb_microdia_control_read(dev, reg, buf, 1);
5908 if (ret < 0)
5909 goto err;
5910
5911 reg = 0x1007 ;
5912 buf[0] = 0x20;
5913 ret = usb_microdia_control_write(dev, reg, buf, 1);
5914 if (ret < 0)
5915 goto err;
5916
5917 reg = 0x1006 ;
5918 buf[0] = 0x20;
5919 ret = usb_microdia_control_write(dev, reg, buf, 1);
5920 if (ret < 0)
5921 goto err;
5922
5923
5924
5925
5926 /* END OF MICRODIA 6288 START STREAM */
5927
5928 return 0;
5929 err:
5930 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
5931 return ret;
5932 }
5933
5934
5935 /**
5936 * @brief Wrapper function for device-specific stopstream functions
5937 *
5938 * @param dev Pointer to device structure
5939 *
5940 * @returns 0
5941 *
5942 * This will execute a function determined by the array #cameras and
5943 * the function find_camera().
5944 *
5945 */
5946 int dev_microdia_stop_stream(struct usb_microdia *dev)
5947 {
5948 int ret = -ENODEV;
5949 if (dev && dev->stop_stream)
5950 ret = dev->stop_stream(dev);
5951
5952 return ret;
5953 }
5954
5955 /**
5956 * @brief From stop.htm
5957 *
5958 * @param dev
5959 *
5960 * @returns 0
5961 *
5962 * @author GWater
5963 *
5964 * For SN9C201 with MI1310.
5965 * This function has not been tested yet.
5966 */
5967 int microdia_6242_stop_stream(struct usb_microdia *dev)
5968 {
5969 __u8 buf[3];
5970
5971 __u8 only10c0[3] = {0x0d, 0x00, 0x00};
5972
5973 buf[0] = 0x01;
5974 usb_microdia_control_write(dev, 0x1061, buf, 1);
5975
5976 buf[0] = 0x60;
5977 usb_microdia_control_write(dev, 0x1007, buf, 1);
5978
5979 buf[0] = 0x00;
5980 usb_microdia_control_write(dev, 0x1006, buf, 1);
5981
5982 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5983 only10c0[0], dev->sensor_flags, &only10c0[1]);
5984
5985 buf[0] = 0x38;
5986 usb_microdia_control_write(dev, 0x1000, buf, 1);
5987
5988 buf[0] = 0x6b;
5989 usb_microdia_control_write(dev, 0x11b8, buf, 1);
5990
5991 buf[0] = 0x60;
5992 usb_microdia_control_write(dev, 0x1007, buf, 1);
5993
5994 buf[0] = 0x20;
5995 usb_microdia_control_write(dev, 0x1006, buf, 1);
5996
5997
5998 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
5999 usb_microdia_control_write(dev, 0x1000, buf, 3);
6000
6001 /**
6002 * After the select alternate setting 0 is actually another transfer:
6003 * buf[0] = 0x00;
6004 * usb_microdia_control_write(dev, 0x1066, buf, 1);
6005 */
6006
6007 return 0;
6008 }
6009
6010
6011 /**
6012 * @brief From stopstream.log
6013 *
6014 * @param dev
6015 *
6016 * @returns 0
6017 *
6018 * @author GWater
6019 *
6020 * For SN9C201 with SOI968.
6021 * I don't whether the function really stops the stream.
6022 * Nevertheless the LED on the webcam now stops glowing.
6023 * The function is very similar to "microdia_624f_stop_stream".
6024 */
6025 int microdia_624e_stop_stream(struct usb_microdia *dev)
6026 {
6027 __u8 buf[3];
6028
6029 buf[0] = 0x01;
6030 usb_microdia_control_write(dev, 0x1061, buf, 1);
6031
6032 /* Next two writes added because it works better.
6033 * The LED stops glowing and I think the stream does too.
6034 * 0x20 = 0b00100000 which is the minimal of what the
6035 * other stopstreams have in common.
6036 */
6037 buf[0] = 0x20;
6038 usb_microdia_control_write(dev, 0x1007, buf, 1);
6039
6040 buf[0] = 0x20;
6041 usb_microdia_control_write(dev, 0x1006, buf, 1);
6042
6043 buf[0] = 0x3c;
6044 usb_microdia_control_write(dev, 0x1000, buf, 1);
6045
6046 buf[0] = 0x6a;
6047 usb_microdia_control_write(dev, 0x11b8, buf, 1);
6048
6049 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
6050 usb_microdia_control_write(dev, 0x1000, buf, 3);
6051
6052 usb_microdia_control_read(dev, 0x1066, buf, 1);
6053
6054 return 0;
6055 }
6056
6057
6058 /**
6059 * @brief Stop device 624f from streaming
6060 *
6061 * @param dev Pointer to device structure
6062 *
6063 * @returns 0 or negative error code
6064 *
6065 */
6066 int microdia_624f_stop_stream(struct usb_microdia *dev)
6067 {
6068 int ret;
6069 __u16 command;
6070 __u8 buf[3];
6071
6072 buf[0] = 0x02;
6073 command = 0x1066;
6074 ret = usb_microdia_control_write(dev, command, buf, 1);
6075 if (ret < 0)
6076 goto err;
6077
6078 buf[0] = 0x01;
6079 command = 0x1061;
6080 ret = usb_microdia_control_write(dev, command, buf, 1);
6081 if (ret < 0)
6082 goto err;
6083
6084 buf[0] = 0x38;
6085 command = 0x1000;
6086 ret = usb_microdia_control_write(dev, command, buf, 1);
6087 if (ret < 0)
6088 goto err;
6089
6090 buf[0] = 0x6a;
6091 command = 0x11b8;
6092 ret = usb_microdia_control_write(dev, command, buf, 1);
6093 if (ret < 0)
6094 goto err;
6095
6096 buf[0] = 0x20;
6097 command = 0x1007;
6098 ret = usb_microdia_control_write(dev, command, buf, 1);
6099 if (ret < 0)
6100 goto err;
6101
6102 buf[0] = 0x20;
6103 command = 0x1006;
6104 ret = usb_microdia_control_write(dev, command, buf, 1);
6105 if (ret < 0)
6106 goto err;
6107
6108 buf[0] = 0x98;
6109 buf[1] = 0xe7;
6110 buf[2] = 0x11;
6111 command = 0x1000;
6112 ret = usb_microdia_control_write(dev, command, buf, 3);
6113 if (ret < 0)
6114 goto err;
6115
6116 return ret;
6117
6118 err:
6119 UDIA_ERROR("command %x failed (%d)!\n", command, ret);
6120 return ret;
6121 }
6122
6123 /**
6124 * @brief Stop device 6260 from streaming
6125 *
6126 * @param dev Pointer to device structure
6127 *
6128 * @returns 0 or negative error code
6129 *
6130 */
6131 int microdia_6260_stop_stream(struct usb_microdia *dev)
6132 {
6133 int ret = 0;
6134 int i;
6135 __u16 reg;
6136 __u8 value[1];
6137
6138 static __u16 bridge6260_stop[][2] = {
6139 {0x1061, 0x01},
6140 {0x1000, 0x38},
6141 {0x11b8, 0x6b},
6142 {0x1007, 0x20},
6143 {0x1006, 0x20},
6144 {0x1000, 0x98},
6145 {0x1001, 0xe7},
6146 {0x1002, 0x11},
6147 {0x1066, 0x00},
6148 {0x1045, 0x0f},
6149 {0x10c8, 0x00},
6150 {0x1020, 0x80},
6151 };
6152
6153 UDIA_INFO("Stopping camera...\n");
6154
6155 for (i = 0; i < ARRAY_SIZE(bridge6260_stop); i++) {
6156 reg = bridge6260_stop[i][0];
6157 value[0] = bridge6260_stop[i][1];
6158 ret = usb_microdia_control_write(dev, reg, value, 1);
6159 if (ret < 0) {
6160 UDIA_INFO("6260 Bridge: Stop Sequence Error (%d) on array line %d\n", ret, i);
6161 break;
6162 }
6163 }
6164
6165 return 0;
6166 }
6167
6168 /**
6169 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
6170 *
6171 * @param dev
6172 *
6173 * @returns 0 (ok) or -1 (error)
6174 *
6175 * @author Comer352l
6176 *
6177 * Windows driver version: 5.7.23.000
6178 * Windows versions: 2000 and XP
6179 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
6180 * All logs were made using AMCAP with 640x480, RGB24
6181 */
6182 int microdia_6270_stop_stream(struct usb_microdia *dev)
6183 {
6184 int ret = 0;
6185 int retI2C = 0;
6186 __u8 buf[3];
6187
6188 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
6189 buf[0] = 0x20;
6190 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
6191 buf[0] = 0x20;
6192 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
6193 /* => These two writes seem to cause the cam to stop sending isochronus USB messages */
6194 }
6195 buf[0] = 0x01;
6196 ret += usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 3544 */
6197 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
6198 buf[0] = 0x60;
6199 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
6200 buf[0] = 0x60;
6201 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
6202 }
6203 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
6204 /* Write to sensor register 0x07: Output Control */
6205 buf[0] = 0x00; buf[1] = 0x00; /* stop sensor readout, normal operation */
6206 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
6207 }
6208 buf[0] = 0x38; /* ALEX: 0x3c */
6209 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 3545 */
6210 buf[0] = 0x6d; /* ALEX: 0xec; FRANK: also 0x6c */
6211 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 3546 */
6212 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
6213 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 3547 */
6214
6215 /* INTERRUPT COMMING BACK (URB 2227) */
6216 /* SELECT ALTERNATE SETTINGS (URB 3548) */
6217 /* INTERRUPT GOING DOWN (URB 3549) */
6218
6219 buf[0] = 0x00;
6220 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 3550 */
6221
6222 if (ret < 9) {
6223 UDIA_INFO("One ore more errors occured while stopping stream !\n");
6224 return -1;
6225 } else {
6226 return 0;
6227 }
6228 }
6229
6230 /**
6231 * @brief Stop device 627b from streaming
6232 *
6233 * @param dev Pointer to device structure
6234 *
6235 * @returns 0 or negative error code
6236 *
6237 */
6238 int microdia_627b_stop_stream(struct usb_microdia *dev)
6239 {
6240 int ret = 0;
6241 __u16 reg;
6242 __u8 buf[3];
6243
6244 reg = 0x1007;
6245 buf[0] = 0x60;
6246 ret = usb_microdia_control_write(dev, reg, buf, 1);
6247 if (ret < 0)
6248 goto err;
6249
6250 reg = 0x1006;
6251 buf[0] = 0x20;
6252 ret = usb_microdia_control_write(dev, reg, buf, 1);
6253 if (ret < 0)
6254 goto err;
6255
6256 reg = 0x1061;
6257 buf[0] = 0x01;
6258 ret = usb_microdia_control_write(dev, reg, buf, 1);
6259 if (ret < 0)
6260 goto err;
6261
6262 reg = 0x1000;
6263 buf[0] = 0x38;
6264 ret = usb_microdia_control_write(dev, reg, buf, 1);
6265 if (ret < 0)
6266 goto err;
6267
6268 reg = 0x11b8;
6269 buf[0] = 0x6b;
6270 ret = usb_microdia_control_write(dev, reg, buf, 1);
6271 if (ret < 0)
6272 goto err;
6273
6274 reg = 0x1000;
6275 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
6276 ret = usb_microdia_control_write(dev, reg, buf, 3);
6277 if (ret < 0)
6278 goto err;
6279
6280 reg = 0x1066;
6281 buf[0] = 0x00;
6282 ret = usb_microdia_control_write(dev, reg, buf, 1);
6283 if (ret < 0)
6284 goto err;
6285
6286 return ret;
6287
6288 err:
6289 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
6290 return ret;
6291 }
6292
6293 /**
6294 * @brief From UsbSnoop-plugin-parsed.log
6295 *
6296 * @param dev
6297 *
6298 * @returns 0 (OK) or <0 (Error)
6299 *
6300 * @author Vincent, Kuzja
6301 */
6302 int microdia_6288_stop_stream(struct usb_microdia *dev)
6303 {
6304 int ret = 0;
6305 __u16 reg;
6306 __u8 buf[8];
6307
6308 reg = 0x1061 ;
6309 buf[0] = 0x01;
6310 ret = usb_microdia_control_write(dev, reg, buf, 1);
6311 if (ret < 0)
6312 goto err;
6313
6314 reg = 0x1000 ;
6315 buf[0] = 0x38;
6316 ret = usb_microdia_control_write(dev, reg, buf, 1);
6317 if (ret < 0)
6318 goto err;
6319
6320 reg = 0x11b8 ;
6321 buf[0] = 0xe9;
6322 ret = usb_microdia_control_write(dev, reg, buf, 1);
6323 if (ret < 0)
6324 goto err;
6325
6326 reg = 0x1007 ;
6327 buf[0] = 0x20;
6328 ret = usb_microdia_control_write(dev, reg, buf, 1);
6329 if (ret < 0)
6330 goto err;
6331
6332 reg = 0x1006 ;
6333 buf[0] = 0x20;
6334 ret = usb_microdia_control_write(dev, reg, buf, 1);
6335 if (ret < 0)
6336 goto err;
6337
6338 reg = 0x1000 ;
6339 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
6340 ret = usb_microdia_control_write(dev, reg, buf, 3);
6341 if (ret < 0)
6342 goto err;
6343
6344 reg = 0x1066 ;
6345 buf[0] = 0x00;
6346 ret = usb_microdia_control_write(dev, reg, buf, 1);
6347 if (ret < 0)
6348 goto err;
6349
6350 return 0;
6351 err:
6352 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
6353 return ret;
6354 }
6355
6356 /**
6357 * @brief Detect whether the image for 624f has to be flipped
6358 *
6359 * @param dev Pointer to device structure
6360 *
6361 * @returns 0 or negative error code
6362 *
6363 */
6364 int microdia_624f_flip_detect(struct usb_microdia *dev)
6365 {
6366 int ret = 0;
6367 __u8 val;
6368
6369 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
6370 if (ret < 0)
6371 return -EAGAIN;
6372 if (val & 0x01)
6373 dev->vsettings.vflip = 1;
6374 else
6375 dev->vsettings.vflip = 0;
6376 return ret;
6377 }
6378
6379 /**
6380 * @brief Detect whether the image for 6260 has to be flipped
6381 *
6382 * @param dev Pointer to device structure
6383 *
6384 * @returns 0 or negative error code
6385 *
6386 */
6387 int microdia_6260_flip_detect(struct usb_microdia *dev)
6388 {
6389 const __u8 flip_bit = 0x01;
6390 int ret = 0;
6391 __u8 val;
6392 static __u8 flip_reg = flip_bit;
6393 __u8 vflip;
6394
6395 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
6396 if (ret < 0)
6397 return -EAGAIN;
6398 if (flip_reg != (val & flip_bit)) {
6399 if (val & flip_bit)
6400 vflip = 0;
6401 else
6402 vflip = 1;
6403 ret = ov7670_auto_flip(dev, vflip);
6404 flip_reg = (val & flip_bit);
6405 }
6406
6407 return ret;
6408 }
6409
Microdia : webcam kernel driver, for USB webcams with vendor id 0c45