Changeset 126


Ignore:
Timestamp:
Apr 15, 2011, 11:31:00 AM (6 years ago)
Author:
voyteckst
Message:

Marc's camera module changes

Location:
modules/camera
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • modules/camera/s3c_camera_driver.c

    r109 r126  
    307307 
    308308        __TRACE_CAMERA_DRV(printk("[CAM-DRV] +s3c_camif_convert_type\n")); 
    309  
     309        printk("CAMIF convert type: W:%d H:%d \n", cfg->v2.frmbuf.fmt.width, cfg->v2.frmbuf.fmt.height); 
    310310        cfg->target_x = cfg->v2.frmbuf.fmt.width; 
    311311        cfg->target_y = cfg->v2.frmbuf.fmt.height; 
     
    321321static int s3c_camif_get_sensor_format(unsigned int    in_width, unsigned int    in_height) 
    322322{ 
    323         int sensor_type = SENSOR_XGA; 
     323        int sensor_type = SENSOR_VGA; 
    324324 
    325325        __TRACE_CAMERA_DRV(printk("[CAM-DRV] +s3c_camif_get_sensor_format\n")); 
    326326 
    327         #if defined(CONFIG_VIDEO_SAMSUNG_S5K4CA) 
    328         { 
    329                 if(2048 <= in_width || 1536 <= in_height) 
     327                if(2560 == in_width & 1920 == in_height) 
     328                        sensor_type = SENSOR_QSXGA; 
     329                if(2048 == in_width & 1536 == in_height) 
    330330                        sensor_type = SENSOR_QXGA; 
    331                 else 
    332                         sensor_type = SENSOR_VGA; //XGA ORIGINAL 
    333         } 
    334         #elif defined(CONFIG_VIDEO_SAMSUNG_CE131) 
    335         { 
    336                 if(2048 <= in_width || 1536 <= in_height) 
    337                         sensor_type = SENSOR_QXGA; 
    338                 else 
    339                         sensor_type = SENSOR_VGA; //XGA ORIGINAL 
    340         }/* 
    341         { 
    342                 if(2560 <= in_width || 1920 <= in_height) 
    343                         sensor_type = SENSOR_QSXGA; 
    344                 else 
    345                         sensor_type = SENSOR_XGA; 
    346         }*/ 
    347         #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3AA) 
    348         { 
    349                 if(1280 <= in_width || 1024 <= in_height) 
     331                if(1280 == in_width & 1024 == in_height) 
    350332                        sensor_type = SENSOR_SXGA; 
    351                 else 
     333                if(1600 == in_width & 1200 == in_height) 
     334                        sensor_type = SENSOR_UXGA; 
     335                if(800 == in_width & 600 == in_height) 
     336                        sensor_type = SENSOR_SVGA; 
     337                if(640 == in_width & 480 == in_height) 
    352338                        sensor_type = SENSOR_VGA; 
    353         } 
    354         #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3BA) 
    355         { 
    356                 if(1600 <= in_width || 1024 <= in_height) 
    357                         sensor_type = SENSOR_UXGA; 
    358                 else 
    359                         sensor_type = SENSOR_SVGA; 
    360         } 
    361         #elif defined(CONFIG_VIDEO_SAMSUNG_S5K4BA) 
    362         { 
    363                 if(800 <= in_width || 600 <= in_height) 
    364                         sensor_type = SENSOR_SVGA; 
    365                 else 
    366                         sensor_type = SENSOR_VGA; 
    367         } 
    368         #endif 
     339                //if(800 = in_width || 480 = in_height) 
     340                //      sensor_type = SENSOR_WVGA; 
     341 
     342        printk("[CAM-DRV] -s3c_camif_get_sensor_format sensor_type=%d\n",sensor_type) 
     343 
     344 
    369345 
    370346        __TRACE_CAMERA_DRV(printk("[CAM-DRV] -s3c_camif_get_sensor_format sensor_type=%d\n",sensor_type)); 
     
    380356 
    381357        __TRACE_CAMERA_DRV(printk("[CAM-DRV] +s3c_camif_start_capture\n")); 
    382         printk("s3c_camif_start_capture  \n"); 
     358        //printk("s3c_camif_start_capture  \n"); 
    383359        cfg->capture_enable = CAMIF_DMA_ON; 
    384360        s3c_camif_start_dma(cfg); 
     
    397373#endif 
    398374 
    399                 printk(" CISRCFMT = %x \n", readl(cfg->regs + S3C_CISRCFMT)); 
     375                /*printk(" CISRCFMT = %x \n", readl(cfg->regs + S3C_CISRCFMT)); 
    400376                printk(" CIGCTRL  = %x \n", readl(cfg->regs + S3C_CIGCTRL)); 
    401377                printk(" CIWDOFST   = %x \n", readl(cfg->regs + S3C_CIWDOFST )); 
     
    405381                printk(" CIPRCTRL = %x \n", readl(cfg->regs + S3C_CIPRCTRL)); 
    406382                printk(" MSCOCTRL = %x \n", readl(cfg->regs + S3C_MSCOCTRL)); 
    407                 printk(" MSPRCTRL = %x \n", readl(cfg->regs + S3C_MSPRWIDTH + 4)); 
     383                printk(" MSPRCTRL = %x \n", readl(cfg->regs + S3C_MSPRWIDTH + 4));*/ 
    408384 
    409385 
     
    527503 
    528504        __TRACE_CAMERA_DRV(printk("[CAM-DRV] +s3c_camif_change_mode %d\n",mode)); 
    529  
     505        printk("[CAM-DRV] +s3c_camif_change_mode %d\n",mode); 
    530506        if (mode == SENSOR_MAX) 
    531507        { 
    532                 #if defined(CONFIG_VIDEO_SAMSUNG_S5K4CA) 
    533                         res = SENSOR_QXGA; 
    534                 #elif defined(CONFIG_VIDEO_SAMSUNG_CE131) 
    535                         res = SENSOR_QXGA; //FIXME res = SENSOR_QSXGA; 
    536                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3AA) 
    537                         res = SENSOR_SXGA; 
    538                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3BA) 
    539                         res = SENSOR_UXGA; 
    540                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K4BA) 
    541                         res = SENSOR_SVGA; 
    542                 #endif 
     508                res = SENSOR_QSXGA; 
    543509        } 
    544510        else if (mode == SENSOR_DEFAULT) 
    545511        { 
    546                 #if defined(CONFIG_VIDEO_SAMSUNG_S5K4CA) 
    547                         res = SENSOR_VGA; //XGA original 
    548                 #elif defined(CONFIG_VIDEO_SAMSUNG_CE131) 
    549                         res = SENSOR_VGA;//                     res = SENSOR_XGA; 
    550                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3AA) 
    551512                        res = SENSOR_VGA; 
    552                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K3BA) 
    553                         res = SENSOR_SVGA; 
    554                 #elif defined(CONFIG_VIDEO_SAMSUNG_S5K4BA) 
    555                         res = SENSOR_SVGA; 
    556                 #else 
    557                         res = SENSOR_VGA; 
    558                 #endif 
    559513        } 
    560514        else 
     
    570524                        cis->source_y = 1920; 
    571525 
    572                         #if defined(CONFIG_VIDEO_SAMSUNG_CE131) 
    573                                 cfg->sc.scalerbypass = 1; 
    574                         #else 
    575                                 cfg->sc.scalerbypass = 0; 
    576                         #endif 
     526                        cfg->sc.scalerbypass = 1; 
     527                        //cfg->sc.scalerbypass = 0; 
     528 
    577529 
    578530                        break; 
     
    610562                        break; 
    611563 
     564/*              case SENSOR_W1MP: 
     565                        printk("Resolution changed into XGA (1024x768) mode\n"); 
     566                        cis->source_x = 1600; 
     567                        cis->source_y = 960; 
     568 
     569                        cfg->sc.scalerbypass = 0; 
     570                        break;*/ 
     571 
    612572                case SENSOR_SVGA: 
    613573                        printk("Resolution changed into SVGA (800x600) mode\n"); 
     
    626586                        break; 
    627587        } 
    628  
    629         //cis->sensor->driver->command(cis->sensor, res, NULL); 
     588        printk("before SENSOR SET CAPTURE SIZE \n"); 
     589        cis->sensor->driver->command(cis->sensor, SENSOR_SET_CAPTURE_SIZE, res); //MARC 
    630590         
    631591        cis->win_hor_ofst = cis->win_hor_ofst2 = 0; 
     
    838798                        cfg->v2.status       |= CAMIF_v4L2_DIRTY; 
    839799                        cfg->v2.status      &= ~CAMIF_v4L2_DIRTY; /* dummy ? */ 
    840 #ifdef CONFIG_VIDEO_SAMSUNG_CE131 
    841                         sensor_type = SENSOR_QXGA;  // FIXME 3M                 sensor_type = SENSOR_QSXGA; // 5M  
    842 #else 
    843                         sensor_type = SENSOR_QXGA;  // 3M 
    844 #endif 
     800                        sensor_type = s3c_camif_get_sensor_format(f->fmt.pix.width, f->fmt.pix.height); 
     801                        printk("sensor format capture = W: %d, H: %d \n", f->fmt.pix.width, f->fmt.pix.height); 
    845802                        break; 
    846803 
     
    850807                        cfg->v2.status       |= CAMIF_v4L2_DIRTY; 
    851808                        cfg->v2.status      &= ~CAMIF_v4L2_DIRTY; /* dummy ? */ 
    852  
    853                         sensor_type = SENSOR_VGA; //FIXME original XGA 
     809                        printk("sensor format preview = W: %d, H: %d \n", f->fmt.pix.width, f->fmt.pix.height); 
     810                        sensor_type = SENSOR_VGA; //FIXME original XGA, FIXME DO THE SAME AS ABOVE 
    854811                        break; 
    855812 
     
    864821        cfg->v2.status       |= CAMIF_v4L2_DIRTY; 
    865822        cfg->v2.status      &= ~CAMIF_v4L2_DIRTY; // dummy ? 
    866                          
     823        */               
    867824        // set source 
    868         sensor_type = s3c_camif_get_sensor_format(f->fmt.pix.width, f->fmt.pix.height); 
    869         */ 
     825 
    870826        s3c_camif_change_mode(cfg, sensor_type); 
    871827         
     
    1042998        case V4L2_CID_CAM_JPEG_MAIN_SIZE: 
    1043999                printk("## V4L2_CID_CAM_JPEG_MAIN_SIZE \n"); 
    1044                 //ctrl->value = 4;//state->jpeg.main_size; 
    10451000                err = 0; 
    1046                 //ctrl = (struct v4l2_control *) arg;  
    10471001                ctrl->value = cfg->cis->sensor->driver->command(cfg->cis->sensor, SENSOR_GET_JPEG_SIZE, (void *) arg); 
    1048                 //ctrl->value = 4; 
    10491002                break; 
    10501003 
    10511004        default: 
    1052                 printk("no such ctrl\n"); 
     1005                printk("no such ctrl: %x \n", ctrl->id); 
    10531006                break; 
    10541007        } 
  • modules/camera/s3c_camif.c

    r116 r126  
    338338int s3c_camif_setup_dma(camif_cfg_t *cfg) 
    339339{ 
    340         printk("s3c_camif_setup_dma \n"); 
     340        //printk("s3c_camif_setup_dma \n"); 
    341341        unsigned int width = cfg->target_x; 
    342342        unsigned int val, yburst_m, yburst_r, cburst_m, cburst_r; 
     
    511511static int s3c_camif_input_msdma(camif_cfg_t *cfg) 
    512512{ 
    513         printk("s3c_camif_input_msdma \n"); 
     513        //printk("s3c_camif_input_msdma \n"); 
    514514        if (cfg->input_channel == MSDMA_FROM_PREVIEW) 
    515515                s3c_camif_input_msdma_preview(cfg); 
     
    524524int s3c_camif_input_msdma_codec(camif_cfg_t * cfg) 
    525525{ 
    526         printk("s3c_camif_input_msdma_codec \n"); 
     526        //printk("s3c_camif_input_msdma_codec \n"); 
    527527        int ret = 0; 
    528528        u32 addr_start_Y = 0, addr_start_CB = 0, addr_start_CR = 0; 
     
    602602int s3c_camif_input_msdma_preview(camif_cfg_t * cfg) 
    603603{ 
    604         printk("s3c_camif_input_msdma_preview \n"); 
     604        //printk("s3c_camif_input_msdma_preview \n"); 
    605605        int ret = 0; 
    606606        unsigned int addr_start_Y = 0, addr_start_CB = 0, addr_start_CR = 0; 
     
    680680static int s3c_camif_input_msdma(camif_cfg_t *cfg) 
    681681{ 
    682         printk("s3c_camif_input_msdma \n"); 
     682        //printk("s3c_camif_input_msdma \n"); 
    683683        if (cfg->input_channel == MSDMA_FROM_PREVIEW) 
    684684                s3c_camif_input_msdma_preview(cfg); 
     
    692692static int s3c_camif_input_camera(camif_cfg_t *cfg) 
    693693{ 
    694         printk("s3c_camif_input_camera \n"); 
     694        //printk("s3c_camif_input_camera \n"); 
    695695        unsigned int val; 
    696696 
     
    699699        if (cfg->dma_type & CAMIF_CODEC) 
    700700        { 
    701         printk("s3c_camif_input_camera:CAMIF_CODEC  \n"); 
     701        //printk("s3c_camif_input_camera:CAMIF_CODEC  \n"); 
    702702                #if defined(CONFIG_CPU_S3C6400) || defined(CONFIG_CPU_S3C6410) 
    703703                        val = readl(cfg->regs + S3C_MSCOCTRL); 
     
    708708        else if (cfg->dma_type & CAMIF_PREVIEW) 
    709709        { 
    710         printk("s3c_camif_input_camera:CAMIF_PREVIEW  \n"); 
     710        //printk("s3c_camif_input_camera:CAMIF_PREVIEW  \n"); 
    711711                #if defined(CONFIG_CPU_S3C2443) || defined(CONFIG_CPU_S3C2450) 
    712712                        val = readl(cfg->regs + S3C_CIMSCTRL); 
     
    727727static int s3c_camif_setup_input_path(camif_cfg_t *cfg) 
    728728{ 
    729         printk("s3c_camif_setup_input_path \n"); 
     729        //printk("s3c_camif_setup_input_path \n"); 
    730730        if (cfg->input_channel == CAMERA_INPUT) 
    731731                s3c_camif_input_camera(cfg); 
     
    741741static int s3c_camif_output_pp_codec_rgb(camif_cfg_t *cfg) 
    742742{ 
    743         printk("s3c_camif_output_pp_codec_rgb \n"); 
     743        //printk("s3c_camif_output_pp_codec_rgb \n"); 
    744744        int i; 
    745745        unsigned int val; 
     
    794794static int s3c_camif_output_pp_codec(camif_cfg_t *cfg) 
    795795{ 
    796         printk("s3c_camif_output_pp_codec \n"); 
     796        //printk("s3c_camif_output_pp_codec \n"); 
    797797        unsigned int i, cbcr_size = 0; 
    798798        unsigned int area = cfg->target_x * cfg->target_y; 
     
    952952static int s3c_camif_io_duplex_preview(camif_cfg_t *cfg) 
    953953{ 
    954         printk("s3c_camif_io_duplex_preview \n"); 
     954        //printk("s3c_camif_io_duplex_preview \n"); 
    955955        unsigned int cbcr_size = 0; 
    956956        unsigned int area = cfg->cis->source_x * cfg->cis->source_y; 
     
    10281028static int s3c_camif_output_pp_preview(camif_cfg_t *cfg) 
    10291029{ 
    1030         printk("s3c_camif_output_pp_preview \n"); 
     1030        //printk("s3c_camif_output_pp_preview \n"); 
    10311031        int i; 
    10321032        unsigned int area            = cfg->target_x * cfg->target_y; 
     
    10881088static int s3c_camif_output_pp(camif_cfg_t *cfg) 
    10891089{ 
    1090         printk("s3c_camif_output_pp \n"); 
     1090        //printk("s3c_camif_output_pp \n"); 
    10911091        if (cfg->dma_type & CAMIF_CODEC) 
    10921092                s3c_camif_output_pp_codec(cfg); 
     
    10991099static int s3c_camif_output_lcd(camif_cfg_t *cfg) 
    11001100{ 
    1101         printk("s3c_camif_output_lcd \n"); 
     1101        //printk("s3c_camif_output_lcd \n"); 
    11021102        /* To Be Implemented */ 
    11031103        return 0; 
     
    11061106static int s3c_camif_setup_output_path(camif_cfg_t *cfg) 
    11071107{ 
    1108         printk("s3c_camif_setup_output_path \n"); 
     1108        //printk("s3c_camif_setup_output_path \n"); 
    11091109        if (cfg->output_channel == CAMIF_OUT_FIFO) 
    11101110                s3c_camif_output_lcd(cfg); 
     
    11201120static int s3c_camif_set_target_area(camif_cfg_t *cfg) 
    11211121{ 
    1122         printk("ss3c_camif_set_target_area \n"); 
     1122        //printk("ss3c_camif_set_target_area \n"); 
    11231123        unsigned int rect = cfg->target_x * cfg->target_y; 
    11241124 
     
    11341134static inline int s3c_camif_set_ratio(camif_cfg_t *cfg) 
    11351135{ 
    1136         printk("s3c_camif_set_ratio \n"); 
     1136        //printk("s3c_camif_set_ratio \n"); 
    11371137        unsigned int cmd = (S3C_CICOSCCTRL_CSCR2Y_WIDE | S3C_CICOSCCTRL_CSCY2R_WIDE); 
    11381138 
     
    12921292static int s3c_camif_setup_scaler(camif_cfg_t *cfg) 
    12931293{ 
    1294         printk("s3c_camif_setup_scaler \n"); 
     1294        //printk("s3c_camif_setup_scaler \n"); 
    12951295        int tx = cfg->target_x, ty=cfg->target_y; 
    12961296        int sx, sy; 
     
    13691369int s3c_camif_set_source_format(camif_cis_t *cis) 
    13701370{ 
    1371         printk("s3c_camif_set_source_format \n"); 
     1371        //printk("s3c_camif_set_source_format \n"); 
    13721372        camif_cfg_t *cfg = s3c_camif_get_fimc_object(CODEC_MINOR); 
    13731373        unsigned int cmd = 0; 
     
    14131413                //cmd = CAMIF_YCBYCR;           // + mihee 090725 
    14141414                cmd = (cis->order422 >> 14); //MARC = 2 
    1415                 //cmd = 3;       
    14161415                writel((readl(cfg->regs + S3C_CICOCTRL) & ~(0x3 << 0)) | cmd, cfg->regs + S3C_CICOCTRL); 
    14171416                //writel(cmd, cfg->regs + S3C_CICOCTRL); 
    1418                 printk("##2 ORDERING FOR JPEG cmd = %x \n",cmd); //MARC HERE CE131 CHANGE 
     1417                /*printk("##2 ORDERING FOR JPEG cmd = %x \n",cmd); //MARC HERE CE131 CHANGE 
    14191418                printk(" CISRCFMT = %x \n", readl(cfg->regs + S3C_CISRCFMT)); 
    14201419                printk(" CIGCTRL  = %x \n", readl(cfg->regs + S3C_CIGCTRL)); 
     
    14251424                printk(" CIPRCTRL = %x \n", readl(cfg->regs + S3C_CIPRCTRL)); 
    14261425                printk(" MSCOCTRL = %x \n", readl(cfg->regs + S3C_MSCOCTRL)); 
    1427                 printk(" MSPRCTRL = %x \n", readl(cfg->regs + S3C_MSPRWIDTH + 4)); 
     1426                printk(" MSPRCTRL = %x \n", readl(cfg->regs + S3C_MSPRWIDTH + 4));*/ 
    14281427 
    14291428        } 
     
    14781477static int s3c_camif_set_target_format(camif_cfg_t *cfg) 
    14791478{ 
    1480         printk("s3c_camif_set_target_format \n"); 
     1479        //printk("s3c_camif_set_target_format \n"); 
    14811480        unsigned int cmd = 0; 
    14821481 
     
    15411540int s3c_camif_control_global_capture(camif_cfg_t *cfg,int value) 
    15421541{ 
    1543         printk("CE131:s3c_camif_control_global_capture\n"); 
     1542        //printk("CE131:s3c_camif_control_global_capture\n"); 
    15441543        unsigned int val; 
    15451544 
     
    15551554int s3c_camif_control_fimc(camif_cfg_t *cfg) 
    15561555{ 
    1557         printk("s3c_camif_control_fimc  \n"); 
     1556        //printk("s3c_camif_control_fimc  \n"); 
    15581557        if (s3c_camif_request_memory(cfg)) { 
    15591558                printk(KERN_ERR "Instead of using consistent_alloc(). Let me use dedicated mem for DMA\n"); 
     
    15831582{ 
    15841583        unsigned int n_cmd = readl(cfg->regs + S3C_CIIMGCPT); 
    1585         printk("s3c_camif_start_dma called, cmd= %x \n", n_cmd); 
     1584        //printk("s3c_camif_start_dma called, cmd= %x \n", n_cmd); 
    15861585        unsigned int val; 
    15871586        unsigned int timeout = 300; 
     
    15901589        switch(cfg->capture_enable) { 
    15911590        case CAMIF_BOTH_DMA_ON: 
    1592                 printk("s3c_camif_start_dma:CAMIF_BOTH_DMA_ON \n"); 
     1591                //printk("s3c_camif_start_dma:CAMIF_BOTH_DMA_ON \n"); 
    15931592                s3c_camif_reset(CAMIF_RESET, 0); /* Flush Camera Core Buffer */ 
    15941593 
     
    16131612 
    16141613        case CAMIF_DMA_ON: 
    1615                 printk("s3c_camif_start_dma:CAMIF_DMA_ON \n"); 
     1614                //printk("s3c_camif_start_dma:CAMIF_DMA_ON \n"); 
    16161615                s3c_camif_reset(CAMIF_RESET, 0); /* Flush Camera Core Buffer */ // - mihee 090730 multishot lockup 
    16171616                 
    16181617                if (cfg->dma_type & CAMIF_CODEC) { 
    1619                         printk("s3c_camif_start_dma:CAMIF_DMA_ON : CAMIF_CODEC \n"); 
     1618                        //printk("s3c_camif_start_dma:CAMIF_DMA_ON : CAMIF_CODEC \n"); 
    16201619                        // (091124 / kcoolsw) : for scalerbypass mode 
    16211620                        /* 
     
    16411640 
    16421641                } else { 
    1643                         printk("s3c_camif_start_dma:CAMIF_DMA_ON : else \n"); 
     1642                        //printk("s3c_camif_start_dma:CAMIF_DMA_ON : else \n"); 
    16441643                        val = readl(cfg->regs + S3C_CIPRSCCTRL); 
    16451644                        val |= S3C_CIPRSCCTRL_START; 
     
    16791678        val &= ~(0x7 << 29); 
    16801679        writel(val | n_cmd | S3C_CIIMGCPT_IMGCPTEN, cfg->regs + S3C_CIIMGCPT); 
    1681         printk("s3c_camif_start_dma ended \n"); 
     1680        //printk("s3c_camif_start_dma ended \n"); 
    16821681        return 0; 
    16831682} 
     
    16851684int s3c_camif_stop_dma(camif_cfg_t *cfg) 
    16861685{ 
    1687         printk("s3c_camif_stop_dma \n"); 
     1686        //printk("s3c_camif_stop_dma \n"); 
    16881687        unsigned int n_cmd = readl(cfg->regs + S3C_CIIMGCPT); 
    16891688        unsigned int val; 
     
    17541753int s3c_camif_start_codec_msdma(camif_cfg_t *cfg) 
    17551754{ 
    1756         printk("s3c_camif_start_codec_msdma \n"); 
     1755        //printk("s3c_camif_start_codec_msdma \n"); 
    17571756        int ret = 0; 
    17581757        u32 val; 
     
    17721771int s3c_camif_start_preview_msdma(camif_cfg_t * cfg) 
    17731772{ 
    1774         printk("s3c_camif_start_preview_msdma \n"); 
     1773        //printk("s3c_camif_start_preview_msdma \n"); 
    17751774        unsigned int val; 
    17761775        int ret = 0; 
     
    18791878int s3c_camif_set_offset(camif_cis_t *cis) 
    18801879{ 
    1881         printk("s3c_camif_set_offset \n"); 
     1880        //printk("s3c_camif_set_offset \n"); 
    18821881        camif_cfg_t *cfg = s3c_camif_get_fimc_object(CODEC_MINOR); 
    18831882        unsigned int h = cis->win_hor_ofst;     /* Camera input offset ONLY */ 
     
    19321931void s3c_camif_enable_lastirq(camif_cfg_t *cfg) 
    19331932{ 
    1934         printk("s3c_camif_enable_lastirq \n"); 
     1933        //printk("s3c_camif_enable_lastirq \n"); 
    19351934        unsigned int val; 
    19361935 
     
    19581957void s3c_camif_disable_lastirq(camif_cfg_t *cfg) 
    19591958{ 
    1960         printk("s3c_camif_disable_lastirq \n"); 
     1959        //printk("s3c_camif_disable_lastirq \n"); 
    19611960        unsigned int val; 
    19621961 
     
    20332032{ 
    20342033 
    2035         printk("s3c_camif_set_gpio \n"); 
     2034        //printk("s3c_camif_set_gpio \n"); 
    20362035        s3c_gpio_cfgpin(S3C64XX_GPF(5), S3C_GPIO_SFN(2)); 
    20372036        s3c_gpio_setpull(S3C64XX_GPF(5), S3C_GPIO_PULL_NONE); 
     
    20672066void s3c_camif_reset(int is, int delay) 
    20682067{ 
    2069         printk("s3c_camif_reset \n"); 
     2068        //printk("s3c_camif_reset \n"); 
    20702069        camif_cfg_t *cfg = s3c_camif_get_fimc_object(CODEC_MINOR); 
    20712070        unsigned int val; 
     
    20742073        switch (is) { 
    20752074        case CAMIF_RESET: 
    2076                 printk("case = CAMIF_RESET \n"); 
     2075                //printk("case = CAMIF_RESET \n"); 
    20772076                tmp = readl(cfg->regs + S3C_CISRCFMT); //THE PROBLEM OFFICER 
    2078                 printk(" S3C_CISRCFMT = %x \n", tmp); 
    2079                 printk(" CIGCTRL  = %x \n", readl(cfg->regs + S3C_CIGCTRL)); 
     2077                //printk(" S3C_CISRCFMT = %x \n", tmp); 
     2078                //printk(" CIGCTRL  = %x \n", readl(cfg->regs + S3C_CIGCTRL)); 
    20802079                // (091124 / kcoolsw) : for continuous zooming 
    20812080                //if (tmp &= (1 << 31)) { 
     
    21072106                } else { 
    21082107                        // ITU-R BT 656 
    2109                         printk("ITU-R BT 656 \n"); 
     2108                        //printk("ITU-R BT 656 \n"); 
    21102109                        tmp = readl(cfg->regs + S3C_CISRCFMT); 
    21112110                        tmp |= (1 << 31); 
     
    21302129                        writel(tmp, cfg->regs + S3C_CISRCFMT); 
    21312130                } 
    2132                 printk(" finished s3c_cam reset \n"); 
     2131                //printk(" finished s3c_cam reset \n"); 
    21332132                break; 
    21342133 
     
    21772176void s3c_camif_init(void) 
    21782177{ 
    2179         printk("s3c_camif_init \n"); 
     2178        //printk("s3c_camif_init \n"); 
    21802179        s3c_camif_reset(CAMIF_RESET, 0); 
    21812180        s3c_camif_set_gpio(); 
  • modules/camera/samsung/ce131.c

    r116 r126  
    132132#define CMD_CHECK_AUTO_FOCUS_SEARCH     0x24 
    133133#define CMD_FW_STATUS                   0xF5 //CHECKED, not implemented yet --> for firmware update 
    134 #define CMD_GET_STROBE_RESULT           0xBD //NOT in CE147 FIXME 
     134#define CMD_GET_STROBE_RESULT           0xBD //NOT in CE131 FIXME 
    135135#define CMD_JPEG_CONFIG                 0x90 
    136136#define CMD_JPEG_BUFFERING              0x8F 
     
    184184} ;  
    185185 
     186enum ce131_oprmode { 
     187        CE131_OPRMODE_VIDEO = 0, 
     188        CE131_OPRMODE_IMAGE = 1, 
     189}; 
     190 
     191enum ce131_frame_size { 
     192        CE131_PREVIEW_QCIF = 0, 
     193        CE131_PREVIEW_QVGA, 
     194        CE131_PREVIEW_592x480, 
     195        CE131_PREVIEW_VGA, 
     196        CE131_PREVIEW_D1, 
     197        CE131_PREVIEW_WVGA, 
     198        CE131_PREVIEW_720P, 
     199        CE131_PREVIEW_VERTICAL_QCIF, 
     200        //CE131_CAPTURE_VGA, /* 640 x 480 */     
     201        CE131_CAPTURE_WVGA, /* 800 x 480 */ 
     202        CE131_CAPTURE_W1MP, /* 1600 x 960 */ 
     203        //CE131_CAPTURE_2MP, /* UXGA  - 1600 x 1200 */ 
     204        CE131_CAPTURE_W2MP, /* 35mm Academy Offset Standard 1.66  - 2048 x 1232, 2.4MP */        
     205        //CE131_CAPTURE_3MP, /* QXGA  - 2048 x 1536 */ 
     206        CE131_CAPTURE_W4MP, /* WQXGA - 2560 x 1536 */ 
     207        //CE131_CAPTURE_5MP, /* 2560 x 1920 */ 
     208}; 
     209 
     210#define CE131_CAPTURE_5MP SENSOR_QSXGA 
     211#define CE131_CAPTURE_3MP SENSOR_QXGA 
     212#define CE131_CAPTURE_2MP SENSOR_UXGA 
     213#define CE131_CAPTURE_VGA SENSOR_VGA 
     214 
     215 
     216struct ce131_enum_framesize { 
     217        /* mode is 0 for preview, 1 for capture */ 
     218        enum ce131_oprmode mode; 
     219        unsigned int index; 
     220        unsigned int width; 
     221        unsigned int height;     
     222}; 
     223 
     224static struct ce131_enum_framesize ce131_framesize_list[] = { 
     225        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_QCIF,       176,  144 }, 
     226        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_QVGA,       320,  240 }, 
     227        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_592x480,    592,  480 }, 
     228        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_VGA,                640,  480 }, 
     229        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_D1,         720,  480 }, 
     230        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_WVGA,       800,  480 }, 
     231        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_720P,      1280,  720 }, 
     232        { CE131_OPRMODE_VIDEO, CE131_PREVIEW_VERTICAL_QCIF,     144,    176}, 
     233        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_VGA,                640,  480 }, 
     234        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_WVGA,               800,  480 }, 
     235        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_W1MP,      1600,  960 }, 
     236        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_2MP,       1600, 1200 }, 
     237        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_W2MP,              2048, 1232 }, 
     238        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_3MP,       2048, 1536 }, 
     239        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_W4MP,      2560, 1536 }, 
     240        { CE131_OPRMODE_IMAGE, CE131_CAPTURE_5MP,       2560, 1920 }, 
     241}; 
     242 
     243 
     244 
    186245enum ce131_runmode { 
    187246        CE131_RUNMODE_NOTREADY, 
     
    189248        CE131_RUNMODE_READY, 
    190249        CE131_RUNMODE_RUNNING,  
     250        CE131_RUNMODE_CAPTURE,  
    191251}; 
    192252 
     
    196256        enum ce131_runmode runmode; 
    197257        int flash; 
     258        int fps; 
     259        int iso; 
     260        int preview_size; 
     261        int framesize_index; 
     262        int saturation; 
     263        int sharpness; 
     264        int af; 
     265        int contrast; 
     266        int metering; 
     267        int brightness; 
     268        int whitebalance; 
     269        int effect; 
    198270}; 
    199271 
     
    655727        unsigned int ce131_reglen_preview_size = 3;  
    656728 
    657 /*      switch(type){ 
     729        struct ce131_state *state = to_state(client); 
     730 
     731        switch(state->preview_size){ 
    658732                case CE131_PREVIEW_VGA: 
    659                         ce131_regbuf_preview_size[1] = 0x08; 
     733                        ce131_regbuf_preview_size[0] = 0x08; 
    660734                        break; 
    661735                case CE131_PREVIEW_WVGA: 
    662736                        ce131_regbuf_preview_size[0] = 0x10; 
    663737                        break; 
    664                 case CE131_PREVIEW_UNKNOWN: 
     738                /*case CE131_PREVIEW_UNKNOWN: 
    665739                        ce131_regbuf_preview_size[0] = 0x0d; 
    666740                        break; 
     
    670744                case CE131_PREVIEW_UNKNOWN3: 
    671745                        ce131_regbuf_preview_size[0] = 0x06; 
    672                         break;  
     746                        break; */ 
    673747                default: 
    674                         ce131_regbuf_preview_size[1] = 0x08; 
    675                         ce131_msg(&client->dev, "Setting preview resoution as VGA for image capture mode\n"); 
    676                         break; 
    677         } 
    678  
    679 */ 
    680  
     748                        ce131_regbuf_preview_size[0] = 0x08; 
     749                        printk("Setting preview resolution as VGA for image capture mode, send: %x \n", state->preview_size ); 
     750                        break; 
     751        } 
    681752 
    682753        err = ce131_i2c_write_multi(client, CMD_PREVIEW_SIZE, ce131_regbuf_preview_size, ce131_reglen_preview_size); 
     
    685756                return -EIO; 
    686757        } 
    687  
    688  
    689758        return 0; 
    690759} 
     
    800869        unsigned int ce131_reglen_capture_size = 4; 
    801870 
    802         //struct ce131_state *state = to_state(client); 
    803  
    804         /*int index = state->framesize_index; 
    805  
     871        struct ce131_state *state = to_state(client); 
     872 
     873        int index = state->framesize_index; 
     874        printk("CE131: set capture size: "); 
    806875        switch(index){ 
    807876        case CE131_CAPTURE_VGA: // 640x480  
    808877                ce131_regbuf_capture_size[0] = 0x08; 
    809                 break; 
    810         case CE131_CAPTURE_SVGA: // 800x600  
    811                 ce131_regbuf_capture_size[0] = 0x09; 
    812                 break; 
     878                printk("VGA \n"); 
     879                break; 
     880        //case CE131_CAPTURE_SVGA: // 800x600  
     881        //      ce131_regbuf_capture_size[0] = 0x09; 
     882        //      break; 
    813883        case CE131_CAPTURE_WVGA: // 800x480  
    814884                ce131_regbuf_capture_size[0] = 0x10; 
     885                printk("WVGA \n"); 
    815886                break; 
    816887        case CE131_CAPTURE_W1MP: // 1280x768  
    817888                ce131_regbuf_capture_size[0] = 0x11; 
     889                printk("W1 \n"); 
    818890                break;   
    819         case CE131_CAPTURE_1MP: // 1280x960  
    820                 ce131_regbuf_capture_size[0] = 0x12; 
    821                 break; 
     891        //case CE131_CAPTURE_1MP: // 1280x960  
     892        //      ce131_regbuf_capture_size[0] = 0x12; 
     893        //      break; 
    822894        case CE131_CAPTURE_2MP: // 1600x1200  
    823895                ce131_regbuf_capture_size[0] = 0x0C; 
     896                printk("2m \n"); 
    824897                break; 
    825898        case CE131_CAPTURE_W2MP: //2048x960 
    826899                ce131_regbuf_capture_size[0] = 0x12; 
     900                printk("w2m\n"); 
    827901                break; 
    828902        case CE131_CAPTURE_3MP: // 2048x1536  
     903                //ce131_regbuf_capture_size[0] = 0x0F;//0x0D;  
    829904                ce131_regbuf_capture_size[0] = 0x0D;  
    830                 break; 
    831         case CE131_CAPTURE_4MP: //2560x1440 
    832                 ("NOT IMPLEMENTED \n"); 
    833                 break; 
     905                printk("3m \n"); 
     906                break; 
     907        //case CE131_CAPTURE_4MP: //2560x1440 
     908        //      ("NOT IMPLEMENTED \n"); 
     909        //      break; 
    834910        case CE131_CAPTURE_W4MP: //2560x1536  
     911                printk("4m \n"); 
    835912                ce131_regbuf_capture_size[0] = 0x14; 
    836913                break; 
    837914        case CE131_CAPTURE_5MP: // 2560x1920  
     915                printk("5m \n"); 
    838916                ce131_regbuf_capture_size[0] = 0x0F; 
    839917                break; 
    840918        default: 
    841919                printk("Default 3MP is set \n"); 
    842                 return -EINVAL; 
    843         } 
    844 */ 
     920                ce131_regbuf_capture_size[0] = 0x0D;  
     921        } 
     922 
    845923        // Set capture image size  
    846924        err = ce131_i2c_write_multi(client, CMD_CAPTURE_SIZE, ce131_regbuf_capture_size, ce131_reglen_capture_size); 
     
    851929 
    852930 
    853         //printk("ce131set_capture_size: 0x%02x\n", index); 
     931        printk("CE131: set_capture_size: 0x%02x\n", index); 
    854932 
    855933        return 0;        
     
    862940        unsigned char ce131_regbuf_fps[2] = { 0x1e, 0x00 };  
    863941        unsigned int ce131_reglen_fps = 2; 
    864          
    865 /* 
     942        struct ce131_state *state = to_state(client); 
     943 
    866944        switch(state->fps) 
    867945        { 
     
    891969                break; 
    892970        } 
    893 */ 
     971 
    894972        err = ce131_i2c_write_multi(client, CMD_FPS, ce131_regbuf_fps, ce131_reglen_fps); 
    895973        if(err < 0){ 
     
    11101188 
    11111189                default: 
    1112                         ce131_buf_set_flash[1] = 0x00; 
     1190                        ce131_buf_set_flash[1] = 0x02; //standard AUTO 
    11131191 
    11141192                break; 
     
    12081286                        printk("WHITE_BALANCE_default \n"); 
    12091287                        dev_err(&client->dev, "%s: failed: to set_white_balance, enum: %d\n", __func__, ctrl->value); 
    1210                         return -EINVAL; 
     1288                        ce131_buf_set_wb_auto[0] = 0x00; 
    12111289                break; 
    12121290        } 
     
    13721450                default: 
    13731451                        dev_err(&client->dev, "%s: failed: to set_iso, enum: %d\n", __func__, ctrl->value); 
    1374                         return -EINVAL; 
     1452                        ce131_buf_set_iso[0] = 0x06; 
    13751453                break; 
    13761454        } 
     
    14741552/* Not sure what this routine does yet, at least not very important 
    14751553        #define CMD_DATA_CHECK 0x61 
    1476         // 0x61 WINMO loc_1001A474 NOT IN CE147  
     1554        // 0x61 WINMO loc_1001A474 NOT IN CE131  
    14771555                cmd_buf_setdata[0] = 0x01; //WINMO 
    14781556        err = ce131_i2c_read_multi(client, CMD_DATA_CHECK, cmd_buf_setdata, cmd_len_framesize, jpeg_status, jpeg_status_len); 
     
    16391717                dev_err(&client->dev, "%s: failed: i2c_write for set_SHARPNESS\n", __func__); 
    16401718                return -EIO; 
     1719        } 
     1720 
     1721        err = ce131_get_batch_reflection_status(client); 
     1722        if(err < 0){ 
     1723                dev_err(&client->dev, "%s: failed: ce131_get_batch_reflection_status \n", __func__); 
     1724                return -EIO;  
    16411725        } 
    16421726 
     
    16681752 
    16691753                default: 
    1670                         dev_err(&client->dev, "%s: failed: to set_photometry\n"); 
    1671                         return -EINVAL; 
     1754                        printk("set_photometry ->default\n"); 
     1755                        ce131_buf_set_metering[0] = 0x00; 
    16721756                break; 
    16731757        } 
     
    17051789        { 
    17061790                case 0: //RELEASE 
    1707                         printk("AF Release choosen ? \n"); 
    1708                         /*err = ce131_i2c_write_multi(client, CMD_STOP_LENS_MOVEMENT, ce131_buf_set_af, ce131_len_set_af); 
    1709                         if(err < 0){ 
    1710                                 dev_err(&client->dev, "%s: failed: i2c_write for auto_focus\n", __func__); 
    1711                         return -EIO;*/ 
    1712                 break; 
    1713  
     1791                        printk("RELEASE AF choosen ? \n"); 
     1792                        ret = 1; 
     1793                break; 
    17141794                case 1: //SINGLE 
    17151795                        printk("SINGLE AF choosen ? \n"); 
    1716                 break; 
    1717  
     1796                        ret = 1; 
     1797                break; 
    17181798                case 2: //AUTO 
    17191799                        printk("AUTO AF choosen ? \n"); 
     1800                        ce131_buf_set_af[0] =  0x00 ; 
    17201801                        err = ce131_i2c_write_multi(client, CMD_START_AUTO_FOCUS_SEARCH, ce131_buf_set_af, ce131_len_set_af); 
    17211802                        if(err < 0){ 
     
    17351816                                if(ce131_buf_get_af_status[0] == 0x00 || ce131_buf_get_af_status[0] == 0x02) break; 
    17361817                        }        
     1818 
     1819                        /*err = ce131_i2c_write_multi(client, CMD_SET_AUTO_FOCUS_MODE, 0x1, 0x1); //HAVE TO CHECK WHERE TO PUT 
     1820                        if(err < 0){ 
     1821                                dev_err(&client->dev, "%s: failed: i2c_write for auto_focus\n", __func__); 
     1822                                return -EIO; 
     1823                        }*/      
    17371824                 
    17381825                        if(ce131_buf_get_af_status[0] == 0x00) 
     
    17511838                        } 
    17521839                        break; 
    1753  
    17541840                case 3: //INFINITY 
    1755                         printk("Infinity AF choosen ? \n"); 
    1756                 break; 
    1757  
     1841                        printk("INFINITY choosen ? \n"); 
     1842                        ret = 1; 
     1843                        break; 
    17581844                case 4: //MACRO 
     1845                case 5: //FIXED 
    17591846                        printk("MACRO AF choosen ? \n"); 
    1760                 break; 
    1761  
    1762                 case 5: //FIXED 
    1763                         printk("Fixed AF choosen ? \n"); 
    1764                 break; 
     1847                        ce131_buf_set_af[0] =  0x01 ; 
     1848                        err = ce131_i2c_write_multi(client, CMD_START_AUTO_FOCUS_SEARCH, ce131_buf_set_af, ce131_len_set_af); 
     1849                        if(err < 0){ 
     1850                                dev_err(&client->dev, "%s: failed: i2c_write for auto_focus\n", __func__); 
     1851                        return -EIO; 
     1852 
     1853                        for(count = 0; count < 600; count++) 
     1854                        { 
     1855                                msleep(10); 
     1856                                ce131_buf_get_af_status[0] = 0xFF; 
     1857                                err = ce131_i2c_read_multi(client, CMD_CHECK_AUTO_FOCUS_SEARCH, NULL, 0, ce131_buf_get_af_status, 1); 
     1858                                if(err < 0){ 
     1859                                        dev_err(&client->dev, "%s: failed: i2c_read for auto_focus\n", __func__); 
     1860                                        return -EIO; 
     1861                                } 
     1862                                if(ce131_buf_get_af_status[0] == 0x05) continue; 
     1863                                if(ce131_buf_get_af_status[0] == 0x00 || ce131_buf_get_af_status[0] == 0x02) break; 
     1864                        }        
     1865 
     1866                        /*err = ce131_i2c_write_multi(client, CMD_SET_AUTO_FOCUS_MODE, 0x1, 0x1); //NEW!! 
     1867                        if(err < 0){ 
     1868                                dev_err(&client->dev, "%s: failed: i2c_write for auto_focus\n", __func__); 
     1869                                return -EIO; 
     1870                        }*/      
     1871                 
     1872                        if(ce131_buf_get_af_status[0] == 0x00) 
     1873                        { 
     1874                                if(err < 0){ 
     1875                                        dev_err(&client->dev, "%s: failed: AF is failed\n", __func__); 
     1876                                        return -EIO; 
     1877                                } 
     1878                                ret =0; 
     1879                        } 
     1880                        else  
     1881                                ret = 1; 
     1882 
     1883                        ce131_msg(&client->dev, "%s: done\n", __func__); 
     1884 
     1885                        } 
     1886                        break; 
     1887                break; 
     1888 
    17651889 
    17661890                default: 
     
    19592083                default: 
    19602084                        dev_err(&client->dev, "%s: failed: to set_ev, enum: %d\n", __func__, ctrl->value); 
    1961                         return -EINVAL; 
     2085                        ce131_buf_set_ev[0] = 0x06; 
    19622086                break; 
    19632087        } 
     
    20302154 
    20312155 
    2032                 ctrl.value = METERING_MATRIX; 
     2156                ctrl.value = state->metering; 
    20332157                err = ce131_set_metering(client, &ctrl); 
    20342158                if(err < 0){ 
    2035                         dev_err(&client->dev, "%s: failed: Could not set anti banding\n", __func__); 
     2159                        dev_err(&client->dev, "%s: failed: Could not set metering\n", __func__); 
    20362160                return -EIO; 
    20372161                } 
    20382162 
    2039                 ctrl.value = ISO_AUTO; 
     2163                ctrl.value = state->iso; 
    20402164                err = ce131_set_iso(client, &ctrl); 
    20412165                if(err < 0){ 
     
    20502174                } 
    20512175 
    2052                 ctrl.value = ANTI_SHAKE_OFF; 
     2176                ctrl.value = ANTI_SHAKE_STILL_ON; //STANDARD ON 
    20532177                err = ce131_set_anti_shake(client, &ctrl); 
    20542178                if(err < 0){ 
     
    20712195                err = ce131_set_capture_size(client);  
    20722196                if(err < 0){ 
    2073                         dev_err(&client->dev, "%s: failed: Could not set fps\n", __func__); 
     2197                        dev_err(&client->dev, "%s: failed: Could not set capture size\n", __func__); 
    20742198                        return -EIO; 
    20752199                } 
     
    21052229                } 
    21062230 
     2231                //ctrl.value = //state->af; 
     2232                err = ce131_set_auto_focus(client, 2); //NEW, is this better? 
     2233                if(err < 0){ 
     2234                        dev_err(&client->dev, "%s: failed: Settings AF\n", __func__); 
     2235                return -EIO; 
     2236                } 
     2237 
    21072238                state->runmode = CE131_RUNMODE_RUNNING; 
    21082239        } 
     
    21112242 
    21122243                printk("#-> Capture \n"); 
     2244                printk("runmode = %x \n", state->runmode); 
     2245                //state->runmode = CE131_RUNMODE_CAPTURE; 
    21132246 
    21142247                err = ce131_set_capture_size(client); //--> without same idea 
     
    21232256                return -EIO; 
    21242257                } 
     2258 
     2259                //ctrl.value = state->af; --> NOT WORKING, HERE 
     2260/*              err = ce131_set_auto_focus(client, 2); //NEW, is this better?, DISABLE HW_AF IN ANDROID! 
     2261                if(err < 0){ 
     2262                        dev_err(&client->dev, "%s: failed: Settings AF\n", __func__); 
     2263                return -EIO; 
     2264                }*/ 
    21252265 
    21262266                ctrl.value = 0; 
     
    21512291                        return -EIO; 
    21522292                } 
    2153  
     2293                 
     2294                //state->runmode = CE131_RUNMODE_RUNNING; 
     2295                printk("runmode = %x \n", state->runmode); 
    21542296        } 
    21552297        else if (type & SENSOR_CAMCORDER ) 
     
    21932335                        printk("SENSOR_EFFECT\n"); 
    21942336                        ctrl = (struct v4l2_control *)arg; 
    2195                         ret = ce131_set_effect(client, ctrl); 
     2337                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2338                        { 
     2339                                state->effect = ctrl->value; 
     2340                                ret = 0; 
     2341                        } 
     2342                        else 
     2343                        { 
     2344                                ret = ce131_set_effect(client, ctrl); 
     2345                        } 
    21962346                        break; 
    21972347 
     
    21992349                        printk("SENSOR_BRIGHTNESS\n"); 
    22002350                        ctrl = (struct v4l2_control *)arg; 
    2201                         ret = ce131_set_ev(client, ctrl); 
     2351                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2352                        { 
     2353                                state->brightness = ctrl->value; 
     2354                                ret = 0; 
     2355                        } 
     2356                        else 
     2357                        { 
     2358                                ret = ce131_set_ev(client, ctrl); 
     2359                        } 
    22022360                        break; 
    22032361 
    22042362                case SENSOR_WB: 
    22052363                        ctrl = (struct v4l2_control *)arg; 
    2206                         ret = ce131_set_white_balance(client, ctrl); 
     2364                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2365                        { 
     2366                                state->whitebalance = ctrl->value; 
     2367                                ret = 0; 
     2368                        } 
     2369                        else 
     2370                        { 
     2371                                ret = ce131_set_white_balance(client, ctrl); 
     2372                        } 
    22072373                        break; 
    22082374 
     
    22142380                        printk("SENSOR_PHOTOMETRY\n"); 
    22152381                        ctrl = (struct v4l2_control *)arg; 
    2216                         ret = ce131_set_metering(client, ctrl); 
     2382                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2383                        { 
     2384                                state->metering = ctrl->value; 
     2385                                ret = 0; 
     2386                        } 
     2387                        else 
     2388                        { 
     2389                                ret = ce131_set_metering(client, ctrl); 
     2390                        } 
    22172391                        break; 
    22182392 
     
    22202394                        printk("SENSOR_ISO \n"); 
    22212395                        ctrl = (struct v4l2_control *)arg; 
    2222                         ret = ce131_set_iso(client, ctrl); 
     2396                        //ret = ce131_set_iso(client, ctrl); //HAVE TO BE CHANGED INTO  
     2397                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2398                        { 
     2399                                state->iso = ctrl->value; 
     2400                                ret = 0; 
     2401                        } 
     2402                        else 
     2403                        { 
     2404                                ret = ce131_set_iso(client, ctrl); 
     2405                        } 
    22232406                        break; 
    22242407 
     
    22262409                        printk("SENSOR_CONTRAST \n"); 
    22272410                        ctrl = (struct v4l2_control *)arg; 
    2228                         ret = ce131_set_contrast(client, ctrl); 
     2411                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2412                        { 
     2413                                state->contrast = ctrl->value; 
     2414                                ret = 0; 
     2415                        } 
     2416                        else 
     2417                        { 
     2418                                ret = ce131_set_contrast(client, ctrl); 
     2419                        } 
    22292420                        break; 
    22302421 
     
    22322423                        printk("SENSOR_SATURATION \n"); 
    22332424                        ctrl = (struct v4l2_control *)arg; 
    2234                         ret = ce131_set_saturation(client, ctrl); 
     2425                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2426                        { 
     2427                                state->saturation = ctrl->value; 
     2428                                ret = 0; 
     2429                        } 
     2430                        else 
     2431                        { 
     2432                                ret = ce131_set_saturation(client, ctrl); 
     2433                        } 
    22352434                        break; 
    22362435 
     
    22382437                        printk("SENSOR_SHARPNESS \n"); 
    22392438                        ctrl = (struct v4l2_control *)arg; 
    2240                         ret = ce131_set_sharpness(client, ctrl); 
     2439                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2440                        { 
     2441                                state->sharpness = ctrl->value; 
     2442                                ret = 0; 
     2443                        } 
     2444                        else 
     2445                        { 
     2446                                ret = ce131_set_sharpness(client, ctrl); 
     2447                        } 
    22412448                        break; 
    22422449 
     
    22442451                        printk("SENSOR_AF \n"); 
    22452452                        ctrl = (struct v4l2_control *)arg; 
    2246                         ret = ce131_set_auto_focus(client, ctrl->value); 
     2453                        if(state->runmode != CE131_RUNMODE_RUNNING) 
     2454                        { 
     2455                                state->af = ctrl->value; 
     2456                                ret = 0; 
     2457                        } 
     2458                        else 
     2459                        { 
     2460                                ret = ce131_set_auto_focus(client, ctrl->value); 
     2461                        } 
    22472462                        break; 
    22482463 
     
    22522467                        ce131_sensor_mode_set(client, ctrl->value); 
    22532468                        break; 
    2254  
     2469/* REMOVE ASAP 
    22552470                case SENSOR_XGA: 
    22562471                        printk("SENSOR_xga \n"); 
     
    22882503                        printk("SENSOR_USER_READ \n"); 
    22892504                        break; 
    2290          
     2505        */ 
    22912506                case SENSOR_FLASH_CAMERA: 
    22922507                        printk("SENSOR_FLASH_CAMERA \n");        
     
    23092524                        break; 
    23102525                case SENSOR_FIX_FRAMERATE: 
    2311                         printk("SENSOR_FIX_FRAMERATE \n");       
     2526                        printk("SENSOR_FIX_FRAMERATE \n"); 
     2527                        state->fps = ctrl->value; //TODO                 
    23122528                        break; 
    23132529                case SENSOR_SET_CAPTURE_SIZE: 
    2314                         printk("SENSOR_SET_CAPTURE_SIZE \n");    
     2530                        ctrl = (struct v4l2_control *)arg; 
     2531                        printk("SENSOR_SET_CAPTURE_SIZE: %x \n", ctrl); 
     2532                        state->framesize_index = ctrl; //TODO   FOR NOW LIKE THIS OTHERWISE LOCK UP 
    23152533                        break; 
    23162534                case SENSOR_GET_JPEG_SIZE: 
     
    23202538                case SENSOR_SET_PREVIEW_SIZE: 
    23212539                        printk("SENSOR_SET_PREVIEW_SIZE \n");    
     2540                        state->preview_size = ctrl->value; //TODO NOT IMPLEMENTED IN ANDROID YET         
    23222541                        break; 
    23232542                case SENSOR_SET_JPEG_QUAL: 
     
    23272546                        ctrl = (struct v4l2_control *)arg; 
    23282547                        printk("SENSOR_DIG_ZOOM \n"); 
    2329                         ret =ce131_set_dzoom(client, ctrl);              
     2548                        ret =ce131_set_dzoom(client, ctrl);     //NOT USED IN ANDROID    
    23302549                        break; 
    23312550                case SENSOR_WDR: 
    23322551                        printk("SENSOR_WDR \n"); 
    23332552                        ctrl = (struct v4l2_control *)arg; 
    2334                         ret = ce131_set_wdr(client, ctrl); 
     2553                        ret = ce131_set_wdr(client, ctrl); //NOT USED IN ANDROID 
    23352554                        break; 
    23362555                case SENSOR_FW_UPDATE: 
    2337                         printk("SENSOR_FW_UPDATE \n");   
     2556                        printk("CE131 SENSOR_FW_UPDATE -> NOT IMPLEMENTED \n");  
    23382557                        break; 
    23392558 
  • modules/camera/samsung/videodev2_samsung.h

    r109 r126  
    194194        WHITE_BALANCE_BASE = 0, 
    195195        WHITE_BALANCE_AUTO, 
     196        WHITE_BALANCE_CLOUDY, 
    196197        WHITE_BALANCE_SUNNY, 
    197         WHITE_BALANCE_CLOUDY, 
     198        WHITE_BALANCE_FLUORESCENT, 
    198199        WHITE_BALANCE_TUNGSTEN, 
    199         WHITE_BALANCE_FLUORESCENT, 
    200200        WHITE_BALANCE_MAX, 
    201201}; 
     
    205205        IMAGE_EFFECT_BASE = 0, 
    206206        IMAGE_EFFECT_NONE, 
     207        IMAGE_EFFECT_AQUA, 
    207208        IMAGE_EFFECT_BNW, 
     209        IMAGE_EFFECT_NEGATIVE, 
    208210        IMAGE_EFFECT_SEPIA, 
    209         IMAGE_EFFECT_AQUA, 
    210211        IMAGE_EFFECT_ANTIQUE, 
    211         IMAGE_EFFECT_NEGATIVE, 
    212212        IMAGE_EFFECT_SHARPEN, 
    213213        IMAGE_EFFECT_MAX, 
     
    429429enum v4l2_frame_rate { 
    430430        FRAME_RATE_AUTO = 0, 
    431         FRAME_RATE_7 = 7,                
     431        FRAME_RATE_7 = 7,        
     432        FRAME_RATE_14 = 14,      
    432433        FRAME_RATE_15 = 15, 
    433434        FRAME_RATE_30 = 30, 
Note: See TracChangeset for help on using the changeset viewer.