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