microdia-dev.c

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