stk11xx-dev.c

Go to the documentation of this file.
00001 
00034 #include <linux/module.h>
00035 #include <linux/init.h>
00036 #include <linux/kernel.h>
00037 #include <linux/errno.h>
00038 #include <linux/slab.h>
00039 #include <linux/kref.h>
00040 
00041 #include <linux/usb.h>
00042 #include <media/v4l2-common.h>
00043 
00044 #include "stk11xx.h"
00045 
00046 
00047 int dev_stka311_initialize_device(struct usb_stk11xx *);
00048 int dev_stka311_configure_device(struct usb_stk11xx *, int);
00049 int dev_stka311_start_stream(struct usb_stk11xx *);
00050 int dev_stka311_stop_stream(struct usb_stk11xx *);
00051 int dev_stka311_camera_asleep(struct usb_stk11xx *);
00052 int dev_stka311_init_camera(struct usb_stk11xx *);
00053 int dev_stka311_load_microcode(struct usb_stk11xx *);
00054 int dev_stka311_reconf_camera(struct usb_stk11xx *);
00055 int dev_stka311_camera_settings(struct usb_stk11xx *);
00056 int dev_stka311_set_camera_quality(struct usb_stk11xx *);
00057 int dev_stka311_set_camera_fps(struct usb_stk11xx *);
00058 
00059 int dev_stka821_initialize_device(struct usb_stk11xx *);
00060 int dev_stka821_configure_device(struct usb_stk11xx *, int);
00061 int dev_stka821_start_stream(struct usb_stk11xx *);
00062 int dev_stka821_stop_stream(struct usb_stk11xx *);
00063 int dev_stka821_camera_asleep(struct usb_stk11xx *);
00064 int dev_stka821_init_camera(struct usb_stk11xx *);
00065 int dev_stka821_load_microcode(struct usb_stk11xx *);
00066 int dev_stka821_reconf_camera(struct usb_stk11xx *);
00067 int dev_stka821_camera_settings(struct usb_stk11xx *);
00068 int dev_stka821_set_camera_quality(struct usb_stk11xx *);
00069 int dev_stka821_set_camera_fps(struct usb_stk11xx *);
00070 
00071 int dev_stk6a31_initialize_device(struct usb_stk11xx *);
00072 int dev_stk6a31_configure_device(struct usb_stk11xx *, int);
00073 int dev_stk6a31_start_stream(struct usb_stk11xx *);
00074 int dev_stk6a31_stop_stream(struct usb_stk11xx *);
00075 int dev_stk6a31_camera_asleep(struct usb_stk11xx *);
00076 int dev_stk6a31_init_camera(struct usb_stk11xx *);
00077 int dev_stk6a31_load_microcode(struct usb_stk11xx *);
00078 int dev_stk6a31_reconf_camera(struct usb_stk11xx *);
00079 int dev_stk6a31_camera_settings(struct usb_stk11xx *);
00080 int dev_stk6a31_set_camera_quality(struct usb_stk11xx *);
00081 int dev_stk6a31_set_camera_fps(struct usb_stk11xx *);
00082 
00083 
00097 int dev_stk11xx_initialize_device(struct usb_stk11xx *dev)
00098 {
00099     int ret;
00100 
00101     switch (dev->webcam_model) {
00102         case SYNTEK_STK_M811:
00103         case SYNTEK_STK_A311:
00104             ret = dev_stka311_initialize_device(dev);
00105             break;
00106 
00107         case SYNTEK_STK_A821:
00108             ret = dev_stka821_initialize_device(dev);
00109             break;
00110 
00111         case SYNTEK_STK_6A31:
00112             ret = dev_stk6a31_initialize_device(dev);
00113             break;
00114 
00115         default:
00116             ret = -1;
00117     }
00118 
00119     return ret;
00120 }
00121 
00122 
00133 int dev_stk11xx_init_camera(struct usb_stk11xx *dev)
00134 {
00135     int ret;
00136 
00137     switch (dev->webcam_model) {
00138         case SYNTEK_STK_M811:
00139         case SYNTEK_STK_A311:
00140             ret = dev_stka311_init_camera(dev);
00141             break;
00142 
00143         case SYNTEK_STK_A821:
00144             ret = dev_stka821_init_camera(dev);
00145             break;
00146 
00147         case SYNTEK_STK_6A31:
00148             ret = dev_stk6a31_init_camera(dev);
00149             break;
00150 
00151         default:
00152             ret = -1;
00153     }
00154 
00155     return ret;
00156 }
00157 
00158 
00172 int dev_stk11xx_check_device(struct usb_stk11xx *dev, int nbr)
00173 {
00174     int i;
00175     int value;
00176 
00177     for (i=0; i<nbr; i++) {
00178         usb_stk11xx_read_registry(dev, 0x201, &value);
00179         
00180         if (value == 0x00) {
00181         }
00182         else if (value == 0x01) {
00183             return 1;
00184         }
00185         else if (value == 0x04)
00186             return 1;
00187         else {
00188             STK_ERROR("Check device return error (0x0201 = %02X) !\n", value);
00189             return -1;
00190         }
00191     }
00192 
00193     return 0;
00194 }
00195 
00196 
00208 int dev_stk11xx_watchdog_camera(struct usb_stk11xx *dev)
00209 {
00210     int value;
00211 
00212     usb_stk11xx_read_registry(dev, 0x0001, &value);
00213 
00214     if (value != 0x03) {
00215         STK_ERROR("Error : Register 0x0001 = %02X\n", value);
00216     }
00217 
00218     return value;
00219 }
00220 
00221 
00231 int dev_stk11xx_camera_on(struct usb_stk11xx *dev)
00232 {
00233     int ret = -1;
00234     struct usb_device *udev = dev->udev;
00235 
00236     ret = usb_set_interface(udev, 0, 5);
00237 
00238     if (ret < 0)
00239         STK_ERROR("usb_set_interface failed !\n");
00240 
00241     return ret;
00242 }
00243 
00244 
00254 int dev_stk11xx_camera_off(struct usb_stk11xx *dev)
00255 {
00256     int ret = -1;
00257     struct usb_device *udev = dev->udev;
00258 
00259     ret = usb_set_interface(udev, 0, 0);
00260 
00261     if (ret < 0)
00262         STK_ERROR("usb_set_interface failed !\n");
00263 
00264     return 0;
00265 }
00266 
00267 
00277 int dev_stk11xx_camera_asleep(struct usb_stk11xx *dev)
00278 {
00279     int ret;
00280 
00281     switch (dev->webcam_model) {
00282         case SYNTEK_STK_M811:
00283         case SYNTEK_STK_A311:
00284             ret = dev_stka311_camera_asleep(dev);
00285             break;
00286 
00287         case SYNTEK_STK_A821:
00288             ret = dev_stka821_camera_asleep(dev);
00289             break;
00290 
00291         case SYNTEK_STK_6A31:
00292             ret = dev_stk6a31_camera_asleep(dev);
00293             break;
00294 
00295         default:
00296             ret = -1;
00297     }
00298 
00299     return ret;
00300 }
00301 
00302 
00316 int dev_stk11xx_camera_settings(struct usb_stk11xx *dev)
00317 {
00318     int ret;
00319 
00320     switch (dev->webcam_model) {
00321         case SYNTEK_STK_M811:
00322         case SYNTEK_STK_A311:
00323             ret = dev_stka311_camera_settings(dev);
00324             break;
00325 
00326         case SYNTEK_STK_A821:
00327             ret = dev_stka821_camera_settings(dev);
00328             break;
00329 
00330         case SYNTEK_STK_6A31:
00331             ret = dev_stk6a31_camera_settings(dev);
00332             break;
00333 
00334         default:
00335             ret = -1;
00336     }
00337 
00338     return ret;
00339 }
00340 
00341 
00355 int dev_stk11xx_set_camera_quality(struct usb_stk11xx *dev)
00356 {
00357     int ret;
00358 
00359     switch (dev->webcam_model) {
00360         case SYNTEK_STK_M811:
00361         case SYNTEK_STK_A311:
00362             ret = dev_stka311_set_camera_quality(dev);
00363             break;
00364 
00365         case SYNTEK_STK_A821:
00366             ret = dev_stka821_set_camera_quality(dev);
00367             break;
00368 
00369         case SYNTEK_STK_6A31:
00370             ret = dev_stk6a31_set_camera_quality(dev);
00371             break;
00372 
00373         default:
00374             ret = -1;
00375     }
00376 
00377     return ret;
00378 }
00379 
00380 
00391 int dev_stk11xx_set_camera_fps(struct usb_stk11xx *dev)
00392 {
00393     int ret;
00394 
00395     switch (dev->webcam_model) {
00396         case SYNTEK_STK_M811:
00397         case SYNTEK_STK_A311:
00398             ret = dev_stka311_set_camera_fps(dev);
00399             break;
00400 
00401         case SYNTEK_STK_A821:
00402             ret = dev_stka821_set_camera_fps(dev);
00403             break;
00404 
00405         case SYNTEK_STK_6A31:
00406             ret = dev_stk6a31_set_camera_fps(dev);
00407             break;
00408 
00409         default:
00410             ret = -1;
00411     }
00412 
00413     return ret;
00414 }
00415 
00416 
00427 int dev_stk11xx_start_stream(struct usb_stk11xx *dev)
00428 {
00429     int ret;
00430 
00431     switch (dev->webcam_model) {
00432         case SYNTEK_STK_M811:
00433         case SYNTEK_STK_A311:
00434             ret = dev_stka311_start_stream(dev);
00435             break;
00436 
00437         case SYNTEK_STK_A821:
00438             ret = dev_stka821_start_stream(dev);
00439             break;
00440 
00441         case SYNTEK_STK_6A31:
00442             ret = dev_stk6a31_start_stream(dev);
00443             break;
00444 
00445         default:
00446             ret = -1;
00447     }
00448 
00449     return ret;
00450 }
00451 
00452 
00462 int dev_stk11xx_reconf_camera(struct usb_stk11xx *dev)
00463 {
00464     int ret;
00465 
00466     switch (dev->webcam_model) {
00467         case SYNTEK_STK_M811:
00468         case SYNTEK_STK_A311:
00469             ret = dev_stka311_reconf_camera(dev);
00470             break;
00471 
00472         case SYNTEK_STK_A821:
00473             ret = dev_stka821_reconf_camera(dev);
00474             break;
00475 
00476         case SYNTEK_STK_6A31:
00477             ret = dev_stk6a31_reconf_camera(dev);
00478             break;
00479 
00480         default:
00481             ret = -1;
00482     }
00483 
00484     return ret;
00485 }
00486 
00487 
00498 int dev_stk11xx_stop_stream(struct usb_stk11xx *dev)
00499 {
00500     int ret;
00501 
00502     switch (dev->webcam_model) {
00503         case SYNTEK_STK_M811:
00504         case SYNTEK_STK_A311:
00505             ret = dev_stka311_stop_stream(dev);
00506             break;
00507 
00508         case SYNTEK_STK_A821:
00509             ret = dev_stka821_stop_stream(dev);
00510             break;
00511 
00512         case SYNTEK_STK_6A31:
00513             ret = dev_stk6a31_stop_stream(dev);
00514             break;
00515 
00516         default:
00517             ret = -1;
00518     }
00519 
00520     return ret;
00521 }
00522 
00523 
00524 //=============================================================================
00525 //
00526 // STK-M811 API / STK-A311 API
00527 //
00528 //=============================================================================
00529 
00530 
00544 int dev_stka311_initialize_device(struct usb_stk11xx *dev)
00545 {
00546     int i;
00547     int retok;
00548     int value;
00549 
00550     STK_INFO("Initialize USB2.0 Syntek Camera\n");
00551 
00552     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00553     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
00554     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
00555 
00556     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
00557     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00558     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00559     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00560     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00561     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00562     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00563     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00564     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00565     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00566     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00567     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00568     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00569     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00570     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00571     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00572     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00573     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00574     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00575     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00576     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00577     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00578     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00579     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00580     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00581     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00582     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00583     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00584     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00585     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
00586     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00587 
00588     for (i=0; i<16; i++) {
00589         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00590         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00591         usb_stk11xx_read_registry(dev, 0x0000, &value);
00592     
00593         STK_DEBUG("Loop 1 : Read 0x0000 = %02X\n", value);
00594     }
00595 
00596     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00597     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00598 
00599     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
00600     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00601     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00602     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00603     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00604     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00605     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00606     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00607     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00608     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00609     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00610     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00611     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00612     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00613     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00614     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00615     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00616     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00617     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00618     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00619     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00620     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00621     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00622     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00623     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00624     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00625     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00626     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00627     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00628     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00629     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00630     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00631     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00632     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00633     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00634     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
00635     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00636 
00637     for (i=0; i<16; i++) {
00638         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00639         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00640         usb_stk11xx_read_registry(dev, 0x0000, &value);
00641 
00642         STK_DEBUG("Loop 2 : Read 0x0000 = %02X\n", value);
00643     }
00644 
00645     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00646     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00647 
00648     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
00649     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00650     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00651     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00652     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00653     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00654     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00655     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00656     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00657     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00658     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00659     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00660     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00661     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00662     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00663     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00664     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00665     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00666     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00667     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00668     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00669     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00670     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00671     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00672     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00673     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00674     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00675     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00676     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00677     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00678     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00679     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00680     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00681     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00682     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00683     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00684     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00685     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
00686     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
00687     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00688     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00689     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
00690     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00691 
00692     for (i=0; i<16; i++) {
00693         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00694         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00695         usb_stk11xx_read_registry(dev, 0x0000, &value);
00696     
00697         STK_DEBUG("Loop 3 : Read 0x0000 = %02X\n", value);
00698     }
00699 
00700     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00701     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00702     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
00703     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00704     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00705 
00706     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
00707     usb_stk11xx_read_registry(dev, 0x0103, &value);
00708     usb_stk11xx_write_registry(dev, 0x0103, 0x0001);
00709     usb_stk11xx_read_registry(dev, 0x0103, &value);
00710     usb_stk11xx_write_registry(dev, 0x0103, 0x0000);
00711 
00712     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
00713     usb_stk11xx_write_registry(dev, 0x0002, 0x00E8);
00714     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
00715     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00716 
00717     dev_stka311_configure_device(dev, 0);
00718     retok = dev_stk11xx_check_device(dev, 65);
00719     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
00720 
00721     dev_stka311_configure_device(dev, 1);
00722     retok = dev_stk11xx_check_device(dev, 65);
00723     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
00724 
00725     dev_stka311_configure_device(dev, 2);
00726     retok = dev_stk11xx_check_device(dev, 500);
00727     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00728     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00729     usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
00730     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00731     retok = dev_stk11xx_check_device(dev, 500);
00732     usb_stk11xx_read_registry(dev, 0x0209, &value);
00733     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00734     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00735     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00736     usb_stk11xx_write_registry(dev, 0x0208, 0x000A);
00737     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00738     retok = dev_stk11xx_check_device(dev, 500);
00739     usb_stk11xx_read_registry(dev, 0x0209, &value);
00740     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00741     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00742     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00743     usb_stk11xx_write_registry(dev, 0x0208, 0x000B);
00744     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00745     retok = dev_stk11xx_check_device(dev, 500);
00746     usb_stk11xx_read_registry(dev, 0x0209, &value);
00747     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00748 
00749     dev_stka311_configure_device(dev, 3);
00750     retok = dev_stk11xx_check_device(dev, 65);
00751     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
00752 
00753     dev_stka311_configure_device(dev, 4);
00754     retok = dev_stk11xx_check_device(dev, 65);
00755     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
00756 
00757     dev_stka311_configure_device(dev, 5);
00758     retok = dev_stk11xx_check_device(dev, 500);
00759     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00760     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00761     usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
00762     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00763     retok = dev_stk11xx_check_device(dev, 500);
00764     usb_stk11xx_read_registry(dev, 0x0209, &value);
00765     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00766     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00767     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00768     usb_stk11xx_write_registry(dev, 0x0208, 0x000A);
00769     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00770     retok = dev_stk11xx_check_device(dev, 500);
00771     usb_stk11xx_read_registry(dev, 0x0209, &value);
00772     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00773     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00774     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00775     usb_stk11xx_write_registry(dev, 0x0208, 0x000B);
00776     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00777     retok = dev_stk11xx_check_device(dev, 500);
00778     usb_stk11xx_read_registry(dev, 0x0209, &value);
00779     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00780 
00781     dev_stka311_configure_device(dev, 6);
00782     retok = dev_stk11xx_check_device(dev, 500);
00783     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00784     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00785     usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
00786     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00787     retok = dev_stk11xx_check_device(dev, 500);
00788     usb_stk11xx_read_registry(dev, 0x0209, &value);
00789     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00790     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00791     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00792     usb_stk11xx_write_registry(dev, 0x0208, 0x000A);
00793     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00794     retok = dev_stk11xx_check_device(dev, 500);
00795     usb_stk11xx_read_registry(dev, 0x0209, &value);
00796     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00797     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00798     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00799     usb_stk11xx_write_registry(dev, 0x0208, 0x000B);
00800     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00801     retok = dev_stk11xx_check_device(dev, 500);
00802     usb_stk11xx_read_registry(dev, 0x0209, &value);
00803     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00804 
00805     dev_stka311_configure_device(dev, 7);
00806     retok = dev_stk11xx_check_device(dev, 500);
00807     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00808     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00809     usb_stk11xx_write_registry(dev, 0x0208, 0x0013);
00810     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00811     retok = dev_stk11xx_check_device(dev, 500);
00812     usb_stk11xx_read_registry(dev, 0x0209, &value);
00813     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00814     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00815     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00816     usb_stk11xx_write_registry(dev, 0x0208, 0x000A);
00817     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00818     retok = dev_stk11xx_check_device(dev, 500);
00819     usb_stk11xx_read_registry(dev, 0x0209, &value);
00820     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00821     usb_stk11xx_read_registry(dev, 0x02FF, &value);
00822     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00823     usb_stk11xx_write_registry(dev, 0x0208, 0x000B);
00824     usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
00825     retok = dev_stk11xx_check_device(dev, 500);
00826     usb_stk11xx_read_registry(dev, 0x0209, &value);
00827     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
00828 
00829     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
00830     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00831     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
00832     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00833     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
00834     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
00835 
00836     dev_stka311_configure_device(dev, 8);
00837 
00838     dev_stka311_camera_asleep(dev);
00839 
00840     usb_stk11xx_set_feature(dev, 0);
00841 
00842     // Device is initialized and is ready !!!
00843     STK_INFO("Syntek USB2.0 Camera is ready\n");
00844 
00845     return 0;
00846 }
00847 
00848 
00867 int dev_stka311_configure_device(struct usb_stk11xx *dev, int step)
00868 {
00869     int retok;
00870     int value;
00871 
00872     //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11
00873 
00874     int values_001B[] = {
00875         0x0E, 0x03, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E
00876     };
00877     int values_001C[] = {
00878         0x06, 0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0E
00879     };
00880     int values_0202[] = {
00881         0x1E, 0x0A, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E
00882     };
00883     int values_0110[] = {
00884         0x07, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00
00885     };
00886     int values_0112[] = {
00887         0x07, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00
00888     };
00889     int values_0114[] = {
00890         0x87, 0x80, 0x80, 0x80, 0x80, 0xBE, 0xBE, 0x80, 0x80, 0x80, 0x80, 0x00
00891     };
00892     int values_0115[] = {
00893         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05
00894     };
00895     int values_0116[] = {
00896         0xE7, 0xE0, 0xE0, 0xE0, 0xE0, 0xE9, 0xE9, 0xE0, 0xE0, 0xE0, 0xE0, 0x00
00897     };
00898     int values_0117[] = {
00899         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04
00900     };
00901     int values_0100[] = {
00902         0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21
00903     };
00904 
00905     STK_DEBUG("dev_stka311_configure_device : %d\n", step);
00906 
00907     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
00908     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
00909     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
00910     usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
00911     
00912     usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
00913     usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
00914     usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
00915     usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
00916     usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
00917     
00918     usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
00919     usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
00920     usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
00921     usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
00922     usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
00923     
00924     usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
00925     usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
00926     usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
00927     usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
00928     usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
00929     
00930     usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
00931     usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
00932     usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
00933     usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
00934     usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
00935     
00936     usb_stk11xx_write_registry(dev, 0x0115, values_0115[step]);
00937     usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
00938     usb_stk11xx_write_registry(dev, 0x0117, values_0117[step]);
00939 
00940     usb_stk11xx_read_registry(dev, 0x0100, &value);
00941     usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
00942 
00943     usb_stk11xx_write_registry(dev, 0x0200, 0x0080); 
00944     usb_stk11xx_write_registry(dev, 0x0200, 0x0000); 
00945     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
00946 
00947 
00948     switch (step) {
00949         case 0:
00950             usb_stk11xx_write_registry(dev, 0x0203, 0x0040); 
00951 
00952             usb_stk11xx_write_registry(dev, 0x0204, 0x0041); 
00953             usb_stk11xx_write_registry(dev, 0x0205, 0x0001); 
00954             usb_stk11xx_write_registry(dev, 0x0204, 0x001C); 
00955             usb_stk11xx_write_registry(dev, 0x0205, 0x0002); 
00956 
00957             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
00958 
00959             break;
00960 
00961         case 1:
00962             usb_stk11xx_write_registry(dev, 0x0203, 0x0022); 
00963 
00964             usb_stk11xx_write_registry(dev, 0x0204, 0x0027); 
00965             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
00966 
00967             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
00968 
00969             break;
00970     
00971         case 2:
00972             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
00973 
00974             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
00975             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
00976             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
00977             usb_stk11xx_write_registry(dev, 0x0205, 0x00BF); 
00978 
00979             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
00980 
00981             break;
00982 
00983         case 3:
00984             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
00985 
00986             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
00987             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
00988             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
00989             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
00990 
00991             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
00992 
00993             break;
00994 
00995         case 4:
00996             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
00997 
00998             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
00999             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01000             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01001             usb_stk11xx_write_registry(dev, 0x0205, 0x00E0); 
01002             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
01003             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
01004 
01005             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01006 
01007             break;
01008 
01009         case 5:
01010             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01011 
01012             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01013             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01014             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01015             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
01016 
01017             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01018 
01019             break;
01020 
01021         case 6:
01022             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01023 
01024             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01025             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01026             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01027             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
01028 
01029             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01030 
01031             break;
01032 
01033         case 7:
01034             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01035 
01036             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01037             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01038             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01039             usb_stk11xx_write_registry(dev, 0x0205, 0x00B7); 
01040 
01041             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01042 
01043             break;
01044 
01045         case 8:
01046             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01047 
01048             dev_stka311_load_microcode(dev);
01049 
01050             usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
01051             usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
01052             usb_stk11xx_write_registry(dev, 0x02FF, 0x0001);
01053             usb_stk11xx_write_registry(dev, 0x0203, 0x00A0);
01054 
01055             break;
01056 
01057         case 9:
01058             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01059 
01060             dev_stka311_load_microcode(dev);
01061 
01062             usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
01063             usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
01064             usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
01065 
01066             break;
01067     
01068         case 10:
01069         case 11:
01070             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01071 
01072             dev_stka311_load_microcode(dev);
01073 
01074             usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
01075             usb_stk11xx_read_registry(dev, 0x02FF, &value);
01076             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01077             usb_stk11xx_write_registry(dev, 0x0204, 0x002A);
01078             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01079             usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
01080             retok = dev_stk11xx_check_device(dev, 500);
01081             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01082             usb_stk11xx_read_registry(dev, 0x02FF, &value);
01083             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01084             usb_stk11xx_write_registry(dev, 0x0204, 0x002B);
01085             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01086             usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
01087             retok = dev_stk11xx_check_device(dev, 500);
01088             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01089 
01090             break;
01091     }
01092     
01093     return 0;
01094 }
01095 
01096 
01106 int dev_stka311_camera_asleep(struct usb_stk11xx *dev)
01107 {
01108     int value;
01109 
01110     usb_stk11xx_read_registry(dev, 0x0104, &value);
01111     usb_stk11xx_read_registry(dev, 0x0105, &value);
01112     usb_stk11xx_read_registry(dev, 0x0106, &value);
01113 
01114     usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
01115     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
01116     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
01117     usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
01118 
01119     usb_stk11xx_read_registry(dev, 0x0000, &value);
01120     usb_stk11xx_write_registry(dev, 0x0000, 0x004C);
01121 
01122     return 0;
01123 }
01124 
01125 
01136 int dev_stka311_init_camera(struct usb_stk11xx *dev)
01137 {
01138     int retok;
01139     int value;
01140 
01141     dev_stka311_camera_asleep(dev);
01142 
01143     usb_stk11xx_set_feature(dev, 0);
01144 
01145     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
01146     usb_stk11xx_write_registry(dev, 0x0002, 0x00E8);
01147     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
01148     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01149 
01150     dev_stka311_configure_device(dev, 9);
01151 
01152     dev_stk11xx_camera_off(dev);
01153 
01154     usb_stk11xx_read_registry(dev, 0x02FF, &value);
01155     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01156     usb_stk11xx_write_registry(dev, 0x0204, 0x002a);
01157     usb_stk11xx_write_registry(dev, 0x0205, 0x0000); 
01158     usb_stk11xx_write_registry(dev, 0x0200, 0x0001); 
01159     retok = dev_stk11xx_check_device(dev, 500);
01160     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01161     usb_stk11xx_read_registry(dev, 0x02FF, &value);
01162     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01163     usb_stk11xx_write_registry(dev, 0x0204, 0x002B);
01164     usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01165     usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
01166     retok = dev_stk11xx_check_device(dev, 500);
01167     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01168 
01169     dev_stka311_camera_settings(dev);
01170 
01171     return 0;
01172 }
01173 
01174 
01184 int dev_stka311_load_microcode(struct usb_stk11xx *dev)
01185 {
01186     int i;
01187     int retok;
01188     int value;
01189 
01190     int *values_204 = NULL;
01191     int *values_205 = NULL;
01192 
01193     // From 80x60 to 640x480
01194     int values_1_204[] = {
01195         0x12, 0x11, 0x3b, 0x6a, 0x13, 0x10, 0x00, 0x01, 0x02, 0x13,
01196         0x39, 0x38, 0x37, 0x35, 0x0e, 0x12, 0x04, 0x0c, 0x0d, 0x17,
01197         0x18, 0x32, 0x19, 0x1a, 0x03, 0x1b, 0x16, 0x33, 0x34, 0x41,
01198         0x96, 0x3d, 0x69, 0x3a, 0x8e, 0x3c, 0x8f, 0x8b, 0x8c, 0x94,
01199         0x95, 0x40, 0x29, 0x0f, 0xa5, 0x1e, 0xa9, 0xaa, 0xab, 0x90,
01200         0x91, 0x9f, 0xa0, 0x24, 0x25, 0x26, 0x14, 0x2a, 0x2b 
01201     };
01202     int values_1_205[] = {
01203         0x45, 0x80, 0x01, 0x7d, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80,
01204         0x50, 0x93, 0x00, 0x81, 0x20, 0x45, 0x00, 0x00, 0x00, 0x24,
01205         0xc4, 0xb6, 0x00, 0x3c, 0x36, 0x00, 0x07, 0xe2, 0xbf, 0x00,
01206         0x04, 0x19, 0x40, 0x0d, 0x00, 0x73, 0xdf, 0x06, 0x20, 0x88,
01207         0x88, 0xc1, 0x3f, 0x42, 0x80, 0x04, 0xb8, 0x92, 0x0a, 0x00,
01208         0x00, 0x00, 0x00, 0x68, 0x5c, 0xc3, 0x2e, 0x00, 0x00
01209     };
01210 
01211     // From 800x600 to 1280x1024
01212     int values_2_204[] = {
01213         0x12, 0x11, 0x3b, 0x6a, 0x13, 0x10, 0x00, 0x01, 0x02, 0x13,
01214         0x39, 0x38, 0x37, 0x35, 0x0e, 0x12, 0x04, 0x0c, 0x0d, 0x17,
01215         0x18, 0x32, 0x19, 0x1a, 0x03, 0x1b, 0x16, 0x33, 0x34, 0x41,
01216         0x96, 0x3d, 0x69, 0x3a, 0x8e, 0x3c, 0x8f, 0x8b, 0x8c, 0x94,
01217         0x95, 0x40, 0x29, 0x0f, 0xa5, 0x1e, 0xa9, 0xaa, 0xab, 0x90,
01218         0x91, 0x9f, 0xa0, 0x24, 0x25, 0x26, 0x14, 0x2a, 0x2b 
01219     };
01220     int values_2_205[] = {
01221         0x05, 0x80, 0x01, 0x7d, 0x80, 0x00, 0x00, 0x80, 0x80, 0x80,
01222         0x50, 0x93, 0x00, 0x81, 0x20, 0x05, 0x00, 0x00, 0x00, 0x1b,
01223         0xbb, 0xa4, 0x01, 0x81, 0x12, 0x00, 0x07, 0xe2, 0xbf, 0x00,
01224         0x04, 0x19, 0x40, 0x0d, 0x00, 0x73, 0xdf, 0x06, 0x20, 0x88,
01225         0x88, 0xc1, 0x3f, 0x42, 0x80, 0x04, 0xb8, 0x92, 0x0a, 0x00,
01226         0x00, 0x00, 0x00, 0x68, 0x5c, 0xc3, 0x2e, 0x00, 0x00
01227     };
01228 
01229 
01230     // From the resolution
01231     switch (dev->resolution) {
01232         case STK11XX_1280x1024:
01233         case STK11XX_1024x768:
01234         case STK11XX_800x600:
01235             values_204 = values_2_204;
01236             values_205 = values_2_205;
01237             break;
01238 
01239         case STK11XX_640x480:
01240         case STK11XX_320x240:
01241         case STK11XX_160x120:
01242         case STK11XX_213x160:
01243         case STK11XX_128x96:
01244         case STK11XX_80x60:
01245         default:
01246             values_204 = values_1_204;
01247             values_205 = values_1_205;
01248             break;
01249     }
01250     
01251 
01252     for(i=0; i<59; i++) {
01253         usb_stk11xx_read_registry(dev, 0x02FF, &value);
01254         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01255 
01256         usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
01257         usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
01258         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
01259 
01260         retok = dev_stk11xx_check_device(dev, 500);
01261 
01262         if (retok != 1) {
01263             STK_ERROR("Load microcode fail !\n");
01264             return -1;
01265         }
01266 
01267         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01268     }
01269 
01270     retok = dev_stk11xx_check_device(dev, 500);
01271 
01272     return 0;
01273 }
01274 
01275 
01289 int dev_stka311_camera_settings(struct usb_stk11xx *dev)
01290 {
01291     int ret;
01292 
01293     dev_stka311_set_camera_quality(dev);
01294 
01295     ret = dev_stk11xx_check_device(dev, 500);
01296 
01297     if (!ret)
01298         STK_DEBUG("Find not 0x4... seems OK\n");
01299 
01300     dev_stka311_set_camera_fps(dev);
01301 
01302     ret = dev_stk11xx_check_device(dev, 500);
01303 
01304     if (!ret)
01305         STK_DEBUG("Find not 0x4... seems OK\n");
01306 
01307     return 0;
01308 }
01309 
01310 
01329 int dev_stka311_set_camera_quality(struct usb_stk11xx *dev)
01330 {
01331     usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
01332 
01333     // Colour registers
01334     usb_stk11xx_write_registry(dev, 0x0204, 0x0001);
01335     usb_stk11xx_write_registry(dev, 0x0205, (255 - (dev->vsettings.colour >> 8)));
01336     usb_stk11xx_write_registry(dev, 0x0204, 0x0002);
01337     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.colour >> 8));
01338 
01339     // Unknown register
01340     usb_stk11xx_write_registry(dev, 0x0204, 0x00A1);
01341     usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01342 
01343     // Contrast register
01344     usb_stk11xx_write_registry(dev, 0x0204, 0x0010);
01345     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 9));
01346 
01347     // Unknown register
01348     usb_stk11xx_write_registry(dev, 0x0204, 0x0004);
01349     usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01350 
01351     // Whiteness register
01352     usb_stk11xx_write_registry(dev, 0x0204, 0x0000);
01353     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.whiteness >> 11) | 0x20);
01354 
01355     usb_stk11xx_write_registry(dev, 0x0200, 0x0006);
01356 
01357     STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
01358     STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
01359     STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
01360     STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
01361 
01362     return 0;
01363 }
01364 
01365 
01386 int dev_stka311_set_camera_fps(struct usb_stk11xx *dev)
01387 {
01388     usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
01389 
01390     // FPS register
01391     switch (dev->vsettings.fps) {
01392         case 10:
01393             usb_stk11xx_write_registry(dev, 0x0204, 0x002E);
01394             usb_stk11xx_write_registry(dev, 0x0205, 0x0004);
01395             usb_stk11xx_write_registry(dev, 0x0204, 0x002D);
01396             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01397             break;
01398 
01399         case 15:
01400             usb_stk11xx_write_registry(dev, 0x0204, 0x002E);
01401             usb_stk11xx_write_registry(dev, 0x0205, 0x0002);
01402             usb_stk11xx_write_registry(dev, 0x0204, 0x002D);
01403             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01404             break;
01405 
01406         case 20:
01407             usb_stk11xx_write_registry(dev, 0x0204, 0x002E);
01408             usb_stk11xx_write_registry(dev, 0x0205, 0x0001);
01409             usb_stk11xx_write_registry(dev, 0x0204, 0x002D);
01410             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01411             break;
01412 
01413         default:
01414         case 25:
01415             usb_stk11xx_write_registry(dev, 0x0204, 0x002E);
01416             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01417             usb_stk11xx_write_registry(dev, 0x0204, 0x002D);
01418             usb_stk11xx_write_registry(dev, 0x0205, 0x0064);
01419             break;
01420 
01421         case 30:
01422             usb_stk11xx_write_registry(dev, 0x0204, 0x002E);
01423             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01424             usb_stk11xx_write_registry(dev, 0x0204, 0x002D);
01425             usb_stk11xx_write_registry(dev, 0x0205, 0x0000);
01426             break;
01427     }
01428 
01429     usb_stk11xx_write_registry(dev, 0x0200, 0x0006);
01430 
01431     return 0;
01432 }
01433 
01434 
01445 int dev_stka311_start_stream(struct usb_stk11xx *dev)
01446 {
01447     int value;
01448     int value_116, value_117;
01449 
01450     usb_stk11xx_read_registry(dev, 0x0116, &value_116);
01451     usb_stk11xx_read_registry(dev, 0x0117, &value_117);
01452 
01453     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
01454     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
01455 
01456     usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
01457     usb_stk11xx_write_registry(dev, 0x0100, 0x00A1);
01458 
01459     usb_stk11xx_write_registry(dev, 0x0116, value_116);
01460     usb_stk11xx_write_registry(dev, 0x0117, value_117);
01461 
01462     return 0;
01463 }
01464 
01465 
01475 int dev_stka311_reconf_camera(struct usb_stk11xx *dev)
01476 {
01477     int step = 10;
01478 
01479     // Choose the step from the resolution
01480     switch (dev->resolution) {
01481         case STK11XX_1280x1024:
01482         case STK11XX_1024x768:
01483         case STK11XX_800x600:
01484             step = 11;
01485             break;
01486 
01487         case STK11XX_640x480:
01488         case STK11XX_320x240:
01489         case STK11XX_160x120:
01490         case STK11XX_213x160:
01491         case STK11XX_128x96:
01492         case STK11XX_80x60:
01493         default:
01494             step = 10;
01495             break;
01496     }
01497 
01498     dev_stka311_configure_device(dev, step);
01499 
01500     dev_stk11xx_camera_settings(dev);
01501 
01502     return 0;
01503 }
01504 
01505 
01516 int dev_stka311_stop_stream(struct usb_stk11xx *dev)
01517 {
01518     int value;
01519 
01520     usb_stk11xx_read_registry(dev, 0x0100, &value);
01521     usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
01522 
01523     return 0;
01524 }
01525 
01526 
01527 //=============================================================================
01528 //
01529 // STK-A821 API
01530 //
01531 //=============================================================================
01532 
01533 
01547 int dev_stka821_initialize_device(struct usb_stk11xx *dev)
01548 {
01549     int i;
01550     int retok;
01551     int value;
01552 
01553     STK_INFO("Initialize USB2.0 Syntek Camera\n");
01554 
01555     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01556     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
01557     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
01558 
01559     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
01560     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01561     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01562     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01563     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01564     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01565     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01566     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01567     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01568     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01569     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01570     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01571     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01572     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01573     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01574     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01575     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01576     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01577     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01578     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01579     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01580     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01581     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01582     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01583     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01584     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01585     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01586     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01587     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01588     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
01589     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01590 
01591     for (i=0; i<16; i++) {
01592         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01593         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01594         usb_stk11xx_read_registry(dev, 0x0000, &value);
01595     
01596         STK_DEBUG("Loop 1 : Read 0x0000 = %02X\n", value);
01597     }
01598 
01599     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01600     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01601 
01602     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
01603     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01604     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01605     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01606     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01607     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01608     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01609     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01610     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01611     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01612     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01613     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01614     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01615     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01616     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01617     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01618     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01619     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01620     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01621     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01622     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01623     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01624     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01625     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01626     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01627     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01628     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01629     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01630     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01631     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01632     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01633     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01634     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01635     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01636     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01637     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
01638     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01639 
01640     for (i=0; i<16; i++) {
01641         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01642         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01643         usb_stk11xx_read_registry(dev, 0x0000, &value);
01644 
01645         STK_DEBUG("Loop 2 : Read 0x0000 = %02X\n", value);
01646     }
01647 
01648     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01649     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01650 
01651     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
01652     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01653     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01654     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01655     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01656     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01657     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01658     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01659     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01660     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01661     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01662     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01663     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01664     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01665     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01666     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01667     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01668     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01669     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01670     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01671     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01672     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01673     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01674     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01675     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01676     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01677     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01678     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01679     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01680     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01681     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01682     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01683     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01684     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01685     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01686     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01687     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01688     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
01689     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
01690     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01691     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01692     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
01693     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01694 
01695     for (i=0; i<16; i++) {
01696         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01697         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01698         usb_stk11xx_read_registry(dev, 0x0000, &value);
01699     
01700         STK_DEBUG("Loop 3 : Read 0x0000 = %02X\n", value);
01701     }
01702 
01703     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01704     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01705     usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
01706     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01707     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01708 
01709     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
01710     usb_stk11xx_read_registry(dev, 0x0103, &value);
01711     usb_stk11xx_write_registry(dev, 0x0103, 0x0001);
01712     usb_stk11xx_read_registry(dev, 0x0103, &value);
01713     usb_stk11xx_write_registry(dev, 0x0103, 0x0000);
01714 
01715     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
01716     usb_stk11xx_write_registry(dev, 0x0002, 0x00E8);
01717     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
01718     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01719 
01720     dev_stka821_configure_device(dev, 0);
01721     retok = dev_stk11xx_check_device(dev, 65);
01722     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01723 
01724     dev_stka821_configure_device(dev, 1);
01725     retok = dev_stk11xx_check_device(dev, 65);
01726     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01727 
01728     dev_stka821_configure_device(dev, 2);
01729     retok = dev_stk11xx_check_device(dev, 65);
01730     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01731 
01732     dev_stka821_configure_device(dev, 3);
01733     retok = dev_stk11xx_check_device(dev, 65);
01734     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01735 
01736     dev_stka821_configure_device(dev, 4);
01737     retok = dev_stk11xx_check_device(dev, 65);
01738     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01739 
01740     dev_stka821_configure_device(dev, 5);
01741     retok = dev_stk11xx_check_device(dev, 65);
01742     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01743 
01744     dev_stka821_configure_device(dev, 6);
01745     retok = dev_stk11xx_check_device(dev, 65);
01746     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01747 
01748     dev_stka821_configure_device(dev, 7);
01749     retok = dev_stk11xx_check_device(dev, 65);
01750     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01751 
01752     dev_stka821_configure_device(dev, 8);
01753     retok = dev_stk11xx_check_device(dev, 65);
01754     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
01755 
01756     dev_stka821_configure_device(dev, 9);
01757     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01758     usb_stk11xx_write_registry(dev, 0x0002, 0x006D);
01759     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01760     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
01761     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
01762 
01763     dev_stka821_configure_device(dev, 10);
01764     usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
01765     usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
01766     usb_stk11xx_write_registry(dev, 0x02FF, 0x0001);
01767     usb_stk11xx_write_registry(dev, 0x0203, 0x00A0);
01768 
01769     dev_stka821_camera_asleep(dev);
01770 
01771     usb_stk11xx_set_feature(dev, 0);
01772 
01773     // Device is initialized and is ready !!!
01774     STK_INFO("Syntek USB2.0 Camera is ready\n");
01775 
01776     return 0;
01777 }
01778 
01779 
01793 int dev_stka821_configure_device(struct usb_stk11xx *dev, int step)
01794 {
01795     int retok;
01796     int value;
01797 
01798     //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13
01799 
01800     int values_001B[] = {
01801         0x0E, 0x03, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07
01802     };
01803     int values_001C[] = {
01804         0x06, 0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
01805     };
01806     int values_0202[] = {
01807         0x1E, 0x0A, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E
01808     };
01809     int values_0110[] = {
01810         0x07, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x3E, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
01811     };
01812     int values_0112[] = {
01813         0x07, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00
01814     };
01815     int values_0114[] = {
01816         0x87, 0x80, 0x80, 0x80, 0x80, 0xBE, 0xBE, 0x80, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80
01817     };
01818     int values_0116[] = {
01819         0xE7, 0xE0, 0xE0, 0xE0, 0xE0, 0xE9, 0xE9, 0xE0, 0xE4, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0
01820     };
01821     int values_0100[] = {
01822         0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20
01823     };
01824 
01825     STK_DEBUG("dev_stka821_configure_device : %d\n", step);
01826 
01827     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
01828     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
01829     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
01830     usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
01831     
01832     usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
01833     usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
01834     usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
01835     usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
01836     usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
01837     
01838     usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
01839     usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
01840     usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
01841     usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
01842     usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
01843     
01844     usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
01845     usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
01846     usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
01847     usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
01848     usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
01849     
01850     usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
01851     usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
01852     usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
01853     usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
01854     usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
01855     
01856     usb_stk11xx_write_registry(dev, 0x0115, 0x0002);
01857     usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
01858     usb_stk11xx_write_registry(dev, 0x0117, 0x0001);
01859 
01860     usb_stk11xx_read_registry(dev, 0x0100, &value);
01861     usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
01862 
01863     usb_stk11xx_write_registry(dev, 0x0200, 0x0080); 
01864     usb_stk11xx_write_registry(dev, 0x0200, 0x0000); 
01865     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
01866 
01867 
01868     switch (step) {
01869         case 0:
01870             usb_stk11xx_write_registry(dev, 0x0203, 0x0040); 
01871 
01872             usb_stk11xx_write_registry(dev, 0x0204, 0x0041); 
01873             usb_stk11xx_write_registry(dev, 0x0205, 0x0001); 
01874             usb_stk11xx_write_registry(dev, 0x0204, 0x001C); 
01875             usb_stk11xx_write_registry(dev, 0x0205, 0x0002); 
01876 
01877             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01878 
01879             break;
01880 
01881         case 1:
01882             usb_stk11xx_write_registry(dev, 0x0203, 0x0022); 
01883 
01884             usb_stk11xx_write_registry(dev, 0x0204, 0x0027); 
01885             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
01886 
01887             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01888 
01889             break;
01890     
01891         case 2:
01892             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01893 
01894             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01895             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01896             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01897             usb_stk11xx_write_registry(dev, 0x0205, 0x00BF); 
01898 
01899             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01900 
01901             break;
01902 
01903         case 3:
01904             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
01905 
01906             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01907             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01908             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
01909             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
01910 
01911             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01912 
01913             break;
01914 
01915         case 4:
01916             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
01917 
01918             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01919             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01920             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01921             usb_stk11xx_write_registry(dev, 0x0205, 0x00E0); 
01922             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
01923             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
01924 
01925             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01926 
01927             break;
01928 
01929         case 5:
01930             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01931 
01932             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01933             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01934             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01935             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
01936 
01937             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01938 
01939             break;
01940 
01941         case 6:
01942             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01943 
01944             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01945             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01946             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01947             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
01948 
01949             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01950 
01951             break;
01952 
01953         case 7:
01954             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
01955 
01956             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01957             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01958             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
01959             usb_stk11xx_write_registry(dev, 0x0205, 0x00B7); 
01960 
01961             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01962 
01963             break;
01964 
01965         case 8:
01966             usb_stk11xx_write_registry(dev, 0x0203, 0x0080); 
01967 
01968             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
01969             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01970             usb_stk11xx_write_registry(dev, 0x0204, 0x000A); 
01971             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
01972 
01973             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01974 
01975             break;
01976 
01977         case 9:
01978             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
01979 
01980             usb_stk11xx_write_registry(dev, 0x0204, 0x0015); 
01981             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
01982 
01983             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
01984 
01985             retok = dev_stk11xx_check_device(dev, 500);
01986             usb_stk11xx_read_registry(dev, 0x02FF, &value);
01987             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01988             usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
01989             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
01990             retok = dev_stk11xx_check_device(dev, 500);
01991             usb_stk11xx_read_registry(dev, 0x0209, &value);
01992             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01993             usb_stk11xx_read_registry(dev, 0x02FF, &value);
01994             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
01995             usb_stk11xx_write_registry(dev, 0x0208, 0x0001);
01996             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
01997             retok = dev_stk11xx_check_device(dev, 500);
01998             usb_stk11xx_read_registry(dev, 0x0209, &value);
01999             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02000             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02001             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02002             usb_stk11xx_write_registry(dev, 0x0208, 0x0002);
02003             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02004             retok = dev_stk11xx_check_device(dev, 500);
02005             usb_stk11xx_read_registry(dev, 0x0209, &value);
02006             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02007             usb_stk11xx_write_registry(dev, 0x0002, 0x006F);
02008 
02009             break;
02010 
02011         case 10:
02012             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
02013             
02014             dev_stka821_load_microcode(dev);
02015 
02016             break;
02017 
02018         case 11:
02019             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
02020 
02021             dev_stka821_load_microcode(dev);
02022     
02023             usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
02024             usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
02025             usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
02026 
02027             break;
02028 
02029         case 12:
02030             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
02031 
02032             dev_stka821_load_microcode(dev);
02033 
02034             usb_stk11xx_write_registry(dev, 0x0104, 0x0000);
02035             usb_stk11xx_write_registry(dev, 0x0105, 0x0000);
02036             usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
02037 
02038             break;
02039 
02040         case 13:
02041             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
02042 
02043             dev_stka821_load_microcode(dev);
02044 
02045             usb_stk11xx_write_registry(dev, 0x0106, 0x0000);
02046     }
02047     
02048     return 0;
02049 }
02050 
02051 
02061 int dev_stka821_camera_asleep(struct usb_stk11xx *dev)
02062 {
02063     int value;
02064 
02065     usb_stk11xx_read_registry(dev, 0x0104, &value);
02066     usb_stk11xx_read_registry(dev, 0x0105, &value);
02067     usb_stk11xx_read_registry(dev, 0x0106, &value);
02068 
02069     usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
02070     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
02071     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
02072     usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
02073 
02074     usb_stk11xx_read_registry(dev, 0x0000, &value);
02075     usb_stk11xx_write_registry(dev, 0x0000, 0x0049);
02076 
02077     return 0;
02078 }
02079 
02080 
02091 int dev_stka821_init_camera(struct usb_stk11xx *dev)
02092 {
02093 //  int retok;
02094 //  int value;
02095 
02096     dev_stka821_camera_asleep(dev);
02097 
02098     usb_stk11xx_set_feature(dev, 0);
02099 
02100     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
02101     usb_stk11xx_write_registry(dev, 0x0002, 0x00E8);
02102     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
02103     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02104 
02105     dev_stka821_configure_device(dev, 11);
02106 
02107     dev_stk11xx_camera_off(dev);
02108 
02109     dev_stka821_camera_settings(dev);
02110 
02111     dev_stka821_camera_asleep(dev);
02112 
02113     usb_stk11xx_set_feature(dev, 0);
02114 
02115     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
02116     usb_stk11xx_write_registry(dev, 0x0002, 0x00E8);
02117     usb_stk11xx_write_registry(dev, 0x0002, 0x0068);
02118     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02119 
02120     dev_stka821_configure_device(dev, 12);
02121 
02122     dev_stk11xx_camera_off(dev);
02123 
02124     dev_stka821_camera_settings(dev);
02125 
02126     return 0;
02127 }
02128 
02129 
02139 int dev_stka821_load_microcode(struct usb_stk11xx *dev)
02140 {
02141     int i;
02142     int retok;
02143     int value;
02144 
02145     int values_204[] = {
02146         0x17, 0x19, 0xb4, 0xa6, 0x12, 0x13, 0x1e, 0x21, 0x24, 0x32,
02147         0x36, 0x39, 0x4d, 0x53, 0x5d, 0x5f, 0x60, 0x61, 0x62, 0x63,
02148         0x64, 0x65, 0x66, 0x82, 0x83, 0x85, 0x86, 0x89, 0x97, 0x98,
02149         0xad, 0xae, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbf, 0x48, 0xd8,
02150         0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
02151         0x80, 0x81, 0xd8, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
02152         0x7d, 0x7e, 0x7f, 0x80, 0x81, 0xd8, 0x76, 0x77, 0x78, 0x79,
02153         0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x5c, 0xc0,
02154         0x59, 0x5a, 0x5b, 0xd4, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93,
02155         0x94, 0x95, 0x96, 0xb3, 0x73, 0x06, 0x07, 0x0b, 0x15, 0x20,
02156         0x4e, 0x4f, 0x49, 0x4a, 0x4b, 0x4c, 0x46, 0x06, 0x07, 0xb9,
02157         0xba, 0xbb, 0xbc, 0x61, 0x62, 0x65, 0x66
02158     };
02159     int values_205[] = {
02160         0x41, 0x41, 0x03, 0x06, 0x06, 0x08, 0x06, 0x00, 0x02, 0x69,
02161         0x35, 0x60, 0xfe, 0x1c, 0x04, 0x08, 0x08, 0x08, 0x08, 0x00,
02162         0x00, 0x10, 0x14, 0x01, 0x80, 0x0c, 0xb6, 0x00, 0x25, 0x25,
02163         0x3f, 0x24, 0x10, 0x07, 0xcc, 0x1f, 0x30, 0x02, 0x9c, 0x80,
02164         0x00, 0x0d, 0x18, 0x22, 0x2c, 0x3e, 0x4f, 0x6f, 0x8e, 0xac,
02165         0xc8, 0xe5, 0xa0, 0x00, 0x0d, 0x18, 0x22, 0x2c, 0x3e, 0x4f,
02166         0x6f, 0x8e, 0xac, 0xc8, 0xe5, 0xc0, 0x00, 0x0d, 0x18, 0x22,
02167         0x2c, 0x3e, 0x4f, 0x6f, 0x8e, 0xac, 0xc8, 0xe5, 0x70, 0x18,
02168         0x09, 0x07, 0x07, 0x3c, 0x3d, 0x95, 0x88, 0x89, 0x47, 0x9c,
02169         0x81, 0x9c, 0x3d, 0x76, 0x76, 0x01, 0xf3, 0x05, 0x00, 0x44,
02170         0x06, 0x0a, 0x96, 0x00, 0x7d, 0x00, 0x20, 0x01, 0xf3, 0x04,
02171         0xe4, 0x09, 0xc8, 0x08, 0x08, 0x10, 0x14
02172     };
02173     
02174 
02175     for(i=0; i<117; i++) {
02176         usb_stk11xx_read_registry(dev, 0x02FF, &value);
02177         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02178 
02179         usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
02180         usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
02181         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
02182 
02183         retok = dev_stk11xx_check_device(dev, 500);
02184 
02185         if (retok != 1) {
02186             STK_ERROR("Load microcode fail !\n");
02187             return -1;
02188         }
02189 
02190         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02191     }
02192 
02193     retok = dev_stk11xx_check_device(dev, 500);
02194 
02195     return 0;
02196 }
02197 
02198 
02212 int dev_stka821_camera_settings(struct usb_stk11xx *dev)
02213 {
02214     int i;
02215     int ret;
02216     int value;
02217 
02218     int values_204[] = {
02219         0xB3, 0x73, 0x46, 0x06, 0x07, 0xB9, 0xBA, 0xBB, 0xBC, 0x61, 0x62, 0x65, 0x66
02220     };
02221     int values_205[] = {
02222         0x76, 0x76, 0x20, 0x01, 0xF3, 0x04, 0xE4, 0x09, 0xC8, 0x08, 0x08, 0x10, 0x14
02223     };
02224 
02225 
02226     // Contrast register
02227     usb_stk11xx_read_registry(dev, 0x02FF, &value);
02228     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02229 
02230     usb_stk11xx_write_registry(dev, 0x0204, 0x00B3);
02231     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
02232 
02233     usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
02234     ret = dev_stk11xx_check_device(dev, 500);
02235     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02236 
02237 
02238     for (i=1; i<13; i++) {
02239         usb_stk11xx_read_registry(dev, 0x02FF, &value);
02240         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02241 
02242         usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
02243         usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
02244 
02245         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
02246         ret = dev_stk11xx_check_device(dev, 500);
02247         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02248     }
02249 
02250     return 0;
02251 }
02252 
02253 
02267 int dev_stka821_set_camera_quality(struct usb_stk11xx *dev)
02268 {
02269     int ret;
02270     int value;
02271 
02272     // Contrast register
02273     usb_stk11xx_read_registry(dev, 0x02FF, &value);
02274     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02275 
02276     usb_stk11xx_write_registry(dev, 0x0204, 0x00B3);
02277     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
02278 
02279     usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
02280     ret = dev_stk11xx_check_device(dev, 500);
02281     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02282 
02283     STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
02284     STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
02285     STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
02286     STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
02287 
02288     return 0;
02289 }
02290 
02291 
02301 int dev_stka821_set_camera_fps(struct usb_stk11xx *dev)
02302 {
02303     return 0;
02304 }
02305 
02306 
02317 int dev_stka821_start_stream(struct usb_stk11xx *dev)
02318 {
02319     int value;
02320     int value_116, value_117;
02321 
02322     usb_stk11xx_read_registry(dev, 0x0116, &value_116);
02323     usb_stk11xx_read_registry(dev, 0x0117, &value_117);
02324 
02325     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
02326     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
02327 
02328     usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
02329     usb_stk11xx_write_registry(dev, 0x0100, 0x00A0);
02330 
02331     usb_stk11xx_write_registry(dev, 0x0116, value_116);
02332     usb_stk11xx_write_registry(dev, 0x0117, value_117);
02333 
02334     return 0;
02335 }
02336 
02337 
02347 int dev_stka821_reconf_camera(struct usb_stk11xx *dev)
02348 {
02349     dev_stka821_configure_device(dev, 13);
02350 
02351     dev_stk11xx_camera_settings(dev);
02352 
02353     return 0;
02354 }
02355 
02356 
02367 int dev_stka821_stop_stream(struct usb_stk11xx *dev)
02368 {
02369     int value;
02370 
02371     usb_stk11xx_read_registry(dev, 0x0100, &value);
02372     usb_stk11xx_write_registry(dev, 0x0100, 0x0020);
02373 
02374     return 0;
02375 }
02376 
02377 
02378 //=============================================================================
02379 //
02380 // STK-6A31 API
02381 //
02382 //=============================================================================
02383 
02384 
02398 int dev_stk6a31_initialize_device(struct usb_stk11xx *dev)
02399 {
02400 //  int i;
02401     int retok;
02402 //  int value;
02403 
02404     STK_INFO("Initialize USB2.0 Syntek Camera\n");
02405 /*
02406     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02407     usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
02408     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
02409 
02410     usb_stk11xx_write_registry(dev, 0x0002, 0x007F);
02411     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02412     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02413     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02414     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02415     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02416     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02417     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02418     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02419     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02420     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02421     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02422     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02423     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02424     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02425     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02426     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02427     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02428     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02429     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02430     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02431     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02432     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02433     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02434     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02435     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02436     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02437     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02438     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02439     usb_stk11xx_write_registry(dev, 0x0002, 0x007D);
02440     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02441 
02442     for (i=0; i<16; i++) {
02443         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02444         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02445         usb_stk11xx_read_registry(dev, 0x0000, &value);
02446     
02447         STK_DEBUG("Loop 1 : Read 0x0000 = %02X\n", value);
02448     }
02449 
02450     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02451     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02452 
02453     usb_stk11xx_write_registry(dev, 0x0002, 0x007F);
02454     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02455     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02456     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02457     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02458     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02459     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02460     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02461     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02462     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02463     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02464     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02465     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02466     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02467     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02468     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02469     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02470     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02471     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02472     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02473     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02474     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02475     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02476     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02477     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02478     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02479     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02480     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02481     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02482     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02483     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02484     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02485     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02486     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02487     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02488     usb_stk11xx_write_registry(dev, 0x0002, 0x007D);
02489     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02490 
02491     for (i=0; i<16; i++) {
02492         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02493         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02494         usb_stk11xx_read_registry(dev, 0x0000, &value);
02495 
02496         STK_DEBUG("Loop 2 : Read 0x0000 = %02X\n", value);
02497     }
02498 
02499     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02500     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02501 
02502     usb_stk11xx_write_registry(dev, 0x0002, 0x007F);
02503     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02504     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02505     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02506     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02507     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02508     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02509     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02510     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02511     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02512     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02513     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02514     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02515     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02516     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02517     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02518     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02519     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02520     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02521     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02522     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02523     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02524     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02525     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02526     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02527     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02528     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02529     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02530     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02531     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02532     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02533     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02534     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02535     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02536     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02537     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02538     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02539     usb_stk11xx_write_registry(dev, 0x0000, 0x0027);
02540     usb_stk11xx_write_registry(dev, 0x0000, 0x0026);
02541     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02542     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02543     usb_stk11xx_write_registry(dev, 0x0002, 0x007D);
02544     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02545 
02546     for (i=0; i<16; i++) {
02547         usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02548         usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02549         usb_stk11xx_read_registry(dev, 0x0000, &value);
02550     
02551         STK_DEBUG("Loop 3 : Read 0x0000 = %02X\n", value);
02552     }
02553 
02554     usb_stk11xx_write_registry(dev, 0x0000, 0x0025);
02555     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02556     usb_stk11xx_write_registry(dev, 0x0002, 0x007F);
02557     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02558     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02559 
02560     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
02561     usb_stk11xx_read_registry(dev, 0x0103, &value);
02562     usb_stk11xx_write_registry(dev, 0x0103, 0x0001);
02563     usb_stk11xx_read_registry(dev, 0x0103, &value);
02564     usb_stk11xx_write_registry(dev, 0x0103, 0x0000);
02565 */
02566     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
02567     usb_stk11xx_write_registry(dev, 0x0002, 0x00F8);
02568     usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
02569     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
02570 
02571     dev_stk6a31_configure_device(dev, 0);
02572     retok = dev_stk11xx_check_device(dev, 65);
02573     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02574 
02575     dev_stk6a31_configure_device(dev, 1);
02576     retok = dev_stk11xx_check_device(dev, 65);
02577     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02578 
02579     dev_stk6a31_configure_device(dev, 2);
02580     retok = dev_stk11xx_check_device(dev, 65);
02581     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02582 
02583     dev_stk6a31_configure_device(dev, 3);
02584     retok = dev_stk11xx_check_device(dev, 65);
02585     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02586 
02587     dev_stk6a31_configure_device(dev, 4);
02588     retok = dev_stk11xx_check_device(dev, 65);
02589     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02590 
02591     dev_stk6a31_configure_device(dev, 5);
02592     retok = dev_stk11xx_check_device(dev, 65);
02593     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02594 
02595     dev_stk6a31_configure_device(dev, 6);
02596     retok = dev_stk11xx_check_device(dev, 65);
02597     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02598 
02599     dev_stk6a31_configure_device(dev, 7);
02600     retok = dev_stk11xx_check_device(dev, 65);
02601     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02602 
02603     dev_stk6a31_configure_device(dev, 8);
02604 
02605     dev_stk6a31_configure_device(dev, 9);
02606     retok = dev_stk11xx_check_device(dev, 65);
02607     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02608 
02609     dev_stk6a31_configure_device(dev, 10);
02610     retok = dev_stk11xx_check_device(dev, 65);
02611     usb_stk11xx_write_registry(dev, 0x0200, 0x0008);
02612 
02613     dev_stk6a31_configure_device(dev, 11);
02614 
02615     dev_stk6a31_configure_device(dev, 12);
02616 
02617     dev_stk6a31_configure_device(dev, 13);
02618 
02619     dev_stk6a31_configure_device(dev, 14);
02620 
02621     dev_stk6a31_camera_asleep(dev);
02622 
02623     usb_stk11xx_set_feature(dev, 0);
02624 
02625     // Device is initialized and is ready !!!
02626     STK_INFO("Syntek USB2.0 Camera is ready\n");
02627 
02628     return 0;
02629 }
02630 
02631 
02645 int dev_stk6a31_configure_device(struct usb_stk11xx *dev, int step)
02646 {
02647     int retok;
02648     int value;
02649 
02650     //     0,    1,    2,    3,    4,    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,   15,   16
02651 
02652     int values_001B[] = {
02653         0x03, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07
02654     };
02655     int values_001C[] = {
02656         0x02, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06
02657     };
02658     int values_0202[] = {
02659         0x0A, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x1E, 0x0A, 0x1E, 0x1F, 0x1F, 0x1F, 0x1F
02660     };
02661     int values_0110[] = {
02662         0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
02663     };
02664     int values_0112[] = {
02665         0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
02666     };
02667     int values_0114[] = {
02668         0x80, 0x80, 0x80, 0x80, 0x00, 0xBE, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80
02669     };
02670     int values_0115[] = {
02671         0x02, 0x02, 0x02, 0x02, 0x05, 0x02, 0x02, 0x02, 0x00, 0x02, 0x02, 0x02, 0x05, 0x02, 0x02, 0x02, 0x02
02672     };
02673     int values_0116[] = {
02674         0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE9, 0xE0, 0xE0, 0x00, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0
02675     };
02676     int values_0117[] = {
02677         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
02678     };
02679     int values_0100[] = {
02680         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
02681     };
02682 
02683     STK_DEBUG("dev_stk6a31_configure_device : %d\n", step);
02684 
02685     usb_stk11xx_write_registry(dev, 0x0000, 0x0024);
02686     usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
02687     usb_stk11xx_write_registry(dev, 0x0003, 0x0080);
02688     usb_stk11xx_write_registry(dev, 0x0005, 0x0000);
02689     
02690     usb_stk11xx_write_registry(dev, 0x0007, 0x0003);
02691     usb_stk11xx_write_registry(dev, 0x000d, 0x0000);
02692     usb_stk11xx_write_registry(dev, 0x000f, 0x0002);
02693     usb_stk11xx_write_registry(dev, 0x0300, 0x0012);
02694     usb_stk11xx_write_registry(dev, 0x0350, 0x0041);
02695     
02696     usb_stk11xx_write_registry(dev, 0x0351, 0x0000);
02697     usb_stk11xx_write_registry(dev, 0x0352, 0x0000);
02698     usb_stk11xx_write_registry(dev, 0x0353, 0x0000);
02699     usb_stk11xx_write_registry(dev, 0x0018, 0x0010);
02700     usb_stk11xx_write_registry(dev, 0x0019, 0x0000);
02701     
02702     usb_stk11xx_write_registry(dev, 0x001b, values_001B[step]);
02703     usb_stk11xx_write_registry(dev, 0x001c, values_001C[step]);
02704     usb_stk11xx_write_registry(dev, 0x0300, 0x0080);
02705     usb_stk11xx_write_registry(dev, 0x001a, 0x0004);
02706     usb_stk11xx_write_registry(dev, 0x0202, values_0202[step]);
02707     
02708     usb_stk11xx_write_registry(dev, 0x0110, values_0110[step]);
02709     usb_stk11xx_write_registry(dev, 0x0111, 0x0000);
02710     usb_stk11xx_write_registry(dev, 0x0112, values_0112[step]);
02711     usb_stk11xx_write_registry(dev, 0x0113, 0x0000);
02712     usb_stk11xx_write_registry(dev, 0x0114, values_0114[step]);
02713     
02714     usb_stk11xx_write_registry(dev, 0x0115, values_0115[step]);
02715     usb_stk11xx_write_registry(dev, 0x0116, values_0116[step]);
02716     usb_stk11xx_write_registry(dev, 0x0117, values_0117[step]);
02717 
02718     usb_stk11xx_read_registry(dev, 0x0100, &value);
02719     usb_stk11xx_write_registry(dev, 0x0100, values_0100[step]);
02720 
02721 //  usb_stk11xx_write_registry(dev, 0x0200, 0x0080); 
02722 //  usb_stk11xx_write_registry(dev, 0x0200, 0x0000); 
02723     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02724 
02725 
02726     switch (step) {
02727         case 0:
02728             usb_stk11xx_write_registry(dev, 0x0203, 0x0022); 
02729 
02730             usb_stk11xx_write_registry(dev, 0x0204, 0x0027); 
02731             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
02732 
02733             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02734 
02735             break;
02736     
02737         case 1:
02738             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02739 
02740             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02741             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02742             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02743             usb_stk11xx_write_registry(dev, 0x0205, 0x00BF); 
02744 
02745             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02746 
02747             break;
02748 
02749         case 2:
02750             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
02751 
02752             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02753             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02754             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
02755             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
02756 
02757             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02758 
02759             break;
02760 
02761         case 3:
02762             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
02763 
02764             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02765             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02766             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02767             usb_stk11xx_write_registry(dev, 0x0205, 0x00E0); 
02768             usb_stk11xx_write_registry(dev, 0x0204, 0x0024); 
02769             usb_stk11xx_write_registry(dev, 0x0205, 0x00A5); 
02770 
02771             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02772 
02773             break;
02774 
02775         case 4:
02776             usb_stk11xx_write_registry(dev, 0x0203, 0x0042); 
02777 
02778             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02779             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02780             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02781             usb_stk11xx_write_registry(dev, 0x0205, 0x00BF); 
02782 
02783             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02784 
02785             break;
02786 
02787         case 5:
02788             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02789 
02790             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02791             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02792             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02793             usb_stk11xx_write_registry(dev, 0x0205, 0x00FF); 
02794 
02795             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02796 
02797             break;
02798 
02799         case 6:
02800             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02801 
02802             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02803             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02804             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02805             usb_stk11xx_write_registry(dev, 0x0205, 0x00B7); 
02806 
02807             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02808 
02809             break;
02810 
02811         case 7:
02812             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02813 
02814             usb_stk11xx_write_registry(dev, 0x0204, 0x0012); 
02815             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02816             usb_stk11xx_write_registry(dev, 0x0204, 0x0013); 
02817             usb_stk11xx_write_registry(dev, 0x0205, 0x00B7); 
02818 
02819             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02820 
02821             break;
02822 
02823         case 8:
02824             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02825 
02826             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02827             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02828 
02829             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02830             usb_stk11xx_write_registry(dev, 0x0204, 0x00FF); 
02831             usb_stk11xx_write_registry(dev, 0x0205, 0x0001); 
02832             usb_stk11xx_write_registry(dev, 0x0200, 0x0001); 
02833             retok = dev_stk11xx_check_device(dev, 500);
02834             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02835             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02836             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02837 
02838             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02839             usb_stk11xx_write_registry(dev, 0x0208, 0x000A); 
02840             usb_stk11xx_write_registry(dev, 0x0200, 0x0020); 
02841             retok = dev_stk11xx_check_device(dev, 500);
02842             usb_stk11xx_read_registry(dev, 0x0209, &value);
02843             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02844             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02845             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02846 
02847             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02848             usb_stk11xx_write_registry(dev, 0x0208, 0x000B); 
02849             usb_stk11xx_write_registry(dev, 0x0200, 0x0020); 
02850             retok = dev_stk11xx_check_device(dev, 500);
02851             usb_stk11xx_read_registry(dev, 0x0209, &value);
02852             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02853             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02854             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02855 
02856             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02857             usb_stk11xx_write_registry(dev, 0x0208, 0x001C); 
02858             usb_stk11xx_write_registry(dev, 0x0200, 0x0020); 
02859             retok = dev_stk11xx_check_device(dev, 500);
02860             usb_stk11xx_read_registry(dev, 0x0209, &value);
02861             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02862             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02863             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02864 
02865             usb_stk11xx_write_registry(dev, 0x0203, 0x0060); 
02866             usb_stk11xx_write_registry(dev, 0x0208, 0x001D); 
02867             usb_stk11xx_write_registry(dev, 0x0200, 0x0020); 
02868             retok = dev_stk11xx_check_device(dev, 500);
02869             usb_stk11xx_read_registry(dev, 0x0209, &value);
02870             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000); 
02871 
02872             break;
02873 
02874         case 9:
02875             usb_stk11xx_write_registry(dev, 0x0203, 0x00DC); 
02876 
02877             usb_stk11xx_write_registry(dev, 0x0204, 0x0015); 
02878             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02879 
02880             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02881 
02882             break;
02883 
02884         case 10:
02885             usb_stk11xx_write_registry(dev, 0x0203, 0x00EC); 
02886 
02887             usb_stk11xx_write_registry(dev, 0x0204, 0x0015); 
02888             usb_stk11xx_write_registry(dev, 0x0205, 0x0080); 
02889 
02890             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02891 
02892             break;
02893 
02894         case 11:
02895             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02896 
02897             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02898             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02899 
02900             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02901 
02902             usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
02903             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02904             retok = dev_stk11xx_check_device(dev, 500);
02905             usb_stk11xx_read_registry(dev, 0x0209, &value);
02906             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02907 
02908             break;
02909 
02910         case 12:
02911             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02912 
02913             usb_stk11xx_write_registry(dev, 0x0204, 0x00F0); 
02914             usb_stk11xx_write_registry(dev, 0x0205, 0x0000); 
02915             usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
02916             retok = dev_stk11xx_check_device(dev, 500);
02917             usb_stk11xx_write_registry(dev, 0x0204, 0x00F1); 
02918             usb_stk11xx_write_registry(dev, 0x0205, 0x0000); 
02919             usb_stk11xx_write_registry(dev, 0x0200, 0x0005);
02920             retok = dev_stk11xx_check_device(dev, 500);
02921             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02922             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02923 
02924             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02925             usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
02926             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02927             retok = dev_stk11xx_check_device(dev, 500);
02928             usb_stk11xx_read_registry(dev, 0x0209, &value);
02929             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02930             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02931             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02932 
02933             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02934             usb_stk11xx_write_registry(dev, 0x0208, 0x00F1);
02935             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02936             retok = dev_stk11xx_check_device(dev, 500);
02937             usb_stk11xx_read_registry(dev, 0x0209, &value);
02938             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02939 
02940             break;
02941 
02942         case 13:
02943             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02944 
02945             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02946             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02947 
02948             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02949             usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
02950             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02951             retok = dev_stk11xx_check_device(dev, 500);
02952             usb_stk11xx_read_registry(dev, 0x0209, &value);
02953             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02954             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02955             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02956 
02957             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02958             usb_stk11xx_write_registry(dev, 0x0208, 0x00F1);
02959             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02960             retok = dev_stk11xx_check_device(dev, 500);
02961             usb_stk11xx_read_registry(dev, 0x0209, &value);
02962             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02963 
02964             break;
02965 
02966         case 14:
02967             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02968 
02969             usb_stk11xx_write_registry(dev, 0x0204, 0x0001); 
02970             usb_stk11xx_write_registry(dev, 0x0205, 0x0000); 
02971             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02972             retok = dev_stk11xx_check_device(dev, 500);
02973             usb_stk11xx_write_registry(dev, 0x0204, 0x00F1); 
02974             usb_stk11xx_write_registry(dev, 0x0205, 0x0000); 
02975             usb_stk11xx_write_registry(dev, 0x0200, 0x0005); 
02976             retok = dev_stk11xx_check_device(dev, 500);
02977             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02978             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02979 
02980             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02981             usb_stk11xx_write_registry(dev, 0x0208, 0x0000);
02982             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02983             retok = dev_stk11xx_check_device(dev, 500);
02984             usb_stk11xx_read_registry(dev, 0x0209, &value);
02985             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02986             usb_stk11xx_read_registry(dev, 0x02FF, &value);
02987             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02988 
02989             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
02990             usb_stk11xx_write_registry(dev, 0x0208, 0x00F1);
02991             usb_stk11xx_write_registry(dev, 0x0200, 0x0020);
02992             retok = dev_stk11xx_check_device(dev, 500);
02993             usb_stk11xx_read_registry(dev, 0x0209, &value);
02994             usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
02995 
02996             break;
02997 
02998         case 15:
02999             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
03000 
03001             dev_stk6a31_load_microcode(dev);
03002 
03003             usb_stk11xx_write_registry(dev, 0x0200, 0x0080);
03004             usb_stk11xx_write_registry(dev, 0x0200, 0x0000);
03005             usb_stk11xx_write_registry(dev, 0x02FF, 0x0001);
03006             usb_stk11xx_write_registry(dev, 0x0203, 0x00A0);
03007 
03008 
03009             break;
03010 
03011         case 16:
03012             usb_stk11xx_write_registry(dev, 0x0203, 0x00BA); 
03013 
03014             dev_stk6a31_load_microcode(dev);
03015 
03016             break;
03017     }
03018     
03019     return 0;
03020 }
03021 
03022 
03032 int dev_stk6a31_camera_asleep(struct usb_stk11xx *dev)
03033 {
03034     int value;
03035 
03036     usb_stk11xx_read_registry(dev, 0x0104, &value);
03037     usb_stk11xx_read_registry(dev, 0x0105, &value);
03038     usb_stk11xx_read_registry(dev, 0x0106, &value);
03039 
03040     usb_stk11xx_write_registry(dev, 0x0100, 0x0021);
03041     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
03042     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
03043     usb_stk11xx_write_registry(dev, 0x0018, 0x0000);
03044 
03045     usb_stk11xx_read_registry(dev, 0x0000, &value);
03046     usb_stk11xx_write_registry(dev, 0x0000, 0x0049);
03047 
03048     return 0;
03049 }
03050 
03051 
03062 int dev_stk6a31_init_camera(struct usb_stk11xx *dev)
03063 {
03064 //  int retok;
03065 //  int value;
03066 
03067     dev_stk6a31_camera_asleep(dev);
03068 
03069     usb_stk11xx_set_feature(dev, 0);
03070 
03071     dev_stk6a31_camera_asleep(dev);
03072 
03073     usb_stk11xx_write_registry(dev, 0x0000, 0x00E0);
03074     usb_stk11xx_write_registry(dev, 0x0002, 0x00F8);
03075     usb_stk11xx_write_registry(dev, 0x0002, 0x0078);
03076     usb_stk11xx_write_registry(dev, 0x0000, 0x0020);
03077 
03078     dev_stk6a31_configure_device(dev, 15);
03079 
03080     dev_stk11xx_camera_off(dev);
03081 
03082     return 0;
03083 }
03084 
03085 
03095 int dev_stk6a31_load_microcode(struct usb_stk11xx *dev)
03096 {
03097     int i;
03098     int retok;
03099     int value;
03100 
03101     int values_204[] = {
03102         0xf0, 0xf1, 0x0d, 0xf1, 0x0d, 0xf1, 0xf0, 0xf1, 0x35, 0xf1,
03103         0xf0, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0xdd, 0xf1, 0xf0, 0xf1,
03104         0x1f, 0xf1, 0x20, 0xf1, 0x21, 0xf1, 0x22, 0xf1, 0x23, 0xf1,
03105         0x24, 0xf1, 0x28, 0xf1, 0x29, 0xf1, 0x5e, 0xf1, 0x5f, 0xf1, 
03106         0x60, 0xf1, 0xef, 0xf1, 0xf2, 0xf1, 0x02, 0xf1, 0x03, 0xf1,
03107         0x04, 0xf1, 0x09, 0xf1, 0x0a, 0xf1, 0x0b, 0xf1, 0x0c, 0xf1,
03108         0x0d, 0xf1, 0x0e, 0xf1, 0x0f, 0xf1, 0x10, 0xf1, 0x11, 0xf1, 
03109         0x15, 0xf1, 0x16, 0xf1, 0x17, 0xf1, 0x18, 0xf1, 0x19, 0xf1,
03110         0x1a, 0xf1, 0x1b, 0xf1, 0x1c, 0xf1, 0x1d, 0xf1, 0x1e, 0xf1,
03111         0xf0, 0xf1, 0x06, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0x80, 0xf1,
03112         0x81, 0xf1, 0x82, 0xf1, 0x83, 0xf1, 0x84, 0xf1, 0x85, 0xf1,
03113         0x86, 0xf1, 0x87, 0xf1, 0x88, 0xf1, 0x89, 0xf1, 0x8a, 0xf1, 
03114         0x8b, 0xf1, 0x8c, 0xf1, 0x8d, 0xf1, 0x8e, 0xf1, 0x8f, 0xf1,
03115         0x90, 0xf1, 0x91, 0xf1, 0x92, 0xf1, 0x93, 0xf1, 0x94, 0xf1,
03116         0x95, 0xf1, 0xb6, 0xf1, 0xb7, 0xf1, 0xb8, 0xf1, 0xb9, 0xf1,
03117         0xba, 0xf1, 0xbb, 0xf1, 0xbc, 0xf1, 0xbd, 0xf1, 0xbe, 0xf1,
03118         0xbf, 0xf1, 0xc0, 0xf1, 0xc1, 0xf1, 0xc2, 0xf1, 0xc3, 0xf1,
03119         0xc4, 0xf1, 0x06, 0xf1, 0xf0, 0xf1, 0x53, 0xf1, 0x54, 0xf1,
03120         0x55, 0xf1, 0x56, 0xf1, 0x57, 0xf1, 0x58, 0xf1, 0xdc, 0xf1,
03121         0xdd, 0xf1, 0xde, 0xf1, 0xdf, 0xf1, 0xe0, 0xf1, 0xe1, 0xf1,
03122         0xf0, 0xf1, 0xa7, 0xf1, 0xaa, 0xf1, 0x3a, 0xf1, 0xa1, 0xf1,
03123         0xa4, 0xf1, 0x9b, 0xf1, 0x08, 0xf1, 0xf0, 0xf1, 0x2f, 0xf1,
03124         0x9c, 0xf1, 0xd2, 0xf1, 0xcc, 0xf1, 0xcb, 0xf1, 0x2e, 0xf1,
03125         0x67, 0xf1, 0xf0, 0xf1, 0x65, 0xf1, 0x66, 0xf1, 0x67, 0xf1,
03126         0x65, 0xf1, 0xf0, 0xf1, 0x05, 0xf1, 0x07, 0xf1, 0xf0, 0xf1,
03127         0x39, 0xf1, 0x3b, 0xf1, 0x3a, 0xf1, 0x3c, 0xf1, 0x57, 0xf1,
03128         0x58, 0xf1, 0x59, 0xf1, 0x5a, 0xf1, 0x5c, 0xf1, 0x5d, 0xf1,
03129         0x64, 0xf1, 0xf0, 0xf1, 0x5b, 0xf1, 0xf0, 0xf1, 0x36, 0xf1,
03130         0x37, 0xf1, 0xf0, 0xf1, 0x08, 0xf1
03131     };
03132     int values_205[] = {
03133         0x00, 0x00, 0x00, 0x0b, 0x00, 0x08, 0x00, 0x00, 0x00, 0x22,
03134         0x00, 0x01, 0x70, 0x0e, 0x00, 0x02, 0x18, 0xe0, 0x00, 0x02,
03135         0x01, 0x80, 0xc8, 0x14, 0x80, 0x80, 0xa0, 0x78, 0xa0, 0x78,
03136         0x5f, 0x20, 0xea, 0x02, 0x86, 0x7a, 0x59, 0x4c, 0x4d, 0x51,
03137         0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0x00, 0xee, 0x39, 0x23,
03138         0x07, 0x24, 0x00, 0xcd, 0x00, 0x93, 0x00, 0x04, 0x00, 0x5c,
03139         0x00, 0xd9, 0x00, 0x53, 0x00, 0x08, 0x00, 0x91, 0x00, 0xcf,
03140         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
03141         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
03142         0x00, 0x01, 0xf0, 0x0e, 0x70, 0x0e, 0x00, 0x01, 0x00, 0x07,
03143         0xde, 0x13, 0xeb, 0xe2, 0x00, 0xf6, 0xe1, 0x14, 0xea, 0xdd,
03144         0xfd, 0xf6, 0xe5, 0x11, 0xed, 0xe6, 0xfb, 0xf7, 0xd6, 0x13, 
03145         0xed, 0xec, 0xf9, 0xf2, 0x00, 0x00, 0xd8, 0x15, 0xe9, 0xea, 
03146         0xf9, 0xf1, 0x00, 0x02, 0xde, 0x10, 0xef, 0xef, 0xfb, 0xf4,
03147         0x00, 0x02, 0x0e, 0x06, 0x27, 0x13, 0x11, 0x06, 0x27, 0x13,
03148         0x0c, 0x03, 0x2a, 0x0f, 0x12, 0x08, 0x1a, 0x16, 0x00, 0x22,
03149         0x15, 0x0a, 0x1c, 0x1a, 0x00, 0x2d, 0x11, 0x09, 0x14, 0x14,
03150         0x00, 0x2a, 0x74, 0x0e, 0x00, 0x01, 0x0b, 0x03, 0x47, 0x22,
03151         0xac, 0x82, 0xda, 0xc7, 0xf5, 0xe9, 0xff, 0x00, 0x0b, 0x03,
03152         0x47, 0x22, 0xac, 0x82, 0xda, 0xc7, 0xf5, 0xe9, 0xff, 0x00,
03153         0x00, 0x01, 0x02, 0x80, 0x01, 0xe0, 0x43, 0x00, 0x05, 0x00,
03154         0x04, 0x00, 0x43, 0x00, 0x01, 0x80, 0x00, 0x02, 0xd1, 0x00,
03155         0xd1, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x0c, 0x3c,
03156         0x10, 0x10, 0x00, 0x00, 0xa0, 0x00, 0x20, 0x03, 0x05, 0x01,
03157         0x20, 0x00, 0x00, 0x00, 0x01, 0xb8, 0x00, 0xd8, 0x00, 0x02,
03158         0x06, 0xc0, 0x04, 0x0e, 0x06, 0xc0, 0x05, 0x64, 0x02, 0x08,
03159         0x02, 0x71, 0x02, 0x09, 0x02, 0x71, 0x12, 0x0d, 0x17, 0x12,
03160         0x5e, 0x1c, 0x00, 0x02, 0x00, 0x03, 0x00, 0x02, 0x78, 0x10,
03161         0x83, 0x04, 0x00, 0x00, 0x00, 0x21
03162     };
03163     
03164 
03165     for(i=0; i<286; i++) {
03166         usb_stk11xx_read_registry(dev, 0x02FF, &value);
03167         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03168 
03169         usb_stk11xx_write_registry(dev, 0x0203, 0x00BA);
03170 
03171         usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
03172         usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
03173         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
03174 
03175         retok = dev_stk11xx_check_device(dev, 500);
03176 
03177         if (retok != 1) {
03178             STK_ERROR("Load microcode fail !\n");
03179             return -1;
03180         }
03181 
03182         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03183     }
03184 
03185     retok = dev_stk11xx_check_device(dev, 500);
03186 
03187     return 0;
03188 }
03189 
03190 
03204 int dev_stk6a31_camera_settings(struct usb_stk11xx *dev)
03205 {
03206     int i;
03207     int ret;
03208     int value;
03209 
03210     int values_204[] = {
03211         0xF0, 0xF1, 0x2E, 0xF1, 0xF0, 0xF1, 0x5B, 0xF1, 0xF0, 0xF1, 0x36, 0xF1, 0x37, 0xF1, 0xF0, 0xF1, 0x08, 0xF1
03212     };
03213     int values_205[] = {
03214         0x00, 0x02, 0x0C, 0x3C, 0x00, 0x02, 0x00, 0x03, 0x00, 0x02, 0x78, 0x10, 0x83, 0x04, 0x00, 0x00, 0x00, 0x21
03215     };
03216 
03217 
03218     // Contrast register
03219     for (i=0; i<18; i++) {
03220         usb_stk11xx_read_registry(dev, 0x02FF, &value);
03221         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03222 
03223         usb_stk11xx_write_registry(dev, 0x0204, values_204[i]);
03224         usb_stk11xx_write_registry(dev, 0x0205, values_205[i]);
03225 
03226         usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
03227         ret = dev_stk11xx_check_device(dev, 500);
03228         usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03229     }
03230 
03231     return 0;
03232 }
03233 
03234 
03248 int dev_stk6a31_set_camera_quality(struct usb_stk11xx *dev)
03249 {
03250     int ret;
03251     int value;
03252 
03253     // Contrast register
03254     usb_stk11xx_read_registry(dev, 0x02FF, &value);
03255     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03256 
03257     usb_stk11xx_write_registry(dev, 0x0204, 0x00B3);
03258     usb_stk11xx_write_registry(dev, 0x0205, (dev->vsettings.contrast >> 8));
03259 
03260     usb_stk11xx_write_registry(dev, 0x0200, 0x0001);
03261     ret = dev_stk11xx_check_device(dev, 500);
03262     usb_stk11xx_write_registry(dev, 0x02FF, 0x0000);
03263 
03264     STK_DEBUG("Set colour : %d\n", dev->vsettings.colour);
03265     STK_DEBUG("Set contrast : %d\n", dev->vsettings.contrast);
03266     STK_DEBUG("Set whiteness : %d\n", dev->vsettings.whiteness);
03267     STK_DEBUG("Set brightness : %d\n", dev->vsettings.brightness);
03268 
03269     return 0;
03270 }
03271 
03272 
03282 int dev_stk6a31_set_camera_fps(struct usb_stk11xx *dev)
03283 {
03284     return 0;
03285 }
03286 
03287 
03298 int dev_stk6a31_start_stream(struct usb_stk11xx *dev)
03299 {
03300     int value;
03301     int value_116, value_117;
03302 
03303     usb_stk11xx_read_registry(dev, 0x0114, &value); // read 0x80
03304     usb_stk11xx_read_registry(dev, 0x0115, &value); // read 0x02
03305 
03306     usb_stk11xx_read_registry(dev, 0x0116, &value_116);
03307     usb_stk11xx_read_registry(dev, 0x0117, &value_117);
03308 
03309     usb_stk11xx_write_registry(dev, 0x0116, 0x0000);
03310     usb_stk11xx_write_registry(dev, 0x0117, 0x0000);
03311 
03312     usb_stk11xx_read_registry(dev, 0x0100, &value); // read 0x21
03313     usb_stk11xx_write_registry(dev, 0x0100, 0x00A0);
03314 
03315     usb_stk11xx_write_registry(dev, 0x0116, value_116);
03316     usb_stk11xx_write_registry(dev, 0x0117, value_117);
03317 
03318     return 0;
03319 }
03320 
03321 
03331 int dev_stk6a31_reconf_camera(struct usb_stk11xx *dev)
03332 {
03333     dev_stk6a31_configure_device(dev, 16);
03334 
03335     dev_stk11xx_camera_settings(dev);
03336 
03337     return 0;
03338 }
03339 
03340 
03351 int dev_stk6a31_stop_stream(struct usb_stk11xx *dev)
03352 {
03353     return 0;
03354 }
03355 
03356 

Generated on Tue Oct 30 13:32:13 2007 for SyntekUSBVideoCamera by  doxygen 1.5.3