自学教程：C++ CAM_CALDB函数代码示例

//#define//Main jobs:// 1.check for device-specified errors, device not ready.// 2.Initialize the device if it is opened for the first time.static int CAM_CAL_Open(struct inode * a_pstInode, struct file * a_pstFile){    CAM_CALDB("[S24CAM_CAL] CAM_CAL_Open/n");    spin_lock(&g_CAM_CALLock);    if(g_u4Opened)    {        spin_unlock(&g_CAM_CALLock);        return -EBUSY;    }    else    {        g_u4Opened = 1;        atomic_set(&g_CAM_CALatomic,0);    }    spin_unlock(&g_CAM_CALLock);#if defined(MT6572)	// do nothing#else    if(TRUE != hwPowerOn(MT65XX_POWER_LDO_VCAMA, VOL_2800, "S24CS64A"))    {        CAM_CALDB("[CAM_CAL] Fail to enable analog gain/n");        return -EIO;    }#endif	    return 0;}

static int CAM_CAL_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             int i4RetValue = 0;    CAM_CALDB("[S24CAM_CAL] Attach I2C /n");//    spin_lock_init(&g_CAM_CALLock);    //get sensor i2c client    spin_lock(&g_CAM_CALLock); //for SMP    g_pstI2Cclient = client;	g_pstI2Cclient->timing = 200;//200k    g_pstI2Cclient->addr = ov16825OTP_AWBAF_DEVICE_ID>>1;    spin_unlock(&g_CAM_CALLock); // for SMP            CAM_CALDB("[CAM_CAL] g_pstI2Cclient->addr = 0x%8x /n",g_pstI2Cclient->addr);    //Register char driver    i4RetValue = RegisterCAM_CALCharDrv();    if(i4RetValue){        CAM_CALDB("[S24CAM_CAL] register char device failed!/n");        return i4RetValue;    }    CAM_CALDB("[S24CAM_CAL] Attached!! /n");    return 0;                                                                                       } 

static int CAM_CAL_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {             int i4RetValue = 0;    CAM_CALDB("[imx219otp_CAL] Attach I2C /n");//    spin_lock_init(&g_CAM_CALLock);    //get sensor i2c client    spin_lock(&g_CAM_CALLock); //for SMP    g_pstI2Cclient = client;    g_pstI2Cclient->addr = HI551QTECHV2_EEPROM_DEVICE_ID>>1;    spin_unlock(&g_CAM_CALLock); // for SMP            CAM_CALDB("[CAM_CAL] g_pstI2Cclient->addr = 0x%8x /n",g_pstI2Cclient->addr);    //Register char driver    i4RetValue = RegisterCAM_CALCharDrv();    if(i4RetValue){        CAM_CALDB("[imx219otp_CAL] register char device failed!/n");        return i4RetValue;    }    CAM_CALDB("[imx219otp_CAL] Attached!! /n");    return 0;                                                                                       } 

//Burst Read Datastatic int iReadData(unsigned int  ui4_offset, unsigned int  ui4_length, unsigned char * pinputdata){   int  i4RetValue = 0;   int  i4ResidueDataLength;   u32 u4IncOffset = 0;   u32 u4CurrentOffset;   u8 * pBuff;   u8 * pOneByteBuff = NULL;	pOneByteBuff = (u8 *)kmalloc(I2C_UNIT_SIZE, GFP_KERNEL);   CAM_CALDB("ui4_offset=%0x,ui4_length=%d/n",ui4_offset,ui4_length);   i4ResidueDataLength = (int)ui4_length;   u4CurrentOffset = ui4_offset;   pBuff = pinputdata;   do    {          i4RetValue = iReadCAM_CAL(u4CurrentOffset, 1, pBuff);	               //* pBuff   = HI704_read_cmos_sensor(u4CurrentOffset);	   	   CAM_CALDB("[CAM_CAL][iReadData] Read 0x%x=0x%x /n", u4CurrentOffset, pBuff[0]);       if (i4RetValue != 0)       {            CAM_CALDB("[CAM_CAL] I2C iReadData failed!! /n");            return -1;       }                  u4IncOffset++;       i4ResidueDataLength --;       u4CurrentOffset = ui4_offset + u4IncOffset;       pBuff = pinputdata + u4IncOffset;   }while (i4ResidueDataLength > 0);//   CAM_CALDB("[S24EEPORM] iReadData finial address is %d length is %d buffer address is 0x%x/n",u4CurrentOffset, i4ResidueDataLength, pBuff);   //   CAM_CALDB("[S24EEPORM] iReadData done/n" );   return 0;}

int iReadCAM_CAL_8(u8 a_u2Addr, u8 * a_puBuff, u16 i2c_id){    int  i4RetValue = 0;    char puReadCmd[1] = {(char)(a_u2Addr)};    spin_lock(&g_CAM_CALLock); //for SMP    g_pstI2Cclient->addr = i2c_id>>1;	g_pstI2Cclient->timing=400;	g_pstI2Cclient->addr = g_pstI2Cclient->addr & (I2C_MASK_FLAG | I2C_WR_FLAG);    spin_unlock(&g_CAM_CALLock); // for SMP            i4RetValue = i2c_master_send(g_pstI2Cclient, puReadCmd, 1);	    if (i4RetValue != 1)    {        CAM_CALDB("[CAM_CAL] I2C send read address failed!! /n");	    CAM_CALDB("[CAMERA SENSOR] I2C send failed, addr = 0x%x, data = 0x%x !! /n", a_u2Addr,  *a_puBuff );        return -1;    }    i4RetValue = i2c_master_recv(g_pstI2Cclient, (char *)a_puBuff, 1);	CAM_CALDB("[CAM_CAL][iReadCAM_CAL] Read 0x%x=0x%x /n", a_u2Addr, a_puBuff[0]);    if (i4RetValue != 1)    {        CAM_CALDB("[CAM_CAL] I2C read data failed!! /n");        return -1;    }     return 0;}

static int CAM_CAL_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id){	int i4RetValue = 0;	CAM_CALDB("[CAM_CAL] Attach I2C/n");	/* spin_lock_init(&g_CAM_CALLock); */	/* get sensor i2c client */	spin_lock(&g_CAM_CALLock); /* for SMP */	g_pstI2Cclient = client;	g_pstI2Cclient->addr = S24CS64A_DEVICE_ID >> 1;	spin_unlock(&g_CAM_CALLock); /* for SMP */	CAM_CALDB("[CAM_CAL] g_pstI2Cclient->addr = 0x%8x/n", g_pstI2Cclient->addr);	/* Register char driver */	i4RetValue = RegisterCAM_CALCharDrv();	if (i4RetValue) {		CAM_CALDB("[CAM_CAL] register char device failed!/n");		return i4RetValue;	}	CAM_CALDB("[CAM_CAL] Attached!!/n");	return 0;}

static kal_uint8 OV5670_ReadOtp(u8 address,unsigned char *iBuffer,unsigned int buffersize){		kal_uint16 i = 0;		u8 readbuff = 0;		int ret ;		u16 i2c_id = 0;		CAM_CALDB("[CAM_CAL_SUB]ENTER  address:0x%x buffersize:%d/n ", address, buffersize);				if (get_module_type() == SUNNY_MODULE) {			*(iBuffer) =(unsigned char)sunny_otp_data->module_id;			*(iBuffer+1) =(unsigned char)sunny_otp_data->awb_rg_msb;			*(iBuffer+2) =(unsigned char)sunny_otp_data->awb_bg_msb;			*(iBuffer+3) =(unsigned char)sunny_otp_data->awb_lsb;		} else if (get_module_type() == OFILM_MODULE) {			*(iBuffer) =(unsigned char)ofilm_otp_data->module_id;			*(iBuffer+1) =(unsigned char)ofilm_otp_data->awb_rg_msb;			*(iBuffer+2) =(unsigned char)ofilm_otp_data->awb_bg_msb;			*(iBuffer+3) =(unsigned char)ofilm_otp_data->awb_lsb;		} else if (get_module_type() == QTECH_MODULE) {			*(iBuffer) =(unsigned char)qtech_otp_data->module_id;			*(iBuffer+1) =(unsigned char)qtech_otp_data->awb_rg_msb;			*(iBuffer+2) =(unsigned char)qtech_otp_data->awb_bg_msb;			*(iBuffer+3) =(unsigned char)qtech_otp_data->awb_lsb;		}else			return 0;		for(i = 0; i<4; i++)			CAM_CALDB("[CAM_CAL_SUB]ov5670 otp readbuff[%d] = 0x%x/n",i,*(iBuffer+i));}

static kal_uint8 check_IMX135_otp_valid_AWBPage(void){	kal_uint8 Pagemax = 12;	kal_uint8 Pagemin = 9;	kal_uint8 page = 0;	kal_uint8 AWB_OK = 0x00;	u8  readbuff;	int ret;	for(page = Pagemax ; page>=Pagemin;page--)	{	if (IMX135_GotoPage(page))		{			ret = iReadCAM_CAL(0x3b04,1,&readbuff);			AWB_OK = readbuff;			if (AWB_OK != 0)			{				CAM_CALDB("AWB otp is exist/n");				break;			}				}	}	if ( page<Pagemin)		{				CAM_CALDB("No AWB OTP data!");		return 0;		}return page;}

static int __init CAM_CAL_init(void){    int i4RetValue = 0;    CAM_CALDB("CAM_CAL_i2C_init/n");   //Register char driver	i4RetValue = RegisterCAM_CALCharDrv();    if(i4RetValue){ 	   CAM_CALDB(" register char device failed!/n");	   return i4RetValue;	}	CAM_CALDB(" Attached!! /n");  //  i2c_register_board_info(CAM_CAL_I2C_BUSNUM, &kd_cam_cal_dev, 1);    if(platform_driver_register(&g_stCAM_CAL_Driver)){        CAM_CALERR("failed to register 135otp driver/n");        return -ENODEV;    }    if (platform_device_register(&g_stCAM_CAL_Device))    {        CAM_CALERR("failed to register 135otp driver, 2nd time/n");        return -ENODEV;    }    return 0;}

//#define//Main jobs:// 1.check for device-specified errors, device not ready.// 2.Initialize the device if it is opened for the first time.static int CAM_CAL_Open(struct inode * a_pstInode, struct file * a_pstFile){    CAM_CALDB("[S24CAM_CAL] CAM_CAL_Open/n");    spin_lock(&g_CAM_CALLock);    if(g_u4Opened)    {        spin_unlock(&g_CAM_CALLock);		CAM_CALDB("[S24CAM_CAL] Opened, return -EBUSY/n");        return -EBUSY;    }    else    {        g_u4Opened = 1;        atomic_set(&g_CAM_CALatomic,0);    }    spin_unlock(&g_CAM_CALLock);    if(TRUE != hwPowerOn(MT65XX_POWER_LDO_VCAMA, VOL_2800, CAM_CAL_DRVNAME))    {        CAM_CALDB("[S24CAM_CAL] Fail to enable analog gain/n");        return -EIO;    }    return 0;}

//Burst Write Datastatic int iWriteData(unsigned int  ui4_offset, unsigned int  ui4_length, unsigned char * pinputdata){   int  i4RetValue = 0;   int  i4ResidueDataLength;   u32 u4IncOffset = 0;   u32 u4CurrentOffset;   u8 * pBuff;   CAM_CALDB("[S24CAM_CAL] iWriteData/n" );   i4ResidueDataLength = (int)ui4_length;   u4CurrentOffset = ui4_offset;   pBuff = pinputdata;      CAM_CALDB("[CAM_CAL] iWriteData u4CurrentOffset is %d /n",u4CurrentOffset);      do    {       CAM_CALDB("[CAM_CAL][iWriteData] Write 0x%x=0x%x /n",u4CurrentOffset, pBuff[0]);       i4RetValue = iWriteCAM_CAL((u16)u4CurrentOffset, 1, pBuff[0]);       if (i4RetValue != 0)       {            CAM_CALDB("[CAM_CAL] I2C iWriteData failed!! /n");            return -1;       }                  u4IncOffset ++;       i4ResidueDataLength --;       u4CurrentOffset = ui4_offset + u4IncOffset;       pBuff = pinputdata + u4IncOffset;   }while (i4ResidueDataLength > 0);   CAM_CALDB("[S24CAM_CAL] iWriteData done/n" );    return 0;}

//Address: 1Byte, Data: 1Byteint iReadCAM_CAL(u8 a_u2Addr, u32 ui4_length, u8 * a_puBuff, u8 i2c_id){    int  i4RetValue = 0;    char puReadCmd[1] = {a_u2Addr};    spin_lock(&g_CAM_CALLock); //for SMP    g_pstI2Cclient->addr = i2c_id >> 1;    spin_unlock(&g_CAM_CALLock); // for SMP        //CAM_CALDB("[CAM_CAL] iReadCAM_CAL!! /n");       //CAM_CALDB("[CAM_CAL] i2c_master_send /n");    i4RetValue = i2c_master_send(g_pstI2Cclient, puReadCmd, 1);	    if (i4RetValue != 1)    {        CAM_CALDB("[CAM_CAL] I2C send read address failed!! /n");        return -1;    }    //CAM_CALDB("[CAM_CAL] i2c_master_recv /n");    i4RetValue = i2c_master_recv(g_pstI2Cclient, (char *)a_puBuff, ui4_length);//	CAM_CALDB("[CAM_CAL][iReadCAM_CAL] Read 0x%x=0x%x /n", a_u2Addr, a_puBuff[0]);    if (i4RetValue != ui4_length)    {        CAM_CALDB("[CAM_CAL] I2C read data failed!! /n");        return -1;    }     //CAM_CALDB("[CAM_CAL] iReadCAM_CAL done!! /n");    return 0;}

/* maximun read length is limited at "I2C_FIFO_SIZE" in I2c-mt65xx.c which is 8 bytes */int iReadCAM_CAL(u16 a_u2Addr, u32 ui4_length, u8 *a_puBuff){	int  i4RetValue = 0;	char puReadCmd[2] = {(char)(a_u2Addr >> 8) , (char)(a_u2Addr & 0xFF)};	/* CAM_CALDB("[CAM_CAL] iReadCAM_CAL!!/n"); */	if (ui4_length > 8) {		CAM_CALDB("[CAM_CAL] exceed I2c-mt65xx.c 8 bytes limitation/n");		return -1;	}	spin_lock(&g_CAM_CALLock); /* for SMP */	g_pstI2Cclient->addr = g_pstI2Cclient->addr & (I2C_MASK_FLAG | I2C_WR_FLAG);	spin_unlock(&g_CAM_CALLock); /* for SMP */	/* CAM_CALDB("[EERPOM] i2c_master_send/n"); */	i4RetValue = i2c_master_send(g_pstI2Cclient, puReadCmd, 2);	if (i4RetValue != 2) {		CAM_CALDB("[CAM_CAL] I2C send read address failed!!/n");		return -1;	}	/* CAM_CALDB("[EERPOM] i2c_master_recv/n"); */	i4RetValue = i2c_master_recv(g_pstI2Cclient, (char *)a_puBuff, ui4_length);	if (i4RetValue != ui4_length) {		CAM_CALDB("[CAM_CAL] I2C read data failed!!/n");		return -1;	}	spin_lock(&g_CAM_CALLock); /* for SMP */	g_pstI2Cclient->addr = g_pstI2Cclient->addr & I2C_MASK_FLAG;	spin_unlock(&g_CAM_CALLock); /* for SMP */	/* CAM_CALDB("[CAM_CAL] iReadCAM_CAL done!!/n"); */	return 0;}

//Address: 2Byte, Data: 1Byteint iReadCAM_CAL(u16 a_u2Addr, u32 ui4_length, u8 * a_puBuff){    int  i4RetValue = 0;    char puReadCmd[2] = {(char)(a_u2Addr >> 8) , (char)(a_u2Addr & 0xFF)};    //CAM_CALDB("[CAM_CAL] iReadCAM_CAL!! /n");       //CAM_CALDB("[CAM_CAL] i2c_master_send /n");    i4RetValue = i2c_master_send(g_pstI2Cclient, puReadCmd, 2);	    if (i4RetValue != 2)    {        CAM_CALDB("[CAM_CAL] I2C send read address failed!! /n");        return -1;    }    //CAM_CALDB("[CAM_CAL] i2c_master_recv /n");    i4RetValue = i2c_master_recv(g_pstI2Cclient, (char *)a_puBuff, ui4_length);	CAM_CALDB("[CAM_CAL][iReadCAM_CAL] Read 0x%x=0x%x /n", a_u2Addr, a_puBuff[0]);    if (i4RetValue != ui4_length)    {        CAM_CALDB("[CAM_CAL] I2C read data failed!! /n");        return -1;    }     //CAM_CALDB("[CAM_CAL] iReadCAM_CAL done!! /n");    return 0;}

static int get_module_type(){	int ret = 0;	u8 module_id = 0;	u8 program_id = 0;	u16 puSendCmd = 0x09;	/* module id reg addr = 0x09 for s5k3l2xx liteon module */	ret = iReadCAM_CAL(0x02 , 1, &program_id, S5K3L2XXOTP_LITEON_DEVICE_ID); //read 0x02,if equal to 0x4d,primax module,otherwise,liteon module	ret = iReadCAM_CAL(puSendCmd , 1, &module_id, S5K3L2XXOTP_LITEON_DEVICE_ID);	if (!((ret < 0) || (module_id != 0x01) || (program_id == 0x4D))){		CAM_CALDB("[CAM_CAL]Get s5k3l2xx module type: liteon/n");		return LITEON_MODULE;	}	/* module id reg addr = 0x01 for s5k3l2xx primax module */	puSendCmd = 0x01;	ret = iReadCAM_CAL(puSendCmd ,1, &module_id, S5K3L2XXOTP_PRIMAX_DEVICE_ID);	if (!((ret < 0) || (module_id != 0x03) || (program_id != 0x4D))){		CAM_CALDB("[CAM_CAL]Get s5k3l2xx module type: primax/n");		return PRIMAX_MODULE;	}	CAM_CALDB("[CAM_CAL] get module type: no support main camera module! /n");	return -ENODEV;}

//Address: 2Byte, Data: 1Bytestatic int iWriteCAM_CAL(u16 a_u2Addr  , u32 a_u4Bytes, u8 puDataInBytes){       #if 0    int  i4RetValue = 0;	int retry = 3;    char puSendCmd[3] = {(char)(a_u2Addr >> 8) , (char)(a_u2Addr & 0xFF) ,puDataInBytes};	g_pstI2Cclient->addr = (IMX214OTP_DEVICE_ID>> 1);	do {        CAM_CALDB("[CAM_CAL][iWriteCAM_CAL] Write 0x%x=0x%x /n",a_u2Addr, puDataInBytes);		i4RetValue = i2c_master_send(g_pstI2Cclient, puSendCmd, 3);        if (i4RetValue != 3) {            CAM_CALDB("[CAM_CAL] I2C send failed!!/n");        }        else {            break;    	}        mdelay(10);    } while ((retry--) > 0);       //CAM_CALDB("[CAM_CAL] iWriteCAM_CAL done!! /n");   #else   CAM_CALDB("[CAM_CAL][iWriteCAM_CAL] Write 0x%x=0x%x /n",a_u2Addr, puDataInBytes);   iWriteReg(a_u2Addr,puDataInBytes,1,IMX214OTP_DEVICE_ID);   #endif   return 0;}

// maximun read length is limited at "I2C_FIFO_SIZE" in I2c-mt65xx.c which is 8 bytesint iWriteCAM_CAL(u16 a_u2Addr  , u32 a_u4Bytes, u8 * puDataInBytes){    int  i4RetValue = 0;    u32 u4Index = 0;    char puSendCmd[8] = {(char)(a_u2Addr >> 8) , (char)(a_u2Addr & 0xFF) ,        0, 0, 0, 0, 0, 0};    if(a_u4Bytes + 2 > 8)    {        CAM_CALDB("[CAM_CAL] exceed I2c-mt65xx.c 8 bytes limitation (include address 2 Byte)/n");        return -1;    }    for(u4Index = 0 ; u4Index < a_u4Bytes ; u4Index += 1 )    {        puSendCmd[(u4Index + 2)] = puDataInBytes[u4Index];    }        i4RetValue = i2c_master_send(g_pstI2Cclient, puSendCmd, (a_u4Bytes + 2));    if (i4RetValue != (a_u4Bytes + 2))    {        CAM_CALDB("[CAM_CAL] I2C write  failed!! /n");        return -1;    }    mdelay(10); //for tWR singnal --> write data form buffer to memory.       //CAM_CALDB("[CAM_CAL] iWriteCAM_CAL done!! /n");    return 0;}

inline static int RegisterCAM_CALCharDrv(void){    struct device* CAM_CAL_device = NULL;#if CAM_CAL_DYNAMIC_ALLOCATE_DEVNO    if( alloc_chrdev_region(&g_CAM_CALdevno, 0, 1,S5K3M2_CAM_CAL_DRVNAME) )    {        CAM_CALDB("[S5K3M2_CAL] Allocate device no failed/n");        return -EAGAIN;    }#else    if( register_chrdev_region(  g_CAM_CALdevno , 1 , S5K3M2_CAM_CAL_DRVNAME) )    {        CAM_CALDB("[S5K3M2_CAL] Register device no failed/n");        return -EAGAIN;    }#endif    //Allocate driver    g_pCAM_CAL_CharDrv = cdev_alloc();    if(NULL == g_pCAM_CAL_CharDrv)    {        unregister_chrdev_region(g_CAM_CALdevno, 1);        CAM_CALDB("[S5K3M2_CAL] Allocate mem for kobject failed/n");        return -ENOMEM;    }    //Attatch file operation.    cdev_init(g_pCAM_CAL_CharDrv, &g_stCAM_CAL_fops);    g_pCAM_CAL_CharDrv->owner = THIS_MODULE;    //Add to system    if(cdev_add(g_pCAM_CAL_CharDrv, g_CAM_CALdevno, 1))    {        CAM_CALDB("[S5K3M2_CAL] Attatch file operation failed/n");        unregister_chrdev_region(g_CAM_CALdevno, 1);        return -EAGAIN;    }    CAM_CAL_class = class_create(THIS_MODULE, "S5K3M2_CAM_CALdrv");    if (IS_ERR(CAM_CAL_class)) {        int ret = PTR_ERR(CAM_CAL_class);        CAM_CALDB("Unable to create class, err = %d/n", ret);        return ret;    }    CAM_CAL_device = device_create(CAM_CAL_class, NULL, g_CAM_CALdevno, NULL, S5K3M2_CAM_CAL_DRVNAME);    return 0;}

 kal_bool IMX214_Read_LSC_Otp(kal_uint8 pagestart,kal_uint8 pageend,u16 Outdatalen,unsigned char * pOutputdata) {  kal_uint8 page = 0; kal_uint16 byteperpage = 256; kal_uint16 number = 0; kal_uint16 LSCOTPaddress = 0x00 ;  u8 readbuff; int i = 0; if(otp_flag){	for(i=0;i<Outdatalen;i++)		pOutputdata[i]=OTPData[i]; }else{ 	   if (!check_IMX214_otp_valid_LSC_Page(page))	{	 CAM_CALDB("check_IMX214_otp_valid_LSC_Page fail!/n");	 return KAL_FALSE;		 	}	 for(page = pagestart; page<=pageend; page++)	 {	   CAM_CALDB("read page=%d/n",page);   	   if(page==0){		   for(i = 49; i < byteperpage;i++)		   {			 iReadCAM_CAL_8(LSCOTPaddress+i,&readbuff,0xA0);			 pOutputdata[number]=readbuff;			 number+=1;		   }		 	   }	   else{		  for(i = 0; i <=244;i++)		  {			iReadCAM_CAL_8(LSCOTPaddress+i,&readbuff,0xA2);			pOutputdata[number]=readbuff;			number+=1;   		  }	   }      }}     CAM_CALDB("LSC read finished number= %d/n",--number);	 otp_flag=0;	 return KAL_TRUE;  }

//int iReadData(stCAM_CAL_INFO_STRUCT * st_pOutputBuffer)static int iReadData(unsigned int  ui4_offset, unsigned int  ui4_length, unsigned char * pinputdata){   int  i4RetValue = 0;   int  i4ResidueDataLength;   u32 u4IncOffset = 0;   u32 u4CurrentOffset;   u8 * pBuff;   CAM_CALDB("[CAM_CAL] iReadData /n" );      if (ui4_offset + ui4_length >= 0x2000)   {      CAM_CALDB("[CAM_CAL] Read Error!! S-24CS64A not supprt address >= 0x2000!! /n" );      return -1;   }   i4ResidueDataLength = (int)ui4_length;   u4CurrentOffset = ui4_offset;   pBuff = pinputdata;   do    {       if(i4ResidueDataLength >= 8)       {           i4RetValue = iReadCAM_CAL((u16)u4CurrentOffset, 8, pBuff);           if (i4RetValue != 0)           {                CAM_CALDB("[CAM_CAL] I2C iReadData failed!! /n");                return -1;           }                      u4IncOffset += 8;           i4ResidueDataLength -= 8;           u4CurrentOffset = ui4_offset + u4IncOffset;           pBuff = pinputdata + u4IncOffset;       }       else       {           i4RetValue = iReadCAM_CAL((u16)u4CurrentOffset, i4ResidueDataLength, pBuff);           if (i4RetValue != 0)           {                CAM_CALDB("[CAM_CAL] I2C iReadData failed!! /n");                return -1;           }             u4IncOffset += 8;           i4ResidueDataLength -= 8;           u4CurrentOffset = ui4_offset + u4IncOffset;           pBuff = pinputdata + u4IncOffset;           //break;       }   }while (i4ResidueDataLength > 0);//fix warning MSG   CAM_CALDB("[CAM_CAL] iReadData finial address is %d length is %d buffer address is 0x%x/n",u4CurrentOffset, i4ResidueDataLength, pBuff);      CAM_CALDB("[CAM_CAL] iReadData done/n" );   return 0;}

//Burst Read Datastatic int iReadData(u8  ui4_offset, unsigned int  ui4_length, unsigned char * pinputdata){   int  i4RetValue = 0;    kal_uint8 page = 0;    /* read otp */    OV5670_ReadOtp(ui4_offset,pinputdata, ui4_length);#if 0    for(i4RetValue = 0;i4RetValue<ui4_length;i4RetValue++){    CAM_CALDB( "[[CAM_CAL]]pinputdata[%d]=%d/n", i4RetValue,*(pinputdata+i4RetValue));}    CAM_CALDB(" [[CAM_CAL]]page = %d,ui4_length = %d,ui4_offset =%d/n ",page,ui4_length,ui4_offset);    CAM_CALDB("[S24EEPORM] iReadData done/n" );#endif   return 0;}

static int CAM_CAL_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) {//int i4RetValue = 0;    CAM_CALDB("Attach I2C /n");//    spin_lock_init(&g_CAM_CALLock);    //get sensor i2c client    spin_lock(&g_CAM_CALLock); //for SMP    g_pstI2Cclient = client;    g_pstI2Cclient->addr = IMX135_OTP_DEVICE_ID>>1;    spin_unlock(&g_CAM_CALLock); // for SMP    CAM_CALDB("g_pstI2Cclient->addr = 0x%x /n",g_pstI2Cclient->addr);    return 0;}

static void Enb_OTP_Read(int enb){	u8 * pOneByteBuff = NULL;	pOneByteBuff = (u8 *)kmalloc(I2C_UNIT_SIZE, GFP_KERNEL);	//Enable Reading OTP	CAM_CALDB("[CAM_CAL]Enb_OTP_Read=%d/n",enb);	iReadData(0x3d21, I2C_UNIT_SIZE, pOneByteBuff);	CAM_CALDB("[CAM_CAL]0x3d21=0x%x/n",*pOneByteBuff);	if(enb){		*pOneByteBuff = (*pOneByteBuff | 0x01);	    iWriteData(0x3d21, I2C_UNIT_SIZE, pOneByteBuff );	} else {	    *pOneByteBuff = (*pOneByteBuff & 0xFE);	    iWriteData(0x3d21, I2C_UNIT_SIZE, pOneByteBuff );	}}

static int __init CAM_CAL_i2C_init(void){	i2c_register_board_info(CAM_CAL_I2C_BUSNUM, &kd_cam_cal_dev, 1);	if (platform_driver_register(&g_stCAM_CAL_Driver)) {		CAM_CALDB("failed to register CAM_CAL driver/n");		return -ENODEV;	}	if (platform_device_register(&g_stCAM_CAL_Device)) {		CAM_CALDB("failed to register CAM_CAL driver/n");		return -ENODEV;	}	return 0;}

static kal_uint8 S5K3L2XX_ReadOtp(u8 address,unsigned char *iBuffer,unsigned int buffersize){		kal_uint16 i = 0;		u8 readbuff = 0;		int ret ;		u16 i2c_id = 0;		CAM_CALDB("[CAM_CAL]ENTER  address:0x%x buffersize:%d/n ", address, buffersize);				if (get_module_type() == LITEON_MODULE) {			i2c_id = S5K3L2XXOTP_LITEON_DEVICE_ID;			if (address == LITEON_LSC_START_ADDR ) {				memcpy(iBuffer, liteon_lsc_data, LITEON_LSC_SIZE);				return 0;			}		} else if (get_module_type() == PRIMAX_MODULE) {			i2c_id = S5K3L2XXOTP_PRIMAX_DEVICE_ID;			if (address == PRIMAX_LSC_START_ADDR ) {				/*				 * lsc data had been read out in sensor driver,				 * so just copy it to user.				 */				memcpy(iBuffer, primax_lsc_data, PRIMAX_LSC_SIZE);				return 0;			}		}		for(i = 0; i<buffersize; i++)		{							ret= iReadCAM_CAL(address+i,1, &readbuff, i2c_id);			//CAM_CALDB("[CAM_CAL]address+i = 0x%x,readbuff = 0x%x/n",(address+i),readbuff );			*(iBuffer+i) =(unsigned char)readbuff;		}		return 0;}

/* 2.Initialize the device if it is opened for the first time. */static int CAM_CAL_Open(struct inode *a_pstInode, struct file *a_pstFile){	CAM_CALDB("[S24CAM_CAL] CAM_CAL_Open/n");	spin_lock(&g_CAM_CALLock);	if (g_u4Opened) {		spin_unlock(&g_CAM_CALLock);		return -EBUSY;	} /*else {*//*LukeHu--150720=For check fo*/	if (!g_u4Opened) {/*LukeHu++150720=For check fo*/		g_u4Opened = 1;		atomic_set(&g_CAM_CALatomic, 0);	}	spin_unlock(&g_CAM_CALLock);	/* #if defined(MT6572) */	/* do nothing */	/* #else */	/* if(TRUE != hwPowerOn(MT65XX_POWER_LDO_VCAMA, VOL_2800, "S24CS64A")) */	/* { */	/* CAM_CALDB("[CAM_CAL] Fail to enable analog gain/n"); */	/* return -EIO; */	/* } */	/* #endif */	return 0;}

static kal_uint8 IMX135_ReadOtp(kal_uint8 page,kal_uint16 address,unsigned char *iBuffer,unsigned int buffersize){		kal_uint16 i = 0;		u8 readbuff ;		int ret ;		CAM_CALDB("[CAM_CAL]ENTER page:0x%x address:0x%x buffersize:%d/n ",page, address, buffersize);		if (IMX135_GotoPage(page))		{			for(i = 0; i<buffersize; i++)			{								ret= iReadCAM_CAL(address+i,1,&readbuff);				CAM_CALDB("[CAM_CAL]address+i = 0x%x,readbuff = 0x%x/n",(address+i),readbuff );				*(iBuffer+i) =(unsigned char)readbuff;			}		}		return 0;}

int read_imx219_eeprom(u8 slv_id, u16 offset, u8* data){    int ret = 0;	ret = read_cmos_sensor(slv_id,offset,data);	CAM_CALDB("OTP read slv_id 0x%x offset 0x%x  data 0x%x/n", slv_id,offset,*data);	return ret;}

 void IMX214_ReadOtp(kal_uint8 page,kal_uint16 address,unsigned char *iBuffer,unsigned int buffersize){		kal_uint16 i = 0;		u8 readbuff, base_add;		int ret ;		//base_add=(address/10)*16+(address%10);					CAM_CALDB("[CAM_CAL]ENTER page:0x%x address:0x%x buffersize:%d/n ",page, address, buffersize);		if (IMX214_GotoPage(page))		{			for(i = 0; i<buffersize; i++)			{								ret= iReadCAM_CAL_8(address+i,&readbuff,0xA0);				CAM_CALDB("[CAM_CAL]address+i = 0x%x,readbuff = 0x%x/n",(address+i),readbuff );				*(iBuffer+i) =(unsigned char)readbuff;			}		}}

//#define//Main jobs:// 1.check for device-specified errors, device not ready.// 2.Initialize the device if it is opened for the first time.static int CAM_CAL_Open(struct inode * a_pstInode, struct file * a_pstFile){    CAM_CALDB("[S5K3M2_CAL] CAM_CAL_Open/n");    spin_lock(&g_CAM_CALLock);    if(g_u4Opened)    {        spin_unlock(&g_CAM_CALLock);		CAM_CALDB("[S5K3M2_CAL] Opened, return -EBUSY/n");        return -EBUSY;    }    else    {        g_u4Opened = 1;        atomic_set(&g_CAM_CALatomic,0);    }    spin_unlock(&g_CAM_CALLock);    mdelay(2);    return 0;}