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

Generated on Tue Oct 2 06:18:12 2007 for SyntekUSBVideoCamera by  doxygen 1.5.3