// 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; }