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 void Enb_OTP_Read(int enb){
#if 0
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(0x0711, I2C_UNIT_SIZE, pOneByteBuff);
CAM_CALDB("[CAM_CAL]0x0711=0x%x\n",pOneByteBuff[0]);
if(enb){
*pOneByteBuff = 0x06;
iWriteData(0x0747, I2C_UNIT_SIZE, pOneByteBuff );
*pOneByteBuff = 0x81;
iWriteData(0x0711, I2C_UNIT_SIZE, pOneByteBuff );
} else {
*pOneByteBuff = 0x00;
iWriteData(0x0711, I2C_UNIT_SIZE, pOneByteBuff );
}
#endif
}
static long EEPROM_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0;
u8 * pBuff = NULL;
u8 * pWorkingBuff = NULL;
stEEPROM_INFO_STRUCT *ptempbuf;
#ifdef EEPROMGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
if(_IOC_NONE == _IOC_DIR(a_u4Command))
{
}
else
{
pBuff = (u8 *)kmalloc(sizeof(stEEPROM_INFO_STRUCT),GFP_KERNEL);
if(NULL == pBuff)
{
EEPROMDB("[S24EEPROM] ioctl allocate mem failed\n");
return -ENOMEM;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command))
{
if(copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stEEPROM_INFO_STRUCT)))
{ //get input structure address
kfree(pBuff);
EEPROMDB("[S24EEPROM] ioctl copy from user failed\n");
return -EFAULT;
}
}
}
ptempbuf = (stEEPROM_INFO_STRUCT *)pBuff;
pWorkingBuff = (u8*)kmalloc(ptempbuf->u4Length,GFP_KERNEL);
if(NULL == pWorkingBuff)
{
kfree(pBuff);
EEPROMDB("[S24EEPROM] ioctl allocate mem failed\n");
return -ENOMEM;
}
EEPROMDB("[S24EEPROM] init Working buffer address 0x%8x command is 0x%8x\n", (u32)pWorkingBuff, (u32)a_u4Command);
if(copy_from_user((u8*)pWorkingBuff , (u8*)ptempbuf->pu1Params, ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
EEPROMDB("[S24EEPROM] ioctl copy from user failed\n");
return -EFAULT;
}
switch(a_u4Command)
{
case EEPROMIOC_S_WRITE:
EEPROMDB("[S24EEPROM] Write CMD \n");
#ifdef EEPROMGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#ifdef EEPROMGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Write data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case EEPROMIOC_G_READ:
EEPROMDB("[S24EEPROM] Read CMD \n");
#ifdef EEPROMGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
EEPROMDB("[EEPROM] offset %d \n", ptempbuf->u4Offset);
EEPROMDB("[EEPROM] length %d \n", ptempbuf->u4Length);
EEPROMDB("[EEPROM] Before read Working buffer address 0x%8x \n", (u32)pWorkingBuff);
i4RetValue = iReadData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
EEPROMDB("[S24EEPROM] After read Working buffer data 0x%4x \n", *pWorkingBuff);
#ifdef EEPROMGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Read data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
default :
EEPROMDB("[S24EEPROM] No CMD \n");
i4RetValue = -EPERM;
break;
}
if(_IOC_READ & _IOC_DIR(a_u4Command))
{
//copy data to user space buffer, keep other input paremeter unchange.
EEPROMDB("[S24EEPROM] to user length %d \n", ptempbuf->u4Length);
EEPROMDB("[S24EEPROM] to user Working buffer address 0x%8x \n", (u32)pWorkingBuff);
if(copy_to_user((u8 __user *) ptempbuf->pu1Params , (u8 *)pWorkingBuff , ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
EEPROMDB("[S24EEPROM] ioctl copy to user failed\n");
return -EFAULT;
}
}
kfree(pBuff);
kfree(pWorkingBuff);
return i4RetValue;
}
static long CAM_CAL_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0;
u8 * pBuff = NULL;
u8 * pu1Params = NULL;
stCAM_CAL_INFO_STRUCT *ptempbuf;
CAM_CALDB("[S5K3M2_CAL] ioctl\n");
#ifdef CAM_CALGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
if(_IOC_NONE == _IOC_DIR(a_u4Command))
{
}
else
{
pBuff = (u8 *)kmalloc(sizeof(stCAM_CAL_INFO_STRUCT),GFP_KERNEL);
if(NULL == pBuff)
{
CAM_CALDB(" ioctl allocate mem failed\n");
return -ENOMEM;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command))
{
if(copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stCAM_CAL_INFO_STRUCT)))
{ //get input structure address
kfree(pBuff);
CAM_CALDB("[S5K3M2_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
}
}
ptempbuf = (stCAM_CAL_INFO_STRUCT *)pBuff;
pu1Params = (u8*)kmalloc(ptempbuf->u4Length,GFP_KERNEL);
if(NULL == pu1Params)
{
kfree(pBuff);
CAM_CALDB("ioctl allocate mem failed\n");
return -ENOMEM;
}
CAM_CALDB(" init Working buffer address 0x%p command is 0x%x\n", pu1Params, a_u4Command);
if(copy_from_user((u8*)pu1Params , (u8*)ptempbuf->pu1Params, ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pu1Params);
CAM_CALDB("[S5K3M2_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
if(is_firstboot == 1)
{
mdelay(300);
}
spin_lock(&g_CAM_CALLock);
is_firstboot = 0;
spin_unlock(&g_CAM_CALLock);
switch(a_u4Command)
{
case CAM_CALIOC_S_WRITE:
CAM_CALDB("[S5K3M2_CAL] Write CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pu1Params);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
CAM_CALDB("Write data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case CAM_CALIOC_G_READ:
CAM_CALDB("[S5K3M2_CAL] Read CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[CAM_CAL] offset %d \n", ptempbuf->u4Offset);
CAM_CALDB("[CAM_CAL] length %d \n", ptempbuf->u4Length);
//CAM_CALDB("[CAM_CAL] Before read Working buffer address 0x%p \n", pu1Params);
//i4RetValue = selective_read_region(ptempbuf->u4Offset, pu1Params, S5K3M2_DEVICE_ID,ptempbuf->u4Length);
if((ptempbuf->u4Offset == AWB_ADDR) && (ptempbuf->u4Length == 16) )
{
i4RetValue = Read3M2AWBData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pu1Params);
}
else if((ptempbuf->u4Offset == AF_ADDR) && (ptempbuf->u4Length == 4) )
{
i4RetValue = Read3M2AFData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pu1Params);
}
else if((ptempbuf->u4Offset == LSC_ADDR) && (ptempbuf->u4Length == LSC_SIZE) )
{
i4RetValue = Read3M2LSCData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pu1Params);
}
else
{
i4RetValue = iReadData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pu1Params);
}
CAM_CALDB("[S5K3M2_CAL] After read Working buffer data 0x%x \n", *pu1Params);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
CAM_CALDB("Read data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
default :
CAM_CALDB("[S5K3M2_CAL] No CMD \n");
i4RetValue = -EPERM;
break;
}
if(_IOC_READ & _IOC_DIR(a_u4Command))
{
//copy data to user space buffer, keep other input paremeter unchange.
CAM_CALDB("[S5K3M2_CAL] to user length %d \n", ptempbuf->u4Length);
CAM_CALDB("[S5K3M2_CAL] to user Working buffer address 0x%p \n", pu1Params);
if(copy_to_user((u8 __user *) ptempbuf->pu1Params , (u8 *)pu1Params , ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pu1Params);
CAM_CALDB("[S5K3M2_CAL] ioctl copy to user failed\n");
return -EFAULT;
}
}
kfree(pBuff);
kfree(pu1Params);
return i4RetValue;
}
static long CAM_CAL_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0;
u8 * pBuff = NULL;
u8 * pWorkingBuff = NULL;
stCAM_CAL_INFO_STRUCT *ptempbuf;
u16 otp_data;
u8 temp_data=0;
#ifdef CAM_CALGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
if(_IOC_NONE == _IOC_DIR(a_u4Command))
{
}
else
{
pBuff = (u8 *)kmalloc(sizeof(stCAM_CAL_INFO_STRUCT),GFP_KERNEL);
if(NULL == pBuff)
{
CAM_CALDB("[S24CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command))
{
if(copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stCAM_CAL_INFO_STRUCT)))
{ //get input structure address
kfree(pBuff);
CAM_CALDB("[S24CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
}
CAM_CALDB("[S24CAM_CAL] LONG TEST SIZE=%d.\n",sizeof( stCAM_CAL_INFO_STRUCT));
}
ptempbuf = (stCAM_CAL_INFO_STRUCT *)pBuff;
CAM_CALDB("[S24CAM_CAL] pBuff u4Length=%d.\n",ptempbuf->u4Length);
pWorkingBuff = (u8*)kmalloc(ptempbuf->u4Length,GFP_KERNEL);
//CAM_CALDB("[S24CAM_CAL]WorkingBuff Start Address is =%x, Buff length=%d, WorkingBuff End Address is=%x\n", pWorkingBuff, ptempbuf->u4Length, pWorkingBuff+ptempbuf->u4Length);
if(NULL == pWorkingBuff)
{
kfree(pBuff);
CAM_CALDB("[S24CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
CAM_CALDB("[S24CAM_CAL] init Working buffer address 0x%8x command is 0x%8x\n", (u32)pWorkingBuff, (u32)a_u4Command);
if(copy_from_user((u8*)pWorkingBuff , (u8*)ptempbuf->pu1Params, 2))
{
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[S24CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
switch(a_u4Command)
{
case CAM_CALIOC_S_WRITE:
CAM_CALDB("[S24CAM_CAL] Write CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[S24CAM_CAL] ptempbuf->u4Offset=%0x.\n",ptempbuf->u4Offset);
CAM_CALDB("[S24CAM_CAL] ptempbuf->u4Length=%0x.\n",ptempbuf->u4Length);
//i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Write data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case CAM_CALIOC_G_READ:
CAM_CALDB("[S24CAM_CAL] Read CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
// CAM_CALDB("[CAM_CAL] offset %x \n", ptempbuf->u4Offset);
// CAM_CALDB("[CAM_CAL] length %d \n", ptempbuf->u4Length);
// CAM_CALDB("[CAM_CAL] Before read Working buffer address 0x%8x,value 0x%8x \n", (u32)pWorkingBuff,(u8 *)pWorkingBuff);
if(ptempbuf->u4Offset==0x3806)
{
if (isHaveOtpData(ptempbuf->u4Offset))
{
CAM_CALDB("[S24CAM_CAL] have read otp data! \n");
otp_data = restoreOtpData(ptempbuf->u4Offset);
pWorkingBuff[0] = otp_data >> 8;
pWorkingBuff[1] = otp_data & 0xFF;
}
else
{
Enb_OTP_Read(1); //Enable OTP Read
i4RetValue = iReadData((u16)(ptempbuf->u4Offset), ptempbuf->u4Length, pWorkingBuff);
Enb_OTP_Read(0); //Disable OTP Read
saveOtpData(ptempbuf->u4Offset, (u16)(pWorkingBuff[0] << 8 | pWorkingBuff[1]));
}
// Clear_OTP_Buff(); //Clean OTP buff
CAM_CALDB("[S24CAM_CAL] After read Working buffer data 0x%x,%x \n", pWorkingBuff[0],pWorkingBuff[1]);
}
static int Enb_OTP_Read(int enb)
{
u16 * pOneByteBuff = NULL;
u8 * reVal;
//kal_int16 cnt=0;
pOneByteBuff = (u16 *)kmalloc(1, GFP_KERNEL);
reVal=(u8 *)kmalloc(I2C_UNIT_SIZE, GFP_KERNEL);
//Enable Reading OTP
CAM_CALDB("[CAM_CAL]Enb_OTP_Read=%d\n",enb);
if(enb){
if(otp_flag==0)
{
for(datatype=0x3100;datatype>=0x3000;datatype-=0x100)
{
*pOneByteBuff = 0x0610;
iWriteData(0x301A, 1, pOneByteBuff );
*pOneByteBuff = 0xCD95;
iWriteData(0x3134, 1, pOneByteBuff );
*pOneByteBuff = datatype;
iWriteData(0x304C, 1, pOneByteBuff );
*pOneByteBuff = 0x0210;
iWriteData(0x304A, 1, pOneByteBuff );
iReadData(0x304A, 1 , reVal);
CAM_CALDB("[CAM_CAL]Read= %x, %x \n", reVal[0], reVal[1]);
if((reVal[1] | 0xBF) != 0xFF)
{
continue;
}
iReadData(0x38F2, 1, reVal);
CAM_CALDB("[CAM_CAL]Read= %x, %x \n", reVal[0], reVal[1]);
if((reVal[0] != 0xFF) || (reVal[1] != 0xFF))
{
continue;
}
spin_lock(&g_CAM_CALLock);
otp_flag=1;
spin_unlock(&g_CAM_CALLock);
kfree(pOneByteBuff);
kfree(reVal);
//kfree(flag);
return 1;
}
kfree(pOneByteBuff);
kfree(reVal);
//kfree(flag);
return 0;
}
else
{
CAM_CALDB("data type=%x \n",datatype);
*pOneByteBuff = 0x0610;
iWriteData(0x301A, 1, pOneByteBuff );
*pOneByteBuff = 0xCD95;
iWriteData(0x3134, 1, pOneByteBuff );
*pOneByteBuff = datatype;
iWriteData(0x304C, 1, pOneByteBuff );
*pOneByteBuff = 0x0210;
iWriteData(0x304A, 1, pOneByteBuff );
iReadData(0x304A, 1, reVal);
CAM_CALDB("[CAM_CAL]Read = %x, %x \n", reVal[0], reVal[1]);
kfree(pOneByteBuff);
kfree(reVal);
//kfree(flag);
return 1;
}
}
else
{
*pOneByteBuff = 0x021C; // 0x001C
iWriteData(0x301A, 1, pOneByteBuff );
kfree(pOneByteBuff);
kfree(reVal);
return 1;
}
}
static long CAM_CAL_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0;
u8 *pBuff = NULL;
u8 *pWorkingBuff = NULL;
stCAM_CAL_INFO_STRUCT *ptempbuf;
#ifdef CAM_CALGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
/*
if (_IOC_NONE == _IOC_DIR(a_u4Command)) {
} else {
*/
if (_IOC_NONE != _IOC_DIR(a_u4Command)) {
pBuff = kmalloc(sizeof(stCAM_CAL_INFO_STRUCT), GFP_KERNEL);
if (NULL == pBuff) {
CAM_CALDB("[CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
if (_IOC_WRITE & _IOC_DIR(a_u4Command)) {
if (copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stCAM_CAL_INFO_STRUCT))) {
/* get input structure address */
kfree(pBuff);
CAM_CALDB("[CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
}
}
ptempbuf = (stCAM_CAL_INFO_STRUCT *)pBuff;
pWorkingBuff = kmalloc(ptempbuf->u4Length, GFP_KERNEL);
if (NULL == pWorkingBuff) {
kfree(pBuff);
CAM_CALDB("[CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
/* fix warning MSG CAM_CALDB("[CAM_CAL] init Working buffer address 0x%x command is
0x%08x\n", pWorkingBuff, a_u4Command); */
if (copy_from_user((u8 *)pWorkingBuff , (u8 *)ptempbuf->pu1Params, ptempbuf->u4Length)) {
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
switch (a_u4Command) {
case CAM_CALIOC_S_WRITE:
CAM_CALDB("[CAM_CAL] Write CMD\n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if (ktv2.tv_sec > ktv1.tv_sec)
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
else
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
CAM_CALDB("Write data %d bytes take %lu us\n", ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case CAM_CALIOC_G_READ:
CAM_CALDB("[CAM_CAL] Read CMD\n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[CAM_CAL] offset %d\n", ptempbuf->u4Offset);
CAM_CALDB("[CAM_CAL] length %d\n", ptempbuf->u4Length);
/* fix warning MSG CAM_CALDB("[CAM_CAL] Before read Working buffer address
0x%x\n", pWorkingBuff); */
i4RetValue = iReadData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
/* fix warning MSG CAM_CALDB("[CAM_CAL] After read Working buffer address
0x%x\n", pWorkingBuff); */
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if (ktv2.tv_sec > ktv1.tv_sec)
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
else
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
CAM_CALDB("Read data %d bytes take %lu us\n", ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
default:
CAM_CALDB("[CAM_CAL] No CMD\n");
i4RetValue = -EPERM;
break;
}
if (_IOC_READ & _IOC_DIR(a_u4Command)) {
/* copy data to user space buffer, keep other input paremeter unchange. */
CAM_CALDB("[CAM_CAL] to user length %d\n", ptempbuf->u4Length);
/* fix warning MSG CAM_CALDB("[CAM_CAL] to user Working buffer address 0x%x\n",
pWorkingBuff); */
if (copy_to_user((u8 __user *) ptempbuf->pu1Params , (u8 *)pWorkingBuff , ptempbuf->u4Length)) {
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[CAM_CAL] ioctl copy to user failed\n");
return -EFAULT;
}
}
kfree(pBuff);
kfree(pWorkingBuff);
return i4RetValue;
}
static long CAM_CAL_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0;
u8 * pBuff = NULL;
u8 * pWorkingBuff = NULL;
stCAM_CAL_INFO_STRUCT *ptempbuf;
#ifdef CAM_CALGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
if(_IOC_NONE == _IOC_DIR(a_u4Command))
{
}
else
{
pBuff = (u8 *)kmalloc(sizeof(stCAM_CAL_INFO_STRUCT),GFP_KERNEL);
if(NULL == pBuff)
{
CAM_CALDB("[S24CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command))
{
if(copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stCAM_CAL_INFO_STRUCT)))
{ //get input structure address
kfree(pBuff);
CAM_CALDB("[S24CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
}
}
ptempbuf = (stCAM_CAL_INFO_STRUCT *)pBuff;
CAM_CALDB("[S24CAM_CAL] pBuff u4Length=%d.\n",ptempbuf->u4Length);
pWorkingBuff = (u8*)kmalloc(ptempbuf->u4Length,GFP_KERNEL);
CAM_CALDB("[S24CAM_CAL]WorkingBuff Start Address is =%x, Buff length=%d, WorkingBuff End Address is=%x\n", pWorkingBuff, ptempbuf->u4Length, pWorkingBuff+ptempbuf->u4Length);
if(NULL == pWorkingBuff)
{
kfree(pBuff);
CAM_CALDB("[S24CAM_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
CAM_CALDB("[S24CAM_CAL] init Working buffer address 0x%8x command is 0x%8x\n", (u32)pWorkingBuff, (u32)a_u4Command);
if(copy_from_user((u8*)pWorkingBuff , (u8*)ptempbuf->pu1Params, ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[S24CAM_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
switch(a_u4Command)
{
case CAM_CALIOC_S_WRITE:
CAM_CALDB("[S24CAM_CAL] Write CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[S24CAM_CAL] ptempbuf->u4Offset=%0x.\n",ptempbuf->u4Offset);
CAM_CALDB("[S24CAM_CAL] ptempbuf->u4Length=%0x.\n",ptempbuf->u4Length);
i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Write data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case CAM_CALIOC_G_READ:
CAM_CALDB("[S24CAM_CAL] Read CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[CAM_CAL] offset %x \n", ptempbuf->u4Offset);
CAM_CALDB("[CAM_CAL] length %d \n", ptempbuf->u4Length);
CAM_CALDB("[CAM_CAL] Before read Working buffer address 0x%8x \n", (u32)pWorkingBuff);
CAM_CALDB("[CAM_CAL] Before read Working buffer value 0x%8x \n", (u8 *)pWorkingBuff);
if(ptempbuf->u4Offset <= Page_Block0_AWBAF) //AWBAF
{
//Enb_OTP_Read(1); //Enable OTP Read
i4RetValue = iReadData((u16)(ptempbuf->u4Offset), ptempbuf->u4Length, pWorkingBuff);
//Enb_OTP_Read(0); //Disable OTP Read
//Clear_OTP_Buff(); //Clean OTP buff
CAM_CALDB("[S24CAM_CAL] After read Working buffer data 0x%4x \n", pWorkingBuff[0]);
}
else //LSC
{
//Enb_OTP_Read(1); //Enable OTP Read
i4RetValue = iReadData((u16)(ptempbuf->u4Offset+OTP_START_ADDR), ptempbuf->u4Length, pWorkingBuff);
//Enb_OTP_Read(0); //Disable OTP Read
//Clear_OTP_Buff(); //Clean OTP buff
CAM_CALDB("[S24CAM_CAL] After read Working buffer data 0x%4x \n", pWorkingBuff[0]);
}
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Read data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
default :
CAM_CALDB("[S24CAM_CAL] No CMD \n");
i4RetValue = -EPERM;
break;
}
if(_IOC_READ & _IOC_DIR(a_u4Command))
{
//copy data to user space buffer, keep other input paremeter unchange.
CAM_CALDB("[S24CAM_CAL] to user length %d \n", ptempbuf->u4Length);
CAM_CALDB("[S24CAM_CAL] to user Working buffer address 0x%8x \n", (u32)pWorkingBuff);
if(copy_to_user((u8 __user *) ptempbuf->pu1Params , (u8 *)pWorkingBuff , ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[S24CAM_CAL] ioctl copy to user failed\n");
return -EFAULT;
}
}
kfree(pBuff);
kfree(pWorkingBuff);
return i4RetValue;
}
static long CAM_CAL_Ioctl(
struct file *file,
unsigned int a_u4Command,
unsigned long a_u4Param
)
#endif
{
int i4RetValue = 0,i4RetValue1 = 0;
u8 * pBuff = NULL;
u8 * pWorkingBuff = NULL;
stCAM_CAL_INFO_STRUCT *ptempbuf;
u8 * pOTP_write_OneByteBuff = NULL;
pOTP_write_OneByteBuff = (u8 *)kmalloc(I2C_UNIT_SIZE, GFP_KERNEL);
//Enable Reading OTP
#ifdef CAM_CALGETDLT_DEBUG
struct timeval ktv1, ktv2;
unsigned long TimeIntervalUS;
#endif
if(_IOC_NONE == _IOC_DIR(a_u4Command))
{
}
else
{
pBuff = (u8 *)kmalloc(sizeof(stCAM_CAL_INFO_STRUCT),GFP_KERNEL);
if(NULL == pBuff)
{
CAM_CALDB("[hi551otp_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
if(_IOC_WRITE & _IOC_DIR(a_u4Command))
{
if(copy_from_user((u8 *) pBuff , (u8 *) a_u4Param, sizeof(stCAM_CAL_INFO_STRUCT)))
{ //get input structure address
kfree(pBuff);
CAM_CALDB("[hi551otp_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
}
}
ptempbuf = (stCAM_CAL_INFO_STRUCT *)pBuff;
pWorkingBuff = (u8*)kmalloc(ptempbuf->u4Length,GFP_KERNEL);
if(NULL == pWorkingBuff)
{
kfree(pBuff);
CAM_CALDB("[hi551otp_CAL] ioctl allocate mem failed\n");
return -ENOMEM;
}
//CAM_CALDB("[imx219otp_CAL] init Working buffer address 0x%8x command is 0x%8x\n", (u32)pWorkingBuff, (u32)a_u4Command);
if(copy_from_user((u8*)pWorkingBuff , (u8*)ptempbuf->pu1Params, ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[hi551otp_CAL] ioctl copy from user failed\n");
return -EFAULT;
}
switch(a_u4Command)
{
case CAM_CALIOC_S_WRITE:
CAM_CALDB("[hi551otp_CAL] Write CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
i4RetValue = iWriteData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Write data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
case CAM_CALIOC_G_READ:
CAM_CALDB("[hi551otp_CAL] Read CMD \n");
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv1);
#endif
CAM_CALDB("[CAM_CAL] offset %d \n", ptempbuf->u4Offset);
CAM_CALDB("[CAM_CAL] length %d \n", ptempbuf->u4Length);
//CAM_CALDB("[CAM_CAL] Before read Working buffer address 0x%8x \n", (u32)pWorkingBuff);
printk("[CAM_CAL] offset %x \n", ptempbuf->u4Offset);
printk("[CAM_CAL] length %d \n", ptempbuf->u4Length);
//printk("[CAM_CAL] Before read Working buffer address 0x%8x \n", (u32)pWorkingBuff);
#if defined(HI551QTECHV2_MIPI_RAW)
if ( hi551_cam_cal_read_data(ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff)
!= ptempbuf->u4Length){
CAM_CALDB("[hi551otp_CAL]Read lsc lenth error\n");
i4RetValue = -1;
} else {
i4RetValue = 0;
}
#else
i4RetValue = iReadData((u16)ptempbuf->u4Offset, ptempbuf->u4Length, pWorkingBuff);
#endif
//i4RetValue = iReadData(0x350a, ptempbuf->u4Length, pWorkingBuff);
CAM_CALDB("[hi551otp_CAL] After read Working buffer data 0x%4x \n", pWorkingBuff[0]);
#ifdef CAM_CALGETDLT_DEBUG
do_gettimeofday(&ktv2);
if(ktv2.tv_sec > ktv1.tv_sec)
{
TimeIntervalUS = ktv1.tv_usec + 1000000 - ktv2.tv_usec;
}
else
{
TimeIntervalUS = ktv2.tv_usec - ktv1.tv_usec;
}
printk("Read data %d bytes take %lu us\n",ptempbuf->u4Length, TimeIntervalUS);
#endif
break;
default :
CAM_CALDB("[hi551otp_CAL] No CMD \n");
i4RetValue = -EPERM;
break;
}
if(_IOC_READ & _IOC_DIR(a_u4Command))
{
//copy data to user space buffer, keep other input paremeter unchange.
CAM_CALDB("[hi551otp_CAL] to user length %d \n", ptempbuf->u4Length);
//CAM_CALDB("[imx219otp_CAL] to user Working buffer address 0x%8x \n", (u32)pWorkingBuff);
if(copy_to_user((u8 __user *) ptempbuf->pu1Params , (u8 *)pWorkingBuff , ptempbuf->u4Length))
{
kfree(pBuff);
kfree(pWorkingBuff);
CAM_CALDB("[hi551otp_CAL] ioctl copy to user failed\n");
return -EFAULT;
}
}
kfree(pBuff);
kfree(pWorkingBuff);
return i4RetValue;
}
