stk11xx-dev-6a33.c

   1 /**
   2  * @file stk11xx-dev-6a33.c
   3  * @author Nicolas VIVIEN
   4  * @date 2006-10-23
   5  * @version v1.2.0
   6  *
   7  * @brief Driver for Syntek USB video camera
   8  *
   9  * @note Copyright (C) Nicolas VIVIEN
  10  *
  11  * @par Licences
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26  *
  27  * @par SubVersion
  28  *   $Date$
  29  *   $Revision$
  30  *   $Author$
  31  *   $HeadURL$
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/kernel.h>
  37 #include <linux/version.h>
  38 #include <linux/errno.h>
  39 #include <linux/slab.h>
  40 #include <linux/kref.h>
  41
  42 #include <linux/usb.h>
  43 #include <media/v4l2-common.h>
  44
  45 #include "stk11xx.h"
  46 #include "stk11xx-dev.h"
  47
  48
  49 //=============================================================================
  50 //
  51 // STK-6A33 API
  52 //
  53 //=============================================================================
  54
  55
  56 /**
  57  * @param dev Device structure
  58  *
  59  * @returns 0 if all is OK
  60  *
  61  * @brief This function permits to initialize the device.
  62  *
  63  * This function must be called at first. It's the start of the
  64  * initialization process. After this process, the device is
  65  * completly initalized and it's ready.
  66  *
  67  * This function is written from the USB log.
  68  */
  69 int dev_stk6a33_initialize_device(struct usb_stk11xx *dev)
  70 {
  71         int i;
  72         int retok;
  73         int value;
  74
  75         STK_INFO("Initialize USB2.0 Syntek Camera\n");
  76
  77         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  78         usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
  79         usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
  80
  81         usb_stk11xx_write_registry(dev, 0x0002, 0x007f);
  82         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  83         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  84         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  85         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
  86         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  87         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  88         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
  89         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  90         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  91         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
  92         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  93         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  94         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
  95         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
  96         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  97         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
  98         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
  99         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 100         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 101         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 102         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 103         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 104         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 105         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 106         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 107         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 108         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 109         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 110         usb_stk11xx_write_registry(dev, 0x0002, 0x007d);
 111         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 112
 113         for (i=0; i<16; i++) {
 114                 usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 115                 usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 116                 usb_stk11xx_read_registry(dev, 0x0000, &value);
 117
 118                 STK_DEBUG("Loop 1 : Read 0x0000 = %02X\n", value);
 119         }
 120
 121         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 122         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 123
 124         usb_stk11xx_write_registry(dev, 0x0002, 0x007f);
 125         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 126         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 127         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 128         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 129         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 130         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 131         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 132         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 133         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 134         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 135         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 136         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 137         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 138         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 139         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 140         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 141         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 142         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 143         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 144         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 145         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 146         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 147         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 148         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 149         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 150         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 151         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 152         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 153         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 154         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 155         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 156         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 157         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 158         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 159         usb_stk11xx_write_registry(dev, 0x0002, 0x007d);
 160         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 161
 162         for (i=0; i<16; i++) {
 163                 usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 164                 usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 165                 usb_stk11xx_read_registry(dev, 0x0000, &value);
 166
 167                 STK_DEBUG("Loop 2 : Read 0x0000 = %02X\n", value);
 168         }
 169
 170         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 171         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 172
 173         usb_stk11xx_write_registry(dev, 0x0002, 0x007f);
 174         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 175         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 176         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 177         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 178         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 179         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 180         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 181         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 182         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 183         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 184         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 185         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 186         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 187         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 188         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 189         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 190         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 191         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 192         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 193         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 194         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 195         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 196         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 197         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 198         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 199         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 200         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 201         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 202         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 203         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 204         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 205         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 206         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 207         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 208         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 209         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 210         usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
 211         usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
 212         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 213         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 214         usb_stk11xx_write_registry(dev, 0x0002, 0x007d);
 215         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 216
 217         for (i=0; i<16; i++) {
 218                 usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 219                 usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 220                 usb_stk11xx_read_registry(dev, 0x0000, &value);
 221
 222                 STK_DEBUG("Loop 3 : Read 0x0000 = %02X\n", value);
 223         }
 224
 225         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 226         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 227         usb_stk11xx_write_registry(dev, 0x0002, 0x007f);
 228         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 229         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 230
 231         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 232         usb_stk11xx_read_registry(dev, 0x0103, &value);
 233         usb_stk11xx_write_registry(dev, 0x0103, 0x0001);
 234         usb_stk11xx_read_registry(dev, 0x0103, &value);
 235         usb_stk11xx_write_registry(dev, 0x0103, 0x0000);
 236
 237         usb_stk11xx_write_registry(dev, 0x0000, 0x00e0);
 238         usb_stk11xx_write_registry(dev, 0x0002, 0x00f8);
 239         usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
 240         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 241
 242         dev_stk6a33_configure_device(dev, 0);
 243         retok = dev_stk11xx_check_device(dev, 65);
 244         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 245
 246         dev_stk6a33_configure_device(dev, 1);
 247         retok = dev_stk11xx_check_device(dev, 65);
 248         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 249
 250         dev_stk6a33_configure_device(dev, 2);
 251         retok = dev_stk11xx_check_device(dev, 65);
 252         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 253
 254         dev_stk6a33_configure_device(dev, 3);
 255         retok = dev_stk11xx_check_device(dev, 65);
 256         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 257
 258         dev_stk6a33_configure_device(dev, 4);
 259         retok = dev_stk11xx_check_device(dev, 65);
 260         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 261
 262         dev_stk6a33_configure_device(dev, 5);
 263         retok = dev_stk11xx_check_device(dev, 65);
 264         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 265
 266         dev_stk6a33_configure_device(dev, 6);
 267         retok = dev_stk11xx_check_device(dev, 65);
 268         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 269
 270         dev_stk6a33_configure_device(dev, 7);
 271         retok = dev_stk11xx_check_device(dev, 65);
 272         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 273
 274         dev_stk6a33_configure_device(dev, 8);
 275         retok = dev_stk11xx_check_device(dev, 65);
 276         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 277
 278         dev_stk6a33_configure_device(dev, 9);
 279         retok = dev_stk11xx_check_device(dev, 65);
 280         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 281
 282         dev_stk6a33_configure_device(dev, 10);
 283         retok = dev_stk11xx_check_device(dev, 65);
 284         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 285
 286         dev_stk6a33_configure_device(dev, 11);
 287         retok = dev_stk11xx_check_device(dev, 65);
 288         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 289
 290         dev_stk6a33_configure_device(dev, 12);
 291         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 292         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 293         usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
 294         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 295         retok = dev_stk11xx_check_device(dev, 500);
 296         usb_stk11xx_read_registry(dev, 0x0209, &value);
 297         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 298
 299         dev_stk6a33_configure_device(dev, 13);
 300         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 301         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 302         usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
 303         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 304         retok = dev_stk11xx_check_device(dev, 500);
 305         usb_stk11xx_read_registry(dev, 0x0209, &value);
 306         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 307         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 308         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 309         usb_stk11xx_write_registry(dev, 0x0208, 0x00f1);
 310         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 311         retok = dev_stk11xx_check_device(dev, 500);
 312         usb_stk11xx_read_registry(dev, 0x0209, &value);
 313         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 314
 315         dev_stk6a33_configure_device(dev, 14);
 316         retok = dev_stk11xx_check_device(dev, 500);
 317         usb_stk11xx_write_registry(dev, 0x0204, 0x00f1);
 318         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 319         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 320         retok = dev_stk11xx_check_device(dev, 500);
 321         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 322         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 323         usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
 324         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 325         retok = dev_stk11xx_check_device(dev, 500);
 326         usb_stk11xx_read_registry(dev, 0x0209, &value);
 327         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 328         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 329         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 330         usb_stk11xx_write_registry(dev, 0x0208, 0x00f1);
 331         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 332         retok = dev_stk11xx_check_device(dev, 500);
 333         usb_stk11xx_read_registry(dev, 0x0209, &value);
 334         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 335
 336         dev_stk6a33_configure_device(dev, 15);
 337
 338         dev_stk6a33_camera_asleep(dev);
 339
 340         usb_stk11xx_set_feature(dev, 0);
 341
 342         // Device is initialized and is ready !!!
 343         STK_INFO("Syntek USB2.0 Camera is ready\n");
 344
 345         return 0;
 346 }
 347
 348
 349 /**
 350  * @param dev Device structure
 351  * @param step The step of configuration [0-11]
 352  *
 353  * @returns 0 if all is OK
 354  *
 355  * @brief This function permits to configure the device.
 356  *
 357  * The configuration of device is composed of 11 steps.
 358  * This function is called by the initialization process.
 359  *
 360  * We don't know the meaning of these steps ! We only replay the USB log.
 361  *
 362  * The steps 0 to 9 are called during the initialization.
 363  * Then, the driver choose the last step :
 364  *   10 : for a resolution from 80x60 to 640x480
 365  *   11 : for a resolution from 800x600 to 1280x1024
 366  */
 367 int dev_stk6a33_configure_device(struct usb_stk11xx *dev, int step)
 368 {
 369         int value;
 370
 371         //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,   17
 372
 373         static const int values_001B[] = {
 374                 0x0e, 0x03, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07
 375         };
 376         static const int values_001C[] = {
 377                 0x06, 0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
 378         };
 379         static const int values_0202[] = {
 380                 0x1e, 0x0a, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x14, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f
 381         };
 382         static const int values_0110[] = {
 383                 0x07, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 384         };
 385         static const int values_0112[] = {
 386                 0x07, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 387         };
 388         static const int values_0114[] = {
 389                 0x87, 0x80, 0x80, 0x80, 0x80, 0xbe, 0xbe, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80
 390         };
 391         static const int values_0115[] = {
 392                 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
 393         };
 394         static const int values_0116[] = {
 395                 0xe7, 0xe0, 0xe0, 0xe0, 0xe0, 0xe9, 0xe9, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0
 396         };
 397         static const int values_0117[] = {
 398                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
 399         };
 400         static const int values_0100[] = {
 401                 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
 402         };
 403
 404         STK_DEBUG("dev_stk6a33_configure_device : %d\n", step);
 405
 406         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 407         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 408         usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
 409         usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
 410
 411         usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
 412         usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
 413         usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
 414         usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
 415         usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
 416
 417         usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
 418         usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
 419         usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
 420         usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
 421         usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
 422
 423         usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
 424         usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
 425         usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
 426         usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
 427         usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
 428
 429         usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
 430         usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
 431         usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
 432         usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
 433         usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
 434
 435         usb_stk11xx_write_registry(dev, 0x0115, values_0115[step]);
 436         usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
 437         usb_stk11xx_write_registry(dev, 0x0117, values_0117[step]);
 438
 439         usb_stk11xx_read_registry(dev, 0x0100, &value);
 440         usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
 441
 442         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 443         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 444         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 445
 446
 447         switch (step) {
 448                 case 0:
 449                         usb_stk11xx_write_registry(dev, 0x0203, 0x0040);
 450
 451                         usb_stk11xx_write_registry(dev, 0x0204, 0x0041);
 452                         usb_stk11xx_write_registry(dev, 0x0205, 0x0001);
 453                         usb_stk11xx_write_registry(dev, 0x0204, 0x001c);
 454                         usb_stk11xx_write_registry(dev, 0x0205, 0x0002);
 455
 456                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 457
 458                         break;
 459
 460                 case 1:
 461                         usb_stk11xx_write_registry(dev, 0x0203, 0x0022);
 462
 463                         usb_stk11xx_write_registry(dev, 0x0204, 0x0027);
 464                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 465
 466                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 467
 468                         break;
 469
 470                 case 2:
 471                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 472
 473                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 474                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 475                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 476                         usb_stk11xx_write_registry(dev, 0x0205, 0x00bf);
 477
 478                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 479
 480                         break;
 481
 482                 case 3:
 483                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 484
 485                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 486                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 487                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 488                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 489
 490                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 491
 492                         break;
 493
 494                 case 4:
 495                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 496
 497                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 498                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 499                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 500                         usb_stk11xx_write_registry(dev, 0x0205, 0x00e0);
 501                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 502                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 503
 504                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 505
 506                         break;
 507
 508                 case 5:
 509                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 510
 511                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 512                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 513                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 514                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 515
 516                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 517
 518                         break;
 519
 520                 case 6:
 521                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 522
 523                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 524                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 525                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 526                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 527
 528                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 529
 530                         break;
 531
 532                 case 7:
 533                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 534
 535                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 536                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 537                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 538                         usb_stk11xx_write_registry(dev, 0x0205, 0x00b7);
 539
 540                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 541
 542                         break;
 543
 544                 case 8:
 545                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 546
 547                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 548                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 549                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 550                         usb_stk11xx_write_registry(dev, 0x0205, 0x00b7);
 551
 552                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 553
 554                         break;
 555
 556                 case 9:
 557                         usb_stk11xx_write_registry(dev, 0x0203, 0x0080);
 558
 559                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 560                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 561                         usb_stk11xx_write_registry(dev, 0x0204, 0x000a);
 562                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 563
 564                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 565
 566                         break;
 567
 568                 case 10:
 569                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 570
 571                         usb_stk11xx_write_registry(dev, 0x0204, 0x0015);
 572                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 573
 574                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 575
 576                         break;
 577
 578                 case 11:
 579                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ec);
 580
 581                         usb_stk11xx_write_registry(dev, 0x0204, 0x0015);
 582                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 583
 584                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 585
 586                         break;
 587
 588                 case 12:
 589                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 590                         break;
 591
 592                 case 13:
 593                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 594                         break;
 595
 596                 case 14:
 597                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 598
 599                         usb_stk11xx_write_registry(dev, 0x0204, 0x0001);
 600                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 601
 602                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 603                         break;
 604
 605                 case 15:
 606                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 607
 608                         dev_stk6a33_sensor_settings(dev);
 609
 610                         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 611                         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 612                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0001);
 613                         usb_stk11xx_write_registry(dev, 0x0203, 0x00a0);
 614
 615                         break;
 616
 617                 case 16:
 618                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 619
 620                         dev_stk6a33_sensor_settings(dev);
 621
 622                         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 623                         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 624                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0001);
 625                         usb_stk11xx_write_registry(dev, 0x0203, 0x00a0);
 626
 627
 628                         break;
 629
 630                 case 17:
 631                         usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 632
 633                         dev_stk6a33_sensor_settings(dev);
 634
 635                         break;
 636         }
 637
 638         return 0;
 639 }
 640
 641
 642 /**
 643  * @param dev Device structure
 644  *
 645  * @returns 0 if all is OK
 646  *
 647  * @brief Wake-up the camera.
 648  *
 649  * This function permits to wake-up the device.
 650  */
 651 int dev_stk6a33_camera_asleep(struct usb_stk11xx *dev)
 652 {
 653         int value;
 654
 655         usb_stk11xx_read_registry(dev, 0x0104, &value);
 656         usb_stk11xx_read_registry(dev, 0x0105, &value);
 657         usb_stk11xx_read_registry(dev, 0x0106, &value);
 658
 659         usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
 660         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 661         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 662         usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
 663
 664         usb_stk11xx_read_registry(dev, 0x0000, &value);
 665         usb_stk11xx_write_registry(dev, 0x0000, 0x0049);
 666
 667         return 0;
 668 }
 669
 670
 671 /**
 672  * @param dev Device structure
 673  *
 674  * @returns 0 if all is OK
 675  *
 676  * @brief This function initializes the device for the stream.
 677  *
 678  * It's the start. This function has to be called at first, before
 679  * enabling the video stream.
 680  */
 681 int dev_stk6a33_init_camera(struct usb_stk11xx *dev)
 682 {
 683         dev_stk6a33_camera_asleep(dev);
 684
 685         usb_stk11xx_set_feature(dev, 0);
 686
 687         usb_stk11xx_write_registry(dev, 0x0000, 0x00e0);
 688         usb_stk11xx_write_registry(dev, 0x0002, 0x00e8);
 689         usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
 690         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 691
 692         dev_stk6a33_configure_device(dev, 16);
 693
 694         dev_stk11xx_camera_off(dev);
 695
 696         return 0;
 697 }
 698
 699
 700 /**
 701  * @param dev Device structure
 702  *
 703  * @returns 0 if all is OK
 704  *
 705  * @brief This function permits to set default sensor settings.
 706  *
 707  * We set some registers in using a I2C bus.
 708  * WARNING, the sensor settings can be different following the situation.
 709  */
 710 int dev_stk6a33_sensor_settings(struct usb_stk11xx *dev)
 711 {
 712         int i;
 713         int retok;
 714         int value;
 715
 716         int asize;
 717         static const int values_204[] = {
 718                 0xf0, 0xf1, 0x0d, 0xf1, 0x0d, 0xf1, 0xf0, 0xf1, 0x35, 0xf1,
 719                 0xf0, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0xdd, 0xf1, 0xf0, 0xf1,
 720                 0x1f, 0xf1, 0x20, 0xf1, 0x21, 0xf1, 0x22, 0xf1, 0x23, 0xf1,
 721                 0x24, 0xf1, 0x28, 0xf1, 0x29, 0xf1, 0x5e, 0xf1, 0x5f, 0xf1,
 722                 0x60, 0xf1, 0xef, 0xf1, 0xf2, 0xf1, 0x02, 0xf1, 0x03, 0xf1,
 723                 0x04, 0xf1, 0x09, 0xf1, 0x0a, 0xf1, 0x0b, 0xf1, 0x0c, 0xf1,
 724                 0x0d, 0xf1, 0x0e, 0xf1, 0x0f, 0xf1, 0x10, 0xf1, 0x11, 0xf1,
 725                 0x15, 0xf1, 0x16, 0xf1, 0x17, 0xf1, 0x18, 0xf1, 0x19, 0xf1,
 726                 0x1a, 0xf1, 0x1b, 0xf1, 0x1c, 0xf1, 0x1d, 0xf1, 0x1e, 0xf1,
 727                 0xf0, 0xf1, 0x06, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0x80, 0xf1,
 728                 0x81, 0xf1, 0x82, 0xf1, 0x83, 0xf1, 0x84, 0xf1, 0x85, 0xf1,
 729                 0x86, 0xf1, 0x87, 0xf1, 0x88, 0xf1, 0x89, 0xf1, 0x8a, 0xf1,
 730                 0x8b, 0xf1, 0x8c, 0xf1, 0x8d, 0xf1, 0x8e, 0xf1, 0x8f, 0xf1,
 731                 0x90, 0xf1, 0x91, 0xf1, 0x92, 0xf1, 0x93, 0xf1, 0x94, 0xf1,
 732                 0x95, 0xf1, 0xb6, 0xf1, 0xb7, 0xf1, 0xb8, 0xf1, 0xb9, 0xf1,
 733                 0xba, 0xf1, 0xbb, 0xf1, 0xbc, 0xf1, 0xbd, 0xf1, 0xbe, 0xf1,
 734                 0xbf, 0xf1, 0xc0, 0xf1, 0xc1, 0xf1, 0xc2, 0xf1, 0xc3, 0xf1,
 735                 0xc4, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0x53, 0xf1, 0x54, 0xf1,
 736                 0x55, 0xf1, 0x56, 0xf1, 0x57, 0xf1, 0x58, 0xf1, 0xf0, 0xf1,
 737                 0xa7, 0xf1, 0xaa, 0xf1, 0x3a, 0xf1, 0xa1, 0xf1, 0xa4, 0xf1,
 738                 0x9b, 0xf1, 0x08, 0xf1, 0xf0, 0xf1, 0x2f, 0xf1, 0x9c, 0xf1,
 739                 0xd2, 0xf1, 0xcc, 0xf1, 0xcb, 0xf1, 0x2e, 0xf1, 0x67, 0xf1,
 740                 0xf0, 0xf1, 0x65, 0xf1, 0x66, 0xf1, 0x67, 0xf1, 0x65, 0xf1,
 741                 0xf0, 0xf1, 0x05, 0xf1, 0x07, 0xf1, 0xf0, 0xf1, 0x39, 0xf1,
 742                 0x3b, 0xf1, 0x3a, 0xf1, 0x3c, 0xf1, 0x57, 0xf1, 0x58, 0xf1,
 743                 0x59, 0xf1, 0x5a, 0xf1, 0x5c, 0xf1, 0x5d, 0xf1, 0x64, 0xf1,
 744                 0xf0, 0xf1, 0x5b, 0xf1, 0xf0, 0xf1, 0x36, 0xf1, 0x37, 0xf1,
 745                 0xf0, 0xf1, 0x08, 0xf1
 746         };
 747         static const int values_205[] = {
 748                 0x00, 0x00, 0x00, 0x0b, 0x00, 0x08, 0x00, 0x00, 0x00, 0x22,
 749                 0x00, 0x01, 0x70, 0x0e, 0x00, 0x02, 0x18, 0xe0, 0x00, 0x02,
 750                 0x01, 0x80, 0xc8, 0x14, 0x80, 0x80, 0xa0, 0x78, 0xa0, 0x78,
 751                 0x5f, 0x20, 0xea, 0x02, 0x86, 0x7a, 0x59, 0x4c, 0x4d, 0x51,
 752                 0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0x00, 0xee, 0x39, 0x23,
 753                 0x07, 0x24, 0x00, 0xcd, 0x00, 0x93, 0x00, 0x04, 0x00, 0x5c,
 754                 0x00, 0xd9, 0x00, 0x53, 0x00, 0x08, 0x00, 0x91, 0x00, 0xcf,
 755                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 756                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 757                 0x00, 0x01, 0xf0, 0x0e, 0x70, 0x0e, 0x00, 0x01, 0x00, 0x0b,
 758                 0xee, 0x08, 0xf8, 0xf3, 0x00, 0xfb, 0xee, 0x09, 0xf7, 0xf3,
 759                 0xff, 0xfa, 0xf2, 0x08, 0xf9, 0xf5, 0xff, 0xf9, 0xe4, 0x10,
 760                 0xf1, 0xea, 0xf8, 0xf6, 0x00, 0x00, 0xe9, 0x0f, 0xf2, 0xed,
 761                 0xf6, 0xf6, 0x00, 0x00, 0xea, 0x0d, 0xf4, 0xf1, 0xf8, 0xf8,
 762                 0x00, 0x00, 0x07, 0x06, 0x1c, 0x0b, 0x08, 0x06, 0x17, 0x0a,
 763                 0x05, 0x06, 0x1a, 0x07, 0x06, 0x04, 0x0a, 0x08, 0x00, 0x19,
 764                 0x06, 0x05, 0x07, 0x0a, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x08,
 765                 0x00, 0x1b, 0x74, 0x0e, 0x00, 0x01, 0x0b, 0x03, 0x47, 0x22,
 766                 0xac, 0x82, 0xda, 0xc7, 0xf5, 0xe9, 0xff, 0x00, 0x00, 0x01,
 767                 0x02, 0x80, 0x01, 0xe0, 0x43, 0x00, 0x05, 0x00, 0x04, 0x00,
 768                 0x43, 0x00, 0x01, 0x80, 0x00, 0x02, 0xd1, 0x00, 0xd1, 0x00,
 769                 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x0c, 0x50, 0x10, 0x10,
 770                 0x00, 0x00, 0xa0, 0x00, 0x20, 0x03, 0x05, 0x01, 0x20, 0x00,
 771                 0x00, 0x00, 0x01, 0xb8, 0x00, 0xd8, 0x00, 0x02, 0x06, 0xc0,
 772                 0x04, 0x0e, 0x06, 0xc0, 0x05, 0x64, 0x02, 0x08, 0x02, 0x71,
 773                 0x02, 0x08, 0x02, 0x71, 0x12, 0x0d, 0x17, 0x12, 0x5e, 0x1c,
 774                 0x00, 0x02, 0x00, 0x03, 0x00, 0x02, 0x78, 0x10, 0x83, 0x04,
 775                 0x00, 0x00, 0x00, 0x21
 776         };
 777
 778
 779         asize = ARRAY_SIZE(values_204);
 780
 781         for(i=0; i<asize; i++) {
 782                 usb_stk11xx_read_registry(dev, 0x02ff, &value);
 783                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 784
 785                 usb_stk11xx_write_registry(dev, 0x0203, 0x00ba);
 786
 787                 usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
 788                 usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
 789                 usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 790
 791                 retok = dev_stk11xx_check_device(dev, 500);
 792
 793                 if (retok != 1) {
 794                         STK_ERROR("Load default sensor settings fail !\n");
 795                         return -1;
 796                 }
 797
 798                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 799         }
 800
 801         retok = dev_stk11xx_check_device(dev, 500);
 802
 803         return 0;
 804 }
 805
 806
 807 /**
 808  * @param dev Device structure
 809  *
 810  * @returns 0 if all is OK
 811  *
 812  * @brief This function permits to modify the settings of the camera.
 813  *
 814  * This functions permits to modify the settings :
 815  *   - brightness
 816  *   - contrast
 817  *   - white balance
 818  *   - ...
 819  */
 820 int dev_stk6a33_camera_settings(struct usb_stk11xx *dev)
 821 {
 822         int i;
 823         int ret;
 824         int value;
 825
 826         int asize;
 827         static const int values_204[] = {
 828                 0xf0, 0xf1, 0x2e, 0xf1, 0xf0, 0xf1, 0x5b, 0xf1, 0xf0, 0xf1, 0x36, 0xf1, 0x37, 0xf1, 0xf0, 0xf1, 0x08, 0xf1
 829         };
 830         static const int values_205[] = {
 831                 0x00, 0x02, 0x0c, 0x3c, 0x00, 0x02, 0x00, 0x03, 0x00, 0x02, 0x78, 0x10, 0x83, 0x04, 0x00, 0x00, 0x00, 0x21
 832         };
 833
 834
 835         asize = ARRAY_SIZE(values_204);
 836
 837         // Contrast register
 838         for (i=0; i<asize; i++) {
 839                 usb_stk11xx_read_registry(dev, 0x02ff, &value);
 840                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 841
 842                 usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
 843                 usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
 844
 845                 usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 846                 ret = dev_stk11xx_check_device(dev, 500);
 847                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 848         }
 849
 850         return 0;
 851 }
 852
 853
 854 /**
 855  * @param dev Device structure
 856  *
 857  * @returns 0 if all is OK
 858  *
 859  * @brief This function permits to modify the settings of the camera.
 860  *
 861  * This functions permits to modify the settings :
 862  *   - brightness
 863  *   - contrast
 864  *   - white balance
 865  *   - ...
 866  *
 867  * 0x204 = 0xa1 : unkown (by default 0x00)
 868  * 0x204 = 0x10 : contrast (by default 0x7c)
 869  * 0x204 = 0x04 : Mode (unknown) (by default 0x00) (=> already looked 0x01 and 0x02)
 870  * 0x204 = 0x00 : brightness / white balance (by default 0x00)
 871  */
 872 int dev_stk6a33_set_camera_quality(struct usb_stk11xx *dev)
 873 {
 874         int ret;
 875         int value;
 876
 877         // Contrast register
 878         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 879         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 880
 881         usb_stk11xx_write_registry(dev, 0x0204, 0x00b3);
 882         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
 883
 884         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 885         ret = dev_stk11xx_check_device(dev, 500);
 886         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 887
 888         STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
 889         STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
 890         STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
 891         STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
 892
 893         return 0;
 894 }
 895
 896
 897 /**
 898  * @param dev Device structure
 899  *
 900  * @returns 0 if all is OK
 901  *
 902  * @brief This function permits to modify the settings of the camera.
 903  *
 904  * This functions permits to modify the frame rate per second.
 905  *
 906  * 0x204 = 0x2e : Fps MSB (by default 0x01)
 907  * 0x204 = 0x2d : Fps LSB (by default 0x00)
 908  *
 909  * 0x2e | 0x2d | Nbr fps
 910  * -----+------+--------
 911  * 0x00 | 0x00 |  30
 912  * 0x01 | 0x00 |  20
 913  * 0x02 | 0x00 |  15
 914  * 0x03 | 0x00 |  12
 915  * 0x04 | 0x00 |  10
 916  */
 917 int dev_stk6a33_set_camera_fps(struct usb_stk11xx *dev)
 918 {
 919         return 0;
 920 }
 921
 922
 923 /**
 924  * @param dev Device structure
 925  *
 926  * @returns 0 if all is OK
 927  *
 928  * @brief This function sets the device to start the stream.
 929  *
 930  * After the initialization of the device and the initialization of the video stream,
 931  * this function permits to enable the stream.
 932  */
 933 int dev_stk6a33_start_stream(struct usb_stk11xx *dev)
 934 {
 935         int value;
 936         int value_116, value_117;
 937
 938         usb_stk11xx_read_registry(dev, 0x0114, &value); // read 0x80
 939         usb_stk11xx_read_registry(dev, 0x0115, &value); // read 0x02
 940
 941         usb_stk11xx_read_registry(dev, 0x0116, &value_116);
 942         usb_stk11xx_read_registry(dev, 0x0117, &value_117);
 943
 944         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 945         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 946
 947         usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
 948         usb_stk11xx_write_registry(dev, 0x0100, 0x00a0);
 949
 950         usb_stk11xx_write_registry(dev, 0x0116, value_116);
 951         usb_stk11xx_write_registry(dev, 0x0117, value_117);
 952
 953         return 0;
 954 }
 955
 956
 957 /**
 958  * @param dev Device structure
 959  *
 960  * @returns 0 if all is OK
 961  *
 962  * @brief Reconfigure the camera before the stream.
 963  *
 964  * Before enabling the video stream, you have to reconfigure the device.
 965  */
 966 int dev_stk6a33_reconf_camera(struct usb_stk11xx *dev)
 967 {
 968         dev_stk6a33_configure_device(dev, 16);
 969
 970         dev_stk11xx_camera_settings(dev);
 971
 972         return 0;
 973 }
 974
 975
 976 /**
 977  * @param dev Device structure
 978  *
 979  * @returns 0 if all is OK
 980  *
 981  * @brief This function sets the device to stop the stream.
 982  *
 983  * You use the function start_stream to enable the video stream. So you
 984  * have to use the function stop_strem to disable the video stream.
 985  */
 986 int dev_stk6a33_stop_stream(struct usb_stk11xx *dev)
 987 {
 988         int value;
 989
 990         usb_stk11xx_read_registry(dev, 0x0100, &value);
 991         usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
 992
 993         return 0;
 994 }
 995