static int sensor_active(struct i2c_client *client, int enable, int rate)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
int status = 0;
sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);
//register setting according to chip datasheet
if(enable)
{
status = L3G4200D_ENABLE; //l3g4200d
sensor->ops->ctrl_data |= status;
}
else
{
status = ~L3G4200D_ENABLE; //l3g4200d
sensor->ops->ctrl_data &= status;
}
DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
printk("%s:fail to active sensor\n",__func__);
return result;
}
int cm3511_sensor_init(void)
{
cm3511_set_mclk(0);
cm3511_reset();
sensor_write_reg(cm3511.client,0x03, 0x00);//
sensor_write_reg(cm3511.client,0x01, 0xC1);
sensor_write_reg(cm3511.client,0x01, 0xC3);//
sensor_write_reg(cm3511.client,0x01, 0xC1);
mdelay(50);
sensor_write_reg(cm3511.client,0x03, 0x00);//
cm3511_init_setting(cm3511.client);
return 0;
}
static int sensor_active(struct i2c_client *client, int enable, int rate)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
int status = 0;
sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);
//register setting according to chip datasheet
if(enable)
{
sensor->ops->ctrl_data &= 0x1f;
sensor->ops->ctrl_data |= COMMMAND1_OPMODE_ALS_CONTINUE;
}
else
{
sensor->ops->ctrl_data &= 0x1f;
//sensor->ops->ctrl_data |= COMMMAND1_OPMODE_POWER_DOWN;
}
DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
printk("%s:fail to active sensor\n",__func__);
if(enable)
sensor->ops->report(sensor->client);
return result;
}
static ssize_t i2c_set_write(struct file *file, const char __user *buf, size_t count,
loff_t *ppos)
{
int len;
int arg[2];
arg[0]=0;
if (*ppos)
return 0; /* the end */
len=(count > DBG_TXT_BUF_SIZE-1)?(DBG_TXT_BUF_SIZE-1):(count);
if (copy_from_user(debugTxtBuf,buf,len))
return -EFAULT;
debugTxtBuf[len]=0; //add string end
sscanf(debugTxtBuf, "%x %x", &arg[0], &arg[1]);
*ppos=len;
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, arg[0], arg[1]);
return len; /* the end */
}
static int sensor_active(struct i2c_client *client, int enable, int rate)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
//sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);
//register setting according to chip datasheet
if(enable)
{
sensor->ops->ctrl_data = AK8975_MODE_SNG_MEASURE;
}
else
{
sensor->ops->ctrl_data = AK8975_MODE_POWERDOWN;
}
DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
printk("%s:fail to active sensor\n",__func__);
return result;
}
static int sensor_init(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
unsigned char buf[5];
unsigned char data = 0;
int i = 0;
result = sensor->ops->active(client,0,0);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
sensor->status_cur = SENSOR_OFF;
buf[0] = 0x07; //27
buf[1] = 0x00;
buf[2] = 0x00;
buf[3] = 0x20; //0x00
buf[4] = 0x00;
for(i=0; i<5; i++)
{
result = sensor_write_reg(client, sensor->ops->ctrl_reg+i, buf[i]);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
}
result = sensor_read_reg(client, sensor->ops->ctrl_reg);
if (result >= 0)
data = result & 0x000F;
sensor->ops->ctrl_data = data + ODR100_BW12_5;
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
return result;
}
/************************FPS Set******************************/
int ov7690_set_FPS15(struct i2c_client *client)
{
sensor_write_reg(client, 0x11, 0x01);
sensor_write_reg(client, 0x29, 0x50);
sensor_write_reg(client, 0x2a, 0x30);
sensor_write_reg(client, 0x2b, 0x08);
sensor_write_reg(client, 0x2c, 0x00);
sensor_write_reg(client, 0x15, 0x00);
sensor_write_reg(client, 0x2d, 0x00);
sensor_write_reg(client, 0x2e, 0x00);
return 0;
}
static int sensor_report_value(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
int value = 0;
char buffer[2] = {0};
char index = 0;
if(sensor->ops->read_len < 2) //sensor->ops->read_len = 2
{
printk("%s:lenth is error,len=%d\n",__func__,sensor->ops->read_len);
return -1;
}
memset(buffer, 0, 2);
buffer[0] = sensor->ops->read_reg;
result = sensor_rx_data(client, buffer, sensor->ops->read_len);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
value = (buffer[0] << 8) | buffer[1];
index = light_report_value(sensor->input_dev, value);
DBG("%s:%s result=0x%x,index=%d\n",__func__,sensor->ops->name, value,index);
if(sensor->pdata->irq_enable)
{
if(sensor->ops->int_status_reg)
{
value = sensor_read_reg(client, sensor->ops->int_status_reg);
}
if(value & STA_ALS_INT)
{
value &= ~STA_ALS_INT;
result = sensor_write_reg(client, sensor->ops->int_status_reg,value); //clear int
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
}
}
return result;
}
static int sensor_init(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
result = sensor->ops->active(client,0,0);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
sensor->status_cur = SENSOR_OFF;
result = sensor_write_reg(client, SW_RESET, 0);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
sensor->ops->ctrl_data |= PS_15T_3MS| PS_SLP_90MS;
sensor->ops->ctrl_data &= ~TRIG_PS_AND_LS;
if(sensor->pdata->irq_enable)
sensor->ops->ctrl_data |= PS_INT_ENABLE;
else
sensor->ops->ctrl_data &= ~PS_INT_ENABLE;
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
return result;
}
static int sensor_active(struct i2c_client *client, int enable, int rate)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
char value = 0;
if(enable)
sensor_power_updown(client, 1);
value = sensor_read_reg(client, sensor->ops->ctrl_reg);
//register setting according to chip datasheet
if(enable)
{
if( (value & 0x03) == ONLY_PROX_EN )
{
value &= ~0x03;
value |= ALL_PROX_ALS_EN;
}
else if((value & 0x03) == ALL_IDLE )
{
value &= ~0x03;
value |= ONLY_ALS_EN;
}
}
else
{
if( (value & 0x03) == ONLY_ALS_EN )
{
value &= ~0x03;
value |= ALL_IDLE;
}
else if((value & 0x03) == ALL_PROX_ALS_EN )
{
value &= ~0x03;
value |= ONLY_PROX_EN;
}
}
sensor->ops->ctrl_data = value;
DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
printk("%s:fail to active sensor\n",__func__);
return result;
}
int ov7690_color_matrix_set(struct i2c_client *client)
{
sensor_write_reg(client, 0xbb, 0x80);
sensor_write_reg(client, 0xbc, 0x62);
sensor_write_reg(client, 0xbd, 0x1e);
sensor_write_reg(client, 0xbe, 0x26);
sensor_write_reg(client, 0xbf, 0x7b);
sensor_write_reg(client, 0xc0, 0xac);
sensor_write_reg(client, 0xc1, 0x1e);
return 0;
}
/****************lens corrention**********************/
int ov7690_lens_corrention_set(struct i2c_client *client)
{
sensor_write_reg(client, 0x85, 0x90);
sensor_write_reg(client, 0x86, 0x00);
sensor_write_reg(client, 0x87, 0x00);
sensor_write_reg(client, 0x88, 0x10);
sensor_write_reg(client, 0x89, 0x30);
sensor_write_reg(client, 0x8a, 0x29);
sensor_write_reg(client, 0x8b, 0x26);
return 0;
}
int cm3511_sensor_probe(void)
{
int sensor_id=0;
cm3511_power_up();
cm3511_reset();
sensor_write_reg(cm3511.client,0x03, 0x00);//
sensor_write_reg(cm3511.client,0x01, 0xC1);
sensor_write_reg(cm3511.client,0x01, 0xC3);//
sensor_write_reg(cm3511.client,0x01, 0xC1);
mdelay(50);
sensor_write_reg(cm3511.client,0x03, 0x00);//
sensor_id = sensor_read_reg(cm3511.client,0x04);
cm3511_power_down();
if(sensor_id == 0x81)
return 0;
dprintk("sensor read is %d",sensor_id);
return -1;
}
static int sensor_active(struct i2c_client *client, int enable, int rate)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
//int status = 0;
//sensor->client->addr = sensor->ops->ctrl_reg;
//sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);
//printk("%s: client addr = %#x\n\n", __func__, client->addr);
//register setting according to chip datasheet
if (enable) {
sensor->ops->ctrl_data = ALS_RESET(1);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result) {
printk("%s:fail to active sensor\n",__func__);
return -1;
}
}
if(enable)
{
sensor->ops->ctrl_data = ALS_IT(ALS_IT200MS) | HIGH_SENSITIVITY(1);
}
else
{
sensor->ops->ctrl_data = SHUT_DOWN(1);
}
DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(result)
printk("%s:fail to active sensor\n",__func__);
return result;
}
static int sensor_init(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
char value = 0;
sensor_power_updown(client, 0);
result = sensor->ops->active(client,0,0);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
sensor->status_cur = SENSOR_OFF;
value = 0x41;//The ADC effective resolution = 9; Low lux threshold level = 1;
//value = 0x69; //The ADC effective resolution = 17; Low lux threshold level = 9;
result = sensor_write_reg(client, ALS_CTL_REG, value);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
//value = 0x04;//0x01-0x0f; 17%->93.5% if value = 0x04,then Compensate Loss 52%
value = 0x02;//0x01-0x0f; 17%->93.5% if value = 0x02,then Compensate Loss 31%
result = sensor_write_reg(client, ALS_WINDOWS_REG, value);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
return result;
}
/************************Format Set******************************/
int ov7690_format_yuv422(struct i2c_client *client)
{
sensor_write_reg(client, 0x12, 0x00);
sensor_write_reg(client, 0x82, 0x03);
sensor_write_reg(client, 0xd0, 0x48);
sensor_write_reg(client, 0x80, 0x7f);
sensor_write_reg(client, 0x3e, 0x30);
sensor_write_reg(client, 0x22, 0x00);
return 0;
}
static int sensor_init(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
int result = 0;
result = sensor->ops->active(client,0,0);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
sensor->status_cur = SENSOR_OFF;
result = sensor_write_reg(client, ISL29023_REG_ADD_COMMANDII, COMMANDII_RANGE_4000 | COMMANDII_RESOLUTION_4096);
if(result)
{
printk("%s:line=%d,error\n",__func__,__LINE__);
return result;
}
return result;
}
static int compass_akm_reset(struct i2c_client *client)
{
struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client);
int result = 0;
if(sensor->pdata->reset_pin > 0)
{
gpio_direction_output(sensor->pdata->reset_pin, GPIO_LOW);
udelay(10);
gpio_direction_output(sensor->pdata->reset_pin, GPIO_HIGH);
}
else
{
/* Set measure mode */
result = sensor_write_reg(client, AK8963_REG_CNTL2, AK8963_MODE_SNG_MEASURE);
if(result)
printk("%s:fail to Set measure mode\n",__func__);
}
udelay(100);
return result;
}
/*************************Resolution Set*************************/
int ov7690_640_480(struct i2c_client *client)
{
sensor_write_reg(client,0x16,0x03);
sensor_write_reg(client,0x17,0x69);
sensor_write_reg(client,0x18,0xa4);
sensor_write_reg(client,0x19,0x0c);
sensor_write_reg(client,0x1a,0xf6);
sensor_write_reg(client,0x22,0x00);
sensor_write_reg(client,0xc8,0x02);
sensor_write_reg(client,0xc9,0x80);
sensor_write_reg(client,0xca,0x01);
sensor_write_reg(client,0xcb,0xe0);
sensor_write_reg(client,0xcc,0x02);
sensor_write_reg(client,0xcd,0x80);
sensor_write_reg(client,0xce,0x01);
sensor_write_reg(client,0xcf,0xe0);
return 0;
}
int ov7690_set_scene_night(struct i2c_client *client)
{
sensor_write_reg(client, 0x13, 0xf7);
sensor_write_reg(client, 0x15, 0xb8);
return 0;
}
int ov7690_set_scene_auto(struct i2c_client *client)
{
sensor_write_reg(client, 0x13, 0xf7);
sensor_write_reg(client, 0x15, 0x00);
return 0;
}
int ov7690_set_wb_auto(struct i2c_client *client)
{
sensor_write_reg(client, 0x8c, 0x5c);
sensor_write_reg(client, 0x8d, 0x11);
sensor_write_reg(client, 0x8e, 0x12);
sensor_write_reg(client, 0x8f, 0x19);
sensor_write_reg(client, 0x90, 0x50);
sensor_write_reg(client, 0x91, 0x20);
sensor_write_reg(client, 0x92, 0x99);
sensor_write_reg(client, 0x93, 0x91);
sensor_write_reg(client, 0x94, 0x0f);
sensor_write_reg(client, 0x95, 0x13);
sensor_write_reg(client, 0x96, 0xff);
sensor_write_reg(client, 0x97, 0x00);
sensor_write_reg(client, 0x98, 0x38);
sensor_write_reg(client, 0x99, 0x33);
sensor_write_reg(client, 0x9a, 0x4f);
sensor_write_reg(client, 0x9b, 0x43);
sensor_write_reg(client, 0x9c, 0xf0);
sensor_write_reg(client, 0x9d, 0xf0);
sensor_write_reg(client, 0x9e, 0xf0);
sensor_write_reg(client, 0x9f, 0xff);
sensor_write_reg(client, 0xa0, 0x60);
sensor_write_reg(client, 0xa1, 0x5a);
sensor_write_reg(client, 0xa2, 0x10);
return 0;
}
int ov7690_general_control_set(struct i2c_client *client)
{
sensor_write_reg(client, 0x14, 0x20);
sensor_write_reg(client, 0x13, 0xf7);
return 0;
}
int ov7690_gama_set(struct i2c_client *client)
{
sensor_write_reg(client, 0xa3, 0x08);
sensor_write_reg(client, 0xa4, 0x15);
sensor_write_reg(client, 0xa5, 0x24);
sensor_write_reg(client, 0xa6, 0x45);
sensor_write_reg(client, 0xa7, 0x55);
sensor_write_reg(client, 0xa8, 0x6a);
sensor_write_reg(client, 0xa9, 0x78);
sensor_write_reg(client, 0xaa, 0x87);
sensor_write_reg(client, 0xab, 0x96);
sensor_write_reg(client, 0xac, 0xa3);
sensor_write_reg(client, 0xad, 0xb4);
sensor_write_reg(client, 0xae, 0xc3);
sensor_write_reg(client, 0xaf, 0xd6);
sensor_write_reg(client, 0xb0, 0xe6);
sensor_write_reg(client, 0xb1, 0xf2);
sensor_write_reg(client, 0xb2, 0x12);
return 0;
}
int ov7690_352_288(struct i2c_client *client)
{
sensor_write_reg(client,0x16,0x03);
sensor_write_reg(client,0x17,0x83);
sensor_write_reg(client,0x18,0x97);
sensor_write_reg(client,0x19,0x08);
sensor_write_reg(client,0x1a,0xf6);
sensor_write_reg(client,0x22,0x00);
sensor_write_reg(client,0xc8,0x02);
sensor_write_reg(client,0xc9,0x4c);
sensor_write_reg(client,0xca,0x01);
sensor_write_reg(client,0xcb,0xe2);
sensor_write_reg(client,0xcc,0x01);
sensor_write_reg(client,0xcd,0x60);
sensor_write_reg(client,0xce,0x01);
sensor_write_reg(client,0xcf,0x20);
return 0;
}
static int sensor_report_value(struct i2c_client *client)
{
struct sensor_private_data *sensor =
(struct sensor_private_data *) i2c_get_clientdata(client);
char buffer[8] = {0};
unsigned char *stat;
unsigned char *stat2;
int ret = 0;
char value = 0;
#ifdef SENSOR_DEBUG_TYPE
int i;
#endif
if(sensor->ops->read_len < 8) //sensor->ops->read_len = 8
{
printk("%s:lenth is error,len=%d\n",__func__,sensor->ops->read_len);
return -1;
}
memset(buffer, 0, 8);
/* Data bytes from hardware xL, xH, yL, yH, zL, zH */
do {
*buffer = sensor->ops->read_reg;
ret = sensor_rx_data(client, buffer, sensor->ops->read_len);
if (ret < 0)
return ret;
} while (0);
stat = &buffer[0];
stat2 = &buffer[7];
/*
* ST : data ready -
* Measurement has been completed and data is ready to be read.
*/
if ((*stat & 0x01) != 0x01) {
DBG(KERN_ERR "%s:ST is not set\n",__func__);
return -1;
}
/*
* ST2 : data error -
* occurs when data read is started outside of a readable period;
* data read would not be correct.
* Valid in continuous measurement mode only.
* In single measurement mode this error should not occour but we
* stil account for it and return an error, since the data would be
* corrupted.
* DERR bit is self-clearing when ST2 register is read.
*/
if (*stat2 & 0x04)
{
DBG(KERN_ERR "%s:compass data error\n",__func__);
return -2;
}
/*
* ST2 : overflow -
* the sum of the absolute values of all axis |X|+|Y|+|Z| < 2400uT.
* This is likely to happen in presence of an external magnetic
* disturbance; it indicates, the sensor data is incorrect and should
* be ignored.
* An error is returned.
* HOFL bit clears when a new measurement starts.
*/
if (*stat2 & 0x08)
{
DBG(KERN_ERR "%s:compass data overflow\n",__func__);
return -3;
}
/* »¥³âµØ»º´æÊý¾Ý. */
mutex_lock(&sensor->data_mutex);
memcpy(sensor->sensor_data, buffer, sensor->ops->read_len);
mutex_unlock(&sensor->data_mutex);
#ifdef SENSOR_DEBUG_TYPE
DBG("%s:",__func__);
for(i=0; i<sensor->ops->read_len; i++)
DBG("%d,",buffer[i]);
DBG("\n");
#endif
if((sensor->pdata->irq_enable)&& (sensor->ops->int_status_reg >= 0)) //read sensor intterupt status register
{
value = sensor_read_reg(client, sensor->ops->int_status_reg);
DBG("%s:sensor int status :0x%x\n",__func__,value);
}
//trigger next measurement
ret = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
if(ret)
{
printk(KERN_ERR "%s:fail to set ctrl_data:0x%x\n",__func__,sensor->ops->ctrl_data);
return ret;
}
return ret;
}
static int compass_akm_set_mode(struct i2c_client *client, char mode)
{
struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client);
int result = 0;
switch(mode)
{
case AK8975_MODE_SNG_MEASURE:
case AK8975_MODE_SELF_TEST:
case AK8975_MODE_FUSE_ACCESS:
if(sensor->status_cur == SENSOR_OFF)
{
if(sensor->pdata->irq_enable)
{
//DBG("%s:enable irq=%d\n",__func__,client->irq);
//enable_irq(client->irq);
}
else
{
schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
}
sensor->status_cur = SENSOR_ON;
}
break;
case AK8975_MODE_POWERDOWN:
if(sensor->status_cur == SENSOR_ON)
{
if(sensor->pdata->irq_enable)
{
//DBG("%s:disable irq=%d\n",__func__,client->irq);
//disable_irq_nosync(client->irq);//disable irq
}
else
cancel_delayed_work_sync(&sensor->delaywork);
sensor->status_cur = SENSOR_OFF;
}
break;
}
switch(mode)
{
case AK8975_MODE_SNG_MEASURE:
result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_SNG_MEASURE);
if(result)
printk("%s:i2c error,mode=%d\n",__func__,mode);
break;
case AK8975_MODE_SELF_TEST:
result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_SELF_TEST);
if(result)
printk("%s:i2c error,mode=%d\n",__func__,mode);
break;
case AK8975_MODE_FUSE_ACCESS:
result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_FUSE_ACCESS);
if(result)
printk("%s:i2c error,mode=%d\n",__func__,mode);
break;
case AK8975_MODE_POWERDOWN:
/* Set powerdown mode */
result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8975_MODE_POWERDOWN);
if(result)
printk("%s:i2c error,mode=%d\n",__func__,mode);
udelay(100);
break;
default:
printk("%s: Unknown mode(%d)", __func__, mode);
result = -EINVAL;
break;
}
DBG("%s:mode=%d\n",__func__,mode);
return result;
}
static int init_read_otp(void){
int i=0;
u16 opt_start_addr=imx219_opt_start;
int block=2;
int bank=0;
//static u32 otp_get_value;
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x0100,0x00);//write standby mode
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x0100, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x0100++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3302,0x02);//write OTP write clock
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x3302, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x3302++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3303,0x58);//write OTP write clock
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x3303, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x3303++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x012A,0x18);//write INCK
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x012A, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x012A++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x012B,0x00);//write INCK
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x012B, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x012B++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3300,0x08);//write ECC
//sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, 0x3300, (u16 *)&otp_get_value);
//pr_err("init_read_otp +0x3300++ otp_get_value =%x\n",otp_get_value);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3200,1);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3202,block);
sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, opt_start_addr+8, (u16 *)&i2c_get_value);
pr_err("init_read_otp +++ i2c_get_value =%x\n",i2c_get_value);
if( i2c_get_value!=0xa){
block=1;
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3200,1);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3202,block);
sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, opt_start_addr+8, (u16 *)&i2c_get_value);
if(i2c_get_value!=0xa){
block=0;
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3200,1);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3202,block);
sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, opt_start_addr+8, (u16 *)&i2c_get_value);
if(i2c_get_value!=0xa) return -1;
}
}
for(bank=0;bank<3;bank++){
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3200,1);
sensor_write_reg(imx219_asus_s_ctrl.sensor_i2c_client->client,0x3202,block);
for(i=0;i<8;i++){
sensor_read_reg(imx219_asus_s_ctrl.sensor_i2c_client->client, opt_start_addr+(bank*8+i), (u16 *)&i2c_get_value);
pr_err("init_read_otp page = %d bank=%x addr=%x value=%x\n",block,bank,opt_start_addr+(bank*8+i),i2c_get_value);
imx219_asus_otp_value[bank*8+i]=i2c_get_value;
}
}
#ifdef CONFIG_MSMB_CAMERA_DEBUG
for(i=0;i<opt_size;i++)
printk("imx219_asus_otp_value i=%d =%x\n",i,imx219_asus_otp_value[i]);
#endif
return 0;
}