// I2C read one byte data from register
static int i2c_read_reg(struct i2c_client *client,u8 reg,u8 *data)
{
u8 databuf[2];
int res = 0;
databuf[0]= reg;
mutex_lock(&txc_info->i2c_lock);
res = i2c_master_send(client,databuf,0x1);
if(res <= 0)
{
APS_ERR("i2c_master_send function err\n");
mutex_unlock(&txc_info->i2c_lock);
return res;
}
res = i2c_master_recv(client,data,0x1);
if(res <= 0)
{
APS_ERR("i2c_master_recv function err\n");
mutex_unlock(&txc_info->i2c_lock);
return res;
}
mutex_unlock(&txc_info->i2c_lock);
return 0;
}
/*----------------------------------------------------------------------------*/
static int touch_probe(struct platform_device *pdev)
{
struct hwmsen_object obj_ps;
int err = 0;
if(!(touch_obj = kzalloc(sizeof(touch_obj), GFP_KERNEL)))
{
err = -ENOMEM;
}
memset(touch_obj, 0, sizeof(touch_obj));
if((err = misc_register(&touch_device)))
{
APS_ERR("touch_device register failed\n");
}
obj_ps.self = touch_obj;
obj_ps.polling = 0;
obj_ps.sensor_operate = touch_ps_operate;
if((err = hwmsen_attach(ID_PROXIMITY, &obj_ps)))
{
APS_ERR("attach fail = %d\n", err);
}
touch_create_attr(&touch_alsps_driver.driver);
APS_LOG("%s: OK\n", __func__);
return 0;
}
static int pa12201001_set_ps_mode(struct i2c_client *client)
{
u8 sendvalue=0;
int res = 0;
if (!txc_info->mcu_enable) {
sendvalue= PA12_LED_CURR100 | PA12_PS_PRST4;
res=i2c_write_reg(client,REG_CFG1,sendvalue);
sendvalue= PA12_PS_INT_WINDOW | PA12_PS_PERIOD12;
res=i2c_write_reg(client,REG_CFG3,sendvalue);
} else {
sendvalue= PA12_LED_CURR50 | PA12_PS_PRST4;
res=i2c_write_reg(client,REG_CFG1,sendvalue);
/* when mcu enbaled, we should set the irq as edge type*/
sendvalue= PA12_PS_INT_HYSTERESIS | PA12_PS_PERIOD12;
res=i2c_write_reg(client,REG_CFG3,sendvalue);
}
res=i2c_write_reg(client,REG_PS_SET, 0x03); //PSET, Normal Mode
if (txc_info->mcu_enable) {
// Set PS threshold
sendvalue=PA12_PS_FAR_TH_HIGH;
res=i2c_write_reg(client,REG_PS_TH,sendvalue); //set TH threshold
sendvalue=PA12_PS_NEAR_TH_LOW;
res=i2c_write_reg(client,REG_PS_TL,sendvalue); //set TL threshold
} else {
// Set PS threshold
sendvalue=PA12_PS_FAR_TH_HIGH;
res=i2c_write_reg(client,REG_PS_TH,sendvalue); //set TH threshold
sendvalue=PA12_PS_FAR_TH_LOW;
res=i2c_write_reg(client,REG_PS_TL,sendvalue); //set TL threshold
}
// Interrupt Setting
res=i2c_write_reg(client,REG_CFG2, (PA12_INT_PS | PA12_PS_MODE_NORMAL | PA12_PS_INTF_INACTIVE)); //set int mode
res = i2c_write_reg(client, REG_PS_OFFSET, PA12_PS_OFFSET_DEFAULT);
if(res < 0)
{
APS_ERR("i2c_send function err\n");
goto EXIT_ERR;
}
return 0 ;
EXIT_ERR:
APS_ERR("pa12201001 init dev fail!!!!: %d\n", res);
return res;
}
//PS enable function
int pa12201001_enable_ps(struct i2c_client *client, int enable)
{
int res;
u8 regdata=0;
u8 sendvalue=0;
if(enable == 1) //PS ON
{
printk("pa12201001 enable ps sensor\n");
res=i2c_read_reg(client,REG_CFG0,®data); //Read Status
if(res<0){
APS_ERR("i2c_read function err\n");
return res;
}else{
//sendvalue=regdata & 0xFD; //clear bit
//sendvalue=sendvalue | 0x02; //0x02 PS Flag
sendvalue=regdata & 0xFC; //clear bit-0 & bit-1
sendvalue=sendvalue | 0x02; //0x02 PS On
res=i2c_write_reg(client,REG_CFG0,sendvalue); //Write PS enable
if(res<0){
APS_ERR("i2c_write function err\n");
return res;
}
res=i2c_read_reg(client,REG_CFG0,®data); //Read Status
APS_LOG("CFG0 Status: %d\n",regdata);
}
}else{ //PS OFF
printk("pa12201001 disable ps sensor\n");
res=i2c_read_reg(client,REG_CFG0,®data); //Read Status
if(res<0){
APS_ERR("i2c_read function err\n");
return res;
}else{
APS_LOG("CFG0 Status: %d\n",regdata);
//sendvalue=regdata & 0xFD; //clear bit
sendvalue=regdata & 0xFC; //clear bit-0 & bit-1
res=i2c_write_reg(client,REG_CFG0,sendvalue); //Write PS disable
if(res<0){
APS_ERR("i2c_write function err\n");
return res;
}
}
}
return 0;
}
static void txc_set_enable(struct txc_data *txc, int enable)
{
struct i2c_client *client = txc->client;
int ret;
mutex_lock(&txc->enable_lock);
if (enable) {
mt_eint_mask(CUST_EINT_INTI_INT_NUM);
pa12201001_set_ps_mode(client);
#if defined(PA12_FAST_CAL)
pa122_run_fast_calibration(client);
#endif
} else {
input_report_abs(txc->input_dev, ABS_DISTANCE, PS_UNKONW);
input_sync(txc->input_dev);
}
ret = pa12201001_enable_ps(client, enable);
if (enable) {
mdelay(50);
mt_eint_unmask(CUST_EINT_INTI_INT_NUM);
}
if (ret < 0) {
mutex_unlock(&txc->enable_lock);
APS_ERR("pa12201001_enable_ps function err\n");
return ret;
}
mutex_unlock(&txc->enable_lock);
}
static int pa12201001_init(struct txc_data *data)
{
int ret = 0;
u8 sendvalue = 0;
struct i2c_client *client = data->client;
data->pa122_sys_run_cal = 0;
data->ps_calibvalue = PA12_PS_OFFSET_DEFAULT + PA12_PS_OFFSET_EXTRA;
data->fast_calib_flag = 0;
data->ps_data = PS_UNKONW;
ret = i2c_write_reg(client,REG_PS_SET, 0x03); //PSET, Normal Mode
sendvalue= PA12_PS_INT_HYSTERESIS | PA12_PS_PERIOD12;
ret=i2c_write_reg(client,REG_CFG3,sendvalue);
// Set PS threshold
sendvalue=PA12_PS_FAR_TH_HIGH;
ret=i2c_write_reg(client,REG_PS_TH,sendvalue); //set TH threshold
sendvalue=PA12_PS_NEAR_TH_LOW;
ret=i2c_write_reg(client,REG_PS_TL,sendvalue); //set TL threshold
ret = i2c_write_reg(client, REG_PS_OFFSET, PA12_PS_OFFSET_DEFAULT);
if(ret < 0)
{
APS_ERR("i2c_send function err\n");
return ret;
}
return ret;
}
/*----------------------------------------------------------------------------*/
static int __init touch_init(void)
{
if(platform_driver_register(&touch_alsps_driver))
{
APS_ERR("failed to register driver");
return -ENODEV;
}
return 0;
}
static int __init irrc_init ( void )
{
APS_FUN ();
if ( platform_driver_register ( &irrc_driver ) )
{
APS_ERR ( "failed to register platform driver\n" );
return -ENODEV;
}
return 0;
}
//Read PS Count : 8 bit
int pa12201001_read_ps(struct i2c_client *client, u8 *data)
{
int res;
u8 psdata = 0;
// APS_FUN(f);
res = i2c_read_reg(client,REG_PS_DATA,data); //Read PS Data
//psdata = i2c_smbus_read_byte_data(client, REG_PS_DATA);
if(res < 0){
APS_ERR("i2c_send function err\n");
}
return res;
}
/*----------------------------------------------------------------------------*/
static int __init TGesture_init(void)
{
APS_FUN();
if( platform_device_register(&TGesture_sensor))
{
printk("failed to register driver");
return 0;
}
if(platform_driver_register(&TGesture_driver))
{
APS_ERR("failed to register driver");
return -ENODEV;
}
return 0;
}
/*----------------------------------------------------------------------------*/
static ssize_t TGesture_store_key(struct device_driver *ddri, const char *buf, size_t count)
{
int enable, res;
u8 databuf[1];
if(1 == sscanf(buf, "%d", &enable))
{
enable_key = enable;
}
else
{
APS_ERR("invalid enable content: '%s', length = %d\n", buf, count);
}
return count;
}
// I2C Write one byte data to register
static int i2c_write_reg(struct i2c_client *client,u8 reg,u8 value)
{
u8 databuf[2];
int res = 0;
databuf[0] = reg;
databuf[1] = value;
res = i2c_master_send(client,databuf,0x2);
if (res < 0){
return res;
APS_ERR("i2c_master_send function err\n");
}
return 0;
}
/*----------------------------------------------------------------------------*/
static ssize_t pa12200001_store_send(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
{
struct i2c_client *client = to_i2c_client(dev);
int addr, cmd;
if(2 != sscanf(buf, "%x %x", &addr, &cmd))
{
APS_ERR("invalid format: '%s'\n", buf);
return 0;
}
i2c_write_reg(client, addr, cmd);
//****************************
return count;
}
//Read ALS Count : 16 bit
int pa12201001_read_als(struct i2c_client *client, u16 *data)
{
int res;
u8 LSB = 0;
u8 MSB = 0;
// APS_FUN(f);
res = i2c_read_reg(client, REG_ALS_DATA_LSB, &LSB); //Read PS Data
res = i2c_read_reg(client, REG_ALS_DATA_MSB, &MSB); //Read PS Data
*data = (MSB << 8) | LSB;
//psdata = i2c_smbus_read_byte_data(client, REG_PS_DATA);
if(res < 0){
APS_ERR("i2c_send function err\n");
}
return res;
}
// I2C Write one byte data to register
static int i2c_write_reg(struct i2c_client *client,u8 reg,u8 value)
{
u8 databuf[2];
int res = 0;
databuf[0] = reg;
databuf[1] = value;
mutex_lock(&txc_info->i2c_lock);
res = i2c_master_send(client,databuf,0x2);
if (res < 0){
APS_ERR("i2c_master_send function err\n");
mutex_unlock(&txc_info->i2c_lock);
return res;
}
mutex_unlock(&txc_info->i2c_lock);
return 0;
}
/*----------------------------------------------------------------------------*/
static ssize_t touch_show_ps(struct device_driver *ddri, char *buf)
{
ssize_t res;
if(!touch_obj)
{
APS_ERR("touch_obj is null!!\n");
return 0;
}
if((res = touch_read_ps(&touch_obj->ps)))
{
return snprintf(buf, PAGE_SIZE, "ERROR: %d\n", res);
}
else
{
return snprintf(buf, PAGE_SIZE, "%d\n", touch_obj->ps);
}
}
int touch_set_ps(bool val)
{
int err;
hwm_sensor_data sensor_data;
memset(&sensor_data, 0, sizeof(sensor_data));
sensor_data.values[0] = val;
sensor_data.value_divide = 1;
sensor_data.status = SENSOR_STATUS_ACCURACY_MEDIUM;
//let up layer to know
if((err = hwmsen_get_interrupt_data(ID_PROXIMITY, &sensor_data)))
{
APS_ERR("call hwmsen_get_interrupt_data fail = %d\n", err);
}
//map and store data to hwm_sensor_data
PS_VAL = val ;
return 0;
}
/*----------------------------------------------------------------------------*/
static int TGesture_create_attr(struct device_driver *driver)
{
int idx, err = 0;
int num = (int)(sizeof(TGesture_attr_list)/sizeof(TGesture_attr_list[0]));
if (driver == NULL)
{
return -EINVAL;
}
for(idx = 0; idx < num; idx++)
{
if((err = driver_create_file(driver, TGesture_attr_list[idx])))
{
APS_ERR("driver_create_file (%s) = %d\n", TGesture_attr_list[idx]->attr.name, err);
break;
}
}
return err;
}
/*----------------------------------------------------------------------------*/
static int touch_enable_ps(int enable)
{
if(tpd_ps_enable == NULL)
{
APS_ERR("ERROR: Not implement touch ps function!\n");
return 0;
}
if(enable)
{
(*tpd_ps_enable)(1);
}
else
{
(*tpd_ps_enable)(0);
}
return 0;
}
/*----------------------------------------------------------------------------*/
static int touch_unlocked_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
unsigned long arg)
{
struct touch_priv *obj = touch_obj;
int err = 0;
void __user *ptr = (void __user*) arg;
int dat;
uint32_t enable;
switch (cmd)
{
case ALSPS_SET_PS_MODE:
if(copy_from_user(&enable, ptr, sizeof(enable)))
{
err = -EFAULT;
goto err_out;
}
if(enable)
{
if((err = touch_enable_ps(1)))
{
APS_ERR("enable ps fail: %ld\n", err);
goto err_out;
}
}
else
{
if((err = touch_enable_ps(0)))
{
APS_ERR("disable ps fail: %ld\n", err);
goto err_out;
}
}
break;
case ALSPS_GET_PS_MODE:
if(copy_to_user(ptr, &enable, sizeof(enable)))
{
err = -EFAULT;
goto err_out;
}
break;
case ALSPS_GET_PS_DATA:
if((err = touch_read_ps(&obj->ps)))
{
goto err_out;
}
dat = touch_get_ps_value(obj->ps);
if(copy_to_user(ptr, &dat, sizeof(dat)))
{
err = -EFAULT;
goto err_out;
}
break;
case ALSPS_GET_PS_RAW_DATA:
if((err = touch_read_ps(&obj->ps)))
{
goto err_out;
}
dat = obj->ps;
if(copy_to_user(ptr, &dat, sizeof(dat)))
{
err = -EFAULT;
goto err_out;
}
break;
default:
APS_ERR("%s not supported = 0x%04x", __FUNCTION__, cmd);
err = -ENOIOCTLCMD;
break;
}
err_out:
return err;
}
static int __devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int retval = TPD_OK;
int panel_version = 0;
int panel_vendor = 0;
int iRetry = 3;
tinno_ts_data *ts;
int ret = 0;
if ( tpd_load_status ){
CTP_DBG("Already probed a TP, needn't to probe any more!");
return -1;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev,"need I2C_FUNC_I2C");
ret = -ENODEV;
goto err_check_functionality_failed;
}
ts = kzalloc(sizeof(*ts), GFP_KERNEL);
if (ts == NULL) {
ret = -ENOMEM;
goto err_alloc_data_failed;
}
CTP_DBG("TPD enter tpd_probe ts=0x%p, TPD_RES_X=%d, TPD_RES_Y=%d, addr=0x%x\n", ts, TPD_RES_X, TPD_RES_Y, client->addr);
memset(ts, 0, sizeof(*ts));
g_pts = ts;
client->timing = I2C_MASTER_CLOCK;
ts->client = client;
ts->start_reg = 0x00;
atomic_set( &ts->ts_sleepState, 0 );
mutex_init(&ts->mutex);
i2c_set_clientdata(client, ts);
fts_6x06_hw_init();
msleep(120);
fts_iic_init(ts);
if ( fts_6x06_isp_init(ts) ){
goto err_isp_register;
}
while (iRetry) {
ret = ft6x06_get_vendor_version(ts, &panel_vendor, &panel_version);
if ( panel_version < 0 || panel_vendor<0 || ret<0 ){
CTP_DBG("Product version is %d\n", panel_version);
fts_6x06_hw_reset();
}else{
break;
}
iRetry--;
msleep(15);
}
if ( panel_version < 0 || panel_vendor<0 || ret<0 ){
goto err_get_version;
}
#ifdef TPD_HAVE_BUTTON
tinno_update_tp_button_dim(panel_vendor);
#endif
#ifdef CONFIG_TOUCHSCREEN_FT5X05_DISABLE_KEY_WHEN_SLIDE
if ( fts_keys_init(ts) ){
fts_keys_deinit();
goto err_get_version;
}
#endif
mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
//mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
//mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
//mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 0);
mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_TYPE, tpd_eint_interrupt_handler, 1);
ts->thread = kthread_run(touch_event_handler, ts, TPD_DEVICE);
if (IS_ERR(ts->thread)){
retval = PTR_ERR(ts->thread);
TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", retval);
goto err_start_touch_kthread;
}
tpd_load_status = 1;
mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
CTP_DBG("Touch Panel Device(%s) Probe PASS\n", fts_get_vendor_name(panel_vendor));
//BEGIN <tp> <DATE20130507> <tp version> zhangxiaofei
{
extern char tpd_desc[50];
extern int tpd_fw_version;
sprintf(tpd_desc, "%s", fts_get_vendor_name(panel_vendor));
tpd_fw_version = panel_version;
}
//END <tp> <DATE20130507> <tp version> zhangxiaofei
//LINE<tp><DATE20130619><add for focaltech debug>zhangxiaofei
#ifdef FTS_CTL_IIC
if (ft_rw_iic_drv_init(client) < 0)
dev_err(&client->dev, "%s:[FTS] create fts control iic driver failed\n",
__func__);
#endif
//BEGIN <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
#if defined TPD_PROXIMITY
struct hwmsen_object obj_ps;
int err=0;
obj_ps.polling = 0;//interrupt mode
obj_ps.sensor_operate = tpd_ps_operate;
if((err = hwmsen_attach(ID_PROXIMITY, &obj_ps)))
{
APS_ERR("proxi_fts attach fail = %d\n", err);
}
else
{
APS_ERR("proxi_fts attach ok = %d\n", err);
}
#endif
//END <touch panel> <DATE20130831> <tp proximity> zhangxiaofei
//BEGIN<touch panel><date20131028><tp auto update>yinhuiyong
#if defined(FTS_AUTO_TP_UPGRADE)
focaltech_auto_upgrade();
#endif
//END<touch panel><date20131028><tp auto update>yinhuiyong
return 0;
err_start_touch_kthread:
mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
err_get_version:
err_isp_register:
#ifdef CONFIG_TOUCHSCREEN_POWER_DOWN_WHEN_SLEEP
hwPowerDown(MT65XX_POWER_LDO_VGP2, "touch");
#endif
fts_6x06_isp_exit();
mutex_destroy(&ts->mutex);
g_pts = NULL;
kfree(ts);
err_alloc_data_failed:
err_check_functionality_failed:
CTP_DBG("Touch Panel Device Probe FAIL\n");
return -1;
}
int tpd_ps_operate(void* self, uint32_t command, void* buff_in, int size_in,
void* buff_out, int size_out, int* actualout)
{
int err = 0;
int value;
hwm_sensor_data *sensor_data;
TPD_DEBUG("[proxi_5206]command = 0x%02X\n", command);
switch (command)
{
case SENSOR_DELAY:
if((buff_in == NULL) || (size_in < sizeof(int)))
{
APS_ERR("Set delay parameter error!\n");
err = -EINVAL;
}
// Do nothing
break;
case SENSOR_ENABLE:
if((buff_in == NULL) || (size_in < sizeof(int)))
{
APS_ERR("Enable sensor parameter error!\n");
err = -EINVAL;
}
else
{
value = *(int *)buff_in;
if(value)
{
if((tpd_enable_ps(1) != 0))
{
APS_ERR("enable ps fail: %d\n", err);
return -1;
}
}
else
{
if((tpd_enable_ps(0) != 0))
{
APS_ERR("disable ps fail: %d\n", err);
return -1;
}
}
}
break;
case SENSOR_GET_DATA:
if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
{
APS_ERR("get sensor data parameter error!\n");
err = -EINVAL;
}
else
{
sensor_data = (hwm_sensor_data *)buff_out;
if((err = tpd_read_ps()))
{
err = -1;;
}
else
{
sensor_data->values[0] = tpd_get_ps_value();
TPD_PROXIMITY_DBG("huang sensor_data->values[0] 1082 = %d\n", sensor_data->values[0]);
sensor_data->value_divide = 1;
sensor_data->status = SENSOR_STATUS_ACCURACY_MEDIUM;
}
}
break;
default:
APS_ERR("proxmy sensor operate function no this parameter %d!\n", command);
err = -1;
break;
}
return err;
}
int touch_ps_operate(void* self, uint32_t command, void* buff_in, int size_in,
void* buff_out, int size_out, int* actualout)
{
int err = 0;
int value;
hwm_sensor_data* sensor_data;
struct touch_priv *obj = (struct touch_priv *)self;
//APS_FUN(f);
switch (command)
{
case SENSOR_DELAY:
if((buff_in == NULL) || (size_in < sizeof(int)))
{
APS_ERR("Set delay parameter error!\n");
err = -EINVAL;
}
// Do nothing
break;
case SENSOR_ENABLE:
if((buff_in == NULL) || (size_in < sizeof(int)))
{
APS_ERR("Enable sensor parameter error!\n");
err = -EINVAL;
}
else
{
value = *(int *)buff_in;
if(value)
{
if((err = touch_enable_ps(1)))
{
APS_ERR("enable ps fail: %d\n", err);
return -1;
}
}
else
{
if((err = touch_enable_ps(0)))
{
APS_ERR("disable ps fail: %d\n", err);
return -1;
}
}
}
break;
case SENSOR_GET_DATA:
if((buff_out == NULL) || (size_out< sizeof(hwm_sensor_data)))
{
APS_ERR("get sensor data parameter error!\n");
err = -EINVAL;
}
else
{
sensor_data = (hwm_sensor_data *)buff_out;
if((err = touch_read_ps(&obj->ps)))
{
err = -1;;
}
else
{
sensor_data->values[0] = touch_get_ps_value(obj->ps);
sensor_data->value_divide = 1;
sensor_data->status = SENSOR_STATUS_ACCURACY_MEDIUM;
}
}
break;
default:
APS_ERR("proxmy sensor operate function no this parameter %d!\n", command);
err = -1;
break;
}
return err;
}
static int rpr400_enable_als(struct i2c_client *client, int enable)
{
struct PS_ALS_DATA *obj = i2c_get_clientdata(client);
u8 databuf[2];
int res = 0;
u8 buffer[1];
u8 reg_value[1];
u8 power_state, power_set;
PWR_ST pwr_st;
if(client == NULL)
{
APS_DBG("CLIENT CANN'T EQUL NULL\n");
return -1;
}
buffer[0]= REG_MODECONTROL;
res = i2c_master_send(client, buffer, 0x1);
if(res <= 0){
goto EXIT_ERR;
}
res = i2c_master_recv(client, reg_value, 0x1);
if(res <= 0){
goto EXIT_ERR;
}
power_state = reg_value[0] & 0xF;
if (MCTL_TABLE[power_state].PS == 0){
pwr_st.ps_state = CTL_STANDBY;
}else{
pwr_st.ps_state = CTL_STANDALONE;
}
if(enable){
if (pwr_st.ps_state == CTL_STANDALONE){
power_set = PWRON_PS_ALS;
databuf[0] = REG_MODECONTROL;
databuf[1] = power_set | (reg_value[0] & CLR_LOW4BIT);
res = i2c_master_send(client, databuf, 0x2);
if(res <= 0){
goto EXIT_ERR;
}
}else if (pwr_st.ps_state == CTL_STANDBY){
power_set = PWRON_ONLY_ALS;
databuf[0] = REG_MODECONTROL;
databuf[1] = power_set | (reg_value[0] & CLR_LOW4BIT);
res = i2c_master_send(client, databuf, 0x2);
if(res <= 0){
goto EXIT_ERR;
}
}
/*modify ps to ALS below two lines */
atomic_set(&obj->als_deb_on, 1);
atomic_set(&obj->als_deb_end, jiffies+atomic_read(&obj->als_debounce)/(1000/HZ));
}else{
if (pwr_st.ps_state == CTL_STANDALONE){
power_set = PWRON_ONLY_PS;
databuf[0] = REG_MODECONTROL;
databuf[1] = power_set | (reg_value[0] & CLR_LOW4BIT);
res = i2c_master_send(client, databuf, 0x2);
if(res <= 0){
goto EXIT_ERR;
}
}else if (pwr_st.ps_state == CTL_STANDBY){
power_set = PWRON_STANDBY;
databuf[0] = REG_MODECONTROL;
databuf[1] = power_set | (reg_value[0] & CLR_LOW4BIT);
res = i2c_master_send(client, databuf, 0x2);
if(res <= 0){
goto EXIT_ERR;
}
}
atomic_set(&obj->als_deb_on, 0);
}
return 0;
EXIT_ERR:
APS_ERR("rpr400_enable_als fail\n");
return res;
}
