stk11xx-dev-a311.c

   1 /**
   2  * @file stk11xx-dev-a311.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-M811 API / STK-A311 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_stka311_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, 0x0068);
  79         usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
  80
  81         usb_stk11xx_write_registry(dev, 0x0002, 0x006f);
  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, 0x006d);
 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, 0x006f);
 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, 0x006d);
 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, 0x006f);
 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, 0x006d);
 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, 0x006f);
 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, 0x00e8);
 239         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 240         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 241
 242         dev_stka311_configure_device(dev, 0);
 243         retok = dev_stk11xx_check_device(dev, 65);
 244         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 245
 246         dev_stka311_configure_device(dev, 1);
 247         retok = dev_stk11xx_check_device(dev, 65);
 248         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 249
 250         dev_stka311_configure_device(dev, 2);
 251         retok = dev_stk11xx_check_device(dev, 500);
 252         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 253         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 254         usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
 255         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 256         retok = dev_stk11xx_check_device(dev, 500);
 257         usb_stk11xx_read_registry(dev, 0x0209, &value);
 258         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 259         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 260         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 261         usb_stk11xx_write_registry(dev, 0x0208, 0x000a);
 262         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 263         retok = dev_stk11xx_check_device(dev, 500);
 264         usb_stk11xx_read_registry(dev, 0x0209, &value);
 265         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 266         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 267         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 268         usb_stk11xx_write_registry(dev, 0x0208, 0x000b);
 269         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 270         retok = dev_stk11xx_check_device(dev, 500);
 271         usb_stk11xx_read_registry(dev, 0x0209, &value);
 272         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 273
 274         dev_stka311_configure_device(dev, 3);
 275         retok = dev_stk11xx_check_device(dev, 65);
 276         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 277
 278         dev_stka311_configure_device(dev, 4);
 279         retok = dev_stk11xx_check_device(dev, 65);
 280         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 281
 282         dev_stka311_configure_device(dev, 5);
 283         retok = dev_stk11xx_check_device(dev, 500);
 284         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 285         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 286         usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
 287         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 288         retok = dev_stk11xx_check_device(dev, 500);
 289         usb_stk11xx_read_registry(dev, 0x0209, &value);
 290         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 291         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 292         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 293         usb_stk11xx_write_registry(dev, 0x0208, 0x000a);
 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         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 299         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 300         usb_stk11xx_write_registry(dev, 0x0208, 0x000b);
 301         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 302         retok = dev_stk11xx_check_device(dev, 500);
 303         usb_stk11xx_read_registry(dev, 0x0209, &value);
 304         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 305
 306         dev_stka311_configure_device(dev, 6);
 307         retok = dev_stk11xx_check_device(dev, 500);
 308         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 309         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 310         usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
 311         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 312         retok = dev_stk11xx_check_device(dev, 500);
 313         usb_stk11xx_read_registry(dev, 0x0209, &value);
 314         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 315         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 316         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 317         usb_stk11xx_write_registry(dev, 0x0208, 0x000a);
 318         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 319         retok = dev_stk11xx_check_device(dev, 500);
 320         usb_stk11xx_read_registry(dev, 0x0209, &value);
 321         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 322         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 323         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 324         usb_stk11xx_write_registry(dev, 0x0208, 0x000b);
 325         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 326         retok = dev_stk11xx_check_device(dev, 500);
 327         usb_stk11xx_read_registry(dev, 0x0209, &value);
 328         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 329
 330         dev_stka311_configure_device(dev, 7);
 331         retok = dev_stk11xx_check_device(dev, 500);
 332         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 333         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 334         usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
 335         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 336         retok = dev_stk11xx_check_device(dev, 500);
 337         usb_stk11xx_read_registry(dev, 0x0209, &value);
 338         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 339         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 340         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 341         usb_stk11xx_write_registry(dev, 0x0208, 0x000a);
 342         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 343         retok = dev_stk11xx_check_device(dev, 500);
 344         usb_stk11xx_read_registry(dev, 0x0209, &value);
 345         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 346         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 347         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 348         usb_stk11xx_write_registry(dev, 0x0208, 0x000b);
 349         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 350         retok = dev_stk11xx_check_device(dev, 500);
 351         usb_stk11xx_read_registry(dev, 0x0209, &value);
 352         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 353
 354         usb_stk11xx_write_registry(dev, 0x0002, 0x006f);
 355         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 356         usb_stk11xx_write_registry(dev, 0x0002, 0x006d);
 357         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 358         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 359         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 360
 361         dev_stka311_configure_device(dev, 8);
 362
 363         dev_stka311_camera_asleep(dev);
 364
 365         usb_stk11xx_set_feature(dev, 0);
 366
 367         // Device is initialized and is ready !!!
 368         STK_INFO("Syntek USB2.0 Camera is ready\n");
 369
 370         return 0;
 371 }
 372
 373
 374 /**
 375  * @param dev Device structure
 376  * @param step The step of configuration [0-11]
 377  *
 378  * @returns 0 if all is OK
 379  *
 380  * @brief This function permits to configure the device.
 381  *
 382  * The configuration of device is composed of 11 steps.
 383  * This function is called by the initialization process.
 384  *
 385  * We don't know the meaning of these steps ! We only replay the USB log.
 386  *
 387  * The steps 0 to 9 are called during the initialization.
 388  * Then, the driver choose the last step :
 389  *   10 : for a resolution from 80x60 to 640x480
 390  *   11 : for a resolution from 800x600 to 1280x1024
 391  */
 392 int dev_stka311_configure_device(struct usb_stk11xx *dev, int step)
 393 {
 394         int retok;
 395         int value;
 396
 397         //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11
 398
 399         static const int values_001B[] = {
 400                 0x0e, 0x03, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e
 401         };
 402         static const int values_001C[] = {
 403                 0x06, 0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0e
 404         };
 405         static const int values_0202[] = {
 406                 0x1e, 0x0a, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e
 407         };
 408         static const int values_0110[] = {
 409                 0x07, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00
 410         };
 411         static const int values_0112[] = {
 412                 0x07, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
 413         };
 414         static const int values_0114[] = {
 415                 0x87, 0x80, 0x80, 0x80, 0x80, 0xbe, 0xbe, 0x80, 0x80, 0x80, 0x80, 0x00
 416         };
 417         static const int values_0115[] = {
 418                 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05
 419         };
 420         static const int values_0116[] = {
 421                 0xe7, 0xe0, 0xe0, 0xe0, 0xe0, 0xe9, 0xe9, 0xe0, 0xe0, 0xe0, 0xe0, 0x00
 422         };
 423         static const int values_0117[] = {
 424                 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04
 425         };
 426         static const int values_0100[] = {
 427                 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21
 428         };
 429
 430         STK_DEBUG("dev_stka311_configure_device : %d\n", step);
 431
 432         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 433         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 434         usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
 435         usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
 436
 437         usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
 438         usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
 439         usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
 440         usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
 441         usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
 442
 443         usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
 444         usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
 445         usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
 446         usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
 447         usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
 448
 449         usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
 450         usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
 451         usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
 452         usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
 453         usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
 454
 455         usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
 456         usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
 457         usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
 458         usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
 459         usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
 460
 461         usb_stk11xx_write_registry(dev, 0x0115, values_0115[step]);
 462         usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
 463         usb_stk11xx_write_registry(dev, 0x0117, values_0117[step]);
 464
 465         usb_stk11xx_read_registry(dev, 0x0100, &value);
 466         usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
 467
 468         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 469         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 470         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 471
 472
 473         switch (step) {
 474                 case 0:
 475                         usb_stk11xx_write_registry(dev, 0x0203, 0x0040);
 476
 477                         usb_stk11xx_write_registry(dev, 0x0204, 0x0041);
 478                         usb_stk11xx_write_registry(dev, 0x0205, 0x0001);
 479                         usb_stk11xx_write_registry(dev, 0x0204, 0x001c);
 480                         usb_stk11xx_write_registry(dev, 0x0205, 0x0002);
 481
 482                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 483
 484                         break;
 485
 486                 case 1:
 487                         usb_stk11xx_write_registry(dev, 0x0203, 0x0022);
 488
 489                         usb_stk11xx_write_registry(dev, 0x0204, 0x0027);
 490                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 491
 492                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 493
 494                         break;
 495
 496                 case 2:
 497                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 498
 499                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 500                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 501                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 502                         usb_stk11xx_write_registry(dev, 0x0205, 0x00bf);
 503
 504                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 505
 506                         break;
 507
 508                 case 3:
 509                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 510
 511                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 512                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 513                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 514                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 515
 516                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 517
 518                         break;
 519
 520                 case 4:
 521                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 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, 0x00e0);
 527                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 528                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 529
 530                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 531
 532                         break;
 533
 534                 case 5:
 535                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 536
 537                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 538                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 539                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 540                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 541
 542                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 543
 544                         break;
 545
 546                 case 6:
 547                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 548
 549                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 550                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 551                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 552                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 553
 554                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 555
 556                         break;
 557
 558                 case 7:
 559                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 560
 561                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 562                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 563                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 564                         usb_stk11xx_write_registry(dev, 0x0205, 0x00b7);
 565
 566                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 567
 568                         break;
 569
 570                 case 8:
 571                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 572
 573                         dev_stka311_sensor_settings(dev);
 574
 575                         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 576                         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 577                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0001);
 578                         usb_stk11xx_write_registry(dev, 0x0203, 0x00a0);
 579
 580                         break;
 581
 582                 case 9:
 583                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 584
 585                         dev_stka311_sensor_settings(dev);
 586
 587                         usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
 588                         usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
 589                         usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
 590
 591                         break;
 592
 593                 case 10:
 594                 case 11:
 595                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 596
 597                         dev_stka311_sensor_settings(dev);
 598
 599                         usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
 600                         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 601                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 602                         usb_stk11xx_write_registry(dev, 0x0204, 0x002a);
 603                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 604                         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 605                         retok = dev_stk11xx_check_device(dev, 500);
 606                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 607                         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 608                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 609                         usb_stk11xx_write_registry(dev, 0x0204, 0x002b);
 610                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 611                         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 612                         retok = dev_stk11xx_check_device(dev, 500);
 613                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 614
 615                         break;
 616         }
 617
 618         return 0;
 619 }
 620
 621
 622 /**
 623  * @param dev Device structure
 624  *
 625  * @returns 0 if all is OK
 626  *
 627  * @brief Wake-up the camera.
 628  *
 629  * This function permits to wake-up the device.
 630  */
 631 int dev_stka311_camera_asleep(struct usb_stk11xx *dev)
 632 {
 633         int value;
 634
 635         usb_stk11xx_read_registry(dev, 0x0104, &value);
 636         usb_stk11xx_read_registry(dev, 0x0105, &value);
 637         usb_stk11xx_read_registry(dev, 0x0106, &value);
 638
 639         usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
 640         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 641         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 642         usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
 643
 644         usb_stk11xx_read_registry(dev, 0x0000, &value);
 645         usb_stk11xx_write_registry(dev, 0x0000, 0x004c);
 646
 647         return 0;
 648 }
 649
 650
 651 /**
 652  * @param dev Device structure
 653  *
 654  * @returns 0 if all is OK
 655  *
 656  * @brief This function initializes the device for the stream.
 657  *
 658  * It's the start. This function has to be called at first, before
 659  * enabling the video stream.
 660  */
 661 int dev_stka311_init_camera(struct usb_stk11xx *dev)
 662 {
 663         int retok;
 664         int value;
 665
 666         dev_stka311_camera_asleep(dev);
 667
 668         usb_stk11xx_set_feature(dev, 0);
 669
 670         usb_stk11xx_write_registry(dev, 0x0000, 0x00e0);
 671         usb_stk11xx_write_registry(dev, 0x0002, 0x00e8);
 672         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 673         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 674
 675         dev_stka311_configure_device(dev, 9);
 676
 677         dev_stk11xx_camera_off(dev);
 678
 679         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 680         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 681         usb_stk11xx_write_registry(dev, 0x0204, 0x002a);
 682         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 683         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 684         retok = dev_stk11xx_check_device(dev, 500);
 685         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 686         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 687         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 688         usb_stk11xx_write_registry(dev, 0x0204, 0x002b);
 689         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 690         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 691         retok = dev_stk11xx_check_device(dev, 500);
 692         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 693
 694         dev_stka311_camera_settings(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_stka311_sensor_settings(struct usb_stk11xx *dev)
 711 {
 712         int i;
 713         int retok;
 714         int value;
 715
 716         int asize;
 717         int *values_204 = NULL;
 718         int *values_205 = NULL;
 719
 720         // From 80x60 to 640x480
 721         static const int values_1_204[] = {
 722                 0x12, 0x11, 0x3b, 0x6a, 0x13, 0x10, 0x00, 0x01, 0x02, 0x13,
 723                 0x39, 0x38, 0x37, 0x35, 0x0e, 0x12, 0x04, 0x0c, 0x0d, 0x17,
 724                 0x18, 0x32, 0x19, 0x1a, 0x03, 0x1b, 0x16, 0x33, 0x34, 0x41,
 725                 0x96, 0x3d, 0x69, 0x3a, 0x8e, 0x3c, 0x8f, 0x8b, 0x8c, 0x94,
 726                 0x95, 0x40, 0x29, 0x0f, 0xa5, 0x1e, 0xa9, 0xaa, 0xab, 0x90,
 727                 0x91, 0x9f, 0xa0, 0x24, 0x25, 0x26, 0x14, 0x2a, 0x2b
 728         };
 729         static const int values_1_205[] = {
 730                 0x45, 0x80, 0x01, 0x7d, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80,
 731                 0x50, 0x93, 0x00, 0x81, 0x20, 0x45, 0x00, 0x00, 0x00, 0x24,
 732                 0xc4, 0xb6, 0x00, 0x3c, 0x36, 0x00, 0x07, 0xe2, 0xbf, 0x00,
 733                 0x04, 0x19, 0x40, 0x0d, 0x00, 0x73, 0xdf, 0x06, 0x20, 0x88,
 734                 0x88, 0xc1, 0x3f, 0x42, 0x80, 0x04, 0xb8, 0x92, 0x0a, 0x00,
 735                 0x00, 0x00, 0x00, 0x68, 0x5c, 0xc3, 0x2e, 0x00, 0x00
 736         };
 737
 738         // From 800x600 to 1280x1024
 739         static const int values_2_204[] = {
 740                 0x12, 0x11, 0x3b, 0x6a, 0x13, 0x10, 0x00, 0x01, 0x02, 0x13,
 741                 0x39, 0x38, 0x37, 0x35, 0x0e, 0x12, 0x04, 0x0c, 0x0d, 0x17,
 742                 0x18, 0x32, 0x19, 0x1a, 0x03, 0x1b, 0x16, 0x33, 0x34, 0x41,
 743                 0x96, 0x3d, 0x69, 0x3a, 0x8e, 0x3c, 0x8f, 0x8b, 0x8c, 0x94,
 744                 0x95, 0x40, 0x29, 0x0f, 0xa5, 0x1e, 0xa9, 0xaa, 0xab, 0x90,
 745                 0x91, 0x9f, 0xa0, 0x24, 0x25, 0x26, 0x14, 0x2a, 0x2b
 746         };
 747         static const int values_2_205[] = {
 748                 0x05, 0x80, 0x01, 0x7d, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80,
 749                 0x50, 0x93, 0x00, 0x81, 0x20, 0x05, 0x00, 0x00, 0x00, 0x1b,
 750                 0xbb, 0xa4, 0x01, 0x81, 0x12, 0x00, 0x07, 0xe2, 0xbf, 0x00,
 751                 0x04, 0x19, 0x40, 0x0d, 0x00, 0x73, 0xdf, 0x06, 0x20, 0x88,
 752                 0x88, 0xc1, 0x3f, 0x42, 0x80, 0x04, 0xb8, 0x92, 0x0a, 0x00,
 753                 0x00, 0x00, 0x00, 0x68, 0x5c, 0xc3, 0x2e, 0x00, 0x00
 754         };
 755
 756
 757         // From the resolution
 758         switch (dev->resolution) {
 759                 case STK11XX_1280x1024:
 760                 case STK11XX_1024x768:
 761                 case STK11XX_800x600:
 762                         asize = ARRAY_SIZE(values_2_204);
 763                         values_204 = (int *) values_2_204;
 764                         values_205 = (int *) values_2_205;
 765                         break;
 766
 767                 case STK11XX_640x480:
 768                 case STK11XX_320x240:
 769                 case STK11XX_160x120:
 770                 case STK11XX_213x160:
 771                 case STK11XX_128x96:
 772                 case STK11XX_80x60:
 773                 default:
 774                         asize = ARRAY_SIZE(values_1_204);
 775                         values_204 = (int *) values_1_204;
 776                         values_205 = (int *) values_1_205;
 777                         break;
 778         }
 779
 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, 0x0204, values_204[i]);
 786                 usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
 787                 usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 788
 789                 retok = dev_stk11xx_check_device(dev, 500);
 790
 791                 if (retok != 1) {
 792                         STK_ERROR("Load default sensor settings fail !\n");
 793                         return -1;
 794                 }
 795
 796                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 797         }
 798
 799         retok = dev_stk11xx_check_device(dev, 500);
 800
 801         return 0;
 802 }
 803
 804
 805 /**
 806  * @param dev Device structure
 807  *
 808  * @returns 0 if all is OK
 809  *
 810  * @brief This function permits to modify the settings of the camera.
 811  *
 812  * This functions permits to modify the settings :
 813  *   - brightness
 814  *   - contrast
 815  *   - white balance
 816  *   - ...
 817  */
 818 int dev_stka311_camera_settings(struct usb_stk11xx *dev)
 819 {
 820         int ret;
 821
 822         dev_stka311_set_camera_quality(dev);
 823
 824         ret = dev_stk11xx_check_device(dev, 500);
 825
 826         if (!ret)
 827                 STK_DEBUG("Find not 0x4... seems OK\n");
 828
 829         dev_stka311_set_camera_fps(dev);
 830
 831         ret = dev_stk11xx_check_device(dev, 500);
 832
 833         if (!ret)
 834                 STK_DEBUG("Find not 0x4... seems OK\n");
 835
 836         return 0;
 837 }
 838
 839
 840 /**
 841  * @param dev Device structure
 842  *
 843  * @returns 0 if all is OK
 844  *
 845  * @brief This function permits to modify the settings of the camera.
 846  *
 847  * This functions permits to modify the settings :
 848  *   - brightness
 849  *   - contrast
 850  *   - white balance
 851  *   - ...
 852  *
 853  * 0x204 = 0xa1 : unkown (by default 0x00)
 854  * 0x204 = 0x10 : contrast (by default 0x7c)
 855  * 0x204 = 0x04 : Mode (unknown) (by default 0x00) (=> already looked 0x01 and 0x02)
 856  * 0x204 = 0x00 : brightness / white balance (by default 0x00)
 857  */
 858 int dev_stka311_set_camera_quality(struct usb_stk11xx *dev)
 859 {
 860         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 861
 862         // Colour registers
 863         usb_stk11xx_write_registry(dev, 0x0204, 0x0001);
 864         usb_stk11xx_write_registry(dev, 0x0205, (255 - (dev->vsettings.colour >> 8)));
 865         usb_stk11xx_write_registry(dev, 0x0204, 0x0002);
 866         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.colour >> 8));
 867
 868         // Unknown register
 869         usb_stk11xx_write_registry(dev, 0x0204, 0x00a1);
 870         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 871
 872         // Contrast register
 873         usb_stk11xx_write_registry(dev, 0x0204, 0x0010);
 874         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 9));
 875
 876         // Unknown register
 877         usb_stk11xx_write_registry(dev, 0x0204, 0x0004);
 878         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 879
 880         // Whiteness register
 881         usb_stk11xx_write_registry(dev, 0x0204, 0x0000);
 882         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.whiteness >> 11) | 0x20);
 883
 884         usb_stk11xx_write_registry(dev, 0x0200, 0x0006);
 885
 886         STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
 887         STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
 888         STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
 889         STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
 890
 891         return 0;
 892 }
 893
 894
 895 /**
 896  * @param dev Device structure
 897  *
 898  * @returns 0 if all is OK
 899  *
 900  * @brief This function permits to modify the settings of the camera.
 901  *
 902  * This functions permits to modify the frame rate per second.
 903  *
 904  * 0x204 = 0x2e : Fps MSB (by default 0x01)
 905  * 0x204 = 0x2d : Fps LSB (by default 0x00)
 906  *
 907  * 0x2e | 0x2d | Nbr fps
 908  * -----+------+--------
 909  * 0x00 | 0x00 |  30
 910  * 0x01 | 0x00 |  20
 911  * 0x02 | 0x00 |  15
 912  * 0x03 | 0x00 |  12
 913  * 0x04 | 0x00 |  10
 914  */
 915 int dev_stka311_set_camera_fps(struct usb_stk11xx *dev)
 916 {
 917         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 918
 919         // FPS register
 920         switch (dev->vsettings.fps) {
 921                 case 10:
 922                         usb_stk11xx_write_registry(dev, 0x0204, 0x002e);
 923                         usb_stk11xx_write_registry(dev, 0x0205, 0x0004);
 924                         usb_stk11xx_write_registry(dev, 0x0204, 0x002d);
 925                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 926                         break;
 927
 928                 case 15:
 929                         usb_stk11xx_write_registry(dev, 0x0204, 0x002e);
 930                         usb_stk11xx_write_registry(dev, 0x0205, 0x0002);
 931                         usb_stk11xx_write_registry(dev, 0x0204, 0x002d);
 932                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 933                         break;
 934
 935                 case 20:
 936                         usb_stk11xx_write_registry(dev, 0x0204, 0x002e);
 937                         usb_stk11xx_write_registry(dev, 0x0205, 0x0001);
 938                         usb_stk11xx_write_registry(dev, 0x0204, 0x002d);
 939                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 940                         break;
 941
 942                 default:
 943                 case 25:
 944                         usb_stk11xx_write_registry(dev, 0x0204, 0x002e);
 945                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 946                         usb_stk11xx_write_registry(dev, 0x0204, 0x002d);
 947                         usb_stk11xx_write_registry(dev, 0x0205, 0x0064);
 948                         break;
 949
 950                 case 30:
 951                         usb_stk11xx_write_registry(dev, 0x0204, 0x002e);
 952                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 953                         usb_stk11xx_write_registry(dev, 0x0204, 0x002d);
 954                         usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
 955                         break;
 956         }
 957
 958         usb_stk11xx_write_registry(dev, 0x0200, 0x0006);
 959
 960         return 0;
 961 }
 962
 963
 964 /**
 965  * @param dev Device structure
 966  *
 967  * @returns 0 if all is OK
 968  *
 969  * @brief This function sets the device to start the stream.
 970  *
 971  * After the initialization of the device and the initialization of the video stream,
 972  * this function permits to enable the stream.
 973  */
 974 int dev_stka311_start_stream(struct usb_stk11xx *dev)
 975 {
 976         int value;
 977         int value_116, value_117;
 978
 979         usb_stk11xx_read_registry(dev, 0x0116, &value_116);
 980         usb_stk11xx_read_registry(dev, 0x0117, &value_117);
 981
 982         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 983         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 984
 985         usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
 986         usb_stk11xx_write_registry(dev, 0x0100, 0x00a1);
 987
 988         usb_stk11xx_write_registry(dev, 0x0116, value_116);
 989         usb_stk11xx_write_registry(dev, 0x0117, value_117);
 990
 991         return 0;
 992 }
 993
 994
 995 /**
 996  * @param dev Device structure
 997  *
 998  * @returns 0 if all is OK
 999  *
1000  * @brief Reconfigure the camera before the stream.
1001  *
1002  * Before enabling the video stream, you have to reconfigure the device.
1003  */
1004 int dev_stka311_reconf_camera(struct usb_stk11xx *dev)
1005 {
1006         int step = 10;
1007
1008         // Choose the step from the resolution
1009         switch (dev->resolution) {
1010                 case STK11XX_1280x1024:
1011                 case STK11XX_1024x768:
1012                 case STK11XX_800x600:
1013                         step = 11;
1014                         break;
1015
1016                 case STK11XX_640x480:
1017                 case STK11XX_320x240:
1018                 case STK11XX_160x120:
1019                 case STK11XX_213x160:
1020                 case STK11XX_128x96:
1021                 case STK11XX_80x60:
1022                 default:
1023                         step = 10;
1024                         break;
1025         }
1026
1027         dev_stka311_configure_device(dev, step);
1028
1029         dev_stk11xx_camera_settings(dev);
1030
1031         return 0;
1032 }
1033
1034
1035 /**
1036  * @param dev Device structure
1037  *
1038  * @returns 0 if all is OK
1039  *
1040  * @brief This function sets the device to stop the stream.
1041  *
1042  * You use the function start_stream to enable the video stream. So you
1043  * have to use the function stop_strem to disable the video stream.
1044  */
1045 int dev_stka311_stop_stream(struct usb_stk11xx *dev)
1046 {
1047         int value;
1048
1049         usb_stk11xx_read_registry(dev, 0x0100, &value);
1050         usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
1051
1052         return 0;
1053 }
1054