ov7725.c

ov7725寄存器配置

    gpio_i2c_write(I2C_OV7725, 0x90, 0x05);
    gpio_i2c_write(I2C_OV7725, 0x91, 0x01);
    gpio_i2c_write(I2C_OV7725, 0x92, 0x03);
    gpio_i2c_write(I2C_OV7725, 0x93, 0x00);

    gpio_i2c_write(I2C_OV7725, 0x94, 0xb0);
    gpio_i2c_write(I2C_OV7725, 0x95, 0x9d);
    gpio_i2c_write(I2C_OV7725, 0x96, 0x13);
    gpio_i2c_write(I2C_OV7725, 0x97, 0x16);
    gpio_i2c_write(I2C_OV7725, 0x98, 0x7b);
    gpio_i2c_write(I2C_OV7725, 0x99, 0x91);
    gpio_i2c_write(I2C_OV7725, 0x9a, 0x1e);
    
    gpio_i2c_write(I2C_OV7725, 0x9b, 0x00);
    gpio_i2c_write(I2C_OV7725, 0x9c, 0x25);
    gpio_i2c_write(I2C_OV7725, 0x9e, 0x81);    
    gpio_i2c_write(I2C_OV7725, 0xa6, 0x06);
    
//modified saturation initialization value by pw 2008-03-04
    gpio_i2c_write(I2C_OV7725, 0xa7, 0x65);
    gpio_i2c_write(I2C_OV7725, 0xa8, 0x65);
    
    gpio_i2c_write(I2C_OV7725, 0x7e, 0x0c);
    gpio_i2c_write(I2C_OV7725, 0x7f, 0x16);
    gpio_i2c_write(I2C_OV7725, 0x80, 0x2a);
    gpio_i2c_write(I2C_OV7725, 0x81, 0x4e);
    gpio_i2c_write(I2C_OV7725, 0x82, 0x61);
    gpio_i2c_write(I2C_OV7725, 0x83, 0x6f);
    gpio_i2c_write(I2C_OV7725, 0x84, 0x7b);
    gpio_i2c_write(I2C_OV7725, 0x85, 0x86);
    gpio_i2c_write(I2C_OV7725, 0x86, 0x8e);    
    gpio_i2c_write(I2C_OV7725, 0x87, 0x97);
    gpio_i2c_write(I2C_OV7725, 0x88, 0xa4);
    gpio_i2c_write(I2C_OV7725, 0x89, 0xaf);
    gpio_i2c_write(I2C_OV7725, 0x8a, 0xc5);
    gpio_i2c_write(I2C_OV7725, 0x8b, 0xd7);
    gpio_i2c_write(I2C_OV7725, 0x8c, 0xe8);
    gpio_i2c_write(I2C_OV7725, 0x8d, 0x20);
#if 0 
    gpio_i2c_write(I2C_OV7725, 0x34, 0x00);
    gpio_i2c_write(I2C_OV7725, 0x33, 0x40);
    gpio_i2c_write(I2C_OV7725, 0x22, 0x99);
    gpio_i2c_write(I2C_OV7725, 0x23, 0x03);
    gpio_i2c_write(I2C_OV7725, 0x4a, 0x10);
    gpio_i2c_write(I2C_OV7725, 0x49, 0x10);
    gpio_i2c_write(I2C_OV7725, 0x4b, 0x14);
    gpio_i2c_write(I2C_OV7725, 0x4c, 0x17);
    gpio_i2c_write(I2C_OV7725, 0x46, 0x05);
    gpio_i2c_write(I2C_OV7725, 0x0e, 0x65);
#endif    
    gpio_i2c_write(I2C_OV7725, 0x69, 0x5d);	
    gpio_i2c_write(I2C_OV7725, 0x0c, 0x00);

    gpio_i2c_write(I2C_OV7725, 0x33, 0xfb);//0x66/0x99
    gpio_i2c_write(I2C_OV7725, 0x0e, 0x65);

//sharpness strength modified by pw 2008-03-05
    regvalue = gpio_sccb_read(I2C_OV7725, 0xac);
    gpio_i2c_write(I2C_OV7725, 0xac, 0xdf&regvalue);
    gpio_i2c_write(I2C_OV7725, 0x8f, 0x04);
} 
}

void ov7725_vga_ioctl(void)
{
    if(powerfreq == DC_VAL_50HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0x00);
    	
    }
    else if(powerfreq == DC_VAL_60HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0xff);
    }
    gpio_i2c_write(I2C_OV7725, 0x29, 0xa0);
    gpio_i2c_write(I2C_OV7725, 0x2c, 0xf0);
    gpio_i2c_write(I2C_OV7725, 0x65, 0x20);

}
	
void  ov7725_qvga_ioctl(void)
   {
		 	
    if(powerfreq == DC_VAL_50HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0x00);
    	
    }
    else if(powerfreq == DC_VAL_60HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0xff);
    }
    gpio_i2c_write(I2C_OV7725, 0x29, 0x50);
    gpio_i2c_write(I2C_OV7725, 0x2c, 0x78);
    gpio_i2c_write(I2C_OV7725, 0x65, 0x20);
   }
   
void  ov7725_qqvga_ioctl(void)
{
		 	
    if(powerfreq == DC_VAL_50HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0x00);
    	
    }
    else if(powerfreq == DC_VAL_60HZ)
    {
    	gpio_i2c_write(I2C_OV7725, 0x2b, 0xff);
    }
    gpio_i2c_write(I2C_OV7725, 0x29, 0x25);
    gpio_i2c_write(I2C_OV7725, 0x2c, 0x39);
    gpio_i2c_write(I2C_OV7725, 0x65, 0x20);
}
/*
 * ov7725 open routine. 
 * do nothing.
 *
 */
 
int ov7725_open(struct inode * inode, struct file * file)
{

    return 0;
}

/*
 * ov7725 close routine. 
 * do nothing.
 *
 */
 
int ov7725_close(struct inode * inode, struct file * file)
{

    return 0;
}

#define REG_DIRECT_OPR 0x8000
#define is_directreg_opt(cmd) ((cmd & REG_DIRECT_OPR) == REG_DIRECT_OPR)
int ov7725_ioctl_reg(unsigned int oprcmd, unsigned long arg)
{
    void __user *argp = (void __user *)arg;

    #define REG_OPR_READ_MASK  0x8000 
    #define REG_OPR_WRITE_MASK 0xC000
    #define REG_ADDR_MASK      0x00FF
    
    unsigned int regaddr = 0;
    unsigned int regvalue = 0;
    
    unsigned int val     = 0;
    
        
    if ((oprcmd & REG_DIRECT_OPR) == 0)
    {

        return -1;
    }
    
    regaddr = oprcmd & REG_ADDR_MASK;
    
    if ( (oprcmd & REG_OPR_WRITE_MASK) == REG_OPR_WRITE_MASK)/*WRITE*/
    {
        if (copy_from_user(&val, argp, sizeof(val)))
        {
             return -EFAULT;
        }        
        gpio_i2c_write(I2C_OV7725, regaddr, val);
        
    }
    else if ( (oprcmd & REG_OPR_READ_MASK) == REG_OPR_READ_MASK)  /*READ*/
    {
        regvalue = gpio_sccb_read(I2C_OV7725, regaddr);
        return copy_to_user(argp, &regvalue, sizeof(regvalue))?-EFAULT : 0;            
    }
    else
    {
        return -1;
    }
    return 0;
}
/*
 * ov7725 ioctl routine. 
 * @param inode: pointer of the node;
 * @param file: pointer of the file;
 *
 * @param cmd: command from the app:
 * DC_MODE_SET(1):set ov7725's output format; 
 * DC_MODE_GET(2):get ov7725's output format;
 * DC_ZOOM_SET(3):set ov7725's output drive capability;
 * DC_ZOOM_GET(4):get ov7725's output drive capability;
 * DC_MIRROR_SET(5):set ov7725's mirror enable or disable;
 * DC_MIRROR_GET(6):get ov7725's mirror enable or disable;;
 * DC_NIGHTMODE_SET(7):set ov7725's night mode;
 * DC_NIGHTMODE_GET(8):get ov7725's night mode;
 * DC_SYNCMODE_SET(9):set ov7725's sync mode;
 * DC_SYNCMODE_GET(a):get ov7725's sync mode;
 * 
 * @param arg:arg from app layer.
 *
 * @return value:0-- set success; 1-- set error. 
 *
 */
 
int ov7725_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    void __user *argp = (void __user *)arg;
    unsigned int val = 0;
    unsigned int regvalue = 0;
     
    if (is_directreg_opt(cmd))
    {
        return ov7725_ioctl_reg(cmd, arg);
    }
    
   
    if (copy_from_user(&val, argp, sizeof(val))) 
    {
        return -EFAULT;
    }

    switch (cmd)
    {
        case DC_SET_IMAGESIZE:
        {
        	unsigned int imagesize = val;
         	if(imagesize == DC_VAL_VGA)
         	{
         		 ov7725_vga_ioctl();
         	}
         	else if(imagesize == DC_VAL_QVGA)
         	{
         		 ov7725_qvga_ioctl();
         	}
         	else if(imagesize == DC_VAL_QQVGA)
         	{
         		 ov7725_qqvga_ioctl();
         	}
         	else
         	{
         		printk("imagesize_set_error.\n");
         		return -1;

         	}	
        	break;
        }
        
        /*case DC_SET_BRIGHT:
        {
        	unsigned int bright = val;
               	gpio_i2c_write(I2C_OV7725, 0x9b, bright);
        	break;
        }
	 
	 case DC_SET_CONTRACT:
        {
        	unsigned int contrast = val;
               	gpio_i2c_write(I2C_OV7725, 0x9c, contrast);
        	break;
        }*/
        
        case DC_SET_HUE:
        {
        	unsigned int hue = val,
        	regvalue = gpio_sccb_read(I2C_OV7725, 0xa6);
        	gpio_i2c_write(I2C_OV7725, 0xa6, regvalue|0x01);
        	if(hue <0x80)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xaa, (hue+0x80));
        		gpio_i2c_write(I2C_OV7725, 0xa9, (hue+0x80));
        	}
        	else if(hue >= 0x80&&hue <= 0xff)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xaa, !hue);
        		gpio_i2c_write(I2C_OV7725, 0xa9, !hue);
        	}
        	else
        	{
        		printk("hue_set_error.\n");
        		return -1;

        	}
        	break;
        }
        
        case DC_SET_SATURATION:
        {
        	unsigned int saturation = val;
            	gpio_i2c_write(I2C_OV7725, 0xa7, saturation);
            	gpio_i2c_write(I2C_OV7725, 0xa8, saturation);
        	break;
        }
        case DC_SET_SHARPNESS:
        {
        	unsigned int sharpness = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0xac);
            	gpio_i2c_write(I2C_OV7725, 0xac, 0xdf&regvalue);
            	gpio_i2c_write(I2C_OV7725, 0x8f, sharpness);
        	break;
        }
        
        case DC_SET_ADNSWITCH:
        {
        	unsigned int adnswitch = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0xac);
        	if(adnswitch == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xac, (0x40|regvalue));
        	}
        	else if(adnswitch == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xac, (0xbf&regvalue));
        	}
        	else
        	{
        		printk("adnswitch_set_error.\n");
        		return -1;
        		
        	}
        	break;
        }
        case DC_SET_DNT:
        {
        	unsigned int dnt = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0xac);
            	gpio_i2c_write(I2C_OV7725, 0xac, 0xbf&regvalue);
        	gpio_i2c_write(I2C_OV7725, 0x8e, dnt);
        	break;
        }	
        	
        case DC_SET_AWBSWITCH:
        {
        	unsigned int awbswitch = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	if(awbswitch == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0x02|regvalue));
        	}
        	else if(awbswitch == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0xfd&regvalue));
        	}
        	break;
        }	
        case DC_SET_WBR:
        {
        	unsigned int wbr = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	gpio_i2c_write(I2C_OV7725, 0x13, (0xfd&regvalue));
        	gpio_i2c_write(I2C_OV7725, 0x02, wbr);
        	break;
        }	
        
        case DC_SET_WBB:
        {
        	unsigned int wbb = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	gpio_i2c_write(I2C_OV7725, 0x13, (0xfd&regvalue));
        	gpio_i2c_write(I2C_OV7725, 0x01, wbb);
        	break;
        }
       
        case DC_SET_AECSWITCH:
        {
        	unsigned int aecswitch = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	if(aecswitch == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0x01|regvalue));
        	}
        	else if(aecswitch == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0xfe&regvalue));
        	}
        	else 
        	{
        		printk("aecswitch_set_error.\n");
        		return -1;
        		
        	}
        	break;
        }
        case DC_SET_EC:
        {
        	unsigned int ec = val;
        	if(ec >= 0x80)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x10, 0xff);
        		gpio_i2c_write(I2C_OV7725, 0x08, (ec - 0x80)*2);
        	}
        	else if(ec < 0x80)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x10, 0x00);
        		gpio_i2c_write(I2C_OV7725, 0x08, ec*2);
        	}
        	else
        	{
        		printk("ec_set_error.\n");
        		return -1;
        	}
        	break;
        }
        		
        case DC_SET_AGCSWITCH:
        {
        	unsigned int agcswitch = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	if(agcswitch == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0x04|regvalue));
        	}
        	else if(agcswitch == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, (0xfb&regvalue));
        	}
        	else 
        	{
        		printk("agcswitch_set_error.\n");
        		return -1;
        		
        	}
        	break;
        }	
      
         case DC_SET_GC:
        {
        	unsigned int agc = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x13);
        	gpio_i2c_write(I2C_OV7725, 0x13, 0xfb&regvalue);
        	gpio_i2c_write(I2C_OV7725, 0x00, agc);
        	break;
        }
         
         case DC_SET_ABLCSWITCH:
        {
        	unsigned int ablcswitch = val;
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x3e);
        	if(ablcswitch == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x3e, (0x04|regvalue));
        	}
        	else if(ablcswitch == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x3e, (0xfb&regvalue));
        	}
        	else 
        	{
        		printk("ablcswitch_set_error.\n");
        		return -1;
        		
        	}
        	break;
        }
        
         case DC_SET_COLOR:
        {
        	unsigned int color = val,precolor_u,precolor_v;
        	precolor_u = gpio_sccb_read(I2C_OV7725, 0xa7);
        	precolor_v = gpio_sccb_read(I2C_OV7725, 0xa8);
        	regvalue = gpio_sccb_read(I2C_OV7725, 0x64);
        	if(color == DC_VAL_ON)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xa7, precolor_u);
        		gpio_i2c_write(I2C_OV7725, 0xa8, precolor_v);
        	}
        	else if(color == DC_VAL_OFF)
        	{
        		gpio_i2c_write(I2C_OV7725, 0xa7, 0x00);
        		gpio_i2c_write(I2C_OV7725, 0xa8, 0x00);
        	}
        	else
        	{
        		printk("color_set_error.\n");
        		return -1;
        		
        	}
        	break;
        }
         
         case DC_SET_SCENE:
        {
        	unsigned int scene = val;
        	if(scene == DC_VAL_OUTDOOR)
        	{
        		gpio_i2c_write(I2C_OV7725, 0x13, 0xfd);
        		gpio_i2c_write(I2C_OV7725, 0x01, 0x5a);
        		gpio_i2c_write(I2C_OV7725, 0x02, 0x5c);
        		gpio_i2c_write(I2C_OV7725, 0x0e, 0x65);
        		gpio_i2c_write(I2C_OV7725, 0x2d, 0x00);
        		gpio_i2c_write(I2C_OV7725, 0x2e, 0x00);
        		s_s32Scene = DC_VAL_OUTDOOR;
        	}