void sync_sensor_state(struct ssp_data *data)
{
unsigned char uBuf[9] = {0,};
unsigned int uSensorCnt;
int iRet = 0;
iRet = set_gyro_cal(data);
if (iRet < 0)
ssp_errf("set_gyro_cal failed");
iRet = set_accel_cal(data);
if (iRet < 0)
ssp_errf("set_accel_cal failed");
udelay(10);
for (uSensorCnt = 0; uSensorCnt < SENSOR_MAX; uSensorCnt++) {
if (atomic64_read(&data->aSensorEnable) & (1 << uSensorCnt)) {
s32 dMsDelay
= get_msdelay(data->adDelayBuf[uSensorCnt]);
memcpy(&uBuf[0], &dMsDelay, 4);
memcpy(&uBuf[4], &data->batchLatencyBuf[uSensorCnt], 4);
uBuf[8] = data->batchOptBuf[uSensorCnt];
send_instruction(data, ADD_SENSOR, uSensorCnt, uBuf, 9);
udelay(10);
}
}
if (data->bProximityRawEnabled == true) {
s32 dMsDelay = 20;
memcpy(&uBuf[0], &dMsDelay, 4);
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, uBuf, 4);
}
set_proximity_threshold(data, data->uProxHiThresh, data->uProxLoThresh);
data->buf[PROXIMITY_SENSOR].prox = 0;
report_sensordata(data, PROXIMITY_SENSOR, &data->buf[PROXIMITY_SENSOR]);
#if 1
if(sec_debug_get_debug_level() > 0)
{
data->bMcuDumpMode = true;
ssp_info("Mcu Dump Enabled");
}
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,
data->bMcuDumpMode);
if (iRet < 0)
ssp_errf("MSG2SSP_AP_MCU_SET_DUMPMODE failed");
#else
#if CONFIG_SEC_DEBUG
data->bMcuDumpMode = sec_debug_is_enabled();
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,
data->bMcuDumpMode);
if (iRet < 0)
ssp_errf("MSG2SSP_AP_MCU_SET_DUMPMODE failed");
#endif
#endif
}
void sync_sensor_state(struct ssp_data *data)
{
unsigned char uBuf[9] = {0,};
unsigned int uSensorCnt;
int iRet = 0;
iRet = set_gyro_cal(data);
if (iRet < 0)
pr_err("[SSP]: %s - set_gyro_cal failed\n", __func__);
iRet = set_accel_cal(data);
if (iRet < 0)
pr_err("[SSP]: %s - set_accel_cal failed\n", __func__);
#ifdef CONFIG_SENSORS_SSP_SX9306
if (atomic_read(&data->aSensorEnable) & (1 << GRIP_SENSOR)) {
open_grip_caldata(data);
set_grip_calibration(data, true);
}
#endif
udelay(10);
for (uSensorCnt = 0; uSensorCnt < SENSOR_MAX; uSensorCnt++) {
mutex_lock(&data->enable_mutex);
if (atomic_read(&data->aSensorEnable) & (1 << uSensorCnt)) {
s32 dMsDelay =
get_msdelay(data->adDelayBuf[uSensorCnt]);
memcpy(&uBuf[0], &dMsDelay, 4);
memcpy(&uBuf[4], &data->batchLatencyBuf[uSensorCnt], 4);
uBuf[8] = data->batchOptBuf[uSensorCnt];
send_instruction(data, ADD_SENSOR, uSensorCnt, uBuf, 9);
udelay(10);
}
mutex_unlock(&data->enable_mutex);
}
if (data->bProximityRawEnabled == true) {
s32 dMsDelay = 20;
memcpy(&uBuf[0], &dMsDelay, 4);
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, uBuf, 4);
}
set_proximity_threshold(data, data->uProxHiThresh,data->uProxLoThresh);
data->bMcuDumpMode = ssp_check_sec_dump_mode();
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,
data->bMcuDumpMode);
if (iRet < 0)
pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n",
__func__);
}
void sync_sensor_state(struct ssp_data *data)
{
unsigned char uBuf[9] = {0,};
unsigned int uSensorCnt;
int iRet = 0;
#ifdef CONFIG_SENSORS_SSP_YAS532
iRet = set_hw_offset(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_hw_offset failed\n", __func__);
}
#endif
iRet = set_gyro_cal(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_gyro_cal failed\n", __func__);
}
iRet = set_accel_cal(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_accel_cal failed\n", __func__);
}
udelay(10);
for (uSensorCnt = 0; uSensorCnt < SENSOR_MAX; uSensorCnt++) {
if (atomic_read(&data->aSensorEnable) & (1 << uSensorCnt)) {
s32 dMsDelay = get_msdelay(data->adDelayBuf[uSensorCnt]);
memcpy(&uBuf[0], &dMsDelay, 4);
memcpy(&uBuf[4], &data->batchLatencyBuf[uSensorCnt], 4);
uBuf[8] = data->batchOptBuf[uSensorCnt];
send_instruction(data, ADD_SENSOR, uSensorCnt, uBuf, 9);
udelay(10);
}
}
if (data->bProximityRawEnabled == true) {
s32 dMsDelay = 20;
memcpy(&uBuf[0], &dMsDelay, 4);
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, uBuf, 4);
}
set_proximity_threshold(data, data->uProxHiThresh,data->uProxLoThresh);
#if SSP_SEC_DEBUG
data->bMcuDumpMode = sec_debug_is_enabled();
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,data->bMcuDumpMode);
if (iRet < 0) {
pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n", __func__);
}
#endif
}
void sync_sensor_state(struct ssp_data *data)
{
unsigned char uBuf[2] = {0,};
unsigned int uSensorCnt;
int iRet = 0;
iRet = set_hw_offset(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_hw_offset failed\n", __func__);
}
iRet = set_gyro_cal(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_gyro_cal failed\n", __func__);
}
iRet = set_accel_cal(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_accel_cal failed\n", __func__);
}
udelay(10);
for (uSensorCnt = 0; uSensorCnt < (SENSOR_MAX - 1); uSensorCnt++) {
if (atomic_read(&data->aSensorEnable) & (1 << uSensorCnt)) {
uBuf[1] = (u8)get_msdelay(data->adDelayBuf[uSensorCnt]);
uBuf[0] = (u8)get_delay_cmd(uBuf[1]);
send_instruction(data, ADD_SENSOR, uSensorCnt, uBuf, 2);
udelay(10);
}
}
if (data->bProximityRawEnabled == true) {
uBuf[0] = 1;
uBuf[1] = 20;
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, uBuf, 2);
}
set_proximity_threshold(data, data->uProxHiThresh,data->uProxLoThresh);
data->bMcuDumpMode = sec_debug_is_enabled();
iRet = ssp_send_cmd(data, MSG2SSP_AP_MCU_SET_DUMPMODE,data->bMcuDumpMode);
if (iRet < 0) {
pr_err("[SSP]: %s - MSG2SSP_AP_MCU_SET_DUMPMODE failed\n", __func__);
}
}
static int accel_do_calibrate(struct ssp_data *data, int iEnable)
{
int iSum[3] = { 0, };
int iRet = 0, iCount;
struct file *cal_filp = NULL;
mm_segment_t old_fs;
if (iEnable) {
data->accelcal.x = 0;
data->accelcal.y = 0;
data->accelcal.z = 0;
set_accel_cal(data);
iRet = enable_accel_for_cal(data);
msleep(300);
for (iCount = 0; iCount < CALIBRATION_DATA_AMOUNT; iCount++) {
iSum[0] += data->buf[ACCELEROMETER_SENSOR].x;
iSum[1] += data->buf[ACCELEROMETER_SENSOR].y;
iSum[2] += data->buf[ACCELEROMETER_SENSOR].z;
mdelay(10);
}
disable_accel_for_cal(data, iRet);
data->accelcal.x = (iSum[0] / CALIBRATION_DATA_AMOUNT);
data->accelcal.y = (iSum[1] / CALIBRATION_DATA_AMOUNT);
data->accelcal.z = (iSum[2] / CALIBRATION_DATA_AMOUNT);
if (data->accelcal.z > 0)
data->accelcal.z -= MAX_ACCEL_1G;
else if (data->accelcal.z < 0)
data->accelcal.z += MAX_ACCEL_1G;
} else {
data->accelcal.x = 0;
data->accelcal.y = 0;
data->accelcal.z = 0;
}
ssp_dbg("[SSP]: do accel calibrate %d, %d, %d\n",
data->accelcal.x, data->accelcal.y, data->accelcal.z);
old_fs = get_fs();
set_fs(KERNEL_DS);
cal_filp = filp_open(CALIBRATION_FILE_PATH,
O_CREAT | O_TRUNC | O_WRONLY, 0666);
if (IS_ERR(cal_filp)) {
pr_err("[SSP]: %s - Can't open calibration file\n", __func__);
set_fs(old_fs);
iRet = PTR_ERR(cal_filp);
return iRet;
}
iRet = cal_filp->f_op->write(cal_filp, (char *)&data->accelcal,
3 * sizeof(int), &cal_filp->f_pos);
if (iRet != 3 * sizeof(int)) {
pr_err("[SSP]: %s - Can't write the accelcal to file\n",
__func__);
iRet = -EIO;
}
filp_close(cal_filp, current->files);
set_fs(old_fs);
set_accel_cal(data);
return iRet;
}
static int ssp_remove_sensor(struct ssp_data *data,
unsigned int uChangedSensor, unsigned int uNewEnable)
{
u8 uBuf[2];
int iRet = 0;
int64_t dSensorDelay = data->adDelayBuf[uChangedSensor];
ssp_dbg("[SSP]: %s - remove sensor = %d, current state = %d\n",
__func__, (1 << uChangedSensor), uNewEnable);
data->adDelayBuf[uChangedSensor] = DEFUALT_POLLING_DELAY;
if (data->aiCheckStatus[uChangedSensor] == INITIALIZATION_STATE) {
data->aiCheckStatus[uChangedSensor] = NO_SENSOR_STATE;
if (uChangedSensor == ACCELEROMETER_SENSOR) {
accel_open_calibration(data);
iRet = set_accel_cal(data);
if (iRet < 0)
pr_err("[SSP]: %s - set_accel_cal failed %d\n", __func__, iRet);
}
else if (uChangedSensor == GYROSCOPE_SENSOR) {
gyro_open_calibration(data);
iRet = set_gyro_cal(data);
if (iRet < 0)
pr_err("[SSP]: %s - set_gyro_cal failed %d\n", __func__, iRet);
}
else if (uChangedSensor == PRESSURE_SENSOR)
pressure_open_calibration(data);
else if (uChangedSensor == PROXIMITY_SENSOR) {
proximity_open_lcd_ldi(data);
proximity_open_calibration(data);
} else if (uChangedSensor == GEOMAGNETIC_SENSOR) {
iRet = mag_open_hwoffset(data);
if (iRet < 0)
pr_err("[SSP]: %s - mag_open_hw_offset"
" failed, %d\n", __func__, iRet);
iRet = set_hw_offset(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_hw_offset failed\n",
__func__);
}
}
return 0;
} else if (uChangedSensor == ORIENTATION_SENSOR) {
if (!(atomic_read(&data->aSensorEnable)
& (1 << ACCELEROMETER_SENSOR))) {
uChangedSensor = ACCELEROMETER_SENSOR;
} else {
change_sensor_delay(data, ACCELEROMETER_SENSOR,
data->adDelayBuf[ACCELEROMETER_SENSOR]);
return 0;
}
} else if (uChangedSensor == ACCELEROMETER_SENSOR) {
if (atomic_read(&data->aSensorEnable)
& (1 << ORIENTATION_SENSOR)) {
change_sensor_delay(data, ORIENTATION_SENSOR,
data->adDelayBuf[ORIENTATION_SENSOR]);
return 0;
}
} else if (uChangedSensor == GEOMAGNETIC_SENSOR) {
if (mag_store_hwoffset(data))
pr_err("mag_store_hwoffset success\n");
}
if (!data->bSspShutdown)
if (atomic_read(&data->aSensorEnable) & (1 << uChangedSensor)) {
uBuf[1] = (u8) get_msdelay(dSensorDelay);
uBuf[0] = (u8) get_delay_cmd(uBuf[1]);
send_instruction(data, REMOVE_SENSOR, uChangedSensor, uBuf, 2);
}
data->aiCheckStatus[uChangedSensor] = NO_SENSOR_STATE;
return 0;
}
