?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support for hardware resolultion change
[microdia.git] / microdia-dev.c
blob78ac4a24a4061bb66b968098df6d21924889055b
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 {0x1061, 0x03},
3978 };
3979
3980 __u8 reg_11c0[48] = {
3981 0x10, 0x21, 0x34, 0x40, 0x47, 0x4f, 0x57, 0x5f,
3982 0x64, 0x68, 0x6d, 0x73, 0x79, 0x80, 0x89, 0x97,
3983 0x0d, 0x1c, 0x2a, 0x33, 0x38, 0x3d, 0x44, 0x4a,
3984 0x4e, 0x52, 0x56, 0x5b, 0x61, 0x68, 0x6f, 0x7a,
3985 0x0d, 0x1a, 0x2a, 0x31, 0x36, 0x3b, 0x41, 0x47,
3986 0x4a, 0x4e, 0x53, 0x58, 0x5d, 0x64, 0x6b, 0x76
3987 };
3988
3989 __u8 qtable1[64] = {
3990 0x0d, 0x08, 0x08, 0x0d, 0x08, 0x08, 0x0d, 0x0d,
3991 0x0d, 0x0d, 0x11, 0x0d, 0x0d, 0x11, 0x15, 0x21,
3992 0x15, 0x15, 0x11, 0x11, 0x15, 0x2a, 0x1d, 0x1d,
3993 0x19, 0x21, 0x32, 0x2a, 0x32, 0x32, 0x2e, 0x2a,
3994 0x2e, 0x2e, 0x36, 0x3a, 0x4b, 0x43, 0x36, 0x3a,
3995 0x47, 0x3a, 0x2e, 0x2e, 0x43, 0x5c, 0x43, 0x47,
3996 0x4f, 0x54, 0x58, 0x58, 0x58, 0x32, 0x3f, 0x60,
3997 0x64, 0x5c, 0x54, 0x64, 0x4b, 0x54, 0x58, 0x54
3998 };
3999
4000 __u8 qtable2[64] = {
4001 0x0d, 0x11, 0x11, 0x15, 0x11, 0x15, 0x26, 0x15,
4002 0x15, 0x26, 0x54, 0x36, 0x2e, 0x36, 0x54, 0x54,
4003 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4004 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4005 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4006 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4007 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
4008 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54
4009 };
4010
4011 for (i = 0; i < ARRAY_SIZE(regs); i++) {
4012 reg = regs[i][0];
4013 value = regs[i][1];
4014 ret = usb_microdia_control_write(dev, reg, &value, 1);
4015 if (ret < 0) {
4016 UDIA_INFO("Bridge Init Error (%d). line %d", ret, i);
4017 goto err;
4018 }
4019 }
4020
4021 ret = usb_microdia_control_write(dev, 0x11c0, reg_11c0, 48);
4022 if (ret < 0)
4023 goto err;
4024
4025 ret = usb_microdia_control_write(dev, 0x1100, qtable1, 64);
4026 if (ret < 0)
4027 goto err;
4028
4029 ret = usb_microdia_control_write(dev, 0x1140, qtable2, 64);
4030 if (ret < 0)
4031 goto err;
4032
4033 /* this is the same register as the I2C write, not sure why
4034 * we're writing 9 bytes -- the SN9C102 docs say all writes
4035 * must be 8 bytes, but we don't have docs for SN9C20x */
4036 ret = usb_microdia_control_write(dev, 0x10c0, unknown1, 9);
4037 if (ret < 0)
4038 goto err;
4039
4040 if (dev->sensor_init)
4041 dev->sensor_init(dev);
4042
4043 return 0;
4044
4045 err:
4046 UDIA_ERROR("start stream: failed (%d)!\n", ret);
4047 return ret;
4048 }
4049
4050 int microdia_6260_start_stream(struct usb_microdia *dev)
4051 {
4052 int ret;
4053 __u8 buf[32];
4054
4055 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
4056 buf[0] = 0x1f;
4057 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
4058 buf[0] = 0x00;
4059 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
4060 buf[0] = 0x20;
4061 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
4062 buf[0] = 0x00;
4063 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
4064 buf[0] = 0x78;
4065 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4066 buf[0] = 0xc7;
4067 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4068 buf[0] = 0x18;
4069 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4070 buf[0] = 0x01;
4071 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4072 buf[0] = 0x80;
4073 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
4074
4075 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10;
4076 buf[4] = 0x08;
4077 ret = usb_microdia_control_write(dev, 0x1067, buf, 5);
4078
4079 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
4080 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
4081 buf[8] = 0x03;
4082 ret = usb_microdia_control_write(dev, 0x10c0, buf, 9);
4083
4084 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
4085 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
4086 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
4087 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
4088 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
4089 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
4090 ret = usb_microdia_control_write(dev, 0x10e0, buf, 24);
4091
4092 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
4093 ret = usb_microdia_control_write(dev, 0x10f8, buf, 3);
4094
4095 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
4096 buf[4] = 0x00;
4097 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4098
4099 buf[0] = 0x8a; buf[1] = 0x8c; buf[2] = 0x08;
4100 ret = usb_microdia_control_write(dev, 0x1188, buf, 3);
4101
4102 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
4103 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
4104 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
4105 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
4106 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
4107 buf[20] = 0xf4; buf[21] = 0xff;
4108 ret = usb_microdia_control_write(dev, 0x118b, buf, 22);
4109
4110 buf[0] = 0x00; buf[1] = 0x00;
4111 ret = usb_microdia_control_write(dev, 0x11a1, buf, 2);
4112
4113 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x00;
4114 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
4115 buf[8] = 0x00;
4116 ret = usb_microdia_control_write(dev, 0x11b7, buf, 9);
4117
4118 buf[0] = 0x78;
4119 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4120
4121 buf[0] = 0x38;
4122 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4123
4124 ret = ov7670_initialise(dev);
4125 if (ret < 0)
4126 return ret;
4127
4128 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1, 0x3b, dev->sensor_flags, buf);
4129 ret = usb_microdia_control_read(dev, 0x10c1, buf, 1);
4130 buf[0] = 0x50;
4131 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
4132
4133 /* TRY TO READ FROM EEPROM: */
4134 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, dev->sensor_flags, buf);
4135 if (ret < 0)
4136 UDIA_INFO("No EEPROM found\n");
4137 else
4138 UDIA_INFO("Read from EEPROM successful\n");
4139
4140 buf[0] = 0x21;
4141 ret = usb_microdia_control_write(dev, 0x10c1, buf, 1);
4142 buf[0] = 0x45;
4143 ret = usb_microdia_control_write(dev, 0x10e0, buf, 1);
4144 buf[0] = 0xc6;
4145 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4146 buf[0] = 0xc4;
4147 ret = usb_microdia_control_write(dev, 0x1001, buf, 1);
4148
4149 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
4150 buf[4] = 0x50; buf[5] = 0x3c;
4151 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
4152
4153 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
4154 buf[4] = 0x01;
4155 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4156
4157 buf[0] = 0x80;
4158 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
4159
4160 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
4161 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
4162
4163 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
4164 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
4165 buf[0] = 0x78;
4166 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4167 buf[0] = 0x10;
4168 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4169 buf[0] = 0x00;
4170 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4171 buf[0] = 0x38;
4172 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4173 buf[0] = 0x04;
4174 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
4175 buf[0] = 0x04;
4176 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
4177 buf[0] = 0x78;
4178 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4179 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4180 buf[0] = 0xf9;
4181 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4182 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4183 buf[0] = 0xfa;
4184 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4185 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4186 buf[0] = 0x7b;
4187 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4188 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4189 buf[0] = 0x7c;
4190 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4191 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4192 buf[0] = 0x7d;
4193 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4194 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4195 buf[0] = 0x7b;
4196 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4197
4198 /* OV7670 Intialise Part 2 */
4199 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
4200 buf[4] = 0x50; buf[5] = 0x3c;
4201 ret = usb_microdia_control_write(dev, 0x1180, buf, 6);
4202
4203 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x00; buf[3] = 0xf0;
4204 buf[4] = 0x01;
4205 ret = usb_microdia_control_write(dev, 0x10fb, buf, 5);
4206
4207 buf[0] = 0x80;
4208 ret = usb_microdia_control_write(dev, 0x1189, buf, 1);
4209
4210 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0x50;
4211 ret = usb_microdia_control_write(dev, 0x11a1, buf, 4);
4212
4213 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x3c;
4214 ret = usb_microdia_control_write(dev, 0x11ab, buf, 4);
4215
4216 buf[0] = 0x03;
4217 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4218 buf[0] = 0x01;
4219 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4220 buf[0] = 0x78;
4221 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
4222 buf[0] = 0x00;
4223 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4224 buf[0] = 0x00;
4225 ret = usb_microdia_control_write(dev, 0x1002, buf, 1);
4226 buf[0] = 0x7b;
4227 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4228 buf[0] = 0x04;
4229 ret = usb_microdia_control_write(dev, 0x118a, buf, 1);
4230 buf[0] = 0x04;
4231 ret = usb_microdia_control_write(dev, 0x0395, buf, 1);
4232 buf[0] = 0x78;
4233 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4234 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4235 buf[0] = 0x79;
4236 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4237 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4238 buf[0] = 0x7a;
4239 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4240 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4241 buf[0] = 0x7b;
4242 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4243 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4244 buf[0] = 0x7c;
4245 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4246 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4247 buf[0] = 0x7d;
4248 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4249 ret = usb_microdia_control_read(dev, 0x11b8, buf, 1);
4250 buf[0] = 0xfa;
4251 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
4252
4253 /* OV7670 Initialisation Part 3 Goes Here */
4254 buf[0] = 0x03;
4255 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
4256
4257 return ret;
4258 }
4259
4260 /**
4261 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
4262 *
4263 * @param dev
4264 *
4265 * @returns 0 (ok) or -1 (error)
4266 *
4267 * @author Comer352l
4268 *
4269 * Windows driver versions: 5.7.23.000
4270 * Windows versions: 2000 and XP
4271 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
4272 * All logs were made using AMCAP with 640x480, RGB24
4273 */
4274 int microdia_6270_start_stream(struct usb_microdia *dev)
4275 {
4276 __u8 buf[64];
4277 __u8 last_11b8[1];
4278 int k;
4279 int retI2C;
4280
4281 /* Check if sensor slave address is valid: */
4282 if ((dev->sensor_slave_address != MT9V111_I2C_SLAVE_ADDRESS) && (dev->sensor_slave_address != MT9V011_I2C_SLAVE_ADDRESS)) {
4283 UDIA_INFO("microdia_6270_start_stream(): Invalid sensor slave address !\n");
4284 return -1;
4285 }
4286
4287 /* <= INTERRUPT COMING BACK (URB 1953) */
4288 /* SWITCH TO ALTERNATE SETTINGS 8 (URB 1954) // NOT IN ALEX'S LOG */
4289 /* => INTERRUPT GOING DOWN (URB 1955) */
4290
4291 buf[0] = 0x00;
4292 usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 1956 */
4293
4294 /* <= INTERRUPT COMING BACK (URB 1955) */
4295 /* => INTERRUPT GOING DOWN (URB 1957) */
4296
4297 buf[0] = 0x78;
4298 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1958 */
4299 buf[0] = 0xc7;
4300 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 1959 */
4301 buf[0] = 0x18;
4302 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 1960 */
4303 buf[0] = 0x01;
4304 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 1961 */
4305 buf[0] = 0x80;
4306 usb_microdia_control_write(dev, 0x1020, buf, 1); /* URB 1962 */
4307 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
4308 usb_microdia_control_write(dev, 0x1067, buf, 5); /* URB 1963 */
4309
4310 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4311 /* STRANGE I2C MESSAGE: */
4312 /* - 9 bytes */
4313 /* - byte 8 = 0x00 at first start + first cycle */
4314 /* - procedure not complete: no wait/check for ack/error, no readout of 0x10c2 */
4315 /* - dummy writes at first cycle and read at second cycle, but there are many I2C messages in the meantime, so this should not work */
4316 /* */
4317 /* AT FIRST START + FIRST CYCLE: */
4318 buf[0] = 0x80; buf[1] = dev->sensor_slave_address; buf[2] = 0x00; buf[3] = 0x00;
4319 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x03;
4320 /* AT ALL FURTHER STARTS + FIRST CYCLE: */
4321 /* MT9V111: I2C MESSAGE => IFP Register 0x33: Auto exposure */
4322 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x33; buf[3] = 0x00; */
4323 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4324 /* MT9V011: ????????????????????????? */
4325 /* buf[0] = 0x90; buf[1] = dev->sensor_slave_address; buf[2] = 0x07; buf[3] = 0x00; */
4326 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4327 /* ALWAYS AT 2nd AND FURTHER CYCLES: */
4328 /* MT9V111: */
4329 /* buf[0] = 0xa2; buf[1] = 0x5c; buf[2] = 0x00; buf[3] = 0x36; */
4330 /* buf[4] = 0x00; buf[5] = 0x82; buf[6] = 0x3a; buf[7] = 0x10; buf[8] = 0x03; */
4331 /* => buf[3] to buf[6] simply contain bytes read with URB 2215 */
4332 /* MT9V011: */
4333 /* buf[0] = 0xb0; buf[1] = 0x5d; buf[2] = 0x07; buf[3] = 0x00; */
4334 /* buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10; buf[8] = 0x03; */
4335 usb_microdia_control_write(dev, 0x10c0, buf, 9); /* URB 1964 */
4336 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4337
4338 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
4339 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
4340 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
4341 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
4342 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
4343 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
4344 usb_microdia_control_write(dev, 0x10e0, buf, 24); /* URB 1965 */
4345 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
4346 usb_microdia_control_write(dev, 0x10f8, buf, 3); /* URB 1966 */
4347 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
4348 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 1967 */
4349 buf[0] = 0x06; buf[1] = 0x0c; buf[2] = 0x08;
4350 usb_microdia_control_write(dev, 0x1188, buf, 3); /* URB 1968 */
4351 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
4352 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
4353 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
4354 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
4355 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
4356 buf[20] = 0xf4; buf[21] = 0xff;
4357 usb_microdia_control_write(dev, 0x118b, buf, 22); /* URB 1969 */
4358 buf[0] = 0x00; buf[1] = 0x00;
4359 usb_microdia_control_write(dev, 0x11a1, buf, 2); /* URB 1970 */
4360 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08;
4361 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
4362 buf[8] = 0x00;
4363 usb_microdia_control_write(dev, 0x11b7, buf, 9); /* URB 1971 */
4364 buf[0] = 0x38;
4365 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 1972 */
4366 buf[0] = 0x78;
4367 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 1973 */
4368
4369 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4370 /* I2C MESSAGES */
4371 retI2C = 0;
4372 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4373 /* Write to IFP register 0x0d: Color Correction Register 8 */
4374 buf[0] = 0x00; buf[1] = 0x01;
4375 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1974-1976 */
4376 /* Write to IFP register 0x0d: Color Correction Register 8 */
4377 buf[0] = 0x00; buf[1] = 0x00; /* ??? */
4378 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf); /* URBs 1977-1979 */
4379 /* Writes to IFP registers 0x01: Register Address Space Selection */
4380 /* 0x02: Color Correction Register 1 */
4381 buf[0] = 0x00; buf[1] = 0x01; /* select IFP address space */
4382 buf[2] = 0x00; buf[3] = 0x16; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4383 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1980-1982 */
4384 /* Writes to IFP registers 0x03: Color Correction Register 3 */
4385 /* 0x04: Color Correction Register 4 */
4386 buf[0] = 0x01; buf[1] = 0xe1; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4387 buf[2] = 0x02; buf[3] = 0x81; /* ??? // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4388 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1983-1985 */
4389 /* Writes to IFP registers 0x05: Aperture Correction (Sharpening) */
4390 /* 0x06: Operating Mode Control */
4391 buf[0] = 0x00; buf[1] = 0x04; /* 100% sharpening, no automatic sharpness reduction at low light // AT FIRST START + FIRST CYCLE: 0x00 0x00: no sharpening */
4392 buf[2] = 0x00; buf[3] = 0x00; /* stop AWB at the current values, no on-the-fly defect correction, no auto exposure, + RESREVED option */
4393 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 1986-1988 */
4394 /* Writes to IFP registers 0x07: Image Flow Processor Soft Reset */
4395 /* 0x08: Output Format Control */
4396 buf[0] = 0x30; buf[1] = 0x02; /* reset // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4397 buf[2] = 0x04; buf[3] = 0x80; /* bypass entire image processing, raw 8+2 Bayer data output directly */
4398 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 1989-1991 */
4399 /* "Dummy" write to IFP Register 0x11: Color Correction Register 12 */
4400 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 1992-1993 */
4401 /* Write to register 0x01: Register address space selection */
4402 /* Write to sensor register 0x02: Column Start */
4403 buf[0] = 0x00; buf[1] = 0x04; /* select sensor address space */
4404 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
4405 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf); /* URBs 1994-1996 */
4406 /* Writes to sensor registers 0x03: Window Height */
4407 /* 0x04: Window Width */
4408 buf[0] = 0x01; buf[1] = 0xe6; /* 486 */
4409 buf[2] = 0x02; buf[3] = 0x86; /* 646 */
4410 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf); /* URBs 1997-1999 */
4411 /* Writes to sensor registers 0x05: Horizontal Blanking */
4412 /* 0x06: Vertical Blanking */
4413 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4414 buf[2] = 0x00; buf[3] = 0x00; /* 0 rows */
4415 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf); /* URBs 2000-2002 */
4416 /* Writes to sensor registers 0x07: Output Control */
4417 /* 0x08: Row Start */
4418 buf[0] = 0x30; buf[1] = 0x02; /* normal operation + chip enable + RESERVED options */
4419 buf[2] = 0x00; buf[3] = 0x08; /* row 8 */
4420 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x07, dev->sensor_flags, buf); /* URBs 2003-2005 */
4421 /* "Dummy" write to sensor Register 0x11: UNDOCUMENTED */
4422 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x11, dev->sensor_flags, NULL); /* URBs 2006-2007 */
4423 /* Writes to sensor registers 0x0c: Shutter Delay */
4424 /* 0x0d: Reset (Soft) (from MT9V011 datasheet) */
4425 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
4426 buf[2] = 0x00; buf[3] = 0x00; /* return to normal operation */
4427 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf); /* URBs 2008-2010 */
4428 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
4429 /* 0x0f: UNDOCUMENTED */
4430 buf[0] = 0x00; buf[1] = 0x00;
4431 buf[2] = 0x00; buf[3] = 0x00;
4432 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf); /* URBs 2011-2013 */
4433 /* Writes to sensor registers 0x10: UNDOCUMENTED */
4434 /* 0x11: UNDOCUMENTED */
4435 buf[0] = 0x00; buf[1] = 0x00;
4436 buf[2] = 0x00; buf[3] = 0x00;
4437 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf); /* URBs 2014-2016 */
4438 /* Writes to sensor registers 0x12: 2X Zoom Col Start => 0x1e bit 0 must be set to activate zoom */
4439 /* 0x13: 2X Zoom Row Start => 0x1e bit 0 must be set to activate zoom */
4440 buf[0] = 0x00; buf[1] = 0xb0; /* column 176 */
4441 buf[2] = 0x00; buf[3] = 0x7c; /* row 124 */
4442 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf); /* URBs 2017-2018 */
4443 /* Writes to sensor registers 0x14: UNDOCUMENTED */
4444 /* 0x15: UNDOCUMENTED */
4445 buf[0] = 0x00; buf[1] = 0x00;
4446 buf[2] = 0x00; buf[3] = 0x00;
4447 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf); /* URBs 2019-2021 */
4448 /* Writes to sensor registers 0x16: UNDOCUMENTED */
4449 /* 0x17: UNDOCUMENTED */
4450 buf[0] = 0x00; buf[1] = 0x00;
4451 buf[2] = 0x00; buf[3] = 0x00;
4452 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf); /* URBs 2022-2024 */
4453 /* Writes to sensor registers 0x18: UNDOCUMENTED */
4454 /* 0x19: UNDOCUMENTED */
4455 buf[0] = 0x00; buf[1] = 0x00;
4456 buf[2] = 0x00; buf[3] = 0x00;
4457 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf); /* URBs 2025-2027 */
4458 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
4459 /* 0x1b: UNDOCUMENTED */
4460 buf[0] = 0x00; buf[1] = 0x00;
4461 buf[2] = 0x00; buf[3] = 0x00;
4462 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf); /* URBs 2028-2030 */
4463 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
4464 /* 0x1d: UNDOCUMENTED */
4465 buf[0] = 0x00; buf[1] = 0x00;
4466 buf[2] = 0x00; buf[3] = 0x00;
4467 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf); /* URBs 2031-2033 */
4468 /* Write to sensor register 0x30: RESERVED */
4469 buf[0] = 0x00; buf[1] = 0x00;
4470 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x30, dev->sensor_flags, buf); /* URBs 2034-2036 */
4471 /* Write to sensor register 0x20: Read Mode */
4472 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4473 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2037-2039 */
4474 /* Writes to sensor registers 0x30: RESERVED */
4475 /* 0x31: RESERVED */
4476 buf[0] = 0x00; buf[1] = 0x05;
4477 buf[2] = 0x00; buf[3] = 0x00;
4478 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x30, dev->sensor_flags, buf); /* URBs 2040-2042 */
4479 /* "Dummy" write to sensor Register 0x34: RESERVED */
4480 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x34, dev->sensor_flags, NULL); /* URBs 2043-2044 */
4481 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4482 /* Write to sensor register 0x07: Output Control */
4483 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
4484 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4485 /* Write to sensor register 0x0d: Soft Reset */
4486 buf[0] = 0x00; buf[1] = 0x01; /* reset */
4487 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4488 /* Write to sensor register 0x0d: Soft Reset */
4489 buf[0] = 0x00; buf[1] = 0x00; /* resume operation */
4490 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4491 /* Writes to sensor registers 0x01: Row start */
4492 /* 0x02: Column Start */
4493 buf[0] = 0x00; buf[1] = 0x08; /* start with row 8 */
4494 buf[2] = 0x00; buf[3] = 0x16; /* start with column 22 */
4495 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x01, dev->sensor_flags, buf);
4496 /* Writes to sensor registers 0x03: Window Height */
4497 /* 0x04: Window Width */
4498 buf[0] = 0x01; buf[1] = 0xe1; /* 481 */
4499 buf[2] = 0x02; buf[3] = 0x81; /* 641 */
4500 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x03, dev->sensor_flags, buf);
4501 /* Writes to sensor registers 0x05: Horizontal Blanking */
4502 /* 0x06: Vertical Blanking */
4503 buf[0] = 0x00; buf[1] = 0x83; /* 131 columns (pixel clocks) */
4504 buf[2] = 0x00; buf[3] = 0x06; /* 6 rows */
4505 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x05, dev->sensor_flags, buf);
4506 /* Write to sensor register 0x0d: Soft Reset */
4507 buf[0] = 0x00; buf[1] = 0x02; /* UNKNOWN */
4508 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0d, dev->sensor_flags, buf);
4509 /* Writes to sensor registers 0x0a: Pixel Clock Speed */
4510 /* 0x0b: Frame Restart */
4511 buf[0] = 0x00; buf[1] = 0x00; /* default */
4512 buf[2] = 0x00; buf[3] = 0x00; /* (has no effect/no restart) */
4513 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0a, dev->sensor_flags, buf);
4514 /* Writes to sensor registers 0x0c: Shutter Delay */
4515 /* 0x0d: Soft Reset */
4516 buf[0] = 0x00; buf[1] = 0x00; /* 0 master clocks */
4517 buf[2] = 0x00; buf[3] = 0x00; /* resume operation */
4518 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0c, dev->sensor_flags, buf);
4519 /* Writes to sensor registers 0x0e: UNDOCUMENTED */
4520 /* 0x0f: UNDOCUMENTED */
4521 buf[0] = 0x00; buf[1] = 0x00;
4522 buf[2] = 0x00; buf[3] = 0x00;
4523 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x0e, dev->sensor_flags, buf);
4524 /* Writes to sensor registers 0x10: UNDOCUMENTED */
4525 /* 0x11: UNDOCUMENTED */
4526 buf[0] = 0x00; buf[1] = 0x00;
4527 buf[2] = 0x00; buf[3] = 0x00;
4528 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x10, dev->sensor_flags, buf);
4529 /* Writes to sensor registers 0x12: 2X Zoom Column Start (from MT9V111 datasheet) */
4530 /* 0x13: 2X Zoom Row Start (from MT9V111 datasheet) */
4531 buf[0] = 0x00; buf[1] = 0x00; /* column 0 => bit0 of reg 0x1e must be set to activate zoom */
4532 buf[2] = 0x00; buf[3] = 0x00; /* row 0 => bit0 of reg 0x1e must be set to activate zoom */
4533 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x12, dev->sensor_flags, buf);
4534 /* Writes to sensor registers 0x14: UNDOCUMENTED */
4535 /* 0x15: UNDOCUMENTED */
4536 buf[0] = 0x00; buf[1] = 0x00;
4537 buf[2] = 0x00; buf[3] = 0x00;
4538 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x14, dev->sensor_flags, buf);
4539 /* Writes to sensor registers 0x16: UNDOCUMENTED */
4540 /* 0x17: UNDOCUMENTED */
4541 buf[0] = 0x00; buf[1] = 0x00;
4542 buf[2] = 0x00; buf[3] = 0x00;
4543 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x16, dev->sensor_flags, buf);
4544 /* Writes to sensor registers 0x18: UNDOCUMENTED */
4545 /* 0x19: UNDOCUMENTED */
4546 buf[0] = 0x00; buf[1] = 0x00;
4547 buf[2] = 0x00; buf[3] = 0x00;
4548 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x18, dev->sensor_flags, buf);
4549 /* Writes to sensor registers 0x1a: UNDOCUMENTED */
4550 /* 0x1b: UNDOCUMENTED */
4551 buf[0] = 0x00; buf[1] = 0x00;
4552 buf[2] = 0x00; buf[3] = 0x00;
4553 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1a, dev->sensor_flags, buf);
4554 /* Writes to sensor registers 0x1c: UNDOCUMENTED */
4555 /* 0x1d: UNDOCUMENTED */
4556 buf[0] = 0x00; buf[1] = 0x00;
4557 buf[2] = 0x00; buf[3] = 0x00;
4558 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x1c, dev->sensor_flags, buf);
4559 /* Write to sensor register 0x32: RESERVED */
4560 buf[0] = 0x00; buf[1] = 0x00;
4561 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x32, dev->sensor_flags, buf);
4562 /* Writes to sensor registers 0x20: Read Mode */
4563 /* 0x21: RESERVED */
4564 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad frames) + UNDOCUMENTED */
4565 buf[2] = 0x00; buf[3] = 0x00;
4566 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x20, dev->sensor_flags, buf);
4567 /* Writes to sensor registers 0x22: RESERVED */
4568 /* 0x23: UNDOCUMENTED */
4569 buf[0] = 0x00; buf[1] = 0x00;
4570 buf[2] = 0x00; buf[3] = 0x00;
4571 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x22, dev->sensor_flags, buf);
4572 /* Writes to sensor registers 0x24: UNDOCUMENTED */
4573 /* 0x25: UNDOCUMENTED */
4574 buf[0] = 0x00; buf[1] = 0x00;
4575 buf[2] = 0x00; buf[3] = 0x00;
4576 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x24, dev->sensor_flags, buf);
4577 /* Writes to sensor registers 0x26: UNDOCUMENTED */
4578 /* 0x27: RESERVED */
4579 buf[0] = 0x00; buf[1] = 0x00;
4580 buf[2] = 0x00; buf[3] = 0x24;
4581 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x26, dev->sensor_flags, buf);
4582 /* "Dummy" write to sensor Register 0x30: RESERVED */
4583 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x30, dev->sensor_flags, NULL);
4584 /* Writes to sensor registers 0x2f: RESERVED */
4585 /* 0x30: RESERVED */
4586 buf[0] = 0xf7; buf[1] = 0xb0;
4587 buf[2] = 0x00; buf[3] = 0x05;
4588 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2f, dev->sensor_flags, buf);
4589 /* Writes to sensor registers 0x31: RESERVED */
4590 /* 0x32: RESERVED */
4591 buf[0] = 0x00; buf[1] = 0x00;
4592 buf[2] = 0x00; buf[3] = 0x00;
4593 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x31, dev->sensor_flags, buf);
4594 /* Writes to sensor registers 0x33: RESERVED */
4595 /* 0x34: RESERVED */
4596 buf[0] = 0x00; buf[1] = 0x00;
4597 buf[2] = 0x01; buf[3] = 0x00;
4598 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x33, dev->sensor_flags, buf);
4599 /* "Dummy" write to sensor Register 0x3b: RESERVED */
4600 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x3b, dev->sensor_flags, NULL);
4601 /* Write to sensor register 0x3d: RESERVED */
4602 buf[0] = 0x06; buf[1] = 0x8f;
4603 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x3d, dev->sensor_flags, buf);
4604 /* Writes to sensor registers 0x40: RESERVED */
4605 /* 0x41: RESERVED */
4606 buf[0] = 0x01; buf[1] = 0xe0;
4607 buf[2] = 0x00; buf[3] = 0xd1;
4608 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x40, dev->sensor_flags, buf);
4609 /* Write to sensor register 0x44: UNDOCUMENTED */
4610 buf[0] = 0x00; buf[1] = 0x82;
4611 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x44, dev->sensor_flags, buf);
4612 /* Writes to sensor registers 0x5a: RESERVED */
4613 /* 0x5b: RESERVED */
4614 buf[0] = 0x00; buf[1] = 0x00;
4615 buf[2] = 0x00; buf[3] = 0x00;
4616 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5a, dev->sensor_flags, buf);
4617 /* Writes to sensor registers 0x5c: RESERVED */
4618 /* 0x5d: RESERVED */
4619 buf[0] = 0x00; buf[1] = 0x00;
4620 buf[2] = 0x00; buf[3] = 0x00;
4621 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5c, dev->sensor_flags, buf);
4622 /* Writes to sensor registers 0x5e: RESERVED */
4623 /* 0x5f: RESERVED */
4624 buf[0] = 0x00; buf[1] = 0x00;
4625 buf[2] = 0xa3; buf[3] = 0x1d;
4626 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x5e, dev->sensor_flags, buf);
4627 /* "Dummy" write to sensor Register 0x68: UNDOCUMENTED */
4628 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x68, dev->sensor_flags, NULL);
4629 /* Write to sensor register 0x62: RESERVED */
4630 buf[0] = 0x06; buf[1] = 0x11;
4631 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x62, dev->sensor_flags, buf);
4632 }
4633 if (retI2C < 0) {
4634 UDIA_INFO("1 or more errors occured in I2C-message-block 1 !\n");
4635 return -1;
4636 }
4637 /* END OF I2C MESSAGES */
4638 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4639
4640 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4641 buf[0] = 0x40;
4642 usb_microdia_control_write(dev, 0x1007, buf, 8);
4643 buf[0] = 0x40;
4644 usb_microdia_control_write(dev, 0x1006, buf, 8);
4645 }
4646
4647
4648 /* *** TEMPORARY SWITCH TO SLAVE ADDRESS 0x50, I2C READ ATTEMPT: */
4649 /* - WE CURRENTLY KNOW NO 6270 CAM THAT IS SUCCESSFULLY READ HERE */
4650 /* - IF READ FAILS, THIS IS NEVER DONE AGAIN (IN NEXT CYCLE OR FURTHER STARTS) */
4651 usb_microdia_control_read(dev, 0x10c1, buf, 1); /* returns 0x5c */
4652 buf[0] = 0x50;
4653 usb_microdia_control_write(dev, 0x10c1, buf, 1);
4654 retI2C = sn9c20x_read_i2c_data(dev, 0x50, 1, 0x00, SN9C20X_I2C_2WIRE, buf);
4655 if (retI2C >= 0)
4656 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");
4657 buf[0] = 0x5c;
4658 usb_microdia_control_write(dev, 0x10c1, buf, 1);
4659
4660
4661 buf[0] = 0x47; /* ALEX: 0x44 */
4662 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2045 */
4663 buf[0] = 0x47; /* ALEX: 0x04 */
4664 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2046 */
4665 buf[0] = 0xc6;
4666 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2047 */
4667 buf[0] = 0xc4;
4668 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2048 */
4669 buf[0] = 0x84; /* ALEX: 0xc0 */
4670 usb_microdia_control_write(dev, 0x1001, buf, 1); /* URB 2049 */
4671 /* ALEX:
4672 buf[0] = 0x40;
4673 usb_microdia_control_write(dev, 0x1001, buf, 1);
4674 */
4675
4676 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4677 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4678 /* I2C MESSAGES */
4679 retI2C = 0;
4680 /* Writes to sensor registers 0x02: Column Start */
4681 /* 0x03: Window Height */
4682 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
4683 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
4684 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2050-2052 */
4685 /* Writes to sensor registers 0x04: Window Width */
4686 /* 0x05: Horizontal Blanking */
4687 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
4688 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) // AT FIRST START + FIRST CYCLE: 0x00 0x00 */
4689 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2053-2055 */
4690 /* Writes to sensor registers 0x06: Vertical Blanking */
4691 /* 0x07: Output Control */
4692 buf[0] = 0x00; buf[1] = 0x00; /* 0 rows */
4693 buf[2] = 0x30; buf[3] = 0x02; /* normal operation + chip enable + RESERVED options */
4694 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2056-2058 */
4695 /* Write to sensor register 0x0e: UNDOCUMENTED */
4696 buf[0] = 0x00; buf[1] = 0x08;
4697 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2059-2061 */
4698 if (retI2C < 0) {
4699 UDIA_INFO("1 or more errors occured in I2C-message-block 2 !\n");
4700 return -1;
4701 }
4702 /* END OF I2C MESSAGES */
4703 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4704 }
4705
4706 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
4707 buf[4] = 0x28; buf[5] = 0x3c;
4708 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2062 */
4709 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
4710 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2063 */
4711 buf[0] = 0x0c;
4712 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2064 */
4713 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
4714 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2065 */
4715 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
4716 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2066 */
4717 buf[0] = 0x78; /* ALEX: 0x7c */
4718 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2067 */
4719 buf[0] = 0x18; /* ALEX: 0x1c */
4720 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2068 */
4721 buf[0] = 0x18; /* ALEX: 0x1c */
4722 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2069 */
4723 buf[0] = 0x38;
4724 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2070 */
4725 buf[0] = 0x04;
4726 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2071 */
4727 buf[0] = 0x04;
4728 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2072 */
4729
4730 buf[0] = 0x78;
4731 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2073 */
4732 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2074 // 0x38 */
4733 if (buf[0] == 0x38)
4734 buf[0] = 0x79;
4735 else if (buf[0] == 0xb8)
4736 buf[0] = 0xf9;
4737 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2075 */
4738 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2076 // 0xb9 */
4739 if (buf[0] == 0x39)
4740 buf[0] = 0x7a;
4741 else if (buf[0] == 0xb9)
4742 buf[0] = 0xfa;
4743 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2077 */
4744 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2078 */
4745 if (buf[0] == 0x3a)
4746 buf[0] = 0x7b;
4747 else if (buf[0] == 0xba)
4748 buf[0] = 0xfb;
4749 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2079 */
4750 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2080 // 0x3b */
4751 if (buf[0] == 0x3b)
4752 buf[0] = 0x7c;
4753 else if (buf[0] == 0xbb)
4754 buf[0] = 0xfc;
4755 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2081 */
4756 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2082 // 0x3c */
4757 if (buf[0] == 0x3c)
4758 buf[0] = 0x7d;
4759 else if (buf[0] == 0xbc)
4760 buf[0] = 0xfd;
4761 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2083 */
4762 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2084 // 0x3d */
4763 last_11b8[0] = buf[0];
4764 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4765 if (buf[0] == 0x3d)
4766 buf[0] = 0x7e;
4767 else if (buf[0] == 0xbd)
4768 buf[0] = 0xfe;
4769 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2085 */
4770 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2086 */
4771 if (buf[0] == 0x3e)
4772 buf[0] = 0x7f;
4773 else if (buf[0] == 0xbe)
4774 buf[0] = 0xff;
4775 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2087 */
4776 usb_microdia_control_read(dev, 0x11b8, last_11b8, 1); /* URB 2088 */
4777 }
4778 buf[0] = last_11b8[0] & 0xf0; /* 0xf0 or 0x70 */
4779 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
4780 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
4781
4782
4783 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4784 /* I2C MESSAGES */
4785 retI2C = 0;
4786 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4787 /* Write to sensor register 0x06: Vertical Blanking */
4788 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
4789 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2090-2092 */
4790 /* Write to sensor register 0x05: Horizontal Blanking */
4791 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
4792 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2093-2095 */
4793 /* Write to sensor register 0x20: Read Mode */
4794 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4795 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2096-2098 */
4796 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4797 /* Write to sensor register 0x0a: Pixel Clock Speed */
4798 buf[0] = 0x00; buf[1] = 0x00; /* default */
4799 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0a, dev->sensor_flags, buf);
4800 /* Write to sensor register 0x06: Vertical Blanking */
4801 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
4802 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
4803 /* Write to sensor register 0x05: Horizontal Blanking */
4804 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
4805 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
4806 /* Write to sensor register 0x20: Read Mode */
4807 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
4808 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
4809 }
4810 if (retI2C < 0) {
4811 UDIA_INFO("1 or more errors occured in I2C-message-block 3 !\n");
4812 return -1;
4813 }
4814 /* END OF I2C MESSAGES */
4815 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4816
4817
4818 buf[0] = 0x02;
4819 usb_microdia_control_write(dev, 0x1180, buf, 1); /* URB 2099 */
4820
4821 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4822 /* I2C MESSAGE */
4823 retI2C = 0;
4824 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4825 /* Write to sensor register 0x20: Read Mode */
4826 buf[0] = 0x00; buf[1] = 0x00; /* normal readout */
4827 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf); /* URBs 2100-2102 */
4828 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4829 /* Write to sensor register 0x20: Read Mode */
4830 buf[0] = 0x11; buf[1] = 0x01; /* output all frames (including bad ones) + UNKNOWN */
4831 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x20, dev->sensor_flags, buf);
4832 }
4833 if (retI2C < 0) {
4834 UDIA_INFO("1 or more errors occured in I2C-message-block 4 !\n");
4835 return -1;
4836 }
4837 /* END OF I2C MESSAGES */
4838 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4839
4840
4841 buf[0] = 0x02;
4842 usb_microdia_control_write(dev, 0x1182, buf, 1); /* URB 2103 */
4843
4844
4845 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4846 /* I2C MESSAGES */
4847 retI2C = 0;
4848 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4849 /* Write to sensor register 0x09: Shutter Width */
4850 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
4851 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf); /* URBs 2104-2106 */
4852 /* Write to sensor register 0x2b: Green 1 Gain */
4853 /* 0x2c: Blue Gain */
4854 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4855 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4856 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf); /* URBs 2107-2109 */
4857 /* Write to sensor register 0x2d: Red Gain */
4858 /* 0x2e: Green 2 Gain */
4859 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4860 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4861 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf); /* URBs 2110-2112 */
4862 /* "Dummy" write to sensor Register 0x33: RESERVED */
4863 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL); /* URBs 2113-2114 */
4864 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4865 /* Write to sensor register 0x09: Shutter Width */
4866 buf[0] = 0x00; buf[1] = 0x64; /* integration of 100 rows */
4867 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x09, dev->sensor_flags, buf);
4868 /* Write to sensor register 0x07: Output Control */
4869 buf[0] = 0x00; buf[1] = 0x03; /* dont update changes until bit0=0, chip enable, normal operation */
4870 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4871 /* Write to sensor register 0x2b: Green 1 Gain */
4872 /* 0x2c: Blue Gain */
4873 buf[0] = 0x00; buf[1] = 0x33; /* 51*0.03125*1 = 1.59375 */
4874 buf[2] = 0x00; buf[3] = 0xa0; /* 32*0.03125*2 = 2 */
4875 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2b, dev->sensor_flags, buf);
4876 /* Write to sensor register 0x2d: Red Gain */
4877 /* 0x2e: Green 2 Gain */
4878 buf[0] = 0x00; buf[1] = 0xa0; /* 32*0.03125*2 = 2 */
4879 buf[2] = 0x00; buf[3] = 0x33; /* 51*0.03125*1 = 1.59375 */
4880 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x2d, dev->sensor_flags, buf);
4881 /* "Dummy" write to sensor Register 0x33: RESERVED */
4882 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0, 0x33, dev->sensor_flags, NULL);
4883 /* Write to sensor register 0x07: Output Control */
4884 buf[0] = 0x00; buf[1] = 0x02; /* chip enable, normal operation */
4885 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
4886 }
4887 if (retI2C < 0) {
4888 UDIA_INFO("1 or more errors occured in I2C-message-block 5 !\n");
4889 return -1;
4890 }
4891 /* END OF I2C MESSAGES */
4892 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4893
4894 buf[0] = 0x0a;
4895 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2119 */
4896
4897 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4898 buf[0] = 0x14;
4899 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4900 buf[0] = 0x0a;
4901 usb_microdia_control_write(dev, 0x118b, buf, 1); /* URB 2124 */
4902
4903 buf[0] = 0x07;
4904 usb_microdia_control_write(dev, 0x10f7, buf, 1); /* URB 2135 */
4905
4906 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4907 buf[0] = 0x01;
4908 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4909 buf[0] = 0x14;
4910 usb_microdia_control_write(dev, 0x10f8, buf, 1); /* URB 2138 */
4911
4912 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
4913 buf[0] = 0x0a;
4914 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
4915 buf[0] = 0xff;
4916 usb_microdia_control_write(dev, 0x10fa, buf, 1); /* URB 2139 */
4917
4918 buf[0] = 0x00;
4919 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2140 */
4920 buf[0] = 0x00;
4921 usb_microdia_control_write(dev, 0x10f9, buf, 1); /* URB 2141 */
4922 buf[0] = 0x0a;
4923 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2142 */
4924 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
4925 usb_microdia_control_write(dev, 0x11bc, buf, 4); /* URB 2143 */
4926 for (k = 0; k < 48; k++)
4927 buf[k] = 0x00;
4928 usb_microdia_control_write(dev, 0x11c0, buf, 48); /* URB 2144 */
4929
4930 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
4931 buf[4] = 0x04; buf[5] = 0x3f;
4932 usb_microdia_control_write(dev, 0x11a5, buf, 6); /* URB 2149 */
4933
4934 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4935 buf[0] = 0x14; buf[1] = 0xec; buf[2] = 0x0a; buf[3] = 0xf6;
4936 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
4937 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
4938 }
4939 usb_microdia_control_write(dev, 0x11af, buf, 4); /* URB 2150 */
4940
4941 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x2d; buf[3] = 0xdd;
4942 usb_microdia_control_write(dev, 0x11b3, buf, 4); /* URB 2151 */
4943 buf[0] = 0x47; /* ALEX: 0x04 */
4944 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2152 */
4945 buf[0] = 0x01;
4946 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2153 */
4947 buf[0] = 0x67; /* ALEX: 0x24 */
4948 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2154 */
4949 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
4950 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
4951 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
4952 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
4953 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
4954 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
4955 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
4956 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
4957 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
4958 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
4959 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
4960 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
4961 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
4962 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
4963 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
4964 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
4965 usb_microdia_control_write(dev, 0x1100, buf, 64); /* URB 2155 */
4966 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
4967 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
4968 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
4969 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
4970 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
4971 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
4972 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
4973 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
4974 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
4975 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
4976 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
4977 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
4978 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
4979 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
4980 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
4981 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
4982 usb_microdia_control_write(dev, 0x1140, buf, 64); /* URB 2156 */
4983 buf[0] = 0x47; /* ALEX: 0x04 */
4984 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2157 */
4985 buf[0] = 0x03;
4986 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2158 */
4987 buf[0] = 0x4b; /* ALEX: 0x08 */
4988 usb_microdia_control_write(dev, 0x10e0, buf, 1); /* URB 2159 */
4989
4990 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
4991 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
4992 /* I2C MESSAGES */
4993 retI2C = 0;
4994 /* Writes to sensor registers 0x02: Column Start */
4995 /* 0x03: Window Hight */
4996 buf[0] = 0x00; buf[1] = 0x16; /* coulmn 22 */
4997 buf[2] = 0x01; buf[3] = 0xe1; /* 481 */
4998 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x02, dev->sensor_flags, buf); /* URBs 2160-2162 */
4999 /* Writes to sensor registers 0x04: Window Width */
5000 /* 0x05: Horizontal Blanking */
5001 buf[0] = 0x02; buf[1] = 0x81; /* 641 */
5002 buf[2] = 0x00; buf[3] = 0x04; /* 4 columns (pixel clocks) */
5003 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x04, dev->sensor_flags, buf); /* URBs 2163-2165 */
5004 /* Writes to sensor registers 0x06: Vertical Blanking */
5005 /* 0x07: Output Control */
5006 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
5007 buf[2] = 0x30; buf[3] = 0x02; /* RESERVED options */
5008 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, 0x06, dev->sensor_flags, buf); /* URBs 2166-2167 */
5009 /* Writes to sensor register 0x0e: UNDOCUMENTED */
5010 buf[0] = 0x00; buf[1] = 0x08;
5011 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x0e, dev->sensor_flags, buf); /* URBs 2168-2170 */
5012 if (retI2C < 0) {
5013 UDIA_INFO("1 or more errors occured in I2C-message-block 6 !\n");
5014 return -1;
5015 }
5016 /* END OF I2C MESSAGES */
5017 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5018 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5019 buf[0] = 0x40;
5020 usb_microdia_control_write(dev, 0x1007, buf, 1);
5021 buf[0] = 0x40;
5022 usb_microdia_control_write(dev, 0x1006, buf, 1);
5023 }
5024
5025
5026 buf[0] = 0x02; buf[1] = 0x00; buf[2] = 0x02; buf[3] = 0x00;
5027 buf[4] = 0x28; buf[5] = 0x3c;
5028 usb_microdia_control_write(dev, 0x1180, buf, 6); /* URB 2171 */
5029 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5030 usb_microdia_control_write(dev, 0x10fb, buf, 5); /* URB 2172 */
5031 buf[0] = 0x0c;
5032 usb_microdia_control_write(dev, 0x1189, buf, 1); /* URB 2173 */
5033 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
5034 usb_microdia_control_write(dev, 0x11a1, buf, 4); /* URB 2174 */
5035 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
5036 usb_microdia_control_write(dev, 0x11ab, buf, 4); /* URB 2175 */
5037 buf[0] = 0x03;
5038 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2176 */
5039 buf[0] = 0x0a;
5040 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2177 */
5041 buf[0] = 0x00;
5042 usb_microdia_control_write(dev, 0x11b9, buf, 1); /* URB 2178 */
5043 buf[0] = 0x0b;
5044 usb_microdia_control_write(dev, 0x11ba, buf, 1); /* URB 2179 */
5045 buf[0] = 0x01;
5046 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2180 */
5047 buf[0] = 0x78; /* ALEX: 0x7c */
5048 usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 2181 */
5049 buf[0] = 0x18; /* ALEX: 0x1c */
5050 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2182 */
5051 buf[0] = 0x18; /* ALEX: 0x1c */
5052 usb_microdia_control_write(dev, 0x1002, buf, 1); /* URB 2183 */
5053 buf[0] = 0x7d; /* ALEX: 0xfc */
5054 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2184 */
5055 buf[0] = 0x04;
5056 usb_microdia_control_write(dev, 0x118a, buf, 1); /* URB 2185 */
5057 buf[0] = 0x04;
5058 usb_microdia_control_write(dev, 0x0395, buf, 1); /* URB 2186 */
5059
5060 if ((last_11b8[0] == 0x3d) || (last_11b8[0] == 0x3f))
5061 buf[0] = 0x78;
5062 else if ((last_11b8[0] == 0xbd) || (last_11b8[0] == 0xbf))
5063 buf[0] = 0xf8;
5064 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2187 */
5065 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2188 // 0x38 */
5066 if (buf[0] == 0x38)
5067 buf[0] = 0x79;
5068 else if (buf[0] == 0xb8)
5069 buf[0] = 0xf9;
5070 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2189 */
5071 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2190 // 0xb9 */
5072 if (buf[0] == 0x39)
5073 buf[0] = 0x7a;
5074 else if (buf[0] == 0xb9)
5075 buf[0] = 0xfa;
5076 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2191 */
5077 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2192 // 0xba */
5078 if (buf[0] == 0x3a)
5079 buf[0] = 0x7b;
5080 else if (buf[0] == 0xba)
5081 buf[0] = 0xfb;
5082 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2193 */
5083 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2194 // 0x3b */
5084 if (buf[0] == 0x3b)
5085 buf[0] = 0x7c;
5086 else if (buf[0] == 0xbb)
5087 buf[0] = 0xfc;
5088 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2195 */
5089 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2196 // 0x3c */
5090 if (buf[0] == 0x3c)
5091 buf[0] = 0x7d;
5092 else if (buf[0] == 0xbc)
5093 buf[0] = 0xfd;
5094 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2197 */
5095 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2198 // 0x3d */
5096 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5097 if (buf[0] == 0x3d)
5098 buf[0] = 0x7e;
5099 else if (buf[0] == 0xbd)
5100 buf[0] = 0xfe;
5101 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2199 */
5102 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2200 */
5103 if (buf[0] == 0x3e)
5104 buf[0] = 0x7f;
5105 else if (buf[0] == 0xbe)
5106 buf[0] = 0xff;
5107 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2201 */
5108 usb_microdia_control_read(dev, 0x11b8, buf, 1); /* URB 2202 */
5109 }
5110 buf[0] = buf[0] & 0xf0; /* 0xf0 or 0x70 */
5111 buf[0] = buf[0] | 0x0d; /* 0x0c => THIS VALUE SEEMS TO DEPEND ON WHAT WAS READ/WRITTEN IN THE LAST 8 READS/WRITES */
5112 usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 2089 */
5113
5114 /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5115 /* I2C MESSAGES */
5116 retI2C = 0;
5117 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5118 /* Write to sensor register 0x06: Vertical Blanking */
5119 buf[0] = 0x00; buf[1] = 0x2d; /* 45 rows */
5120 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf); /* URBs 2204-2206 */
5121 /* Write to sensor register 0x05: Horizontal Blanking */
5122 buf[0] = 0x00; buf[1] = 0x04; /* 4 columns (pixel clocks) */
5123 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf); /* URBs 2207-2209 */
5124 /* Read of sensor register 0x36: Chip Version (mirror of reg0xff) */
5125 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x36, dev->sensor_flags, buf); /* URBs 2211-2215 // 0x82 0x3a */
5126 } else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
5127 /* Write to sensor register 0x0a: Pixel Clock Speed */
5128 buf[0] = 0x00; buf[1] = 0x00; /* default */
5129 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
5130 /* Write to sensor register 0x06: Vertical Blanking */
5131 buf[0] = 0x00; buf[1] = 0x29; /* 41 rows */
5132 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x06, dev->sensor_flags, buf);
5133 /* Write to sensor register 0x05: Horizontal Blanking */
5134 buf[0] = 0x00; buf[1] = 0x09; /* 9 columns (pixel clocks) */
5135 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x05, dev->sensor_flags, buf);
5136 /* Read of sensor register 0x00: Chip Version (=reg0xff) */
5137 retI2C += sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 2, 0x00, dev->sensor_flags, buf); /* 0x82 0x43 */
5138 }
5139 if (retI2C < 0) {
5140 UDIA_INFO("1 or more errors occured in I2C-message-block 7 !\n");
5141 return -1;
5142 }
5143 /* END OF I2C MESSAGES */
5144 /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
5145
5146
5147 buf[0] = 0x03;
5148 usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 2216 */
5149
5150
5151 /*** NOW DRIVER DOES STOP-SEQUENCE
5152 - WITHOUT WRITES TO 0x1007 AND 0x1006 (URBs 3544-3550) => MT9V111
5153 - WRITING 0x40 INSTEAD OF 0x60 TO 0x1007 AND 0x1006 => MT9V011
5154 ***/
5155 /*** 2nd, 3rd, ... CYCLE: ALL MESSAGES (URBs 1953 - URBs 2216) ARE REPEATED ***/
5156 /*** ----- WE DON'T DO THIS, IT SEEMS TO BE UNNECESSARY ----- ***/
5157
5158 /* Setup IFP registers for AE and AWB (new, not in the logs): */
5159 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
5160 mt9v111_setup_autoexposure(dev);
5161 mt9v111_setup_autowhitebalance(dev);
5162 mt9v111_set_autocorrections(dev, 1);
5163 }
5164
5165 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5166 buf[0] = 0x20;
5167 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5168 buf[0] = 0x60;
5169 usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 2489 */
5170 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS)
5171 buf[0] = 0x00;
5172 else if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS)
5173 buf[0] = 0x40;
5174 usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 2490 */
5175 /* => These two writes seem to cause the cam to start sending isochronus USB messages */
5176
5177 return 0;
5178 }
5179
5180 int microdia_627b_start_stream(struct usb_microdia *dev)
5181 {
5182 int ret;
5183 /* int actual; */
5184 __u16 reg;
5185 __u8 buf[64];
5186
5187 buf[0] = 0x00; /** Will have to be set for every single interrupt. */
5188 /*
5189 ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 43
5190 */
5191
5192 reg = 0x1066;
5193 buf[0] = 0x00;
5194 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 44 */
5195 if (ret < 0)
5196 goto err;
5197
5198 /*
5199 //ret = usb_set_interface(dev->udev, 0, 8);
5200 //if(ret < 0) goto err;
5201
5202 //buf[0] = 0x00; // Will have to be set for every single interrupt
5203 //ret = usb_interrupt_msg(dev->udev, 0x00000083, buf, 0x0000001, &actual, 1000); // URB 45
5204 */
5205
5206 reg = 0x1000;
5207 buf[0] = 0x78;
5208 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 46 */
5209 if (ret < 0)
5210 goto err;
5211
5212 reg = 0x1001;
5213 buf[0] = 0xc7;
5214 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 47 */
5215 if (ret < 0)
5216 goto err;
5217
5218 reg = 0x1002;
5219 buf[0] = 0x18;
5220 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 48 */
5221 if (ret < 0)
5222 goto err;
5223
5224 reg = 0x1061;
5225 buf[0] = 0x01;
5226 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 49 */
5227 if (ret < 0)
5228 goto err;
5229
5230 reg = 0x1020;
5231 buf[0] = 0x80;
5232 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 50 */
5233 if (ret < 0)
5234 goto err;
5235
5236 reg = 0x1067;
5237 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20; buf[3] = 0x10; buf[4] = 0x08;
5238 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 51 */
5239 if (ret < 0)
5240 goto err;
5241
5242 reg = 0x10c0;
5243 buf[0] = 0x80; buf[1] = 0x21; buf[2] = 0x00; buf[3] = 0x00;
5244 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
5245 buf[8] = 0x03;
5246 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 52 */
5247 if (ret < 0)
5248 goto err;
5249
5250 /* transferbufferlength is 18, but data is 24 bytes long, what to do ? */
5251 reg = 0x10e0;
5252 buf[0] = 0x45; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30; buf[4] = 0x00;
5253 buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed; buf[8] = 0x0f; buf[9] = 0xda;
5254 buf[10] = 0x0f; buf[11] = 0x3a; buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00;
5255 buf[15] = 0xd0; buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
5256 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
5257 ret = usb_microdia_control_write(dev, reg, buf, 24); /* URB 53 */
5258 if (ret < 0)
5259 goto err;
5260
5261 reg = 0x10f8;
5262 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
5263 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 54 */
5264 if (ret < 0)
5265 goto err;
5266
5267 reg = 0x10fb;
5268 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5269 ret = usb_microdia_control_write(dev, reg, buf, 5); /* URB 55 */
5270 if (ret < 0)
5271 goto err;
5272
5273 reg = 0x1188;
5274 buf[0] = 0x86; buf[1] = 0x8c; buf[2] = 0x08;
5275 ret = usb_microdia_control_write(dev, reg, buf, 3); /* URB 56 */
5276 if (ret < 0)
5277 goto err;
5278
5279 reg = 0x118b;
5280 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20; buf[4] = 0x20;
5281 buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b; buf[8] = 0x4f; buf[9] = 0x61;
5282 buf[10] = 0x71; buf[11] = 0x80; buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab;
5283 buf[15] = 0xb8; buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
5284 buf[20] = 0xf4; buf[21] = 0xff;
5285 ret = usb_microdia_control_write(dev, reg, buf, 22); /* URB 57 */
5286 if (ret < 0)
5287 goto err;
5288
5289 reg = 0x11a1;
5290 buf[0] = 0x00; buf[1] = 0x00;
5291 ret = usb_microdia_control_write(dev, reg, buf, 2); /* URB 58 */
5292 if (ret < 0)
5293 goto err;
5294
5295 reg = 0x11b7;
5296 buf[0] = 0x60; buf[1] = 0x28; buf[2] = 0x00; buf[3] = 0x08; buf[4] = 0x00;
5297 buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0; buf[8] = 0x00;
5298 ret = usb_microdia_control_write(dev, reg, buf, 9); /* URB 59 */
5299 if (ret < 0)
5300 goto err;
5301
5302 reg = 0x11b8;
5303 buf[0] = 0x38;
5304 ret = usb_microdia_control_write(dev, reg, buf, 1); /* URB 60 */
5305 if (ret < 0)
5306 goto err;
5307
5308 reg = 0x1000;
5309 buf[0] = 0x78;
5310 ret = usb_microdia_control_write(dev, reg, buf, 1);
5311 if (ret < 0)
5312 goto err;
5313
5314 buf[0] = 0x80;
5315 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5316 OV7660_CTL_COM7, dev->sensor_flags, buf);
5317 if (ret < 0)
5318 goto errI2C;
5319
5320 buf[0] = 0x01; buf[1] = 0x74; buf[2] = 0x92; buf[3] = 0x00;
5321 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5322 OV7660_CTL_GAIN, dev->sensor_flags, buf);
5323 if (ret < 0)
5324 goto errI2C;
5325
5326 buf[0] = 0x00; buf[1] = 0x7d; buf[2] = 0x62; buf[3] = 0x00;
5327 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5328 OV7660_CTL_COM1, dev->sensor_flags, buf);
5329 if (ret < 0)
5330 goto errI2C;
5331
5332 buf[0] = 0x83; buf[1] = 0x01;
5333 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5334 OV7660_CTL_RAVE, dev->sensor_flags, buf);
5335 if (ret < 0)
5336 goto errI2C;
5337
5338 buf[0] = 0x00; buf[1] = 0x08; buf[2] = 0x04; buf[3] = 0x62;
5339 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5340 OV7660_CTL_COM3, dev->sensor_flags, buf);
5341 if (ret < 0)
5342 goto errI2C;
5343
5344 buf[0] = 0x00; buf[1] = 0x40; buf[2] = 0x05; buf[3] = 0xf8;
5345 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5346 OV7660_CTL_AECH, dev->sensor_flags, buf);
5347 if (ret < 0)
5348 goto errI2C;
5349
5350 buf[0] = 0x2e; buf[1] = 0x00; buf[2] = 0x02;
5351 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
5352 OV7660_CTL_COM9, dev->sensor_flags, buf);
5353 if (ret < 0)
5354 goto errI2C;
5355
5356 buf[0] = 0x10; buf[1] = 0x60; buf[2] = 0x02; buf[3] = 0x7b;
5357 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5358 OV7660_CTL_HSTART, dev->sensor_flags, buf);
5359 if (ret < 0)
5360 goto errI2C;
5361
5362 buf[0] = 0x06;
5363 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5364 OV7660_CTL_PSHFT, dev->sensor_flags, buf);
5365 if (ret < 0)
5366 goto errI2C;
5367
5368 buf[0] = 0x01; buf[1] = 0x0e;
5369 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5370 OV7660_CTL_MVFP, dev->sensor_flags, buf);
5371 if (ret < 0)
5372 goto errI2C;
5373
5374 buf[0] = 0x07; buf[1] = 0x07; buf[2] = 0x07; buf[3] = 0x07;
5375 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5376 OV7660_CTL_BOS, dev->sensor_flags, buf);
5377 if (ret < 0)
5378 goto errI2C;
5379
5380 buf[0] = 0x68; buf[1] = 0x58; buf[2] = 0xd4; buf[3] = 0x80;
5381 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5382 OV7660_CTL_AEW, dev->sensor_flags, buf);
5383 if (ret < 0)
5384 goto errI2C;
5385
5386 buf[0] = 0x80; buf[1] = 0x3c; buf[2] = 0x00; buf[3] = 0x00;
5387 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5388 OV7660_CTL_GbBIAS, dev->sensor_flags, buf);
5389 if (ret < 0)
5390 goto errI2C;
5391
5392 buf[0] = 0x80; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x62;
5393 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5394 OV7660_CTL_RBIAS, dev->sensor_flags, buf);
5395 if (ret < 0)
5396 goto errI2C;
5397
5398 buf[0] = 0x08; buf[1] = 0x30; buf[2] = 0xb4;
5399 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3,
5400 OV7660_CTL_HSYST, dev->sensor_flags, buf);
5401 if (ret < 0)
5402 goto errI2C;
5403
5404 buf[0] = 0x00; buf[1] = 0x07; buf[2] = 0x84; buf[3] = 0x00;
5405 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5406 OV7660_CTL_CHLF, dev->sensor_flags, buf);
5407 if (ret < 0)
5408 goto errI2C;
5409
5410 buf[0] = 0x0c; buf[1] = 0x02; buf[2] = 0x43; buf[3] = 0x00;
5411 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5412 OV7660_CTL_ADC, dev->sensor_flags, buf);
5413 if (ret < 0)
5414 goto errI2C;
5415
5416 buf[0] = 0x02; buf[1] = 0x6c; buf[2] = 0x19; buf[3] = 0x0e;
5417 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5418 OV7660_CTL_COM11, dev->sensor_flags, buf);
5419 if (ret < 0)
5420 goto errI2C;
5421
5422 buf[0] = 0x41; buf[1] = 0xc1; buf[2] = 0x22; buf[3] = 0x08;
5423 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5424 OV7660_CTL_EDGE, dev->sensor_flags, buf);
5425 if (ret < 0)
5426 goto errI2C;
5427
5428 /* "Dummy" write */
5429 reg = 0x43; /* RSVD 0x43 is Reserved */
5430 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5431 reg, dev->sensor_flags, NULL);
5432 if (ret < 0)
5433 goto errI2C;
5434
5435 reg = 0x43; /* RSVD 0x43 is Reserved */
5436 buf[0] = 0xf0; buf[1] = 0x10; buf[2] = 0x78; buf[3] = 0xa8;
5437 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5438 dev->sensor_flags, buf);
5439 if (ret < 0)
5440 goto errI2C;
5441
5442 reg = 0x47; /* RSVD 0x47 is Reserved */
5443 buf[0] = 0x60; buf[1] = 0x80; buf[2] = 0x00; buf[3] = 0x00;
5444 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5445 dev->sensor_flags, buf);
5446 if (ret < 0)
5447 goto errI2C;
5448
5449 reg = 0x4b; /* RSVD 0x4b is Reserved */
5450 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5451 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4, reg,
5452 dev->sensor_flags, buf);
5453 if (ret < 0)
5454 goto errI2C;
5455
5456 /* "Dummy" write */
5457 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5458 OV7660_CTL_MTX1, dev->sensor_flags, NULL);
5459 if (ret < 0)
5460 goto errI2C;
5461
5462 reg = 0x59; /* RSVD 0x59 is Reserved */
5463 buf[0] = 0xba; buf[1] = 0x9a; buf[2] = 0x22; buf[3] = 0xb9;
5464 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5465 reg, dev->sensor_flags, buf);
5466 if (ret < 0)
5467 goto errI2C;
5468
5469 reg = 0x5d; /* RSVD 0x5d is Reserved */
5470 buf[0] = 0x9b; buf[1] = 0x10; buf[2] = 0xf0; buf[3] = 0x05;
5471 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5472 reg, dev->sensor_flags, buf);
5473 if (ret < 0)
5474 goto errI2C;
5475
5476 reg = 0x61; /* RSVD 0x61 is Reserved */
5477 buf[0] = 0x60;
5478 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5479 reg, dev->sensor_flags, buf);
5480 if (ret < 0)
5481 goto errI2C;
5482
5483 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x30;
5484 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5485 OV7660_CTL_LCC1, dev->sensor_flags, buf);
5486 if (ret < 0)
5487 goto errI2C;
5488
5489 buf[0] = 0x00;
5490 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5491 OV7660_CTL_LCC5, dev->sensor_flags, buf);
5492 if (ret < 0)
5493 goto errI2C;
5494
5495 buf[0] = 0x80; buf[1] = 0x7a; buf[2] = 0x90; buf[3] = 0x80;
5496 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5497 OV7660_CTL_MANU, dev->sensor_flags, buf);
5498 if (ret < 0)
5499 goto errI2C;
5500
5501 buf[0] = 0x0a;
5502 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5503 OV7660_CTL_DBLV, dev->sensor_flags, buf);
5504 if (ret < 0)
5505 goto errI2C;
5506
5507 reg = 0x8b; /* RSVD 0x8b is Reserved */
5508 buf[0] = 0x99; buf[1] = 0x99; buf[2] = 0xcf;
5509 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 3, reg,
5510 dev->sensor_flags, buf);
5511 if (ret < 0)
5512 goto errI2C;
5513
5514 buf[0] = 0x00; buf[1] = 0x00;
5515 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5516 OV7660_CTL_DM_LNL, dev->sensor_flags, buf);
5517 if (ret < 0)
5518 goto errI2C;
5519
5520 reg = 0x1007;
5521 buf[0] = 0x40;
5522 ret = usb_microdia_control_write(dev, reg, buf, 1);
5523 if (ret < 0)
5524 goto err;
5525
5526 reg = 0x1006;
5527 buf[0] = 0x00;
5528 ret = usb_microdia_control_write(dev, reg, buf, 1);
5529 if (ret < 0)
5530 goto err;
5531
5532 reg = 0x10c1;
5533 ret = usb_microdia_control_read(dev, reg, buf, 1);
5534 if (ret < 0)
5535 goto err;
5536
5537 reg = 0x10c1;
5538 buf[0] = 0x50;
5539 ret = usb_microdia_control_write(dev, reg, buf, 1);
5540 if (ret < 0)
5541 goto err;
5542
5543 /* TRY TO READ FROM EEPROM: */
5544 reg = 0x00;
5545 ret = sn9c20x_read_i2c_data(dev, 0x50, 1, reg, SN9C20X_I2C_2WIRE, buf);
5546 if (ret < 0)
5547 UDIA_INFO("No EEPROM found\n");
5548 else
5549 UDIA_INFO("Read from EEPROM successful\n");
5550
5551 reg = 0x10c1;
5552 buf[0] = 0x21;
5553 ret = usb_microdia_control_write(dev, reg, buf, 1);
5554 if (ret < 0)
5555 goto err;
5556
5557 reg = 0x10e0;
5558 buf[0] = 0x47;
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 = 0x1001;
5570 buf[0] = 0xc6;
5571 ret = usb_microdia_control_write(dev, reg, buf, 1);
5572 if (ret < 0)
5573 goto err;
5574
5575 reg = 0x1001;
5576 buf[0] = 0xc4;
5577 ret = usb_microdia_control_write(dev, reg, buf, 1);
5578 if (ret < 0)
5579 goto err;
5580
5581 reg = 0x1001;
5582 buf[0] = 0x84;
5583 ret = usb_microdia_control_write(dev, reg, buf, 1);
5584 if (ret < 0)
5585 goto err;
5586
5587 buf[0] = 0x08;
5588 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5589 OV7660_CTL_VREF, dev->sensor_flags, buf);
5590 if (ret < 0)
5591 goto errI2C;
5592
5593 buf[0] = 0x10; buf[1] = 0x61; buf[2] = 0x02; buf[3] = 0x7a;
5594 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 4,
5595 OV7660_CTL_HSTART, dev->sensor_flags, buf);
5596 if (ret < 0)
5597 goto errI2C;
5598
5599 /* "Dummy" write: */
5600 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 0,
5601 OV7660_CTL_PSHFT, dev->sensor_flags, NULL);
5602 if (ret < 0)
5603 goto errI2C;
5604
5605 buf[0] = 0x84;
5606 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5607 OV7660_CTL_HREF, dev->sensor_flags, buf);
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 reg = 0x1180;
5636 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
5637 buf[5] = 0x3c;
5638 ret = usb_microdia_control_write(dev, reg, buf, 6);
5639 if (ret < 0)
5640 goto err;
5641
5642 reg = 0x10fb;
5643 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
5644 ret = usb_microdia_control_write(dev, reg, buf, 5);
5645 if (ret < 0)
5646 goto err;
5647
5648 reg = 0x1189;
5649 buf[0] = 0x8c;
5650 ret = usb_microdia_control_write(dev, reg, buf, 1);
5651 if (ret < 0)
5652 goto err;
5653
5654 reg = 0x11a1;
5655 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
5656 ret = usb_microdia_control_write(dev, reg, buf, 4);
5657 if (ret < 0)
5658 goto err;
5659
5660 reg = 0x11ab;
5661 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
5662 ret = usb_microdia_control_write(dev, reg, buf, 4);
5663 if (ret < 0)
5664 goto err;
5665
5666 reg = 0x1000;
5667 buf[0] = 0x78;
5668 ret = usb_microdia_control_write(dev, reg, buf, 1);
5669 if (ret < 0)
5670 goto err;
5671
5672 reg = 0x1002;
5673 buf[0] = 0x18;
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 = 0x11b8;
5685 buf[0] = 0x38;
5686 ret = usb_microdia_control_write(dev, reg, buf, 1);
5687 if (ret < 0)
5688 goto err;
5689
5690 reg = 0x118a;
5691 buf[0] = 0x04;
5692 ret = usb_microdia_control_write(dev, reg, buf, 1);
5693 if (ret < 0)
5694 goto err;
5695
5696 reg = 0x0395;
5697 buf[0] = 0x04;
5698 ret = usb_microdia_control_write(dev, reg, buf, 1);
5699 if (ret < 0)
5700 goto err;
5701
5702 reg = 0x11b8;
5703 buf[0] = 0x78;
5704 ret = usb_microdia_control_write(dev, reg, buf, 1);
5705 if (ret < 0)
5706 goto err;
5707 ret = usb_microdia_control_read(dev, reg, buf, 1);
5708 if (ret < 0)
5709 goto err;
5710
5711 reg = 0x11b8;
5712 buf[0] = 0xf9;
5713 ret = usb_microdia_control_write(dev, reg, buf, 1);
5714 if (ret < 0)
5715 goto err;
5716 ret = usb_microdia_control_read(dev, reg, buf, 1);
5717 if (ret < 0)
5718 goto err;
5719
5720 reg = 0x11b8;
5721 buf[0] = 0xfa;
5722 ret = usb_microdia_control_write(dev, reg, buf, 1);
5723 if (ret < 0)
5724 goto err;
5725 ret = usb_microdia_control_read(dev, reg, buf, 1);
5726 if (ret < 0)
5727 goto err;
5728
5729 reg = 0x11b8;
5730 buf[0] = 0x7b;
5731 ret = usb_microdia_control_write(dev, reg, buf, 1);
5732 if (ret < 0)
5733 goto err;
5734 ret = usb_microdia_control_read(dev, reg, buf, 1);
5735 if (ret < 0)
5736 goto err;
5737
5738 reg = 0x11b8;
5739 buf[0] = 0x7c;
5740 ret = usb_microdia_control_write(dev, reg, buf, 1);
5741 if (ret < 0)
5742 goto err;
5743 ret = usb_microdia_control_read(dev, reg, buf, 1);
5744 if (ret < 0)
5745 goto err;
5746
5747 reg = 0x11b8;
5748 buf[0] = 0x7d;
5749 ret = usb_microdia_control_write(dev, reg, buf, 1);
5750 if (ret < 0)
5751 goto err;
5752 ret = usb_microdia_control_read(dev, reg, buf, 1);
5753 if (ret < 0)
5754 goto err;
5755
5756 reg = 0x11b8;
5757 buf[0] = 0x7b;
5758 ret = usb_microdia_control_write(dev, reg, buf, 1);
5759 if (ret < 0)
5760 goto err;
5761
5762 /*
5763 //ret = usb_microdia_control_read(dev, reg, buf, 1);
5764 //if(ret < 0) goto err;
5765 */
5766
5767 buf[0] = 0x40;
5768 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5769 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
5770 if (ret < 0)
5771 goto errI2C;
5772
5773 buf[0] = 0x00;
5774 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5775 OV7660_CTL_EXHCH, 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_EXHCL, 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_DM_LNL, 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_LNH, dev->sensor_flags, buf);
5794 if (ret < 0)
5795 goto errI2C;
5796
5797 buf[0] = 0x01;
5798 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5799 OV7660_CTL_MVFP, 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] = 0x08;
5810 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5811 OV7660_CTL_VREF, dev->sensor_flags, buf);
5812 if (ret < 0)
5813 goto errI2C;
5814
5815 buf[0] = 0x00;
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] = 0x7f;
5822 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5823 OV7660_CTL_AECH, dev->sensor_flags, buf);
5824 if (ret < 0)
5825 goto errI2C;
5826
5827 buf[0] = 0x00;
5828 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
5829 OV7660_CTL_COM1, 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_ADVFL, 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_ADVFH, 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_GAIN, dev->sensor_flags, buf);
5848 if (ret < 0)
5849 goto errI2C;
5850
5851 buf[0] = 0x78; buf[1] = 0x78;
5852 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
5853 OV7660_CTL_BLUE, dev->sensor_flags, buf);
5854 if (ret < 0)
5855 goto errI2C;
5856
5857 reg = 0x11ba;
5858 buf[0] = 0x0a;
5859 ret = usb_microdia_control_write(dev, reg, buf, 1);
5860 if (ret < 0)
5861 goto err;
5862
5863 reg = 0x118b;
5864 buf[0] = 0x0c;
5865 ret = usb_microdia_control_write(dev, reg, buf, 1);
5866 if (ret < 0)
5867 goto err;
5868
5869 reg = 0x10f7;
5870 buf[0] = 0x05;
5871 ret = usb_microdia_control_write(dev, reg, buf, 1);
5872 if (ret < 0)
5873 goto err;
5874
5875 reg = 0x10f8;
5876 buf[0] = 0x14;
5877 ret = usb_microdia_control_write(dev, reg, buf, 1);
5878 if (ret < 0)
5879 goto err;
5880
5881 reg = 0x10fa;
5882 buf[0] = 0xff;
5883 ret = usb_microdia_control_write(dev, reg, buf, 1);
5884 if (ret < 0)
5885 goto err;
5886
5887 reg = 0x10f9;
5888 buf[0] = 0x00;
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 = 0x11ba;
5900 buf[0] = 0x0a;
5901 ret = usb_microdia_control_write(dev, reg, buf, 1);
5902 if (ret < 0)
5903 goto err;
5904
5905 reg = 0x11bc;
5906 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
5907 ret = usb_microdia_control_write(dev, reg, buf, 4);
5908 if (ret < 0)
5909 goto err;
5910
5911 reg = 0x11c0;
5912 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00;
5913 buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00; buf[8] = 0x00; buf[9] = 0x00;
5914 buf[10] = 0x00; buf[11] = 0x00; buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00;
5915 buf[15] = 0x00; buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
5916 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00; buf[24] = 0x00;
5917 buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00; buf[28] = 0x00; buf[29] = 0x00;
5918 buf[30] = 0x00; buf[31] = 0x00; buf[32] = 0x00;
5919 ret = usb_microdia_control_write(dev, reg, buf, 33);
5920 if (ret < 0)
5921 goto err;
5922 /* transferbufferlength was only 30 ? */
5923
5924 reg = 0x11a5;
5925 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05; buf[4] = 0x04;
5926 buf[5] = 0x3f;
5927 ret = usb_microdia_control_write(dev, reg, buf, 6);
5928 if (ret < 0)
5929 goto err;
5930
5931 reg = 0x11af;
5932 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
5933 ret = usb_microdia_control_write(dev, reg, buf, 4);
5934 if (ret < 0)
5935 goto err;
5936
5937 reg = 0x11b3;
5938 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
5939 ret = usb_microdia_control_write(dev, reg, buf, 4);
5940 if (ret < 0)
5941 goto err;
5942
5943 reg = 0x10e0;
5944 buf[0] = 0x47;
5945 ret = usb_microdia_control_write(dev, reg, buf, 1);
5946 if (ret < 0)
5947 goto err;
5948
5949 reg = 0x1061;
5950 buf[0] = 0x01;
5951 ret = usb_microdia_control_write(dev, reg, buf, 1);
5952 if (ret < 0)
5953 goto err;
5954
5955 reg = 0x10e0;
5956 buf[0] = 0x67;
5957 ret = usb_microdia_control_write(dev, reg, buf, 1);
5958 if (ret < 0)
5959 goto err;
5960
5961 reg = 0x1100;
5962 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d; buf[4] = 0x08;
5963 buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d; buf[8] = 0x0d; buf[9] = 0x0d;
5964 buf[10] = 0x11; buf[11] = 0x0d; buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15;
5965 buf[15] = 0x21; buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
5966 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d; buf[24] = 0x19;
5967 buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a; buf[28] = 0x32; buf[29] = 0x32;
5968 buf[30] = 0x2e; buf[31] = 0x2a; buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36;
5969 buf[35] = 0x3a; buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
5970 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e; buf[44] = 0x43;
5971 buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47; buf[48] = 0x4f; buf[49] = 0x53;
5972 buf[50] = 0x58; buf[51] = 0x58; buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f;
5973 buf[55] = 0x60; buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
5974 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
5975 ret = usb_microdia_control_write(dev, reg, buf, 64);
5976 if (ret < 0)
5977 goto err;
5978 /* transferbufferlength is only 40 ? */
5979
5980 reg = 0x1140;
5981 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15; buf[4] = 0x11;
5982 buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15; buf[8] = 0x15; buf[9] = 0x26;
5983 buf[10] = 0x53; buf[11] = 0x36; buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53;
5984 buf[15] = 0x53; buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
5985 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53; buf[24] = 0x53;
5986 buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53; buf[28] = 0x53; buf[29] = 0x53;
5987 buf[30] = 0x53; buf[31] = 0x53; buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53;
5988 buf[35] = 0x53; buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
5989 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53; buf[44] = 0x53;
5990 buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53; buf[48] = 0x53; buf[49] = 0x53;
5991 buf[50] = 0x53; buf[51] = 0x53; buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53;
5992 buf[55] = 0x53; buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
5993 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
5994 ret = usb_microdia_control_write(dev, reg, buf, 64);
5995 if (ret < 0)
5996 goto err;
5997 /* transferbufferlength is only 40 ? */
5998
5999 reg = 0x10e0;
6000 buf[0] = 0x47;
6001 ret = usb_microdia_control_write(dev, reg, buf, 1);
6002 if (ret < 0)
6003 goto err;
6004
6005 reg = 0x1061;
6006 buf[0] = 0x03;
6007 ret = usb_microdia_control_write(dev, reg, buf, 1);
6008 if (ret < 0)
6009 goto err;
6010
6011 reg = 0x10e0;
6012 buf[0] = 0x4b;
6013 ret = usb_microdia_control_write(dev, reg, buf, 1);
6014 if (ret < 0)
6015 goto err;
6016
6017 buf[0] = 0x08;
6018 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6019 OV7660_CTL_VREF, dev->sensor_flags, buf);
6020 if (ret < 0)
6021 goto errI2C;
6022
6023 reg = 0x1180;
6024 buf[0] = 0x01; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x28;
6025 buf[5] = 0x3c;
6026 ret = usb_microdia_control_write(dev, reg, buf, 6);
6027 if (ret < 0)
6028 goto err;
6029
6030 reg = 0x10fb;
6031 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6032 ret = usb_microdia_control_write(dev, reg, buf, 5);
6033 if (ret < 0)
6034 goto err;
6035
6036 reg = 0x1189;
6037 buf[0] = 0x8c;
6038 ret = usb_microdia_control_write(dev, reg, buf, 1);
6039 if (ret < 0)
6040 goto err;
6041
6042 reg = 0x11a1;
6043 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x6a; buf[3] = 0x50;
6044 ret = usb_microdia_control_write(dev, reg, buf, 4);
6045 if (ret < 0)
6046 goto err;
6047
6048 reg = 0x11ab;
6049 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x50; buf[3] = 0x3c;
6050 ret = usb_microdia_control_write(dev, reg, buf, 4);
6051 if (ret < 0)
6052 goto err;
6053
6054 reg = 0x1061;
6055 buf[0] = 0x03;
6056 ret = usb_microdia_control_write(dev, reg, buf, 1);
6057 if (ret < 0)
6058 goto err;
6059
6060 reg = 0x11ba;
6061 buf[0] = 0x0a;
6062 ret = usb_microdia_control_write(dev, reg, buf, 1);
6063 if (ret < 0)
6064 goto err;
6065
6066 reg = 0x11b9;
6067 buf[0] = 0x00;
6068 ret = usb_microdia_control_write(dev, reg, buf, 1);
6069 if (ret < 0)
6070 goto err;
6071
6072 reg = 0x11ba;
6073 buf[0] = 0x0b;
6074 ret = usb_microdia_control_write(dev, reg, buf, 1);
6075 if (ret < 0)
6076 goto err;
6077
6078 reg = 0x1061;
6079 buf[0] = 0x01;
6080 ret = usb_microdia_control_write(dev, reg, buf, 1);
6081 if (ret < 0)
6082 goto err;
6083
6084 reg = 0x1000;
6085 buf[0] = 0x78;
6086 ret = usb_microdia_control_write(dev, reg, buf, 1);
6087 if (ret < 0)
6088 goto err;
6089
6090 reg = 0x1002;
6091 buf[0] = 0x18;
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 = 0x11b8;
6103 buf[0] = 0x7b;
6104 ret = usb_microdia_control_write(dev, reg, buf, 1);
6105 if (ret < 0)
6106 goto err;
6107
6108 reg = 0x118a;
6109 buf[0] = 0x04;
6110 ret = usb_microdia_control_write(dev, reg, buf, 1);
6111 if (ret < 0)
6112 goto err;
6113
6114 reg = 0x0395;
6115 buf[0] = 0x04;
6116 ret = usb_microdia_control_write(dev, reg, buf, 1);
6117 if (ret < 0)
6118 goto err;
6119
6120 reg = 0x11b8;
6121 buf[0] = 0x78;
6122 ret = usb_microdia_control_write(dev, reg, buf, 1);
6123 if (ret < 0)
6124 goto err;
6125 ret = usb_microdia_control_read(dev, reg, buf, 1);
6126 if (ret < 0)
6127 goto err;
6128
6129 reg = 0x11b8;
6130 buf[0] = 0xf9;
6131 ret = usb_microdia_control_write(dev, reg, buf, 1);
6132 if (ret < 0)
6133 goto err;
6134 ret = usb_microdia_control_read(dev, reg, buf, 1);
6135 if (ret < 0)
6136 goto err;
6137
6138 reg = 0x11b8;
6139 buf[0] = 0xfa;
6140 ret = usb_microdia_control_write(dev, reg, buf, 1);
6141 if (ret < 0)
6142 goto err;
6143 ret = usb_microdia_control_read(dev, reg, buf, 1);
6144 if (ret < 0)
6145 goto err;
6146
6147 reg = 0x11b8;
6148 buf[0] = 0x7b;
6149 ret = usb_microdia_control_write(dev, reg, buf, 1);
6150 if (ret < 0)
6151 goto err;
6152 ret = usb_microdia_control_read(dev, reg, buf, 1);
6153 if (ret < 0)
6154 goto err;
6155
6156 reg = 0x11b8;
6157 buf[0] = 0x7c;
6158 ret = usb_microdia_control_write(dev, reg, buf, 1);
6159 if (ret < 0)
6160 goto err;
6161 ret = usb_microdia_control_read(dev, reg, buf, 1);
6162 if (ret < 0)
6163 goto err;
6164
6165 reg = 0x11b8;
6166 buf[0] = 0x7d;
6167 ret = usb_microdia_control_write(dev, reg, buf, 1);
6168 if (ret < 0)
6169 goto err;
6170 ret = usb_microdia_control_read(dev, reg, buf, 1);
6171 if (ret < 0)
6172 goto err;
6173
6174 reg = 0x11b8;
6175 buf[0] = 0x7b;
6176 ret = usb_microdia_control_write(dev, reg, buf, 1);
6177 if (ret < 0)
6178 goto err;
6179
6180 buf[0] = 0x40;
6181 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6182 OV7660_CTL_CLKRC, dev->sensor_flags, buf);
6183 if (ret < 0)
6184 goto errI2C;
6185
6186 buf[0] = 0x00;
6187 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6188 OV7660_CTL_EXHCH, 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_EXHCL, 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_DM_LNL, 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_LNH, dev->sensor_flags, buf);
6207 if (ret < 0)
6208 goto errI2C;
6209
6210 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6211 OV7660_CTL_PID, dev->sensor_flags, buf);
6212 if (ret < 0)
6213 goto errI2C;
6214
6215 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6216 OV7660_CTL_VER, dev->sensor_flags, buf);
6217 if (ret < 0)
6218 goto errI2C;
6219
6220 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6221 OV7660_CTL_MIDH, dev->sensor_flags, buf);
6222 if (ret < 0)
6223 goto errI2C;
6224
6225 ret = sn9c20x_read_i2c_data(dev, dev->sensor_slave_address, 1,
6226 OV7660_CTL_MIDL, dev->sensor_flags, buf);
6227 if (ret < 0)
6228 goto errI2C;
6229
6230 reg = 0x1061;
6231 buf[0] = 0x03;
6232 ret = usb_microdia_control_write(dev, reg, buf, 1);
6233 if (ret < 0)
6234 goto err;
6235
6236 reg = 0x1007;
6237 buf[0] = 0x60;
6238 ret = usb_microdia_control_write(dev, reg, buf, 1);
6239 if (ret < 0)
6240 goto err;
6241
6242 reg = 0x1006;
6243 buf[0] = 0x00;
6244 ret = usb_microdia_control_write(dev, reg, buf, 1);
6245 if (ret < 0)
6246 goto err;
6247
6248 reg = 0x1007;
6249 buf[0] = 0x60;
6250 ret = usb_microdia_control_write(dev, reg, buf, 1);
6251 if (ret < 0)
6252 goto err;
6253
6254 reg = 0x1006;
6255 buf[0] = 0x00;
6256 ret = usb_microdia_control_write(dev, reg, buf, 1);
6257 if (ret < 0)
6258 goto err;
6259
6260 buf[0] = 0x7f;
6261 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6262 OV7660_CTL_AECH, dev->sensor_flags, buf);
6263 if (ret < 0)
6264 goto errI2C;
6265
6266 buf[0] = 0x01;
6267 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6268 OV7660_CTL_COM1, dev->sensor_flags, buf);
6269 if (ret < 0)
6270 goto errI2C;
6271
6272 buf[0] = 0x13;
6273 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6274 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6275 if (ret < 0)
6276 goto errI2C;
6277
6278 buf[0] = 0x00; buf[1] = 0x01;
6279 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6280 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6281 if (ret < 0)
6282 goto errI2C;
6283
6284 buf[0] = 0x1e;
6285 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 1,
6286 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6287 if (ret < 0)
6288 goto errI2C;
6289
6290 buf[0] = 0x50; buf[1] = 0x60;
6291 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6292 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6293 if (ret < 0)
6294 goto errI2C;
6295
6296 buf[0] = 0xfc; buf[1] = 0x04;
6297 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6298 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6299 if (ret < 0)
6300 goto errI2C;
6301
6302 buf[0] = 0x1f; buf[1] = 0x00;
6303 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6304 OV7660_CTL_GAIN, dev->sensor_flags, buf);
6305 if (ret < 0)
6306 goto errI2C;
6307
6308 buf[0] = 0x48; buf[1] = 0x58;
6309 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6310 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6311 if (ret < 0)
6312 goto errI2C;
6313
6314 buf[0] = 0xf6; buf[1] = 0x0b;
6315 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6316 OV7660_CTL_ADVFL, dev->sensor_flags, buf);
6317 if (ret < 0)
6318 goto errI2C;
6319
6320 reg = 0x1006;
6321 buf[0] = 0x40;
6322 ret = usb_microdia_control_write(dev, reg, buf, 1);
6323 if (ret < 0)
6324 goto err;
6325
6326 buf[0] = 0x50; buf[1] = 0x60;
6327 ret = sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
6328 OV7660_CTL_BLUE, dev->sensor_flags, buf);
6329 if (ret < 0)
6330 goto errI2C;
6331
6332 return ret;
6333 err:
6334 UDIA_ERROR("r/w in bridge register %x failed (%d)!\n", reg, ret);
6335 return ret;
6336
6337 errI2C:
6338 UDIA_ERROR("r/w in sensor register %x failed (%d)!\n", reg, ret);
6339 return ret;
6340
6341 }
6342
6343 /**
6344 * @brief From UsbSnoop-plugin-parsed.log
6345 *
6346 * @param dev
6347 *
6348 * @returns 0 (OK) or <0 (Error)
6349 *
6350 * @author Vincent, Kuzja
6351 */
6352 int microdia_6288_start_stream(struct usb_microdia *dev)
6353 {
6354 int ret;
6355 __u16 reg;
6356 __u8 buf[64];
6357
6358
6359
6360 reg = 0x1066 ;
6361 buf[0] = 0x00;
6362 ret = usb_microdia_control_write(dev, reg, buf, 1);
6363 if (ret < 0)
6364 goto err;
6365
6366 reg = 0x1000 ;
6367 buf[0] = 0x78;
6368 ret = usb_microdia_control_write(dev, reg, buf, 1);
6369 if (ret < 0)
6370 goto err;
6371
6372 reg = 0x1001 ;
6373 buf[0] = 0xc7;
6374 ret = usb_microdia_control_write(dev, reg, buf, 1);
6375 if (ret < 0)
6376 goto err;
6377
6378 reg = 0x1002 ;
6379 buf[0] = 0x1c;
6380 ret = usb_microdia_control_write(dev, reg, buf, 1);
6381 if (ret < 0)
6382 goto err;
6383
6384 reg = 0x1061 ;
6385 buf[0] = 0x01;
6386 ret = usb_microdia_control_write(dev, reg, buf, 1);
6387 if (ret < 0)
6388 goto err;
6389
6390 reg = 0x1020 ;
6391 buf[0] = 0x80;
6392 ret = usb_microdia_control_write(dev, reg, buf, 1);
6393 if (ret < 0)
6394 goto err;
6395
6396 reg = 0x1067 ;
6397 buf[0] = 0x40; buf[1] = 0x30; buf[2] = 0x20;
6398 buf[3] = 0x10; buf[4] = 0x08;
6399 ret = usb_microdia_control_write(dev, reg, buf, 5);
6400 if (ret < 0)
6401 goto err;
6402
6403 reg = 0x10c0 ;
6404 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;
6405 ret = usb_microdia_control_write(dev, reg, buf, 9);
6406 if (ret < 0)
6407 goto err;
6408
6409 reg = 0x10e0 ;
6410 buf[0] = 0x44; buf[1] = 0x18; buf[2] = 0x00; buf[3] = 0x30;
6411 buf[4] = 0x00; buf[5] = 0x09; buf[6] = 0x00; buf[7] = 0xed;
6412 buf[8] = 0x0f; buf[9] = 0xda; buf[10] = 0x0f; buf[11] = 0x3a;
6413 buf[12] = 0x00; buf[13] = 0x3a; buf[14] = 0x00; buf[15] = 0xd0;
6414 buf[16] = 0x0f; buf[17] = 0xf7; buf[18] = 0x0f; buf[19] = 0x00;
6415 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x60; buf[23] = 0x0a;
6416 ret = usb_microdia_control_write(dev, reg, buf, 24);
6417 if (ret < 0)
6418 goto err;
6419
6420 reg = 0x10f8 ;
6421 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00;
6422 ret = usb_microdia_control_write(dev, reg, buf, 3);
6423 if (ret < 0)
6424 goto err;
6425
6426 reg = 0x10fb ;
6427 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
6428 ret = usb_microdia_control_write(dev, reg, buf, 5);
6429 if (ret < 0)
6430 goto err;
6431
6432 reg = 0x1188 ;
6433 buf[0] = 0x86; buf[1] = 0xcc; buf[2] = 0x08;
6434 ret = usb_microdia_control_write(dev, reg, buf, 3);
6435 if (ret < 0)
6436 goto err;
6437
6438 reg = 0x118b ;
6439 buf[0] = 0x00; buf[1] = 0x20; buf[2] = 0x20; buf[3] = 0x20;
6440 buf[4] = 0x20; buf[5] = 0x00; buf[6] = 0x24; buf[7] = 0x3b;
6441 buf[8] = 0x4f; buf[9] = 0x61; buf[10] = 0x71; buf[11] = 0x80;
6442 buf[12] = 0x8f; buf[13] = 0x9d; buf[14] = 0xab; buf[15] = 0xb8;
6443 buf[16] = 0xc4; buf[17] = 0xd1; buf[18] = 0xdd; buf[19] = 0xe9;
6444 buf[20] = 0xf4; buf[21] = 0xff;
6445 ret = usb_microdia_control_write(dev, reg, buf, 22);
6446 if (ret < 0)
6447 goto err;
6448
6449 reg = 0x11a1 ;
6450 buf[0] = 0x00; buf[1] = 0x00;
6451 ret = usb_microdia_control_write(dev, reg, buf, 2);
6452 if (ret < 0)
6453 goto err;
6454
6455 reg = 0x11b7 ;
6456 buf[0] = 0x60; buf[1] = 0x20; buf[2] = 0x00; buf[3] = 0x08;
6457 buf[4] = 0x00; buf[5] = 0x40; buf[6] = 0x01; buf[7] = 0xf0;
6458 buf[8] = 0x00;
6459 ret = usb_microdia_control_write(dev, reg, buf, 9);
6460 if (ret < 0)
6461 goto err;
6462
6463 reg = 0x11b8 ;
6464 buf[0] = 0x30;
6465 ret = usb_microdia_control_write(dev, reg, buf, 1);
6466 if (ret < 0)
6467 goto err;
6468
6469 reg = 0x1000 ;
6470 buf[0] = 0x78;
6471 ret = usb_microdia_control_write(dev, reg, buf, 1);
6472 if (ret < 0)
6473 goto err;
6474
6475 reg = 0x10c0 ;
6476 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6477 ret = usb_microdia_control_write(dev, reg, buf, 8);
6478 if (ret < 0)
6479 goto err;
6480
6481 reg = 0x10c0 ;
6482 ret = usb_microdia_control_read(dev, reg, buf, 1);
6483 if (ret < 0)
6484 goto err;
6485
6486 reg = 0x10c0 ;
6487 ret = usb_microdia_control_read(dev, reg, buf, 1);
6488 if (ret < 0)
6489 goto err;
6490
6491 reg = 0x10c0 ;
6492 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x12; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6493 ret = usb_microdia_control_write(dev, reg, buf, 8);
6494 if (ret < 0)
6495 goto err;
6496
6497 reg = 0x10c0 ;
6498 ret = usb_microdia_control_read(dev, reg, buf, 1);
6499 if (ret < 0)
6500 goto err;
6501
6502 reg = 0x10c0 ;
6503 ret = usb_microdia_control_read(dev, reg, buf, 1);
6504 if (ret < 0)
6505 goto err;
6506
6507 reg = 0x10c0 ;
6508 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6509 ret = usb_microdia_control_write(dev, reg, buf, 8);
6510 if (ret < 0)
6511 goto err;
6512
6513 reg = 0x10c0 ;
6514 ret = usb_microdia_control_read(dev, reg, buf, 1);
6515 if (ret < 0)
6516 goto err;
6517
6518 reg = 0x10c0 ;
6519 ret = usb_microdia_control_read(dev, reg, buf, 1);
6520 if (ret < 0)
6521 goto err;
6522
6523 reg = 0x10c0 ;
6524 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x0e; buf[3] = 0x61; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6525 ret = usb_microdia_control_write(dev, reg, buf, 8);
6526 if (ret < 0)
6527 goto err;
6528
6529 reg = 0x10c0 ;
6530 ret = usb_microdia_control_read(dev, reg, buf, 1);
6531 if (ret < 0)
6532 goto err;
6533
6534 reg = 0x10c0 ;
6535 ret = usb_microdia_control_read(dev, reg, buf, 1);
6536 if (ret < 0)
6537 goto err;
6538
6539 reg = 0x10c0 ;
6540 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6541 ret = usb_microdia_control_write(dev, reg, buf, 8);
6542 if (ret < 0)
6543 goto err;
6544
6545 reg = 0x10c0 ;
6546 ret = usb_microdia_control_read(dev, reg, buf, 1);
6547 if (ret < 0)
6548 goto err;
6549
6550 reg = 0x10c0 ;
6551 ret = usb_microdia_control_read(dev, reg, buf, 1);
6552 if (ret < 0)
6553 goto err;
6554
6555 reg = 0x10c0 ;
6556 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x13; buf[3] = 0xb8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6557 ret = usb_microdia_control_write(dev, reg, buf, 8);
6558 if (ret < 0)
6559 goto err;
6560
6561 reg = 0x10c0 ;
6562 ret = usb_microdia_control_read(dev, reg, buf, 1);
6563 if (ret < 0)
6564 goto err;
6565
6566 reg = 0x10c0 ;
6567 ret = usb_microdia_control_read(dev, reg, buf, 1);
6568 if (ret < 0)
6569 goto err;
6570
6571 reg = 0x10c0 ;
6572 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x14; buf[3] = 0x3e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6573 ret = usb_microdia_control_write(dev, reg, buf, 8);
6574 if (ret < 0)
6575 goto err;
6576
6577 reg = 0x10c0 ;
6578 ret = usb_microdia_control_read(dev, reg, buf, 1);
6579 if (ret < 0)
6580 goto err;
6581
6582 reg = 0x10c0 ;
6583 ret = usb_microdia_control_read(dev, reg, buf, 1);
6584 if (ret < 0)
6585 goto err;
6586
6587 reg = 0x10c0 ;
6588 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x16; buf[3] = 0x24; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6589 ret = usb_microdia_control_write(dev, reg, buf, 8);
6590 if (ret < 0)
6591 goto err;
6592
6593 reg = 0x10c0 ;
6594 ret = usb_microdia_control_read(dev, reg, buf, 1);
6595 if (ret < 0)
6596 goto err;
6597
6598 reg = 0x10c0 ;
6599 ret = usb_microdia_control_read(dev, reg, buf, 1);
6600 if (ret < 0)
6601 goto err;
6602
6603 reg = 0x10c0 ;
6604 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6605 ret = usb_microdia_control_write(dev, reg, buf, 8);
6606 if (ret < 0)
6607 goto err;
6608
6609 reg = 0x10c0 ;
6610 ret = usb_microdia_control_read(dev, reg, buf, 1);
6611 if (ret < 0)
6612 goto err;
6613
6614 reg = 0x10c0 ;
6615 ret = usb_microdia_control_read(dev, reg, buf, 1);
6616 if (ret < 0)
6617 goto err;
6618
6619 reg = 0x10c0 ;
6620 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6621 ret = usb_microdia_control_write(dev, reg, buf, 8);
6622 if (ret < 0)
6623 goto err;
6624
6625 reg = 0x10c0 ;
6626 ret = usb_microdia_control_read(dev, reg, buf, 1);
6627 if (ret < 0)
6628 goto err;
6629
6630 reg = 0x10c0 ;
6631 ret = usb_microdia_control_read(dev, reg, buf, 1);
6632 if (ret < 0)
6633 goto err;
6634
6635 reg = 0x10c0 ;
6636 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6637 ret = usb_microdia_control_write(dev, reg, buf, 8);
6638 if (ret < 0)
6639 goto err;
6640
6641 reg = 0x10c0 ;
6642 ret = usb_microdia_control_read(dev, reg, buf, 1);
6643 if (ret < 0)
6644 goto err;
6645
6646 reg = 0x10c0 ;
6647 ret = usb_microdia_control_read(dev, reg, buf, 1);
6648 if (ret < 0)
6649 goto err;
6650
6651 reg = 0x10c0 ;
6652 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x27; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6653 ret = usb_microdia_control_write(dev, reg, buf, 8);
6654 if (ret < 0)
6655 goto err;
6656
6657 reg = 0x10c0 ;
6658 ret = usb_microdia_control_read(dev, reg, buf, 1);
6659 if (ret < 0)
6660 goto err;
6661
6662 reg = 0x10c0 ;
6663 ret = usb_microdia_control_read(dev, reg, buf, 1);
6664 if (ret < 0)
6665 goto err;
6666
6667 reg = 0x10c0 ;
6668 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x28; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6669 ret = usb_microdia_control_write(dev, reg, buf, 8);
6670 if (ret < 0)
6671 goto err;
6672
6673 reg = 0x10c0 ;
6674 ret = usb_microdia_control_read(dev, reg, buf, 1);
6675 if (ret < 0)
6676 goto err;
6677
6678 reg = 0x10c0 ;
6679 ret = usb_microdia_control_read(dev, reg, buf, 1);
6680 if (ret < 0)
6681 goto err;
6682
6683 reg = 0x10c0 ;
6684 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x29; buf[3] = 0x15; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6685 ret = usb_microdia_control_write(dev, reg, buf, 8);
6686 if (ret < 0)
6687 goto err;
6688
6689 reg = 0x10c0 ;
6690 ret = usb_microdia_control_read(dev, reg, buf, 1);
6691 if (ret < 0)
6692 goto err;
6693
6694 reg = 0x10c0 ;
6695 ret = usb_microdia_control_read(dev, reg, buf, 1);
6696 if (ret < 0)
6697 goto err;
6698
6699 reg = 0x10c0 ;
6700 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2c; buf[3] = 0x08; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6701 ret = usb_microdia_control_write(dev, reg, buf, 8);
6702 if (ret < 0)
6703 goto err;
6704
6705 reg = 0x10c0 ;
6706 ret = usb_microdia_control_read(dev, reg, buf, 1);
6707 if (ret < 0)
6708 goto err;
6709
6710 reg = 0x10c0 ;
6711 ret = usb_microdia_control_read(dev, reg, buf, 1);
6712 if (ret < 0)
6713 goto err;
6714
6715 reg = 0x10c0 ;
6716 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6717 ret = usb_microdia_control_write(dev, reg, buf, 8);
6718 if (ret < 0)
6719 goto err;
6720
6721 reg = 0x10c0 ;
6722 ret = usb_microdia_control_read(dev, reg, buf, 1);
6723 if (ret < 0)
6724 goto err;
6725
6726 reg = 0x10c0 ;
6727 ret = usb_microdia_control_read(dev, reg, buf, 1);
6728 if (ret < 0)
6729 goto err;
6730
6731 reg = 0x10c0 ;
6732 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x34; buf[3] = 0x3d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6733 ret = usb_microdia_control_write(dev, reg, buf, 8);
6734 if (ret < 0)
6735 goto err;
6736
6737 reg = 0x10c0 ;
6738 ret = usb_microdia_control_read(dev, reg, buf, 1);
6739 if (ret < 0)
6740 goto err;
6741
6742 reg = 0x10c0 ;
6743 ret = usb_microdia_control_read(dev, reg, buf, 1);
6744 if (ret < 0)
6745 goto err;
6746
6747 reg = 0x10c0 ;
6748 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x35; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6749 ret = usb_microdia_control_write(dev, reg, buf, 8);
6750 if (ret < 0)
6751 goto err;
6752
6753 reg = 0x10c0 ;
6754 ret = usb_microdia_control_read(dev, reg, buf, 1);
6755 if (ret < 0)
6756 goto err;
6757
6758 reg = 0x10c0 ;
6759 ret = usb_microdia_control_read(dev, reg, buf, 1);
6760 if (ret < 0)
6761 goto err;
6762
6763 reg = 0x10c0 ;
6764 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x36; buf[3] = 0xf8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6765 ret = usb_microdia_control_write(dev, reg, buf, 8);
6766 if (ret < 0)
6767 goto err;
6768
6769 reg = 0x10c0 ;
6770 ret = usb_microdia_control_read(dev, reg, buf, 1);
6771 if (ret < 0)
6772 goto err;
6773
6774 reg = 0x10c0 ;
6775 ret = usb_microdia_control_read(dev, reg, buf, 1);
6776 if (ret < 0)
6777 goto err;
6778
6779 reg = 0x10c0 ;
6780 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x38; buf[3] = 0x12; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6781 ret = usb_microdia_control_write(dev, reg, buf, 8);
6782 if (ret < 0)
6783 goto err;
6784
6785 reg = 0x10c0 ;
6786 ret = usb_microdia_control_read(dev, reg, buf, 1);
6787 if (ret < 0)
6788 goto err;
6789
6790 reg = 0x10c0 ;
6791 ret = usb_microdia_control_read(dev, reg, buf, 1);
6792 if (ret < 0)
6793 goto err;
6794
6795 reg = 0x10c0 ;
6796 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x39; buf[3] = 0x57; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6797 ret = usb_microdia_control_write(dev, reg, buf, 8);
6798 if (ret < 0)
6799 goto err;
6800
6801 reg = 0x10c0 ;
6802 ret = usb_microdia_control_read(dev, reg, buf, 1);
6803 if (ret < 0)
6804 goto err;
6805
6806 reg = 0x10c0 ;
6807 ret = usb_microdia_control_read(dev, reg, buf, 1);
6808 if (ret < 0)
6809 goto err;
6810
6811 reg = 0x10c0 ;
6812 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6813 ret = usb_microdia_control_write(dev, reg, buf, 8);
6814 if (ret < 0)
6815 goto err;
6816
6817 reg = 0x10c0 ;
6818 ret = usb_microdia_control_read(dev, reg, buf, 1);
6819 if (ret < 0)
6820 goto err;
6821
6822 reg = 0x10c0 ;
6823 ret = usb_microdia_control_read(dev, reg, buf, 1);
6824 if (ret < 0)
6825 goto err;
6826
6827 reg = 0x10c0 ;
6828 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3b; buf[3] = 0xcc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6829 ret = usb_microdia_control_write(dev, reg, buf, 8);
6830 if (ret < 0)
6831 goto err;
6832
6833 reg = 0x10c0 ;
6834 ret = usb_microdia_control_read(dev, reg, buf, 1);
6835 if (ret < 0)
6836 goto err;
6837
6838 reg = 0x10c0 ;
6839 ret = usb_microdia_control_read(dev, reg, buf, 1);
6840 if (ret < 0)
6841 goto err;
6842
6843 reg = 0x10c0 ;
6844 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3c; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6845 ret = usb_microdia_control_write(dev, reg, buf, 8);
6846 if (ret < 0)
6847 goto err;
6848
6849 reg = 0x10c0 ;
6850 ret = usb_microdia_control_read(dev, reg, buf, 1);
6851 if (ret < 0)
6852 goto err;
6853
6854 reg = 0x10c0 ;
6855 ret = usb_microdia_control_read(dev, reg, buf, 1);
6856 if (ret < 0)
6857 goto err;
6858
6859 reg = 0x10c0 ;
6860 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3d; buf[3] = 0x19; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6861 ret = usb_microdia_control_write(dev, reg, buf, 8);
6862 if (ret < 0)
6863 goto err;
6864
6865 reg = 0x10c0 ;
6866 ret = usb_microdia_control_read(dev, reg, buf, 1);
6867 if (ret < 0)
6868 goto err;
6869
6870 reg = 0x10c0 ;
6871 ret = usb_microdia_control_read(dev, reg, buf, 1);
6872 if (ret < 0)
6873 goto err;
6874
6875 reg = 0x10c0 ;
6876 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3e; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6877 ret = usb_microdia_control_write(dev, reg, buf, 8);
6878 if (ret < 0)
6879 goto err;
6880
6881 reg = 0x10c0 ;
6882 ret = usb_microdia_control_read(dev, reg, buf, 1);
6883 if (ret < 0)
6884 goto err;
6885
6886 reg = 0x10c0 ;
6887 ret = usb_microdia_control_read(dev, reg, buf, 1);
6888 if (ret < 0)
6889 goto err;
6890
6891 reg = 0x10c0 ;
6892 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x3f; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6893 ret = usb_microdia_control_write(dev, reg, buf, 8);
6894 if (ret < 0)
6895 goto err;
6896
6897 reg = 0x10c0 ;
6898 ret = usb_microdia_control_read(dev, reg, buf, 1);
6899 if (ret < 0)
6900 goto err;
6901
6902 reg = 0x10c0 ;
6903 ret = usb_microdia_control_read(dev, reg, buf, 1);
6904 if (ret < 0)
6905 goto err;
6906
6907 reg = 0x10c0 ;
6908 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x41; buf[3] = 0x40; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6909 ret = usb_microdia_control_write(dev, reg, buf, 8);
6910 if (ret < 0)
6911 goto err;
6912
6913 reg = 0x10c0 ;
6914 ret = usb_microdia_control_read(dev, reg, buf, 1);
6915 if (ret < 0)
6916 goto err;
6917
6918 reg = 0x10c0 ;
6919 ret = usb_microdia_control_read(dev, reg, buf, 1);
6920 if (ret < 0)
6921 goto err;
6922
6923 reg = 0x10c0 ;
6924 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x42; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6925 ret = usb_microdia_control_write(dev, reg, buf, 8);
6926 if (ret < 0)
6927 goto err;
6928
6929 reg = 0x10c0 ;
6930 ret = usb_microdia_control_read(dev, reg, buf, 1);
6931 if (ret < 0)
6932 goto err;
6933
6934 reg = 0x10c0 ;
6935 ret = usb_microdia_control_read(dev, reg, buf, 1);
6936 if (ret < 0)
6937 goto err;
6938
6939 reg = 0x10c0 ;
6940 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x45; buf[3] = 0x46; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6941 ret = usb_microdia_control_write(dev, reg, buf, 8);
6942 if (ret < 0)
6943 goto err;
6944
6945 reg = 0x10c0 ;
6946 ret = usb_microdia_control_read(dev, reg, buf, 1);
6947 if (ret < 0)
6948 goto err;
6949
6950 reg = 0x10c0 ;
6951 ret = usb_microdia_control_read(dev, reg, buf, 1);
6952 if (ret < 0)
6953 goto err;
6954
6955 reg = 0x10c0 ;
6956 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x46; buf[3] = 0x62; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6957 ret = usb_microdia_control_write(dev, reg, buf, 8);
6958 if (ret < 0)
6959 goto err;
6960
6961 reg = 0x10c0 ;
6962 ret = usb_microdia_control_read(dev, reg, buf, 1);
6963 if (ret < 0)
6964 goto err;
6965
6966 reg = 0x10c0 ;
6967 ret = usb_microdia_control_read(dev, reg, buf, 1);
6968 if (ret < 0)
6969 goto err;
6970
6971 reg = 0x10c0 ;
6972 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x47; buf[3] = 0x2a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6973 ret = usb_microdia_control_write(dev, reg, buf, 8);
6974 if (ret < 0)
6975 goto err;
6976
6977 reg = 0x10c0 ;
6978 ret = usb_microdia_control_read(dev, reg, buf, 1);
6979 if (ret < 0)
6980 goto err;
6981
6982 reg = 0x10c0 ;
6983 ret = usb_microdia_control_read(dev, reg, buf, 1);
6984 if (ret < 0)
6985 goto err;
6986
6987 reg = 0x10c0 ;
6988 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x48; buf[3] = 0x3c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
6989 ret = usb_microdia_control_write(dev, reg, buf, 8);
6990 if (ret < 0)
6991 goto err;
6992
6993 reg = 0x10c0 ;
6994 ret = usb_microdia_control_read(dev, reg, buf, 1);
6995 if (ret < 0)
6996 goto err;
6997
6998 reg = 0x10c0 ;
6999 ret = usb_microdia_control_read(dev, reg, buf, 1);
7000 if (ret < 0)
7001 goto err;
7002
7003 reg = 0x10c0 ;
7004 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4a; buf[3] = 0xf0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7005 ret = usb_microdia_control_write(dev, reg, buf, 8);
7006 if (ret < 0)
7007 goto err;
7008
7009 reg = 0x10c0 ;
7010 ret = usb_microdia_control_read(dev, reg, buf, 1);
7011 if (ret < 0)
7012 goto err;
7013
7014 reg = 0x10c0 ;
7015 ret = usb_microdia_control_read(dev, reg, buf, 1);
7016 if (ret < 0)
7017 goto err;
7018
7019 reg = 0x10c0 ;
7020 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4b; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7021 ret = usb_microdia_control_write(dev, reg, buf, 8);
7022 if (ret < 0)
7023 goto err;
7024
7025 reg = 0x10c0 ;
7026 ret = usb_microdia_control_read(dev, reg, buf, 1);
7027 if (ret < 0)
7028 goto err;
7029
7030 reg = 0x10c0 ;
7031 ret = usb_microdia_control_read(dev, reg, buf, 1);
7032 if (ret < 0)
7033 goto err;
7034
7035 reg = 0x10c0 ;
7036 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4c; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7037 ret = usb_microdia_control_write(dev, reg, buf, 8);
7038 if (ret < 0)
7039 goto err;
7040
7041 reg = 0x10c0 ;
7042 ret = usb_microdia_control_read(dev, reg, buf, 1);
7043 if (ret < 0)
7044 goto err;
7045
7046 reg = 0x10c0 ;
7047 ret = usb_microdia_control_read(dev, reg, buf, 1);
7048 if (ret < 0)
7049 goto err;
7050
7051 reg = 0x10c0 ;
7052 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4d; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7053 ret = usb_microdia_control_write(dev, reg, buf, 8);
7054 if (ret < 0)
7055 goto err;
7056
7057 reg = 0x10c0 ;
7058 ret = usb_microdia_control_read(dev, reg, buf, 1);
7059 if (ret < 0)
7060 goto err;
7061
7062 reg = 0x10c0 ;
7063 ret = usb_microdia_control_read(dev, reg, buf, 1);
7064 if (ret < 0)
7065 goto err;
7066
7067 reg = 0x10c0 ;
7068 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x4e; buf[3] = 0xdc; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7069 ret = usb_microdia_control_write(dev, reg, buf, 8);
7070 if (ret < 0)
7071 goto err;
7072
7073 reg = 0x10c0 ;
7074 ret = usb_microdia_control_read(dev, reg, buf, 1);
7075 if (ret < 0)
7076 goto err;
7077
7078 reg = 0x10c0 ;
7079 ret = usb_microdia_control_read(dev, reg, buf, 1);
7080 if (ret < 0)
7081 goto err;
7082
7083 reg = 0x10c0 ;
7084 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x69; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7085 ret = usb_microdia_control_write(dev, reg, buf, 8);
7086 if (ret < 0)
7087 goto err;
7088
7089 reg = 0x10c0 ;
7090 ret = usb_microdia_control_read(dev, reg, buf, 1);
7091 if (ret < 0)
7092 goto err;
7093
7094 reg = 0x10c0 ;
7095 ret = usb_microdia_control_read(dev, reg, buf, 1);
7096 if (ret < 0)
7097 goto err;
7098
7099 reg = 0x10c0 ;
7100 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6c; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7101 ret = usb_microdia_control_write(dev, reg, buf, 8);
7102 if (ret < 0)
7103 goto err;
7104
7105 reg = 0x10c0 ;
7106 ret = usb_microdia_control_read(dev, reg, buf, 1);
7107 if (ret < 0)
7108 goto err;
7109
7110 reg = 0x10c0 ;
7111 ret = usb_microdia_control_read(dev, reg, buf, 1);
7112 if (ret < 0)
7113 goto err;
7114
7115 reg = 0x10c0 ;
7116 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x6f; buf[3] = 0x9e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7117 ret = usb_microdia_control_write(dev, reg, buf, 8);
7118 if (ret < 0)
7119 goto err;
7120
7121 reg = 0x10c0 ;
7122 ret = usb_microdia_control_read(dev, reg, buf, 1);
7123 if (ret < 0)
7124 goto err;
7125
7126 reg = 0x10c0 ;
7127 ret = usb_microdia_control_read(dev, reg, buf, 1);
7128 if (ret < 0)
7129 goto err;
7130
7131 reg = 0x10c0 ;
7132 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x70; buf[3] = 0x05; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7133 ret = usb_microdia_control_write(dev, reg, buf, 8);
7134 if (ret < 0)
7135 goto err;
7136
7137 reg = 0x10c0 ;
7138 ret = usb_microdia_control_read(dev, reg, buf, 1);
7139 if (ret < 0)
7140 goto err;
7141
7142 reg = 0x10c0 ;
7143 ret = usb_microdia_control_read(dev, reg, buf, 1);
7144 if (ret < 0)
7145 goto err;
7146
7147 reg = 0x10c0 ;
7148 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x71; buf[3] = 0x78; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7149 ret = usb_microdia_control_write(dev, reg, buf, 8);
7150 if (ret < 0)
7151 goto err;
7152
7153 reg = 0x10c0 ;
7154 ret = usb_microdia_control_read(dev, reg, buf, 1);
7155 if (ret < 0)
7156 goto err;
7157
7158 reg = 0x10c0 ;
7159 ret = usb_microdia_control_read(dev, reg, buf, 1);
7160 if (ret < 0)
7161 goto err;
7162
7163 reg = 0x10c0 ;
7164 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x77; buf[3] = 0x02; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7165 ret = usb_microdia_control_write(dev, reg, buf, 8);
7166 if (ret < 0)
7167 goto err;
7168
7169 reg = 0x10c0 ;
7170 ret = usb_microdia_control_read(dev, reg, buf, 1);
7171 if (ret < 0)
7172 goto err;
7173
7174 reg = 0x10c0 ;
7175 ret = usb_microdia_control_read(dev, reg, buf, 1);
7176 if (ret < 0)
7177 goto err;
7178
7179 reg = 0x10c0 ;
7180 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8a; buf[3] = 0x23; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7181 ret = usb_microdia_control_write(dev, reg, buf, 8);
7182 if (ret < 0)
7183 goto err;
7184
7185 reg = 0x10c0 ;
7186 ret = usb_microdia_control_read(dev, reg, buf, 1);
7187 if (ret < 0)
7188 goto err;
7189
7190 reg = 0x10c0 ;
7191 ret = usb_microdia_control_read(dev, reg, buf, 1);
7192 if (ret < 0)
7193 goto err;
7194
7195 reg = 0x10c0 ;
7196 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x8c; buf[3] = 0x0d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7197 ret = usb_microdia_control_write(dev, reg, buf, 8);
7198 if (ret < 0)
7199 goto err;
7200
7201 reg = 0x10c0 ;
7202 ret = usb_microdia_control_read(dev, reg, buf, 1);
7203 if (ret < 0)
7204 goto err;
7205
7206 reg = 0x10c0 ;
7207 ret = usb_microdia_control_read(dev, reg, buf, 1);
7208 if (ret < 0)
7209 goto err;
7210
7211 reg = 0x10c0 ;
7212 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x90; buf[3] = 0x7e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7213 ret = usb_microdia_control_write(dev, reg, buf, 8);
7214 if (ret < 0)
7215 goto err;
7216
7217 reg = 0x10c0 ;
7218 ret = usb_microdia_control_read(dev, reg, buf, 1);
7219 if (ret < 0)
7220 goto err;
7221
7222 reg = 0x10c0 ;
7223 ret = usb_microdia_control_read(dev, reg, buf, 1);
7224 if (ret < 0)
7225 goto err;
7226
7227 reg = 0x10c0 ;
7228 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x91; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7229 ret = usb_microdia_control_write(dev, reg, buf, 8);
7230 if (ret < 0)
7231 goto err;
7232
7233 reg = 0x10c0 ;
7234 ret = usb_microdia_control_read(dev, reg, buf, 1);
7235 if (ret < 0)
7236 goto err;
7237
7238 reg = 0x10c0 ;
7239 ret = usb_microdia_control_read(dev, reg, buf, 1);
7240 if (ret < 0)
7241 goto err;
7242
7243 reg = 0x10c0 ;
7244 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x9f; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7245 ret = usb_microdia_control_write(dev, reg, buf, 8);
7246 if (ret < 0)
7247 goto err;
7248
7249 reg = 0x10c0 ;
7250 ret = usb_microdia_control_read(dev, reg, buf, 1);
7251 if (ret < 0)
7252 goto err;
7253
7254 reg = 0x10c0 ;
7255 ret = usb_microdia_control_read(dev, reg, buf, 1);
7256 if (ret < 0)
7257 goto err;
7258
7259 reg = 0x10c0 ;
7260 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa0; buf[3] = 0x6e; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7261 ret = usb_microdia_control_write(dev, reg, buf, 8);
7262 if (ret < 0)
7263 goto err;
7264
7265 reg = 0x10c0 ;
7266 ret = usb_microdia_control_read(dev, reg, buf, 1);
7267 if (ret < 0)
7268 goto err;
7269
7270 reg = 0x10c0 ;
7271 ret = usb_microdia_control_read(dev, reg, buf, 1);
7272 if (ret < 0)
7273 goto err;
7274
7275 reg = 0x10c0 ;
7276 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa4; buf[3] = 0x50; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7277 ret = usb_microdia_control_write(dev, reg, buf, 8);
7278 if (ret < 0)
7279 goto err;
7280
7281 reg = 0x10c0 ;
7282 ret = usb_microdia_control_read(dev, reg, buf, 1);
7283 if (ret < 0)
7284 goto err;
7285
7286 reg = 0x10c0 ;
7287 ret = usb_microdia_control_read(dev, reg, buf, 1);
7288 if (ret < 0)
7289 goto err;
7290
7291 reg = 0x10c0 ;
7292 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa5; buf[3] = 0x68; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7293 ret = usb_microdia_control_write(dev, reg, buf, 8);
7294 if (ret < 0)
7295 goto err;
7296
7297 reg = 0x10c0 ;
7298 ret = usb_microdia_control_read(dev, reg, buf, 1);
7299 if (ret < 0)
7300 goto err;
7301
7302 reg = 0x10c0 ;
7303 ret = usb_microdia_control_read(dev, reg, buf, 1);
7304 if (ret < 0)
7305 goto err;
7306
7307 reg = 0x10c0 ;
7308 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa6; buf[3] = 0x60; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7309 ret = usb_microdia_control_write(dev, reg, buf, 8);
7310 if (ret < 0)
7311 goto err;
7312
7313 reg = 0x10c0 ;
7314 ret = usb_microdia_control_read(dev, reg, buf, 1);
7315 if (ret < 0)
7316 goto err;
7317
7318 reg = 0x10c0 ;
7319 ret = usb_microdia_control_read(dev, reg, buf, 1);
7320 if (ret < 0)
7321 goto err;
7322
7323 reg = 0x10c0 ;
7324 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa8; buf[3] = 0xc1; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7325 ret = usb_microdia_control_write(dev, reg, buf, 8);
7326 if (ret < 0)
7327 goto err;
7328
7329 reg = 0x10c0 ;
7330 ret = usb_microdia_control_read(dev, reg, buf, 1);
7331 if (ret < 0)
7332 goto err;
7333
7334 reg = 0x10c0 ;
7335 ret = usb_microdia_control_read(dev, reg, buf, 1);
7336 if (ret < 0)
7337 goto err;
7338
7339 reg = 0x10c0 ;
7340 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa9; buf[3] = 0xfa; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7341 ret = usb_microdia_control_write(dev, reg, buf, 8);
7342 if (ret < 0)
7343 goto err;
7344
7345 reg = 0x10c0 ;
7346 ret = usb_microdia_control_read(dev, reg, buf, 1);
7347 if (ret < 0)
7348 goto err;
7349
7350 reg = 0x10c0 ;
7351 ret = usb_microdia_control_read(dev, reg, buf, 1);
7352 if (ret < 0)
7353 goto err;
7354
7355 reg = 0x10c0 ;
7356 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaa; buf[3] = 0x92; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7357 ret = usb_microdia_control_write(dev, reg, buf, 8);
7358 if (ret < 0)
7359 goto err;
7360
7361 reg = 0x10c0 ;
7362 ret = usb_microdia_control_read(dev, reg, buf, 1);
7363 if (ret < 0)
7364 goto err;
7365
7366 reg = 0x10c0 ;
7367 ret = usb_microdia_control_read(dev, reg, buf, 1);
7368 if (ret < 0)
7369 goto err;
7370
7371 reg = 0x10c0 ;
7372 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xab; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7373 ret = usb_microdia_control_write(dev, reg, buf, 8);
7374 if (ret < 0)
7375 goto err;
7376
7377 reg = 0x10c0 ;
7378 ret = usb_microdia_control_read(dev, reg, buf, 1);
7379 if (ret < 0)
7380 goto err;
7381
7382 reg = 0x10c0 ;
7383 ret = usb_microdia_control_read(dev, reg, buf, 1);
7384 if (ret < 0)
7385 goto err;
7386
7387 reg = 0x10c0 ;
7388 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xac; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7389 ret = usb_microdia_control_write(dev, reg, buf, 8);
7390 if (ret < 0)
7391 goto err;
7392
7393 reg = 0x10c0 ;
7394 ret = usb_microdia_control_read(dev, reg, buf, 1);
7395 if (ret < 0)
7396 goto err;
7397
7398 reg = 0x10c0 ;
7399 ret = usb_microdia_control_read(dev, reg, buf, 1);
7400 if (ret < 0)
7401 goto err;
7402
7403 reg = 0x10c0 ;
7404 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xad; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7405 ret = usb_microdia_control_write(dev, reg, buf, 8);
7406 if (ret < 0)
7407 goto err;
7408
7409 reg = 0x10c0 ;
7410 ret = usb_microdia_control_read(dev, reg, buf, 1);
7411 if (ret < 0)
7412 goto err;
7413
7414 reg = 0x10c0 ;
7415 ret = usb_microdia_control_read(dev, reg, buf, 1);
7416 if (ret < 0)
7417 goto err;
7418
7419 reg = 0x10c0 ;
7420 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xae; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7421 ret = usb_microdia_control_write(dev, reg, buf, 8);
7422 if (ret < 0)
7423 goto err;
7424
7425 reg = 0x10c0 ;
7426 ret = usb_microdia_control_read(dev, reg, buf, 1);
7427 if (ret < 0)
7428 goto err;
7429
7430 reg = 0x10c0 ;
7431 ret = usb_microdia_control_read(dev, reg, buf, 1);
7432 if (ret < 0)
7433 goto err;
7434
7435 reg = 0x10c0 ;
7436 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xaf; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7437 ret = usb_microdia_control_write(dev, reg, buf, 8);
7438 if (ret < 0)
7439 goto err;
7440
7441 reg = 0x10c0 ;
7442 ret = usb_microdia_control_read(dev, reg, buf, 1);
7443 if (ret < 0)
7444 goto err;
7445
7446 reg = 0x10c0 ;
7447 ret = usb_microdia_control_read(dev, reg, buf, 1);
7448 if (ret < 0)
7449 goto err;
7450
7451 reg = 0x10c0 ;
7452 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb2; buf[3] = 0xf2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7453 ret = usb_microdia_control_write(dev, reg, buf, 8);
7454 if (ret < 0)
7455 goto err;
7456
7457 reg = 0x10c0 ;
7458 ret = usb_microdia_control_read(dev, reg, buf, 1);
7459 if (ret < 0)
7460 goto err;
7461
7462 reg = 0x10c0 ;
7463 ret = usb_microdia_control_read(dev, reg, buf, 1);
7464 if (ret < 0)
7465 goto err;
7466
7467 reg = 0x10c0 ;
7468 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb3; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7469 ret = usb_microdia_control_write(dev, reg, buf, 8);
7470 if (ret < 0)
7471 goto err;
7472
7473 reg = 0x10c0 ;
7474 ret = usb_microdia_control_read(dev, reg, buf, 1);
7475 if (ret < 0)
7476 goto err;
7477
7478 reg = 0x10c0 ;
7479 ret = usb_microdia_control_read(dev, reg, buf, 1);
7480 if (ret < 0)
7481 goto err;
7482
7483 reg = 0x10c0 ;
7484 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb4; buf[3] = 0x20; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7485 ret = usb_microdia_control_write(dev, reg, buf, 8);
7486 if (ret < 0)
7487 goto err;
7488
7489 reg = 0x10c0 ;
7490 ret = usb_microdia_control_read(dev, reg, buf, 1);
7491 if (ret < 0)
7492 goto err;
7493
7494 reg = 0x10c0 ;
7495 ret = usb_microdia_control_read(dev, reg, buf, 1);
7496 if (ret < 0)
7497 goto err;
7498
7499 reg = 0x10c0 ;
7500 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb5; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7501 ret = usb_microdia_control_write(dev, reg, buf, 8);
7502 if (ret < 0)
7503 goto err;
7504
7505 reg = 0x10c0 ;
7506 ret = usb_microdia_control_read(dev, reg, buf, 1);
7507 if (ret < 0)
7508 goto err;
7509
7510 reg = 0x10c0 ;
7511 ret = usb_microdia_control_read(dev, reg, buf, 1);
7512 if (ret < 0)
7513 goto err;
7514
7515 reg = 0x10c0 ;
7516 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xb6; buf[3] = 0xaf; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7517 ret = usb_microdia_control_write(dev, reg, buf, 8);
7518 if (ret < 0)
7519 goto err;
7520
7521 reg = 0x10c0 ;
7522 ret = usb_microdia_control_read(dev, reg, buf, 1);
7523 if (ret < 0)
7524 goto err;
7525
7526 reg = 0x10c0 ;
7527 ret = usb_microdia_control_read(dev, reg, buf, 1);
7528 if (ret < 0)
7529 goto err;
7530
7531 reg = 0x10c0 ;
7532 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbb; buf[3] = 0xae; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7533 ret = usb_microdia_control_write(dev, reg, buf, 8);
7534 if (ret < 0)
7535 goto err;
7536
7537 reg = 0x10c0 ;
7538 ret = usb_microdia_control_read(dev, reg, buf, 1);
7539 if (ret < 0)
7540 goto err;
7541
7542 reg = 0x10c0 ;
7543 ret = usb_microdia_control_read(dev, reg, buf, 1);
7544 if (ret < 0)
7545 goto err;
7546
7547 reg = 0x10c0 ;
7548 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbc; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7549 ret = usb_microdia_control_write(dev, reg, buf, 8);
7550 if (ret < 0)
7551 goto err;
7552
7553 reg = 0x10c0 ;
7554 ret = usb_microdia_control_read(dev, reg, buf, 1);
7555 if (ret < 0)
7556 goto err;
7557
7558 reg = 0x10c0 ;
7559 ret = usb_microdia_control_read(dev, reg, buf, 1);
7560 if (ret < 0)
7561 goto err;
7562
7563 reg = 0x10c0 ;
7564 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbd; buf[3] = 0x44; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7565 ret = usb_microdia_control_write(dev, reg, buf, 8);
7566 if (ret < 0)
7567 goto err;
7568
7569 reg = 0x10c0 ;
7570 ret = usb_microdia_control_read(dev, reg, buf, 1);
7571 if (ret < 0)
7572 goto err;
7573
7574 reg = 0x10c0 ;
7575 ret = usb_microdia_control_read(dev, reg, buf, 1);
7576 if (ret < 0)
7577 goto err;
7578
7579 reg = 0x10c0 ;
7580 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbe; buf[3] = 0x3b; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7581 ret = usb_microdia_control_write(dev, reg, buf, 8);
7582 if (ret < 0)
7583 goto err;
7584
7585 reg = 0x10c0 ;
7586 ret = usb_microdia_control_read(dev, reg, buf, 1);
7587 if (ret < 0)
7588 goto err;
7589
7590 reg = 0x10c0 ;
7591 ret = usb_microdia_control_read(dev, reg, buf, 1);
7592 if (ret < 0)
7593 goto err;
7594
7595 reg = 0x10c0 ;
7596 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xbf; buf[3] = 0x3a; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7597 ret = usb_microdia_control_write(dev, reg, buf, 8);
7598 if (ret < 0)
7599 goto err;
7600
7601 reg = 0x10c0 ;
7602 ret = usb_microdia_control_read(dev, reg, buf, 1);
7603 if (ret < 0)
7604 goto err;
7605
7606 reg = 0x10c0 ;
7607 ret = usb_microdia_control_read(dev, reg, buf, 1);
7608 if (ret < 0)
7609 goto err;
7610
7611 reg = 0x10c0 ;
7612 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc0; buf[3] = 0xe2; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7613 ret = usb_microdia_control_write(dev, reg, buf, 8);
7614 if (ret < 0)
7615 goto err;
7616
7617 reg = 0x10c0 ;
7618 ret = usb_microdia_control_read(dev, reg, buf, 1);
7619 if (ret < 0)
7620 goto err;
7621
7622 reg = 0x10c0 ;
7623 ret = usb_microdia_control_read(dev, reg, buf, 1);
7624 if (ret < 0)
7625 goto err;
7626
7627 reg = 0x10c0 ;
7628 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc1; buf[3] = 0xc8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7629 ret = usb_microdia_control_write(dev, reg, buf, 8);
7630 if (ret < 0)
7631 goto err;
7632
7633 reg = 0x10c0 ;
7634 ret = usb_microdia_control_read(dev, reg, buf, 1);
7635 if (ret < 0)
7636 goto err;
7637
7638 reg = 0x10c0 ;
7639 ret = usb_microdia_control_read(dev, reg, buf, 1);
7640 if (ret < 0)
7641 goto err;
7642
7643 reg = 0x10c0 ;
7644 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc2; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7645 ret = usb_microdia_control_write(dev, reg, buf, 8);
7646 if (ret < 0)
7647 goto err;
7648
7649 reg = 0x10c0 ;
7650 ret = usb_microdia_control_read(dev, reg, buf, 1);
7651 if (ret < 0)
7652 goto err;
7653
7654 reg = 0x10c0 ;
7655 ret = usb_microdia_control_read(dev, reg, buf, 1);
7656 if (ret < 0)
7657 goto err;
7658
7659 reg = 0x10c0 ;
7660 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc4; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7661 ret = usb_microdia_control_write(dev, reg, buf, 8);
7662 if (ret < 0)
7663 goto err;
7664
7665 reg = 0x10c0 ;
7666 ret = usb_microdia_control_read(dev, reg, buf, 1);
7667 if (ret < 0)
7668 goto err;
7669
7670 reg = 0x10c0 ;
7671 ret = usb_microdia_control_read(dev, reg, buf, 1);
7672 if (ret < 0)
7673 goto err;
7674
7675 reg = 0x10c0 ;
7676 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc6; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7677 ret = usb_microdia_control_write(dev, reg, buf, 8);
7678 if (ret < 0)
7679 goto err;
7680
7681 reg = 0x10c0 ;
7682 ret = usb_microdia_control_read(dev, reg, buf, 1);
7683 if (ret < 0)
7684 goto err;
7685
7686 reg = 0x10c0 ;
7687 ret = usb_microdia_control_read(dev, reg, buf, 1);
7688 if (ret < 0)
7689 goto err;
7690
7691 reg = 0x10c0 ;
7692 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc7; buf[3] = 0x81; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7693 ret = usb_microdia_control_write(dev, reg, buf, 8);
7694 if (ret < 0)
7695 goto err;
7696
7697 reg = 0x10c0 ;
7698 ret = usb_microdia_control_read(dev, reg, buf, 1);
7699 if (ret < 0)
7700 goto err;
7701
7702 reg = 0x10c0 ;
7703 ret = usb_microdia_control_read(dev, reg, buf, 1);
7704 if (ret < 0)
7705 goto err;
7706
7707 reg = 0x10c0 ;
7708 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xc9; buf[3] = 0xe0; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7709 ret = usb_microdia_control_write(dev, reg, buf, 8);
7710 if (ret < 0)
7711 goto err;
7712
7713 reg = 0x10c0 ;
7714 ret = usb_microdia_control_read(dev, reg, buf, 1);
7715 if (ret < 0)
7716 goto err;
7717
7718 reg = 0x10c0 ;
7719 ret = usb_microdia_control_read(dev, reg, buf, 1);
7720 if (ret < 0)
7721 goto err;
7722
7723 reg = 0x10c0 ;
7724 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xca; buf[3] = 0xe8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7725 ret = usb_microdia_control_write(dev, reg, buf, 8);
7726 if (ret < 0)
7727 goto err;
7728
7729 reg = 0x10c0 ;
7730 ret = usb_microdia_control_read(dev, reg, buf, 1);
7731 if (ret < 0)
7732 goto err;
7733
7734 reg = 0x10c0 ;
7735 ret = usb_microdia_control_read(dev, reg, buf, 1);
7736 if (ret < 0)
7737 goto err;
7738
7739 reg = 0x10c0 ;
7740 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcc; buf[3] = 0xd8; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7741 ret = usb_microdia_control_write(dev, reg, buf, 8);
7742 if (ret < 0)
7743 goto err;
7744
7745 reg = 0x10c0 ;
7746 ret = usb_microdia_control_read(dev, reg, buf, 1);
7747 if (ret < 0)
7748 goto err;
7749
7750 reg = 0x10c0 ;
7751 ret = usb_microdia_control_read(dev, reg, buf, 1);
7752 if (ret < 0)
7753 goto err;
7754
7755 reg = 0x10c0 ;
7756 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xcd; buf[3] = 0x93; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7757 ret = usb_microdia_control_write(dev, reg, buf, 8);
7758 if (ret < 0)
7759 goto err;
7760
7761 reg = 0x10c0 ;
7762 ret = usb_microdia_control_read(dev, reg, buf, 1);
7763 if (ret < 0)
7764 goto err;
7765
7766 reg = 0x10c0 ;
7767 ret = usb_microdia_control_read(dev, reg, buf, 1);
7768 if (ret < 0)
7769 goto err;
7770
7771 reg = 0x10c1 ;
7772 ret = usb_microdia_control_read(dev, reg, buf, 1);
7773 if (ret < 0)
7774 goto err;
7775
7776 reg = 0x10c1 ;
7777 buf[0] = 0x50;
7778 ret = usb_microdia_control_write(dev, reg, buf, 1);
7779 if (ret < 0)
7780 goto err;
7781
7782 reg = 0x10c0 ;
7783 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7784 ret = usb_microdia_control_write(dev, reg, buf, 8);
7785 if (ret < 0)
7786 goto err;
7787
7788 reg = 0x10c0 ;
7789 ret = usb_microdia_control_read(dev, reg, buf, 1);
7790 if (ret < 0)
7791 goto err;
7792
7793 reg = 0x10c0 ;
7794 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7795 ret = usb_microdia_control_write(dev, reg, buf, 8);
7796 if (ret < 0)
7797 goto err;
7798
7799 reg = 0x10c0 ;
7800 ret = usb_microdia_control_read(dev, reg, buf, 1);
7801 if (ret < 0)
7802 goto err;
7803
7804 reg = 0x10c0 ;
7805 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7806 ret = usb_microdia_control_write(dev, reg, buf, 8);
7807 if (ret < 0)
7808 goto err;
7809
7810 reg = 0x10c0 ;
7811 ret = usb_microdia_control_read(dev, reg, buf, 1);
7812 if (ret < 0)
7813 goto err;
7814
7815 reg = 0x10c0 ;
7816 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7817 ret = usb_microdia_control_write(dev, reg, buf, 8);
7818 if (ret < 0)
7819 goto err;
7820
7821 reg = 0x10c0 ;
7822 ret = usb_microdia_control_read(dev, reg, buf, 1);
7823 if (ret < 0)
7824 goto err;
7825
7826 reg = 0x10c0 ;
7827 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7828 ret = usb_microdia_control_write(dev, reg, buf, 8);
7829 if (ret < 0)
7830 goto err;
7831
7832 reg = 0x10c0 ;
7833 ret = usb_microdia_control_read(dev, reg, buf, 1);
7834 if (ret < 0)
7835 goto err;
7836
7837 reg = 0x10c0 ;
7838 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7839 ret = usb_microdia_control_write(dev, reg, buf, 8);
7840 if (ret < 0)
7841 goto err;
7842
7843 reg = 0x10c0 ;
7844 ret = usb_microdia_control_read(dev, reg, buf, 1);
7845 if (ret < 0)
7846 goto err;
7847
7848 reg = 0x10c0 ;
7849 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7850 ret = usb_microdia_control_write(dev, reg, buf, 8);
7851 if (ret < 0)
7852 goto err;
7853
7854 reg = 0x10c0 ;
7855 ret = usb_microdia_control_read(dev, reg, buf, 1);
7856 if (ret < 0)
7857 goto err;
7858
7859 reg = 0x10c0 ;
7860 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7861 ret = usb_microdia_control_write(dev, reg, buf, 8);
7862 if (ret < 0)
7863 goto err;
7864
7865 reg = 0x10c0 ;
7866 ret = usb_microdia_control_read(dev, reg, buf, 1);
7867 if (ret < 0)
7868 goto err;
7869
7870 reg = 0x10c0 ;
7871 buf[0] = 0x90; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7872 ret = usb_microdia_control_write(dev, reg, buf, 8);
7873 if (ret < 0)
7874 goto err;
7875
7876 reg = 0x10c0 ;
7877 buf[0] = 0x92; 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 ret = usb_microdia_control_read(dev, reg, buf, 1);
7884 if (ret < 0)
7885 goto err;
7886
7887 reg = 0x10c0 ;
7888 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7889 ret = usb_microdia_control_write(dev, reg, buf, 8);
7890 if (ret < 0)
7891 goto err;
7892
7893 reg = 0x10c0 ;
7894 ret = usb_microdia_control_read(dev, reg, buf, 1);
7895 if (ret < 0)
7896 goto err;
7897
7898 reg = 0x10c0 ;
7899 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7900 ret = usb_microdia_control_write(dev, reg, buf, 8);
7901 if (ret < 0)
7902 goto err;
7903
7904 reg = 0x10c0 ;
7905 ret = usb_microdia_control_read(dev, reg, buf, 1);
7906 if (ret < 0)
7907 goto err;
7908
7909 reg = 0x10c0 ;
7910 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7911 ret = usb_microdia_control_write(dev, reg, buf, 8);
7912 if (ret < 0)
7913 goto err;
7914
7915 reg = 0x10c0 ;
7916 ret = usb_microdia_control_read(dev, reg, buf, 1);
7917 if (ret < 0)
7918 goto err;
7919
7920 reg = 0x10c0 ;
7921 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7922 ret = usb_microdia_control_write(dev, reg, buf, 8);
7923 if (ret < 0)
7924 goto err;
7925
7926 reg = 0x10c0 ;
7927 ret = usb_microdia_control_read(dev, reg, buf, 1);
7928 if (ret < 0)
7929 goto err;
7930
7931 reg = 0x10c0 ;
7932 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7933 ret = usb_microdia_control_write(dev, reg, buf, 8);
7934 if (ret < 0)
7935 goto err;
7936
7937 reg = 0x10c0 ;
7938 ret = usb_microdia_control_read(dev, reg, buf, 1);
7939 if (ret < 0)
7940 goto err;
7941
7942 reg = 0x10c0 ;
7943 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7944 ret = usb_microdia_control_write(dev, reg, buf, 8);
7945 if (ret < 0)
7946 goto err;
7947
7948 reg = 0x10c0 ;
7949 ret = usb_microdia_control_read(dev, reg, buf, 1);
7950 if (ret < 0)
7951 goto err;
7952
7953 reg = 0x10c0 ;
7954 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7955 ret = usb_microdia_control_write(dev, reg, buf, 8);
7956 if (ret < 0)
7957 goto err;
7958
7959 reg = 0x10c0 ;
7960 ret = usb_microdia_control_read(dev, reg, buf, 1);
7961 if (ret < 0)
7962 goto err;
7963
7964 reg = 0x10c0 ;
7965 buf[0] = 0x92; buf[1] = 0x50; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
7966 ret = usb_microdia_control_write(dev, reg, buf, 8);
7967 if (ret < 0)
7968 goto err;
7969
7970 reg = 0x10c2 ;
7971 ret = usb_microdia_control_read(dev, reg, buf, 5);
7972 if (ret < 0)
7973 goto err;
7974
7975 reg = 0x10c1 ;
7976 buf[0] = 0x30;
7977 ret = usb_microdia_control_write(dev, reg, buf, 1);
7978 if (ret < 0)
7979 goto err;
7980
7981 reg = 0x10e0 ;
7982 buf[0] = 0x47;
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 = 0x1001 ;
7994 buf[0] = 0xc6;
7995 ret = usb_microdia_control_write(dev, reg, buf, 1);
7996 if (ret < 0)
7997 goto err;
7998
7999 reg = 0x1001 ;
8000 buf[0] = 0xc4;
8001 ret = usb_microdia_control_write(dev, reg, buf, 1);
8002 if (ret < 0)
8003 goto err;
8004
8005 reg = 0x1001 ;
8006 buf[0] = 0x84;
8007 ret = usb_microdia_control_write(dev, reg, buf, 1);
8008 if (ret < 0)
8009 goto err;
8010
8011 reg = 0x1189 ;
8012 buf[0] = 0xcc;
8013 ret = usb_microdia_control_write(dev, reg, buf, 1);
8014 if (ret < 0)
8015 goto err;
8016
8017 reg = 0x11bc ;
8018 buf[0] = 0x00;
8019 ret = usb_microdia_control_write(dev, reg, buf, 1);
8020 if (ret < 0)
8021 goto err;
8022
8023 reg = 0x11bd ;
8024 buf[0] = 0x00;
8025 ret = usb_microdia_control_write(dev, reg, buf, 1);
8026 if (ret < 0)
8027 goto err;
8028
8029 reg = 0x11be ;
8030 buf[0] = 0x00;
8031 ret = usb_microdia_control_write(dev, reg, buf, 1);
8032 if (ret < 0)
8033 goto err;
8034
8035 reg = 0x11bf ;
8036 buf[0] = 0x00;
8037 ret = usb_microdia_control_write(dev, reg, buf, 1);
8038 if (ret < 0)
8039 goto err;
8040
8041 reg = 0x10c0 ;
8042 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8043 ret = usb_microdia_control_write(dev, reg, buf, 8);
8044 if (ret < 0)
8045 goto err;
8046
8047 reg = 0x10c0 ;
8048 ret = usb_microdia_control_read(dev, reg, buf, 1);
8049 if (ret < 0)
8050 goto err;
8051
8052 reg = 0x10c0 ;
8053 ret = usb_microdia_control_read(dev, reg, buf, 1);
8054 if (ret < 0)
8055 goto err;
8056
8057 reg = 0x10c0 ;
8058 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
8059 ret = usb_microdia_control_write(dev, reg, buf, 8);
8060 if (ret < 0)
8061 goto err;
8062
8063 reg = 0x10c0 ;
8064 ret = usb_microdia_control_read(dev, reg, buf, 1);
8065 if (ret < 0)
8066 goto err;
8067
8068 reg = 0x10c0 ;
8069 ret = usb_microdia_control_read(dev, reg, buf, 1);
8070 if (ret < 0)
8071 goto err;
8072
8073 reg = 0x10c0 ;
8074 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8075 ret = usb_microdia_control_write(dev, reg, buf, 8);
8076 if (ret < 0)
8077 goto err;
8078
8079 reg = 0x10c0 ;
8080 ret = usb_microdia_control_read(dev, reg, buf, 1);
8081 if (ret < 0)
8082 goto err;
8083
8084 reg = 0x10c0 ;
8085 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8086 ret = usb_microdia_control_write(dev, reg, buf, 8);
8087 if (ret < 0)
8088 goto err;
8089
8090 reg = 0x10c0 ;
8091 ret = usb_microdia_control_read(dev, reg, buf, 1);
8092 if (ret < 0)
8093 goto err;
8094
8095 reg = 0x10c0 ;
8096 ret = usb_microdia_control_read(dev, reg, buf, 1);
8097 if (ret < 0)
8098 goto err;
8099
8100 reg = 0x1180 ;
8101 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00; buf[4] = 0x50; buf[5] = 0x78;
8102 ret = usb_microdia_control_write(dev, reg, buf, 6);
8103 if (ret < 0)
8104 goto err;
8105
8106 reg = 0x10fb ;
8107 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0; buf[4] = 0x00;
8108 ret = usb_microdia_control_write(dev, reg, buf, 5);
8109 if (ret < 0)
8110 goto err;
8111
8112 reg = 0x1189 ;
8113 buf[0] = 0xdc;
8114 ret = usb_microdia_control_write(dev, reg, buf, 1);
8115 if (ret < 0)
8116 goto err;
8117
8118 reg = 0x1189 ;
8119 buf[0] = 0xd0;
8120 ret = usb_microdia_control_write(dev, reg, buf, 1);
8121 if (ret < 0)
8122 goto err;
8123
8124 reg = 0x11a1 ;
8125 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
8126 ret = usb_microdia_control_write(dev, reg, buf, 4);
8127 if (ret < 0)
8128 goto err;
8129
8130 reg = 0x11ab ;
8131 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
8132 ret = usb_microdia_control_write(dev, reg, buf, 4);
8133 if (ret < 0)
8134 goto err;
8135
8136 reg = 0x1000 ;
8137 buf[0] = 0x78;
8138 ret = usb_microdia_control_write(dev, reg, buf, 1);
8139 if (ret < 0)
8140 goto err;
8141
8142 reg = 0x1002 ;
8143 buf[0] = 0x18;
8144 ret = usb_microdia_control_write(dev, reg, buf, 1);
8145 if (ret < 0)
8146 goto err;
8147
8148 reg = 0x1002 ;
8149 buf[0] = 0x08;
8150 ret = usb_microdia_control_write(dev, reg, buf, 1);
8151 if (ret < 0)
8152 goto err;
8153
8154 reg = 0x11b8 ;
8155 buf[0] = 0x38;
8156 ret = usb_microdia_control_write(dev, reg, buf, 1);
8157 if (ret < 0)
8158 goto err;
8159
8160 reg = 0x118a ;
8161 buf[0] = 0x02;
8162 ret = usb_microdia_control_write(dev, reg, buf, 1);
8163 if (ret < 0)
8164 goto err;
8165
8166 reg = 0x0395 ;
8167 buf[0] = 0x02;
8168 ret = usb_microdia_control_write(dev, reg, buf, 1);
8169 if (ret < 0)
8170 goto err;
8171
8172 reg = 0x11b8 ;
8173 buf[0] = 0x78;
8174 ret = usb_microdia_control_write(dev, reg, buf, 1);
8175 if (ret < 0)
8176 goto err;
8177
8178 reg = 0x11b8 ;
8179 ret = usb_microdia_control_read(dev, reg, buf, 1);
8180 if (ret < 0)
8181 goto err;
8182
8183 reg = 0x11b8 ;
8184 buf[0] = 0xf9;
8185 ret = usb_microdia_control_write(dev, reg, buf, 1);
8186 if (ret < 0)
8187 goto err;
8188
8189 reg = 0x11b8 ;
8190 ret = usb_microdia_control_read(dev, reg, buf, 1);
8191 if (ret < 0)
8192 goto err;
8193
8194 reg = 0x11b8 ;
8195 buf[0] = 0x7a;
8196 ret = usb_microdia_control_write(dev, reg, buf, 1);
8197 if (ret < 0)
8198 goto err;
8199
8200 reg = 0x11b8 ;
8201 ret = usb_microdia_control_read(dev, reg, buf, 1);
8202 if (ret < 0)
8203 goto err;
8204
8205 reg = 0x11b8 ;
8206 buf[0] = 0x7b;
8207 ret = usb_microdia_control_write(dev, reg, buf, 1);
8208 if (ret < 0)
8209 goto err;
8210
8211 reg = 0x11b8 ;
8212 ret = usb_microdia_control_read(dev, reg, buf, 1);
8213 if (ret < 0)
8214 goto err;
8215
8216 reg = 0x11b8 ;
8217 buf[0] = 0x7c;
8218 ret = usb_microdia_control_write(dev, reg, buf, 1);
8219 if (ret < 0)
8220 goto err;
8221
8222 reg = 0x11b8 ;
8223 ret = usb_microdia_control_read(dev, reg, buf, 1);
8224 if (ret < 0)
8225 goto err;
8226
8227 reg = 0x11b8 ;
8228 buf[0] = 0xfd;
8229 ret = usb_microdia_control_write(dev, reg, buf, 1);
8230 if (ret < 0)
8231 goto err;
8232
8233 reg = 0x11b8 ;
8234 ret = usb_microdia_control_read(dev, reg, buf, 1);
8235 if (ret < 0)
8236 goto err;
8237
8238 reg = 0x11b8 ;
8239 buf[0] = 0xfa;
8240 ret = usb_microdia_control_write(dev, reg, buf, 1);
8241 if (ret < 0)
8242 goto err;
8243
8244 reg = 0x10c0 ;
8245 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8246 ret = usb_microdia_control_write(dev, reg, buf, 8);
8247 if (ret < 0)
8248 goto err;
8249
8250 reg = 0x10c0 ;
8251 ret = usb_microdia_control_read(dev, reg, buf, 1);
8252 if (ret < 0)
8253 goto err;
8254
8255 reg = 0x10c0 ;
8256 ret = usb_microdia_control_read(dev, reg, buf, 1);
8257 if (ret < 0)
8258 goto err;
8259
8260 reg = 0x10c0 ;
8261 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8262 ret = usb_microdia_control_write(dev, reg, buf, 8);
8263 if (ret < 0)
8264 goto err;
8265
8266 reg = 0x10c0 ;
8267 ret = usb_microdia_control_read(dev, reg, buf, 1);
8268 if (ret < 0)
8269 goto err;
8270
8271 reg = 0x10c0 ;
8272 ret = usb_microdia_control_read(dev, reg, buf, 1);
8273 if (ret < 0)
8274 goto err;
8275
8276 reg = 0x10c0 ;
8277 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8278 ret = usb_microdia_control_write(dev, reg, buf, 8);
8279 if (ret < 0)
8280 goto err;
8281
8282 reg = 0x10c0 ;
8283 ret = usb_microdia_control_read(dev, reg, buf, 1);
8284 if (ret < 0)
8285 goto err;
8286
8287 reg = 0x10c0 ;
8288 ret = usb_microdia_control_read(dev, reg, buf, 1);
8289 if (ret < 0)
8290 goto err;
8291
8292 reg = 0x10c0 ;
8293 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8294 ret = usb_microdia_control_write(dev, reg, buf, 8);
8295 if (ret < 0)
8296 goto err;
8297
8298 reg = 0x10c0 ;
8299 ret = usb_microdia_control_read(dev, reg, buf, 1);
8300 if (ret < 0)
8301 goto err;
8302
8303 reg = 0x10c0 ;
8304 ret = usb_microdia_control_read(dev, reg, buf, 1);
8305 if (ret < 0)
8306 goto err;
8307
8308 reg = 0x10c0 ;
8309 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8310 ret = usb_microdia_control_write(dev, reg, buf, 8);
8311 if (ret < 0)
8312 goto err;
8313
8314 reg = 0x10c0 ;
8315 ret = usb_microdia_control_read(dev, reg, buf, 1);
8316 if (ret < 0)
8317 goto err;
8318
8319 reg = 0x10c0 ;
8320 ret = usb_microdia_control_read(dev, reg, buf, 1);
8321 if (ret < 0)
8322 goto err;
8323
8324 reg = 0x10c0 ;
8325 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8326 ret = usb_microdia_control_write(dev, reg, buf, 8);
8327 if (ret < 0)
8328 goto err;
8329
8330 reg = 0x10c0 ;
8331 ret = usb_microdia_control_read(dev, reg, buf, 1);
8332 if (ret < 0)
8333 goto err;
8334
8335 reg = 0x10c0 ;
8336 ret = usb_microdia_control_read(dev, reg, buf, 1);
8337 if (ret < 0)
8338 goto err;
8339
8340 reg = 0x10c0 ;
8341 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x1e; buf[3] = 0x04; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8342 ret = usb_microdia_control_write(dev, reg, buf, 8);
8343 if (ret < 0)
8344 goto err;
8345
8346 reg = 0x10c0 ;
8347 ret = usb_microdia_control_read(dev, reg, buf, 1);
8348 if (ret < 0)
8349 goto err;
8350
8351 reg = 0x10c0 ;
8352 ret = usb_microdia_control_read(dev, reg, buf, 1);
8353 if (ret < 0)
8354 goto err;
8355
8356 reg = 0x1182 ;
8357 buf[0] = 0x01;
8358 ret = usb_microdia_control_write(dev, reg, buf, 1);
8359 if (ret < 0)
8360 goto err;
8361
8362 reg = 0x10c0 ;
8363 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x7d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8364 ret = usb_microdia_control_write(dev, reg, buf, 8);
8365 if (ret < 0)
8366 goto err;
8367
8368 reg = 0x10c0 ;
8369 ret = usb_microdia_control_read(dev, reg, buf, 1);
8370 if (ret < 0)
8371 goto err;
8372
8373 reg = 0x10c0 ;
8374 ret = usb_microdia_control_read(dev, reg, buf, 1);
8375 if (ret < 0)
8376 goto err;
8377
8378 reg = 0x10c0 ;
8379 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8380 ret = usb_microdia_control_write(dev, reg, buf, 8);
8381 if (ret < 0)
8382 goto err;
8383
8384 reg = 0x10c0 ;
8385 ret = usb_microdia_control_read(dev, reg, buf, 1);
8386 if (ret < 0)
8387 goto err;
8388
8389 reg = 0x10c0 ;
8390 ret = usb_microdia_control_read(dev, reg, buf, 1);
8391 if (ret < 0)
8392 goto err;
8393
8394 reg = 0x10c0 ;
8395 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8396 ret = usb_microdia_control_write(dev, reg, buf, 8);
8397 if (ret < 0)
8398 goto err;
8399
8400 reg = 0x10c0 ;
8401 ret = usb_microdia_control_read(dev, reg, buf, 1);
8402 if (ret < 0)
8403 goto err;
8404
8405 reg = 0x10c0 ;
8406 ret = usb_microdia_control_read(dev, reg, buf, 1);
8407 if (ret < 0)
8408 goto err;
8409
8410 reg = 0x10c0 ;
8411 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8412 ret = usb_microdia_control_write(dev, reg, buf, 8);
8413 if (ret < 0)
8414 goto err;
8415
8416 reg = 0x10c0 ;
8417 ret = usb_microdia_control_read(dev, reg, buf, 1);
8418 if (ret < 0)
8419 goto err;
8420
8421 reg = 0x10c0 ;
8422 ret = usb_microdia_control_read(dev, reg, buf, 1);
8423 if (ret < 0)
8424 goto err;
8425
8426 reg = 0x10c0 ;
8427 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8428 ret = usb_microdia_control_write(dev, reg, buf, 8);
8429 if (ret < 0)
8430 goto err;
8431
8432 reg = 0x10c0 ;
8433 ret = usb_microdia_control_read(dev, reg, buf, 1);
8434 if (ret < 0)
8435 goto err;
8436
8437 reg = 0x10c0 ;
8438 ret = usb_microdia_control_read(dev, reg, buf, 1);
8439 if (ret < 0)
8440 goto err;
8441
8442 reg = 0x10c0 ;
8443 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8444 ret = usb_microdia_control_write(dev, reg, buf, 8);
8445 if (ret < 0)
8446 goto err;
8447
8448 reg = 0x10c0 ;
8449 ret = usb_microdia_control_read(dev, reg, buf, 1);
8450 if (ret < 0)
8451 goto err;
8452
8453 reg = 0x10c0 ;
8454 ret = usb_microdia_control_read(dev, reg, buf, 1);
8455 if (ret < 0)
8456 goto err;
8457
8458 reg = 0x10c0 ;
8459 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8460 ret = usb_microdia_control_write(dev, reg, buf, 8);
8461 if (ret < 0)
8462 goto err;
8463
8464 reg = 0x10c0 ;
8465 ret = usb_microdia_control_read(dev, reg, buf, 1);
8466 if (ret < 0)
8467 goto err;
8468
8469 reg = 0x10c0 ;
8470 ret = usb_microdia_control_read(dev, reg, buf, 1);
8471 if (ret < 0)
8472 goto err;
8473
8474 reg = 0x10c0 ;
8475 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8476 ret = usb_microdia_control_write(dev, reg, buf, 8);
8477 if (ret < 0)
8478 goto err;
8479
8480 reg = 0x10c0 ;
8481 ret = usb_microdia_control_read(dev, reg, buf, 1);
8482 if (ret < 0)
8483 goto err;
8484
8485 reg = 0x10c0 ;
8486 ret = usb_microdia_control_read(dev, reg, buf, 1);
8487 if (ret < 0)
8488 goto err;
8489
8490 reg = 0x11ba ;
8491 buf[0] = 0x0a;
8492 ret = usb_microdia_control_write(dev, reg, buf, 1);
8493 if (ret < 0)
8494 goto err;
8495
8496 reg = 0x118b ;
8497 buf[0] = 0x10;
8498 ret = usb_microdia_control_write(dev, reg, buf, 1);
8499 if (ret < 0)
8500 goto err;
8501
8502 reg = 0x10f7;
8503 buf[0] = 0x05;
8504 ret = usb_microdia_control_write(dev, reg, buf, 1);
8505 if (ret < 0)
8506 goto err;
8507
8508 reg = 0x10f8 ;
8509 buf[0] = 0x14;
8510 ret = usb_microdia_control_write(dev, reg, buf, 1);
8511 if (ret < 0)
8512 goto err;
8513
8514 reg = 0x10fa ;
8515 buf[0] = 0xff;
8516 ret = usb_microdia_control_write(dev, reg, buf, 1);
8517 if (ret < 0)
8518 goto err;
8519
8520 reg = 0x10f9 ;
8521 buf[0] = 0x00;
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 = 0x11ba ;
8533 buf[0] = 0x0a;
8534 ret = usb_microdia_control_write(dev, reg, buf, 1);
8535 if (ret < 0)
8536 goto err;
8537
8538 reg = 0x11bc ;
8539 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
8540 ret = usb_microdia_control_write(dev, reg, buf, 4);
8541 if (ret < 0)
8542 goto err;
8543
8544 reg = 0x11c0;
8545 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0x00; buf[3] = 0x00;
8546 buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x00;
8547 buf[8] = 0x00; buf[9] = 0x00; buf[10] = 0x00; buf[11] = 0x00;
8548 buf[12] = 0x00; buf[13] = 0x00; buf[14] = 0x00; buf[15] = 0x00;
8549 buf[16] = 0x00; buf[17] = 0x00; buf[18] = 0x00; buf[19] = 0x00;
8550 buf[20] = 0x00; buf[21] = 0x00; buf[22] = 0x00; buf[23] = 0x00;
8551 buf[24] = 0x00; buf[25] = 0x00; buf[26] = 0x00; buf[27] = 0x00;
8552 buf[28] = 0x00; buf[29] = 0x00; buf[30] = 0x00; buf[31] = 0x00;
8553 buf[32] = 0x00; buf[33] = 0x00; buf[34] = 0x00; buf[35] = 0x00;
8554 buf[36] = 0x00; buf[37] = 0x00; buf[38] = 0x00; buf[39] = 0x00;
8555 buf[40] = 0x00; buf[41] = 0x00; buf[42] = 0x00; buf[43] = 0x00;
8556 buf[44] = 0x00; buf[45] = 0x00; buf[46] = 0x00; buf[47] = 0x00;
8557 ret = usb_microdia_control_write(dev, reg, buf, 48);
8558 if (ret < 0)
8559 goto err;
8560
8561 reg = 0x11a5 ;
8562 buf[0] = 0x2d; buf[1] = 0x2d; buf[2] = 0x3a; buf[3] = 0x05;
8563 buf[4] = 0x04; buf[5] = 0x3f;
8564 ret = usb_microdia_control_write(dev, reg, buf, 6);
8565 if (ret < 0)
8566 goto err;
8567
8568 reg = 0x11af ;
8569 buf[0] = 0x28; buf[1] = 0xd8; buf[2] = 0x14; buf[3] = 0xec;
8570 ret = usb_microdia_control_write(dev, reg, buf, 4);
8571 if (ret < 0)
8572 goto err;
8573
8574 reg = 0x11b3 ;
8575 buf[0] = 0x32; buf[1] = 0xdd; buf[2] = 0x32; buf[3] = 0xdd;
8576 ret = usb_microdia_control_write(dev, reg, buf, 4);
8577 if (ret < 0)
8578 goto err;
8579
8580 reg = 0x10e0 ;
8581 buf[0] = 0x47;
8582 ret = usb_microdia_control_write(dev, reg, buf, 1);
8583 if (ret < 0)
8584 goto err;
8585
8586 reg = 0x1061 ;
8587 buf[0] = 0x01;
8588 ret = usb_microdia_control_write(dev, reg, buf, 1);
8589 if (ret < 0)
8590 goto err;
8591
8592 reg = 0x10e0 ;
8593 buf[0] = 0x67;
8594 ret = usb_microdia_control_write(dev, reg, buf, 1);
8595 if (ret < 0)
8596 goto err;
8597
8598 reg = 0x1100 ;
8599 buf[0] = 0x0d; buf[1] = 0x08; buf[2] = 0x08; buf[3] = 0x0d;
8600 buf[4] = 0x08; buf[5] = 0x08; buf[6] = 0x0d; buf[7] = 0x0d;
8601 buf[8] = 0x0d; buf[9] = 0x0d; buf[10] = 0x11; buf[11] = 0x0d;
8602 buf[12] = 0x0d; buf[13] = 0x11; buf[14] = 0x15; buf[15] = 0x21;
8603 buf[16] = 0x15; buf[17] = 0x15; buf[18] = 0x11; buf[19] = 0x11;
8604 buf[20] = 0x15; buf[21] = 0x2a; buf[22] = 0x1d; buf[23] = 0x1d;
8605 buf[24] = 0x19; buf[25] = 0x21; buf[26] = 0x32; buf[27] = 0x2a;
8606 buf[28] = 0x32; buf[29] = 0x32; buf[30] = 0x2e; buf[31] = 0x2a;
8607 buf[32] = 0x2e; buf[33] = 0x2e; buf[34] = 0x36; buf[35] = 0x3a;
8608 buf[36] = 0x4b; buf[37] = 0x43; buf[38] = 0x36; buf[39] = 0x3a;
8609 buf[40] = 0x47; buf[41] = 0x3a; buf[42] = 0x2e; buf[43] = 0x2e;
8610 buf[44] = 0x43; buf[45] = 0x5c; buf[46] = 0x43; buf[47] = 0x47;
8611 buf[48] = 0x4f; buf[49] = 0x53; buf[50] = 0x58; buf[51] = 0x58;
8612 buf[52] = 0x58; buf[53] = 0x32; buf[54] = 0x3f; buf[55] = 0x60;
8613 buf[56] = 0x64; buf[57] = 0x5c; buf[58] = 0x53; buf[59] = 0x64;
8614 buf[60] = 0x4b; buf[61] = 0x53; buf[62] = 0x58; buf[63] = 0x53;
8615 ret = usb_microdia_control_write(dev, reg, buf, 64);
8616 if (ret < 0)
8617 goto err;
8618
8619 reg = 0x1140 ;
8620 buf[0] = 0x0d; buf[1] = 0x11; buf[2] = 0x11; buf[3] = 0x15;
8621 buf[4] = 0x11; buf[5] = 0x15; buf[6] = 0x26; buf[7] = 0x15;
8622 buf[8] = 0x15; buf[9] = 0x26; buf[10] = 0x53; buf[11] = 0x36;
8623 buf[12] = 0x2e; buf[13] = 0x36; buf[14] = 0x53; buf[15] = 0x53;
8624 buf[16] = 0x53; buf[17] = 0x53; buf[18] = 0x53; buf[19] = 0x53;
8625 buf[20] = 0x53; buf[21] = 0x53; buf[22] = 0x53; buf[23] = 0x53;
8626 buf[24] = 0x53; buf[25] = 0x53; buf[26] = 0x53; buf[27] = 0x53;
8627 buf[28] = 0x53; buf[29] = 0x53; buf[30] = 0x53; buf[31] = 0x53;
8628 buf[32] = 0x53; buf[33] = 0x53; buf[34] = 0x53; buf[35] = 0x53;
8629 buf[36] = 0x53; buf[37] = 0x53; buf[38] = 0x53; buf[39] = 0x53;
8630 buf[40] = 0x53; buf[41] = 0x53; buf[42] = 0x53; buf[43] = 0x53;
8631 buf[44] = 0x53; buf[45] = 0x53; buf[46] = 0x53; buf[47] = 0x53;
8632 buf[48] = 0x53; buf[49] = 0x53; buf[50] = 0x53; buf[51] = 0x53;
8633 buf[52] = 0x53; buf[53] = 0x53; buf[54] = 0x53; buf[55] = 0x53;
8634 buf[56] = 0x53; buf[57] = 0x53; buf[58] = 0x53; buf[59] = 0x53;
8635 buf[60] = 0x53; buf[61] = 0x53; buf[62] = 0x53; buf[63] = 0x53;
8636 ret = usb_microdia_control_write(dev, reg, buf, 64);
8637 if (ret < 0)
8638 goto err;
8639
8640 reg = 0x10e0 ;
8641 buf[0] = 0x47;
8642 ret = usb_microdia_control_write(dev, reg, buf, 1);
8643 if (ret < 0)
8644 goto err;
8645
8646 reg = 0x1061 ;
8647 buf[0] = 0x03;
8648 ret = usb_microdia_control_write(dev, reg, buf, 1);
8649 if (ret < 0)
8650 goto err;
8651
8652 reg = 0x10e0 ;
8653 buf[0] = 0x4b;
8654 ret = usb_microdia_control_write(dev, reg, buf, 1);
8655 if (ret < 0)
8656 goto err;
8657
8658 reg = 0x1189 ;
8659 buf[0] = 0xd0;
8660 ret = usb_microdia_control_write(dev, reg, buf, 1);
8661 if (ret < 0)
8662 goto err;
8663
8664 reg = 0x11bc ;
8665 buf[0] = 0x00;
8666 ret = usb_microdia_control_write(dev, reg, buf, 1);
8667 if (ret < 0)
8668 goto err;
8669
8670 reg = 0x11bd ;
8671 buf[0] = 0x00;
8672 ret = usb_microdia_control_write(dev, reg, buf, 1);
8673 if (ret < 0)
8674 goto err;
8675
8676 reg = 0x11be ;
8677 buf[0] = 0x00;
8678 ret = usb_microdia_control_write(dev, reg, buf, 1);
8679 if (ret < 0)
8680 goto err;
8681
8682 reg = 0x11bf ;
8683 buf[0] = 0x00;
8684 ret = usb_microdia_control_write(dev, reg, buf, 1);
8685 if (ret < 0)
8686 goto err;
8687
8688 reg = 0x10c0 ;
8689 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x03; buf[3] = 0x14; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8690 ret = usb_microdia_control_write(dev, reg, buf, 8);
8691 if (ret < 0)
8692 goto err;
8693
8694 reg = 0x10c0 ;
8695 ret = usb_microdia_control_read(dev, reg, buf, 1);
8696 if (ret < 0)
8697 goto err;
8698
8699 reg = 0x10c0 ;
8700 ret = usb_microdia_control_read(dev, reg, buf, 1);
8701 if (ret < 0)
8702 goto err;
8703
8704 reg = 0x10c0 ;
8705 buf[0] = 0xd0; buf[1] = 0x30; buf[2] = 0x17; buf[3] = 0x1b; buf[4] = 0xbc; buf[5] = 0x01; buf[6] = 0x7a; buf[7] = 0x10;
8706 ret = usb_microdia_control_write(dev, reg, buf, 8);
8707 if (ret < 0)
8708 goto err;
8709
8710 reg = 0x10c0 ;
8711 ret = usb_microdia_control_read(dev, reg, buf, 1);
8712 if (ret < 0)
8713 goto err;
8714
8715 reg = 0x10c0 ;
8716 ret = usb_microdia_control_read(dev, reg, buf, 1);
8717 if (ret < 0)
8718 goto err;
8719
8720 reg = 0x10c0 ;
8721 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8722 ret = usb_microdia_control_write(dev, reg, buf, 8);
8723 if (ret < 0)
8724 goto err;
8725
8726 reg = 0x10c0 ;
8727 ret = usb_microdia_control_read(dev, reg, buf, 1);
8728 if (ret < 0)
8729 goto err;
8730
8731 reg = 0x10c0 ;
8732 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x32; buf[3] = 0x82; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8733 ret = usb_microdia_control_write(dev, reg, buf, 8);
8734 if (ret < 0)
8735 goto err;
8736
8737 reg = 0x10c0 ;
8738 ret = usb_microdia_control_read(dev, reg, buf, 1);
8739 if (ret < 0)
8740 goto err;
8741
8742 reg = 0x10c0 ;
8743 ret = usb_microdia_control_read(dev, reg, buf, 1);
8744 if (ret < 0)
8745 goto err;
8746
8747 reg = 0x1180 ;
8748 buf[0] = 0x05; buf[1] = 0x00; buf[2] = 0x01; buf[3] = 0x00;
8749 buf[4] = 0x50; buf[5] = 0x78;
8750 ret = usb_microdia_control_write(dev, reg, buf, 6);
8751 if (ret < 0)
8752 goto err;
8753
8754 reg = 0x10fb ;
8755 buf[0] = 0x00; buf[1] = 0xa0; buf[2] = 0x00; buf[3] = 0xf0;
8756 buf[4] = 0x00;
8757 ret = usb_microdia_control_write(dev, reg, buf, 5);
8758 if (ret < 0)
8759 goto err;
8760
8761 reg = 0x1189 ;
8762 buf[0] = 0xd0;
8763 ret = usb_microdia_control_write(dev, reg, buf, 1);
8764 if (ret < 0)
8765 goto err;
8766
8767 reg = 0x11a1 ;
8768 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xd5; buf[3] = 0xa0;
8769 ret = usb_microdia_control_write(dev, reg, buf, 4);
8770 if (ret < 0)
8771 goto err;
8772
8773 reg = 0x11ab ;
8774 buf[0] = 0x00; buf[1] = 0x00; buf[2] = 0xa0; buf[3] = 0x78;
8775 ret = usb_microdia_control_write(dev, reg, buf, 4);
8776 if (ret < 0)
8777 goto err;
8778
8779 reg = 0x1061 ;
8780 buf[0] = 0x03;
8781 ret = usb_microdia_control_write(dev, reg, buf, 1);
8782 if (ret < 0)
8783 goto err;
8784
8785 reg = 0x11ba ;
8786 buf[0] = 0x0a;
8787 ret = usb_microdia_control_write(dev, reg, buf, 1);
8788 if (ret < 0)
8789 goto err;
8790
8791 reg = 0x11b9 ;
8792 buf[0] = 0x00;
8793 ret = usb_microdia_control_write(dev, reg, buf, 1);
8794 if (ret < 0)
8795 goto err;
8796
8797 reg = 0x11ba ;
8798 buf[0] = 0x0b;
8799 ret = usb_microdia_control_write(dev, reg, buf, 1);
8800 if (ret < 0)
8801 goto err;
8802
8803 reg = 0x1061 ;
8804 buf[0] = 0x01;
8805 ret = usb_microdia_control_write(dev, reg, buf, 1);
8806 if (ret < 0)
8807 goto err;
8808
8809 reg = 0x1000 ;
8810 buf[0] = 0x78;
8811 ret = usb_microdia_control_write(dev, reg, buf, 1);
8812 if (ret < 0)
8813 goto err;
8814
8815 reg = 0x1002 ;
8816 buf[0] = 0x08;
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 = 0x11b8 ;
8828 buf[0] = 0xfa;
8829 ret = usb_microdia_control_write(dev, reg, buf, 1);
8830 if (ret < 0)
8831 goto err;
8832
8833 reg = 0x118a ;
8834 buf[0] = 0x02;
8835 ret = usb_microdia_control_write(dev, reg, buf, 1);
8836 if (ret < 0)
8837 goto err;
8838
8839 reg = 0x0395 ;
8840 buf[0] = 0x02;
8841 ret = usb_microdia_control_write(dev, reg, buf, 1);
8842 if (ret < 0)
8843 goto err;
8844
8845 reg = 0x11b8 ;
8846 buf[0] = 0xf8;
8847 ret = usb_microdia_control_write(dev, reg, buf, 1);
8848 if (ret < 0)
8849 goto err;
8850
8851 reg = 0x11b8 ;
8852 ret = usb_microdia_control_read(dev, reg, buf, 1);
8853 if (ret < 0)
8854 goto err;
8855
8856 reg = 0x11b8 ;
8857 buf[0] = 0xf9;
8858 ret = usb_microdia_control_write(dev, reg, buf, 1);
8859 if (ret < 0)
8860 goto err;
8861
8862 reg = 0x11b8 ;
8863 ret = usb_microdia_control_read(dev, reg, buf, 1);
8864 if (ret < 0)
8865 goto err;
8866
8867 reg = 0x11b8 ;
8868 buf[0] = 0x7a;
8869 ret = usb_microdia_control_write(dev, reg, buf, 1);
8870 if (ret < 0)
8871 goto err;
8872
8873 reg = 0x11b8 ;
8874 ret = usb_microdia_control_read(dev, reg, buf, 1);
8875 if (ret < 0)
8876 goto err;
8877
8878 reg = 0x11b8 ;
8879 buf[0] = 0x7b;
8880 ret = usb_microdia_control_write(dev, reg, buf, 1);
8881 if (ret < 0)
8882 goto err;
8883
8884 reg = 0x11b8 ;
8885 ret = usb_microdia_control_read(dev, reg, buf, 1);
8886 if (ret < 0)
8887 goto err;
8888
8889 reg = 0x11b8 ;
8890 buf[0] = 0x7c;
8891 ret = usb_microdia_control_write(dev, reg, buf, 1);
8892 if (ret < 0)
8893 goto err;
8894
8895 reg = 0x11b8 ;
8896 ret = usb_microdia_control_read(dev, reg, buf, 1);
8897 if (ret < 0)
8898 goto err;
8899
8900 reg = 0x11b8 ;
8901 buf[0] = 0xfd;
8902 ret = usb_microdia_control_write(dev, reg, buf, 1);
8903 if (ret < 0)
8904 goto err;
8905
8906 reg = 0x11b8 ;
8907 ret = usb_microdia_control_read(dev, reg, buf, 1);
8908 if (ret < 0)
8909 goto err;
8910
8911 reg = 0x11b8 ;
8912 buf[0] = 0xfa;
8913 ret = usb_microdia_control_write(dev, reg, buf, 1);
8914 if (ret < 0)
8915 goto err;
8916
8917 reg = 0x10c0 ;
8918 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x11; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8919 ret = usb_microdia_control_write(dev, reg, buf, 8);
8920 if (ret < 0)
8921 goto err;
8922
8923 reg = 0x10c0 ;
8924 ret = usb_microdia_control_read(dev, reg, buf, 1);
8925 if (ret < 0)
8926 goto err;
8927
8928 reg = 0x10c0 ;
8929 ret = usb_microdia_control_read(dev, reg, buf, 1);
8930 if (ret < 0)
8931 goto err;
8932
8933 reg = 0x10c0 ;
8934 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8935 ret = usb_microdia_control_write(dev, reg, buf, 8);
8936 if (ret < 0)
8937 goto err;
8938
8939 reg = 0x10c0 ;
8940 ret = usb_microdia_control_read(dev, reg, buf, 1);
8941 if (ret < 0)
8942 goto err;
8943
8944 reg = 0x10c0 ;
8945 ret = usb_microdia_control_read(dev, reg, buf, 1);
8946 if (ret < 0)
8947 goto err;
8948
8949 reg = 0x10c0 ;
8950 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2b; buf[3] = 0x70; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8951 ret = usb_microdia_control_write(dev, reg, buf, 8);
8952 if (ret < 0)
8953 goto err;
8954
8955 reg = 0x10c0 ;
8956 ret = usb_microdia_control_read(dev, reg, buf, 1);
8957 if (ret < 0)
8958 goto err;
8959
8960 reg = 0x10c0 ;
8961 ret = usb_microdia_control_read(dev, reg, buf, 1);
8962 if (ret < 0)
8963 goto err;
8964
8965 reg = 0x10c0 ;
8966 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x92; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8967 ret = usb_microdia_control_write(dev, reg, buf, 8);
8968 if (ret < 0)
8969 goto err;
8970
8971 reg = 0x10c0 ;
8972 ret = usb_microdia_control_read(dev, reg, buf, 1);
8973 if (ret < 0)
8974 goto err;
8975
8976 reg = 0x10c0 ;
8977 ret = usb_microdia_control_read(dev, reg, buf, 1);
8978 if (ret < 0)
8979 goto err;
8980
8981 reg = 0x10c0 ;
8982 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x93; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8983 ret = usb_microdia_control_write(dev, reg, buf, 8);
8984 if (ret < 0)
8985 goto err;
8986
8987 reg = 0x10c0 ;
8988 ret = usb_microdia_control_read(dev, reg, buf, 1);
8989 if (ret < 0)
8990 goto err;
8991
8992 reg = 0x10c0 ;
8993 ret = usb_microdia_control_read(dev, reg, buf, 1);
8994 if (ret < 0)
8995 goto err;
8996
8997 reg = 0x10c0 ;
8998 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0a; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
8999 ret = usb_microdia_control_write(dev, reg, buf, 8);
9000 if (ret < 0)
9001 goto err;
9002
9003 reg = 0x10c0 ;
9004 ret = usb_microdia_control_read(dev, reg, buf, 1);
9005 if (ret < 0)
9006 goto err;
9007
9008 reg = 0x10c0 ;
9009 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9010 ret = usb_microdia_control_write(dev, reg, buf, 8);
9011 if (ret < 0)
9012 goto err;
9013
9014 reg = 0x10c0 ;
9015 ret = usb_microdia_control_read(dev, reg, buf, 1);
9016 if (ret < 0)
9017 goto err;
9018
9019 reg = 0x10c2 ;
9020 ret = usb_microdia_control_read(dev, reg, buf, 5);
9021 if (ret < 0)
9022 goto err;
9023
9024 reg = 0x10c0 ;
9025 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x0b; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9026 ret = usb_microdia_control_write(dev, reg, buf, 8);
9027 if (ret < 0)
9028 goto err;
9029
9030 reg = 0x10c0 ;
9031 ret = usb_microdia_control_read(dev, reg, buf, 1);
9032 if (ret < 0)
9033 goto err;
9034
9035 reg = 0x10c0 ;
9036 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9037 ret = usb_microdia_control_write(dev, reg, buf, 8);
9038 if (ret < 0)
9039 goto err;
9040
9041 reg = 0x10c0 ;
9042 ret = usb_microdia_control_read(dev, reg, buf, 1);
9043 if (ret < 0)
9044 goto err;
9045
9046 reg = 0x10c2 ;
9047 ret = usb_microdia_control_read(dev, reg, buf, 5);
9048 if (ret < 0)
9049 goto err;
9050
9051 reg = 0x10c0 ;
9052 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1c; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9053 ret = usb_microdia_control_write(dev, reg, buf, 8);
9054 if (ret < 0)
9055 goto err;
9056
9057 reg = 0x10c0 ;
9058 ret = usb_microdia_control_read(dev, reg, buf, 1);
9059 if (ret < 0)
9060 goto err;
9061
9062 reg = 0x10c0 ;
9063 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9064 ret = usb_microdia_control_write(dev, reg, buf, 8);
9065 if (ret < 0)
9066 goto err;
9067
9068 reg = 0x10c0 ;
9069 ret = usb_microdia_control_read(dev, reg, buf, 1);
9070 if (ret < 0)
9071 goto err;
9072
9073 reg = 0x10c2 ;
9074 ret = usb_microdia_control_read(dev, reg, buf, 5);
9075 if (ret < 0)
9076 goto err;
9077
9078 reg = 0x10c0 ;
9079 buf[0] = 0x90; buf[1] = 0x30; buf[2] = 0x1d; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9080 ret = usb_microdia_control_write(dev, reg, buf, 8);
9081 if (ret < 0)
9082 goto err;
9083
9084 reg = 0x10c0 ;
9085 ret = usb_microdia_control_read(dev, reg, buf, 1);
9086 if (ret < 0)
9087 goto err;
9088
9089 reg = 0x10c0 ;
9090 buf[0] = 0x92; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9091 ret = usb_microdia_control_write(dev, reg, buf, 8);
9092 if (ret < 0)
9093 goto err;
9094
9095 reg = 0x10c0 ;
9096 ret = usb_microdia_control_read(dev, reg, buf, 1);
9097 if (ret < 0)
9098 goto err;
9099
9100 reg = 0x10c2 ;
9101 ret = usb_microdia_control_read(dev, reg, buf, 5);
9102 if (ret < 0)
9103 goto err;
9104
9105 reg = 0x1061 ;
9106 buf[0] = 0x03;
9107 ret = usb_microdia_control_write(dev, reg, buf, 1);
9108 if (ret < 0)
9109 goto err;
9110
9111 reg = 0x1007 ;
9112 buf[0] = 0x20;
9113 ret = usb_microdia_control_write(dev, reg, buf, 1);
9114 if (ret < 0)
9115 goto err;
9116
9117 reg = 0x1006 ;
9118 buf[0] = 0x00;
9119 ret = usb_microdia_control_write(dev, reg, buf, 1);
9120 if (ret < 0)
9121 goto err;
9122
9123 reg = 0x10c0 ;
9124 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0xa1; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9125 ret = usb_microdia_control_write(dev, reg, buf, 8);
9126 if (ret < 0)
9127 goto err;
9128
9129 reg = 0x10c0 ;
9130 ret = usb_microdia_control_read(dev, reg, buf, 1);
9131 if (ret < 0)
9132 goto err;
9133
9134 reg = 0x10c0 ;
9135 ret = usb_microdia_control_read(dev, reg, buf, 1);
9136 if (ret < 0)
9137 goto err;
9138
9139 reg = 0x10c0 ;
9140 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x10; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9141 ret = usb_microdia_control_write(dev, reg, buf, 8);
9142 if (ret < 0)
9143 goto err;
9144
9145 reg = 0x10c0 ;
9146 ret = usb_microdia_control_read(dev, reg, buf, 1);
9147 if (ret < 0)
9148 goto err;
9149
9150 reg = 0x10c0 ;
9151 ret = usb_microdia_control_read(dev, reg, buf, 1);
9152 if (ret < 0)
9153 goto err;
9154
9155 reg = 0x10c0 ;
9156 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x04; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9157 ret = usb_microdia_control_write(dev, reg, buf, 8);
9158 if (ret < 0)
9159 goto err;
9160
9161 reg = 0x10c0 ;
9162 ret = usb_microdia_control_read(dev, reg, buf, 1);
9163 if (ret < 0)
9164 goto err;
9165
9166 reg = 0x10c0 ;
9167 ret = usb_microdia_control_read(dev, reg, buf, 1);
9168 if (ret < 0)
9169 goto err;
9170
9171 reg = 0x10c0 ;
9172 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2d; buf[3] = 0x36; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9173 ret = usb_microdia_control_write(dev, reg, buf, 8);
9174 if (ret < 0)
9175 goto err;
9176
9177 reg = 0x10c0 ;
9178 ret = usb_microdia_control_read(dev, reg, buf, 1);
9179 if (ret < 0)
9180 goto err;
9181
9182 reg = 0x10c0 ;
9183 ret = usb_microdia_control_read(dev, reg, buf, 1);
9184 if (ret < 0)
9185 goto err;
9186
9187 reg = 0x10c0 ;
9188 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x2e; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9189 ret = usb_microdia_control_write(dev, reg, buf, 8);
9190 if (ret < 0)
9191 goto err;
9192
9193 reg = 0x10c0 ;
9194 ret = usb_microdia_control_read(dev, reg, buf, 1);
9195 if (ret < 0)
9196 goto err;
9197
9198 reg = 0x10c0 ;
9199 ret = usb_microdia_control_read(dev, reg, buf, 1);
9200 if (ret < 0)
9201 goto err;
9202
9203 reg = 0x10c0 ;
9204 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x01; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9205 ret = usb_microdia_control_write(dev, reg, buf, 8);
9206 if (ret < 0)
9207 goto err;
9208
9209 reg = 0x10c0 ;
9210 ret = usb_microdia_control_read(dev, reg, buf, 1);
9211 if (ret < 0)
9212 goto err;
9213
9214 reg = 0x10c0 ;
9215 ret = usb_microdia_control_read(dev, reg, buf, 1);
9216 if (ret < 0)
9217 goto err;
9218
9219 reg = 0x10c0 ;
9220 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x06; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9221 ret = usb_microdia_control_write(dev, reg, buf, 8);
9222 if (ret < 0)
9223 goto err;
9224
9225 reg = 0x10c0 ;
9226 ret = usb_microdia_control_read(dev, reg, buf, 1);
9227 if (ret < 0)
9228 goto err;
9229
9230 reg = 0x10c0 ;
9231 ret = usb_microdia_control_read(dev, reg, buf, 1);
9232 if (ret < 0)
9233 goto err;
9234
9235 reg = 0x10c0 ;
9236 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x94; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9237 ret = usb_microdia_control_write(dev, reg, buf, 8);
9238 if (ret < 0)
9239 goto err;
9240
9241 reg = 0x10c0 ;
9242 ret = usb_microdia_control_read(dev, reg, buf, 1);
9243 if (ret < 0)
9244 goto err;
9245
9246 reg = 0x10c0 ;
9247 ret = usb_microdia_control_read(dev, reg, buf, 1);
9248 if (ret < 0)
9249 goto err;
9250
9251 reg = 0x10c0 ;
9252 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x8d; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9253 ret = usb_microdia_control_write(dev, reg, buf, 8);
9254 if (ret < 0)
9255 goto err;
9256
9257 reg = 0x10c0 ;
9258 ret = usb_microdia_control_read(dev, reg, buf, 1);
9259 if (ret < 0)
9260 goto err;
9261
9262 reg = 0x10c0 ;
9263 ret = usb_microdia_control_read(dev, reg, buf, 1);
9264 if (ret < 0)
9265 goto err;
9266
9267 reg = 0x10c0 ;
9268 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x09; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9269 ret = usb_microdia_control_write(dev, reg, buf, 8);
9270 if (ret < 0)
9271 goto err;
9272
9273 reg = 0x10c0 ;
9274 ret = usb_microdia_control_read(dev, reg, buf, 1);
9275 if (ret < 0)
9276 goto err;
9277
9278 reg = 0x10c0 ;
9279 ret = usb_microdia_control_read(dev, reg, buf, 1);
9280 if (ret < 0)
9281 goto err;
9282
9283 reg = 0x10c0 ;
9284 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x95; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9285 ret = usb_microdia_control_write(dev, reg, buf, 8);
9286 if (ret < 0)
9287 goto err;
9288
9289 reg = 0x10c0 ;
9290 ret = usb_microdia_control_read(dev, reg, buf, 1);
9291 if (ret < 0)
9292 goto err;
9293
9294 reg = 0x10c0 ;
9295 ret = usb_microdia_control_read(dev, reg, buf, 1);
9296 if (ret < 0)
9297 goto err;
9298
9299 reg = 0x10c0 ;
9300 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x85; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9301 ret = usb_microdia_control_write(dev, reg, buf, 8);
9302 if (ret < 0)
9303 goto err;
9304
9305 reg = 0x10c0 ;
9306 ret = usb_microdia_control_read(dev, reg, buf, 1);
9307 if (ret < 0)
9308 goto err;
9309
9310 reg = 0x10c0 ;
9311 ret = usb_microdia_control_read(dev, reg, buf, 1);
9312 if (ret < 0)
9313 goto err;
9314
9315 reg = 0x10c0 ;
9316 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x00; buf[3] = 0x0c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x15;
9317 ret = usb_microdia_control_write(dev, reg, buf, 8);
9318 if (ret < 0)
9319 goto err;
9320
9321 reg = 0x10c0 ;
9322 ret = usb_microdia_control_read(dev, reg, buf, 1);
9323 if (ret < 0)
9324 goto err;
9325
9326 reg = 0x10c0 ;
9327 ret = usb_microdia_control_read(dev, reg, buf, 1);
9328 if (ret < 0)
9329 goto err;
9330
9331 reg = 0x10c0 ;
9332 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x01; buf[3] = 0x96; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9333 ret = usb_microdia_control_write(dev, reg, buf, 8);
9334 if (ret < 0)
9335 goto err;
9336
9337 reg = 0x10c0 ;
9338 ret = usb_microdia_control_read(dev, reg, buf, 1);
9339 if (ret < 0)
9340 goto err;
9341
9342 reg = 0x10c0 ;
9343 ret = usb_microdia_control_read(dev, reg, buf, 1);
9344 if (ret < 0)
9345 goto err;
9346
9347 reg = 0x10c0 ;
9348 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x80; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9349 ret = usb_microdia_control_write(dev, reg, buf, 8);
9350 if (ret < 0)
9351 goto err;
9352
9353 reg = 0x10c0 ;
9354 ret = usb_microdia_control_read(dev, reg, buf, 1);
9355 if (ret < 0)
9356 goto err;
9357
9358 reg = 0x10c0 ;
9359 ret = usb_microdia_control_read(dev, reg, buf, 1);
9360 if (ret < 0)
9361 goto err;
9362
9363 reg = 0x10c0 ;
9364 buf[0] = 0xa0; buf[1] = 0x30; buf[2] = 0x02; buf[3] = 0x7c; buf[4] = 0x00; buf[5] = 0x00; buf[6] = 0x00; buf[7] = 0x10;
9365 ret = usb_microdia_control_write(dev, reg, buf, 8);
9366 if (ret < 0)
9367 goto err;
9368
9369 reg = 0x10c0 ;
9370 ret = usb_microdia_control_read(dev, reg, buf, 1);
9371 if (ret < 0)
9372 goto err;
9373
9374 reg = 0x10c0 ;
9375 ret = usb_microdia_control_read(dev, reg, buf, 1);
9376 if (ret < 0)
9377 goto err;
9378
9379 reg = 0x1007 ;
9380 buf[0] = 0x20;
9381 ret = usb_microdia_control_write(dev, reg, buf, 1);
9382 if (ret < 0)
9383 goto err;
9384
9385 reg = 0x1006 ;
9386 buf[0] = 0x20;
9387 ret = usb_microdia_control_write(dev, reg, buf, 1);
9388 if (ret < 0)
9389 goto err;
9390
9391
9392
9393
9394 /* END OF MICRODIA 6288 START STREAM */
9395
9396 return 0;
9397 err:
9398 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9399 return ret;
9400 }
9401
9402 int dev_microdia_stop_stream(struct usb_microdia *dev)
9403 {
9404 int ret = -ENODEV;
9405 if (dev && dev->stop_stream)
9406 ret = dev->stop_stream(dev);
9407
9408 return ret;
9409 }
9410
9411 /**
9412 * @brief From stop.htm
9413 *
9414 * @param dev
9415 *
9416 * @returns 0
9417 *
9418 * @author GWater
9419 *
9420 * For SN9C201 with MI1310.
9421 * This function has not been tested yet.
9422 */
9423 int microdia_6242_stop_stream(struct usb_microdia *dev)
9424 {
9425 __u8 buf[3];
9426
9427 __u8 only10c0[3] = {0x0d, 0x00, 0x00};
9428
9429 buf[0] = 0x01;
9430 usb_microdia_control_write(dev, 0x1061, buf, 1);
9431
9432 buf[0] = 0x60;
9433 usb_microdia_control_write(dev, 0x1007, buf, 1);
9434
9435 buf[0] = 0x00;
9436 usb_microdia_control_write(dev, 0x1006, buf, 1);
9437
9438 sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2,
9439 only10c0[0], dev->sensor_flags, &only10c0[1]);
9440
9441 buf[0] = 0x38;
9442 usb_microdia_control_write(dev, 0x1000, buf, 1);
9443
9444 buf[0] = 0x6b;
9445 usb_microdia_control_write(dev, 0x11b8, buf, 1);
9446
9447 buf[0] = 0x60;
9448 usb_microdia_control_write(dev, 0x1007, buf, 1);
9449
9450 buf[0] = 0x20;
9451 usb_microdia_control_write(dev, 0x1006, buf, 1);
9452
9453
9454 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9455 usb_microdia_control_write(dev, 0x1000, buf, 3);
9456
9457 /**
9458 * After the select alternate setting 0 is actually another transfer:
9459 * buf[0] = 0x00;
9460 * usb_microdia_control_write(dev, 0x1066, buf, 1);
9461 */
9462
9463 return 0;
9464 }
9465
9466
9467 /**
9468 * @brief From stopstream.log
9469 *
9470 * @param dev
9471 *
9472 * @returns 0
9473 *
9474 * @author GWater
9475 *
9476 * For SN9C201 with SOI968.
9477 * I don't whether the function really stops the stream.
9478 * Nevertheless the LED on the webcam now stops glowing.
9479 * The function is very similar to "microdia_624f_stop_stream".
9480 */
9481 int microdia_624e_stop_stream(struct usb_microdia *dev)
9482 {
9483 __u8 buf[3];
9484
9485 buf[0] = 0x01;
9486 usb_microdia_control_write(dev, 0x1061, buf, 1);
9487
9488 /* Next two writes added because it works better.
9489 * The LED stops glowing and I think the stream does too.
9490 * 0x20 = 0b00100000 which is the minimal of what the
9491 * other stopstreams have in common.
9492 */
9493 buf[0] = 0x20;
9494 usb_microdia_control_write(dev, 0x1007, buf, 1);
9495
9496 buf[0] = 0x20;
9497 usb_microdia_control_write(dev, 0x1006, buf, 1);
9498
9499 buf[0] = 0x3c;
9500 usb_microdia_control_write(dev, 0x1000, buf, 1);
9501
9502 buf[0] = 0x6a;
9503 usb_microdia_control_write(dev, 0x11b8, buf, 1);
9504
9505 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9506 usb_microdia_control_write(dev, 0x1000, buf, 3);
9507
9508 usb_microdia_control_read(dev, 0x1066, buf, 1);
9509
9510 return 0;
9511 }
9512
9513
9514 int microdia_624f_stop_stream(struct usb_microdia *dev)
9515 {
9516 int ret;
9517 __u16 command;
9518 __u8 buf[3];
9519
9520 buf[0] = 0x02;
9521 command = 0x1066;
9522 ret = usb_microdia_control_write(dev, command, buf, 1);
9523 if (ret < 0)
9524 goto err;
9525
9526 buf[0] = 0x01;
9527 command = 0x1061;
9528 ret = usb_microdia_control_write(dev, command, buf, 1);
9529 if (ret < 0)
9530 goto err;
9531
9532 buf[0] = 0x38;
9533 command = 0x1000;
9534 ret = usb_microdia_control_write(dev, command, buf, 1);
9535 if (ret < 0)
9536 goto err;
9537
9538 buf[0] = 0x6a;
9539 command = 0x11b8;
9540 ret = usb_microdia_control_write(dev, command, buf, 1);
9541 if (ret < 0)
9542 goto err;
9543
9544 buf[0] = 0x20;
9545 command = 0x1007;
9546 ret = usb_microdia_control_write(dev, command, buf, 1);
9547 if (ret < 0)
9548 goto err;
9549
9550 buf[0] = 0x20;
9551 command = 0x1006;
9552 ret = usb_microdia_control_write(dev, command, buf, 1);
9553 if (ret < 0)
9554 goto err;
9555
9556 buf[0] = 0x98;
9557 buf[1] = 0xe7;
9558 buf[2] = 0x11;
9559 command = 0x1000;
9560 ret = usb_microdia_control_write(dev, command, buf, 3);
9561 if (ret < 0)
9562 goto err;
9563
9564 command = 0x1045;
9565 ret = usb_microdia_control_read(dev, command, buf, 1);
9566 if (ret < 0)
9567 goto err;
9568
9569 buf[0] = 0x0f;
9570 ret = usb_microdia_control_write(dev, command, buf, 1);
9571 if (ret < 0)
9572 goto err;
9573
9574 return ret;
9575
9576 err:
9577 UDIA_ERROR("command %x failed (%d)!\n", command, ret);
9578 return ret;
9579 }
9580
9581 int microdia_6260_stop_stream(struct usb_microdia *dev)
9582 {
9583 int ret;
9584 __u8 buf[32];
9585
9586 buf[0] = 0x01;
9587 ret = usb_microdia_control_write(dev, 0x1061, buf, 1);
9588 buf[0] = 0x38;
9589 ret = usb_microdia_control_write(dev, 0x1000, buf, 1);
9590 buf[0] = 0x6b;
9591 ret = usb_microdia_control_write(dev, 0x11b8, buf, 1);
9592 buf[0] = 0x20;
9593 ret = usb_microdia_control_write(dev, 0x1007, buf, 1);
9594 buf[0] = 0x20;
9595 ret = usb_microdia_control_write(dev, 0x1006, buf, 1);
9596
9597 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9598 ret = usb_microdia_control_write(dev, 0x1000, buf, 3);
9599
9600 buf[0] = 0x00;
9601 ret = usb_microdia_control_write(dev, 0x1066, buf, 1);
9602 ret = usb_microdia_control_read(dev, 0x1045, buf, 1);
9603 buf[0] = 0x0f;
9604 ret = usb_microdia_control_write(dev, 0x1045, buf, 1);
9605 buf[0] = 0x00;
9606 ret = usb_microdia_control_write(dev, 0x10c8, buf, 1);
9607 buf[0] = 0x80;
9608 ret = usb_microdia_control_write(dev, 0x1020, buf, 1);
9609
9610 return ret;
9611 }
9612
9613 /**
9614 * @brief From 7 start-stop-logs (made by Alex Carlos, Boris Borisov, bohzan and Comer352l)
9615 *
9616 * @param dev
9617 *
9618 * @returns 0 (ok) or -1 (error)
9619 *
9620 * @author Comer352l
9621 *
9622 * Windows driver version: 5.7.23.000
9623 * Windows versions: 2000 and XP
9624 * USB-Logger: SniffUSB 1.8 and 2.0, USBTrace 2.0, SnoopyPro
9625 * All logs were made using AMCAP with 640x480, RGB24
9626 */
9627 int microdia_6270_stop_stream(struct usb_microdia *dev)
9628 {
9629 int ret = 0;
9630 int retI2C = 0;
9631 __u8 buf[3];
9632
9633 if (dev->sensor_slave_address == MT9V111_I2C_SLAVE_ADDRESS) {
9634 buf[0] = 0x20;
9635 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
9636 buf[0] = 0x20;
9637 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
9638 /* => These two writes seem to cause the cam to stop sending isochronus USB messages */
9639 }
9640 buf[0] = 0x01;
9641 ret += usb_microdia_control_write(dev, 0x1061, buf, 1); /* URB 3544 */
9642 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
9643 buf[0] = 0x60;
9644 ret += usb_microdia_control_write(dev, 0x1007, buf, 1); /* URB 3541 */
9645 buf[0] = 0x60;
9646 ret += usb_microdia_control_write(dev, 0x1006, buf, 1); /* URB 3542 */
9647 }
9648 if (dev->sensor_slave_address == MT9V011_I2C_SLAVE_ADDRESS) {
9649 /* Write to sensor register 0x07: Output Control */
9650 buf[0] = 0x00; buf[1] = 0x00; /* stop sensor readout, normal operation */
9651 retI2C += sn9c20x_write_i2c_data(dev, dev->sensor_slave_address, 2, 0x07, dev->sensor_flags, buf);
9652 }
9653 buf[0] = 0x38; /* ALEX: 0x3c */
9654 ret += usb_microdia_control_write(dev, 0x1000, buf, 1); /* URB 3545 */
9655 buf[0] = 0x6d; /* ALEX: 0xec; FRANK: also 0x6c */
9656 ret += usb_microdia_control_write(dev, 0x11b8, buf, 1); /* URB 3546 */
9657 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9658 ret += usb_microdia_control_write(dev, 0x1000, buf, 3); /* URB 3547 */
9659
9660 /* INTERRUPT COMMING BACK (URB 2227) */
9661 /* SELECT ALTERNATE SETTINGS (URB 3548) */
9662 /* INTERRUPT GOING DOWN (URB 3549) */
9663
9664 buf[0] = 0x00;
9665 ret += usb_microdia_control_write(dev, 0x1066, buf, 1); /* URB 3550 */
9666
9667 if (ret < 9) {
9668 UDIA_INFO("One ore more errors occured while stopping stream !\n");
9669 return -1;
9670 } else {
9671 return 0;
9672 }
9673 }
9674
9675 int microdia_627b_stop_stream(struct usb_microdia *dev)
9676 {
9677 int ret = 0;
9678 __u16 reg;
9679 __u8 buf[3];
9680
9681 reg = 0x1007;
9682 buf[0] = 0x60;
9683 ret = usb_microdia_control_write(dev, reg, buf, 1);
9684 if (ret < 0)
9685 goto err;
9686
9687 reg = 0x1006;
9688 buf[0] = 0x20;
9689 ret = usb_microdia_control_write(dev, reg, buf, 1);
9690 if (ret < 0)
9691 goto err;
9692
9693 /*
9694 //reg = 0x1007;
9695 //buf[0] = 0x60;
9696 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9697 //if(ret < 0) goto err;
9698
9699 //reg = 0x1006;
9700 //buf[0] = 0x20;
9701 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9702 //if(ret < 0) goto err;
9703 */
9704
9705 reg = 0x1061;
9706 buf[0] = 0x01;
9707 ret = usb_microdia_control_write(dev, reg, buf, 1);
9708 if (ret < 0)
9709 goto err;
9710
9711 /*
9712 //reg = 0x1007;
9713 //buf[0] = 0x60;
9714 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9715 //if(ret < 0) goto err;
9716
9717 //reg = 0x1006;
9718 //buf[0] = 0x20;
9719 //ret = usb_microdia_control_write(dev, reg, buf, 1);
9720 //if(ret < 0) goto err;
9721 */
9722
9723 reg = 0x1000;
9724 buf[0] = 0x38;
9725 ret = usb_microdia_control_write(dev, reg, buf, 1);
9726 if (ret < 0)
9727 goto err;
9728
9729 reg = 0x11b8;
9730 buf[0] = 0x6b;
9731 ret = usb_microdia_control_write(dev, reg, buf, 1);
9732 if (ret < 0)
9733 goto err;
9734
9735 reg = 0x1000;
9736 buf[0] = 0x38; buf[1] = 0xe7; buf[2] = 0x11;
9737 ret = usb_microdia_control_write(dev, reg, buf, 3);
9738 if (ret < 0)
9739 goto err;
9740
9741 reg = 0x1066;
9742 buf[0] = 0x00;
9743 ret = usb_microdia_control_write(dev, reg, buf, 1);
9744 if (ret < 0)
9745 goto err;
9746
9747 return ret;
9748 err:
9749 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9750 return ret;
9751 }
9752
9753 /**
9754 * @brief From UsbSnoop-plugin-parsed.log
9755 *
9756 * @param dev
9757 *
9758 * @returns 0 (OK) or <0 (Error)
9759 *
9760 * @author Vincent, Kuzja
9761 */
9762 int microdia_6288_stop_stream(struct usb_microdia *dev)
9763 {
9764 int ret = 0;
9765 __u16 reg;
9766 __u8 buf[8];
9767
9768 reg = 0x1061 ;
9769 buf[0] = 0x01;
9770 ret = usb_microdia_control_write(dev, reg, buf, 1);
9771 if (ret < 0)
9772 goto err;
9773
9774 reg = 0x1000 ;
9775 buf[0] = 0x38;
9776 ret = usb_microdia_control_write(dev, reg, buf, 1);
9777 if (ret < 0)
9778 goto err;
9779
9780 reg = 0x11b8 ;
9781 buf[0] = 0xe9;
9782 ret = usb_microdia_control_write(dev, reg, buf, 1);
9783 if (ret < 0)
9784 goto err;
9785
9786 reg = 0x1007 ;
9787 buf[0] = 0x20;
9788 ret = usb_microdia_control_write(dev, reg, buf, 1);
9789 if (ret < 0)
9790 goto err;
9791
9792 reg = 0x1006 ;
9793 buf[0] = 0x20;
9794 ret = usb_microdia_control_write(dev, reg, buf, 1);
9795 if (ret < 0)
9796 goto err;
9797
9798 reg = 0x1000 ;
9799 buf[0] = 0x98; buf[1] = 0xe7; buf[2] = 0x11;
9800 ret = usb_microdia_control_write(dev, reg, buf, 3);
9801 if (ret < 0)
9802 goto err;
9803
9804 reg = 0x1066 ;
9805 buf[0] = 0x00;
9806 ret = usb_microdia_control_write(dev, reg, buf, 1);
9807 if (ret < 0)
9808 goto err;
9809
9810 return 0;
9811 err:
9812 UDIA_ERROR("r/w in Register %x failed (%d)!\n", reg, ret);
9813 return ret;
9814 }
9815
9816 int microdia_624f_flip_detect(struct usb_microdia *dev)
9817 {
9818 int ret = 0;
9819 __u8 val;
9820
9821 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
9822 if (ret < 0)
9823 return -EAGAIN;
9824 if (val & 0x01)
9825 dev->vsettings.vflip = 1;
9826 else
9827 dev->vsettings.vflip = 0;
9828 return ret;
9829 }
9830
9831 int microdia_6260_flip_detect(struct usb_microdia *dev)
9832 {
9833 const __u8 flip_bit = 0x01;
9834 int ret = 0;
9835 __u8 val;
9836 static __u8 flip_reg = flip_bit;
9837 __u8 vflip;
9838
9839 ret = usb_microdia_control_read(dev, 0x1009, &val, 1);
9840 if (ret < 0)
9841 return -EAGAIN;
9842 if (flip_reg != (val & flip_bit)) {
9843 if (val & flip_bit)
9844 vflip = 0;
9845 else
9846 vflip = 1;
9847 ret = ov7670_auto_flip(dev, vflip);
9848 flip_reg = (val & flip_bit);
9849 }
9850
9851 return ret;
9852 }
9853
Microdia : webcam kernel driver, for USB webcams with vendor id 0c45