stk11xx-dev-a821.c

   1 /**
   2  * @file stk11xx-dev-a821.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-A821 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_stka821_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_stka821_configure_device(dev, 0);
 243         retok = dev_stk11xx_check_device(dev, 65);
 244         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 245
 246         dev_stka821_configure_device(dev, 1);
 247         retok = dev_stk11xx_check_device(dev, 65);
 248         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 249
 250         dev_stka821_configure_device(dev, 2);
 251         retok = dev_stk11xx_check_device(dev, 65);
 252         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 253
 254         dev_stka821_configure_device(dev, 3);
 255         retok = dev_stk11xx_check_device(dev, 65);
 256         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 257
 258         dev_stka821_configure_device(dev, 4);
 259         retok = dev_stk11xx_check_device(dev, 65);
 260         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 261
 262         dev_stka821_configure_device(dev, 5);
 263         retok = dev_stk11xx_check_device(dev, 65);
 264         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 265
 266         dev_stka821_configure_device(dev, 6);
 267         retok = dev_stk11xx_check_device(dev, 65);
 268         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 269
 270         dev_stka821_configure_device(dev, 7);
 271         retok = dev_stk11xx_check_device(dev, 65);
 272         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 273
 274         dev_stka821_configure_device(dev, 8);
 275         retok = dev_stk11xx_check_device(dev, 65);
 276         usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
 277
 278         dev_stka821_configure_device(dev, 9);
 279         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 280         usb_stk11xx_write_registry(dev, 0x0002, 0x006d);
 281         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 282         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
 283         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 284
 285         dev_stka821_configure_device(dev, 10);
 286         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 287         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 288         usb_stk11xx_write_registry(dev, 0x02ff, 0x0001);
 289         usb_stk11xx_write_registry(dev, 0x0203, 0x00a0);
 290
 291         dev_stka821_camera_asleep(dev);
 292
 293         usb_stk11xx_set_feature(dev, 0);
 294
 295         // Device is initialized and is ready !!!
 296         STK_INFO("Syntek USB2.0 Camera is ready\n");
 297
 298         return 0;
 299 }
 300
 301
 302 /**
 303  * @param dev Device structure
 304  * @param step The step of configuration [0-11]
 305  *
 306  * @returns 0 if all is OK
 307  *
 308  * @brief This function permits to configure the device.
 309  *
 310  * The configuration of device is composed of 12 steps.
 311  * This function is called by the initialization process.
 312  *
 313  * We don't know the meaning of these steps ! We only replay the USB log.
 314  */
 315 int dev_stka821_configure_device(struct usb_stk11xx *dev, int step)
 316 {
 317         int retok;
 318         int value;
 319
 320         //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13
 321         static const int values_001B[] = {
 322                 0x0e, 0x03, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x07, 0x07, 0x07, 0x07, 0x07
 323         };
 324         static const int values_001C[] = {
 325                 0x06, 0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
 326         };
 327         static const int values_0202[] = {
 328                 0x1e, 0x0a, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e
 329         };
 330         static const int values_0110[] = {
 331                 0x07, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x3e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
 332         };
 333         static const int values_0112[] = {
 334                 0x07, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
 335         };
 336         static const int values_0114[] = {
 337                 0x87, 0x80, 0x80, 0x80, 0x80, 0xbe, 0xbe, 0x80, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80
 338         };
 339         static const int values_0116[] = {
 340                 0xe7, 0xe0, 0xe0, 0xe0, 0xe0, 0xe9, 0xe9, 0xe0, 0xe4, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0
 341         };
 342         static const int values_0100[] = {
 343                 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20
 344         };
 345
 346         STK_DEBUG("dev_stka821_configure_device : %d\n", step);
 347
 348         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
 349         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 350         usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
 351         usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
 352
 353         usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
 354         usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
 355         usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
 356         usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
 357         usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
 358
 359         usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
 360         usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
 361         usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
 362         usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
 363         usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
 364
 365         usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
 366         usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
 367         usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
 368         usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
 369         usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
 370
 371         usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
 372         usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
 373         usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
 374         usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
 375         usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
 376
 377         usb_stk11xx_write_registry(dev, 0x0115, 0x0002);
 378         usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
 379         usb_stk11xx_write_registry(dev, 0x0117, 0x0001);
 380
 381         usb_stk11xx_read_registry(dev, 0x0100, &value);
 382         usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
 383
 384         usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
 385         usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
 386         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 387
 388
 389         switch (step) {
 390                 case 0:
 391                         usb_stk11xx_write_registry(dev, 0x0203, 0x0040);
 392
 393                         usb_stk11xx_write_registry(dev, 0x0204, 0x0041);
 394                         usb_stk11xx_write_registry(dev, 0x0205, 0x0001);
 395                         usb_stk11xx_write_registry(dev, 0x0204, 0x001c);
 396                         usb_stk11xx_write_registry(dev, 0x0205, 0x0002);
 397
 398                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 399
 400                         break;
 401
 402                 case 1:
 403                         usb_stk11xx_write_registry(dev, 0x0203, 0x0022);
 404
 405                         usb_stk11xx_write_registry(dev, 0x0204, 0x0027);
 406                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 407
 408                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 409
 410                         break;
 411
 412                 case 2:
 413                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 414
 415                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 416                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 417                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 418                         usb_stk11xx_write_registry(dev, 0x0205, 0x00bf);
 419
 420                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 421
 422                         break;
 423
 424                 case 3:
 425                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 426
 427                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 428                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 429                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 430                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 431
 432                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 433
 434                         break;
 435
 436                 case 4:
 437                         usb_stk11xx_write_registry(dev, 0x0203, 0x0042);
 438
 439                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 440                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 441                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 442                         usb_stk11xx_write_registry(dev, 0x0205, 0x00e0);
 443                         usb_stk11xx_write_registry(dev, 0x0204, 0x0024);
 444                         usb_stk11xx_write_registry(dev, 0x0205, 0x00a5);
 445
 446                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 447
 448                         break;
 449
 450                 case 5:
 451                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 452
 453                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 454                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 455                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 456                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 457
 458                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 459
 460                         break;
 461
 462                 case 6:
 463                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 464
 465                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 466                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 467                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 468                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 469
 470                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 471
 472                         break;
 473
 474                 case 7:
 475                         usb_stk11xx_write_registry(dev, 0x0203, 0x0060);
 476
 477                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 478                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 479                         usb_stk11xx_write_registry(dev, 0x0204, 0x0013);
 480                         usb_stk11xx_write_registry(dev, 0x0205, 0x00b7);
 481
 482                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 483
 484                         break;
 485
 486                 case 8:
 487                         usb_stk11xx_write_registry(dev, 0x0203, 0x0080);
 488
 489                         usb_stk11xx_write_registry(dev, 0x0204, 0x0012);
 490                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 491                         usb_stk11xx_write_registry(dev, 0x0204, 0x000a);
 492                         usb_stk11xx_write_registry(dev, 0x0205, 0x00ff);
 493
 494                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 495
 496                         break;
 497
 498                 case 9:
 499                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 500
 501                         usb_stk11xx_write_registry(dev, 0x0204, 0x0015);
 502                         usb_stk11xx_write_registry(dev, 0x0205, 0x0080);
 503
 504                         usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
 505
 506                         retok = dev_stk11xx_check_device(dev, 500);
 507                         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 508                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 509                         usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
 510                         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 511                         retok = dev_stk11xx_check_device(dev, 500);
 512                         usb_stk11xx_read_registry(dev, 0x0209, &value);
 513                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 514                         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 515                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 516                         usb_stk11xx_write_registry(dev, 0x0208, 0x0001);
 517                         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 518                         retok = dev_stk11xx_check_device(dev, 500);
 519                         usb_stk11xx_read_registry(dev, 0x0209, &value);
 520                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 521                         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 522                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 523                         usb_stk11xx_write_registry(dev, 0x0208, 0x0002);
 524                         usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
 525                         retok = dev_stk11xx_check_device(dev, 500);
 526                         usb_stk11xx_read_registry(dev, 0x0209, &value);
 527                         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 528                         usb_stk11xx_write_registry(dev, 0x0002, 0x006f);
 529
 530                         break;
 531
 532                 case 10:
 533                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 534
 535                         dev_stka821_sensor_settings(dev);
 536
 537                         break;
 538
 539                 case 11:
 540                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 541
 542                         dev_stka821_sensor_settings(dev);
 543
 544                         usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
 545                         usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
 546                         usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
 547
 548                         break;
 549
 550                 case 12:
 551                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 552
 553                         dev_stka821_sensor_settings(dev);
 554
 555                         usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
 556                         usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
 557                         usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
 558
 559                         break;
 560
 561                 case 13:
 562                         usb_stk11xx_write_registry(dev, 0x0203, 0x00dc);
 563
 564                         dev_stka821_sensor_settings(dev);
 565
 566                         usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
 567         }
 568
 569         return 0;
 570 }
 571
 572
 573 /**
 574  * @param dev Device structure
 575  *
 576  * @returns 0 if all is OK
 577  *
 578  * @brief Wake-up the camera.
 579  *
 580  * This function permits to wake-up the device.
 581  */
 582 int dev_stka821_camera_asleep(struct usb_stk11xx *dev)
 583 {
 584         int value;
 585
 586         usb_stk11xx_read_registry(dev, 0x0104, &value);
 587         usb_stk11xx_read_registry(dev, 0x0105, &value);
 588         usb_stk11xx_read_registry(dev, 0x0106, &value);
 589
 590         usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
 591         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 592         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 593         usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
 594
 595         usb_stk11xx_read_registry(dev, 0x0000, &value);
 596         usb_stk11xx_write_registry(dev, 0x0000, 0x0049);
 597
 598         return 0;
 599 }
 600
 601
 602 /**
 603  * @param dev Device structure
 604  *
 605  * @returns 0 if all is OK
 606  *
 607  * @brief This function initializes the device for the stream.
 608  *
 609  * It's the start. This function has to be called at first, before
 610  * enabling the video stream.
 611  */
 612 int dev_stka821_init_camera(struct usb_stk11xx *dev)
 613 {
 614 //      int retok;
 615 //      int value;
 616
 617         dev_stka821_camera_asleep(dev);
 618
 619         usb_stk11xx_set_feature(dev, 0);
 620
 621         usb_stk11xx_write_registry(dev, 0x0000, 0x00e0);
 622         usb_stk11xx_write_registry(dev, 0x0002, 0x00e8);
 623         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 624         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 625
 626         dev_stka821_configure_device(dev, 11);
 627
 628         dev_stk11xx_camera_off(dev);
 629
 630         dev_stka821_camera_settings(dev);
 631
 632         dev_stka821_camera_asleep(dev);
 633
 634         usb_stk11xx_set_feature(dev, 0);
 635
 636         usb_stk11xx_write_registry(dev, 0x0000, 0x00e0);
 637         usb_stk11xx_write_registry(dev, 0x0002, 0x00e8);
 638         usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
 639         usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
 640
 641         dev_stka821_configure_device(dev, 12);
 642
 643         dev_stk11xx_camera_off(dev);
 644
 645         dev_stka821_camera_settings(dev);
 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 permits to set default sensor settings.
 657  *
 658  * We set some registers in using a I2C bus.
 659  * WARNING, the sensor settings can be different following the situation.
 660  */
 661 int dev_stka821_sensor_settings(struct usb_stk11xx *dev)
 662 {
 663         int i;
 664         int retok;
 665         int value;
 666
 667         int asize;
 668         static const int values_204[] = {
 669                 0x17, 0x19, 0xb4, 0xa6, 0x12, 0x13, 0x1e, 0x21, 0x24, 0x32,
 670                 0x36, 0x39, 0x4d, 0x53, 0x5d, 0x5f, 0x60, 0x61, 0x62, 0x63,
 671                 0x64, 0x65, 0x66, 0x82, 0x83, 0x85, 0x86, 0x89, 0x97, 0x98,
 672                 0xad, 0xae, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbf, 0x48, 0xd8,
 673                 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 674                 0x80, 0x81, 0xd8, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
 675                 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0xd8, 0x76, 0x77, 0x78, 0x79,
 676                 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x5c, 0xc0,
 677                 0x59, 0x5a, 0x5b, 0xd4, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93,
 678                 0x94, 0x95, 0x96, 0xb3, 0x73, 0x06, 0x07, 0x0b, 0x15, 0x20,
 679                 0x4e, 0x4f, 0x49, 0x4a, 0x4b, 0x4c, 0x46, 0x06, 0x07, 0xb9,
 680                 0xba, 0xbb, 0xbc, 0x61, 0x62, 0x65, 0x66
 681         };
 682         static const int values_205[] = {
 683                 0x41, 0x41, 0x03, 0x06, 0x06, 0x08, 0x06, 0x00, 0x02, 0x69,
 684                 0x35, 0x60, 0xfe, 0x1c, 0x04, 0x08, 0x08, 0x08, 0x08, 0x00,
 685                 0x00, 0x10, 0x14, 0x01, 0x80, 0x0c, 0xb6, 0x00, 0x25, 0x25,
 686                 0x3f, 0x24, 0x10, 0x07, 0xcc, 0x1f, 0x30, 0x02, 0x9c, 0x80,
 687                 0x00, 0x0d, 0x18, 0x22, 0x2c, 0x3e, 0x4f, 0x6f, 0x8e, 0xac,
 688                 0xc8, 0xe5, 0xa0, 0x00, 0x0d, 0x18, 0x22, 0x2c, 0x3e, 0x4f,
 689                 0x6f, 0x8e, 0xac, 0xc8, 0xe5, 0xc0, 0x00, 0x0d, 0x18, 0x22,
 690                 0x2c, 0x3e, 0x4f, 0x6f, 0x8e, 0xac, 0xc8, 0xe5, 0x70, 0x18,
 691                 0x09, 0x07, 0x07, 0x3c, 0x3d, 0x95, 0x88, 0x89, 0x47, 0x9c,
 692                 0x81, 0x9c, 0x3d, 0x76, 0x76, 0x01, 0xf3, 0x05, 0x00, 0x44,
 693                 0x06, 0x0a, 0x96, 0x00, 0x7d, 0x00, 0x20, 0x01, 0xf3, 0x04,
 694                 0xe4, 0x09, 0xc8, 0x08, 0x08, 0x10, 0x14
 695         };
 696
 697
 698         asize = ARRAY_SIZE(values_204);
 699
 700         for(i=0; i<asize; i++) {
 701                 usb_stk11xx_read_registry(dev, 0x02ff, &value);
 702                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 703
 704                 usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
 705                 usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
 706                 usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 707
 708                 retok = dev_stk11xx_check_device(dev, 500);
 709
 710                 if (retok != 1) {
 711                         STK_ERROR("Load default sensor settings fail !\n");
 712                         return -1;
 713                 }
 714
 715                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 716         }
 717
 718         retok = dev_stk11xx_check_device(dev, 500);
 719
 720         return 0;
 721 }
 722
 723
 724 /**
 725  * @param dev Device structure
 726  *
 727  * @returns 0 if all is OK
 728  *
 729  * @brief This function permits to modify the settings of the camera.
 730  *
 731  * This functions permits to modify the settings :
 732  *   - brightness
 733  *   - contrast
 734  *   - white balance
 735  *   - ...
 736  */
 737 int dev_stka821_camera_settings(struct usb_stk11xx *dev)
 738 {
 739         int i;
 740         int ret;
 741         int value;
 742
 743         int asize;
 744         static const int values_204[] = {
 745                 0xb3, 0x73, 0x46, 0x06, 0x07, 0xb9, 0xba, 0xbb, 0xbc, 0x61, 0x62, 0x65, 0x66
 746         };
 747         static const int values_205[] = {
 748                 0x76, 0x76, 0x20, 0x01, 0xf3, 0x04, 0xe4, 0x09, 0xc8, 0x08, 0x08, 0x10, 0x14
 749         };
 750
 751
 752         // Contrast register
 753         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 754         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 755
 756         usb_stk11xx_write_registry(dev, 0x0204, 0x00b3);
 757         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
 758
 759         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 760         ret = dev_stk11xx_check_device(dev, 500);
 761         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 762
 763         asize = ARRAY_SIZE(values_204);
 764
 765         for (i=1; i<asize; i++) {
 766                 usb_stk11xx_read_registry(dev, 0x02ff, &value);
 767                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 768
 769                 usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
 770                 usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
 771
 772                 usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 773                 ret = dev_stk11xx_check_device(dev, 500);
 774                 usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 775         }
 776
 777         return 0;
 778 }
 779
 780
 781 /**
 782  * @param dev Device structure
 783  *
 784  * @returns 0 if all is OK
 785  *
 786  * @brief This function permits to modify the settings of the camera.
 787  *
 788  * This functions permits to modify the settings :
 789  *   - brightness
 790  *   - contrast
 791  *   - white balance
 792  *   - ...
 793  */
 794 int dev_stka821_set_camera_quality(struct usb_stk11xx *dev)
 795 {
 796         int ret;
 797         int value;
 798
 799         // Contrast register
 800         usb_stk11xx_read_registry(dev, 0x02ff, &value);
 801         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 802
 803         usb_stk11xx_write_registry(dev, 0x0204, 0x00b3);
 804         usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
 805
 806         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
 807         ret = dev_stk11xx_check_device(dev, 500);
 808         usb_stk11xx_write_registry(dev, 0x02ff, 0x0000);
 809
 810         STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
 811         STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
 812         STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
 813         STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
 814
 815         return 0;
 816 }
 817
 818
 819 /**
 820  * @param dev Device structure
 821  *
 822  * @returns 0 if all is OK
 823  *
 824  * @brief This function permits to modify the settings of the camera.
 825  *
 826  * This functions permits to modify the frame rate per second.
 827  */
 828 int dev_stka821_set_camera_fps(struct usb_stk11xx *dev)
 829 {
 830         return 0;
 831 }
 832
 833
 834 /**
 835  * @param dev Device structure
 836  *
 837  * @returns 0 if all is OK
 838  *
 839  * @brief This function sets the device to start the stream.
 840  *
 841  * After the initialization of the device and the initialization of the video stream,
 842  * this function permits to enable the stream.
 843  */
 844 int dev_stka821_start_stream(struct usb_stk11xx *dev)
 845 {
 846         int value;
 847         int value_116, value_117;
 848
 849         usb_stk11xx_read_registry(dev, 0x0116, &value_116);
 850         usb_stk11xx_read_registry(dev, 0x0117, &value_117);
 851
 852         usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
 853         usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
 854
 855         usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
 856         usb_stk11xx_write_registry(dev, 0x0100, 0x00a0);
 857
 858         usb_stk11xx_write_registry(dev, 0x0116, value_116);
 859         usb_stk11xx_write_registry(dev, 0x0117, value_117);
 860
 861         return 0;
 862 }
 863
 864
 865 /**
 866  * @param dev Device structure
 867  *
 868  * @returns 0 if all is OK
 869  *
 870  * @brief Reconfigure the camera before the stream.
 871  *
 872  * Before enabling the video stream, you have to reconfigure the device.
 873  */
 874 int dev_stka821_reconf_camera(struct usb_stk11xx *dev)
 875 {
 876         dev_stka821_configure_device(dev, 13);
 877
 878         dev_stk11xx_camera_settings(dev);
 879
 880         return 0;
 881 }
 882
 883
 884 /**
 885  * @param dev Device structure
 886  *
 887  * @returns 0 if all is OK
 888  *
 889  * @brief This function sets the device to stop the stream.
 890  *
 891  * You use the function start_stream to enable the video stream. So you
 892  * have to use the function stop_strem to disable the video stream.
 893  */
 894 int dev_stka821_stop_stream(struct usb_stk11xx *dev)
 895 {
 896         int value;
 897
 898         usb_stk11xx_read_registry(dev, 0x0100, &value);
 899         usb_stk11xx_write_registry(dev, 0x0100, 0x0020);
 900
 901         return 0;
 902 }
 903