microdia-dev.c

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