?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Auto-exposure for ov96xx sensors.
[microdia.git] / microdia-dev.c
blobcd5f36c80bcbdfc8594a8d4a60ba3f1d3b77f2e4
1 /**
2 * @file microdia-dev.c
3 * @author Nicolas VIVIEN
4 * @date 2008-02-01
5 * @version v0.0.0
6 *
7 * @brief Driver for Microdia USB video camera
8 *
9 * @note Copyright (C) Nicolas VIVIEN
10 *
11 * @par Licences
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28 #include <linux/errno.h>
29 #include <linux/string.h>
30 #include <stdarg.h>
31
32 #include "microdia.h"
33 #include "sn9c20x.h"
34 #include "ov7670.h"
35 #include "ov965x.h"
36 #include "mt9vx11.h"
37 #include "ov7660.h"
38
39 int dev_microdia_init_camera(struct usb_microdia *dev)
40 {
41 return 0;
42 }
43
44 int dev_microdia_camera_on(struct usb_microdia *dev)
45 {
46 int ret = -1;
47 struct usb_device *udev = dev->udev;
48
49 ret = usb_set_interface(udev, 0, 8);
50
51 if (ret < 0)
52 UDIA_ERROR("usb_set_interface failed !\n");
53
54 return ret;
55 }
56
57 int dev_microdia_camera_off(struct usb_microdia *dev)
58 {
59 int ret = -1;
60 struct usb_device *udev = dev->udev;
61
62 ret = usb_set_interface(udev, 0, 0);
63
64 if (ret < 0)
65 UDIA_ERROR("usb_set_interface failed !\n");
66
67 return 0;
68 }
69
70 int dev_microdia_camera_settings(struct usb_microdia *dev)
71 {
72 dev_microdia_camera_set_contrast(dev);
73 dev_microdia_camera_set_brightness(dev);
74 dev_microdia_camera_set_gamma(dev);
75 dev_microdia_camera_set_exposure(dev);
76 dev_microdia_camera_set_hvflip(dev);
77 dev_microdia_camera_set_sharpness(dev);
78 dev_microdia_camera_set_rgb_gain(dev);
79 dev_microdia_camera_set_auto_exposure(dev);
80 dev_microdia_camera_set_auto_whitebalance(dev);
81 return 0;
82 }
83
84 int dev_microdia_camera_set_contrast(struct usb_microdia *dev)
85 {
86 int ret = -ENODEV;
87 if (dev && dev->set_contrast)
88 ret = dev->set_contrast(dev);
89 return ret;
90 }
91
92 int dev_microdia_camera_set_brightness(struct usb_microdia *dev)
93 {
94 int ret = -ENODEV;
95 if (dev && dev->set_brightness)
96 ret = dev->set_brightness(dev);
97 return ret;
98 }
99
100 int dev_microdia_camera_set_gamma(struct usb_microdia *dev)
101 {
102 int ret = -ENODEV;
103 if (dev && dev->set_gamma)
104 ret = dev->set_gamma(dev);
105 return ret;
106 }
107
108 int dev_microdia_camera_set_exposure(struct usb_microdia *dev)
109 {
110 if (dev->set_exposure != NULL)
111 return dev->set_exposure(dev);
112
113 return 0;
114 }
115
116 int dev_microdia_camera_set_hvflip(struct usb_microdia *dev)
117 {
118 int ret = -ENODEV;
119 if (dev && dev->set_hvflip)
120 ret = dev->set_hvflip(dev);
121
122 return ret;
123 }
124
125 int dev_microdia_camera_set_sharpness(struct usb_microdia *dev)
126 {
127 int ret = -ENODEV;
128 if (dev && dev->set_sharpness)
129 ret = dev->set_sharpness(dev);
130
131 return ret;
132 }
133
134 int dev_microdia_camera_set_rgb_gain(struct usb_microdia *dev)
135 {
136 int ret = -ENODEV;
137 if (dev && dev->set_rgb_gain)
138 ret = dev->set_rgb_gain(dev);
139
140 return ret;
141 }
142
143 int dev_microdia_camera_set_auto_exposure(struct usb_microdia *dev)
144 {
145 int ret = -ENODEV;
146 if (dev && dev->set_auto_exposure)
147 ret = dev->set_auto_exposure(dev);
148
149 return ret;
150 }
151
152 int dev_microdia_camera_set_auto_whitebalance(struct usb_microdia *dev)
153 {
154 int ret = -ENODEV;
155 if (dev && dev->set_auto_whitebalance)
156 ret = dev->set_auto_whitebalance(dev);
157
158 return ret;
159 }
160
161
162 /**
163 * @brief From UsbSnoop-plugin-parsed.log
164 *
165 * @param dev
166 *
167 * @returns
168 */
169 int dev_microdia_initialize_device(struct usb_microdia *dev)
170 {
171 int ret = -ENODEV;
172
173 if (dev && dev->initialize)
174 ret = dev->initialize(dev);
175
176 return ret;
177 }
178
179 /**
180 * @brief From init-physical-replug.log
181 *
182 * @param dev
183 *
184 * @returns 0
185 *
186 * @author psnel
187 *
188 * For SN9C201 with MI1300.
189 *
190 */
191 int microdia_6240_initialize(struct usb_microdia *dev)
192 {
193 int ret = 0;
194 __u8 buf;
195
196 UDIA_INFO("Initializing camera...\n");
197
198 ret = usb_microdia_control_read(dev, 0x130d, &buf, 1); /* URB 5 0x81 */
199 UDIA_INFO("...init: read %x, ret = %d\n", buf, ret);
200
201 ret += usb_microdia_control_read(dev, 0x1040, &buf, 1); /* URB 6 0xe4 */
202 UDIA_INFO("...init: read %x, ret = %d\n", buf, ret);
203
204 buf = 0x00;
205 ret += usb_microdia_control_write(dev, 0x10c8, &buf, 1); /* URB 7 */
206 UDIA_INFO("...init: write %x, ret = %d\n", buf, ret);
207
208 /* Interrupt going down (URB 8) */
209
210 buf = 0x80;
211 ret += usb_microdia_control_write(dev, 0x1020, &buf, 1); /* URB 9 */
212 UDIA_INFO("...init: write %x, ret = %d\n", buf, ret);
213
214 if (ret < 4) {
215 UDIA_ERROR("One or more errors occured during initialization!\n");
216 return -1;
217 }
218
219 return 0;
220 }
221
222 /**
223 * @brief From start.log (14 jun 2008)
224 *
225 * @param dev
226 *
227 * @returns 0
228 *
229 * @author psnel
230 *
231 * For SN9C201 with MI1300.
232 *
233 */
234 int microdia_6240_start_stream(struct usb_microdia *dev)
235 {
236 int ret = 0;
237 int i;
238 __u16 reg;
239 __u8 buf;
240 __u8 buf24[24];
241 __u8 buf64[64];
242 __u8 buf1100[64] = { 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
243 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
244 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
245 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
246 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
247 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
248 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
249 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54
250 };
251 UDIA_INFO("Starting camera data stream...\n");
252
253 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
254 // URB 10 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 8
255 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
256 reg = 0x1066;
257 buf = 0x00;
258 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 12 */
259 if (ret < 0)
260 goto err;
261
262 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
263 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: */
264
265 reg = 0x1007;
266 buf = 0x20;
267 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 14 */
268 if (ret < 0)
269 goto err;
270 reg = 0x1006;
271 buf = 0x00;
272 ret = usb_microdia_control_write(dev, reg, &buf, 1);
273 if (ret < 0)
274 goto err;
275 reg = 0x1000;
276 buf = 0x78;
277 ret = usb_microdia_control_write(dev, reg, &buf, 1);
278 if (ret < 0)
279 goto err;
280
281 reg = 0x1001;
282 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* cf */
283 if (ret < 0)
284 goto err;
285
286 reg = 0x1001;
287 buf = 0xc7;
288 ret = usb_microdia_control_write(dev, reg, &buf, 1);
289 if (ret < 0)
290 goto err;
291 reg = 0x1002;
292 buf = 0x18;
293 ret = usb_microdia_control_write(dev, reg, &buf, 1);
294 if (ret < 0)
295 goto err;
296
297 reg = 0x1007;
298 ret = usb_microdia_control_read(dev, reg, buf24, 7); /* URB 20 << 20 00 ff 81 00 00 00 */
299 if (ret < 0)
300 goto err;
301
302 reg = 0x1006;
303 buf24[0] = 0x80; buf24[1] = 0xa0;
304 ret = usb_microdia_control_write(dev, reg, buf24, 2);
305 if (ret < 0)
306 goto err;
307 reg = 0x1061;
308 buf = 0x01;
309 ret = usb_microdia_control_write(dev, reg, &buf, 1);
310 if (ret < 0)
311 goto err;
312 reg = 0x1020;
313 buf = 0x80;
314 ret = usb_microdia_control_write(dev, reg, &buf, 1);
315 if (ret < 0)
316 goto err;
317 reg = 0x1067;
318 buf24[0] = 0x40; buf24[1] = 0x30; buf24[2] = 0x20; buf24[3] = 0x10;
319 buf24[4] = 0x08;
320 ret = usb_microdia_control_write(dev, reg, buf24, 5);
321 if (ret < 0)
322 goto err;
323 reg = 0x10c0;
324 buf24[0] = 0x80; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
325 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
326 buf24[8] = 0x03;
327 ret = usb_microdia_control_write(dev, reg, buf24, 9);
328 if (ret < 0)
329 goto err;
330 reg = 0x10e0;
331 buf = 0x45;
332 ret = usb_microdia_control_write(dev, reg, &buf, 1);
333 if (ret < 0)
334 goto err;
335 reg = 0x10f5;
336 buf = 0x60;
337 ret = usb_microdia_control_write(dev, reg, &buf, 1);
338 if (ret < 0)
339 goto err;
340 reg = 0x10f8;
341 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00;
342 ret = usb_microdia_control_write(dev, reg, buf24, 3);
343 if (ret < 0)
344 goto err;
345 reg = 0x10fb;
346 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
347 buf24[4] = 0x00;
348 ret = usb_microdia_control_write(dev, reg, buf24, 5);
349 if (ret < 0)
350 goto err;
351 reg = 0x1188;
352 buf24[0] = 0x06; buf24[1] = 0x4c; buf24[2] = 0x08;
353 ret = usb_microdia_control_write(dev, reg, buf24, 3);
354 if (ret < 0)
355 goto err;
356
357 reg = 0x118b;
358 buf24[0] = 0x00; buf24[1] = 0x20; buf24[2] = 0x20; buf24[3] = 0x20;
359 buf24[4] = 0x20; buf24[5] = 0x00; buf24[6] = 0x24; buf24[7] = 0x3b;
360 buf24[8] = 0x4f; buf24[9] = 0x61; buf24[10] = 0x71; buf24[11] = 0x80;
361 buf24[12] = 0x8f; buf24[13] = 0x9d; buf24[14] = 0xab; buf24[15] = 0xb8;
362
363 buf24[16] = 0xc4; buf24[17] = 0xd1; buf24[18] = 0xdd; buf24[19] = 0xe9;
364 buf24[20] = 0xf4; buf24[21] = 0xff;
365 ret = usb_microdia_control_write(dev, reg, buf24, 22); /* URB 30 */
366 if (ret < 0)
367 goto err;
368
369 reg = 0x11a1;
370 buf24[0] = 0x00; buf24[1] = 0x00;
371 ret = usb_microdia_control_write(dev, reg, buf24, 2);
372 if (ret < 0)
373 goto err;
374
375 reg = 0x11b7;
376 buf24[0] = 0x60; buf24[1] = 0x28; buf24[2] = 0x00; buf24[3] = 0x08;
377 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
378 buf24[8] = 0x00;
379 ret = usb_microdia_control_write(dev, reg, buf24, 9);
380 if (ret < 0)
381 goto err;
382
383 reg = 0x11b8;
384 buf = 0x38;
385 ret = usb_microdia_control_write(dev, reg, &buf, 1);
386 if (ret < 0)
387 goto err;
388
389 reg = 0x1000;
390 buf = 0x78;
391 ret = usb_microdia_control_write(dev, reg, &buf, 1);
392 if (ret < 0)
393 goto err;
394
395 reg = 0x10c0;
396 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
397 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
398 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 35..90 --> */
399 if (ret < 0)
400 goto err;
401
402 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
403 if (ret < 0)
404 goto err;
405 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
406 if (ret < 0)
407 goto err;
408
409 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
410 buf24[4] = 0x01; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
411 ret = usb_microdia_control_write(dev, reg, buf24, 8);
412 if (ret < 0)
413 goto err;
414
415 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
416 if (ret < 0)
417 goto err;
418 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
419 if (ret < 0)
420 goto err;
421
422 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
423 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
424 ret = usb_microdia_control_write(dev, reg, buf24, 8);
425 if (ret < 0)
426 goto err;
427
428 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
429 if (ret < 0)
430 goto err;
431 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
432 if (ret < 0)
433 goto err;
434
435 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x01; buf24[3] = 0x00;
436 buf24[4] = 0x0e; buf24[5] = 0x00; buf24[6] = 0x14; buf24[7] = 0x10;
437 ret = usb_microdia_control_write(dev, reg, buf24, 8);
438 if (ret < 0)
439 goto err;
440
441 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* URB 45 << d0 */
442 if (ret < 0)
443 goto err;
444 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
445 if (ret < 0)
446 goto err;
447
448 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x03; buf24[3] = 0x03;
449 buf24[4] = 0xc1; buf24[5] = 0x05; buf24[6] = 0x01; buf24[7] = 0x10;
450 ret = usb_microdia_control_write(dev, reg, buf24, 8);
451 if (ret < 0)
452 goto err;
453
454 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
455 if (ret < 0)
456 goto err;
457 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
458 if (ret < 0)
459 goto err;
460
461 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
462 buf24[4] = 0x83; buf24[5] = 0x00; buf24[6] = 0x06; buf24[7] = 0x10;
463 ret = usb_microdia_control_write(dev, reg, buf24, 8);
464 if (ret < 0)
465 goto err;
466
467 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
468 if (ret < 0)
469 goto err;
470 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
471 if (ret < 0)
472 goto err;
473
474 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
475 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
476 ret = usb_microdia_control_write(dev, reg, buf24, 8);
477 if (ret < 0)
478 goto err;
479
480 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
481 if (ret < 0)
482 goto err;
483 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
484 if (ret < 0)
485 goto err;
486
487 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x00;
488 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
489 ret = usb_microdia_control_write(dev, reg, buf24, 8);
490 if (ret < 0)
491 goto err;
492
493 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
494 if (ret < 0)
495 goto err;
496 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
497 if (ret < 0)
498 goto err;
499
500 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x0b; buf24[3] = 0x00;
501 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
502 ret = usb_microdia_control_write(dev, reg, buf24, 8);
503 if (ret < 0)
504 goto err;
505
506 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
507 if (ret < 0)
508 goto err;
509 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
510 if (ret < 0)
511 goto err;
512
513 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x11; buf24[3] = 0x00;
514 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
515 ret = usb_microdia_control_write(dev, reg, buf24, 8);
516 if (ret < 0)
517 goto err;
518
519 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
520 if (ret < 0)
521 goto err;
522 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
523 if (ret < 0)
524 goto err;
525
526 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x1e; buf24[3] = 0x80;
527 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
528 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 65 */
529 if (ret < 0)
530 goto err;
531
532 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
533 if (ret < 0)
534 goto err;
535 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
536 if (ret < 0)
537 goto err;
538
539 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
540 buf24[4] = 0x05; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
541 ret = usb_microdia_control_write(dev, reg, buf24, 8);
542 if (ret < 0)
543 goto err;
544
545 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
546 if (ret < 0)
547 goto err;
548 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
549 if (ret < 0)
550 goto err;
551
552 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
553 buf24[4] = 0x08; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
554 ret = usb_microdia_control_write(dev, reg, buf24, 8);
555 if (ret < 0)
556 goto err;
557
558 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
559 if (ret < 0)
560 goto err;
561 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
562 if (ret < 0)
563 goto err;
564
565 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
566 buf24[4] = 0x14; buf24[5] = 0x00; buf24[6] = 0x08; buf24[7] = 0x10;
567 ret = usb_microdia_control_write(dev, reg, buf24, 8);
568 if (ret < 0)
569 goto err;
570
571 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
572 if (ret < 0)
573 goto err;
574 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
575 if (ret < 0)
576 goto err;
577
578 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
579 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
580 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 77 */
581 if (ret < 0)
582 goto err;
583
584 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 94 */
585 if (ret < 0)
586 goto err;
587
588 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x5f; buf24[3] = 0x89;
589 buf24[4] = 0x04; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
590 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 79 */
591 if (ret < 0)
592 goto err;
593
594 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
595 if (ret < 0)
596 goto err;
597 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
598 if (ret < 0)
599 goto err;
600
601 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x60; buf24[3] = 0x00;
602 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
603 ret = usb_microdia_control_write(dev, reg, buf24, 8);
604 if (ret < 0)
605 goto err;
606
607 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
608 if (ret < 0)
609 goto err;
610 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
611 if (ret < 0)
612 goto err;
613
614 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x62; buf24[3] = 0x04;
615 buf24[4] = 0x98; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
616 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 85 */
617 if (ret < 0)
618 goto err;
619
620 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
621 if (ret < 0)
622 goto err;
623 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
624 if (ret < 0)
625 goto err;
626
627 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x68; buf24[3] = 0x00;
628 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
629 ret = usb_microdia_control_write(dev, reg, buf24, 8);
630 if (ret < 0)
631 goto err;
632
633 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
634 if (ret < 0)
635 goto err;
636 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
637 if (ret < 0)
638 goto err;
639 /* <-- 10c0 */
640 reg = 0x10c1;
641 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* URB 91 // << 5d*/
642 if (ret < 0)
643 goto err;
644 buf = 0x50;
645 ret = usb_microdia_control_write(dev, reg, &buf, 1);
646 if (ret < 0)
647 goto err;
648
649 reg = 0x10c0;
650 buf24[0] = 0x90; buf24[1] = 0x50; buf24[2] = 0x00; buf24[3] = 0x00;
651 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
652 for (i = 93; i <= 108; i++) {
653 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 93..108 */
654 if (ret < 0)
655 goto err;
656 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 9c */
657 if (ret < 0)
658 goto err;
659 }
660 ret = usb_microdia_control_write(dev, reg, buf24, 8);
661 if (ret < 0)
662 goto err;
663
664 buf24[0] = 0x92; /* change only 1st value */
665 for (i = 110; i <= 126; i++) {
666 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 110..126 */
667 if (ret < 0)
668 goto err;
669 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 9e */
670 if (ret < 0)
671 goto err;
672 }
673
674 reg = 0x10c2;
675 ret = usb_microdia_control_read(dev, reg, buf24, 5); /* << ff ff ff ff ff */
676 if (ret < 0)
677 goto err;
678
679 reg = 0x10c1;
680 buf = 0x5d;
681 ret = usb_microdia_control_write(dev, reg, &buf, 1);
682 if (ret < 0)
683 goto err;
684
685 reg = 0x10e0;
686 buf = 0x47;
687 ret = usb_microdia_control_write(dev, reg, &buf, 1);
688 if (ret < 0)
689 goto err;
690 buf = 0x07;
691 ret = usb_microdia_control_write(dev, reg, &buf, 1);
692 if (ret < 0)
693 goto err;
694
695 reg = 0x1001;
696 buf = 0xc6;
697 ret = usb_microdia_control_write(dev, reg, &buf, 1);
698 if (ret < 0)
699 goto err;
700 buf = 0xc4;
701 ret = usb_microdia_control_write(dev, reg, &buf, 1);
702 if (ret < 0)
703 goto err;
704 buf = 0x44;
705 ret = usb_microdia_control_write(dev, reg, &buf, 1);
706 if (ret < 0)
707 goto err;
708
709 reg = 0x1189;
710 buf = 0x0c;
711 ret = usb_microdia_control_write(dev, reg, &buf, 1);
712 if (ret < 0)
713 goto err;
714
715 buf = 0x00;
716 reg = 0x11bc;
717 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 135..138 */
718 if (ret < 0)
719 goto err;
720 reg = 0x11bd;
721 ret = usb_microdia_control_write(dev, reg, &buf, 1);
722 if (ret < 0)
723 goto err;
724 reg = 0x11be;
725 ret = usb_microdia_control_write(dev, reg, &buf, 1);
726 if (ret < 0)
727 goto err;
728 reg = 0x11bf;
729 ret = usb_microdia_control_write(dev, reg, &buf, 1);
730 if (ret < 0)
731 goto err;
732
733 reg = 0x10c0;
734 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
735 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
736 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 139 */
737 if (ret < 0)
738 goto err;
739
740 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
741 if (ret < 0)
742 goto err;
743 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
744 if (ret < 0)
745 goto err;
746
747 reg = 0x1180;
748 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
749 buf24[4] = 0x28; buf24[5] = 0x3c;
750 ret = usb_microdia_control_write(dev, reg, buf24, 6); /* URB 142 */
751 if (ret < 0)
752 goto err;
753
754 reg = 0x10fb;
755 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
756 buf24[4] = 0x00;
757 ret = usb_microdia_control_write(dev, reg, buf24, 5);
758 if (ret < 0)
759 goto err;
760
761 reg = 0x1189;
762 buf = 0x0c;
763 ret = usb_microdia_control_write(dev, reg, &buf, 1);
764 if (ret < 0)
765 goto err;
766
767 reg = 0x11a1;
768 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
769 ret = usb_microdia_control_write(dev, reg, buf24, 4);
770 if (ret < 0)
771 goto err;
772
773 reg = 0x11ab;
774 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
775 ret = usb_microdia_control_write(dev, reg, buf24, 4);
776 if (ret < 0)
777 goto err;
778
779 reg = 0x1000;
780 buf = 0x7c;
781 ret = usb_microdia_control_write(dev, reg, &buf, 1);
782 if (ret < 0)
783 goto err;
784
785 reg = 0x1002;
786 buf = 0x1c;
787 for (i = 148; i <= 149; i++) {
788 ret = usb_microdia_control_write(dev, reg, &buf, 1);
789 if (ret < 0)
790 goto err;
791 }
792
793 reg = 0x11b8;
794 buf = 0x38;
795 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 150 */
796 if (ret < 0)
797 goto err;
798
799 reg = 0x118a;
800 buf = 0x05;
801 ret = usb_microdia_control_write(dev, reg, &buf, 1);
802 if (ret < 0)
803 goto err;
804
805 reg = 0x0395;
806 buf = 0x05;
807 ret = usb_microdia_control_write(dev, reg, &buf, 1);
808 if (ret < 0)
809 goto err;
810
811 reg = 0x11b8;
812 buf = 0x78;
813 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 153..163 */
814 if (ret < 0)
815 goto err;
816 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 38 */
817 if (ret < 0)
818 goto err;
819 buf = 0x79;
820 ret = usb_microdia_control_write(dev, reg, &buf, 1);
821 if (ret < 0)
822 goto err;
823 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 39 */
824 if (ret < 0)
825 goto err;
826 buf = 0x7a;
827 ret = usb_microdia_control_write(dev, reg, &buf, 1);
828 if (ret < 0)
829 goto err;
830 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 3a */
831 if (ret < 0)
832 goto err;
833 buf = 0x7b;
834 ret = usb_microdia_control_write(dev, reg, &buf, 1);
835 if (ret < 0)
836 goto err;
837 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << bb */
838 if (ret < 0)
839 goto err;
840 buf = 0xfc;
841 ret = usb_microdia_control_write(dev, reg, &buf, 1);
842 if (ret < 0)
843 goto err;
844 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << 3c */
845 if (ret < 0)
846 goto err;
847 buf = 0x78;
848 ret = usb_microdia_control_write(dev, reg, &buf, 1);
849 if (ret < 0)
850 goto err;
851 /* <-- 0x11b8 */
852 reg = 0x10c0;
853 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
854 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
855 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 164..169 */
856 if (ret < 0)
857 goto err;
858
859 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
860 if (ret < 0)
861 goto err;
862 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
863 if (ret < 0)
864 goto err;
865
866 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
867 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
868 ret = usb_microdia_control_write(dev, reg, buf24, 8);
869 if (ret < 0)
870 goto err;
871
872 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
873 if (ret < 0)
874 goto err;
875 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
876 if (ret < 0)
877 goto err;
878 /* <-- 0x10c0 */
879 reg = 0x11ba;
880 buf = 0x0a;
881 ret = usb_microdia_control_write(dev, reg, &buf, 1);
882 if (ret < 0)
883 goto err;
884
885 reg = 0x118b;
886 buf = 0x0a;
887 ret = usb_microdia_control_write(dev, reg, &buf, 1);
888 if (ret < 0)
889 goto err;
890
891 reg = 0x10f7;
892 buf = 0x07;
893 ret = usb_microdia_control_write(dev, reg, &buf, 1);
894 if (ret < 0)
895 goto err;
896
897 reg = 0x10f8;
898 buf = 0x14;
899 ret = usb_microdia_control_write(dev, reg, &buf, 1);
900 if (ret < 0)
901 goto err;
902 reg = 0x10fa;
903 buf = 0xff;
904 ret = usb_microdia_control_write(dev, reg, &buf, 1);
905 if (ret < 0)
906 goto err;
907 reg = 0x10f9;
908 buf = 0x00;
909 ret = usb_microdia_control_write(dev, reg, &buf, 1);
910 if (ret < 0)
911 goto err;
912 reg = 0x10f9;
913 ret = usb_microdia_control_write(dev, reg, &buf, 1);
914 if (ret < 0)
915 goto err;
916
917 reg = 0x11ba;
918 buf = 0x0a;
919 ret = usb_microdia_control_write(dev, reg, &buf, 1);
920 if (ret < 0)
921 goto err;
922
923 reg = 0x11bc;
924 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x00;
925 ret = usb_microdia_control_write(dev, reg, buf24, 4);
926 if (ret < 0)
927 goto err;
928
929 reg = 0x11c0;
930 for (i = 0; i < 48; i++)
931 buf64[i] = 0; /* zeroes */
932 ret = usb_microdia_control_write(dev, reg, buf64, 48); /* URB 195 */
933 if (ret < 0)
934 goto err;
935
936 reg = 0x10c0;
937 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
938 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
939 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 200 */
940 if (ret < 0)
941 goto err;
942
943 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
944 if (ret < 0)
945 goto err;
946 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
947 if (ret < 0)
948 goto err;
949
950 reg = 0x1180;
951 buf = 0x02;
952 ret = usb_microdia_control_write(dev, reg, &buf, 1);
953 if (ret < 0)
954 goto err;
955
956 reg = 0x10c0;
957 /*
958 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
959 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
960 */
961 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 204..206 */
962 if (ret < 0)
963 goto err;
964
965 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
966 if (ret < 0)
967 goto err;
968 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
969 if (ret < 0)
970 goto err;
971
972 reg = 0x1182;
973 buf = 0x02;
974 ret = usb_microdia_control_write(dev, reg, &buf, 1);
975 if (ret < 0)
976 goto err;
977
978 reg = 0x10c0;
979 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x03;
980 buf24[4] = 0xe8; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
981 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 208..224 */
982 if (ret < 0)
983 goto err;
984
985 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
986 if (ret < 0)
987 goto err;
988 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
989 if (ret < 0)
990 goto err;
991
992 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
993 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
994 ret = usb_microdia_control_write(dev, reg, buf24, 8);
995 if (ret < 0)
996 goto err;
997
998 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
999 if (ret < 0)
1000 goto err;
1001 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1002 if (ret < 0)
1003 goto err;
1004
1005 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
1006 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1007 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 214 */
1008 if (ret < 0)
1009 goto err;
1010
1011 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1012 if (ret < 0)
1013 goto err;
1014 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1015 if (ret < 0)
1016 goto err;
1017
1018 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
1019 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1020 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1021 if (ret < 0)
1022 goto err;
1023
1024 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1025 if (ret < 0)
1026 goto err;
1027 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1028 if (ret < 0)
1029 goto err;
1030
1031 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
1032 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1033 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1034 if (ret < 0)
1035 goto err;
1036
1037 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1038 if (ret < 0)
1039 goto err;
1040
1041 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1042 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1043 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1044 if (ret < 0)
1045 goto err;
1046
1047 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1048 if (ret < 0)
1049 goto err;
1050 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1051 if (ret < 0)
1052 goto err;
1053
1054 reg = 0x11a5;
1055 buf24[0] = 0x2d; buf24[1] = 0x2d; buf24[2] = 0x3a; buf24[3] = 0x05;
1056 buf24[4] = 0x04; buf24[5] = 0x3f;
1057 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1058 if (ret < 0)
1059 goto err;
1060 reg = 0x11af;
1061 buf24[0] = 0x28; buf24[1] = 0xd8; buf24[2] = 0x14; buf24[3] = 0xec;
1062 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1063 if (ret < 0)
1064 goto err;
1065 reg = 0x11b3;
1066 buf24[0] = 0x32; buf24[1] = 0xdd; buf24[2] = 0x2d; buf24[3] = 0xdd;
1067 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1068 if (ret < 0)
1069 goto err;
1070
1071 reg = 0x10c0;
1072 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1073 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1074 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 232..242 */
1075 if (ret < 0)
1076 goto err;
1077
1078 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1079 if (ret < 0)
1080 goto err;
1081 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1082 if (ret < 0)
1083 goto err;
1084
1085 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2c; buf24[3] = 0x00;
1086 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x1d; buf24[7] = 0x10;
1087 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1088 if (ret < 0)
1089 goto err;
1090
1091 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1092 if (ret < 0)
1093 goto err;
1094 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1095 if (ret < 0)
1096 goto err;
1097
1098 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x30; buf24[3] = 0x00;
1099 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1100 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1101 if (ret < 0)
1102 goto err;
1103
1104 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1105 if (ret < 0)
1106 goto err;
1107
1108 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1109 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1110 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1111 if (ret < 0)
1112 goto err;
1113
1114 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1115 if (ret < 0)
1116 goto err;
1117 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1118 if (ret < 0)
1119 goto err;
1120
1121 reg = 0x10e0;
1122 buf = 0x07;
1123 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1124 if (ret < 0)
1125 goto err;
1126 buf = 0x27;
1127 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1128 if (ret < 0)
1129 goto err;
1130
1131 reg = 0x1100;
1132 ret = usb_microdia_control_write(dev, reg, buf1100, 64); /* URB 249 (see also 509/510) */
1133 if (ret < 0)
1134 goto err;
1135
1136 reg = 0x1140; /* 00000000: */
1137 buf64[0] = 0x0d; buf64[1] = 0x11; buf64[2] = 0x11; buf64[3] = 0x15;
1138 buf64[4] = 0x11; buf64[5] = 0x15; buf64[6] = 0x26; buf64[7] = 0x15;
1139 buf64[8] = 0x15; buf64[9] = 0x26; buf64[10] = 0x54; buf64[11] = 0x36;
1140 buf64[12] = 0x2e; buf64[13] = 0x36; buf64[14] = 0x54; buf64[15] = 0x54; /* 00000010: .. 00000030: 0x54 */
1141 for (i = 16; i <= 63; i++)
1142 buf64[i] = 0x54;
1143 ret = usb_microdia_control_write(dev, reg, buf64, 64); /* URB 250 */
1144 if (ret < 0)
1145 goto err;
1146
1147 reg = 0x10e0;
1148 buf = 0x07;
1149 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1150 if (ret < 0)
1151 goto err;
1152 buf = 0x0b;
1153 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1154 if (ret < 0)
1155 goto err;
1156
1157 reg = 0x1189;
1158 buf = 0x0c;
1159 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1160 if (ret < 0)
1161 goto err;
1162
1163 buf = 0x00;
1164 reg = 0x11bc;
1165 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 254..257 */
1166 if (ret < 0)
1167 goto err;
1168 reg = 0x11bd;
1169 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1170 if (ret < 0)
1171 goto err;
1172 reg = 0x11be;
1173 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1174 if (ret < 0)
1175 goto err;
1176 reg = 0x11bf;
1177 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1178 if (ret < 0)
1179 goto err;
1180
1181 reg = 0x1180;
1182 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
1183 buf24[4] = 0x28; buf24[5] = 0x3c;
1184 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1185 if (ret < 0)
1186 goto err;
1187
1188 reg = 0x10fb;
1189 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1190 buf24[4] = 0x00;
1191 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1192 if (ret < 0)
1193 goto err;
1194
1195 reg = 0x1189;
1196 buf = 0x0c;
1197 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1198 if (ret < 0)
1199 goto err;
1200
1201 reg = 0x11a1;
1202 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
1203 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1204 if (ret < 0)
1205 goto err;
1206 reg = 0x11ab;
1207 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
1208 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1209 if (ret < 0)
1210 goto err;
1211
1212 reg = 0x1061;
1213 buf = 0x03;
1214 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1215 if (ret < 0)
1216 goto err;
1217 reg = 0x11ba;
1218 buf = 0x0a;
1219 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1220 if (ret < 0)
1221 goto err;
1222 reg = 0x11b9;
1223 buf = 0x00;
1224 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1225 if (ret < 0)
1226 goto err;
1227 reg = 0x11ba;
1228 buf = 0x0b;
1229 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1230 if (ret < 0)
1231 goto err;
1232 reg = 0x1061;
1233 buf = 0x01;
1234 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1235 if (ret < 0)
1236 goto err;
1237 reg = 0x1000;
1238 buf = 0x7c;
1239 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1240 if (ret < 0)
1241 goto err;
1242 reg = 0x1002;
1243 buf = 0x1c;
1244 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1245 if (ret < 0)
1246 goto err;
1247 buf = 0x1c;
1248 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1249 if (ret < 0)
1250 goto err;
1251 reg = 0x11b8;
1252 buf = 0x78;
1253 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1254 if (ret < 0)
1255 goto err;
1256 reg = 0x118a;
1257 buf = 0x05;
1258 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1259 if (ret < 0)
1260 goto err;
1261 reg = 0x0395;
1262 buf = 0x05;
1263 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1264 if (ret < 0)
1265 goto err;
1266
1267 reg = 0x11b8;
1268 buf = 0x78;
1269 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 274..284 */
1270 if (ret < 0)
1271 goto err;
1272 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
1273 if (ret < 0)
1274 goto err;
1275 buf = 0x79;
1276 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1277 if (ret < 0)
1278 goto err;
1279 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
1280 if (ret < 0)
1281 goto err;
1282 buf = 0x7a;
1283 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1284 if (ret < 0)
1285 goto err;
1286 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
1287 if (ret < 0)
1288 goto err;
1289 buf = 0x7b;
1290 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1291 if (ret < 0)
1292 goto err;
1293 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
1294 if (ret < 0)
1295 goto err;
1296 buf = 0xfc;
1297 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1298 if (ret < 0)
1299 goto err;
1300 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
1301 if (ret < 0)
1302 goto err;
1303 buf = 0x78;
1304 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1305 if (ret < 0)
1306 goto err;
1307 /* // <-- 0x11b8 */
1308 reg = 0x10c0;
1309 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
1310 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1311 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 285..295 */
1312 if (ret < 0)
1313 goto err;
1314
1315 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1316 if (ret < 0)
1317 goto err;
1318 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1319 if (ret < 0)
1320 goto err;
1321
1322 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1323 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1324 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1325 if (ret < 0)
1326 goto err;
1327
1328 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1329 if (ret < 0)
1330 goto err;
1331 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1332 if (ret < 0)
1333 goto err;
1334
1335 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
1336 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1337 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1338 if (ret < 0)
1339 goto err;
1340
1341 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1342 if (ret < 0)
1343 goto err;
1344
1345 buf24[0] = 0xa2; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
1346 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1347 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1348 if (ret < 0)
1349 goto err;
1350
1351 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a2 */
1352 if (ret < 0)
1353 goto err;
1354 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a6 */
1355 if (ret < 0)
1356 goto err;
1357 /* // <-- 0x10c0 */
1358 reg = 0x10c2;
1359 ret = usb_microdia_control_read(dev, reg, buf24, 5); /* URB 296 // << 00 00 00 84 31 */
1360 if (ret < 0)
1361 goto err;
1362
1363 reg = 0x1061;
1364 buf = 0x03;
1365 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1366 if (ret < 0)
1367 goto err;
1368 buf = 0x01;
1369 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1370 if (ret < 0)
1371 goto err;
1372
1373 reg = 0x10c0;
1374 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1375 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1376 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1377 if (ret < 0)
1378 goto err;
1379
1380 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1381 if (ret < 0)
1382 goto err;
1383 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1384 if (ret < 0)
1385 goto err;
1386
1387 reg = 0x1000;
1388 buf = 0x3c;
1389 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1390 if (ret < 0)
1391 goto err;
1392 reg = 0x11b8;
1393 buf = 0x68;
1394 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1395 if (ret < 0)
1396 goto err;
1397 reg = 0x1007;
1398 buf = 0xa0;
1399 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1400 if (ret < 0)
1401 goto err;
1402 reg = 0x1006;
1403 buf = 0xa0;
1404 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1405 if (ret < 0)
1406 goto err;
1407
1408 reg = 0x1000;
1409 buf24[0] = 0x98; buf24[1] = 0xef; buf24[2] = 0x11;
1410 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1411 if (ret < 0)
1412 goto err;
1413
1414 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1415 // URB 307 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 0
1416 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1417 */
1418
1419 reg = 0x1066;
1420 buf = 0x00;
1421 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1422 if (ret < 0)
1423 goto err;
1424
1425 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1426 // URB 310 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 8
1427 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1428 */
1429 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 312 */
1430 if (ret < 0)
1431 goto err;
1432
1433 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1434 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER:
1435 */
1436
1437 reg = 0x1007;
1438 buf = 0xa0;
1439 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 314 */
1440 if (ret < 0)
1441 goto err;
1442 reg = 0x1006;
1443 buf = 0x80;
1444 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1445 if (ret < 0)
1446 goto err;
1447 reg = 0x1000;
1448 buf = 0x78;
1449 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1450 if (ret < 0)
1451 goto err;
1452 reg = 0x1001;
1453 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << ef */
1454 if (ret < 0)
1455 goto err;
1456 buf = 0xc7;
1457 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1458 if (ret < 0)
1459 goto err;
1460 reg = 0x1002;
1461 buf = 0x18;
1462 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1463 if (ret < 0)
1464 goto err;
1465
1466 reg = 0x1007;
1467 ret = usb_microdia_control_read(dev, reg, buf24, 7); /* URB 320 // << a0 00 ff 81 00 00 00 */
1468 if (ret < 0)
1469 goto err;
1470 reg = 0x1006;
1471 buf24[0] = 0x80; buf24[1] = 0xa0;
1472 ret = usb_microdia_control_write(dev, reg, buf24, 2);
1473 if (ret < 0)
1474 goto err;
1475
1476 reg = 0x1061;
1477 buf = 0x01;
1478 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1479 if (ret < 0)
1480 goto err;
1481 reg = 0x1020;
1482 buf = 0x80;
1483 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1484 if (ret < 0)
1485 goto err;
1486
1487 reg = 0x1067;
1488 buf24[0] = 0x40; buf24[1] = 0x30; buf24[2] = 0x20; buf24[3] = 0x10;
1489 buf24[4] = 0x08;
1490 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1491 if (ret < 0)
1492 goto err;
1493
1494 reg = 0x10c0;
1495 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1496 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1497 buf24[8] = 0x03;
1498 ret = usb_microdia_control_write(dev, reg, buf24, 9);
1499 if (ret < 0)
1500 goto err;
1501
1502 reg = 0x10e0;
1503 /* // 00000000: */
1504 buf = 0x45;
1505 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1506 if (ret < 0)
1507 goto err;
1508 reg = 0x10f5;
1509 buf = 0x60;
1510 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1511 if (ret < 0)
1512 goto err;
1513
1514 reg = 0x10f8;
1515 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00;
1516 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1517 if (ret < 0)
1518 goto err;
1519
1520 reg = 0x10fb;
1521 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1522 buf24[4] = 0x00;
1523 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1524 if (ret < 0)
1525 goto err;
1526
1527 reg = 0x1188;
1528 buf24[0] = 0x06; buf24[1] = 0x4c; buf24[2] = 0x08;
1529 ret = usb_microdia_control_write(dev, reg, buf24, 3);
1530 if (ret < 0)
1531 goto err;
1532
1533 reg = 0x118b;
1534 /* // 00000000: */
1535 buf24[0] = 0x00; buf24[1] = 0x20; buf24[2] = 0x20; buf24[3] = 0x20;
1536 buf24[4] = 0x20; buf24[5] = 0x00; buf24[6] = 0x24; buf24[7] = 0x3b;
1537 buf24[8] = 0x4f; buf24[9] = 0x61; buf24[10] = 0x71; buf24[11] = 0x80;
1538 buf24[12] = 0x8f; buf24[13] = 0x9d; buf24[14] = 0xab; buf24[15] = 0xb8;
1539 /* // 00000010: */
1540 buf24[16] = 0xc4; buf24[17] = 0xd1; buf24[18] = 0xdd; buf24[19] = 0xe9;
1541 buf24[20] = 0xf4; buf24[21] = 0xff;
1542 ret = usb_microdia_control_write(dev, reg, buf24, 22); /* URB 330 */
1543 if (ret < 0)
1544 goto err;
1545
1546 reg = 0x11a1;
1547 buf24[0] = 0x00; buf24[1] = 0x00;
1548 ret = usb_microdia_control_write(dev, reg, buf24, 2);
1549 if (ret < 0)
1550 goto err;
1551
1552 reg = 0x11b7;
1553 buf24[0] = 0x60; buf24[1] = 0x28; buf24[2] = 0x00; buf24[3] = 0x08;
1554 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x00;
1555 buf24[8] = 0x00;
1556 ret = usb_microdia_control_write(dev, reg, buf24, 9);
1557 if (ret < 0)
1558 goto err;
1559
1560 reg = 0x11b8;
1561 buf = 0x38;
1562 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1563 if (ret < 0)
1564 goto err;
1565 reg = 0x1000;
1566 buf = 0x78;
1567 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1568 if (ret < 0)
1569 goto err;
1570
1571 reg = 0x10c0;
1572 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
1573 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1574 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 335..390 */
1575 if (ret < 0)
1576 goto err;
1577
1578 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1579 if (ret < 0)
1580 goto err;
1581 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1582 if (ret < 0)
1583 goto err;
1584
1585 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1586 buf24[4] = 0x01; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1587 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1588 if (ret < 0)
1589 goto err;
1590
1591 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1592 if (ret < 0)
1593 goto err;
1594 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1595 if (ret < 0)
1596 goto err;
1597
1598 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1599 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1600 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1601 if (ret < 0)
1602 goto err;
1603
1604 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1605 if (ret < 0)
1606 goto err;
1607 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1608 if (ret < 0)
1609 goto err;
1610
1611 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x01; buf24[3] = 0x00;
1612 buf24[4] = 0x0e; buf24[5] = 0x00; buf24[6] = 0x14; buf24[7] = 0x10;
1613 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 344 */
1614 if (ret < 0)
1615 goto err;
1616
1617 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1618 if (ret < 0)
1619 goto err;
1620 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1621 if (ret < 0)
1622 goto err;
1623
1624 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x03; buf24[3] = 0x03;
1625 buf24[4] = 0xc1; buf24[5] = 0x05; buf24[6] = 0x01; buf24[7] = 0x10;
1626 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1627 if (ret < 0)
1628 goto err;
1629
1630 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1631 if (ret < 0)
1632 goto err;
1633 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1634 if (ret < 0)
1635 goto err;
1636
1637 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1638 buf24[4] = 0x83; buf24[5] = 0x00; buf24[6] = 0x06; buf24[7] = 0x10;
1639 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1640 if (ret < 0)
1641 goto err;
1642
1643 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1644 if (ret < 0)
1645 goto err;
1646 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1647 if (ret < 0)
1648 goto err;
1649
1650 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x0d; buf24[3] = 0x00;
1651 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1652 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1653 if (ret < 0)
1654 goto err;
1655
1656 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1657 if (ret < 0)
1658 goto err;
1659 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1660 if (ret < 0)
1661 goto err;
1662
1663 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x09; buf24[3] = 0x00;
1664 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1665 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 356 */
1666 if (ret < 0)
1667 goto err;
1668
1669 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1670 if (ret < 0)
1671 goto err;
1672 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1673 if (ret < 0)
1674 goto err;
1675
1676 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x0b; buf24[3] = 0x00;
1677 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1678 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1679 if (ret < 0)
1680 goto err;
1681
1682 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1683 if (ret < 0)
1684 goto err;
1685 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1686 if (ret < 0)
1687 goto err;
1688
1689 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x11; buf24[3] = 0x00;
1690 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1691 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1692 if (ret < 0)
1693 goto err;
1694
1695 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1696 if (ret < 0)
1697 goto err;
1698 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1699 if (ret < 0)
1700 goto err;
1701
1702 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x1e; buf24[3] = 0x80;
1703 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1704 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 365 */
1705 if (ret < 0)
1706 goto err;
1707
1708 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1709 if (ret < 0)
1710 goto err;
1711 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1712 if (ret < 0)
1713 goto err;
1714
1715 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
1716 buf24[4] = 0x05; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1717 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1718 if (ret < 0)
1719 goto err;
1720
1721 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1722 if (ret < 0)
1723 goto err;
1724 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1725 if (ret < 0)
1726 goto err;
1727
1728 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
1729 buf24[4] = 0x08; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
1730 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1731 if (ret < 0)
1732 goto err;
1733
1734 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1735 if (ret < 0)
1736 goto err;
1737 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1738 if (ret < 0)
1739 goto err;
1740
1741 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
1742 buf24[4] = 0x14; buf24[5] = 0x00; buf24[6] = 0x08; buf24[7] = 0x10;
1743 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1744 if (ret < 0)
1745 goto err;
1746
1747 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
1748 if (ret < 0)
1749 goto err;
1750 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
1751 if (ret < 0)
1752 goto err;
1753
1754 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
1755 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1756 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 377 */
1757 if (ret < 0)
1758 goto err;
1759
1760 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
1761 if (ret < 0)
1762 goto err;
1763
1764 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x5f; buf24[3] = 0x89;
1765 buf24[4] = 0x04; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1766 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1767 if (ret < 0)
1768 goto err;
1769
1770 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
1771 if (ret < 0)
1772 goto err;
1773 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
1774 if (ret < 0)
1775 goto err;
1776
1777 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x60; buf24[3] = 0x00;
1778 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1779 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1780 if (ret < 0)
1781 goto err;
1782
1783 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
1784 if (ret < 0)
1785 goto err;
1786 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
1787 if (ret < 0)
1788 goto err;
1789
1790 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x62; buf24[3] = 0x04;
1791 buf24[4] = 0x98; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1792 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 385 */
1793 if (ret < 0)
1794 goto err;
1795
1796 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d0 */
1797 if (ret < 0)
1798 goto err;
1799 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << d4 */
1800 if (ret < 0)
1801 goto err;
1802
1803 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x68; buf24[3] = 0x00;
1804 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1805 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1806 if (ret < 0)
1807 goto err;
1808
1809 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b0 */
1810 if (ret < 0)
1811 goto err;
1812 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* << b4 */
1813 if (ret < 0)
1814 goto err;
1815 /* <-- 0x10c0 */
1816 reg = 0x10e0;
1817 buf = 0x47;
1818 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 391 */
1819 if (ret < 0)
1820 goto err;
1821 buf = 0x07;
1822 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1823 if (ret < 0)
1824 goto err;
1825
1826 reg = 0x1001;
1827 buf = 0xc6;
1828 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1829 if (ret < 0)
1830 goto err;
1831 buf = 0xc4;
1832 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1833 if (ret < 0)
1834 goto err;
1835 buf = 0x44;
1836 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1837 if (ret < 0)
1838 goto err;
1839
1840 reg = 0x1189;
1841 buf = 0x0c;
1842 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1843 if (ret < 0)
1844 goto err;
1845
1846 buf = 0x00;
1847 reg = 0x11bc;
1848 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 397..400 */
1849 if (ret < 0)
1850 goto err;
1851 reg = 0x11bd;
1852 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1853 if (ret < 0)
1854 goto err;
1855 reg = 0x11be;
1856 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1857 if (ret < 0)
1858 goto err;
1859 reg = 0x11bf;
1860 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1861 if (ret < 0)
1862 goto err;
1863
1864 reg = 0x10c0;
1865 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
1866 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1867 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 401 */
1868 if (ret < 0)
1869 goto err;
1870
1871 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1872 if (ret < 0)
1873 goto err;
1874 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1875 if (ret < 0)
1876 goto err;
1877
1878 reg = 0x1180;
1879 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
1880 buf24[4] = 0x28; buf24[5] = 0x3c;
1881 ret = usb_microdia_control_write(dev, reg, buf24, 6);
1882 if (ret < 0)
1883 goto err;
1884 reg = 0x10fb;
1885 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
1886 buf24[4] = 0x00;
1887 ret = usb_microdia_control_write(dev, reg, buf24, 5);
1888 if (ret < 0)
1889 goto err;
1890
1891 reg = 0x1189;
1892 buf = 0x0c;
1893 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1894 if (ret < 0)
1895 goto err;
1896
1897 reg = 0x11a1;
1898 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
1899 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1900 if (ret < 0)
1901 goto err;
1902 reg = 0x11ab;
1903 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
1904 ret = usb_microdia_control_write(dev, reg, buf24, 4);
1905 if (ret < 0)
1906 goto err;
1907
1908 reg = 0x1000;
1909 buf = 0x7c;
1910 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1911 if (ret < 0)
1912 goto err;
1913
1914 reg = 0x1002;
1915 buf = 0x1c;
1916 for (i = 410; i <= 411; i++) {
1917 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1918 if (ret < 0)
1919 goto err;
1920 }
1921
1922 reg = 0x11b8;
1923 buf = 0x38;
1924 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1925 if (ret < 0)
1926 goto err;
1927 reg = 0x118a;
1928 buf = 0x05;
1929 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1930 if (ret < 0)
1931 goto err;
1932 reg = 0x0395;
1933 buf = 0x05;
1934 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1935 if (ret < 0)
1936 goto err;
1937
1938 reg = 0x11b8;
1939 buf = 0x78;
1940 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 415..425 */
1941 if (ret < 0)
1942 goto err;
1943 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
1944 if (ret < 0)
1945 goto err;
1946 buf = 0x79;
1947 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1948 if (ret < 0)
1949 goto err;
1950 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
1951 if (ret < 0)
1952 goto err;
1953 buf = 0x7a;
1954 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1955 if (ret < 0)
1956 goto err;
1957 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
1958 if (ret < 0)
1959 goto err;
1960 buf = 0x7b;
1961 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1962 if (ret < 0)
1963 goto err;
1964 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
1965 if (ret < 0)
1966 goto err;
1967 buf = 0xfc;
1968 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1969 if (ret < 0)
1970 goto err;
1971 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
1972 if (ret < 0)
1973 goto err;
1974 buf = 0x78;
1975 ret = usb_microdia_control_write(dev, reg, &buf, 1);
1976 if (ret < 0)
1977 goto err;
1978 /* // <-- 0x11b8 */
1979 reg = 0x10c0;
1980
1981 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
1982 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1983 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 426..431 */
1984 if (ret < 0)
1985 goto err;
1986
1987 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
1988 if (ret < 0)
1989 goto err;
1990 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
1991 if (ret < 0)
1992 goto err;
1993
1994 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
1995 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
1996 ret = usb_microdia_control_write(dev, reg, buf24, 8);
1997 if (ret < 0)
1998 goto err;
1999
2000 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2001 if (ret < 0)
2002 goto err;
2003 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2004 if (ret < 0)
2005 goto err;
2006 /* // <-- 0x10c0 */
2007 reg = 0x11ba;
2008 buf = 0x0a;
2009 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2010 if (ret < 0)
2011 goto err;
2012
2013 reg = 0x118b;
2014 buf = 0x0a;
2015 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2016 if (ret < 0)
2017 goto err;
2018
2019 reg = 0x10f7;
2020 buf = 0x07;
2021 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2022 if (ret < 0)
2023 goto err;
2024
2025 reg = 0x10f8;
2026 buf = 0x14;
2027 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2028 if (ret < 0)
2029 goto err;
2030 reg = 0x10fa;
2031 buf = 0xff;
2032 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2033 if (ret < 0)
2034 goto err;
2035
2036 reg = 0x10f9;
2037 buf = 0x00;
2038 for (i = 453; i < 454; i++) {
2039 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2040 if (ret < 0)
2041 goto err;
2042 }
2043
2044 reg = 0x11ba;
2045 buf = 0x0a;
2046 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2047 if (ret < 0)
2048 goto err;
2049
2050 reg = 0x11bc;
2051 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x00;
2052 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2053 if (ret < 0)
2054 goto err;
2055
2056 reg = 0x11c0;
2057 for (i = 0; i < 48; i++)
2058 buf64[i] = 0; /* // zeroes */
2059 ret = usb_microdia_control_write(dev, reg, buf64, 48); /* URB 457 */
2060 if (ret < 0)
2061 goto err;
2062
2063 reg = 0x10c0;
2064 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
2065 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2066 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 462 */
2067 if (ret < 0)
2068 goto err;
2069
2070 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2071 if (ret < 0)
2072 goto err;
2073 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2074 if (ret < 0)
2075 goto err;
2076
2077 reg = 0x1180;
2078 buf = 0x02;
2079 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2080 if (ret < 0)
2081 goto err;
2082
2083 reg = 0x10c0;
2084 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x20; buf24[3] = 0x11;
2085 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2086 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 466 */
2087 if (ret < 0)
2088 goto err;
2089
2090 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2091 if (ret < 0)
2092 goto err;
2093 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2094 if (ret < 0)
2095 goto err;
2096
2097 reg = 0x1182;
2098 buf = 0x02;
2099 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2100 if (ret < 0)
2101 goto err;
2102
2103 reg = 0x10c0;
2104 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2105 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2106 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 470..483 */
2107 if (ret < 0)
2108 goto err;
2109
2110 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2111 if (ret < 0)
2112 goto err;
2113 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2114 if (ret < 0)
2115 goto err;
2116
2117 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2b; buf24[3] = 0x00;
2118 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
2119 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2120 if (ret < 0)
2121 goto err;
2122
2123 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
2124 if (ret < 0)
2125 goto err;
2126 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2127 if (ret < 0)
2128 goto err;
2129
2130 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2d; buf24[3] = 0x00;
2131 buf24[4] = 0x10; buf24[5] = 0x00; buf24[6] = 0x10; buf24[7] = 0x10;
2132 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2133 if (ret < 0)
2134 goto err;
2135
2136 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d0 */
2137 if (ret < 0)
2138 goto err;
2139 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2140 if (ret < 0)
2141 goto err;
2142
2143 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x33; buf24[3] = 0x00;
2144 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2145 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 479 */
2146 if (ret < 0)
2147 goto err;
2148
2149 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2150 if (ret < 0)
2151 goto err;
2152
2153 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2154 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2155 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2156 if (ret < 0)
2157 goto err;
2158
2159 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2160 if (ret < 0)
2161 goto err;
2162 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2163 if (ret < 0)
2164 goto err;
2165 /* // <-- 0x10c0 */
2166 reg = 0x11a5;
2167 buf24[0] = 0x2d; buf24[1] = 0x2d; buf24[2] = 0x3a; buf24[3] = 0x05;
2168 buf24[4] = 0x04; buf24[5] = 0x3f;
2169 ret = usb_microdia_control_write(dev, reg, buf24, 6);
2170 if (ret < 0)
2171 goto err;
2172 reg = 0x11af;
2173 buf24[0] = 0x28; buf24[1] = 0xd8; buf24[2] = 0x14; buf24[3] = 0xec;
2174 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2175 if (ret < 0)
2176 goto err;
2177 reg = 0x11b3;
2178 buf24[0] = 0x32; buf24[1] = 0xdd; buf24[2] = 0x2d; buf24[3] = 0xdd;
2179 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2180 if (ret < 0)
2181 goto err;
2182
2183 reg = 0x10c0;
2184 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2185 buf24[4] = 0x03; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2186 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 491..502 */
2187 if (ret < 0)
2188 goto err;
2189
2190 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2191 if (ret < 0)
2192 goto err;
2193 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2194 if (ret < 0)
2195 goto err;
2196
2197 buf24[0] = 0xd0; buf24[1] = 0x5d; buf24[2] = 0x2c; buf24[3] = 0x00;
2198 buf24[4] = 0x1d; buf24[5] = 0x00; buf24[6] = 0x1d; buf24[7] = 0x10;
2199 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2200 if (ret < 0)
2201 goto err;
2202
2203 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 495: d0 */
2204 if (ret < 0)
2205 goto err;
2206 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 496: d0 */
2207 if (ret < 0)
2208 goto err;
2209 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << d4 */
2210 if (ret < 0)
2211 goto err;
2212
2213 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x30; buf24[3] = 0x00;
2214 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2215 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2216 if (ret < 0)
2217 goto err;
2218
2219 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2220 if (ret < 0)
2221 goto err;
2222
2223 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x07; buf24[3] = 0x00;
2224 buf24[4] = 0x02; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2225 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2226 if (ret < 0)
2227 goto err;
2228
2229 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2230 if (ret < 0)
2231 goto err;
2232 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2233 if (ret < 0)
2234 goto err;
2235 /* // <-- 0x10c0 */
2236 reg = 0x10e0;
2237 buf = 0x07;
2238 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2239 if (ret < 0)
2240 goto err;
2241 buf = 0x27;
2242 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2243 if (ret < 0)
2244 goto err;
2245
2246 reg = 0x1100;
2247 ret = usb_microdia_control_write(dev, reg, buf1100, 64); /* URB 509 (see also 249/250) */
2248 if (ret < 0)
2249 goto err;
2250
2251 reg = 0x1140;
2252 /* 00000000: */
2253 buf64[0] = 0x0d; buf64[1] = 0x11; buf64[2] = 0x11; buf64[3] = 0x15;
2254 buf64[4] = 0x11; buf64[5] = 0x15; buf64[6] = 0x26; buf64[7] = 0x15;
2255 buf64[8] = 0x15; buf64[9] = 0x26; buf64[10] = 0x54; buf64[11] = 0x36;
2256 buf64[12] = 0x2e; buf64[13] = 0x36; buf64[14] = 0x54; buf64[15] = 0x54;
2257 /* 00000010: .. 00000030: 0x54 */
2258 for (i = 16; i <= 63; i++)
2259 buf64[i] = 0x54;
2260 ret = usb_microdia_control_write(dev, reg, buf64, 64); /* URB 510 */
2261 if (ret < 0)
2262 goto err;
2263
2264 reg = 0x10e0;
2265 buf = 0x07;
2266 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2267 if (ret < 0)
2268 goto err;
2269 buf = 0x0b;
2270 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2271 if (ret < 0)
2272 goto err;
2273
2274 reg = 0x1189;
2275 buf = 0x0c;
2276 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2277 if (ret < 0)
2278 goto err;
2279
2280 buf = 0x00;
2281 reg = 0x11bc;
2282 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 514..517 */
2283 if (ret < 0)
2284 goto err;
2285 reg = 0x11bd;
2286 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2287 if (ret < 0)
2288 goto err;
2289 reg = 0x11be;
2290 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2291 if (ret < 0)
2292 goto err;
2293 reg = 0x11bf;
2294 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2295 if (ret < 0)
2296 goto err;
2297
2298 reg = 0x1180;
2299 buf24[0] = 0x02; buf24[1] = 0x00; buf24[2] = 0x02; buf24[3] = 0x00;
2300 buf24[4] = 0x28; buf24[5] = 0x3c;
2301 ret = usb_microdia_control_write(dev, reg, buf24, 6);
2302
2303 reg = 0x10fb;
2304 buf24[0] = 0x00; buf24[1] = 0xa0; buf24[2] = 0x00; buf24[3] = 0xf0;
2305 buf24[4] = 0x00;
2306 ret = usb_microdia_control_write(dev, reg, buf24, 5);
2307
2308 reg = 0x1189;
2309 buf = 0x0c;
2310 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2311 if (ret < 0)
2312 goto err;
2313
2314 reg = 0x11a1;
2315 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x6a; buf24[3] = 0x50;
2316 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2317
2318 reg = 0x11ab;
2319 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x50; buf24[3] = 0x3c;
2320 ret = usb_microdia_control_write(dev, reg, buf24, 4);
2321
2322 reg = 0x1061;
2323 buf = 0x03;
2324 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2325 if (ret < 0)
2326 goto err;
2327 reg = 0x11ba;
2328 buf = 0x0a;
2329 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2330 if (ret < 0)
2331 goto err;
2332 reg = 0x11b9;
2333 buf = 0x00;
2334 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2335 if (ret < 0)
2336 goto err;
2337 reg = 0x11ba;
2338 buf = 0x0b;
2339 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2340 if (ret < 0)
2341 goto err;
2342 reg = 0x1061;
2343 buf = 0x01;
2344 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2345 if (ret < 0)
2346 goto err;
2347 reg = 0x1000;
2348 buf = 0x7c;
2349 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2350 if (ret < 0)
2351 goto err;
2352
2353 reg = 0x1002;
2354 buf = 0x1c;
2355 for (i = 529; i <= 530; i++) {
2356 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2357 if (ret < 0)
2358 goto err;
2359 }
2360
2361 reg = 0x11b8;
2362 buf = 0x78;
2363 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2364 if (ret < 0)
2365 goto err;
2366 reg = 0x118a;
2367 buf = 0x05;
2368 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2369 if (ret < 0)
2370 goto err;
2371 reg = 0x0395;
2372 buf = 0x05;
2373 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2374 if (ret < 0)
2375 goto err;
2376
2377 reg = 0x11b8;
2378 buf = 0x78;
2379 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 534..544 */
2380 if (ret < 0)
2381 goto err;
2382 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 38 */
2383 if (ret < 0)
2384 goto err;
2385 buf = 0x79;
2386 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2387 if (ret < 0)
2388 goto err;
2389 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 39 */
2390 if (ret < 0)
2391 goto err;
2392 buf = 0x7a;
2393 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2394 if (ret < 0)
2395 goto err;
2396 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3a */
2397 if (ret < 0)
2398 goto err;
2399 buf = 0x7b;
2400 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2401 if (ret < 0)
2402 goto err;
2403 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << bb */
2404 if (ret < 0)
2405 goto err;
2406 buf = 0xfc;
2407 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2408 if (ret < 0)
2409 goto err;
2410 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 3c */
2411 if (ret < 0)
2412 goto err;
2413 buf = 0x78;
2414 ret = usb_microdia_control_write(dev, reg, &buf, 1);
2415 if (ret < 0)
2416 goto err;
2417 /* // <-- 0x11b8 */
2418 reg = 0x10c0;
2419 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x06; buf24[3] = 0x00;
2420 buf24[4] = 0xf2; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2421 ret = usb_microdia_control_write(dev, reg, buf24, 8); /* URB 545..555 */
2422 if (ret < 0)
2423 goto err;
2424
2425 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2426 if (ret < 0)
2427 goto err;
2428 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2429 if (ret < 0)
2430 goto err;
2431
2432 buf24[0] = 0xb0; buf24[1] = 0x5d; buf24[2] = 0x05; buf24[3] = 0x00;
2433 buf24[4] = 0x13; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2434 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2435 if (ret < 0)
2436 goto err;
2437
2438 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b0 */
2439 if (ret < 0)
2440 goto err;
2441 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << b4 */
2442 if (ret < 0)
2443 goto err;
2444
2445 buf24[0] = 0x90; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
2446 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2447 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2448 if (ret < 0)
2449 goto err;
2450
2451 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << 94 */
2452 if (ret < 0)
2453 goto err;
2454
2455 buf24[0] = 0xa2; buf24[1] = 0x5d; buf24[2] = 0x00; buf24[3] = 0x00;
2456 buf24[4] = 0x00; buf24[5] = 0x00; buf24[6] = 0x00; buf24[7] = 0x10;
2457 ret = usb_microdia_control_write(dev, reg, buf24, 8);
2458 if (ret < 0)
2459 goto err;
2460
2461 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a2 */
2462 if (ret < 0)
2463 goto err;
2464 ret = usb_microdia_control_read(dev, reg, &buf, 1); /* // << a6 */
2465 if (ret < 0)
2466 goto err;
2467 /* // <-- 0x10c0 */
2468 reg = 0x10c2;
2469 buf24[0] = 0x00; buf24[1] = 0x00; buf24[2] = 0x00; buf24[3] = 0x84;
2470 buf24[4] = 0x31;
2471 ret = usb_microdia_control_write(dev, reg, buf24, 5);
2472 if (ret < 0)
2473 goto err;
2474
2475 reg = 0x1061;
2476 buf = 0x03;
2477 ret = usb_microdia_control_write(dev, reg, &buf, 1); /* URB 557 */
2478 if (ret < 0)
2479 goto err;
2480
2481 /* UNKNOWN -- URB_FUNCTION_RESET_PIPE:
2482 // UNKNOWN -- URB_FUNCTION_RESET_PIPE:
2483 // UNKNOWN -- URB_FUNCTION_GET_CURRENT_FRAME_NUMBER:
2484 // UNKNOWN -- URB_FUNCTION_GET_CURRENT_FRAME_NUMBER:
2485 // URB 560 >>> SENDING ISO REQUEST
2486 */
2487 UDIA_INFO("...start function completed without errors.\n");
2488 return ret;
2489 err:
2490 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
2491 return ret;
2492 }
2493
2494 /**
2495 * @brief From stop-close-amcap.log
2496 *
2497 * @param dev
2498 *
2499 * @returns 0
2500 *
2501 * @author psnel
2502 *
2503 * For SN9C201 with MI1300. Comments from parser-usbsnoop(updated_13Mar2008).pl output
2504 *
2505 */
2506 int microdia_6240_stop_stream(struct usb_microdia *dev)
2507 {
2508 int ret = 0;
2509 __u8 buf[8];
2510
2511 UDIA_INFO("Stopping camera...\n");
2512
2513 buf[0] = 0x01;
2514 ret = usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 25319 */
2515 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2516
2517 buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00;
2518 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
2519 ret += usb_microdia_control_write(dev, 0x10c0, buf, 8); /* URB 25320 */
2520 UDIA_INFO("...stop: write buf[8], ret = %d\n", ret);
2521
2522 ret += usb_microdia_control_read(dev, 0x10c0, buf, 1); /* URB 25321 << b0 */
2523 UDIA_INFO("...stop: read %x, ret = %d\n", buf[0], ret);
2524
2525 ret += usb_microdia_control_read(dev, 0x10c0, buf, 1); /* URB 25322 << b4 */
2526 UDIA_INFO("...stop: read %x, ret = %d\n", buf[0], ret);
2527
2528 buf[0] = 0x3c;
2529 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 25323 */
2530 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2531
2532 buf[0] = 0x68;
2533 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 25324 */
2534 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2535
2536 buf[0] = 0xa0;
2537 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 25325 */
2538 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2539
2540 buf[0] = 0xa0;
2541 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 25326 */
2542 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2543
2544 buf[0] = 0x98; buf[1] = 0xef; buf[2] = 0x11;
2545 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 25327 */
2546 UDIA_INFO("...stop: write buf[3], ret = %d\n", ret);
2547
2548 /* UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: (URB 5009)
2549 // URB 25328 <<< GETTING SELECT_INTERFACE Interface: AlternateSetting = 0
2550 // UNKNOWN -- URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: (URB 25329)
2551 */
2552
2553 buf[0] = 0x00;
2554 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 25330 */
2555 UDIA_INFO("...stop: write %x, ret = %d\n", buf[0], ret);
2556
2557 if (ret < 19) {
2558 UDIA_ERROR("One ore more errors occured during stop sequence !\n");
2559 return -1;
2560 }
2561
2562 return 0;
2563 }
2564
2565 /**
2566 * @brief From init.sequence.log
2567 *
2568 * @param dev
2569 *
2570 * @returns 0
2571 *
2572 * @author GWater
2573 *
2574 * For SN9C201 with SOI968.
2575 * Tests showed this function is actually unnecessary.
2576 * Nevertheless the reads may give us valuable values we don't know about yet.
2577 */
2578 int microdia_624e_initialize(struct usb_microdia *dev)
2579 {
2580 __u8 buf;
2581
2582 usb_microdia_control_read(dev, 0x130d, &buf, 1);
2583 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2584
2585 return 0;
2586 }
2587
2588 /**
2589 * @brief From UsbSnoop-plugin-parsed.log
2590 *
2591 * @param dev
2592 *
2593 * @returns
2594 */
2595 int microdia_624f_initialize(struct usb_microdia *dev)
2596 {
2597 /* Do nothing here */
2598 return 0;
2599 }
2600
2601 /**
2602 * @brief From UsbSnoop-plugin-parsed.log
2603 *
2604 * @param dev
2605 *
2606 * @returns
2607 */
2608 int microdia_6260_initialize(struct usb_microdia *dev)
2609 {
2610 __u8 buf;
2611
2612 usb_microdia_control_read(dev, 0x130d, &buf, 1);
2613 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2614 buf = 0x00;
2615 usb_microdia_control_write(dev, 0x10c8, &buf, 1);
2616 usb_microdia_control_read(dev, 0x100a, &buf, 1);
2617 buf = 0x04;
2618 usb_microdia_control_write(dev, 0x100a, &buf, 1);
2619 usb_microdia_control_read(dev, 0x100b, &buf, 1);
2620 buf = 0x04;
2621 usb_microdia_control_write(dev, 0x100b, &buf, 1);
2622 usb_microdia_control_read(dev, 0x1001, &buf, 1);
2623 buf = 0xc7;
2624 usb_microdia_control_write(dev, 0x1001, &buf, 1);
2625 usb_microdia_control_read(dev, 0x1040, &buf, 1);
2626 buf = 0x00;
2627 usb_microdia_control_write(dev, 0x1040, &buf, 1);
2628 usb_microdia_control_read(dev, 0x1045, &buf, 1);
2629 buf = 0x04;
2630 usb_microdia_control_write(dev, 0x1045, &buf, 1);
2631 usb_microdia_control_read(dev, 0x1046, &buf, 1);
2632 buf = 0x10;
2633 usb_microdia_control_write(dev, 0x1046, &buf, 1);
2634 buf = 0x14;
2635 usb_microdia_control_write(dev, 0x1045, &buf, 1);
2636 buf = 0x01;
2637 usb_microdia_control_write(dev, 0x1040, &buf, 1);
2638 buf = 0x80;
2639 usb_microdia_control_write(dev, 0x1020, &buf, 1);
2640
2641 return 0;
2642 }
2643
2644 /**
2645 * @brief From 6 init-logs
2646 *
2647 * @param dev
2648 *
2649 * @returns 0 (ok) or -1 (error)
2650 *
2651 * @author Comer352l
2652 *
2653 * Windows driver versions: 5.5.8.12 and 5.7.23.000
2654 * Windows versions: 2000 and XP
2655 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
2656 *
2657 * Comments behind read oprations contain HEX-values that appeared in the logs
2658 */
2659 int microdia_6270_initialize(struct usb_microdia *dev)
2660 {
2661 /* int actual; */
2662 int ret = 0;
2663 int retSP = 0;
2664 int retASS = 0;
2665 __u8 buf[8];
2666 __u8 buf_0395[1];
2667 __u8 buf_1000[5];
2668 __u8 buf_1060[2];
2669 __u8 buf_11b8[1];
2670
2671 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81,0x85,0x04,0x8b,0x02,... */
2672
2673 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4,0xc4,0xa4,0x44,... */
2674
2675 /*
2676 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
2677 * buf[0]=0x00;
2678 * usb_microdia_control_write(dev, 0x10c8, buf, 1);
2679 */
2680
2681 ret += usb_microdia_control_read(dev, 0x118a, buf, 1); /* URB 7 0x05,0x7b,0x01,0x04,... */
2682
2683 ret += usb_microdia_control_read(dev, 0x0395, buf_0395, 1); /* URB 8 0xc2,0x82,0x38,0x98,0x04,... */
2684 /* => this value will be rewritten to 0x118a and 0x0395 later (URBs 81+82) */
2685
2686 buf[0] = 0x05;
2687 ret += usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 9 */
2688
2689 ret += usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 10 */
2690
2691 ret += usb_microdia_control_read(dev, 0x11b8, buf_11b8, 1); /* URB 11 0xa0,0x00,0x24,... */
2692 /* => this value will be rewritten to 0x11b8 later (URB 83) */
2693
2694 buf[0] = 0x10;
2695 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 12 */
2696
2697 ret += usb_microdia_control_read(dev, 0x1000, buf_1000, 5); /* URB 13 0x30 0xCF 0x00 0x03 (0x02 or 0x00) */
2698 /* => these values will be rewritten to 0x1000 later (URB 84) */
2699
2700 buf[0] = 0x70; buf[1] = 0x00; buf[2] = 0x18; buf[3] = 0x00; buf[4] = 0x00;
2701 ret += usb_microdia_control_write(dev, 0x1000, buf, 5); /* URB 14 */
2702
2703 ret += usb_microdia_control_read(dev, 0x1060, buf_1060, 2); /* URB 15 0x08 0x00 (always ???) */
2704 /* => this value will be rewritten to 0x1060 later (URB 85) */
2705
2706 buf[0] = 0x00; buf[1] = 0x03;
2707 ret += usb_microdia_control_write(dev, 0x1060, buf, 2); /* URB 16 */
2708
2709 /* initialize I2C registers to avoid getting no ACK at first I2C operation: */
2710 ret += sn9c20x_initialize_i2c(dev, SN9C20X_I2C_2WIRE, MT9V011_I2C_SLAVE_ADDRESS);
2711
2712 /* enable I2C communication (bit 0) */
2713 buf[0] = 0x21; /* THE OLD DRIVER 5.5.8.12 WRITES 0x5d */
2714 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 17 */
2715
2716 /* probe sensor model: */
2717 retSP = mt9vx11_sensor_probe(dev); /* substitutes URBs 18-48 */
2718 if ((retSP == 0) && (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS))
2719 /* switch (back) to IFP address space: */
2720 retASS = mt9v111_select_address_space(dev, MT9V111_ADDRESSSPACE_IFP);
2721
2722 ret += usb_microdia_control_write(dev, 0x118a, buf_0395, 1); /* URB 81 => write value read with URB 8 */
2723
2724 ret += usb_microdia_control_write(dev, 0x0395, buf_0395, 1); /* URB 82 => write value read with URB 8 */
2725
2726 ret += usb_microdia_control_write(dev, 0x11b8, buf_11b8, 1); /* URB 83 => write value read with URB 11 */
2727
2728 ret += usb_microdia_control_write(dev, 0x1000, buf_1000, 5); /* URB 84 => write value read with URB 13 */
2729
2730 ret += usb_microdia_control_write(dev, 0x1060, buf_1060, 2); /* URB 85 => write value read with URB 15; (always 08 00 ???) */
2731
2732 /* USB-interrupt-message: doesn't work yet (returns error -110) */
2733 /* usb_interrupt_msg(dev->udev, usb_rcvintpipe(dev->udev, dev->int_in_endpointAddr), dev->int_in_buffer, dev->int_in_size, &actual, 1000); // URB 86 */
2734
2735 /*
2736 * THE OLD DRIVER 5.5.8.12 DOES AN ADDITIONAL WRITE HERE:
2737 * wbuf[0]=0x80;
2738 * usb_microdia_control_write(dev, 0x1020, wbuf, 1);
2739 */
2740
2741 if ((retSP != 0) || (retASS != 0) || (ret < 33)) {
2742 if (ret < 33)
2743 UDIA_INFO("One ore more errors occured during initialization !\n");
2744 return -1;
2745 } else {
2746 return 0;
2747 }
2748 }
2749
2750
2751 /**
2752 * @brief From UsbSnoop-plugin-parsed.log
2753 *
2754 * @param dev
2755 *
2756 * @returns
2757 */
2758 int microdia_627b_initialize(struct usb_microdia *dev)
2759 {
2760 /*int actual;*/
2761 int ret;
2762 int retI2C;
2763 __u16 reg;
2764 __u8 buf[32];
2765 __u8 reg0395[1];
2766 __u8 reg11b8[1];
2767 __u8 reg1000[5];
2768 __u8 reg1060[2];
2769
2770 reg = 0x130d;
2771 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 5 */
2772 if (ret < 0)
2773 goto err;
2774 reg = 0x1040;
2775 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 6 */
2776 if (ret < 0)
2777 goto err;
2778
2779 reg = 0x118a;
2780 ret = usb_microdia_control_read(dev, reg, buf, 1); /* URB 7 */
2781 if (ret < 0)
2782 goto err;
2783 reg = 0x0395;
2784 ret = usb_microdia_control_read(dev, reg, reg0395, 1); /* URB 8 */
2785 if (ret < 0)
2786 goto err;
2787
2788 reg = 0x118a;
2789 buf[0] = 0x05;
2790 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 9 */
2791 if (ret < 0)
2792 goto err;
2793 reg = 0x0395;
2794 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 10 */
2795 if (ret < 0)
2796 goto err;
2797
2798 reg = 0x11b8;
2799 ret = usb_microdia_control_read(dev, reg, reg11b8, 1); /* URB 11 */
2800 if (ret < 0)
2801 goto err;
2802
2803 reg = 0x11b8;
2804 buf[0] = 0x10;
2805 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 12 */
2806 if (ret < 0)
2807 goto err;
2808 reg = 0x1000;
2809 ret = usb_microdia_control_read(dev, reg, reg1000, 5); /* URB 13 */
2810 if (ret < 0)
2811 goto err;
2812
2813 reg = 0x1000;
2814 buf[0] = 0x70; buf[1] = 0x00; buf[2] = 0x18; buf[3] = 0x00; buf[4] = 0x00;
2815 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 14 */
2816 if (ret < 0)
2817 goto err;
2818
2819 reg = 0x1060;
2820 ret = usb_microdia_control_read(dev, reg, reg1060, 2); /* URB 15 */
2821 if (ret < 0)
2822 goto err;
2823
2824 reg = 0x1060;
2825 buf[0] = 0x00; buf[1] = 0x03;
2826 ret = usb_microdia_control_write(dev, reg, buf, 2); /* URB 16 */
2827 if (ret < 0)
2828 goto err;
2829
2830 reg = 0x10c8;
2831 buf[0] = 0x21;
2832 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 17 */
2833 if (ret < 0)
2834 goto err;
2835
2836 retI2C = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
2837 OV7660_CTL_PID, dev->sensor_flags, buf); /* URBs 18-29 */
2838 if (retI2C < 0) {
2839 /* 2nd try... */
2840 reg = 0x10c8;
2841 buf[0] = 0x21;
2842 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 30 */
2843 if (ret < 0)
2844 goto err;
2845
2846 retI2C = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
2847 OV7660_CTL_PID, dev->sensor_flags, buf); /* URBs 31-35 */
2848 }
2849 if (retI2C < 0)
2850 UDIA_ERROR("Read of sensor register 0x0a failed.");
2851
2852 reg = 0x118a;
2853 buf[0] = 0xa6;
2854 ret = usb_microdia_control_write(dev, reg, reg0395, 1); /* URB 36 */
2855 if (ret < 0)
2856 goto err;
2857 reg = 0x0395;
2858 ret = usb_microdia_control_write(dev, reg, reg0395, 1); /* URB 37 */
2859 if (ret < 0)
2860 goto err;
2861
2862 reg = 0x11b8;
2863 buf[0] = 0x06;
2864 ret = usb_microdia_control_write(dev, reg, reg11b8, 1); /* URB 38 */
2865 if (ret < 0)
2866 goto err;
2867
2868 reg = 0x1000;
2869 buf[0] = 0x30; buf[1] = 0xcf; buf[2] = 0x00; buf[3] = 0x03; buf[4] = 0x02;
2870 ret = usb_microdia_control_write(dev, reg, reg1000, 5); /* URB 39 */
2871 if (ret < 0)
2872 goto err;
2873
2874 reg = 0x1060;
2875 buf[0] = 0x08; buf[1] = 0x00;
2876 ret = usb_microdia_control_write(dev, reg, reg1060, 2); /* URB 40 */
2877 if (ret < 0)
2878 goto err;
2879
2880 /*
2881 //URB 41
2882 ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000);
2883 */
2884
2885 return ret;
2886 err:
2887 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
2888 return ret;
2889 }
2890
2891 /**
2892 * @brief From init-start-stop-log (made by Víctor M. Hernández Rocamora)
2893 *
2894 * @param dev
2895 *
2896 * @returns 0 (ok) or -1 (error)
2897 *
2898 * @author Comer352l
2899 *
2900 * USB-Logger: SniffUSB 2.0
2901 *
2902 * Comments behind read oprations contain HEX-values that appeared in the log
2903 */
2904 int microdia_627f_initialize(struct usb_microdia *dev)
2905 {
2906 __u8 buf[1];
2907 int ret = 0;
2908
2909 ret += usb_microdia_control_read(dev, 0x130d, buf, 1); /* URB 5 0x81 */
2910
2911 ret += usb_microdia_control_read(dev, 0x1040, buf, 1); /* URB 6 0xe4 */
2912
2913 buf[0] = 0x00;
2914 ret += usb_microdia_control_write(dev, 0x10c8, buf, 1); /* URB 7 */
2915
2916 buf[0] = 0x80;
2917 ret += usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 8 */
2918
2919 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 9 0x0f */
2920
2921 buf[0] = 0x1f;
2922 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 10 */
2923
2924 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 11 0x1f */
2925
2926 buf[0] = 0x0f;
2927 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 12 */
2928
2929 ret += usb_microdia_control_read(dev, 0x1045, buf, 1); /* URB 13 0x0f */
2930
2931 buf[0] = 0x1f;
2932 ret += usb_microdia_control_write(dev, 0x1045, buf, 1); /* URB 14 */
2933
2934 if (ret < 10) {
2935 UDIA_INFO("One ore more errors occured during initialization !\n");
2936 return -1;
2937 }
2938 return 0;
2939 }
2940
2941 /**
2942 * @brief From UsbSnoop-plugin-parsed.log
2943 *
2944 * @param dev
2945 *
2946 * @returns 0 (OK) or <0 (Error)
2947 *
2948 * @author Vincent, Kuzja
2949 */
2950 int microdia_6288_initialize(struct usb_microdia *dev)
2951 {
2952
2953 int ret;
2954 __u16 reg;
2955 __u8 buf[2];
2956
2957 reg = 0x130d ;
2958 ret = usb_microdia_control_read(dev, reg, buf, 1);
2959 if (ret < 0)
2960 goto err;
2961
2962 reg = 0x1040 ;
2963 ret = usb_microdia_control_read(dev, reg, buf, 1);
2964 if (ret < 0)
2965 goto err;
2966
2967 if (ret < 0)
2968 return ret;
2969 else
2970 return 0;
2971 err:
2972 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
2973 return ret;
2974 }
2975
2976 int dev_microdia_start_stream(struct usb_microdia *dev)
2977 {
2978 int ret = -ENODEV;
2979 if (dev && dev->start_stream)
2980 ret = dev->start_stream(dev);
2981
2982 return ret;
2983 }
2984
2985 /**
2986 * @brief From start.htm
2987 *
2988 * @param dev
2989 *
2990 * @returns 0
2991 *
2992 * @author GWater
2993 *
2994 * For SN9C201 with MI1310.
2995 * This function has not been tested yet.
2996 */
2997 int microdia_6242_start_stream(struct usb_microdia *dev)
2998 {
2999 int i = -1;
3000 __u8 buf[48];
3001
3002 __u8 urb10[24] = {
3003 0x01, 0x18, 0x00, 0x30, 0x00, 0x09, 0x00, 0xed,
3004 0x0f, 0xda, 0x0f, 0x3a, 0x00, 0x3a, 0x00, 0xd0,
3005 0x0f, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x60, 0x0a};
3006
3007 __u8 urb13[11] = {
3008 0x02, 0x00, 0x02, 0x00, 0x50, 0x78, 0x00, 0x00,
3009 0x07, 0xc0, 0x0a};
3010
3011 __u8 urb14[22] = {
3012 0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x24, 0x3b,
3013 0x4f, 0x61, 0x71, 0x80, 0x8f, 0x9d, 0xab, 0xb8,
3014 0xc4, 0xd1, 0xdd, 0xe9, 0xf4, 0xff};
3015
3016 __u8 qtable1[64] = {
3017 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3018 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3019 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3020 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
3021 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
3022 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
3023 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
3024 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54};
3025
3026 __u8 qtable2[64] = {
3027 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
3028 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
3029 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3030 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3031 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3032 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3033 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
3034 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54};
3035
3036 __u8 first10c0[7][3] = {
3037 {0x0d, 0x00, 0x08},
3038 {0x0d, 0x00, 0x09},
3039 {0x0d, 0x00, 0x08},
3040 {0xf0, 0x00, 0x01},
3041 {0x3a, 0x73, 0x00},
3042 {0x06, 0x30, 0x8c},
3043 {0xf0, 0x00, 0x00}
3044 };
3045
3046 __u8 second10c0a[2][5] = {
3047 {0x01, 0x00, 0x0e, 0x00, 0x14},
3048 {0x03, 0x03, 0xc4, 0x05, 0x14}
3049 };
3050
3051 __u8 second10c0b[3] =
3052 {0xc8, 0x00, 0x03};
3053
3054 __u8 third10c0[4][3] = {
3055 {0x0a, 0x00, 0x01},
3056 {0x06, 0x00, 0x29},
3057 {0x05, 0x00, 0x72},
3058 {0x20, 0x00, 0x00}
3059 };
3060
3061 __u8 fourth10c0a[3][3] = {
3062 {0x20, 0x00, 0x00},
3063 {0x09, 0x01, 0x90},
3064 {0x0d, 0x80, 0x08}
3065 };
3066
3067 __u8 fourth10c0b[2][5] = {
3068 {0x2b, 0x01, 0x88, 0x01, 0x88},
3069 {0x2d, 0x01, 0x88, 0x01, 0x88}
3070 };
3071
3072 __u8 fifth10c0[4][3] = {
3073 {0x0a, 0x00, 0x01},
3074 {0x06, 0x00, 0x29},
3075 {0x05, 0x00, 0x72}
3076 };
3077
3078 /* interrupt down */
3079
3080 buf[0] = 0x00;
3081 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1 */
3082
3083 /* interrupt up */
3084 /* interrupt down */
3085
3086 buf[0] = 0x60;
3087 usb_microdia_control_write(dev, 0x1007, buf, 1);
3088
3089 buf[0] = 0x00;
3090 usb_microdia_control_write(dev, 0x1006, buf, 1);
3091
3092 buf[0] = 0x78;
3093 usb_microdia_control_write(dev, 0x1000, buf, 1);
3094
3095 buf[0] = 0xc7;
3096 usb_microdia_control_write(dev, 0x1001, buf, 1);
3097
3098 buf[0] = 0x1c;
3099 usb_microdia_control_write(dev, 0x1002, buf, 1);
3100
3101 buf[0] = 0x01;
3102 usb_microdia_control_write(dev, 0x1061, buf, 1);
3103
3104 buf[0] = 0x80;
3105 usb_microdia_control_write(dev, 0x1020, buf, 1);
3106
3107 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
3108 buf[3] = 0x10; buf[4] = 0x08;
3109 usb_microdia_control_write(dev, 0x1067, buf, 5);
3110
3111 buf[0] = 0xb0; buf[1] = dev->sensor_slave_address; buf[2] = 0x0d;
3112 buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00;
3113 buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03;
3114 usb_microdia_control_write(dev, 0x10c0, buf, 9);
3115
3116 usb_microdia_control_write(dev, 0x10e0, urb10, 24); /* URB 10 */
3117
3118 buf[0] = 0x00; buf[1] = 0x00; buf[3] = 0x00;
3119 usb_microdia_control_write(dev, 0x10f8, buf, 3);
3120
3121 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00;
3122 buf[3] = 0xe0; buf[4] = 0x03;
3123 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3124
3125 usb_microdia_control_write(dev, 0x1180, urb13, 11);
3126
3127 usb_microdia_control_write(dev, 0x118b, urb14, 22);
3128
3129 buf[0] = 0x00; buf[1] = 0x00;
3130 usb_microdia_control_write(dev, 0x11a1, buf, 2);
3131
3132 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00;
3133 buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00;
3134 buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00;
3135 usb_microdia_control_write(dev, 0x11b7, buf, 9);
3136
3137 buf[0] = 0x30;
3138 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3139
3140 buf[0] = 0x78;
3141 usb_microdia_control_write(dev, 0x1000, buf, 1);
3142
3143 for (i = 0; i < 7; i++)
3144 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3145 first10c0[i][0], dev->sensor_flags, &first10c0[i][1]); /* URB 9-48 */
3146
3147 buf[0] = 0x60;
3148 usb_microdia_control_write(dev, 0x1007, buf, 1);
3149
3150 buf[0] = 0x00;
3151 usb_microdia_control_write(dev, 0x1006, buf, 1);
3152
3153 buf[0] = 0x03;
3154 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 50 */
3155
3156 buf[0] = 0x03;
3157 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3158
3159 buf[0] = 0xc6;
3160 usb_microdia_control_write(dev, 0x1001, buf, 1);
3161
3162 buf[0] = 0xc4;
3163 usb_microdia_control_write(dev, 0x1001, buf, 1);
3164
3165 buf[0] = 0x44;
3166 usb_microdia_control_write(dev, 0x1001, buf, 1);
3167
3168 buf[0] = 0x80;
3169 usb_microdia_control_write(dev, 0x1189, buf, 1);
3170
3171 buf[0] = 0x00;
3172 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3173
3174 buf[0] = 0x00;
3175 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3176
3177 buf[0] = 0x00;
3178 usb_microdia_control_write(dev, 0x11be, buf, 1);
3179
3180 buf[0] = 0x00;
3181 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3182
3183 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3184 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
3185
3186 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3187 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
3188
3189 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3190 0x09, dev->sensor_flags, NULL);
3191
3192 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3193 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3194
3195 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
3196 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3197 usb_microdia_control_write(dev, 0x1180, buf, 6);
3198
3199 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3200 buf[3] = 0xf0; buf[4] = 0x00;
3201 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 70 */
3202
3203 buf[0] = 0x8c;
3204 usb_microdia_control_write(dev, 0x1189, buf, 1);
3205
3206 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3207 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3208
3209 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3210 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3211
3212 buf[0] = 0x78;
3213 usb_microdia_control_write(dev, 0x1000, buf, 1);
3214
3215 buf[0] = 0x18;
3216 usb_microdia_control_write(dev, 0x1002, buf, 1);
3217
3218 buf[0] = 0x18;
3219 usb_microdia_control_write(dev, 0x1002, buf, 1);
3220
3221 buf[0] = 0x38;
3222 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3223
3224 buf[0] = 0x02;
3225 usb_microdia_control_write(dev, 0x118a, buf, 1);
3226
3227 buf[0] = 0x02;
3228 usb_microdia_control_write(dev, 0x0395, buf, 1);
3229
3230 buf[0] = 0x78;
3231 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 80 */
3232 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3233
3234 buf[0] = 0xf9;
3235 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3236 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3237
3238 buf[0] = 0xfa;
3239 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3240 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3241
3242 buf[0] = 0x7b;
3243 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3244 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3245
3246 buf[0] = 0x7c;
3247 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3248 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3249
3250 buf[0] = 0x7b;
3251 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 90 */
3252
3253 for (i = 0; i < 4; i++)
3254 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3255 third10c0[i][0], dev->sensor_flags, &third10c0[i][1]); /* URB 97-106 */
3256
3257 buf[0] = 0x06;
3258 usb_microdia_control_write(dev, 0x1180, buf, 1);
3259
3260 for (i = 0; i < 3; i++)
3261 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3262 fourth10c0a[i][0], dev->sensor_flags, &fourth10c0a[i][1]);
3263
3264 for (i = 0; i < 2; i++)
3265 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3266 fourth10c0b[i][0], dev->sensor_flags, &fourth10c0b[i][1]);
3267
3268 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3269 0x33, dev->sensor_flags, NULL);
3270
3271 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3272 first10c0[0][0], dev->sensor_flags, &first10c0[0][1]);
3273
3274 buf[0] = 0x0a;
3275 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3276
3277 buf[0] = 0x10;
3278 usb_microdia_control_write(dev, 0x118b, buf, 1);
3279
3280 buf[0] = 0x05;
3281 usb_microdia_control_write(dev, 0x10f7, buf, 1);
3282
3283 buf[0] = 0x14;
3284 usb_microdia_control_write(dev, 0x10f8, buf, 1);
3285
3286 buf[0] = 0xff;
3287 usb_microdia_control_write(dev, 0x10fa, buf, 1);
3288
3289 buf[0] = 0x00;
3290 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3291
3292 buf[0] = 0x00;
3293 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3294
3295 buf[0] = 0x0a;
3296 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3297
3298 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
3299 usb_microdia_control_write(dev, 0x11bc, buf, 4);
3300
3301 /* Set whole array buf to 0x00 */
3302 memset(buf, 0x00, 48);
3303 usb_microdia_control_write(dev, 0x11c0, buf, 48);
3304
3305 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a;
3306 buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
3307 usb_microdia_control_write(dev, 0x11a5, buf, 6);
3308
3309 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
3310 usb_microdia_control_write(dev, 0x11af, buf, 4);
3311
3312 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
3313 usb_microdia_control_write(dev, 0x11b3, buf, 4);
3314
3315 buf[0] = 0x07;
3316 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3317
3318 buf[0] = 0x01;
3319 usb_microdia_control_write(dev, 0x1061, buf, 1);
3320
3321 buf[0] = 0x27;
3322 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3323
3324 usb_microdia_control_write(dev, 0x1100, qtable1, 64);
3325
3326 usb_microdia_control_write(dev, 0x1140, qtable2, 64); /* URB 150 */
3327
3328 buf[0] = 0x07;
3329 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3330
3331 buf[0] = 0x03;
3332 usb_microdia_control_write(dev, 0x1061, buf, 1);
3333
3334 buf[0] = 0x0b;
3335 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3336
3337 buf[0] = 0x8c;
3338 usb_microdia_control_write(dev, 0x1189, buf, 1);
3339
3340 buf[0] = 0x00;
3341 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3342
3343 buf[0] = 0x00;
3344 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3345
3346 buf[0] = 0x00;
3347 usb_microdia_control_write(dev, 0x11be, buf, 1);
3348
3349 buf[0] = 0x00;
3350 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3351
3352 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3353 second10c0a[0][0], dev->sensor_flags, &second10c0a[0][1]);
3354
3355 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3356 second10c0a[1][0], dev->sensor_flags, &second10c0a[1][1]);
3357
3358 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3359 0x09, dev->sensor_flags, NULL);
3360
3361 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3362 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3363
3364 buf[0] = 0x06; buf[1] = 0x00; buf[2] = 0x02;
3365 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3366 usb_microdia_control_write(dev, 0x1180, buf, 6);
3367
3368 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3369 buf[3] = 0xf0; buf[4] = 0x00;
3370 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3371
3372 buf[0] = 0x8c;
3373 usb_microdia_control_write(dev, 0x1189, buf, 1);
3374
3375 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3376 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 170 */
3377
3378 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3379 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3380
3381 buf[0] = 0x03;
3382 usb_microdia_control_write(dev, 0x1061, buf, 1);
3383
3384 buf[0] = 0x0a;
3385 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3386
3387 buf[0] = 0x00;
3388 usb_microdia_control_write(dev, 0x11b9, buf, 1);
3389
3390 buf[0] = 0x0b;
3391 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3392
3393 buf[0] = 0x01;
3394 usb_microdia_control_write(dev, 0x1061, buf, 1);
3395
3396 buf[0] = 0x78;
3397 usb_microdia_control_write(dev, 0x1000, buf, 1);
3398
3399 buf[0] = 0x18;
3400 usb_microdia_control_write(dev, 0x1002, buf, 1);
3401
3402 buf[0] = 0x18;
3403 usb_microdia_control_write(dev, 0x1002, buf, 1);
3404
3405 buf[0] = 0x7b;
3406 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 180 */
3407
3408 buf[0] = 0x02;
3409 usb_microdia_control_write(dev, 0x118a, buf, 1);
3410
3411 buf[0] = 0x02;
3412 usb_microdia_control_write(dev, 0x0395, buf, 1);
3413
3414 buf[0] = 0x78;
3415 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3416 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3417
3418 buf[0] = 0xf9;
3419 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3420 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3421
3422 buf[0] = 0xfa;
3423 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3424 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3425
3426 buf[0] = 0x7b;
3427 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3428 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 190 */
3429
3430 buf[0] = 0x7c;
3431 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3432 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3433
3434 buf[0] = 0x7b;
3435 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3436
3437 for (i = 0; i < 3; i++)
3438 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3439 fifth10c0[i][0], dev->sensor_flags, &fifth10c0[i][1]); /* URB 200-205 */
3440
3441 sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2,
3442 0x00, dev->sensor_flags, buf);
3443 /* __u8 result[2] = {buf[3], buf[4]}; */
3444
3445 buf[0] = 0x03;
3446 usb_microdia_control_write(dev, 0x1061, buf, 1);
3447
3448 return 0;
3449 }
3450
3451
3452 /**
3453 * @brief From startstream.log
3454 *
3455 * @param dev
3456 *
3457 * @returns 0
3458 *
3459 * @author GWater
3460 *
3461 * For SN9C201 with SOI968.
3462 * This is function triggers a working stream of image data and a glowing LED.
3463 */
3464 int microdia_624e_start_stream(struct usb_microdia *dev)
3465 {
3466 int i = -1;
3467 __u8 buf[48];
3468
3469 __u8 urb10[24] =
3470 {0x47, 0x18, 0x00, 0x30, 0x00, 0x09, 0x00, 0xed,
3471 0x0f, 0xda, 0x0f, 0x3a, 0x00, 0x3a, 0x00, 0xd0,
3472 0x0f, 0xf7, 0x0f, 0x00, 0x00, 0x00, 0x60, 0x0a};
3473
3474 __u8 urb14[22] =
3475 {0x00, 0x20, 0x20, 0x20, 0x20, 0x00, 0x24, 0x3b,
3476 0x4f, 0x61, 0x71, 0x80, 0x8f, 0x9d, 0xab, 0xb8,
3477 0xc4, 0xd1, 0xdd, 0xe9, 0xf4, 0xff};
3478
3479 __u8 qtable1[64] =
3480 {0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3481 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3482 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3483 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
3484 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
3485 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
3486 0x4f, 0x53, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
3487 0x64, 0x5c, 0x53, 0x64, 0x4b, 0x53, 0x58, 0x53};
3488
3489 __u8 qtable2[64] =
3490 {0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
3491 0x15, 0x26, 0x53, 0x36, 0x2e, 0x36, 0x53, 0x53,
3492 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3493 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3494 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3495 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3496 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53,
3497 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53};
3498
3499 __u8 first10c0[20][2] = {
3500 {0x12, 0x80}, {0x12, 0x00}, {0x0c, 0x00}, {0x0f, 0x1f},
3501 {0x11, 0x80}, {0x38, 0x52}, {0x1e, 0x00}, {0x33, 0x08},
3502 {0x35, 0x8c}, {0x36, 0x0c}, {0x37, 0x04}, {0x45, 0x04},
3503 {0x47, 0xff}, {0x3e, 0x00}, {0x3f, 0x00}, {0x3b, 0x20},
3504 {0x3a, 0x96}, {0x3d, 0x0a}, {0x14, 0x4e}, {0x13, 0x88} };
3505
3506 __u8 second10c0a[2] =
3507 {0x12, 0x40};
3508 __u8 second10c0b[5] =
3509 {0x17, 0x13, 0x63, 0x01, 0x79}; /* 4 bytes */
3510 __u8 second10c0c[2] =
3511 {0x1b, 0x00}; /* 0 bytes */
3512 __u8 second10c0d[2][2] = {
3513 {0x32, 0x24},
3514 {0x03, 0x00} };
3515
3516 __u8 third10c0a[5][2] = {
3517 {0x11, 0x40},
3518 {0x2a, 0x10},
3519 {0x2b, 0xe0},
3520 {0x10, 0x32},
3521 {0x00, 0x00} };
3522 __u8 third10c0b[3] =
3523 {0x01, 0x80, 0x80}; /* 2 bytes */
3524
3525 __u8 read10c0[4] =
3526 {0x0a, 0x0b, 0x1c, 0x1d}; /* these are four addresses */
3527
3528 /* interrupt down */
3529
3530 buf[0] = 0x00;
3531 usb_microdia_control_write(dev, 0x1066, buf, 1);
3532
3533 /* interrupt up and down */
3534
3535 buf[0] = 0x78;
3536 usb_microdia_control_write(dev, 0x1000, buf, 1);
3537
3538 buf[0] = 0xc7;
3539 usb_microdia_control_write(dev, 0x1001, buf, 1);
3540
3541 buf[0] = 0x1c;
3542 usb_microdia_control_write(dev, 0x1002, buf, 1);
3543
3544 buf[0] = 0xa0; buf[1] = 0xa0;
3545 usb_microdia_control_write(dev, 0x1006, buf, 2);
3546
3547 buf[0] = 0x01;
3548 usb_microdia_control_write(dev, 0x1061, buf, 1);
3549
3550 buf[0] = 0x80;
3551 usb_microdia_control_write(dev, 0x1020, buf, 1);
3552
3553 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
3554 buf[3] = 0x10; buf[4] = 0x08;
3555 usb_microdia_control_write(dev, 0x1067, buf, 5);
3556
3557 buf[0] = 0x92; buf[1] = dev->sensor_slave_address; buf[2] = 0x00;
3558 buf[3] = 0x00; buf[4] = 0x1d; buf[5] = 0x00;
3559 buf[6] = 0xa2; buf[7] = 0x10; buf[8] = 0x03;
3560 usb_microdia_control_write(dev, 0x10c0, buf, 9);
3561
3562 usb_microdia_control_write(dev, 0x10e0, urb10, 24);
3563
3564 buf[0] = 0x00; buf[1] = 0x00; buf[3] = 0x00;
3565 usb_microdia_control_write(dev, 0x10f8, buf, 3);
3566
3567 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3568 buf[3] = 0xf0; buf[4] = 0x00;
3569 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3570
3571 buf[0] = 0x8a; buf[1] = 0xcc; buf[2] = 0x08;
3572 usb_microdia_control_write(dev, 0x1188, buf, 3);
3573
3574 usb_microdia_control_write(dev, 0x118b, urb14, 22);
3575
3576 buf[0] = 0x00; buf[1] = 0x00;
3577 usb_microdia_control_write(dev, 0x11a1, buf, 2);
3578
3579 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00;
3580 buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x40;
3581 buf[6] = 0x01; buf[7] = 0xf0; buf[8] = 0x00;
3582 usb_microdia_control_write(dev, 0x11b7, buf, 9);
3583
3584 buf[0] = 0x30;
3585 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3586
3587 buf[0] = 0x78;
3588 usb_microdia_control_write(dev, 0x1000, buf, 1);
3589
3590 for (i = 0; i < 20; i++)
3591 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3592 first10c0[i][0], dev->sensor_flags, &first10c0[i][1]);
3593
3594 buf[0] = 0x47;
3595 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3596
3597 buf[0] = 0x07;
3598 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3599
3600 buf[0] = 0xc6;
3601 usb_microdia_control_write(dev, 0x1001, buf, 1);
3602
3603 buf[0] = 0xc4;
3604 usb_microdia_control_write(dev, 0x1001, buf, 1);
3605
3606 buf[0] = 0x44;
3607 usb_microdia_control_write(dev, 0x1001, buf, 1);
3608
3609 buf[0] = 0x8c;
3610 usb_microdia_control_write(dev, 0x1189, buf, 1);
3611
3612 buf[0] = 0x00;
3613 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3614
3615 buf[0] = 0x00;
3616 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3617
3618 buf[0] = 0x00;
3619 usb_microdia_control_write(dev, 0x11be, buf, 1);
3620
3621 buf[0] = 0x00;
3622 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3623
3624
3625 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3626 second10c0a[0], dev->sensor_flags, &second10c0a[1]);
3627
3628 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3629 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3630
3631 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3632 second10c0c[0], dev->sensor_flags, &second10c0c[1]);
3633
3634 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3635 second10c0d[0][0], dev->sensor_flags, &second10c0d[0][1]);
3636
3637 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3638 second10c0d[1][0], dev->sensor_flags, &second10c0d[1][1]);
3639
3640 buf[0] = 0x3c; buf[1] = 0x00; buf[2] = 0x0b;
3641 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3642 usb_microdia_control_write(dev, 0x1180, buf, 6);
3643
3644 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3645 buf[3] = 0xf0; buf[4] = 0x00;
3646 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3647
3648 buf[0] = 0x8c;
3649 usb_microdia_control_write(dev, 0x1189, buf, 1);
3650
3651 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3652 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3653
3654 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3655 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3656
3657 buf[0] = 0x7c;
3658 usb_microdia_control_write(dev, 0x1000, buf, 1);
3659
3660 buf[0] = 0x1c;
3661 usb_microdia_control_write(dev, 0x1002, buf, 1);
3662
3663 buf[0] = 0x1c;
3664 usb_microdia_control_write(dev, 0x1002, buf, 1);
3665
3666 buf[0] = 0x38;
3667 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3668
3669 buf[0] = 0x05;
3670 usb_microdia_control_write(dev, 0x118a, buf, 1);
3671
3672 buf[0] = 0x05;
3673 usb_microdia_control_write(dev, 0x0395, buf, 1);
3674
3675 buf[0] = 0x78;
3676 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3677 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3678
3679 buf[0] = 0xf9;
3680 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3681 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3682
3683 buf[0] = 0x7a;
3684 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3685 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3686
3687 buf[0] = 0x7b;
3688 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3689 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3690
3691 buf[0] = 0x7c;
3692 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3693 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3694
3695 buf[0] = 0xfd;
3696 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3697 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3698
3699 buf[0] = 0xfe;
3700 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3701 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3702
3703 buf[0] = 0x7f;
3704 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3705 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3706
3707 buf[0] = 0x7a;
3708 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3709
3710 for (i = 0; i < 5; i++)
3711 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3712 third10c0a[i][0], dev->sensor_flags, &third10c0a[i][1]);
3713
3714 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
3715 third10c0b[0], dev->sensor_flags, &third10c0b[1]);
3716
3717 buf[0] = 0x0a;
3718 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3719
3720 buf[0] = 0x0a;
3721 usb_microdia_control_write(dev, 0x118b, buf, 1);
3722
3723 buf[0] = 0x07;
3724 usb_microdia_control_write(dev, 0x10f7, buf, 1);
3725
3726 buf[0] = 0x14;
3727 usb_microdia_control_write(dev, 0x10f8, buf, 1);
3728
3729 buf[0] = 0xff;
3730 usb_microdia_control_write(dev, 0x10fa, buf, 1);
3731
3732 buf[0] = 0x00;
3733 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3734
3735 buf[0] = 0x00;
3736 usb_microdia_control_write(dev, 0x10f9, buf, 1);
3737
3738 buf[0] = 0x0e;
3739 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3740
3741 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
3742 usb_microdia_control_write(dev, 0x11bc, buf, 4);
3743
3744 /* Set whole buf to 0x00 */
3745 memset(buf, 0, 48);
3746 usb_microdia_control_write(dev, 0x11c0, buf, 48);
3747 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a;
3748 buf[3] = 0x05; buf[4] = 0x04; buf[5] = 0x3f;
3749 usb_microdia_control_write(dev, 0x11a5, buf, 6);
3750
3751 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
3752 usb_microdia_control_write(dev, 0x11af, buf, 4);
3753
3754 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
3755 usb_microdia_control_write(dev, 0x11b3, buf, 4);
3756
3757 buf[0] = 0x07;
3758 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3759
3760 buf[0] = 0x01;
3761 usb_microdia_control_write(dev, 0x1061, buf, 1);
3762
3763 buf[0] = 0x27;
3764 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3765
3766 usb_microdia_control_write(dev, 0x1100, qtable1, 64);
3767
3768 usb_microdia_control_write(dev, 0x1140, qtable2, 64);
3769
3770 buf[0] = 0x07;
3771 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3772
3773 buf[0] = 0x03;
3774 usb_microdia_control_write(dev, 0x1061, buf, 1);
3775
3776 buf[0] = 0x0b;
3777 usb_microdia_control_write(dev, 0x10e0, buf, 1);
3778
3779 buf[0] = 0x8c;
3780 usb_microdia_control_write(dev, 0x1189, buf, 1);
3781
3782 buf[0] = 0x00;
3783 usb_microdia_control_write(dev, 0x11bc, buf, 1);
3784
3785 buf[0] = 0x00;
3786 usb_microdia_control_write(dev, 0x11bd, buf, 1);
3787
3788 buf[0] = 0x00;
3789 usb_microdia_control_write(dev, 0x11be, buf, 1);
3790
3791 buf[0] = 0x00;
3792 usb_microdia_control_write(dev, 0x11bf, buf, 1);
3793
3794 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
3795 second10c0b[0], dev->sensor_flags, &second10c0b[1]);
3796
3797 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
3798 second10c0c[0], dev->sensor_flags, &second10c0c[1]);
3799
3800 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3801 second10c0d[0][0], dev->sensor_flags, &second10c0d[0][1]);
3802
3803 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3804 second10c0d[1][0], dev->sensor_flags, &second10c0d[1][1]);
3805
3806 buf[0] = 0x3c; buf[1] = 0x00; buf[2] = 0x0b;
3807 buf[3] = 0x00; buf[4] = 0x28; buf[5] = 0x3c;
3808 usb_microdia_control_write(dev, 0x1180, buf, 6);
3809
3810 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00;
3811 buf[3] = 0xf0; buf[4] = 0x00;
3812 usb_microdia_control_write(dev, 0x10fb, buf, 5);
3813
3814 buf[0] = 0x8c;
3815 usb_microdia_control_write(dev, 0x1189, buf, 1);
3816
3817 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
3818 usb_microdia_control_write(dev, 0x11a1, buf, 4);
3819
3820 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
3821 usb_microdia_control_write(dev, 0x11ab, buf, 4);
3822
3823 buf[0] = 0x03;
3824 usb_microdia_control_write(dev, 0x1061, buf, 1);
3825
3826 buf[0] = 0x0e;
3827 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3828
3829 buf[0] = 0x00;
3830 usb_microdia_control_write(dev, 0x11b9, buf, 1);
3831
3832 buf[0] = 0x0f;
3833 usb_microdia_control_write(dev, 0x11ba, buf, 1);
3834
3835 buf[0] = 0x01;
3836 usb_microdia_control_write(dev, 0x1061, buf, 1);
3837
3838 buf[0] = 0x7c;
3839 usb_microdia_control_write(dev, 0x1000, buf, 1);
3840
3841 buf[0] = 0x1c;
3842 usb_microdia_control_write(dev, 0x1002, buf, 1);
3843
3844 buf[0] = 0x1c;
3845 usb_microdia_control_write(dev, 0x1002, buf, 1);
3846
3847 buf[0] = 0x7a;
3848 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3849
3850 buf[0] = 0x05;
3851 usb_microdia_control_write(dev, 0x118a, buf, 1);
3852
3853 buf[0] = 0x05;
3854 usb_microdia_control_write(dev, 0x0395, buf, 1);
3855
3856 buf[0] = 0x78;
3857 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3858 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3859
3860 buf[0] = 0xf9;
3861 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3862 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3863
3864 buf[0] = 0x7a;
3865 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3866 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3867
3868 buf[0] = 0x7b;
3869 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3870 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3871
3872 buf[0] = 0x7c;
3873 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3874 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3875
3876 buf[0] = 0x7d;
3877 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3878 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3879
3880 buf[0] = 0xfe;
3881 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3882 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3883
3884 buf[0] = 0x7f;
3885 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3886 usb_microdia_control_read(dev, 0x11b8, buf, 1);
3887
3888 buf[0] = 0x7a;
3889 usb_microdia_control_write(dev, 0x11b8, buf, 1);
3890
3891 for (i = 0; i < 3; i++)
3892 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
3893 third10c0a[i][0], dev->sensor_flags, &third10c0a[i][1]);
3894
3895 for (i = 0; i < 4; i++)
3896 sn9c20x_read_i2c_data(dev, dev->sensor_slave_address,
3897 1, read10c0[i], dev->sensor_flags, buf);
3898
3899 buf[0] = 0x03;
3900 usb_microdia_control_write(dev, 0x1061, buf, 1);
3901
3902 buf[0] = 0xa0;
3903 usb_microdia_control_write(dev, 0x1007, buf, 1);
3904
3905 buf[0] = 0x80;
3906 usb_microdia_control_write(dev, 0x1006, buf, 1);
3907
3908 return 0;
3909 }
3910
3911
3912 int microdia_624f_start_stream(struct usb_microdia *dev)
3913 {
3914 int ret, i;
3915 __u8 unknown1[9] = { dev->sensor_flags, dev->sensor_slave_address,
3916 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
3917
3918 __u16 reg;
3919 __u8 value;
3920
3921 __u16 regs[][2] = {
3922 {0x1007, 0x20},
3923 {0x1006, 0x00},
3924 {0x1000, 0x78},
3925 {0x1001, 0x44},
3926 {0x1002, 0x1c},
3927 {0x1061, 0x01},
3928 {0x1020, 0x80},
3929 {0x1067, 0x40},
3930 {0x1068, 0x30},
3931 {0x1069, 0x20},
3932 {0x1070, 0x10},
3933 {0x1071, 0x08},
3934 {0x1188, 0x87},
3935 {0x11a1, 0x00},
3936 {0x11a2, 0x00},
3937 {0x11a3, 0x6a},
3938 {0x11a4, 0x50},
3939 {0x11ab, 0x00},
3940 {0x11ac, 0x00},
3941 {0x11ad, 0x50},
3942 {0x11ae, 0x3c},
3943 {0x118a, 0x04},
3944 {0x0395, 0x04},
3945 {0x11b8, 0x3a},
3946 {0x118b, 0x0e},
3947 {0x10f7, 0x05},
3948 {0x10f8, 0x14},
3949 {0x10fa, 0xff},
3950 {0x10f9, 0x00},
3951 {0x11ba, 0x0e},
3952 {0x11a5, 0x2d},
3953 {0x11a6, 0x2d},
3954 {0x11a7, 0x3a},
3955 {0x11a8, 0x05},
3956 {0x11a9, 0x04},
3957 {0x11aa, 0x3f},
3958 {0x11af, 0x28},
3959 {0x11b0, 0xd8},
3960 {0x11b1, 0x14},
3961 {0x11b2, 0xec},
3962 {0x11b3, 0x32},
3963 {0x11b4, 0xdd},
3964 {0x11b5, 0x32},
3965 {0x11b6, 0xdd},
3966 {0x10e0, 0x0b},
3967 {0x11bc, 0x40},
3968 {0x11bd, 0x01},
3969 {0x11be, 0xf0},
3970 {0x11bf, 0x00},
3971 {0x1180, 0x02},
3972 {0x1181, 0x00},
3973 {0x1182, 0x07},
3974 {0x1183, 0x00},
3975 {0x1184, 0x28},
3976 {0x1185, 0x3c},
3977 {0x10fb, 0x00},
3978 {0x10fc, 0xa0},
3979 {0x10fd, 0x00},
3980 {0x10fe, 0xf0},
3981 {0x10ff, 0x00},
3982 {0x1189, 0x8c},
3983 {0x1061, 0x03},
3984 };
3985
3986 __u8 reg_11c0[48] = {
3987 0x10, 0x21, 0x34, 0x40, 0x47, 0x4f, 0x57, 0x5f,
3988 0x64, 0x68, 0x6d, 0x73, 0x79, 0x80, 0x89, 0x97,
3989 0x0d, 0x1c, 0x2a, 0x33, 0x38, 0x3d, 0x44, 0x4a,
3990 0x4e, 0x52, 0x56, 0x5b, 0x61, 0x68, 0x6f, 0x7a,
3991 0x0d, 0x1a, 0x2a, 0x31, 0x36, 0x3b, 0x41, 0x47,
3992 0x4a, 0x4e, 0x53, 0x58, 0x5d, 0x64, 0x6b, 0x76
3993 };
3994
3995 __u8 qtable1[64] = {
3996 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3997 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3998 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3999 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
4000 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
4001 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
4002 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
4003 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54
4004 };
4005
4006 __u8 qtable2[64] = {
4007 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
4008 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
4009 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4010 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4011 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4012 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4013 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4014 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54
4015 };
4016
4017 for (i = 0; i < ARRAY_SIZE(regs); i++) {
4018 reg = regs[i][0];
4019 value = regs[i][1];
4020 ret = usb_microdia_control_write(dev, reg, &value, 1);
4021 if (ret < 0) {
4022 UDIA_INFO("Bridge Init Error (%d). line %d", ret, i);
4023 goto err;
4024 }
4025 }
4026
4027 ret = usb_microdia_control_write(dev, 0x11c0, reg_11c0, 48);
4028 if (ret < 0)
4029 goto err;
4030
4031 ret = usb_microdia_control_write(dev, 0x1100, qtable1, 64);
4032 if (ret < 0)
4033 goto err;
4034
4035 ret = usb_microdia_control_write(dev, 0x1140, qtable2, 64);
4036 if (ret < 0)
4037 goto err;
4038
4039 /* this is the same register as the I2C write, not sure why
4040 * we're writing 9 bytes -- the SN9C102 docs say all writes
4041 * must be 8 bytes, but we don't have docs for SN9C20x */
4042 ret = usb_microdia_control_write(dev, 0x10c0, unknown1, 9);
4043 if (ret < 0)
4044 goto err;
4045
4046 if (dev->sensor_init)
4047 dev->sensor_init(dev);
4048
4049 return 0;
4050
4051 err:
4052 UDIA_ERROR("start stream: failed (%d)!\n", ret);
4053 return ret;
4054 }
4055
4056 int microdia_6260_start_stream(struct usb_microdia *dev)
4057 {
4058 int ret;
4059 __u8 buf[32];
4060
4061 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
4062 buf[0] = 0x1f;
4063 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
4064 buf[0] = 0x00;
4065 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
4066 buf[0] = 0x20;
4067 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
4068 buf[0] = 0x00;
4069 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
4070 buf[0] = 0x78;
4071 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4072 buf[0] = 0xc7;
4073 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4074 buf[0] = 0x18;
4075 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4076 buf[0] = 0x01;
4077 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4078 buf[0] = 0x80;
4079 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
4080
4081 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10;
4082 buf[4] = 0x08;
4083 ret = usb_microdia_control_write(dev, 0x1067, buf, 5);
4084
4085 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
4086 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
4087 buf[8] = 0x03;
4088 ret = usb_microdia_control_write(dev, 0x10c0, buf, 9);
4089
4090 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
4091 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
4092 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
4093 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
4094 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
4095 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
4096 ret = usb_microdia_control_write(dev, 0x10e0, buf, 24);
4097
4098 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
4099 ret = usb_microdia_control_write(dev, 0x10f8, buf, 3);
4100
4101 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
4102 buf[4] = 0x00;
4103 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4104
4105 buf[0] = 0x8a; buf[1] = 0x8c; buf[2] = 0x08;
4106 ret = usb_microdia_control_write(dev, 0x1188, buf, 3);
4107
4108 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
4109 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
4110 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
4111 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
4112 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
4113 buf[20] = 0xf4; buf[21] = 0xff;
4114 ret = usb_microdia_control_write(dev, 0x118b, buf, 22);
4115
4116 buf[0] = 0x00; buf[1] = 0x00;
4117 ret = usb_microdia_control_write(dev, 0x11a1, buf, 2);
4118
4119 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x00;
4120 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
4121 buf[8] = 0x00;
4122 ret = usb_microdia_control_write(dev, 0x11b7, buf, 9);
4123
4124 buf[0] = 0x78;
4125 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4126
4127 buf[0] = 0x38;
4128 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4129
4130 ret = ov7670_initialise(dev);
4131 if (ret < 0)
4132 return ret;
4133
4134 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1, 0x3b, dev->sensor_flags, buf);
4135 ret = usb_microdia_control_read(dev, 0x10c1, buf, 1);
4136 buf[0] = 0x50;
4137 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
4138
4139 /* TRY TO READ FROM EEPROM: */
4140 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, dev->sensor_flags, buf);
4141 if (ret < 0)
4142 UDIA_INFO("No EEPROM found\n");
4143 else
4144 UDIA_INFO("Read from EEPROM successful\n");
4145
4146 buf[0] = 0x21;
4147 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
4148 buf[0] = 0x45;
4149 ret = usb_microdia_control_write(dev, 0x10e0, buf, 1);
4150 buf[0] = 0xc6;
4151 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4152 buf[0] = 0xc4;
4153 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4154
4155 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
4156 buf[4] = 0x50; buf[5] = 0x3c;
4157 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
4158
4159 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
4160 buf[4] = 0x01;
4161 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4162
4163 buf[0] = 0x80;
4164 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
4165
4166 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
4167 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
4168
4169 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
4170 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
4171 buf[0] = 0x78;
4172 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4173 buf[0] = 0x10;
4174 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4175 buf[0] = 0x00;
4176 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4177 buf[0] = 0x38;
4178 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4179 buf[0] = 0x04;
4180 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
4181 buf[0] = 0x04;
4182 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
4183 buf[0] = 0x78;
4184 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4185 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4186 buf[0] = 0xf9;
4187 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4188 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4189 buf[0] = 0xfa;
4190 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4191 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4192 buf[0] = 0x7b;
4193 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4194 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4195 buf[0] = 0x7c;
4196 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4197 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4198 buf[0] = 0x7d;
4199 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4200 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4201 buf[0] = 0x7b;
4202 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4203
4204 /* OV7670 Intialise Part 2 */
4205 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
4206 buf[4] = 0x50; buf[5] = 0x3c;
4207 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
4208
4209 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
4210 buf[4] = 0x01;
4211 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4212
4213 buf[0] = 0x80;
4214 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
4215
4216 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
4217 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
4218
4219 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
4220 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
4221
4222 buf[0] = 0x03;
4223 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4224 buf[0] = 0x01;
4225 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4226 buf[0] = 0x78;
4227 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4228 buf[0] = 0x00;
4229 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4230 buf[0] = 0x00;
4231 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4232 buf[0] = 0x7b;
4233 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4234 buf[0] = 0x04;
4235 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
4236 buf[0] = 0x04;
4237 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
4238 buf[0] = 0x78;
4239 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4240 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4241 buf[0] = 0x79;
4242 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4243 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4244 buf[0] = 0x7a;
4245 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4246 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4247 buf[0] = 0x7b;
4248 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4249 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4250 buf[0] = 0x7c;
4251 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4252 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4253 buf[0] = 0x7d;
4254 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4255 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4256 buf[0] = 0xfa;
4257 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4258
4259 /* OV7670 Initialisation Part 3 Goes Here */
4260 buf[0] = 0x03;
4261 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4262
4263 return ret;
4264 }
4265
4266 /**
4267 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
4268 *
4269 * @param dev
4270 *
4271 * @returns 0 (ok) or -1 (error)
4272 *
4273 * @author Comer352l
4274 *
4275 * Windows driver versions: 5.7.23.000
4276 * Windows versions: 2000 and XP
4277 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
4278 * All logs were made using AMCAP with 640x480, RGB24
4279 */
4280 int microdia_6270_start_stream(struct usb_microdia *dev)
4281 {
4282 __u8 buf[64];
4283 __u8 last_11b8[1];
4284 int k;
4285 int retI2C;
4286
4287 /* Check if sensor slave address is valid: */
4288 if ((dev->sensor_slave_address != MT9V111_I2C_SLAVE_ADDRESS) && (dev->sensor_slave_address != MT9V011_I2C_SLAVE_ADDRESS)) {
4289 UDIA_INFO("microdia_6270_start_stream(): Invalid sensor slave address !\n");
4290 return -1;
4291 }
4292
4293 /* <= INTERRUPT COMING BACK (URB 1953) */
4294 /* SWITCH TO ALTERNATE SETTINGS 8 (URB 1954) // NOT IN ALEX'S LOG */
4295 /* => INTERRUPT GOING DOWN (URB 1955) */
4296
4297 buf[0] = 0x00;
4298 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1956 */
4299
4300 /* <= INTERRUPT COMING BACK (URB 1955) */
4301 /* => INTERRUPT GOING DOWN (URB 1957) */
4302
4303 buf[0] = 0x78;
4304 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1958 */
4305 buf[0] = 0xc7;
4306 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 1959 */
4307 buf[0] = 0x18;
4308 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 1960 */
4309 buf[0] = 0x01;
4310 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 1961 */
4311 buf[0] = 0x80;
4312 usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 1962 */
4313 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
4314 usb_microdia_control_write(dev, 0x1067, buf, 5); /* URB 1963 */
4315
4316 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4317 /* STRANGE I2C MESSAGE: */
4318 /* - 9 bytes */
4319 /* - byte 8 = 0x00 at first start + first cycle */
4320 /* - procedure not complete: no wait/check for ack/error, no readout of 0x10c2 */
4321 /* - dummy writes at first cycle and read at second cycle, but there are many I2C messages in the meantime, so this should not work */
4322 /* */
4323 /* AT FIRST START + FIRST CYCLE: */
4324 buf[0] = 0x80; buf[1] = dev->sensor_slave_address; buf[2] = 0x00; buf[3] = 0x00;
4325 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x03;
4326 /* AT ALL FURTHER STARTS + FIRST CYCLE: */
4327 /* MT9V111: I2C MESSAGE => IFP Register 0x33: Auto exposure */
4328 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x33; buf[3] = 0x00; */
4329 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4330 /* MT9V011: ????????????????????????? */
4331 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x07; buf[3] = 0x00; */
4332 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4333 /* ALWAYS AT 2nd AND FURTHER CYCLES: */
4334 /* MT9V111: */
4335 /* buf[0] = 0xa2; buf[1] = 0x5c; buf[2] = 0x00; buf[3] = 0x36; */
4336 /* buf[4] = 0x00; buf[5] = 0x82; buf[6] = 0x3a; buf[7] = 0x10; buf[8] = 0x03; */
4337 /* => buf[3] to buf[6] simply contain bytes read with URB 2215 */
4338 /* MT9V011: */
4339 /* buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00; */
4340 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4341 usb_microdia_control_write(dev, 0x10c0, buf, 9); /* URB 1964 */
4342 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4343
4344 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
4345 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
4346 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
4347 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
4348 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
4349 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
4350 usb_microdia_control_write(dev, 0x10e0, buf, 24); /* URB 1965 */
4351 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
4352 usb_microdia_control_write(dev, 0x10f8, buf, 3); /* URB 1966 */
4353 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
4354 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 1967 */
4355 buf[0] = 0x06; buf[1] = 0x0c; buf[2] = 0x08;
4356 usb_microdia_control_write(dev, 0x1188, buf, 3); /* URB 1968 */
4357 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
4358 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
4359 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
4360 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
4361 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
4362 buf[20] = 0xf4; buf[21] = 0xff;
4363 usb_microdia_control_write(dev, 0x118b, buf, 22); /* URB 1969 */
4364 buf[0] = 0x00; buf[1] = 0x00;
4365 usb_microdia_control_write(dev, 0x11a1, buf, 2); /* URB 1970 */
4366 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08;
4367 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
4368 buf[8] = 0x00;
4369 usb_microdia_control_write(dev, 0x11b7, buf, 9); /* URB 1971 */
4370 buf[0] = 0x38;
4371 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 1972 */
4372 buf[0] = 0x78;
4373 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1973 */
4374
4375 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4376 /* I2C MESSAGES */
4377 retI2C = 0;
4378 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4379 /* Write to IFP register 0x0d: Color Correction Register 8 */
4380 buf[0] = 0x00; buf[1] = 0x01;
4381 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1974-1976 */
4382 /* Write to IFP register 0x0d: Color Correction Register 8 */
4383 buf[0] = 0x00; buf[1] = 0x00; /* ??? */
4384 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1977-1979 */
4385 /* Writes to IFP registers 0x01: Register Address Space Selection */
4386 /* 0x02: Color Correction Register 1 */
4387 buf[0] = 0x00; buf[1] = 0x01; /* select IFP address space */
4388 buf[2] = 0x00; buf[3] = 0x16; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4389 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1980-1982 */
4390 /* Writes to IFP registers 0x03: Color Correction Register 3 */
4391 /* 0x04: Color Correction Register 4 */
4392 buf[0] = 0x01; buf[1] = 0xe1; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4393 buf[2] = 0x02; buf[3] = 0x81; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4394 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1983-1985 */
4395 /* Writes to IFP registers 0x05: Aperture Correction (Sharpening) */
4396 /* 0x06: Operating Mode Control */
4397 buf[0] = 0x00; buf[1] = 0x04; /* 100% sharpening, no automatic sharpness reduction at low light // AT FIRST START + FIRST CYCLE: 0x00 0x00: no sharpening */
4398 buf[2] = 0x00; buf[3] = 0x00; /* stop AWB at the current values, no on-the-fly defect correction, no auto exposure, + RESREVED option */
4399 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 1986-1988 */
4400 /* Writes to IFP registers 0x07: Image Flow Processor Soft Reset */
4401 /* 0x08: Output Format Control */
4402 buf[0] = 0x30; buf[1] = 0x02; /* reset // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4403 buf[2] = 0x04; buf[3] = 0x80; /* bypass entire image processing, raw 8+2 Bayer data output directly */
4404 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 1989-1991 */
4405 /* "Dummy" write to IFP Register 0x11: Color Correction Register 12 */
4406 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 1992-1993 */
4407 /* Write to register 0x01: Register address space selection */
4408 /* Write to sensor register 0x02: Column Start */
4409 buf[0] = 0x00; buf[1] = 0x04; /* select sensor address space */
4410 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
4411 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1994-1996 */
4412 /* Writes to sensor registers 0x03: Window Height */
4413 /* 0x04: Window Width */
4414 buf[0] = 0x01; buf[1] = 0xe6; /* 486 */
4415 buf[2] = 0x02; buf[3] = 0x86; /* 646 */
4416 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1997-1999 */
4417 /* Writes to sensor registers 0x05: Horizontal Blanking */
4418 /* 0x06: Vertical Blanking */
4419 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4420 buf[2] = 0x00; buf[3] = 0x00; /* 0 rows */
4421 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 2000-2002 */
4422 /* Writes to sensor registers 0x07: Output Control */
4423 /* 0x08: Row Start */
4424 buf[0] = 0x30; buf[1] = 0x02; /* normal operation + chip enable + RESERVED options */
4425 buf[2] = 0x00; buf[3] = 0x08; /* row 8 */
4426 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 2003-2005 */
4427 /* "Dummy" write to sensor Register 0x11: UNDOCUMENTED */
4428 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 2006-2007 */
4429 /* Writes to sensor registers 0x0c: Shutter Delay */
4430 /* 0x0d: Reset (Soft) (from MT9V011 datasheet) */
4431 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
4432 buf[2] = 0x00; buf[3] = 0x00; /* return to normal operation */
4433 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf); /* URBs 2008-2010 */
4434 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
4435 /* 0x0f: UNDOCUMENTED */
4436 buf[0] = 0x00; buf[1] = 0x00;
4437 buf[2] = 0x00; buf[3] = 0x00;
4438 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf); /* URBs 2011-2013 */
4439 /* Writes to sensor registers 0x10: UNDOCUMENTED */
4440 /* 0x11: UNDOCUMENTED */
4441 buf[0] = 0x00; buf[1] = 0x00;
4442 buf[2] = 0x00; buf[3] = 0x00;
4443 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf); /* URBs 2014-2016 */
4444 /* Writes to sensor registers 0x12: 2X Zoom Col Start => 0x1e bit 0 must be set to activate zoom */
4445 /* 0x13: 2X Zoom Row Start => 0x1e bit 0 must be set to activate zoom */
4446 buf[0] = 0x00; buf[1] = 0xb0; /* column 176 */
4447 buf[2] = 0x00; buf[3] = 0x7c; /* row 124 */
4448 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf); /* URBs 2017-2018 */
4449 /* Writes to sensor registers 0x14: UNDOCUMENTED */
4450 /* 0x15: UNDOCUMENTED */
4451 buf[0] = 0x00; buf[1] = 0x00;
4452 buf[2] = 0x00; buf[3] = 0x00;
4453 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf); /* URBs 2019-2021 */
4454 /* Writes to sensor registers 0x16: UNDOCUMENTED */
4455 /* 0x17: UNDOCUMENTED */
4456 buf[0] = 0x00; buf[1] = 0x00;
4457 buf[2] = 0x00; buf[3] = 0x00;
4458 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf); /* URBs 2022-2024 */
4459 /* Writes to sensor registers 0x18: UNDOCUMENTED */
4460 /* 0x19: UNDOCUMENTED */
4461 buf[0] = 0x00; buf[1] = 0x00;
4462 buf[2] = 0x00; buf[3] = 0x00;
4463 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf); /* URBs 2025-2027 */
4464 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
4465 /* 0x1b: UNDOCUMENTED */
4466 buf[0] = 0x00; buf[1] = 0x00;
4467 buf[2] = 0x00; buf[3] = 0x00;
4468 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf); /* URBs 2028-2030 */
4469 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
4470 /* 0x1d: UNDOCUMENTED */
4471 buf[0] = 0x00; buf[1] = 0x00;
4472 buf[2] = 0x00; buf[3] = 0x00;
4473 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf); /* URBs 2031-2033 */
4474 /* Write to sensor register 0x30: RESERVED */
4475 buf[0] = 0x00; buf[1] = 0x00;
4476 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x30, dev->sensor_flags, buf); /* URBs 2034-2036 */
4477 /* Write to sensor register 0x20: Read Mode */
4478 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4479 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2037-2039 */
4480 /* Writes to sensor registers 0x30: RESERVED */
4481 /* 0x31: RESERVED */
4482 buf[0] = 0x00; buf[1] = 0x05;
4483 buf[2] = 0x00; buf[3] = 0x00;
4484 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x30, dev->sensor_flags, buf); /* URBs 2040-2042 */
4485 /* "Dummy" write to sensor Register 0x34: RESERVED */
4486 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x34, dev->sensor_flags, NULL); /* URBs 2043-2044 */
4487 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4488 /* Write to sensor register 0x07: Output Control */
4489 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
4490 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4491 /* Write to sensor register 0x0d: Soft Reset */
4492 buf[0] = 0x00; buf[1] = 0x01; /* reset */
4493 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4494 /* Write to sensor register 0x0d: Soft Reset */
4495 buf[0] = 0x00; buf[1] = 0x00; /* resume operation */
4496 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4497 /* Writes to sensor registers 0x01: Row start */
4498 /* 0x02: Column Start */
4499 buf[0] = 0x00; buf[1] = 0x08; /* start with row 8 */
4500 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
4501 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf);
4502 /* Writes to sensor registers 0x03: Window Height */
4503 /* 0x04: Window Width */
4504 buf[0] = 0x01; buf[1] = 0xe1; /* 481 */
4505 buf[2] = 0x02; buf[3] = 0x81; /* 641 */
4506 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf);
4507 /* Writes to sensor registers 0x05: Horizontal Blanking */
4508 /* 0x06: Vertical Blanking */
4509 buf[0] = 0x00; buf[1] = 0x83; /* 131 columns (pixel clocks) */
4510 buf[2] = 0x00; buf[3] = 0x06; /* 6 rows */
4511 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf);
4512 /* Write to sensor register 0x0d: Soft Reset */
4513 buf[0] = 0x00; buf[1] = 0x02; /* UNKNOWN */
4514 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4515 /* Writes to sensor registers 0x0a: Pixel Clock Speed */
4516 /* 0x0b: Frame Restart */
4517 buf[0] = 0x00; buf[1] = 0x00; /* default */
4518 buf[2] = 0x00; buf[3] = 0x00; /* (has no effect/no restart) */
4519 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0a, dev->sensor_flags, buf);
4520 /* Writes to sensor registers 0x0c: Shutter Delay */
4521 /* 0x0d: Soft Reset */
4522 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
4523 buf[2] = 0x00; buf[3] = 0x00; /* resume operation */
4524 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf);
4525 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
4526 /* 0x0f: UNDOCUMENTED */
4527 buf[0] = 0x00; buf[1] = 0x00;
4528 buf[2] = 0x00; buf[3] = 0x00;
4529 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf);
4530 /* Writes to sensor registers 0x10: UNDOCUMENTED */
4531 /* 0x11: UNDOCUMENTED */
4532 buf[0] = 0x00; buf[1] = 0x00;
4533 buf[2] = 0x00; buf[3] = 0x00;
4534 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf);
4535 /* Writes to sensor registers 0x12: 2X Zoom Column Start (from MT9V111 datasheet) */
4536 /* 0x13: 2X Zoom Row Start (from MT9V111 datasheet) */
4537 buf[0] = 0x00; buf[1] = 0x00; /* column 0 => bit0 of reg 0x1e must be set to activate zoom */
4538 buf[2] = 0x00; buf[3] = 0x00; /* row 0 => bit0 of reg 0x1e must be set to activate zoom */
4539 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf);
4540 /* Writes to sensor registers 0x14: UNDOCUMENTED */
4541 /* 0x15: UNDOCUMENTED */
4542 buf[0] = 0x00; buf[1] = 0x00;
4543 buf[2] = 0x00; buf[3] = 0x00;
4544 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf);
4545 /* Writes to sensor registers 0x16: UNDOCUMENTED */
4546 /* 0x17: UNDOCUMENTED */
4547 buf[0] = 0x00; buf[1] = 0x00;
4548 buf[2] = 0x00; buf[3] = 0x00;
4549 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf);
4550 /* Writes to sensor registers 0x18: UNDOCUMENTED */
4551 /* 0x19: UNDOCUMENTED */
4552 buf[0] = 0x00; buf[1] = 0x00;
4553 buf[2] = 0x00; buf[3] = 0x00;
4554 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf);
4555 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
4556 /* 0x1b: UNDOCUMENTED */
4557 buf[0] = 0x00; buf[1] = 0x00;
4558 buf[2] = 0x00; buf[3] = 0x00;
4559 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf);
4560 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
4561 /* 0x1d: UNDOCUMENTED */
4562 buf[0] = 0x00; buf[1] = 0x00;
4563 buf[2] = 0x00; buf[3] = 0x00;
4564 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf);
4565 /* Write to sensor register 0x32: RESERVED */
4566 buf[0] = 0x00; buf[1] = 0x00;
4567 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x32, dev->sensor_flags, buf);
4568 /* Writes to sensor registers 0x20: Read Mode */
4569 /* 0x21: RESERVED */
4570 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad frames) + UNDOCUMENTED */
4571 buf[2] = 0x00; buf[3] = 0x00;
4572 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x20, dev->sensor_flags, buf);
4573 /* Writes to sensor registers 0x22: RESERVED */
4574 /* 0x23: UNDOCUMENTED */
4575 buf[0] = 0x00; buf[1] = 0x00;
4576 buf[2] = 0x00; buf[3] = 0x00;
4577 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x22, dev->sensor_flags, buf);
4578 /* Writes to sensor registers 0x24: UNDOCUMENTED */
4579 /* 0x25: UNDOCUMENTED */
4580 buf[0] = 0x00; buf[1] = 0x00;
4581 buf[2] = 0x00; buf[3] = 0x00;
4582 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x24, dev->sensor_flags, buf);
4583 /* Writes to sensor registers 0x26: UNDOCUMENTED */
4584 /* 0x27: RESERVED */
4585 buf[0] = 0x00; buf[1] = 0x00;
4586 buf[2] = 0x00; buf[3] = 0x24;
4587 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x26, dev->sensor_flags, buf);
4588 /* "Dummy" write to sensor Register 0x30: RESERVED */
4589 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x30, dev->sensor_flags, NULL);
4590 /* Writes to sensor registers 0x2f: RESERVED */
4591 /* 0x30: RESERVED */
4592 buf[0] = 0xf7; buf[1] = 0xb0;
4593 buf[2] = 0x00; buf[3] = 0x05;
4594 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2f, dev->sensor_flags, buf);
4595 /* Writes to sensor registers 0x31: RESERVED */
4596 /* 0x32: RESERVED */
4597 buf[0] = 0x00; buf[1] = 0x00;
4598 buf[2] = 0x00; buf[3] = 0x00;
4599 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x31, dev->sensor_flags, buf);
4600 /* Writes to sensor registers 0x33: RESERVED */
4601 /* 0x34: RESERVED */
4602 buf[0] = 0x00; buf[1] = 0x00;
4603 buf[2] = 0x01; buf[3] = 0x00;
4604 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x33, dev->sensor_flags, buf);
4605 /* "Dummy" write to sensor Register 0x3b: RESERVED */
4606 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x3b, dev->sensor_flags, NULL);
4607 /* Write to sensor register 0x3d: RESERVED */
4608 buf[0] = 0x06; buf[1] = 0x8f;
4609 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x3d, dev->sensor_flags, buf);
4610 /* Writes to sensor registers 0x40: RESERVED */
4611 /* 0x41: RESERVED */
4612 buf[0] = 0x01; buf[1] = 0xe0;
4613 buf[2] = 0x00; buf[3] = 0xd1;
4614 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x40, dev->sensor_flags, buf);
4615 /* Write to sensor register 0x44: UNDOCUMENTED */
4616 buf[0] = 0x00; buf[1] = 0x82;
4617 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x44, dev->sensor_flags, buf);
4618 /* Writes to sensor registers 0x5a: RESERVED */
4619 /* 0x5b: RESERVED */
4620 buf[0] = 0x00; buf[1] = 0x00;
4621 buf[2] = 0x00; buf[3] = 0x00;
4622 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5a, dev->sensor_flags, buf);
4623 /* Writes to sensor registers 0x5c: RESERVED */
4624 /* 0x5d: RESERVED */
4625 buf[0] = 0x00; buf[1] = 0x00;
4626 buf[2] = 0x00; buf[3] = 0x00;
4627 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5c, dev->sensor_flags, buf);
4628 /* Writes to sensor registers 0x5e: RESERVED */
4629 /* 0x5f: RESERVED */
4630 buf[0] = 0x00; buf[1] = 0x00;
4631 buf[2] = 0xa3; buf[3] = 0x1d;
4632 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5e, dev->sensor_flags, buf);
4633 /* "Dummy" write to sensor Register 0x68: UNDOCUMENTED */
4634 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x68, dev->sensor_flags, NULL);
4635 /* Write to sensor register 0x62: RESERVED */
4636 buf[0] = 0x06; buf[1] = 0x11;
4637 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x62, dev->sensor_flags, buf);
4638 }
4639 if (retI2C < 0) {
4640 UDIA_INFO("1 or more errors occured in I2C-message-block 1 !\n");
4641 return -1;
4642 }
4643 /* END OF I2C MESSAGES */
4644 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4645
4646 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4647 buf[0] = 0x40;
4648 usb_microdia_control_write(dev, 0x1007, buf, 8);
4649 buf[0] = 0x40;
4650 usb_microdia_control_write(dev, 0x1006, buf, 8);
4651 }
4652
4653
4654 /* *** TEMPORARY SWITCH TO SLAVE ADDRESS 0x50, I2C READ ATTEMPT: */
4655 /* - WE CURRENTLY KNOW NO 6270 CAM THAT IS SUCCESSFULLY READ HERE */
4656 /* - IF READ FAILS, THIS IS NEVER DONE AGAIN (IN NEXT CYCLE OR FURTHER STARTS) */
4657 usb_microdia_control_read(dev, 0x10c1, buf, 1); /* returns 0x5c */
4658 buf[0] = 0x50;
4659 usb_microdia_control_write(dev, 0x10c1, buf, 1);
4660 retI2C = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, SN9C20X_I2C_2WIRE, buf);
4661 if (retI2C >= 0)
4662 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");
4663 buf[0] = 0x5c;
4664 usb_microdia_control_write(dev, 0x10c1, buf, 1);
4665
4666
4667 buf[0] = 0x47; /* ALEX: 0x44 */
4668 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2045 */
4669 buf[0] = 0x47; /* ALEX: 0x04 */
4670 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2046 */
4671 buf[0] = 0xc6;
4672 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2047 */
4673 buf[0] = 0xc4;
4674 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2048 */
4675 buf[0] = 0x84; /* ALEX: 0xc0 */
4676 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2049 */
4677 /* ALEX:
4678 buf[0] = 0x40;
4679 usb_microdia_control_write(dev, 0x1001, buf, 1);
4680 */
4681
4682 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4683 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4684 /* I2C MESSAGES */
4685 retI2C = 0;
4686 /* Writes to sensor registers 0x02: Column Start */
4687 /* 0x03: Window Height */
4688 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
4689 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
4690 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2050-2052 */
4691 /* Writes to sensor registers 0x04: Window Width */
4692 /* 0x05: Horizontal Blanking */
4693 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
4694 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4695 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2053-2055 */
4696 /* Writes to sensor registers 0x06: Vertical Blanking */
4697 /* 0x07: Output Control */
4698 buf[0] = 0x00; buf[1] = 0x00; /* 0 rows */
4699 buf[2] = 0x30; buf[3] = 0x02; /* normal operation + chip enable + RESERVED options */
4700 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2056-2058 */
4701 /* Write to sensor register 0x0e: UNDOCUMENTED */
4702 buf[0] = 0x00; buf[1] = 0x08;
4703 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2059-2061 */
4704 if (retI2C < 0) {
4705 UDIA_INFO("1 or more errors occured in I2C-message-block 2 !\n");
4706 return -1;
4707 }
4708 /* END OF I2C MESSAGES */
4709 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4710 }
4711
4712 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
4713 buf[4] = 0x28; buf[5] = 0x3c;
4714 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2062 */
4715 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
4716 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2063 */
4717 buf[0] = 0x0c;
4718 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2064 */
4719 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
4720 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2065 */
4721 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
4722 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2066 */
4723 buf[0] = 0x78; /* ALEX: 0x7c */
4724 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2067 */
4725 buf[0] = 0x18; /* ALEX: 0x1c */
4726 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2068 */
4727 buf[0] = 0x18; /* ALEX: 0x1c */
4728 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2069 */
4729 buf[0] = 0x38;
4730 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2070 */
4731 buf[0] = 0x04;
4732 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2071 */
4733 buf[0] = 0x04;
4734 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2072 */
4735
4736 buf[0] = 0x78;
4737 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2073 */
4738 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2074 // 0x38 */
4739 if (buf[0] == 0x38)
4740 buf[0] = 0x79;
4741 else if (buf[0] == 0xb8)
4742 buf[0] = 0xf9;
4743 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2075 */
4744 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2076 // 0xb9 */
4745 if (buf[0] == 0x39)
4746 buf[0] = 0x7a;
4747 else if (buf[0] == 0xb9)
4748 buf[0] = 0xfa;
4749 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2077 */
4750 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2078 */
4751 if (buf[0] == 0x3a)
4752 buf[0] = 0x7b;
4753 else if (buf[0] == 0xba)
4754 buf[0] = 0xfb;
4755 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2079 */
4756 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2080 // 0x3b */
4757 if (buf[0] == 0x3b)
4758 buf[0] = 0x7c;
4759 else if (buf[0] == 0xbb)
4760 buf[0] = 0xfc;
4761 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2081 */
4762 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2082 // 0x3c */
4763 if (buf[0] == 0x3c)
4764 buf[0] = 0x7d;
4765 else if (buf[0] == 0xbc)
4766 buf[0] = 0xfd;
4767 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2083 */
4768 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2084 // 0x3d */
4769 last_11b8[0] = buf[0];
4770 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4771 if (buf[0] == 0x3d)
4772 buf[0] = 0x7e;
4773 else if (buf[0] == 0xbd)
4774 buf[0] = 0xfe;
4775 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2085 */
4776 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2086 */
4777 if (buf[0] == 0x3e)
4778 buf[0] = 0x7f;
4779 else if (buf[0] == 0xbe)
4780 buf[0] = 0xff;
4781 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2087 */
4782 usb_microdia_control_read(dev, 0x11b8, last_11b8, 1); /* URB 2088 */
4783 }
4784 buf[0] = last_11b8[0] & 0xf0; /* 0xf0 or 0x70 */
4785 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
4786 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
4787
4788
4789 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4790 /* I2C MESSAGES */
4791 retI2C = 0;
4792 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4793 /* Write to sensor register 0x06: Vertical Blanking */
4794 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
4795 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2090-2092 */
4796 /* Write to sensor register 0x05: Horizontal Blanking */
4797 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
4798 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2093-2095 */
4799 /* Write to sensor register 0x20: Read Mode */
4800 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4801 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2096-2098 */
4802 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4803 /* Write to sensor register 0x0a: Pixel Clock Speed */
4804 buf[0] = 0x00; buf[1] = 0x00; /* default */
4805 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0a, dev->sensor_flags, buf);
4806 /* Write to sensor register 0x06: Vertical Blanking */
4807 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
4808 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
4809 /* Write to sensor register 0x05: Horizontal Blanking */
4810 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
4811 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
4812 /* Write to sensor register 0x20: Read Mode */
4813 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
4814 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
4815 }
4816 if (retI2C < 0) {
4817 UDIA_INFO("1 or more errors occured in I2C-message-block 3 !\n");
4818 return -1;
4819 }
4820 /* END OF I2C MESSAGES */
4821 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4822
4823
4824 buf[0] = 0x02;
4825 usb_microdia_control_write(dev, 0x1180, buf, 1); /* URB 2099 */
4826
4827 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4828 /* I2C MESSAGE */
4829 retI2C = 0;
4830 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4831 /* Write to sensor register 0x20: Read Mode */
4832 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4833 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2100-2102 */
4834 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4835 /* Write to sensor register 0x20: Read Mode */
4836 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
4837 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
4838 }
4839 if (retI2C < 0) {
4840 UDIA_INFO("1 or more errors occured in I2C-message-block 4 !\n");
4841 return -1;
4842 }
4843 /* END OF I2C MESSAGES */
4844 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4845
4846
4847 buf[0] = 0x02;
4848 usb_microdia_control_write(dev, 0x1182, buf, 1); /* URB 2103 */
4849
4850
4851 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4852 /* I2C MESSAGES */
4853 retI2C = 0;
4854 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4855 /* Write to sensor register 0x09: Shutter Width */
4856 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
4857 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf); /* URBs 2104-2106 */
4858 /* Write to sensor register 0x2b: Green 1 Gain */
4859 /* 0x2c: Blue Gain */
4860 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4861 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4862 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf); /* URBs 2107-2109 */
4863 /* Write to sensor register 0x2d: Red Gain */
4864 /* 0x2e: Green 2 Gain */
4865 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4866 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4867 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf); /* URBs 2110-2112 */
4868 /* "Dummy" write to sensor Register 0x33: RESERVED */
4869 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL); /* URBs 2113-2114 */
4870 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4871 /* Write to sensor register 0x09: Shutter Width */
4872 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
4873 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf);
4874 /* Write to sensor register 0x07: Output Control */
4875 buf[0] = 0x00; buf[1] = 0x03; /* dont update changes until bit0=0, chip enable, normal operation */
4876 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4877 /* Write to sensor register 0x2b: Green 1 Gain */
4878 /* 0x2c: Blue Gain */
4879 buf[0] = 0x00; buf[1] = 0x33; /* 51*0.03125*1 = 1.59375 */
4880 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4881 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf);
4882 /* Write to sensor register 0x2d: Red Gain */
4883 /* 0x2e: Green 2 Gain */
4884 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4885 buf[2] = 0x00; buf[3] = 0x33; /* 51*0.03125*1 = 1.59375 */
4886 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf);
4887 /* "Dummy" write to sensor Register 0x33: RESERVED */
4888 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL);
4889 /* Write to sensor register 0x07: Output Control */
4890 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
4891 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4892 }
4893 if (retI2C < 0) {
4894 UDIA_INFO("1 or more errors occured in I2C-message-block 5 !\n");
4895 return -1;
4896 }
4897 /* END OF I2C MESSAGES */
4898 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4899
4900 buf[0] = 0x0a;
4901 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2119 */
4902
4903 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4904 buf[0] = 0x14;
4905 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4906 buf[0] = 0x0a;
4907 usb_microdia_control_write(dev, 0x118b, buf, 1); /* URB 2124 */
4908
4909 buf[0] = 0x07;
4910 usb_microdia_control_write(dev, 0x10f7, buf, 1); /* URB 2135 */
4911
4912 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4913 buf[0] = 0x01;
4914 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4915 buf[0] = 0x14;
4916 usb_microdia_control_write(dev, 0x10f8, buf, 1); /* URB 2138 */
4917
4918 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4919 buf[0] = 0x0a;
4920 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4921 buf[0] = 0xff;
4922 usb_microdia_control_write(dev, 0x10fa, buf, 1); /* URB 2139 */
4923
4924 buf[0] = 0x00;
4925 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2140 */
4926 buf[0] = 0x00;
4927 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2141 */
4928 buf[0] = 0x0a;
4929 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2142 */
4930 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
4931 usb_microdia_control_write(dev, 0x11bc, buf, 4); /* URB 2143 */
4932 for (k = 0; k < 48; k++)
4933 buf[k] = 0x00;
4934 usb_microdia_control_write(dev, 0x11c0, buf, 48); /* URB 2144 */
4935
4936 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
4937 buf[4] = 0x04; buf[5] = 0x3f;
4938 usb_microdia_control_write(dev, 0x11a5, buf, 6); /* URB 2149 */
4939
4940 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4941 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
4942 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4943 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
4944 }
4945 usb_microdia_control_write(dev, 0x11af, buf, 4); /* URB 2150 */
4946
4947 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
4948 usb_microdia_control_write(dev, 0x11b3, buf, 4); /* URB 2151 */
4949 buf[0] = 0x47; /* ALEX: 0x04 */
4950 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2152 */
4951 buf[0] = 0x01;
4952 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2153 */
4953 buf[0] = 0x67; /* ALEX: 0x24 */
4954 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2154 */
4955 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
4956 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
4957 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
4958 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
4959 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
4960 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
4961 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
4962 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
4963 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
4964 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
4965 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
4966 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
4967 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
4968 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
4969 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
4970 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
4971 usb_microdia_control_write(dev, 0x1100, buf, 64); /* URB 2155 */
4972 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
4973 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
4974 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
4975 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
4976 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
4977 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
4978 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
4979 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
4980 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
4981 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
4982 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
4983 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
4984 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
4985 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
4986 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
4987 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
4988 usb_microdia_control_write(dev, 0x1140, buf, 64); /* URB 2156 */
4989 buf[0] = 0x47; /* ALEX: 0x04 */
4990 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2157 */
4991 buf[0] = 0x03;
4992 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2158 */
4993 buf[0] = 0x4b; /* ALEX: 0x08 */
4994 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2159 */
4995
4996 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4997 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4998 /* I2C MESSAGES */
4999 retI2C = 0;
5000 /* Writes to sensor registers 0x02: Column Start */
5001 /* 0x03: Window Hight */
5002 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
5003 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
5004 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2160-2162 */
5005 /* Writes to sensor registers 0x04: Window Width */
5006 /* 0x05: Horizontal Blanking */
5007 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
5008 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) */
5009 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2163-2165 */
5010 /* Writes to sensor registers 0x06: Vertical Blanking */
5011 /* 0x07: Output Control */
5012 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
5013 buf[2] = 0x30; buf[3] = 0x02; /* RESERVED options */
5014 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2166-2167 */
5015 /* Writes to sensor register 0x0e: UNDOCUMENTED */
5016 buf[0] = 0x00; buf[1] = 0x08;
5017 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2168-2170 */
5018 if (retI2C < 0) {
5019 UDIA_INFO("1 or more errors occured in I2C-message-block 6 !\n");
5020 return -1;
5021 }
5022 /* END OF I2C MESSAGES */
5023 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5024 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5025 buf[0] = 0x40;
5026 usb_microdia_control_write(dev, 0x1007, buf, 1);
5027 buf[0] = 0x40;
5028 usb_microdia_control_write(dev, 0x1006, buf, 1);
5029 }
5030
5031
5032 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
5033 buf[4] = 0x28; buf[5] = 0x3c;
5034 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2171 */
5035 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5036 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2172 */
5037 buf[0] = 0x0c;
5038 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2173 */
5039 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
5040 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2174 */
5041 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
5042 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2175 */
5043 buf[0] = 0x03;
5044 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2176 */
5045 buf[0] = 0x0a;
5046 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2177 */
5047 buf[0] = 0x00;
5048 usb_microdia_control_write(dev, 0x11b9, buf, 1); /* URB 2178 */
5049 buf[0] = 0x0b;
5050 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2179 */
5051 buf[0] = 0x01;
5052 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2180 */
5053 buf[0] = 0x78; /* ALEX: 0x7c */
5054 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2181 */
5055 buf[0] = 0x18; /* ALEX: 0x1c */
5056 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2182 */
5057 buf[0] = 0x18; /* ALEX: 0x1c */
5058 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2183 */
5059 buf[0] = 0x7d; /* ALEX: 0xfc */
5060 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2184 */
5061 buf[0] = 0x04;
5062 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2185 */
5063 buf[0] = 0x04;
5064 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2186 */
5065
5066 if ((last_11b8[0] == 0x3d) || (last_11b8[0] == 0x3f))
5067 buf[0] = 0x78;
5068 else if ((last_11b8[0] == 0xbd) || (last_11b8[0] == 0xbf))
5069 buf[0] = 0xf8;
5070 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2187 */
5071 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2188 // 0x38 */
5072 if (buf[0] == 0x38)
5073 buf[0] = 0x79;
5074 else if (buf[0] == 0xb8)
5075 buf[0] = 0xf9;
5076 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2189 */
5077 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2190 // 0xb9 */
5078 if (buf[0] == 0x39)
5079 buf[0] = 0x7a;
5080 else if (buf[0] == 0xb9)
5081 buf[0] = 0xfa;
5082 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2191 */
5083 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2192 // 0xba */
5084 if (buf[0] == 0x3a)
5085 buf[0] = 0x7b;
5086 else if (buf[0] == 0xba)
5087 buf[0] = 0xfb;
5088 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2193 */
5089 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2194 // 0x3b */
5090 if (buf[0] == 0x3b)
5091 buf[0] = 0x7c;
5092 else if (buf[0] == 0xbb)
5093 buf[0] = 0xfc;
5094 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2195 */
5095 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2196 // 0x3c */
5096 if (buf[0] == 0x3c)
5097 buf[0] = 0x7d;
5098 else if (buf[0] == 0xbc)
5099 buf[0] = 0xfd;
5100 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2197 */
5101 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2198 // 0x3d */
5102 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5103 if (buf[0] == 0x3d)
5104 buf[0] = 0x7e;
5105 else if (buf[0] == 0xbd)
5106 buf[0] = 0xfe;
5107 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2199 */
5108 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2200 */
5109 if (buf[0] == 0x3e)
5110 buf[0] = 0x7f;
5111 else if (buf[0] == 0xbe)
5112 buf[0] = 0xff;
5113 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2201 */
5114 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2202 */
5115 }
5116 buf[0] = buf[0] & 0xf0; /* 0xf0 or 0x70 */
5117 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
5118 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
5119
5120 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5121 /* I2C MESSAGES */
5122 retI2C = 0;
5123 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5124 /* Write to sensor register 0x06: Vertical Blanking */
5125 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
5126 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2204-2206 */
5127 /* Write to sensor register 0x05: Horizontal Blanking */
5128 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
5129 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2207-2209 */
5130 /* Read of sensor register 0x36: Chip Version (mirror of reg0xff) */
5131 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x36, dev->sensor_flags, buf); /* URBs 2211-2215 // 0x82 0x3a */
5132 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5133 /* Write to sensor register 0x0a: Pixel Clock Speed */
5134 buf[0] = 0x00; buf[1] = 0x00; /* default */
5135 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
5136 /* Write to sensor register 0x06: Vertical Blanking */
5137 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
5138 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
5139 /* Write to sensor register 0x05: Horizontal Blanking */
5140 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
5141 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
5142 /* Read of sensor register 0x00: Chip Version (=reg0xff) */
5143 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x00, dev->sensor_flags, buf); /* 0x82 0x43 */
5144 }
5145 if (retI2C < 0) {
5146 UDIA_INFO("1 or more errors occured in I2C-message-block 7 !\n");
5147 return -1;
5148 }
5149 /* END OF I2C MESSAGES */
5150 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5151
5152
5153 buf[0] = 0x03;
5154 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2216 */
5155
5156
5157 /*** NOW DRIVER DOES STOP-SEQUENCE
5158 - WITHOUT WRITES TO 0x1007 AND 0x1006 (URBs 3544-3550) => MT9V111
5159 - WRITING 0x40 INSTEAD OF 0x60 TO 0x1007 AND 0x1006 => MT9V011
5160 ***/
5161 /*** 2nd, 3rd, ... CYCLE: ALL MESSAGES (URBs 1953 - URBs 2216) ARE REPEATED ***/
5162 /*** ----- WE DON'T DO THIS, IT SEEMS TO BE UNNECESSARY ----- ***/
5163
5164 /* Setup IFP registers for AE and AWB (new, not in the logs): */
5165 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5166 mt9v111_setup_autoexposure(dev);
5167 mt9v111_setup_autowhitebalance(dev);
5168 mt9v111_set_autocorrections(dev, 1);
5169 }
5170
5171 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5172 buf[0] = 0x20;
5173 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5174 buf[0] = 0x60;
5175 usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 2489 */
5176 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5177 buf[0] = 0x00;
5178 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5179 buf[0] = 0x40;
5180 usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 2490 */
5181 /* => These two writes seem to cause the cam to start sending isochronus USB messages */
5182
5183 return 0;
5184 }
5185
5186 int microdia_627b_start_stream(struct usb_microdia *dev)
5187 {
5188 int ret;
5189 /* int actual; */
5190 __u16 reg;
5191 __u8 buf[64];
5192
5193 buf[0] = 0x00; /** Will have to be set for every single interrupt. */
5194 /*
5195 ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 43
5196 */
5197
5198 reg = 0x1066;
5199 buf[0] = 0x00;
5200 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 44 */
5201 if (ret < 0)
5202 goto err;
5203
5204 /*
5205 //ret = usb_set_interface(dev->udev, 0, 8);
5206 //if(ret < 0) goto err;
5207
5208 //buf[0] = 0x00; // Will have to be set for every single interrupt
5209 //ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 45
5210 */
5211
5212 reg = 0x1000;
5213 buf[0] = 0x78;
5214 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 46 */
5215 if (ret < 0)
5216 goto err;
5217
5218 reg = 0x1001;
5219 buf[0] = 0xc7;
5220 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 47 */
5221 if (ret < 0)
5222 goto err;
5223
5224 reg = 0x1002;
5225 buf[0] = 0x18;
5226 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 48 */
5227 if (ret < 0)
5228 goto err;
5229
5230 reg = 0x1061;
5231 buf[0] = 0x01;
5232 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 49 */
5233 if (ret < 0)
5234 goto err;
5235
5236 reg = 0x1020;
5237 buf[0] = 0x80;
5238 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 50 */
5239 if (ret < 0)
5240 goto err;
5241
5242 reg = 0x1067;
5243 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
5244 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 51 */
5245 if (ret < 0)
5246 goto err;
5247
5248 reg = 0x10c0;
5249 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
5250 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
5251 buf[8] = 0x03;
5252 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 52 */
5253 if (ret < 0)
5254 goto err;
5255
5256 /* transferbufferlength is 18, but data is 24 bytes long, what to do ? */
5257 reg = 0x10e0;
5258 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30; buf[4] = 0x00;
5259 buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed; buf[8] = 0x0f; buf[9] = 0xda;
5260 buf[10] = 0x0f; buf[11] = 0x3a; buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00;
5261 buf[15] = 0xd0; buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
5262 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
5263 ret = usb_microdia_control_write(dev, reg, buf, 24); /* URB 53 */
5264 if (ret < 0)
5265 goto err;
5266
5267 reg = 0x10f8;
5268 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
5269 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 54 */
5270 if (ret < 0)
5271 goto err;
5272
5273 reg = 0x10fb;
5274 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5275 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 55 */
5276 if (ret < 0)
5277 goto err;
5278
5279 reg = 0x1188;
5280 buf[0] = 0x86; buf[1] = 0x8c; buf[2] = 0x08;
5281 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 56 */
5282 if (ret < 0)
5283 goto err;
5284
5285 reg = 0x118b;
5286 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20; buf[4] = 0x20;
5287 buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b; buf[8] = 0x4f; buf[9] = 0x61;
5288 buf[10] = 0x71; buf[11] = 0x80; buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab;
5289 buf[15] = 0xb8; buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
5290 buf[20] = 0xf4; buf[21] = 0xff;
5291 ret = usb_microdia_control_write(dev, reg, buf, 22); /* URB 57 */
5292 if (ret < 0)
5293 goto err;
5294
5295 reg = 0x11a1;
5296 buf[0] = 0x00; buf[1] = 0x00;
5297 ret = usb_microdia_control_write(dev, reg, buf, 2); /* URB 58 */
5298 if (ret < 0)
5299 goto err;
5300
5301 reg = 0x11b7;
5302 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08; buf[4] = 0x00;
5303 buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0; buf[8] = 0x00;
5304 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 59 */
5305 if (ret < 0)
5306 goto err;
5307
5308 reg = 0x11b8;
5309 buf[0] = 0x38;
5310 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 60 */
5311 if (ret < 0)
5312 goto err;
5313
5314 reg = 0x1000;
5315 buf[0] = 0x78;
5316 ret = usb_microdia_control_write(dev, reg, buf, 1);
5317 if (ret < 0)
5318 goto err;
5319
5320 buf[0] = 0x80;
5321 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5322 OV7660_CTL_COM7, dev->sensor_flags, buf);
5323 if (ret < 0)
5324 goto errI2C;
5325
5326 buf[0] = 0x01; buf[1] = 0x74; buf[2] = 0x92; buf[3] = 0x00;
5327 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5328 OV7660_CTL_GAIN, dev->sensor_flags, buf);
5329 if (ret < 0)
5330 goto errI2C;
5331
5332 buf[0] = 0x00; buf[1] = 0x7d; buf[2] = 0x62; buf[3] = 0x00;
5333 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5334 OV7660_CTL_COM1, dev->sensor_flags, buf);
5335 if (ret < 0)
5336 goto errI2C;
5337
5338 buf[0] = 0x83; buf[1] = 0x01;
5339 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5340 OV7660_CTL_RAVE, dev->sensor_flags, buf);
5341 if (ret < 0)
5342 goto errI2C;
5343
5344 buf[0] = 0x00; buf[1] = 0x08; buf[2] = 0x04; buf[3] = 0x62;
5345 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5346 OV7660_CTL_COM3, dev->sensor_flags, buf);
5347 if (ret < 0)
5348 goto errI2C;
5349
5350 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x05; buf[3] = 0xf8;
5351 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5352 OV7660_CTL_AECH, dev->sensor_flags, buf);
5353 if (ret < 0)
5354 goto errI2C;
5355
5356 buf[0] = 0x2e; buf[1] = 0x00; buf[2] = 0x02;
5357 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
5358 OV7660_CTL_COM9, dev->sensor_flags, buf);
5359 if (ret < 0)
5360 goto errI2C;
5361
5362 buf[0] = 0x10; buf[1] = 0x60; buf[2] = 0x02; buf[3] = 0x7b;
5363 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5364 OV7660_CTL_HSTART, dev->sensor_flags, buf);
5365 if (ret < 0)
5366 goto errI2C;
5367
5368 buf[0] = 0x06;
5369 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5370 OV7660_CTL_PSHFT, dev->sensor_flags, buf);
5371 if (ret < 0)
5372 goto errI2C;
5373
5374 buf[0] = 0x01; buf[1] = 0x0e;
5375 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5376 OV7660_CTL_MVFP, dev->sensor_flags, buf);
5377 if (ret < 0)
5378 goto errI2C;
5379
5380 buf[0] = 0x07; buf[1] = 0x07; buf[2] = 0x07; buf[3] = 0x07;
5381 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5382 OV7660_CTL_BOS, dev->sensor_flags, buf);
5383 if (ret < 0)
5384 goto errI2C;
5385
5386 buf[0] = 0x68; buf[1] = 0x58; buf[2] = 0xd4; buf[3] = 0x80;
5387 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5388 OV7660_CTL_AEW, dev->sensor_flags, buf);
5389 if (ret < 0)
5390 goto errI2C;
5391
5392 buf[0] = 0x80; buf[1] = 0x3c; buf[2] = 0x00; buf[3] = 0x00;
5393 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5394 OV7660_CTL_GbBIAS, dev->sensor_flags, buf);
5395 if (ret < 0)
5396 goto errI2C;
5397
5398 buf[0] = 0x80; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x62;
5399 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5400 OV7660_CTL_RBIAS, dev->sensor_flags, buf);
5401 if (ret < 0)
5402 goto errI2C;
5403
5404 buf[0] = 0x08; buf[1] = 0x30; buf[2] = 0xb4;
5405 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
5406 OV7660_CTL_HSYST, dev->sensor_flags, buf);
5407 if (ret < 0)
5408 goto errI2C;
5409
5410 buf[0] = 0x00; buf[1] = 0x07; buf[2] = 0x84; buf[3] = 0x00;
5411 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5412 OV7660_CTL_CHLF, dev->sensor_flags, buf);
5413 if (ret < 0)
5414 goto errI2C;
5415
5416 buf[0] = 0x0c; buf[1] = 0x02; buf[2] = 0x43; buf[3] = 0x00;
5417 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5418 OV7660_CTL_ADC, dev->sensor_flags, buf);
5419 if (ret < 0)
5420 goto errI2C;
5421
5422 buf[0] = 0x02; buf[1] = 0x6c; buf[2] = 0x19; buf[3] = 0x0e;
5423 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5424 OV7660_CTL_COM11, dev->sensor_flags, buf);
5425 if (ret < 0)
5426 goto errI2C;
5427
5428 buf[0] = 0x41; buf[1] = 0xc1; buf[2] = 0x22; buf[3] = 0x08;
5429 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5430 OV7660_CTL_EDGE, dev->sensor_flags, buf);
5431 if (ret < 0)
5432 goto errI2C;
5433
5434 /* "Dummy" write */
5435 reg = 0x43; /* RSVD 0x43 is Reserved */
5436 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5437 reg, dev->sensor_flags, NULL);
5438 if (ret < 0)
5439 goto errI2C;
5440
5441 reg = 0x43; /* RSVD 0x43 is Reserved */
5442 buf[0] = 0xf0; buf[1] = 0x10; buf[2] = 0x78; buf[3] = 0xa8;
5443 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5444 dev->sensor_flags, buf);
5445 if (ret < 0)
5446 goto errI2C;
5447
5448 reg = 0x47; /* RSVD 0x47 is Reserved */
5449 buf[0] = 0x60; buf[1] = 0x80; buf[2] = 0x00; buf[3] = 0x00;
5450 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5451 dev->sensor_flags, buf);
5452 if (ret < 0)
5453 goto errI2C;
5454
5455 reg = 0x4b; /* RSVD 0x4b is Reserved */
5456 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5457 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5458 dev->sensor_flags, buf);
5459 if (ret < 0)
5460 goto errI2C;
5461
5462 /* "Dummy" write */
5463 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5464 OV7660_CTL_MTX1, dev->sensor_flags, NULL);
5465 if (ret < 0)
5466 goto errI2C;
5467
5468 reg = 0x59; /* RSVD 0x59 is Reserved */
5469 buf[0] = 0xba; buf[1] = 0x9a; buf[2] = 0x22; buf[3] = 0xb9;
5470 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5471 reg, dev->sensor_flags, buf);
5472 if (ret < 0)
5473 goto errI2C;
5474
5475 reg = 0x5d; /* RSVD 0x5d is Reserved */
5476 buf[0] = 0x9b; buf[1] = 0x10; buf[2] = 0xf0; buf[3] = 0x05;
5477 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5478 reg, dev->sensor_flags, buf);
5479 if (ret < 0)
5480 goto errI2C;
5481
5482 reg = 0x61; /* RSVD 0x61 is Reserved */
5483 buf[0] = 0x60;
5484 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5485 reg, dev->sensor_flags, buf);
5486 if (ret < 0)
5487 goto errI2C;
5488
5489 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x30;
5490 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5491 OV7660_CTL_LCC1, dev->sensor_flags, buf);
5492 if (ret < 0)
5493 goto errI2C;
5494
5495 buf[0] = 0x00;
5496 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5497 OV7660_CTL_LCC5, dev->sensor_flags, buf);
5498 if (ret < 0)
5499 goto errI2C;
5500
5501 buf[0] = 0x80; buf[1] = 0x7a; buf[2] = 0x90; buf[3] = 0x80;
5502 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5503 OV7660_CTL_MANU, dev->sensor_flags, buf);
5504 if (ret < 0)
5505 goto errI2C;
5506
5507 buf[0] = 0x0a;
5508 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5509 OV7660_CTL_DBLV, dev->sensor_flags, buf);
5510 if (ret < 0)
5511 goto errI2C;
5512
5513 reg = 0x8b; /* RSVD 0x8b is Reserved */
5514 buf[0] = 0x99; buf[1] = 0x99; buf[2] = 0xcf;
5515 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3, reg,
5516 dev->sensor_flags, buf);
5517 if (ret < 0)
5518 goto errI2C;
5519
5520 buf[0] = 0x00; buf[1] = 0x00;
5521 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5522 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
5523 if (ret < 0)
5524 goto errI2C;
5525
5526 reg = 0x1007;
5527 buf[0] = 0x40;
5528 ret = usb_microdia_control_write(dev, reg, buf, 1);
5529 if (ret < 0)
5530 goto err;
5531
5532 reg = 0x1006;
5533 buf[0] = 0x00;
5534 ret = usb_microdia_control_write(dev, reg, buf, 1);
5535 if (ret < 0)
5536 goto err;
5537
5538 reg = 0x10c1;
5539 ret = usb_microdia_control_read(dev, reg, buf, 1);
5540 if (ret < 0)
5541 goto err;
5542
5543 reg = 0x10c1;
5544 buf[0] = 0x50;
5545 ret = usb_microdia_control_write(dev, reg, buf, 1);
5546 if (ret < 0)
5547 goto err;
5548
5549 /* TRY TO READ FROM EEPROM: */
5550 reg = 0x00;
5551 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, reg, SN9C20X_I2C_2WIRE, buf);
5552 if (ret < 0)
5553 UDIA_INFO("No EEPROM found\n");
5554 else
5555 UDIA_INFO("Read from EEPROM successful\n");
5556
5557 reg = 0x10c1;
5558 buf[0] = 0x21;
5559 ret = usb_microdia_control_write(dev, reg, buf, 1);
5560 if (ret < 0)
5561 goto err;
5562
5563 reg = 0x10e0;
5564 buf[0] = 0x47;
5565 ret = usb_microdia_control_write(dev, reg, buf, 1);
5566 if (ret < 0)
5567 goto err;
5568
5569 reg = 0x10e0;
5570 buf[0] = 0x47;
5571 ret = usb_microdia_control_write(dev, reg, buf, 1);
5572 if (ret < 0)
5573 goto err;
5574
5575 reg = 0x1001;
5576 buf[0] = 0xc6;
5577 ret = usb_microdia_control_write(dev, reg, buf, 1);
5578 if (ret < 0)
5579 goto err;
5580
5581 reg = 0x1001;
5582 buf[0] = 0xc4;
5583 ret = usb_microdia_control_write(dev, reg, buf, 1);
5584 if (ret < 0)
5585 goto err;
5586
5587 reg = 0x1001;
5588 buf[0] = 0x84;
5589 ret = usb_microdia_control_write(dev, reg, buf, 1);
5590 if (ret < 0)
5591 goto err;
5592
5593 buf[0] = 0x08;
5594 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5595 OV7660_CTL_VREF, dev->sensor_flags, buf);
5596 if (ret < 0)
5597 goto errI2C;
5598
5599 buf[0] = 0x10; buf[1] = 0x61; buf[2] = 0x02; buf[3] = 0x7a;
5600 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5601 OV7660_CTL_HSTART, dev->sensor_flags, buf);
5602 if (ret < 0)
5603 goto errI2C;
5604
5605 /* "Dummy" write: */
5606 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5607 OV7660_CTL_PSHFT, dev->sensor_flags, NULL);
5608 if (ret < 0)
5609 goto errI2C;
5610
5611 buf[0] = 0x84;
5612 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5613 OV7660_CTL_HREF, dev->sensor_flags, buf);
5614 if (ret < 0)
5615 goto errI2C;
5616
5617 buf[0] = 0x84;
5618 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5619 OV7660_CTL_HREF, dev->sensor_flags, buf);
5620 if (ret < 0)
5621 goto errI2C;
5622
5623 buf[0] = 0x84;
5624 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5625 OV7660_CTL_HREF, dev->sensor_flags, buf);
5626 if (ret < 0)
5627 goto errI2C;
5628
5629 buf[0] = 0x84;
5630 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5631 OV7660_CTL_HREF, dev->sensor_flags, buf);
5632 if (ret < 0)
5633 goto errI2C;
5634
5635 buf[0] = 0x84;
5636 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5637 OV7660_CTL_HREF, dev->sensor_flags, buf);
5638 if (ret < 0)
5639 goto errI2C;
5640
5641 reg = 0x1180;
5642 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
5643 buf[5] = 0x3c;
5644 ret = usb_microdia_control_write(dev, reg, buf, 6);
5645 if (ret < 0)
5646 goto err;
5647
5648 reg = 0x10fb;
5649 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5650 ret = usb_microdia_control_write(dev, reg, buf, 5);
5651 if (ret < 0)
5652 goto err;
5653
5654 reg = 0x1189;
5655 buf[0] = 0x8c;
5656 ret = usb_microdia_control_write(dev, reg, buf, 1);
5657 if (ret < 0)
5658 goto err;
5659
5660 reg = 0x11a1;
5661 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
5662 ret = usb_microdia_control_write(dev, reg, buf, 4);
5663 if (ret < 0)
5664 goto err;
5665
5666 reg = 0x11ab;
5667 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
5668 ret = usb_microdia_control_write(dev, reg, buf, 4);
5669 if (ret < 0)
5670 goto err;
5671
5672 reg = 0x1000;
5673 buf[0] = 0x78;
5674 ret = usb_microdia_control_write(dev, reg, buf, 1);
5675 if (ret < 0)
5676 goto err;
5677
5678 reg = 0x1002;
5679 buf[0] = 0x18;
5680 ret = usb_microdia_control_write(dev, reg, buf, 1);
5681 if (ret < 0)
5682 goto err;
5683
5684 reg = 0x1002;
5685 buf[0] = 0x18;
5686 ret = usb_microdia_control_write(dev, reg, buf, 1);
5687 if (ret < 0)
5688 goto err;
5689
5690 reg = 0x11b8;
5691 buf[0] = 0x38;
5692 ret = usb_microdia_control_write(dev, reg, buf, 1);
5693 if (ret < 0)
5694 goto err;
5695
5696 reg = 0x118a;
5697 buf[0] = 0x04;
5698 ret = usb_microdia_control_write(dev, reg, buf, 1);
5699 if (ret < 0)
5700 goto err;
5701
5702 reg = 0x0395;
5703 buf[0] = 0x04;
5704 ret = usb_microdia_control_write(dev, reg, buf, 1);
5705 if (ret < 0)
5706 goto err;
5707
5708 reg = 0x11b8;
5709 buf[0] = 0x78;
5710 ret = usb_microdia_control_write(dev, reg, buf, 1);
5711 if (ret < 0)
5712 goto err;
5713 ret = usb_microdia_control_read(dev, reg, buf, 1);
5714 if (ret < 0)
5715 goto err;
5716
5717 reg = 0x11b8;
5718 buf[0] = 0xf9;
5719 ret = usb_microdia_control_write(dev, reg, buf, 1);
5720 if (ret < 0)
5721 goto err;
5722 ret = usb_microdia_control_read(dev, reg, buf, 1);
5723 if (ret < 0)
5724 goto err;
5725
5726 reg = 0x11b8;
5727 buf[0] = 0xfa;
5728 ret = usb_microdia_control_write(dev, reg, buf, 1);
5729 if (ret < 0)
5730 goto err;
5731 ret = usb_microdia_control_read(dev, reg, buf, 1);
5732 if (ret < 0)
5733 goto err;
5734
5735 reg = 0x11b8;
5736 buf[0] = 0x7b;
5737 ret = usb_microdia_control_write(dev, reg, buf, 1);
5738 if (ret < 0)
5739 goto err;
5740 ret = usb_microdia_control_read(dev, reg, buf, 1);
5741 if (ret < 0)
5742 goto err;
5743
5744 reg = 0x11b8;
5745 buf[0] = 0x7c;
5746 ret = usb_microdia_control_write(dev, reg, buf, 1);
5747 if (ret < 0)
5748 goto err;
5749 ret = usb_microdia_control_read(dev, reg, buf, 1);
5750 if (ret < 0)
5751 goto err;
5752
5753 reg = 0x11b8;
5754 buf[0] = 0x7d;
5755 ret = usb_microdia_control_write(dev, reg, buf, 1);
5756 if (ret < 0)
5757 goto err;
5758 ret = usb_microdia_control_read(dev, reg, buf, 1);
5759 if (ret < 0)
5760 goto err;
5761
5762 reg = 0x11b8;
5763 buf[0] = 0x7b;
5764 ret = usb_microdia_control_write(dev, reg, buf, 1);
5765 if (ret < 0)
5766 goto err;
5767
5768 /*
5769 //ret = usb_microdia_control_read(dev, reg, buf, 1);
5770 //if(ret < 0) goto err;
5771 */
5772
5773 buf[0] = 0x40;
5774 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5775 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
5776 if (ret < 0)
5777 goto errI2C;
5778
5779 buf[0] = 0x00;
5780 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5781 OV7660_CTL_EXHCH, dev->sensor_flags, buf);
5782 if (ret < 0)
5783 goto errI2C;
5784
5785 buf[0] = 0x00;
5786 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5787 OV7660_CTL_EXHCL, dev->sensor_flags, buf);
5788 if (ret < 0)
5789 goto errI2C;
5790
5791 buf[0] = 0x00;
5792 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5793 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
5794 if (ret < 0)
5795 goto errI2C;
5796
5797 buf[0] = 0x00;
5798 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5799 OV7660_CTL_DM_LNH, dev->sensor_flags, buf);
5800 if (ret < 0)
5801 goto errI2C;
5802
5803 buf[0] = 0x01;
5804 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5805 OV7660_CTL_MVFP, dev->sensor_flags, buf);
5806 if (ret < 0)
5807 goto errI2C;
5808
5809 buf[0] = 0x01;
5810 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5811 OV7660_CTL_MVFP, dev->sensor_flags, buf);
5812 if (ret < 0)
5813 goto errI2C;
5814
5815 buf[0] = 0x08;
5816 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5817 OV7660_CTL_VREF, dev->sensor_flags, buf);
5818 if (ret < 0)
5819 goto errI2C;
5820
5821 buf[0] = 0x00;
5822 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5823 OV7660_CTL_VREF, dev->sensor_flags, buf);
5824 if (ret < 0)
5825 goto errI2C;
5826
5827 buf[0] = 0x7f;
5828 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5829 OV7660_CTL_AECH, dev->sensor_flags, buf);
5830 if (ret < 0)
5831 goto errI2C;
5832
5833 buf[0] = 0x00;
5834 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5835 OV7660_CTL_COM1, dev->sensor_flags, buf);
5836 if (ret < 0)
5837 goto errI2C;
5838
5839 buf[0] = 0x00;
5840 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5841 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
5842 if (ret < 0)
5843 goto errI2C;
5844
5845 buf[0] = 0x00;
5846 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5847 OV7660_CTL_ADVFH, dev->sensor_flags, buf);
5848 if (ret < 0)
5849 goto errI2C;
5850
5851 buf[0] = 0x00;
5852 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5853 OV7660_CTL_GAIN, dev->sensor_flags, buf);
5854 if (ret < 0)
5855 goto errI2C;
5856
5857 buf[0] = 0x78; buf[1] = 0x78;
5858 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5859 OV7660_CTL_BLUE, dev->sensor_flags, buf);
5860 if (ret < 0)
5861 goto errI2C;
5862
5863 reg = 0x11ba;
5864 buf[0] = 0x0a;
5865 ret = usb_microdia_control_write(dev, reg, buf, 1);
5866 if (ret < 0)
5867 goto err;
5868
5869 reg = 0x118b;
5870 buf[0] = 0x0c;
5871 ret = usb_microdia_control_write(dev, reg, buf, 1);
5872 if (ret < 0)
5873 goto err;
5874
5875 reg = 0x10f7;
5876 buf[0] = 0x05;
5877 ret = usb_microdia_control_write(dev, reg, buf, 1);
5878 if (ret < 0)
5879 goto err;
5880
5881 reg = 0x10f8;
5882 buf[0] = 0x14;
5883 ret = usb_microdia_control_write(dev, reg, buf, 1);
5884 if (ret < 0)
5885 goto err;
5886
5887 reg = 0x10fa;
5888 buf[0] = 0xff;
5889 ret = usb_microdia_control_write(dev, reg, buf, 1);
5890 if (ret < 0)
5891 goto err;
5892
5893 reg = 0x10f9;
5894 buf[0] = 0x00;
5895 ret = usb_microdia_control_write(dev, reg, buf, 1);
5896 if (ret < 0)
5897 goto err;
5898
5899 reg = 0x10f9;
5900 buf[0] = 0x00;
5901 ret = usb_microdia_control_write(dev, reg, buf, 1);
5902 if (ret < 0)
5903 goto err;
5904
5905 reg = 0x11ba;
5906 buf[0] = 0x0a;
5907 ret = usb_microdia_control_write(dev, reg, buf, 1);
5908 if (ret < 0)
5909 goto err;
5910
5911 reg = 0x11bc;
5912 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5913 ret = usb_microdia_control_write(dev, reg, buf, 4);
5914 if (ret < 0)
5915 goto err;
5916
5917 reg = 0x11c0;
5918 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00;
5919 buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00; buf[9] = 0x00;
5920 buf[10] = 0x00; buf[11] = 0x00; buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00;
5921 buf[15] = 0x00; buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
5922 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00; buf[24] = 0x00;
5923 buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00; buf[28] = 0x00; buf[29] = 0x00;
5924 buf[30] = 0x00; buf[31] = 0x00; buf[32] = 0x00;
5925 ret = usb_microdia_control_write(dev, reg, buf, 33);
5926 if (ret < 0)
5927 goto err;
5928 /* transferbufferlength was only 30 ? */
5929
5930 reg = 0x11a5;
5931 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05; buf[4] = 0x04;
5932 buf[5] = 0x3f;
5933 ret = usb_microdia_control_write(dev, reg, buf, 6);
5934 if (ret < 0)
5935 goto err;
5936
5937 reg = 0x11af;
5938 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
5939 ret = usb_microdia_control_write(dev, reg, buf, 4);
5940 if (ret < 0)
5941 goto err;
5942
5943 reg = 0x11b3;
5944 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
5945 ret = usb_microdia_control_write(dev, reg, buf, 4);
5946 if (ret < 0)
5947 goto err;
5948
5949 reg = 0x10e0;
5950 buf[0] = 0x47;
5951 ret = usb_microdia_control_write(dev, reg, buf, 1);
5952 if (ret < 0)
5953 goto err;
5954
5955 reg = 0x1061;
5956 buf[0] = 0x01;
5957 ret = usb_microdia_control_write(dev, reg, buf, 1);
5958 if (ret < 0)
5959 goto err;
5960
5961 reg = 0x10e0;
5962 buf[0] = 0x67;
5963 ret = usb_microdia_control_write(dev, reg, buf, 1);
5964 if (ret < 0)
5965 goto err;
5966
5967 reg = 0x1100;
5968 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d; buf[4] = 0x08;
5969 buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d; buf[8] = 0x0d; buf[9] = 0x0d;
5970 buf[10] = 0x11; buf[11] = 0x0d; buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15;
5971 buf[15] = 0x21; buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
5972 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d; buf[24] = 0x19;
5973 buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a; buf[28] = 0x32; buf[29] = 0x32;
5974 buf[30] = 0x2e; buf[31] = 0x2a; buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36;
5975 buf[35] = 0x3a; buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
5976 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e; buf[44] = 0x43;
5977 buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47; buf[48] = 0x4f; buf[49] = 0x53;
5978 buf[50] = 0x58; buf[51] = 0x58; buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f;
5979 buf[55] = 0x60; buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
5980 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
5981 ret = usb_microdia_control_write(dev, reg, buf, 64);
5982 if (ret < 0)
5983 goto err;
5984 /* transferbufferlength is only 40 ? */
5985
5986 reg = 0x1140;
5987 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15; buf[4] = 0x11;
5988 buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15; buf[8] = 0x15; buf[9] = 0x26;
5989 buf[10] = 0x53; buf[11] = 0x36; buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53;
5990 buf[15] = 0x53; buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
5991 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53; buf[24] = 0x53;
5992 buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53; buf[28] = 0x53; buf[29] = 0x53;
5993 buf[30] = 0x53; buf[31] = 0x53; buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53;
5994 buf[35] = 0x53; buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
5995 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53; buf[44] = 0x53;
5996 buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53; buf[48] = 0x53; buf[49] = 0x53;
5997 buf[50] = 0x53; buf[51] = 0x53; buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53;
5998 buf[55] = 0x53; buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
5999 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
6000 ret = usb_microdia_control_write(dev, reg, buf, 64);
6001 if (ret < 0)
6002 goto err;
6003 /* transferbufferlength is only 40 ? */
6004
6005 reg = 0x10e0;
6006 buf[0] = 0x47;
6007 ret = usb_microdia_control_write(dev, reg, buf, 1);
6008 if (ret < 0)
6009 goto err;
6010
6011 reg = 0x1061;
6012 buf[0] = 0x03;
6013 ret = usb_microdia_control_write(dev, reg, buf, 1);
6014 if (ret < 0)
6015 goto err;
6016
6017 reg = 0x10e0;
6018 buf[0] = 0x4b;
6019 ret = usb_microdia_control_write(dev, reg, buf, 1);
6020 if (ret < 0)
6021 goto err;
6022
6023 buf[0] = 0x08;
6024 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6025 OV7660_CTL_VREF, dev->sensor_flags, buf);
6026 if (ret < 0)
6027 goto errI2C;
6028
6029 reg = 0x1180;
6030 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
6031 buf[5] = 0x3c;
6032 ret = usb_microdia_control_write(dev, reg, buf, 6);
6033 if (ret < 0)
6034 goto err;
6035
6036 reg = 0x10fb;
6037 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6038 ret = usb_microdia_control_write(dev, reg, buf, 5);
6039 if (ret < 0)
6040 goto err;
6041
6042 reg = 0x1189;
6043 buf[0] = 0x8c;
6044 ret = usb_microdia_control_write(dev, reg, buf, 1);
6045 if (ret < 0)
6046 goto err;
6047
6048 reg = 0x11a1;
6049 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
6050 ret = usb_microdia_control_write(dev, reg, buf, 4);
6051 if (ret < 0)
6052 goto err;
6053
6054 reg = 0x11ab;
6055 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
6056 ret = usb_microdia_control_write(dev, reg, buf, 4);
6057 if (ret < 0)
6058 goto err;
6059
6060 reg = 0x1061;
6061 buf[0] = 0x03;
6062 ret = usb_microdia_control_write(dev, reg, buf, 1);
6063 if (ret < 0)
6064 goto err;
6065
6066 reg = 0x11ba;
6067 buf[0] = 0x0a;
6068 ret = usb_microdia_control_write(dev, reg, buf, 1);
6069 if (ret < 0)
6070 goto err;
6071
6072 reg = 0x11b9;
6073 buf[0] = 0x00;
6074 ret = usb_microdia_control_write(dev, reg, buf, 1);
6075 if (ret < 0)
6076 goto err;
6077
6078 reg = 0x11ba;
6079 buf[0] = 0x0b;
6080 ret = usb_microdia_control_write(dev, reg, buf, 1);
6081 if (ret < 0)
6082 goto err;
6083
6084 reg = 0x1061;
6085 buf[0] = 0x01;
6086 ret = usb_microdia_control_write(dev, reg, buf, 1);
6087 if (ret < 0)
6088 goto err;
6089
6090 reg = 0x1000;
6091 buf[0] = 0x78;
6092 ret = usb_microdia_control_write(dev, reg, buf, 1);
6093 if (ret < 0)
6094 goto err;
6095
6096 reg = 0x1002;
6097 buf[0] = 0x18;
6098 ret = usb_microdia_control_write(dev, reg, buf, 1);
6099 if (ret < 0)
6100 goto err;
6101
6102 reg = 0x1002;
6103 buf[0] = 0x18;
6104 ret = usb_microdia_control_write(dev, reg, buf, 1);
6105 if (ret < 0)
6106 goto err;
6107
6108 reg = 0x11b8;
6109 buf[0] = 0x7b;
6110 ret = usb_microdia_control_write(dev, reg, buf, 1);
6111 if (ret < 0)
6112 goto err;
6113
6114 reg = 0x118a;
6115 buf[0] = 0x04;
6116 ret = usb_microdia_control_write(dev, reg, buf, 1);
6117 if (ret < 0)
6118 goto err;
6119
6120 reg = 0x0395;
6121 buf[0] = 0x04;
6122 ret = usb_microdia_control_write(dev, reg, buf, 1);
6123 if (ret < 0)
6124 goto err;
6125
6126 reg = 0x11b8;
6127 buf[0] = 0x78;
6128 ret = usb_microdia_control_write(dev, reg, buf, 1);
6129 if (ret < 0)
6130 goto err;
6131 ret = usb_microdia_control_read(dev, reg, buf, 1);
6132 if (ret < 0)
6133 goto err;
6134
6135 reg = 0x11b8;
6136 buf[0] = 0xf9;
6137 ret = usb_microdia_control_write(dev, reg, buf, 1);
6138 if (ret < 0)
6139 goto err;
6140 ret = usb_microdia_control_read(dev, reg, buf, 1);
6141 if (ret < 0)
6142 goto err;
6143
6144 reg = 0x11b8;
6145 buf[0] = 0xfa;
6146 ret = usb_microdia_control_write(dev, reg, buf, 1);
6147 if (ret < 0)
6148 goto err;
6149 ret = usb_microdia_control_read(dev, reg, buf, 1);
6150 if (ret < 0)
6151 goto err;
6152
6153 reg = 0x11b8;
6154 buf[0] = 0x7b;
6155 ret = usb_microdia_control_write(dev, reg, buf, 1);
6156 if (ret < 0)
6157 goto err;
6158 ret = usb_microdia_control_read(dev, reg, buf, 1);
6159 if (ret < 0)
6160 goto err;
6161
6162 reg = 0x11b8;
6163 buf[0] = 0x7c;
6164 ret = usb_microdia_control_write(dev, reg, buf, 1);
6165 if (ret < 0)
6166 goto err;
6167 ret = usb_microdia_control_read(dev, reg, buf, 1);
6168 if (ret < 0)
6169 goto err;
6170
6171 reg = 0x11b8;
6172 buf[0] = 0x7d;
6173 ret = usb_microdia_control_write(dev, reg, buf, 1);
6174 if (ret < 0)
6175 goto err;
6176 ret = usb_microdia_control_read(dev, reg, buf, 1);
6177 if (ret < 0)
6178 goto err;
6179
6180 reg = 0x11b8;
6181 buf[0] = 0x7b;
6182 ret = usb_microdia_control_write(dev, reg, buf, 1);
6183 if (ret < 0)
6184 goto err;
6185
6186 buf[0] = 0x40;
6187 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6188 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
6189 if (ret < 0)
6190 goto errI2C;
6191
6192 buf[0] = 0x00;
6193 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6194 OV7660_CTL_EXHCH, dev->sensor_flags, buf);
6195 if (ret < 0)
6196 goto errI2C;
6197
6198 buf[0] = 0x00;
6199 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6200 OV7660_CTL_EXHCL, dev->sensor_flags, buf);
6201 if (ret < 0)
6202 goto errI2C;
6203
6204 buf[0] = 0x00;
6205 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6206 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
6207 if (ret < 0)
6208 goto errI2C;
6209
6210 buf[0] = 0x00;
6211 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6212 OV7660_CTL_DM_LNH, dev->sensor_flags, buf);
6213 if (ret < 0)
6214 goto errI2C;
6215
6216 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6217 OV7660_CTL_PID, dev->sensor_flags, buf);
6218 if (ret < 0)
6219 goto errI2C;
6220
6221 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6222 OV7660_CTL_VER, dev->sensor_flags, buf);
6223 if (ret < 0)
6224 goto errI2C;
6225
6226 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6227 OV7660_CTL_MIDH, dev->sensor_flags, buf);
6228 if (ret < 0)
6229 goto errI2C;
6230
6231 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6232 OV7660_CTL_MIDL, dev->sensor_flags, buf);
6233 if (ret < 0)
6234 goto errI2C;
6235
6236 reg = 0x1061;
6237 buf[0] = 0x03;
6238 ret = usb_microdia_control_write(dev, reg, buf, 1);
6239 if (ret < 0)
6240 goto err;
6241
6242 reg = 0x1007;
6243 buf[0] = 0x60;
6244 ret = usb_microdia_control_write(dev, reg, buf, 1);
6245 if (ret < 0)
6246 goto err;
6247
6248 reg = 0x1006;
6249 buf[0] = 0x00;
6250 ret = usb_microdia_control_write(dev, reg, buf, 1);
6251 if (ret < 0)
6252 goto err;
6253
6254 reg = 0x1007;
6255 buf[0] = 0x60;
6256 ret = usb_microdia_control_write(dev, reg, buf, 1);
6257 if (ret < 0)
6258 goto err;
6259
6260 reg = 0x1006;
6261 buf[0] = 0x00;
6262 ret = usb_microdia_control_write(dev, reg, buf, 1);
6263 if (ret < 0)
6264 goto err;
6265
6266 buf[0] = 0x7f;
6267 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6268 OV7660_CTL_AECH, dev->sensor_flags, buf);
6269 if (ret < 0)
6270 goto errI2C;
6271
6272 buf[0] = 0x01;
6273 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6274 OV7660_CTL_COM1, dev->sensor_flags, buf);
6275 if (ret < 0)
6276 goto errI2C;
6277
6278 buf[0] = 0x13;
6279 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6280 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6281 if (ret < 0)
6282 goto errI2C;
6283
6284 buf[0] = 0x00; buf[1] = 0x01;
6285 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6286 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6287 if (ret < 0)
6288 goto errI2C;
6289
6290 buf[0] = 0x1e;
6291 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6292 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6293 if (ret < 0)
6294 goto errI2C;
6295
6296 buf[0] = 0x50; buf[1] = 0x60;
6297 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6298 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6299 if (ret < 0)
6300 goto errI2C;
6301
6302 buf[0] = 0xfc; buf[1] = 0x04;
6303 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6304 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6305 if (ret < 0)
6306 goto errI2C;
6307
6308 buf[0] = 0x1f; buf[1] = 0x00;
6309 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6310 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6311 if (ret < 0)
6312 goto errI2C;
6313
6314 buf[0] = 0x48; buf[1] = 0x58;
6315 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6316 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6317 if (ret < 0)
6318 goto errI2C;
6319
6320 buf[0] = 0xf6; buf[1] = 0x0b;
6321 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6322 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6323 if (ret < 0)
6324 goto errI2C;
6325
6326 reg = 0x1006;
6327 buf[0] = 0x40;
6328 ret = usb_microdia_control_write(dev, reg, buf, 1);
6329 if (ret < 0)
6330 goto err;
6331
6332 buf[0] = 0x50; buf[1] = 0x60;
6333 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6334 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6335 if (ret < 0)
6336 goto errI2C;
6337
6338 return ret;
6339 err:
6340 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
6341 return ret;
6342
6343 errI2C:
6344 UDIA_ERROR("r/w in sensor register %x failed (%d)!\n", reg, ret);
6345 return ret;
6346
6347 }
6348
6349 /**
6350 * @brief From UsbSnoop-plugin-parsed.log
6351 *
6352 * @param dev
6353 *
6354 * @returns 0 (OK) or <0 (Error)
6355 *
6356 * @author Vincent, Kuzja
6357 */
6358 int microdia_6288_start_stream(struct usb_microdia *dev)
6359 {
6360 int ret;
6361 __u16 reg;
6362 __u8 buf[64];
6363
6364
6365
6366 reg = 0x1066 ;
6367 buf[0] = 0x00;
6368 ret = usb_microdia_control_write(dev, reg, buf, 1);
6369 if (ret < 0)
6370 goto err;
6371
6372 reg = 0x1000 ;
6373 buf[0] = 0x78;
6374 ret = usb_microdia_control_write(dev, reg, buf, 1);
6375 if (ret < 0)
6376 goto err;
6377
6378 reg = 0x1001 ;
6379 buf[0] = 0xc7;
6380 ret = usb_microdia_control_write(dev, reg, buf, 1);
6381 if (ret < 0)
6382 goto err;
6383
6384 reg = 0x1002 ;
6385 buf[0] = 0x1c;
6386 ret = usb_microdia_control_write(dev, reg, buf, 1);
6387 if (ret < 0)
6388 goto err;
6389
6390 reg = 0x1061 ;
6391 buf[0] = 0x01;
6392 ret = usb_microdia_control_write(dev, reg, buf, 1);
6393 if (ret < 0)
6394 goto err;
6395
6396 reg = 0x1020 ;
6397 buf[0] = 0x80;
6398 ret = usb_microdia_control_write(dev, reg, buf, 1);
6399 if (ret < 0)
6400 goto err;
6401
6402 reg = 0x1067 ;
6403 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
6404 buf[3] = 0x10; buf[4] = 0x08;
6405 ret = usb_microdia_control_write(dev, reg, buf, 5);
6406 if (ret < 0)
6407 goto err;
6408
6409 reg = 0x10c0 ;
6410 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;
6411 ret = usb_microdia_control_write(dev, reg, buf, 9);
6412 if (ret < 0)
6413 goto err;
6414
6415 reg = 0x10e0 ;
6416 buf[0] = 0x44; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
6417 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
6418 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
6419 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
6420 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
6421 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
6422 ret = usb_microdia_control_write(dev, reg, buf, 24);
6423 if (ret < 0)
6424 goto err;
6425
6426 reg = 0x10f8 ;
6427 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
6428 ret = usb_microdia_control_write(dev, reg, buf, 3);
6429 if (ret < 0)
6430 goto err;
6431
6432 reg = 0x10fb ;
6433 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6434 ret = usb_microdia_control_write(dev, reg, buf, 5);
6435 if (ret < 0)
6436 goto err;
6437
6438 reg = 0x1188 ;
6439 buf[0] = 0x86; buf[1] = 0xcc; buf[2] = 0x08;
6440 ret = usb_microdia_control_write(dev, reg, buf, 3);
6441 if (ret < 0)
6442 goto err;
6443
6444 reg = 0x118b ;
6445 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
6446 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
6447 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
6448 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
6449 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
6450 buf[20] = 0xf4; buf[21] = 0xff;
6451 ret = usb_microdia_control_write(dev, reg, buf, 22);
6452 if (ret < 0)
6453 goto err;
6454
6455 reg = 0x11a1 ;
6456 buf[0] = 0x00; buf[1] = 0x00;
6457 ret = usb_microdia_control_write(dev, reg, buf, 2);
6458 if (ret < 0)
6459 goto err;
6460
6461 reg = 0x11b7 ;
6462 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x08;
6463 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
6464 buf[8] = 0x00;
6465 ret = usb_microdia_control_write(dev, reg, buf, 9);
6466 if (ret < 0)
6467 goto err;
6468
6469 reg = 0x11b8 ;
6470 buf[0] = 0x30;
6471 ret = usb_microdia_control_write(dev, reg, buf, 1);
6472 if (ret < 0)
6473 goto err;
6474
6475 reg = 0x1000 ;
6476 buf[0] = 0x78;
6477 ret = usb_microdia_control_write(dev, reg, buf, 1);
6478 if (ret < 0)
6479 goto err;
6480
6481 reg = 0x10c0 ;
6482 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6483 ret = usb_microdia_control_write(dev, reg, buf, 8);
6484 if (ret < 0)
6485 goto err;
6486
6487 reg = 0x10c0 ;
6488 ret = usb_microdia_control_read(dev, reg, buf, 1);
6489 if (ret < 0)
6490 goto err;
6491
6492 reg = 0x10c0 ;
6493 ret = usb_microdia_control_read(dev, reg, buf, 1);
6494 if (ret < 0)
6495 goto err;
6496
6497 reg = 0x10c0 ;
6498 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6499 ret = usb_microdia_control_write(dev, reg, buf, 8);
6500 if (ret < 0)
6501 goto err;
6502
6503 reg = 0x10c0 ;
6504 ret = usb_microdia_control_read(dev, reg, buf, 1);
6505 if (ret < 0)
6506 goto err;
6507
6508 reg = 0x10c0 ;
6509 ret = usb_microdia_control_read(dev, reg, buf, 1);
6510 if (ret < 0)
6511 goto err;
6512
6513 reg = 0x10c0 ;
6514 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6515 ret = usb_microdia_control_write(dev, reg, buf, 8);
6516 if (ret < 0)
6517 goto err;
6518
6519 reg = 0x10c0 ;
6520 ret = usb_microdia_control_read(dev, reg, buf, 1);
6521 if (ret < 0)
6522 goto err;
6523
6524 reg = 0x10c0 ;
6525 ret = usb_microdia_control_read(dev, reg, buf, 1);
6526 if (ret < 0)
6527 goto err;
6528
6529 reg = 0x10c0 ;
6530 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0e; buf[3] = 0x61; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6531 ret = usb_microdia_control_write(dev, reg, buf, 8);
6532 if (ret < 0)
6533 goto err;
6534
6535 reg = 0x10c0 ;
6536 ret = usb_microdia_control_read(dev, reg, buf, 1);
6537 if (ret < 0)
6538 goto err;
6539
6540 reg = 0x10c0 ;
6541 ret = usb_microdia_control_read(dev, reg, buf, 1);
6542 if (ret < 0)
6543 goto err;
6544
6545 reg = 0x10c0 ;
6546 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6547 ret = usb_microdia_control_write(dev, reg, buf, 8);
6548 if (ret < 0)
6549 goto err;
6550
6551 reg = 0x10c0 ;
6552 ret = usb_microdia_control_read(dev, reg, buf, 1);
6553 if (ret < 0)
6554 goto err;
6555
6556 reg = 0x10c0 ;
6557 ret = usb_microdia_control_read(dev, reg, buf, 1);
6558 if (ret < 0)
6559 goto err;
6560
6561 reg = 0x10c0 ;
6562 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x13; buf[3] = 0xb8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6563 ret = usb_microdia_control_write(dev, reg, buf, 8);
6564 if (ret < 0)
6565 goto err;
6566
6567 reg = 0x10c0 ;
6568 ret = usb_microdia_control_read(dev, reg, buf, 1);
6569 if (ret < 0)
6570 goto err;
6571
6572 reg = 0x10c0 ;
6573 ret = usb_microdia_control_read(dev, reg, buf, 1);
6574 if (ret < 0)
6575 goto err;
6576
6577 reg = 0x10c0 ;
6578 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x14; buf[3] = 0x3e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6579 ret = usb_microdia_control_write(dev, reg, buf, 8);
6580 if (ret < 0)
6581 goto err;
6582
6583 reg = 0x10c0 ;
6584 ret = usb_microdia_control_read(dev, reg, buf, 1);
6585 if (ret < 0)
6586 goto err;
6587
6588 reg = 0x10c0 ;
6589 ret = usb_microdia_control_read(dev, reg, buf, 1);
6590 if (ret < 0)
6591 goto err;
6592
6593 reg = 0x10c0 ;
6594 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x16; buf[3] = 0x24; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6595 ret = usb_microdia_control_write(dev, reg, buf, 8);
6596 if (ret < 0)
6597 goto err;
6598
6599 reg = 0x10c0 ;
6600 ret = usb_microdia_control_read(dev, reg, buf, 1);
6601 if (ret < 0)
6602 goto err;
6603
6604 reg = 0x10c0 ;
6605 ret = usb_microdia_control_read(dev, reg, buf, 1);
6606 if (ret < 0)
6607 goto err;
6608
6609 reg = 0x10c0 ;
6610 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6611 ret = usb_microdia_control_write(dev, reg, buf, 8);
6612 if (ret < 0)
6613 goto err;
6614
6615 reg = 0x10c0 ;
6616 ret = usb_microdia_control_read(dev, reg, buf, 1);
6617 if (ret < 0)
6618 goto err;
6619
6620 reg = 0x10c0 ;
6621 ret = usb_microdia_control_read(dev, reg, buf, 1);
6622 if (ret < 0)
6623 goto err;
6624
6625 reg = 0x10c0 ;
6626 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6627 ret = usb_microdia_control_write(dev, reg, buf, 8);
6628 if (ret < 0)
6629 goto err;
6630
6631 reg = 0x10c0 ;
6632 ret = usb_microdia_control_read(dev, reg, buf, 1);
6633 if (ret < 0)
6634 goto err;
6635
6636 reg = 0x10c0 ;
6637 ret = usb_microdia_control_read(dev, reg, buf, 1);
6638 if (ret < 0)
6639 goto err;
6640
6641 reg = 0x10c0 ;
6642 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6643 ret = usb_microdia_control_write(dev, reg, buf, 8);
6644 if (ret < 0)
6645 goto err;
6646
6647 reg = 0x10c0 ;
6648 ret = usb_microdia_control_read(dev, reg, buf, 1);
6649 if (ret < 0)
6650 goto err;
6651
6652 reg = 0x10c0 ;
6653 ret = usb_microdia_control_read(dev, reg, buf, 1);
6654 if (ret < 0)
6655 goto err;
6656
6657 reg = 0x10c0 ;
6658 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x27; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6659 ret = usb_microdia_control_write(dev, reg, buf, 8);
6660 if (ret < 0)
6661 goto err;
6662
6663 reg = 0x10c0 ;
6664 ret = usb_microdia_control_read(dev, reg, buf, 1);
6665 if (ret < 0)
6666 goto err;
6667
6668 reg = 0x10c0 ;
6669 ret = usb_microdia_control_read(dev, reg, buf, 1);
6670 if (ret < 0)
6671 goto err;
6672
6673 reg = 0x10c0 ;
6674 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x28; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6675 ret = usb_microdia_control_write(dev, reg, buf, 8);
6676 if (ret < 0)
6677 goto err;
6678
6679 reg = 0x10c0 ;
6680 ret = usb_microdia_control_read(dev, reg, buf, 1);
6681 if (ret < 0)
6682 goto err;
6683
6684 reg = 0x10c0 ;
6685 ret = usb_microdia_control_read(dev, reg, buf, 1);
6686 if (ret < 0)
6687 goto err;
6688
6689 reg = 0x10c0 ;
6690 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x29; buf[3] = 0x15; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6691 ret = usb_microdia_control_write(dev, reg, buf, 8);
6692 if (ret < 0)
6693 goto err;
6694
6695 reg = 0x10c0 ;
6696 ret = usb_microdia_control_read(dev, reg, buf, 1);
6697 if (ret < 0)
6698 goto err;
6699
6700 reg = 0x10c0 ;
6701 ret = usb_microdia_control_read(dev, reg, buf, 1);
6702 if (ret < 0)
6703 goto err;
6704
6705 reg = 0x10c0 ;
6706 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2c; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6707 ret = usb_microdia_control_write(dev, reg, buf, 8);
6708 if (ret < 0)
6709 goto err;
6710
6711 reg = 0x10c0 ;
6712 ret = usb_microdia_control_read(dev, reg, buf, 1);
6713 if (ret < 0)
6714 goto err;
6715
6716 reg = 0x10c0 ;
6717 ret = usb_microdia_control_read(dev, reg, buf, 1);
6718 if (ret < 0)
6719 goto err;
6720
6721 reg = 0x10c0 ;
6722 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6723 ret = usb_microdia_control_write(dev, reg, buf, 8);
6724 if (ret < 0)
6725 goto err;
6726
6727 reg = 0x10c0 ;
6728 ret = usb_microdia_control_read(dev, reg, buf, 1);
6729 if (ret < 0)
6730 goto err;
6731
6732 reg = 0x10c0 ;
6733 ret = usb_microdia_control_read(dev, reg, buf, 1);
6734 if (ret < 0)
6735 goto err;
6736
6737 reg = 0x10c0 ;
6738 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x34; buf[3] = 0x3d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6739 ret = usb_microdia_control_write(dev, reg, buf, 8);
6740 if (ret < 0)
6741 goto err;
6742
6743 reg = 0x10c0 ;
6744 ret = usb_microdia_control_read(dev, reg, buf, 1);
6745 if (ret < 0)
6746 goto err;
6747
6748 reg = 0x10c0 ;
6749 ret = usb_microdia_control_read(dev, reg, buf, 1);
6750 if (ret < 0)
6751 goto err;
6752
6753 reg = 0x10c0 ;
6754 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x35; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6755 ret = usb_microdia_control_write(dev, reg, buf, 8);
6756 if (ret < 0)
6757 goto err;
6758
6759 reg = 0x10c0 ;
6760 ret = usb_microdia_control_read(dev, reg, buf, 1);
6761 if (ret < 0)
6762 goto err;
6763
6764 reg = 0x10c0 ;
6765 ret = usb_microdia_control_read(dev, reg, buf, 1);
6766 if (ret < 0)
6767 goto err;
6768
6769 reg = 0x10c0 ;
6770 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x36; buf[3] = 0xf8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6771 ret = usb_microdia_control_write(dev, reg, buf, 8);
6772 if (ret < 0)
6773 goto err;
6774
6775 reg = 0x10c0 ;
6776 ret = usb_microdia_control_read(dev, reg, buf, 1);
6777 if (ret < 0)
6778 goto err;
6779
6780 reg = 0x10c0 ;
6781 ret = usb_microdia_control_read(dev, reg, buf, 1);
6782 if (ret < 0)
6783 goto err;
6784
6785 reg = 0x10c0 ;
6786 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x38; buf[3] = 0x12; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6787 ret = usb_microdia_control_write(dev, reg, buf, 8);
6788 if (ret < 0)
6789 goto err;
6790
6791 reg = 0x10c0 ;
6792 ret = usb_microdia_control_read(dev, reg, buf, 1);
6793 if (ret < 0)
6794 goto err;
6795
6796 reg = 0x10c0 ;
6797 ret = usb_microdia_control_read(dev, reg, buf, 1);
6798 if (ret < 0)
6799 goto err;
6800
6801 reg = 0x10c0 ;
6802 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x39; buf[3] = 0x57; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6803 ret = usb_microdia_control_write(dev, reg, buf, 8);
6804 if (ret < 0)
6805 goto err;
6806
6807 reg = 0x10c0 ;
6808 ret = usb_microdia_control_read(dev, reg, buf, 1);
6809 if (ret < 0)
6810 goto err;
6811
6812 reg = 0x10c0 ;
6813 ret = usb_microdia_control_read(dev, reg, buf, 1);
6814 if (ret < 0)
6815 goto err;
6816
6817 reg = 0x10c0 ;
6818 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6819 ret = usb_microdia_control_write(dev, reg, buf, 8);
6820 if (ret < 0)
6821 goto err;
6822
6823 reg = 0x10c0 ;
6824 ret = usb_microdia_control_read(dev, reg, buf, 1);
6825 if (ret < 0)
6826 goto err;
6827
6828 reg = 0x10c0 ;
6829 ret = usb_microdia_control_read(dev, reg, buf, 1);
6830 if (ret < 0)
6831 goto err;
6832
6833 reg = 0x10c0 ;
6834 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3b; buf[3] = 0xcc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6835 ret = usb_microdia_control_write(dev, reg, buf, 8);
6836 if (ret < 0)
6837 goto err;
6838
6839 reg = 0x10c0 ;
6840 ret = usb_microdia_control_read(dev, reg, buf, 1);
6841 if (ret < 0)
6842 goto err;
6843
6844 reg = 0x10c0 ;
6845 ret = usb_microdia_control_read(dev, reg, buf, 1);
6846 if (ret < 0)
6847 goto err;
6848
6849 reg = 0x10c0 ;
6850 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3c; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6851 ret = usb_microdia_control_write(dev, reg, buf, 8);
6852 if (ret < 0)
6853 goto err;
6854
6855 reg = 0x10c0 ;
6856 ret = usb_microdia_control_read(dev, reg, buf, 1);
6857 if (ret < 0)
6858 goto err;
6859
6860 reg = 0x10c0 ;
6861 ret = usb_microdia_control_read(dev, reg, buf, 1);
6862 if (ret < 0)
6863 goto err;
6864
6865 reg = 0x10c0 ;
6866 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3d; buf[3] = 0x19; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6867 ret = usb_microdia_control_write(dev, reg, buf, 8);
6868 if (ret < 0)
6869 goto err;
6870
6871 reg = 0x10c0 ;
6872 ret = usb_microdia_control_read(dev, reg, buf, 1);
6873 if (ret < 0)
6874 goto err;
6875
6876 reg = 0x10c0 ;
6877 ret = usb_microdia_control_read(dev, reg, buf, 1);
6878 if (ret < 0)
6879 goto err;
6880
6881 reg = 0x10c0 ;
6882 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3e; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6883 ret = usb_microdia_control_write(dev, reg, buf, 8);
6884 if (ret < 0)
6885 goto err;
6886
6887 reg = 0x10c0 ;
6888 ret = usb_microdia_control_read(dev, reg, buf, 1);
6889 if (ret < 0)
6890 goto err;
6891
6892 reg = 0x10c0 ;
6893 ret = usb_microdia_control_read(dev, reg, buf, 1);
6894 if (ret < 0)
6895 goto err;
6896
6897 reg = 0x10c0 ;
6898 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3f; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6899 ret = usb_microdia_control_write(dev, reg, buf, 8);
6900 if (ret < 0)
6901 goto err;
6902
6903 reg = 0x10c0 ;
6904 ret = usb_microdia_control_read(dev, reg, buf, 1);
6905 if (ret < 0)
6906 goto err;
6907
6908 reg = 0x10c0 ;
6909 ret = usb_microdia_control_read(dev, reg, buf, 1);
6910 if (ret < 0)
6911 goto err;
6912
6913 reg = 0x10c0 ;
6914 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x41; buf[3] = 0x40; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6915 ret = usb_microdia_control_write(dev, reg, buf, 8);
6916 if (ret < 0)
6917 goto err;
6918
6919 reg = 0x10c0 ;
6920 ret = usb_microdia_control_read(dev, reg, buf, 1);
6921 if (ret < 0)
6922 goto err;
6923
6924 reg = 0x10c0 ;
6925 ret = usb_microdia_control_read(dev, reg, buf, 1);
6926 if (ret < 0)
6927 goto err;
6928
6929 reg = 0x10c0 ;
6930 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x42; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6931 ret = usb_microdia_control_write(dev, reg, buf, 8);
6932 if (ret < 0)
6933 goto err;
6934
6935 reg = 0x10c0 ;
6936 ret = usb_microdia_control_read(dev, reg, buf, 1);
6937 if (ret < 0)
6938 goto err;
6939
6940 reg = 0x10c0 ;
6941 ret = usb_microdia_control_read(dev, reg, buf, 1);
6942 if (ret < 0)
6943 goto err;
6944
6945 reg = 0x10c0 ;
6946 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x45; buf[3] = 0x46; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6947 ret = usb_microdia_control_write(dev, reg, buf, 8);
6948 if (ret < 0)
6949 goto err;
6950
6951 reg = 0x10c0 ;
6952 ret = usb_microdia_control_read(dev, reg, buf, 1);
6953 if (ret < 0)
6954 goto err;
6955
6956 reg = 0x10c0 ;
6957 ret = usb_microdia_control_read(dev, reg, buf, 1);
6958 if (ret < 0)
6959 goto err;
6960
6961 reg = 0x10c0 ;
6962 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x46; buf[3] = 0x62; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6963 ret = usb_microdia_control_write(dev, reg, buf, 8);
6964 if (ret < 0)
6965 goto err;
6966
6967 reg = 0x10c0 ;
6968 ret = usb_microdia_control_read(dev, reg, buf, 1);
6969 if (ret < 0)
6970 goto err;
6971
6972 reg = 0x10c0 ;
6973 ret = usb_microdia_control_read(dev, reg, buf, 1);
6974 if (ret < 0)
6975 goto err;
6976
6977 reg = 0x10c0 ;
6978 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x47; buf[3] = 0x2a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6979 ret = usb_microdia_control_write(dev, reg, buf, 8);
6980 if (ret < 0)
6981 goto err;
6982
6983 reg = 0x10c0 ;
6984 ret = usb_microdia_control_read(dev, reg, buf, 1);
6985 if (ret < 0)
6986 goto err;
6987
6988 reg = 0x10c0 ;
6989 ret = usb_microdia_control_read(dev, reg, buf, 1);
6990 if (ret < 0)
6991 goto err;
6992
6993 reg = 0x10c0 ;
6994 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x48; buf[3] = 0x3c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6995 ret = usb_microdia_control_write(dev, reg, buf, 8);
6996 if (ret < 0)
6997 goto err;
6998
6999 reg = 0x10c0 ;
7000 ret = usb_microdia_control_read(dev, reg, buf, 1);
7001 if (ret < 0)
7002 goto err;
7003
7004 reg = 0x10c0 ;
7005 ret = usb_microdia_control_read(dev, reg, buf, 1);
7006 if (ret < 0)
7007 goto err;
7008
7009 reg = 0x10c0 ;
7010 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4a; buf[3] = 0xf0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7011 ret = usb_microdia_control_write(dev, reg, buf, 8);
7012 if (ret < 0)
7013 goto err;
7014
7015 reg = 0x10c0 ;
7016 ret = usb_microdia_control_read(dev, reg, buf, 1);
7017 if (ret < 0)
7018 goto err;
7019
7020 reg = 0x10c0 ;
7021 ret = usb_microdia_control_read(dev, reg, buf, 1);
7022 if (ret < 0)
7023 goto err;
7024
7025 reg = 0x10c0 ;
7026 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4b; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7027 ret = usb_microdia_control_write(dev, reg, buf, 8);
7028 if (ret < 0)
7029 goto err;
7030
7031 reg = 0x10c0 ;
7032 ret = usb_microdia_control_read(dev, reg, buf, 1);
7033 if (ret < 0)
7034 goto err;
7035
7036 reg = 0x10c0 ;
7037 ret = usb_microdia_control_read(dev, reg, buf, 1);
7038 if (ret < 0)
7039 goto err;
7040
7041 reg = 0x10c0 ;
7042 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4c; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7043 ret = usb_microdia_control_write(dev, reg, buf, 8);
7044 if (ret < 0)
7045 goto err;
7046
7047 reg = 0x10c0 ;
7048 ret = usb_microdia_control_read(dev, reg, buf, 1);
7049 if (ret < 0)
7050 goto err;
7051
7052 reg = 0x10c0 ;
7053 ret = usb_microdia_control_read(dev, reg, buf, 1);
7054 if (ret < 0)
7055 goto err;
7056
7057 reg = 0x10c0 ;
7058 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4d; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7059 ret = usb_microdia_control_write(dev, reg, buf, 8);
7060 if (ret < 0)
7061 goto err;
7062
7063 reg = 0x10c0 ;
7064 ret = usb_microdia_control_read(dev, reg, buf, 1);
7065 if (ret < 0)
7066 goto err;
7067
7068 reg = 0x10c0 ;
7069 ret = usb_microdia_control_read(dev, reg, buf, 1);
7070 if (ret < 0)
7071 goto err;
7072
7073 reg = 0x10c0 ;
7074 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4e; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7075 ret = usb_microdia_control_write(dev, reg, buf, 8);
7076 if (ret < 0)
7077 goto err;
7078
7079 reg = 0x10c0 ;
7080 ret = usb_microdia_control_read(dev, reg, buf, 1);
7081 if (ret < 0)
7082 goto err;
7083
7084 reg = 0x10c0 ;
7085 ret = usb_microdia_control_read(dev, reg, buf, 1);
7086 if (ret < 0)
7087 goto err;
7088
7089 reg = 0x10c0 ;
7090 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x69; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7091 ret = usb_microdia_control_write(dev, reg, buf, 8);
7092 if (ret < 0)
7093 goto err;
7094
7095 reg = 0x10c0 ;
7096 ret = usb_microdia_control_read(dev, reg, buf, 1);
7097 if (ret < 0)
7098 goto err;
7099
7100 reg = 0x10c0 ;
7101 ret = usb_microdia_control_read(dev, reg, buf, 1);
7102 if (ret < 0)
7103 goto err;
7104
7105 reg = 0x10c0 ;
7106 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6c; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7107 ret = usb_microdia_control_write(dev, reg, buf, 8);
7108 if (ret < 0)
7109 goto err;
7110
7111 reg = 0x10c0 ;
7112 ret = usb_microdia_control_read(dev, reg, buf, 1);
7113 if (ret < 0)
7114 goto err;
7115
7116 reg = 0x10c0 ;
7117 ret = usb_microdia_control_read(dev, reg, buf, 1);
7118 if (ret < 0)
7119 goto err;
7120
7121 reg = 0x10c0 ;
7122 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6f; buf[3] = 0x9e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7123 ret = usb_microdia_control_write(dev, reg, buf, 8);
7124 if (ret < 0)
7125 goto err;
7126
7127 reg = 0x10c0 ;
7128 ret = usb_microdia_control_read(dev, reg, buf, 1);
7129 if (ret < 0)
7130 goto err;
7131
7132 reg = 0x10c0 ;
7133 ret = usb_microdia_control_read(dev, reg, buf, 1);
7134 if (ret < 0)
7135 goto err;
7136
7137 reg = 0x10c0 ;
7138 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x70; buf[3] = 0x05; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7139 ret = usb_microdia_control_write(dev, reg, buf, 8);
7140 if (ret < 0)
7141 goto err;
7142
7143 reg = 0x10c0 ;
7144 ret = usb_microdia_control_read(dev, reg, buf, 1);
7145 if (ret < 0)
7146 goto err;
7147
7148 reg = 0x10c0 ;
7149 ret = usb_microdia_control_read(dev, reg, buf, 1);
7150 if (ret < 0)
7151 goto err;
7152
7153 reg = 0x10c0 ;
7154 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x71; buf[3] = 0x78; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7155 ret = usb_microdia_control_write(dev, reg, buf, 8);
7156 if (ret < 0)
7157 goto err;
7158
7159 reg = 0x10c0 ;
7160 ret = usb_microdia_control_read(dev, reg, buf, 1);
7161 if (ret < 0)
7162 goto err;
7163
7164 reg = 0x10c0 ;
7165 ret = usb_microdia_control_read(dev, reg, buf, 1);
7166 if (ret < 0)
7167 goto err;
7168
7169 reg = 0x10c0 ;
7170 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x77; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7171 ret = usb_microdia_control_write(dev, reg, buf, 8);
7172 if (ret < 0)
7173 goto err;
7174
7175 reg = 0x10c0 ;
7176 ret = usb_microdia_control_read(dev, reg, buf, 1);
7177 if (ret < 0)
7178 goto err;
7179
7180 reg = 0x10c0 ;
7181 ret = usb_microdia_control_read(dev, reg, buf, 1);
7182 if (ret < 0)
7183 goto err;
7184
7185 reg = 0x10c0 ;
7186 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8a; buf[3] = 0x23; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7187 ret = usb_microdia_control_write(dev, reg, buf, 8);
7188 if (ret < 0)
7189 goto err;
7190
7191 reg = 0x10c0 ;
7192 ret = usb_microdia_control_read(dev, reg, buf, 1);
7193 if (ret < 0)
7194 goto err;
7195
7196 reg = 0x10c0 ;
7197 ret = usb_microdia_control_read(dev, reg, buf, 1);
7198 if (ret < 0)
7199 goto err;
7200
7201 reg = 0x10c0 ;
7202 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8c; buf[3] = 0x0d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7203 ret = usb_microdia_control_write(dev, reg, buf, 8);
7204 if (ret < 0)
7205 goto err;
7206
7207 reg = 0x10c0 ;
7208 ret = usb_microdia_control_read(dev, reg, buf, 1);
7209 if (ret < 0)
7210 goto err;
7211
7212 reg = 0x10c0 ;
7213 ret = usb_microdia_control_read(dev, reg, buf, 1);
7214 if (ret < 0)
7215 goto err;
7216
7217 reg = 0x10c0 ;
7218 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x90; buf[3] = 0x7e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7219 ret = usb_microdia_control_write(dev, reg, buf, 8);
7220 if (ret < 0)
7221 goto err;
7222
7223 reg = 0x10c0 ;
7224 ret = usb_microdia_control_read(dev, reg, buf, 1);
7225 if (ret < 0)
7226 goto err;
7227
7228 reg = 0x10c0 ;
7229 ret = usb_microdia_control_read(dev, reg, buf, 1);
7230 if (ret < 0)
7231 goto err;
7232
7233 reg = 0x10c0 ;
7234 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x91; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7235 ret = usb_microdia_control_write(dev, reg, buf, 8);
7236 if (ret < 0)
7237 goto err;
7238
7239 reg = 0x10c0 ;
7240 ret = usb_microdia_control_read(dev, reg, buf, 1);
7241 if (ret < 0)
7242 goto err;
7243
7244 reg = 0x10c0 ;
7245 ret = usb_microdia_control_read(dev, reg, buf, 1);
7246 if (ret < 0)
7247 goto err;
7248
7249 reg = 0x10c0 ;
7250 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x9f; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7251 ret = usb_microdia_control_write(dev, reg, buf, 8);
7252 if (ret < 0)
7253 goto err;
7254
7255 reg = 0x10c0 ;
7256 ret = usb_microdia_control_read(dev, reg, buf, 1);
7257 if (ret < 0)
7258 goto err;
7259
7260 reg = 0x10c0 ;
7261 ret = usb_microdia_control_read(dev, reg, buf, 1);
7262 if (ret < 0)
7263 goto err;
7264
7265 reg = 0x10c0 ;
7266 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa0; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7267 ret = usb_microdia_control_write(dev, reg, buf, 8);
7268 if (ret < 0)
7269 goto err;
7270
7271 reg = 0x10c0 ;
7272 ret = usb_microdia_control_read(dev, reg, buf, 1);
7273 if (ret < 0)
7274 goto err;
7275
7276 reg = 0x10c0 ;
7277 ret = usb_microdia_control_read(dev, reg, buf, 1);
7278 if (ret < 0)
7279 goto err;
7280
7281 reg = 0x10c0 ;
7282 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa4; buf[3] = 0x50; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7283 ret = usb_microdia_control_write(dev, reg, buf, 8);
7284 if (ret < 0)
7285 goto err;
7286
7287 reg = 0x10c0 ;
7288 ret = usb_microdia_control_read(dev, reg, buf, 1);
7289 if (ret < 0)
7290 goto err;
7291
7292 reg = 0x10c0 ;
7293 ret = usb_microdia_control_read(dev, reg, buf, 1);
7294 if (ret < 0)
7295 goto err;
7296
7297 reg = 0x10c0 ;
7298 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa5; buf[3] = 0x68; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7299 ret = usb_microdia_control_write(dev, reg, buf, 8);
7300 if (ret < 0)
7301 goto err;
7302
7303 reg = 0x10c0 ;
7304 ret = usb_microdia_control_read(dev, reg, buf, 1);
7305 if (ret < 0)
7306 goto err;
7307
7308 reg = 0x10c0 ;
7309 ret = usb_microdia_control_read(dev, reg, buf, 1);
7310 if (ret < 0)
7311 goto err;
7312
7313 reg = 0x10c0 ;
7314 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa6; buf[3] = 0x60; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7315 ret = usb_microdia_control_write(dev, reg, buf, 8);
7316 if (ret < 0)
7317 goto err;
7318
7319 reg = 0x10c0 ;
7320 ret = usb_microdia_control_read(dev, reg, buf, 1);
7321 if (ret < 0)
7322 goto err;
7323
7324 reg = 0x10c0 ;
7325 ret = usb_microdia_control_read(dev, reg, buf, 1);
7326 if (ret < 0)
7327 goto err;
7328
7329 reg = 0x10c0 ;
7330 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa8; buf[3] = 0xc1; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7331 ret = usb_microdia_control_write(dev, reg, buf, 8);
7332 if (ret < 0)
7333 goto err;
7334
7335 reg = 0x10c0 ;
7336 ret = usb_microdia_control_read(dev, reg, buf, 1);
7337 if (ret < 0)
7338 goto err;
7339
7340 reg = 0x10c0 ;
7341 ret = usb_microdia_control_read(dev, reg, buf, 1);
7342 if (ret < 0)
7343 goto err;
7344
7345 reg = 0x10c0 ;
7346 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa9; buf[3] = 0xfa; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7347 ret = usb_microdia_control_write(dev, reg, buf, 8);
7348 if (ret < 0)
7349 goto err;
7350
7351 reg = 0x10c0 ;
7352 ret = usb_microdia_control_read(dev, reg, buf, 1);
7353 if (ret < 0)
7354 goto err;
7355
7356 reg = 0x10c0 ;
7357 ret = usb_microdia_control_read(dev, reg, buf, 1);
7358 if (ret < 0)
7359 goto err;
7360
7361 reg = 0x10c0 ;
7362 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaa; buf[3] = 0x92; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7363 ret = usb_microdia_control_write(dev, reg, buf, 8);
7364 if (ret < 0)
7365 goto err;
7366
7367 reg = 0x10c0 ;
7368 ret = usb_microdia_control_read(dev, reg, buf, 1);
7369 if (ret < 0)
7370 goto err;
7371
7372 reg = 0x10c0 ;
7373 ret = usb_microdia_control_read(dev, reg, buf, 1);
7374 if (ret < 0)
7375 goto err;
7376
7377 reg = 0x10c0 ;
7378 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xab; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7379 ret = usb_microdia_control_write(dev, reg, buf, 8);
7380 if (ret < 0)
7381 goto err;
7382
7383 reg = 0x10c0 ;
7384 ret = usb_microdia_control_read(dev, reg, buf, 1);
7385 if (ret < 0)
7386 goto err;
7387
7388 reg = 0x10c0 ;
7389 ret = usb_microdia_control_read(dev, reg, buf, 1);
7390 if (ret < 0)
7391 goto err;
7392
7393 reg = 0x10c0 ;
7394 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xac; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7395 ret = usb_microdia_control_write(dev, reg, buf, 8);
7396 if (ret < 0)
7397 goto err;
7398
7399 reg = 0x10c0 ;
7400 ret = usb_microdia_control_read(dev, reg, buf, 1);
7401 if (ret < 0)
7402 goto err;
7403
7404 reg = 0x10c0 ;
7405 ret = usb_microdia_control_read(dev, reg, buf, 1);
7406 if (ret < 0)
7407 goto err;
7408
7409 reg = 0x10c0 ;
7410 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xad; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7411 ret = usb_microdia_control_write(dev, reg, buf, 8);
7412 if (ret < 0)
7413 goto err;
7414
7415 reg = 0x10c0 ;
7416 ret = usb_microdia_control_read(dev, reg, buf, 1);
7417 if (ret < 0)
7418 goto err;
7419
7420 reg = 0x10c0 ;
7421 ret = usb_microdia_control_read(dev, reg, buf, 1);
7422 if (ret < 0)
7423 goto err;
7424
7425 reg = 0x10c0 ;
7426 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xae; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7427 ret = usb_microdia_control_write(dev, reg, buf, 8);
7428 if (ret < 0)
7429 goto err;
7430
7431 reg = 0x10c0 ;
7432 ret = usb_microdia_control_read(dev, reg, buf, 1);
7433 if (ret < 0)
7434 goto err;
7435
7436 reg = 0x10c0 ;
7437 ret = usb_microdia_control_read(dev, reg, buf, 1);
7438 if (ret < 0)
7439 goto err;
7440
7441 reg = 0x10c0 ;
7442 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaf; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7443 ret = usb_microdia_control_write(dev, reg, buf, 8);
7444 if (ret < 0)
7445 goto err;
7446
7447 reg = 0x10c0 ;
7448 ret = usb_microdia_control_read(dev, reg, buf, 1);
7449 if (ret < 0)
7450 goto err;
7451
7452 reg = 0x10c0 ;
7453 ret = usb_microdia_control_read(dev, reg, buf, 1);
7454 if (ret < 0)
7455 goto err;
7456
7457 reg = 0x10c0 ;
7458 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb2; buf[3] = 0xf2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7459 ret = usb_microdia_control_write(dev, reg, buf, 8);
7460 if (ret < 0)
7461 goto err;
7462
7463 reg = 0x10c0 ;
7464 ret = usb_microdia_control_read(dev, reg, buf, 1);
7465 if (ret < 0)
7466 goto err;
7467
7468 reg = 0x10c0 ;
7469 ret = usb_microdia_control_read(dev, reg, buf, 1);
7470 if (ret < 0)
7471 goto err;
7472
7473 reg = 0x10c0 ;
7474 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb3; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7475 ret = usb_microdia_control_write(dev, reg, buf, 8);
7476 if (ret < 0)
7477 goto err;
7478
7479 reg = 0x10c0 ;
7480 ret = usb_microdia_control_read(dev, reg, buf, 1);
7481 if (ret < 0)
7482 goto err;
7483
7484 reg = 0x10c0 ;
7485 ret = usb_microdia_control_read(dev, reg, buf, 1);
7486 if (ret < 0)
7487 goto err;
7488
7489 reg = 0x10c0 ;
7490 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb4; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7491 ret = usb_microdia_control_write(dev, reg, buf, 8);
7492 if (ret < 0)
7493 goto err;
7494
7495 reg = 0x10c0 ;
7496 ret = usb_microdia_control_read(dev, reg, buf, 1);
7497 if (ret < 0)
7498 goto err;
7499
7500 reg = 0x10c0 ;
7501 ret = usb_microdia_control_read(dev, reg, buf, 1);
7502 if (ret < 0)
7503 goto err;
7504
7505 reg = 0x10c0 ;
7506 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb5; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7507 ret = usb_microdia_control_write(dev, reg, buf, 8);
7508 if (ret < 0)
7509 goto err;
7510
7511 reg = 0x10c0 ;
7512 ret = usb_microdia_control_read(dev, reg, buf, 1);
7513 if (ret < 0)
7514 goto err;
7515
7516 reg = 0x10c0 ;
7517 ret = usb_microdia_control_read(dev, reg, buf, 1);
7518 if (ret < 0)
7519 goto err;
7520
7521 reg = 0x10c0 ;
7522 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb6; buf[3] = 0xaf; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7523 ret = usb_microdia_control_write(dev, reg, buf, 8);
7524 if (ret < 0)
7525 goto err;
7526
7527 reg = 0x10c0 ;
7528 ret = usb_microdia_control_read(dev, reg, buf, 1);
7529 if (ret < 0)
7530 goto err;
7531
7532 reg = 0x10c0 ;
7533 ret = usb_microdia_control_read(dev, reg, buf, 1);
7534 if (ret < 0)
7535 goto err;
7536
7537 reg = 0x10c0 ;
7538 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbb; buf[3] = 0xae; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7539 ret = usb_microdia_control_write(dev, reg, buf, 8);
7540 if (ret < 0)
7541 goto err;
7542
7543 reg = 0x10c0 ;
7544 ret = usb_microdia_control_read(dev, reg, buf, 1);
7545 if (ret < 0)
7546 goto err;
7547
7548 reg = 0x10c0 ;
7549 ret = usb_microdia_control_read(dev, reg, buf, 1);
7550 if (ret < 0)
7551 goto err;
7552
7553 reg = 0x10c0 ;
7554 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbc; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7555 ret = usb_microdia_control_write(dev, reg, buf, 8);
7556 if (ret < 0)
7557 goto err;
7558
7559 reg = 0x10c0 ;
7560 ret = usb_microdia_control_read(dev, reg, buf, 1);
7561 if (ret < 0)
7562 goto err;
7563
7564 reg = 0x10c0 ;
7565 ret = usb_microdia_control_read(dev, reg, buf, 1);
7566 if (ret < 0)
7567 goto err;
7568
7569 reg = 0x10c0 ;
7570 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbd; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7571 ret = usb_microdia_control_write(dev, reg, buf, 8);
7572 if (ret < 0)
7573 goto err;
7574
7575 reg = 0x10c0 ;
7576 ret = usb_microdia_control_read(dev, reg, buf, 1);
7577 if (ret < 0)
7578 goto err;
7579
7580 reg = 0x10c0 ;
7581 ret = usb_microdia_control_read(dev, reg, buf, 1);
7582 if (ret < 0)
7583 goto err;
7584
7585 reg = 0x10c0 ;
7586 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbe; buf[3] = 0x3b; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7587 ret = usb_microdia_control_write(dev, reg, buf, 8);
7588 if (ret < 0)
7589 goto err;
7590
7591 reg = 0x10c0 ;
7592 ret = usb_microdia_control_read(dev, reg, buf, 1);
7593 if (ret < 0)
7594 goto err;
7595
7596 reg = 0x10c0 ;
7597 ret = usb_microdia_control_read(dev, reg, buf, 1);
7598 if (ret < 0)
7599 goto err;
7600
7601 reg = 0x10c0 ;
7602 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbf; buf[3] = 0x3a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7603 ret = usb_microdia_control_write(dev, reg, buf, 8);
7604 if (ret < 0)
7605 goto err;
7606
7607 reg = 0x10c0 ;
7608 ret = usb_microdia_control_read(dev, reg, buf, 1);
7609 if (ret < 0)
7610 goto err;
7611
7612 reg = 0x10c0 ;
7613 ret = usb_microdia_control_read(dev, reg, buf, 1);
7614 if (ret < 0)
7615 goto err;
7616
7617 reg = 0x10c0 ;
7618 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc0; buf[3] = 0xe2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7619 ret = usb_microdia_control_write(dev, reg, buf, 8);
7620 if (ret < 0)
7621 goto err;
7622
7623 reg = 0x10c0 ;
7624 ret = usb_microdia_control_read(dev, reg, buf, 1);
7625 if (ret < 0)
7626 goto err;
7627
7628 reg = 0x10c0 ;
7629 ret = usb_microdia_control_read(dev, reg, buf, 1);
7630 if (ret < 0)
7631 goto err;
7632
7633 reg = 0x10c0 ;
7634 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc1; buf[3] = 0xc8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7635 ret = usb_microdia_control_write(dev, reg, buf, 8);
7636 if (ret < 0)
7637 goto err;
7638
7639 reg = 0x10c0 ;
7640 ret = usb_microdia_control_read(dev, reg, buf, 1);
7641 if (ret < 0)
7642 goto err;
7643
7644 reg = 0x10c0 ;
7645 ret = usb_microdia_control_read(dev, reg, buf, 1);
7646 if (ret < 0)
7647 goto err;
7648
7649 reg = 0x10c0 ;
7650 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc2; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7651 ret = usb_microdia_control_write(dev, reg, buf, 8);
7652 if (ret < 0)
7653 goto err;
7654
7655 reg = 0x10c0 ;
7656 ret = usb_microdia_control_read(dev, reg, buf, 1);
7657 if (ret < 0)
7658 goto err;
7659
7660 reg = 0x10c0 ;
7661 ret = usb_microdia_control_read(dev, reg, buf, 1);
7662 if (ret < 0)
7663 goto err;
7664
7665 reg = 0x10c0 ;
7666 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc4; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7667 ret = usb_microdia_control_write(dev, reg, buf, 8);
7668 if (ret < 0)
7669 goto err;
7670
7671 reg = 0x10c0 ;
7672 ret = usb_microdia_control_read(dev, reg, buf, 1);
7673 if (ret < 0)
7674 goto err;
7675
7676 reg = 0x10c0 ;
7677 ret = usb_microdia_control_read(dev, reg, buf, 1);
7678 if (ret < 0)
7679 goto err;
7680
7681 reg = 0x10c0 ;
7682 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc6; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7683 ret = usb_microdia_control_write(dev, reg, buf, 8);
7684 if (ret < 0)
7685 goto err;
7686
7687 reg = 0x10c0 ;
7688 ret = usb_microdia_control_read(dev, reg, buf, 1);
7689 if (ret < 0)
7690 goto err;
7691
7692 reg = 0x10c0 ;
7693 ret = usb_microdia_control_read(dev, reg, buf, 1);
7694 if (ret < 0)
7695 goto err;
7696
7697 reg = 0x10c0 ;
7698 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc7; buf[3] = 0x81; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7699 ret = usb_microdia_control_write(dev, reg, buf, 8);
7700 if (ret < 0)
7701 goto err;
7702
7703 reg = 0x10c0 ;
7704 ret = usb_microdia_control_read(dev, reg, buf, 1);
7705 if (ret < 0)
7706 goto err;
7707
7708 reg = 0x10c0 ;
7709 ret = usb_microdia_control_read(dev, reg, buf, 1);
7710 if (ret < 0)
7711 goto err;
7712
7713 reg = 0x10c0 ;
7714 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc9; buf[3] = 0xe0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7715 ret = usb_microdia_control_write(dev, reg, buf, 8);
7716 if (ret < 0)
7717 goto err;
7718
7719 reg = 0x10c0 ;
7720 ret = usb_microdia_control_read(dev, reg, buf, 1);
7721 if (ret < 0)
7722 goto err;
7723
7724 reg = 0x10c0 ;
7725 ret = usb_microdia_control_read(dev, reg, buf, 1);
7726 if (ret < 0)
7727 goto err;
7728
7729 reg = 0x10c0 ;
7730 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xca; buf[3] = 0xe8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7731 ret = usb_microdia_control_write(dev, reg, buf, 8);
7732 if (ret < 0)
7733 goto err;
7734
7735 reg = 0x10c0 ;
7736 ret = usb_microdia_control_read(dev, reg, buf, 1);
7737 if (ret < 0)
7738 goto err;
7739
7740 reg = 0x10c0 ;
7741 ret = usb_microdia_control_read(dev, reg, buf, 1);
7742 if (ret < 0)
7743 goto err;
7744
7745 reg = 0x10c0 ;
7746 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcc; buf[3] = 0xd8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7747 ret = usb_microdia_control_write(dev, reg, buf, 8);
7748 if (ret < 0)
7749 goto err;
7750
7751 reg = 0x10c0 ;
7752 ret = usb_microdia_control_read(dev, reg, buf, 1);
7753 if (ret < 0)
7754 goto err;
7755
7756 reg = 0x10c0 ;
7757 ret = usb_microdia_control_read(dev, reg, buf, 1);
7758 if (ret < 0)
7759 goto err;
7760
7761 reg = 0x10c0 ;
7762 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcd; buf[3] = 0x93; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7763 ret = usb_microdia_control_write(dev, reg, buf, 8);
7764 if (ret < 0)
7765 goto err;
7766
7767 reg = 0x10c0 ;
7768 ret = usb_microdia_control_read(dev, reg, buf, 1);
7769 if (ret < 0)
7770 goto err;
7771
7772 reg = 0x10c0 ;
7773 ret = usb_microdia_control_read(dev, reg, buf, 1);
7774 if (ret < 0)
7775 goto err;
7776
7777 reg = 0x10c1 ;
7778 ret = usb_microdia_control_read(dev, reg, buf, 1);
7779 if (ret < 0)
7780 goto err;
7781
7782 reg = 0x10c1 ;
7783 buf[0] = 0x50;
7784 ret = usb_microdia_control_write(dev, reg, buf, 1);
7785 if (ret < 0)
7786 goto err;
7787
7788 reg = 0x10c0 ;
7789 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7790 ret = usb_microdia_control_write(dev, reg, buf, 8);
7791 if (ret < 0)
7792 goto err;
7793
7794 reg = 0x10c0 ;
7795 ret = usb_microdia_control_read(dev, reg, buf, 1);
7796 if (ret < 0)
7797 goto err;
7798
7799 reg = 0x10c0 ;
7800 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7801 ret = usb_microdia_control_write(dev, reg, buf, 8);
7802 if (ret < 0)
7803 goto err;
7804
7805 reg = 0x10c0 ;
7806 ret = usb_microdia_control_read(dev, reg, buf, 1);
7807 if (ret < 0)
7808 goto err;
7809
7810 reg = 0x10c0 ;
7811 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7812 ret = usb_microdia_control_write(dev, reg, buf, 8);
7813 if (ret < 0)
7814 goto err;
7815
7816 reg = 0x10c0 ;
7817 ret = usb_microdia_control_read(dev, reg, buf, 1);
7818 if (ret < 0)
7819 goto err;
7820
7821 reg = 0x10c0 ;
7822 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7823 ret = usb_microdia_control_write(dev, reg, buf, 8);
7824 if (ret < 0)
7825 goto err;
7826
7827 reg = 0x10c0 ;
7828 ret = usb_microdia_control_read(dev, reg, buf, 1);
7829 if (ret < 0)
7830 goto err;
7831
7832 reg = 0x10c0 ;
7833 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7834 ret = usb_microdia_control_write(dev, reg, buf, 8);
7835 if (ret < 0)
7836 goto err;
7837
7838 reg = 0x10c0 ;
7839 ret = usb_microdia_control_read(dev, reg, buf, 1);
7840 if (ret < 0)
7841 goto err;
7842
7843 reg = 0x10c0 ;
7844 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7845 ret = usb_microdia_control_write(dev, reg, buf, 8);
7846 if (ret < 0)
7847 goto err;
7848
7849 reg = 0x10c0 ;
7850 ret = usb_microdia_control_read(dev, reg, buf, 1);
7851 if (ret < 0)
7852 goto err;
7853
7854 reg = 0x10c0 ;
7855 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7856 ret = usb_microdia_control_write(dev, reg, buf, 8);
7857 if (ret < 0)
7858 goto err;
7859
7860 reg = 0x10c0 ;
7861 ret = usb_microdia_control_read(dev, reg, buf, 1);
7862 if (ret < 0)
7863 goto err;
7864
7865 reg = 0x10c0 ;
7866 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7867 ret = usb_microdia_control_write(dev, reg, buf, 8);
7868 if (ret < 0)
7869 goto err;
7870
7871 reg = 0x10c0 ;
7872 ret = usb_microdia_control_read(dev, reg, buf, 1);
7873 if (ret < 0)
7874 goto err;
7875
7876 reg = 0x10c0 ;
7877 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7878 ret = usb_microdia_control_write(dev, reg, buf, 8);
7879 if (ret < 0)
7880 goto err;
7881
7882 reg = 0x10c0 ;
7883 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7884 ret = usb_microdia_control_write(dev, reg, buf, 8);
7885 if (ret < 0)
7886 goto err;
7887
7888 reg = 0x10c0 ;
7889 ret = usb_microdia_control_read(dev, reg, buf, 1);
7890 if (ret < 0)
7891 goto err;
7892
7893 reg = 0x10c0 ;
7894 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7895 ret = usb_microdia_control_write(dev, reg, buf, 8);
7896 if (ret < 0)
7897 goto err;
7898
7899 reg = 0x10c0 ;
7900 ret = usb_microdia_control_read(dev, reg, buf, 1);
7901 if (ret < 0)
7902 goto err;
7903
7904 reg = 0x10c0 ;
7905 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7906 ret = usb_microdia_control_write(dev, reg, buf, 8);
7907 if (ret < 0)
7908 goto err;
7909
7910 reg = 0x10c0 ;
7911 ret = usb_microdia_control_read(dev, reg, buf, 1);
7912 if (ret < 0)
7913 goto err;
7914
7915 reg = 0x10c0 ;
7916 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7917 ret = usb_microdia_control_write(dev, reg, buf, 8);
7918 if (ret < 0)
7919 goto err;
7920
7921 reg = 0x10c0 ;
7922 ret = usb_microdia_control_read(dev, reg, buf, 1);
7923 if (ret < 0)
7924 goto err;
7925
7926 reg = 0x10c0 ;
7927 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7928 ret = usb_microdia_control_write(dev, reg, buf, 8);
7929 if (ret < 0)
7930 goto err;
7931
7932 reg = 0x10c0 ;
7933 ret = usb_microdia_control_read(dev, reg, buf, 1);
7934 if (ret < 0)
7935 goto err;
7936
7937 reg = 0x10c0 ;
7938 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7939 ret = usb_microdia_control_write(dev, reg, buf, 8);
7940 if (ret < 0)
7941 goto err;
7942
7943 reg = 0x10c0 ;
7944 ret = usb_microdia_control_read(dev, reg, buf, 1);
7945 if (ret < 0)
7946 goto err;
7947
7948 reg = 0x10c0 ;
7949 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7950 ret = usb_microdia_control_write(dev, reg, buf, 8);
7951 if (ret < 0)
7952 goto err;
7953
7954 reg = 0x10c0 ;
7955 ret = usb_microdia_control_read(dev, reg, buf, 1);
7956 if (ret < 0)
7957 goto err;
7958
7959 reg = 0x10c0 ;
7960 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7961 ret = usb_microdia_control_write(dev, reg, buf, 8);
7962 if (ret < 0)
7963 goto err;
7964
7965 reg = 0x10c0 ;
7966 ret = usb_microdia_control_read(dev, reg, buf, 1);
7967 if (ret < 0)
7968 goto err;
7969
7970 reg = 0x10c0 ;
7971 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7972 ret = usb_microdia_control_write(dev, reg, buf, 8);
7973 if (ret < 0)
7974 goto err;
7975
7976 reg = 0x10c2 ;
7977 ret = usb_microdia_control_read(dev, reg, buf, 5);
7978 if (ret < 0)
7979 goto err;
7980
7981 reg = 0x10c1 ;
7982 buf[0] = 0x30;
7983 ret = usb_microdia_control_write(dev, reg, buf, 1);
7984 if (ret < 0)
7985 goto err;
7986
7987 reg = 0x10e0 ;
7988 buf[0] = 0x47;
7989 ret = usb_microdia_control_write(dev, reg, buf, 1);
7990 if (ret < 0)
7991 goto err;
7992
7993 reg = 0x10e0 ;
7994 buf[0] = 0x47;
7995 ret = usb_microdia_control_write(dev, reg, buf, 1);
7996 if (ret < 0)
7997 goto err;
7998
7999 reg = 0x1001 ;
8000 buf[0] = 0xc6;
8001 ret = usb_microdia_control_write(dev, reg, buf, 1);
8002 if (ret < 0)
8003 goto err;
8004
8005 reg = 0x1001 ;
8006 buf[0] = 0xc4;
8007 ret = usb_microdia_control_write(dev, reg, buf, 1);
8008 if (ret < 0)
8009 goto err;
8010
8011 reg = 0x1001 ;
8012 buf[0] = 0x84;
8013 ret = usb_microdia_control_write(dev, reg, buf, 1);
8014 if (ret < 0)
8015 goto err;
8016
8017 reg = 0x1189 ;
8018 buf[0] = 0xcc;
8019 ret = usb_microdia_control_write(dev, reg, buf, 1);
8020 if (ret < 0)
8021 goto err;
8022
8023 reg = 0x11bc ;
8024 buf[0] = 0x00;
8025 ret = usb_microdia_control_write(dev, reg, buf, 1);
8026 if (ret < 0)
8027 goto err;
8028
8029 reg = 0x11bd ;
8030 buf[0] = 0x00;
8031 ret = usb_microdia_control_write(dev, reg, buf, 1);
8032 if (ret < 0)
8033 goto err;
8034
8035 reg = 0x11be ;
8036 buf[0] = 0x00;
8037 ret = usb_microdia_control_write(dev, reg, buf, 1);
8038 if (ret < 0)
8039 goto err;
8040
8041 reg = 0x11bf ;
8042 buf[0] = 0x00;
8043 ret = usb_microdia_control_write(dev, reg, buf, 1);
8044 if (ret < 0)
8045 goto err;
8046
8047 reg = 0x10c0 ;
8048 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8049 ret = usb_microdia_control_write(dev, reg, buf, 8);
8050 if (ret < 0)
8051 goto err;
8052
8053 reg = 0x10c0 ;
8054 ret = usb_microdia_control_read(dev, reg, buf, 1);
8055 if (ret < 0)
8056 goto err;
8057
8058 reg = 0x10c0 ;
8059 ret = usb_microdia_control_read(dev, reg, buf, 1);
8060 if (ret < 0)
8061 goto err;
8062
8063 reg = 0x10c0 ;
8064 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
8065 ret = usb_microdia_control_write(dev, reg, buf, 8);
8066 if (ret < 0)
8067 goto err;
8068
8069 reg = 0x10c0 ;
8070 ret = usb_microdia_control_read(dev, reg, buf, 1);
8071 if (ret < 0)
8072 goto err;
8073
8074 reg = 0x10c0 ;
8075 ret = usb_microdia_control_read(dev, reg, buf, 1);
8076 if (ret < 0)
8077 goto err;
8078
8079 reg = 0x10c0 ;
8080 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8081 ret = usb_microdia_control_write(dev, reg, buf, 8);
8082 if (ret < 0)
8083 goto err;
8084
8085 reg = 0x10c0 ;
8086 ret = usb_microdia_control_read(dev, reg, buf, 1);
8087 if (ret < 0)
8088 goto err;
8089
8090 reg = 0x10c0 ;
8091 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8092 ret = usb_microdia_control_write(dev, reg, buf, 8);
8093 if (ret < 0)
8094 goto err;
8095
8096 reg = 0x10c0 ;
8097 ret = usb_microdia_control_read(dev, reg, buf, 1);
8098 if (ret < 0)
8099 goto err;
8100
8101 reg = 0x10c0 ;
8102 ret = usb_microdia_control_read(dev, reg, buf, 1);
8103 if (ret < 0)
8104 goto err;
8105
8106 reg = 0x1180 ;
8107 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x50; buf[5] = 0x78;
8108 ret = usb_microdia_control_write(dev, reg, buf, 6);
8109 if (ret < 0)
8110 goto err;
8111
8112 reg = 0x10fb ;
8113 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
8114 ret = usb_microdia_control_write(dev, reg, buf, 5);
8115 if (ret < 0)
8116 goto err;
8117
8118 reg = 0x1189 ;
8119 buf[0] = 0xdc;
8120 ret = usb_microdia_control_write(dev, reg, buf, 1);
8121 if (ret < 0)
8122 goto err;
8123
8124 reg = 0x1189 ;
8125 buf[0] = 0xd0;
8126 ret = usb_microdia_control_write(dev, reg, buf, 1);
8127 if (ret < 0)
8128 goto err;
8129
8130 reg = 0x11a1 ;
8131 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
8132 ret = usb_microdia_control_write(dev, reg, buf, 4);
8133 if (ret < 0)
8134 goto err;
8135
8136 reg = 0x11ab ;
8137 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
8138 ret = usb_microdia_control_write(dev, reg, buf, 4);
8139 if (ret < 0)
8140 goto err;
8141
8142 reg = 0x1000 ;
8143 buf[0] = 0x78;
8144 ret = usb_microdia_control_write(dev, reg, buf, 1);
8145 if (ret < 0)
8146 goto err;
8147
8148 reg = 0x1002 ;
8149 buf[0] = 0x18;
8150 ret = usb_microdia_control_write(dev, reg, buf, 1);
8151 if (ret < 0)
8152 goto err;
8153
8154 reg = 0x1002 ;
8155 buf[0] = 0x08;
8156 ret = usb_microdia_control_write(dev, reg, buf, 1);
8157 if (ret < 0)
8158 goto err;
8159
8160 reg = 0x11b8 ;
8161 buf[0] = 0x38;
8162 ret = usb_microdia_control_write(dev, reg, buf, 1);
8163 if (ret < 0)
8164 goto err;
8165
8166 reg = 0x118a ;
8167 buf[0] = 0x02;
8168 ret = usb_microdia_control_write(dev, reg, buf, 1);
8169 if (ret < 0)
8170 goto err;
8171
8172 reg = 0x0395 ;
8173 buf[0] = 0x02;
8174 ret = usb_microdia_control_write(dev, reg, buf, 1);
8175 if (ret < 0)
8176 goto err;
8177
8178 reg = 0x11b8 ;
8179 buf[0] = 0x78;
8180 ret = usb_microdia_control_write(dev, reg, buf, 1);
8181 if (ret < 0)
8182 goto err;
8183
8184 reg = 0x11b8 ;
8185 ret = usb_microdia_control_read(dev, reg, buf, 1);
8186 if (ret < 0)
8187 goto err;
8188
8189 reg = 0x11b8 ;
8190 buf[0] = 0xf9;
8191 ret = usb_microdia_control_write(dev, reg, buf, 1);
8192 if (ret < 0)
8193 goto err;
8194
8195 reg = 0x11b8 ;
8196 ret = usb_microdia_control_read(dev, reg, buf, 1);
8197 if (ret < 0)
8198 goto err;
8199
8200 reg = 0x11b8 ;
8201 buf[0] = 0x7a;
8202 ret = usb_microdia_control_write(dev, reg, buf, 1);
8203 if (ret < 0)
8204 goto err;
8205
8206 reg = 0x11b8 ;
8207 ret = usb_microdia_control_read(dev, reg, buf, 1);
8208 if (ret < 0)
8209 goto err;
8210
8211 reg = 0x11b8 ;
8212 buf[0] = 0x7b;
8213 ret = usb_microdia_control_write(dev, reg, buf, 1);
8214 if (ret < 0)
8215 goto err;
8216
8217 reg = 0x11b8 ;
8218 ret = usb_microdia_control_read(dev, reg, buf, 1);
8219 if (ret < 0)
8220 goto err;
8221
8222 reg = 0x11b8 ;
8223 buf[0] = 0x7c;
8224 ret = usb_microdia_control_write(dev, reg, buf, 1);
8225 if (ret < 0)
8226 goto err;
8227
8228 reg = 0x11b8 ;
8229 ret = usb_microdia_control_read(dev, reg, buf, 1);
8230 if (ret < 0)
8231 goto err;
8232
8233 reg = 0x11b8 ;
8234 buf[0] = 0xfd;
8235 ret = usb_microdia_control_write(dev, reg, buf, 1);
8236 if (ret < 0)
8237 goto err;
8238
8239 reg = 0x11b8 ;
8240 ret = usb_microdia_control_read(dev, reg, buf, 1);
8241 if (ret < 0)
8242 goto err;
8243
8244 reg = 0x11b8 ;
8245 buf[0] = 0xfa;
8246 ret = usb_microdia_control_write(dev, reg, buf, 1);
8247 if (ret < 0)
8248 goto err;
8249
8250 reg = 0x10c0 ;
8251 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8252 ret = usb_microdia_control_write(dev, reg, buf, 8);
8253 if (ret < 0)
8254 goto err;
8255
8256 reg = 0x10c0 ;
8257 ret = usb_microdia_control_read(dev, reg, buf, 1);
8258 if (ret < 0)
8259 goto err;
8260
8261 reg = 0x10c0 ;
8262 ret = usb_microdia_control_read(dev, reg, buf, 1);
8263 if (ret < 0)
8264 goto err;
8265
8266 reg = 0x10c0 ;
8267 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8268 ret = usb_microdia_control_write(dev, reg, buf, 8);
8269 if (ret < 0)
8270 goto err;
8271
8272 reg = 0x10c0 ;
8273 ret = usb_microdia_control_read(dev, reg, buf, 1);
8274 if (ret < 0)
8275 goto err;
8276
8277 reg = 0x10c0 ;
8278 ret = usb_microdia_control_read(dev, reg, buf, 1);
8279 if (ret < 0)
8280 goto err;
8281
8282 reg = 0x10c0 ;
8283 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8284 ret = usb_microdia_control_write(dev, reg, buf, 8);
8285 if (ret < 0)
8286 goto err;
8287
8288 reg = 0x10c0 ;
8289 ret = usb_microdia_control_read(dev, reg, buf, 1);
8290 if (ret < 0)
8291 goto err;
8292
8293 reg = 0x10c0 ;
8294 ret = usb_microdia_control_read(dev, reg, buf, 1);
8295 if (ret < 0)
8296 goto err;
8297
8298 reg = 0x10c0 ;
8299 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8300 ret = usb_microdia_control_write(dev, reg, buf, 8);
8301 if (ret < 0)
8302 goto err;
8303
8304 reg = 0x10c0 ;
8305 ret = usb_microdia_control_read(dev, reg, buf, 1);
8306 if (ret < 0)
8307 goto err;
8308
8309 reg = 0x10c0 ;
8310 ret = usb_microdia_control_read(dev, reg, buf, 1);
8311 if (ret < 0)
8312 goto err;
8313
8314 reg = 0x10c0 ;
8315 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8316 ret = usb_microdia_control_write(dev, reg, buf, 8);
8317 if (ret < 0)
8318 goto err;
8319
8320 reg = 0x10c0 ;
8321 ret = usb_microdia_control_read(dev, reg, buf, 1);
8322 if (ret < 0)
8323 goto err;
8324
8325 reg = 0x10c0 ;
8326 ret = usb_microdia_control_read(dev, reg, buf, 1);
8327 if (ret < 0)
8328 goto err;
8329
8330 reg = 0x10c0 ;
8331 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8332 ret = usb_microdia_control_write(dev, reg, buf, 8);
8333 if (ret < 0)
8334 goto err;
8335
8336 reg = 0x10c0 ;
8337 ret = usb_microdia_control_read(dev, reg, buf, 1);
8338 if (ret < 0)
8339 goto err;
8340
8341 reg = 0x10c0 ;
8342 ret = usb_microdia_control_read(dev, reg, buf, 1);
8343 if (ret < 0)
8344 goto err;
8345
8346 reg = 0x10c0 ;
8347 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8348 ret = usb_microdia_control_write(dev, reg, buf, 8);
8349 if (ret < 0)
8350 goto err;
8351
8352 reg = 0x10c0 ;
8353 ret = usb_microdia_control_read(dev, reg, buf, 1);
8354 if (ret < 0)
8355 goto err;
8356
8357 reg = 0x10c0 ;
8358 ret = usb_microdia_control_read(dev, reg, buf, 1);
8359 if (ret < 0)
8360 goto err;
8361
8362 reg = 0x1182 ;
8363 buf[0] = 0x01;
8364 ret = usb_microdia_control_write(dev, reg, buf, 1);
8365 if (ret < 0)
8366 goto err;
8367
8368 reg = 0x10c0 ;
8369 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x7d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8370 ret = usb_microdia_control_write(dev, reg, buf, 8);
8371 if (ret < 0)
8372 goto err;
8373
8374 reg = 0x10c0 ;
8375 ret = usb_microdia_control_read(dev, reg, buf, 1);
8376 if (ret < 0)
8377 goto err;
8378
8379 reg = 0x10c0 ;
8380 ret = usb_microdia_control_read(dev, reg, buf, 1);
8381 if (ret < 0)
8382 goto err;
8383
8384 reg = 0x10c0 ;
8385 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8386 ret = usb_microdia_control_write(dev, reg, buf, 8);
8387 if (ret < 0)
8388 goto err;
8389
8390 reg = 0x10c0 ;
8391 ret = usb_microdia_control_read(dev, reg, buf, 1);
8392 if (ret < 0)
8393 goto err;
8394
8395 reg = 0x10c0 ;
8396 ret = usb_microdia_control_read(dev, reg, buf, 1);
8397 if (ret < 0)
8398 goto err;
8399
8400 reg = 0x10c0 ;
8401 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8402 ret = usb_microdia_control_write(dev, reg, buf, 8);
8403 if (ret < 0)
8404 goto err;
8405
8406 reg = 0x10c0 ;
8407 ret = usb_microdia_control_read(dev, reg, buf, 1);
8408 if (ret < 0)
8409 goto err;
8410
8411 reg = 0x10c0 ;
8412 ret = usb_microdia_control_read(dev, reg, buf, 1);
8413 if (ret < 0)
8414 goto err;
8415
8416 reg = 0x10c0 ;
8417 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8418 ret = usb_microdia_control_write(dev, reg, buf, 8);
8419 if (ret < 0)
8420 goto err;
8421
8422 reg = 0x10c0 ;
8423 ret = usb_microdia_control_read(dev, reg, buf, 1);
8424 if (ret < 0)
8425 goto err;
8426
8427 reg = 0x10c0 ;
8428 ret = usb_microdia_control_read(dev, reg, buf, 1);
8429 if (ret < 0)
8430 goto err;
8431
8432 reg = 0x10c0 ;
8433 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8434 ret = usb_microdia_control_write(dev, reg, buf, 8);
8435 if (ret < 0)
8436 goto err;
8437
8438 reg = 0x10c0 ;
8439 ret = usb_microdia_control_read(dev, reg, buf, 1);
8440 if (ret < 0)
8441 goto err;
8442
8443 reg = 0x10c0 ;
8444 ret = usb_microdia_control_read(dev, reg, buf, 1);
8445 if (ret < 0)
8446 goto err;
8447
8448 reg = 0x10c0 ;
8449 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8450 ret = usb_microdia_control_write(dev, reg, buf, 8);
8451 if (ret < 0)
8452 goto err;
8453
8454 reg = 0x10c0 ;
8455 ret = usb_microdia_control_read(dev, reg, buf, 1);
8456 if (ret < 0)
8457 goto err;
8458
8459 reg = 0x10c0 ;
8460 ret = usb_microdia_control_read(dev, reg, buf, 1);
8461 if (ret < 0)
8462 goto err;
8463
8464 reg = 0x10c0 ;
8465 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8466 ret = usb_microdia_control_write(dev, reg, buf, 8);
8467 if (ret < 0)
8468 goto err;
8469
8470 reg = 0x10c0 ;
8471 ret = usb_microdia_control_read(dev, reg, buf, 1);
8472 if (ret < 0)
8473 goto err;
8474
8475 reg = 0x10c0 ;
8476 ret = usb_microdia_control_read(dev, reg, buf, 1);
8477 if (ret < 0)
8478 goto err;
8479
8480 reg = 0x10c0 ;
8481 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8482 ret = usb_microdia_control_write(dev, reg, buf, 8);
8483 if (ret < 0)
8484 goto err;
8485
8486 reg = 0x10c0 ;
8487 ret = usb_microdia_control_read(dev, reg, buf, 1);
8488 if (ret < 0)
8489 goto err;
8490
8491 reg = 0x10c0 ;
8492 ret = usb_microdia_control_read(dev, reg, buf, 1);
8493 if (ret < 0)
8494 goto err;
8495
8496 reg = 0x11ba ;
8497 buf[0] = 0x0a;
8498 ret = usb_microdia_control_write(dev, reg, buf, 1);
8499 if (ret < 0)
8500 goto err;
8501
8502 reg = 0x118b ;
8503 buf[0] = 0x10;
8504 ret = usb_microdia_control_write(dev, reg, buf, 1);
8505 if (ret < 0)
8506 goto err;
8507
8508 reg = 0x10f7;
8509 buf[0] = 0x05;
8510 ret = usb_microdia_control_write(dev, reg, buf, 1);
8511 if (ret < 0)
8512 goto err;
8513
8514 reg = 0x10f8 ;
8515 buf[0] = 0x14;
8516 ret = usb_microdia_control_write(dev, reg, buf, 1);
8517 if (ret < 0)
8518 goto err;
8519
8520 reg = 0x10fa ;
8521 buf[0] = 0xff;
8522 ret = usb_microdia_control_write(dev, reg, buf, 1);
8523 if (ret < 0)
8524 goto err;
8525
8526 reg = 0x10f9 ;
8527 buf[0] = 0x00;
8528 ret = usb_microdia_control_write(dev, reg, buf, 1);
8529 if (ret < 0)
8530 goto err;
8531
8532 reg = 0x10f9 ;
8533 buf[0] = 0x00;
8534 ret = usb_microdia_control_write(dev, reg, buf, 1);
8535 if (ret < 0)
8536 goto err;
8537
8538 reg = 0x11ba ;
8539 buf[0] = 0x0a;
8540 ret = usb_microdia_control_write(dev, reg, buf, 1);
8541 if (ret < 0)
8542 goto err;
8543
8544 reg = 0x11bc ;
8545 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
8546 ret = usb_microdia_control_write(dev, reg, buf, 4);
8547 if (ret < 0)
8548 goto err;
8549
8550 reg = 0x11c0;
8551 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
8552 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
8553 buf[8] = 0x00; buf[9] = 0x00; buf[10] = 0x00; buf[11] = 0x00;
8554 buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00; buf[15] = 0x00;
8555 buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
8556 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00;
8557 buf[24] = 0x00; buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00;
8558 buf[28] = 0x00; buf[29] = 0x00; buf[30] = 0x00; buf[31] = 0x00;
8559 buf[32] = 0x00; buf[33] = 0x00; buf[34] = 0x00; buf[35] = 0x00;
8560 buf[36] = 0x00; buf[37] = 0x00; buf[38] = 0x00; buf[39] = 0x00;
8561 buf[40] = 0x00; buf[41] = 0x00; buf[42] = 0x00; buf[43] = 0x00;
8562 buf[44] = 0x00; buf[45] = 0x00; buf[46] = 0x00; buf[47] = 0x00;
8563 ret = usb_microdia_control_write(dev, reg, buf, 48);
8564 if (ret < 0)
8565 goto err;
8566
8567 reg = 0x11a5 ;
8568 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
8569 buf[4] = 0x04; buf[5] = 0x3f;
8570 ret = usb_microdia_control_write(dev, reg, buf, 6);
8571 if (ret < 0)
8572 goto err;
8573
8574 reg = 0x11af ;
8575 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
8576 ret = usb_microdia_control_write(dev, reg, buf, 4);
8577 if (ret < 0)
8578 goto err;
8579
8580 reg = 0x11b3 ;
8581 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
8582 ret = usb_microdia_control_write(dev, reg, buf, 4);
8583 if (ret < 0)
8584 goto err;
8585
8586 reg = 0x10e0 ;
8587 buf[0] = 0x47;
8588 ret = usb_microdia_control_write(dev, reg, buf, 1);
8589 if (ret < 0)
8590 goto err;
8591
8592 reg = 0x1061 ;
8593 buf[0] = 0x01;
8594 ret = usb_microdia_control_write(dev, reg, buf, 1);
8595 if (ret < 0)
8596 goto err;
8597
8598 reg = 0x10e0 ;
8599 buf[0] = 0x67;
8600 ret = usb_microdia_control_write(dev, reg, buf, 1);
8601 if (ret < 0)
8602 goto err;
8603
8604 reg = 0x1100 ;
8605 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
8606 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
8607 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
8608 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
8609 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
8610 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
8611 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
8612 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
8613 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
8614 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
8615 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
8616 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
8617 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
8618 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
8619 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
8620 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
8621 ret = usb_microdia_control_write(dev, reg, buf, 64);
8622 if (ret < 0)
8623 goto err;
8624
8625 reg = 0x1140 ;
8626 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
8627 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
8628 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
8629 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
8630 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
8631 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
8632 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
8633 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
8634 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
8635 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
8636 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
8637 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
8638 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
8639 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
8640 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
8641 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
8642 ret = usb_microdia_control_write(dev, reg, buf, 64);
8643 if (ret < 0)
8644 goto err;
8645
8646 reg = 0x10e0 ;
8647 buf[0] = 0x47;
8648 ret = usb_microdia_control_write(dev, reg, buf, 1);
8649 if (ret < 0)
8650 goto err;
8651
8652 reg = 0x1061 ;
8653 buf[0] = 0x03;
8654 ret = usb_microdia_control_write(dev, reg, buf, 1);
8655 if (ret < 0)
8656 goto err;
8657
8658 reg = 0x10e0 ;
8659 buf[0] = 0x4b;
8660 ret = usb_microdia_control_write(dev, reg, buf, 1);
8661 if (ret < 0)
8662 goto err;
8663
8664 reg = 0x1189 ;
8665 buf[0] = 0xd0;
8666 ret = usb_microdia_control_write(dev, reg, buf, 1);
8667 if (ret < 0)
8668 goto err;
8669
8670 reg = 0x11bc ;
8671 buf[0] = 0x00;
8672 ret = usb_microdia_control_write(dev, reg, buf, 1);
8673 if (ret < 0)
8674 goto err;
8675
8676 reg = 0x11bd ;
8677 buf[0] = 0x00;
8678 ret = usb_microdia_control_write(dev, reg, buf, 1);
8679 if (ret < 0)
8680 goto err;
8681
8682 reg = 0x11be ;
8683 buf[0] = 0x00;
8684 ret = usb_microdia_control_write(dev, reg, buf, 1);
8685 if (ret < 0)
8686 goto err;
8687
8688 reg = 0x11bf ;
8689 buf[0] = 0x00;
8690 ret = usb_microdia_control_write(dev, reg, buf, 1);
8691 if (ret < 0)
8692 goto err;
8693
8694 reg = 0x10c0 ;
8695 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8696 ret = usb_microdia_control_write(dev, reg, buf, 8);
8697 if (ret < 0)
8698 goto err;
8699
8700 reg = 0x10c0 ;
8701 ret = usb_microdia_control_read(dev, reg, buf, 1);
8702 if (ret < 0)
8703 goto err;
8704
8705 reg = 0x10c0 ;
8706 ret = usb_microdia_control_read(dev, reg, buf, 1);
8707 if (ret < 0)
8708 goto err;
8709
8710 reg = 0x10c0 ;
8711 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
8712 ret = usb_microdia_control_write(dev, reg, buf, 8);
8713 if (ret < 0)
8714 goto err;
8715
8716 reg = 0x10c0 ;
8717 ret = usb_microdia_control_read(dev, reg, buf, 1);
8718 if (ret < 0)
8719 goto err;
8720
8721 reg = 0x10c0 ;
8722 ret = usb_microdia_control_read(dev, reg, buf, 1);
8723 if (ret < 0)
8724 goto err;
8725
8726 reg = 0x10c0 ;
8727 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8728 ret = usb_microdia_control_write(dev, reg, buf, 8);
8729 if (ret < 0)
8730 goto err;
8731
8732 reg = 0x10c0 ;
8733 ret = usb_microdia_control_read(dev, reg, buf, 1);
8734 if (ret < 0)
8735 goto err;
8736
8737 reg = 0x10c0 ;
8738 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8739 ret = usb_microdia_control_write(dev, reg, buf, 8);
8740 if (ret < 0)
8741 goto err;
8742
8743 reg = 0x10c0 ;
8744 ret = usb_microdia_control_read(dev, reg, buf, 1);
8745 if (ret < 0)
8746 goto err;
8747
8748 reg = 0x10c0 ;
8749 ret = usb_microdia_control_read(dev, reg, buf, 1);
8750 if (ret < 0)
8751 goto err;
8752
8753 reg = 0x1180 ;
8754 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
8755 buf[4] = 0x50; buf[5] = 0x78;
8756 ret = usb_microdia_control_write(dev, reg, buf, 6);
8757 if (ret < 0)
8758 goto err;
8759
8760 reg = 0x10fb ;
8761 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
8762 buf[4] = 0x00;
8763 ret = usb_microdia_control_write(dev, reg, buf, 5);
8764 if (ret < 0)
8765 goto err;
8766
8767 reg = 0x1189 ;
8768 buf[0] = 0xd0;
8769 ret = usb_microdia_control_write(dev, reg, buf, 1);
8770 if (ret < 0)
8771 goto err;
8772
8773 reg = 0x11a1 ;
8774 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
8775 ret = usb_microdia_control_write(dev, reg, buf, 4);
8776 if (ret < 0)
8777 goto err;
8778
8779 reg = 0x11ab ;
8780 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
8781 ret = usb_microdia_control_write(dev, reg, buf, 4);
8782 if (ret < 0)
8783 goto err;
8784
8785 reg = 0x1061 ;
8786 buf[0] = 0x03;
8787 ret = usb_microdia_control_write(dev, reg, buf, 1);
8788 if (ret < 0)
8789 goto err;
8790
8791 reg = 0x11ba ;
8792 buf[0] = 0x0a;
8793 ret = usb_microdia_control_write(dev, reg, buf, 1);
8794 if (ret < 0)
8795 goto err;
8796
8797 reg = 0x11b9 ;
8798 buf[0] = 0x00;
8799 ret = usb_microdia_control_write(dev, reg, buf, 1);
8800 if (ret < 0)
8801 goto err;
8802
8803 reg = 0x11ba ;
8804 buf[0] = 0x0b;
8805 ret = usb_microdia_control_write(dev, reg, buf, 1);
8806 if (ret < 0)
8807 goto err;
8808
8809 reg = 0x1061 ;
8810 buf[0] = 0x01;
8811 ret = usb_microdia_control_write(dev, reg, buf, 1);
8812 if (ret < 0)
8813 goto err;
8814
8815 reg = 0x1000 ;
8816 buf[0] = 0x78;
8817 ret = usb_microdia_control_write(dev, reg, buf, 1);
8818 if (ret < 0)
8819 goto err;
8820
8821 reg = 0x1002 ;
8822 buf[0] = 0x08;
8823 ret = usb_microdia_control_write(dev, reg, buf, 1);
8824 if (ret < 0)
8825 goto err;
8826
8827 reg = 0x1002 ;
8828 buf[0] = 0x08;
8829 ret = usb_microdia_control_write(dev, reg, buf, 1);
8830 if (ret < 0)
8831 goto err;
8832
8833 reg = 0x11b8 ;
8834 buf[0] = 0xfa;
8835 ret = usb_microdia_control_write(dev, reg, buf, 1);
8836 if (ret < 0)
8837 goto err;
8838
8839 reg = 0x118a ;
8840 buf[0] = 0x02;
8841 ret = usb_microdia_control_write(dev, reg, buf, 1);
8842 if (ret < 0)
8843 goto err;
8844
8845 reg = 0x0395 ;
8846 buf[0] = 0x02;
8847 ret = usb_microdia_control_write(dev, reg, buf, 1);
8848 if (ret < 0)
8849 goto err;
8850
8851 reg = 0x11b8 ;
8852 buf[0] = 0xf8;
8853 ret = usb_microdia_control_write(dev, reg, buf, 1);
8854 if (ret < 0)
8855 goto err;
8856
8857 reg = 0x11b8 ;
8858 ret = usb_microdia_control_read(dev, reg, buf, 1);
8859 if (ret < 0)
8860 goto err;
8861
8862 reg = 0x11b8 ;
8863 buf[0] = 0xf9;
8864 ret = usb_microdia_control_write(dev, reg, buf, 1);
8865 if (ret < 0)
8866 goto err;
8867
8868 reg = 0x11b8 ;
8869 ret = usb_microdia_control_read(dev, reg, buf, 1);
8870 if (ret < 0)
8871 goto err;
8872
8873 reg = 0x11b8 ;
8874 buf[0] = 0x7a;
8875 ret = usb_microdia_control_write(dev, reg, buf, 1);
8876 if (ret < 0)
8877 goto err;
8878
8879 reg = 0x11b8 ;
8880 ret = usb_microdia_control_read(dev, reg, buf, 1);
8881 if (ret < 0)
8882 goto err;
8883
8884 reg = 0x11b8 ;
8885 buf[0] = 0x7b;
8886 ret = usb_microdia_control_write(dev, reg, buf, 1);
8887 if (ret < 0)
8888 goto err;
8889
8890 reg = 0x11b8 ;
8891 ret = usb_microdia_control_read(dev, reg, buf, 1);
8892 if (ret < 0)
8893 goto err;
8894
8895 reg = 0x11b8 ;
8896 buf[0] = 0x7c;
8897 ret = usb_microdia_control_write(dev, reg, buf, 1);
8898 if (ret < 0)
8899 goto err;
8900
8901 reg = 0x11b8 ;
8902 ret = usb_microdia_control_read(dev, reg, buf, 1);
8903 if (ret < 0)
8904 goto err;
8905
8906 reg = 0x11b8 ;
8907 buf[0] = 0xfd;
8908 ret = usb_microdia_control_write(dev, reg, buf, 1);
8909 if (ret < 0)
8910 goto err;
8911
8912 reg = 0x11b8 ;
8913 ret = usb_microdia_control_read(dev, reg, buf, 1);
8914 if (ret < 0)
8915 goto err;
8916
8917 reg = 0x11b8 ;
8918 buf[0] = 0xfa;
8919 ret = usb_microdia_control_write(dev, reg, buf, 1);
8920 if (ret < 0)
8921 goto err;
8922
8923 reg = 0x10c0 ;
8924 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8925 ret = usb_microdia_control_write(dev, reg, buf, 8);
8926 if (ret < 0)
8927 goto err;
8928
8929 reg = 0x10c0 ;
8930 ret = usb_microdia_control_read(dev, reg, buf, 1);
8931 if (ret < 0)
8932 goto err;
8933
8934 reg = 0x10c0 ;
8935 ret = usb_microdia_control_read(dev, reg, buf, 1);
8936 if (ret < 0)
8937 goto err;
8938
8939 reg = 0x10c0 ;
8940 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8941 ret = usb_microdia_control_write(dev, reg, buf, 8);
8942 if (ret < 0)
8943 goto err;
8944
8945 reg = 0x10c0 ;
8946 ret = usb_microdia_control_read(dev, reg, buf, 1);
8947 if (ret < 0)
8948 goto err;
8949
8950 reg = 0x10c0 ;
8951 ret = usb_microdia_control_read(dev, reg, buf, 1);
8952 if (ret < 0)
8953 goto err;
8954
8955 reg = 0x10c0 ;
8956 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x70; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8957 ret = usb_microdia_control_write(dev, reg, buf, 8);
8958 if (ret < 0)
8959 goto err;
8960
8961 reg = 0x10c0 ;
8962 ret = usb_microdia_control_read(dev, reg, buf, 1);
8963 if (ret < 0)
8964 goto err;
8965
8966 reg = 0x10c0 ;
8967 ret = usb_microdia_control_read(dev, reg, buf, 1);
8968 if (ret < 0)
8969 goto err;
8970
8971 reg = 0x10c0 ;
8972 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8973 ret = usb_microdia_control_write(dev, reg, buf, 8);
8974 if (ret < 0)
8975 goto err;
8976
8977 reg = 0x10c0 ;
8978 ret = usb_microdia_control_read(dev, reg, buf, 1);
8979 if (ret < 0)
8980 goto err;
8981
8982 reg = 0x10c0 ;
8983 ret = usb_microdia_control_read(dev, reg, buf, 1);
8984 if (ret < 0)
8985 goto err;
8986
8987 reg = 0x10c0 ;
8988 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8989 ret = usb_microdia_control_write(dev, reg, buf, 8);
8990 if (ret < 0)
8991 goto err;
8992
8993 reg = 0x10c0 ;
8994 ret = usb_microdia_control_read(dev, reg, buf, 1);
8995 if (ret < 0)
8996 goto err;
8997
8998 reg = 0x10c0 ;
8999 ret = usb_microdia_control_read(dev, reg, buf, 1);
9000 if (ret < 0)
9001 goto err;
9002
9003 reg = 0x10c0 ;
9004 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9005 ret = usb_microdia_control_write(dev, reg, buf, 8);
9006 if (ret < 0)
9007 goto err;
9008
9009 reg = 0x10c0 ;
9010 ret = usb_microdia_control_read(dev, reg, buf, 1);
9011 if (ret < 0)
9012 goto err;
9013
9014 reg = 0x10c0 ;
9015 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9016 ret = usb_microdia_control_write(dev, reg, buf, 8);
9017 if (ret < 0)
9018 goto err;
9019
9020 reg = 0x10c0 ;
9021 ret = usb_microdia_control_read(dev, reg, buf, 1);
9022 if (ret < 0)
9023 goto err;
9024
9025 reg = 0x10c2 ;
9026 ret = usb_microdia_control_read(dev, reg, buf, 5);
9027 if (ret < 0)
9028 goto err;
9029
9030 reg = 0x10c0 ;
9031 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9032 ret = usb_microdia_control_write(dev, reg, buf, 8);
9033 if (ret < 0)
9034 goto err;
9035
9036 reg = 0x10c0 ;
9037 ret = usb_microdia_control_read(dev, reg, buf, 1);
9038 if (ret < 0)
9039 goto err;
9040
9041 reg = 0x10c0 ;
9042 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9043 ret = usb_microdia_control_write(dev, reg, buf, 8);
9044 if (ret < 0)
9045 goto err;
9046
9047 reg = 0x10c0 ;
9048 ret = usb_microdia_control_read(dev, reg, buf, 1);
9049 if (ret < 0)
9050 goto err;
9051
9052 reg = 0x10c2 ;
9053 ret = usb_microdia_control_read(dev, reg, buf, 5);
9054 if (ret < 0)
9055 goto err;
9056
9057 reg = 0x10c0 ;
9058 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1c; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9059 ret = usb_microdia_control_write(dev, reg, buf, 8);
9060 if (ret < 0)
9061 goto err;
9062
9063 reg = 0x10c0 ;
9064 ret = usb_microdia_control_read(dev, reg, buf, 1);
9065 if (ret < 0)
9066 goto err;
9067
9068 reg = 0x10c0 ;
9069 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9070 ret = usb_microdia_control_write(dev, reg, buf, 8);
9071 if (ret < 0)
9072 goto err;
9073
9074 reg = 0x10c0 ;
9075 ret = usb_microdia_control_read(dev, reg, buf, 1);
9076 if (ret < 0)
9077 goto err;
9078
9079 reg = 0x10c2 ;
9080 ret = usb_microdia_control_read(dev, reg, buf, 5);
9081 if (ret < 0)
9082 goto err;
9083
9084 reg = 0x10c0 ;
9085 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9086 ret = usb_microdia_control_write(dev, reg, buf, 8);
9087 if (ret < 0)
9088 goto err;
9089
9090 reg = 0x10c0 ;
9091 ret = usb_microdia_control_read(dev, reg, buf, 1);
9092 if (ret < 0)
9093 goto err;
9094
9095 reg = 0x10c0 ;
9096 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9097 ret = usb_microdia_control_write(dev, reg, buf, 8);
9098 if (ret < 0)
9099 goto err;
9100
9101 reg = 0x10c0 ;
9102 ret = usb_microdia_control_read(dev, reg, buf, 1);
9103 if (ret < 0)
9104 goto err;
9105
9106 reg = 0x10c2 ;
9107 ret = usb_microdia_control_read(dev, reg, buf, 5);
9108 if (ret < 0)
9109 goto err;
9110
9111 reg = 0x1061 ;
9112 buf[0] = 0x03;
9113 ret = usb_microdia_control_write(dev, reg, buf, 1);
9114 if (ret < 0)
9115 goto err;
9116
9117 reg = 0x1007 ;
9118 buf[0] = 0x20;
9119 ret = usb_microdia_control_write(dev, reg, buf, 1);
9120 if (ret < 0)
9121 goto err;
9122
9123 reg = 0x1006 ;
9124 buf[0] = 0x00;
9125 ret = usb_microdia_control_write(dev, reg, buf, 1);
9126 if (ret < 0)
9127 goto err;
9128
9129 reg = 0x10c0 ;
9130 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9131 ret = usb_microdia_control_write(dev, reg, buf, 8);
9132 if (ret < 0)
9133 goto err;
9134
9135 reg = 0x10c0 ;
9136 ret = usb_microdia_control_read(dev, reg, buf, 1);
9137 if (ret < 0)
9138 goto err;
9139
9140 reg = 0x10c0 ;
9141 ret = usb_microdia_control_read(dev, reg, buf, 1);
9142 if (ret < 0)
9143 goto err;
9144
9145 reg = 0x10c0 ;
9146 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9147 ret = usb_microdia_control_write(dev, reg, buf, 8);
9148 if (ret < 0)
9149 goto err;
9150
9151 reg = 0x10c0 ;
9152 ret = usb_microdia_control_read(dev, reg, buf, 1);
9153 if (ret < 0)
9154 goto err;
9155
9156 reg = 0x10c0 ;
9157 ret = usb_microdia_control_read(dev, reg, buf, 1);
9158 if (ret < 0)
9159 goto err;
9160
9161 reg = 0x10c0 ;
9162 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9163 ret = usb_microdia_control_write(dev, reg, buf, 8);
9164 if (ret < 0)
9165 goto err;
9166
9167 reg = 0x10c0 ;
9168 ret = usb_microdia_control_read(dev, reg, buf, 1);
9169 if (ret < 0)
9170 goto err;
9171
9172 reg = 0x10c0 ;
9173 ret = usb_microdia_control_read(dev, reg, buf, 1);
9174 if (ret < 0)
9175 goto err;
9176
9177 reg = 0x10c0 ;
9178 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x36; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9179 ret = usb_microdia_control_write(dev, reg, buf, 8);
9180 if (ret < 0)
9181 goto err;
9182
9183 reg = 0x10c0 ;
9184 ret = usb_microdia_control_read(dev, reg, buf, 1);
9185 if (ret < 0)
9186 goto err;
9187
9188 reg = 0x10c0 ;
9189 ret = usb_microdia_control_read(dev, reg, buf, 1);
9190 if (ret < 0)
9191 goto err;
9192
9193 reg = 0x10c0 ;
9194 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9195 ret = usb_microdia_control_write(dev, reg, buf, 8);
9196 if (ret < 0)
9197 goto err;
9198
9199 reg = 0x10c0 ;
9200 ret = usb_microdia_control_read(dev, reg, buf, 1);
9201 if (ret < 0)
9202 goto err;
9203
9204 reg = 0x10c0 ;
9205 ret = usb_microdia_control_read(dev, reg, buf, 1);
9206 if (ret < 0)
9207 goto err;
9208
9209 reg = 0x10c0 ;
9210 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9211 ret = usb_microdia_control_write(dev, reg, buf, 8);
9212 if (ret < 0)
9213 goto err;
9214
9215 reg = 0x10c0 ;
9216 ret = usb_microdia_control_read(dev, reg, buf, 1);
9217 if (ret < 0)
9218 goto err;
9219
9220 reg = 0x10c0 ;
9221 ret = usb_microdia_control_read(dev, reg, buf, 1);
9222 if (ret < 0)
9223 goto err;
9224
9225 reg = 0x10c0 ;
9226 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9227 ret = usb_microdia_control_write(dev, reg, buf, 8);
9228 if (ret < 0)
9229 goto err;
9230
9231 reg = 0x10c0 ;
9232 ret = usb_microdia_control_read(dev, reg, buf, 1);
9233 if (ret < 0)
9234 goto err;
9235
9236 reg = 0x10c0 ;
9237 ret = usb_microdia_control_read(dev, reg, buf, 1);
9238 if (ret < 0)
9239 goto err;
9240
9241 reg = 0x10c0 ;
9242 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x94; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9243 ret = usb_microdia_control_write(dev, reg, buf, 8);
9244 if (ret < 0)
9245 goto err;
9246
9247 reg = 0x10c0 ;
9248 ret = usb_microdia_control_read(dev, reg, buf, 1);
9249 if (ret < 0)
9250 goto err;
9251
9252 reg = 0x10c0 ;
9253 ret = usb_microdia_control_read(dev, reg, buf, 1);
9254 if (ret < 0)
9255 goto err;
9256
9257 reg = 0x10c0 ;
9258 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x8d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9259 ret = usb_microdia_control_write(dev, reg, buf, 8);
9260 if (ret < 0)
9261 goto err;
9262
9263 reg = 0x10c0 ;
9264 ret = usb_microdia_control_read(dev, reg, buf, 1);
9265 if (ret < 0)
9266 goto err;
9267
9268 reg = 0x10c0 ;
9269 ret = usb_microdia_control_read(dev, reg, buf, 1);
9270 if (ret < 0)
9271 goto err;
9272
9273 reg = 0x10c0 ;
9274 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x09; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9275 ret = usb_microdia_control_write(dev, reg, buf, 8);
9276 if (ret < 0)
9277 goto err;
9278
9279 reg = 0x10c0 ;
9280 ret = usb_microdia_control_read(dev, reg, buf, 1);
9281 if (ret < 0)
9282 goto err;
9283
9284 reg = 0x10c0 ;
9285 ret = usb_microdia_control_read(dev, reg, buf, 1);
9286 if (ret < 0)
9287 goto err;
9288
9289 reg = 0x10c0 ;
9290 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x95; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9291 ret = usb_microdia_control_write(dev, reg, buf, 8);
9292 if (ret < 0)
9293 goto err;
9294
9295 reg = 0x10c0 ;
9296 ret = usb_microdia_control_read(dev, reg, buf, 1);
9297 if (ret < 0)
9298 goto err;
9299
9300 reg = 0x10c0 ;
9301 ret = usb_microdia_control_read(dev, reg, buf, 1);
9302 if (ret < 0)
9303 goto err;
9304
9305 reg = 0x10c0 ;
9306 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9307 ret = usb_microdia_control_write(dev, reg, buf, 8);
9308 if (ret < 0)
9309 goto err;
9310
9311 reg = 0x10c0 ;
9312 ret = usb_microdia_control_read(dev, reg, buf, 1);
9313 if (ret < 0)
9314 goto err;
9315
9316 reg = 0x10c0 ;
9317 ret = usb_microdia_control_read(dev, reg, buf, 1);
9318 if (ret < 0)
9319 goto err;
9320
9321 reg = 0x10c0 ;
9322 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9323 ret = usb_microdia_control_write(dev, reg, buf, 8);
9324 if (ret < 0)
9325 goto err;
9326
9327 reg = 0x10c0 ;
9328 ret = usb_microdia_control_read(dev, reg, buf, 1);
9329 if (ret < 0)
9330 goto err;
9331
9332 reg = 0x10c0 ;
9333 ret = usb_microdia_control_read(dev, reg, buf, 1);
9334 if (ret < 0)
9335 goto err;
9336
9337 reg = 0x10c0 ;
9338 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x96; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9339 ret = usb_microdia_control_write(dev, reg, buf, 8);
9340 if (ret < 0)
9341 goto err;
9342
9343 reg = 0x10c0 ;
9344 ret = usb_microdia_control_read(dev, reg, buf, 1);
9345 if (ret < 0)
9346 goto err;
9347
9348 reg = 0x10c0 ;
9349 ret = usb_microdia_control_read(dev, reg, buf, 1);
9350 if (ret < 0)
9351 goto err;
9352
9353 reg = 0x10c0 ;
9354 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9355 ret = usb_microdia_control_write(dev, reg, buf, 8);
9356 if (ret < 0)
9357 goto err;
9358
9359 reg = 0x10c0 ;
9360 ret = usb_microdia_control_read(dev, reg, buf, 1);
9361 if (ret < 0)
9362 goto err;
9363
9364 reg = 0x10c0 ;
9365 ret = usb_microdia_control_read(dev, reg, buf, 1);
9366 if (ret < 0)
9367 goto err;
9368
9369 reg = 0x10c0 ;
9370 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9371 ret = usb_microdia_control_write(dev, reg, buf, 8);
9372 if (ret < 0)
9373 goto err;
9374
9375 reg = 0x10c0 ;
9376 ret = usb_microdia_control_read(dev, reg, buf, 1);
9377 if (ret < 0)
9378 goto err;
9379
9380 reg = 0x10c0 ;
9381 ret = usb_microdia_control_read(dev, reg, buf, 1);
9382 if (ret < 0)
9383 goto err;
9384
9385 reg = 0x1007 ;
9386 buf[0] = 0x20;
9387 ret = usb_microdia_control_write(dev, reg, buf, 1);
9388 if (ret < 0)
9389 goto err;
9390
9391 reg = 0x1006 ;
9392 buf[0] = 0x20;
9393 ret = usb_microdia_control_write(dev, reg, buf, 1);
9394 if (ret < 0)
9395 goto err;
9396
9397
9398
9399
9400 /* END OF MICRODIA 6288 START STREAM */
9401
9402 return 0;
9403 err:
9404 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9405 return ret;
9406 }
9407
9408 int dev_microdia_stop_stream(struct usb_microdia *dev)
9409 {
9410 int ret = -ENODEV;
9411 if (dev && dev->stop_stream)
9412 ret = dev->stop_stream(dev);
9413
9414 return ret;
9415 }
9416
9417 /**
9418 * @brief From stop.htm
9419 *
9420 * @param dev
9421 *
9422 * @returns 0
9423 *
9424 * @author GWater
9425 *
9426 * For SN9C201 with MI1310.
9427 * This function has not been tested yet.
9428 */
9429 int microdia_6242_stop_stream(struct usb_microdia *dev)
9430 {
9431 __u8 buf[3];
9432
9433 __u8 only10c0[3] = {0x0d, 0x00, 0x00};
9434
9435 buf[0] = 0x01;
9436 usb_microdia_control_write(dev, 0x1061, buf, 1);
9437
9438 buf[0] = 0x60;
9439 usb_microdia_control_write(dev, 0x1007, buf, 1);
9440
9441 buf[0] = 0x00;
9442 usb_microdia_control_write(dev, 0x1006, buf, 1);
9443
9444 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
9445 only10c0[0], dev->sensor_flags, &only10c0[1]);
9446
9447 buf[0] = 0x38;
9448 usb_microdia_control_write(dev, 0x1000, buf, 1);
9449
9450 buf[0] = 0x6b;
9451 usb_microdia_control_write(dev, 0x11b8, buf, 1);
9452
9453 buf[0] = 0x60;
9454 usb_microdia_control_write(dev, 0x1007, buf, 1);
9455
9456 buf[0] = 0x20;
9457 usb_microdia_control_write(dev, 0x1006, buf, 1);
9458
9459
9460 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9461 usb_microdia_control_write(dev, 0x1000, buf, 3);
9462
9463 /**
9464 * After the select alternate setting 0 is actually another transfer:
9465 * buf[0] = 0x00;
9466 * usb_microdia_control_write(dev, 0x1066, buf, 1);
9467 */
9468
9469 return 0;
9470 }
9471
9472
9473 /**
9474 * @brief From stopstream.log
9475 *
9476 * @param dev
9477 *
9478 * @returns 0
9479 *
9480 * @author GWater
9481 *
9482 * For SN9C201 with SOI968.
9483 * I don't whether the function really stops the stream.
9484 * Nevertheless the LED on the webcam now stops glowing.
9485 * The function is very similar to "microdia_624f_stop_stream".
9486 */
9487 int microdia_624e_stop_stream(struct usb_microdia *dev)
9488 {
9489 __u8 buf[3];
9490
9491 buf[0] = 0x01;
9492 usb_microdia_control_write(dev, 0x1061, buf, 1);
9493
9494 /* Next two writes added because it works better.
9495 * The LED stops glowing and I think the stream does too.
9496 * 0x20 = 0b00100000 which is the minimal of what the
9497 * other stopstreams have in common.
9498 */
9499 buf[0] = 0x20;
9500 usb_microdia_control_write(dev, 0x1007, buf, 1);
9501
9502 buf[0] = 0x20;
9503 usb_microdia_control_write(dev, 0x1006, buf, 1);
9504
9505 buf[0] = 0x3c;
9506 usb_microdia_control_write(dev, 0x1000, buf, 1);
9507
9508 buf[0] = 0x6a;
9509 usb_microdia_control_write(dev, 0x11b8, buf, 1);
9510
9511 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9512 usb_microdia_control_write(dev, 0x1000, buf, 3);
9513
9514 usb_microdia_control_read(dev, 0x1066, buf, 1);
9515
9516 return 0;
9517 }
9518
9519
9520 int microdia_624f_stop_stream(struct usb_microdia *dev)
9521 {
9522 int ret;
9523 __u16 command;
9524 __u8 buf[3];
9525
9526 buf[0] = 0x02;
9527 command = 0x1066;
9528 ret = usb_microdia_control_write(dev, command, buf, 1);
9529 if (ret < 0)
9530 goto err;
9531
9532 buf[0] = 0x01;
9533 command = 0x1061;
9534 ret = usb_microdia_control_write(dev, command, buf, 1);
9535 if (ret < 0)
9536 goto err;
9537
9538 buf[0] = 0x38;
9539 command = 0x1000;
9540 ret = usb_microdia_control_write(dev, command, buf, 1);
9541 if (ret < 0)
9542 goto err;
9543
9544 buf[0] = 0x6a;
9545 command = 0x11b8;
9546 ret = usb_microdia_control_write(dev, command, buf, 1);
9547 if (ret < 0)
9548 goto err;
9549
9550 buf[0] = 0x20;
9551 command = 0x1007;
9552 ret = usb_microdia_control_write(dev, command, buf, 1);
9553 if (ret < 0)
9554 goto err;
9555
9556 buf[0] = 0x20;
9557 command = 0x1006;
9558 ret = usb_microdia_control_write(dev, command, buf, 1);
9559 if (ret < 0)
9560 goto err;
9561
9562 buf[0] = 0x98;
9563 buf[1] = 0xe7;
9564 buf[2] = 0x11;
9565 command = 0x1000;
9566 ret = usb_microdia_control_write(dev, command, buf, 3);
9567 if (ret < 0)
9568 goto err;
9569
9570 command = 0x1045;
9571 ret = usb_microdia_control_read(dev, command, buf, 1);
9572 if (ret < 0)
9573 goto err;
9574
9575 buf[0] = 0x0f;
9576 ret = usb_microdia_control_write(dev, command, buf, 1);
9577 if (ret < 0)
9578 goto err;
9579
9580 return ret;
9581
9582 err:
9583 UDIA_ERROR("command %x failed (%d)!\n", command, ret);
9584 return ret;
9585 }
9586
9587 int microdia_6260_stop_stream(struct usb_microdia *dev)
9588 {
9589 int ret;
9590 __u8 buf[32];
9591
9592 buf[0] = 0x01;
9593 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
9594 buf[0] = 0x38;
9595 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
9596 buf[0] = 0x6b;
9597 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
9598 buf[0] = 0x20;
9599 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
9600 buf[0] = 0x20;
9601 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
9602
9603 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9604 ret = usb_microdia_control_write(dev, 0x1000, buf, 3);
9605
9606 buf[0] = 0x00;
9607 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
9608 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
9609 buf[0] = 0x0f;
9610 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
9611 buf[0] = 0x00;
9612 ret = usb_microdia_control_write(dev, 0x10c8, buf, 1);
9613 buf[0] = 0x80;
9614 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
9615
9616 return ret;
9617 }
9618
9619 /**
9620 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
9621 *
9622 * @param dev
9623 *
9624 * @returns 0 (ok) or -1 (error)
9625 *
9626 * @author Comer352l
9627 *
9628 * Windows driver version: 5.7.23.000
9629 * Windows versions: 2000 and XP
9630 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
9631 * All logs were made using AMCAP with 640x480, RGB24
9632 */
9633 int microdia_6270_stop_stream(struct usb_microdia *dev)
9634 {
9635 int ret = 0;
9636 int retI2C = 0;
9637 __u8 buf[3];
9638
9639 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
9640 buf[0] = 0x20;
9641 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
9642 buf[0] = 0x20;
9643 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
9644 /* => These two writes seem to cause the cam to stop sending isochronus USB messages */
9645 }
9646 buf[0] = 0x01;
9647 ret += usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 3544 */
9648 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
9649 buf[0] = 0x60;
9650 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
9651 buf[0] = 0x60;
9652 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
9653 }
9654 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
9655 /* Write to sensor register 0x07: Output Control */
9656 buf[0] = 0x00; buf[1] = 0x00; /* stop sensor readout, normal operation */
9657 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
9658 }
9659 buf[0] = 0x38; /* ALEX: 0x3c */
9660 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 3545 */
9661 buf[0] = 0x6d; /* ALEX: 0xec; FRANK: also 0x6c */
9662 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 3546 */
9663 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9664 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 3547 */
9665
9666 /* INTERRUPT COMMING BACK (URB 2227) */
9667 /* SELECT ALTERNATE SETTINGS (URB 3548) */
9668 /* INTERRUPT GOING DOWN (URB 3549) */
9669
9670 buf[0] = 0x00;
9671 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 3550 */
9672
9673 if (ret < 9) {
9674 UDIA_INFO("One ore more errors occured while stopping stream !\n");
9675 return -1;
9676 } else {
9677 return 0;
9678 }
9679 }
9680
9681 int microdia_627b_stop_stream(struct usb_microdia *dev)
9682 {
9683 int ret = 0;
9684 __u16 reg;
9685 __u8 buf[3];
9686
9687 reg = 0x1007;
9688 buf[0] = 0x60;
9689 ret = usb_microdia_control_write(dev, reg, buf, 1);
9690 if (ret < 0)
9691 goto err;
9692
9693 reg = 0x1006;
9694 buf[0] = 0x20;
9695 ret = usb_microdia_control_write(dev, reg, buf, 1);
9696 if (ret < 0)
9697 goto err;
9698
9699 /*
9700 //reg = 0x1007;
9701 //buf[0] = 0x60;
9702 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9703 //if(ret < 0) goto err;
9704
9705 //reg = 0x1006;
9706 //buf[0] = 0x20;
9707 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9708 //if(ret < 0) goto err;
9709 */
9710
9711 reg = 0x1061;
9712 buf[0] = 0x01;
9713 ret = usb_microdia_control_write(dev, reg, buf, 1);
9714 if (ret < 0)
9715 goto err;
9716
9717 /*
9718 //reg = 0x1007;
9719 //buf[0] = 0x60;
9720 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9721 //if(ret < 0) goto err;
9722
9723 //reg = 0x1006;
9724 //buf[0] = 0x20;
9725 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9726 //if(ret < 0) goto err;
9727 */
9728
9729 reg = 0x1000;
9730 buf[0] = 0x38;
9731 ret = usb_microdia_control_write(dev, reg, buf, 1);
9732 if (ret < 0)
9733 goto err;
9734
9735 reg = 0x11b8;
9736 buf[0] = 0x6b;
9737 ret = usb_microdia_control_write(dev, reg, buf, 1);
9738 if (ret < 0)
9739 goto err;
9740
9741 reg = 0x1000;
9742 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9743 ret = usb_microdia_control_write(dev, reg, buf, 3);
9744 if (ret < 0)
9745 goto err;
9746
9747 reg = 0x1066;
9748 buf[0] = 0x00;
9749 ret = usb_microdia_control_write(dev, reg, buf, 1);
9750 if (ret < 0)
9751 goto err;
9752
9753 return ret;
9754 err:
9755 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9756 return ret;
9757 }
9758
9759 /**
9760 * @brief From UsbSnoop-plugin-parsed.log
9761 *
9762 * @param dev
9763 *
9764 * @returns 0 (OK) or <0 (Error)
9765 *
9766 * @author Vincent, Kuzja
9767 */
9768 int microdia_6288_stop_stream(struct usb_microdia *dev)
9769 {
9770 int ret = 0;
9771 __u16 reg;
9772 __u8 buf[8];
9773
9774 reg = 0x1061 ;
9775 buf[0] = 0x01;
9776 ret = usb_microdia_control_write(dev, reg, buf, 1);
9777 if (ret < 0)
9778 goto err;
9779
9780 reg = 0x1000 ;
9781 buf[0] = 0x38;
9782 ret = usb_microdia_control_write(dev, reg, buf, 1);
9783 if (ret < 0)
9784 goto err;
9785
9786 reg = 0x11b8 ;
9787 buf[0] = 0xe9;
9788 ret = usb_microdia_control_write(dev, reg, buf, 1);
9789 if (ret < 0)
9790 goto err;
9791
9792 reg = 0x1007 ;
9793 buf[0] = 0x20;
9794 ret = usb_microdia_control_write(dev, reg, buf, 1);
9795 if (ret < 0)
9796 goto err;
9797
9798 reg = 0x1006 ;
9799 buf[0] = 0x20;
9800 ret = usb_microdia_control_write(dev, reg, buf, 1);
9801 if (ret < 0)
9802 goto err;
9803
9804 reg = 0x1000 ;
9805 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9806 ret = usb_microdia_control_write(dev, reg, buf, 3);
9807 if (ret < 0)
9808 goto err;
9809
9810 reg = 0x1066 ;
9811 buf[0] = 0x00;
9812 ret = usb_microdia_control_write(dev, reg, buf, 1);
9813 if (ret < 0)
9814 goto err;
9815
9816 return 0;
9817 err:
9818 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9819 return ret;
9820 }
9821
9822 int microdia_624f_flip_detect(struct usb_microdia *dev)
9823 {
9824 int ret = 0;
9825 __u8 val;
9826
9827 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
9828 if (ret < 0)
9829 return -EAGAIN;
9830 if (val & 0x01)
9831 dev->vsettings.vflip = 1;
9832 else
9833 dev->vsettings.vflip = 0;
9834 return ret;
9835 }
9836
9837 int microdia_6260_flip_detect(struct usb_microdia *dev)
9838 {
9839 const __u8 flip_bit = 0x01;
9840 int ret = 0;
9841 __u8 val;
9842 static __u8 flip_reg = flip_bit;
9843 __u8 vflip;
9844
9845 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
9846 if (ret < 0)
9847 return -EAGAIN;
9848 if (flip_reg != (val & flip_bit)) {
9849 if (val & flip_bit)
9850 vflip = 0;
9851 else
9852 vflip = 1;
9853 ret = ov7670_auto_flip(dev, vflip);
9854 flip_reg = (val & flip_bit);
9855 }
9856
9857 return ret;
9858 }
9859
Microdia : webcam kernel driver, for USB webcams with vendor id 0c45