void _config()
{
uint8_t value;
SPI_Init();
// set address width to 5 bytes.
value = ADDRESS_LENGTH - 2; // 0b11 for 5 bytes, 0b10 for 4 bytes, 0b01 for 3 bytes
_set_register(SETUP_AW, &value, 1);
// set Enhanced Shockburst retry to every 586 us, up to 5 times. If packet collisions are a problem even with AA enabled,
// then consider changing the retry delay to be different on the different stations so that they do not keep colliding on each retry.
value = 0x15;
//value = 0x10;
_set_register(SETUP_RETR, &value, 1);
// Set to use 2.4 GHz channel 110.
value = CHANNEL;
_set_register(RF_CH, &value, 1);
// Set radio to 2 Mbps and high power. Leave LNA_HCURR at its default.
value = _BV(RF_DR) | _BV(LNA_HCURR);
_set_register(RF_SETUP, &value, 1);
// Enable 2-byte CRC and power up in receive mode.
value = _BV(EN_CRC) | _BV(CRCO) | _BV(PWR_UP) | _BV(PRIM_RX);
_set_register(CONFIG, &value, 1);
send_instruction(FLUSH_TX, NULL, NULL, 0);
send_instruction(FLUSH_RX, NULL, NULL, 0);
}
static ssize_t adc_data_read(struct device *dev,
struct device_attribute *attr, char *buf)
{
bool bSuccess = false;
u8 chTempbuf[2] = {1, 20};
struct ssp_data *data = dev_get_drvdata(dev);
if (!(atomic_read(&data->aSensorEnable) & (1 << GEOMAGNETIC_SENSOR))) {
send_instruction(data, ADD_SENSOR, GEOMAGNETIC_SENSOR,
chTempbuf, 2);
msleep(200);
}
if ((data->buf[GEOMAGNETIC_SENSOR].x == 0) &&
(data->buf[GEOMAGNETIC_SENSOR].y == 0) &&
(data->buf[GEOMAGNETIC_SENSOR].z == 0))
bSuccess = false;
else
bSuccess = true;
if (!(atomic_read(&data->aSensorEnable) & (1 << GEOMAGNETIC_SENSOR)))
send_instruction(data, REMOVE_SENSOR, GEOMAGNETIC_SENSOR,
chTempbuf, 2);
pr_info("[SSP]: %s - x = %d, y = %d, z = %d\n", __func__,
data->buf[GEOMAGNETIC_SENSOR].x,
data->buf[GEOMAGNETIC_SENSOR].y,
data->buf[GEOMAGNETIC_SENSOR].z);
return sprintf(buf, "%s,%d,%d,%d\n", (bSuccess ? "OK" : "NG"),
data->buf[GEOMAGNETIC_SENSOR].x,
data->buf[GEOMAGNETIC_SENSOR].y,
data->buf[GEOMAGNETIC_SENSOR].z);
}
static ssize_t proximity_avg_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
char chTempbuf[4] = { 0 };
int iRet;
int64_t dEnable;
struct ssp_data *data = dev_get_drvdata(dev);
s32 dMsDelay = 20;
memcpy(&chTempbuf[0], &dMsDelay, 4);
iRet = kstrtoll(buf, 10, &dEnable);
if (iRet < 0)
return iRet;
if (dEnable) {
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, chTempbuf, 4);
data->bProximityRawEnabled = true;
} else {
send_instruction(data, REMOVE_SENSOR, PROXIMITY_RAW,
chTempbuf, 4);
data->bProximityRawEnabled = false;
}
return size;
}
void sync_sensor_state(struct ssp_data *data)
{
unsigned char uBuf[2] = {0,};
unsigned int uSensorCnt;
/* umfa.ssp
int iRet = 0;
proximity_open_calibration(data);
iRet = set_hw_offset(data);
if (iRet < 0) {
pr_err("[SSP]: %s - set_hw_offset 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);
}
}
/**
* Configure radio defaults and turn on the radio in receive mode.
* This configures the radio to its max-power, max-packet-header-length settings. If you want to reduce power consumption
* or increase on-air payload bandwidth, you'll have to change the config.
*/
static void configure_registers(void)
{
uint8_t value;
// set address width to 5 bytes.
value = ADDRESS_LENGTH - 2; // 0b11 for 5 bytes, 0b10 for 4 bytes, 0b01 for 3 bytes
set_register(SETUP_AW, &value, 1);
// set Enhanced Shockburst retry to every 586 us, up to 5 times. If packet collisions are a problem even with AA enabled,
// then consider changing the retry delay to be different on the different stations so that they do not keep colliding on each retry.
value = 0x15;
//value = 0x10;
set_register(SETUP_RETR, &value, 1);
// Set to use 2.4 GHz channel 110.
value = CHANNEL;
set_register(RF_CH, &value, 1);
// Set radio to 2 Mbps and high power. Leave LNA_HCURR at its default.
value = _BV(RF_DR) | _BV(LNA_HCURR);
set_register(RF_SETUP, &value, 1);
// Enable 2-byte CRC and power up in receive mode.
value = _BV(EN_CRC) | _BV(CRCO) | _BV(PWR_UP) | _BV(PRIM_RX);
set_register(CONFIG, &value, 1);
// clear the interrupt flags in case the radio's still asserting an old unhandled interrupt
value = _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT);
set_register(STATUS, &value, 1);
// flush the FIFOs in case there are old data in them.
send_instruction(FLUSH_TX, NULL, NULL, 0);
send_instruction(FLUSH_RX, NULL, NULL, 0);
}
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__);
}
int ssp_charging_motion(struct ssp_data *data, int iEnable)
{
u8 uBuf[2] = {0, 0};
if (iEnable == 1) {
send_instruction(data, ADD_LIBRARY,
SMART_ALERT_MOTION, uBuf, 2);
} else {
send_instruction(data, REMOVE_LIBRARY,
SMART_ALERT_MOTION, uBuf, 2);
}
return 0;
}
static ssize_t raw_data_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
char chTempbuf[9] = { 0 };
int iRet;
int64_t dEnable;
int iRetries = 50;
struct ssp_data *data = dev_get_drvdata(dev);
s32 dMsDelay = 20;
memcpy(&chTempbuf[0], &dMsDelay, 4);
memcpy(&chTempbuf[4], &data->batchLatencyBuf[GEOMAGNETIC_RAW], 4);
chTempbuf[8] = data->batchOptBuf[GEOMAGNETIC_RAW];
iRet = kstrtoll(buf, 10, &dEnable);
if (iRet < 0)
return iRet;
if (dEnable) {
data->buf[GEOMAGNETIC_RAW].x = 0;
data->buf[GEOMAGNETIC_RAW].y = 0;
data->buf[GEOMAGNETIC_RAW].z = 0;
send_instruction(data, ADD_SENSOR, GEOMAGNETIC_RAW,
chTempbuf, 9);
#if 0
do {
msleep(20);
if (check_data_spec(data) == SUCCESS)
break;
} while (--iRetries);
#endif
if (iRetries > 0) {
pr_info("[SSP] %s - success, %d\n", __func__, iRetries);
data->bGeomagneticRawEnabled = true;
} else {
pr_err("[SSP] %s - wait timeout, %d\n", __func__,
iRetries);
data->bGeomagneticRawEnabled = false;
}
} else {
send_instruction(data, REMOVE_SENSOR, GEOMAGNETIC_RAW,
chTempbuf, 4);
data->bGeomagneticRawEnabled = false;
}
return size;
}
static void disable_accel_for_cal(struct ssp_data *data, int iDelayChanged)
{
u8 uBuf[2] = {0, 10};
if (atomic_read(&data->aSensorEnable) & (1 << ACCELEROMETER_SENSOR)) {
uBuf[1] = get_msdelay(data->adDelayBuf[ACCELEROMETER_SENSOR]);
uBuf[0] = get_delay_cmd(uBuf[1]);
if (iDelayChanged)
send_instruction(data, CHANGE_DELAY,
ACCELEROMETER_SENSOR, uBuf, 2);
} else {
send_instruction(data, REMOVE_SENSOR,
ACCELEROMETER_SENSOR, uBuf, 2);
}
}
static void disable_accel_for_cal(struct ssp_data *data, int iDelayChanged)
{
u8 uBuf[9] = { 0, };
s32 dMsDelay = get_msdelay(data->adDelayBuf[ACCELEROMETER_SENSOR]);
memcpy(&uBuf[0], &dMsDelay, 4);
if (atomic_read(&data->aSensorEnable) & (1 << ACCELEROMETER_SENSOR)) {
if (iDelayChanged)
send_instruction(data, CHANGE_DELAY,
ACCELEROMETER_SENSOR, uBuf, 9);
} else {
send_instruction(data, REMOVE_SENSOR,
ACCELEROMETER_SENSOR, uBuf, 4);
}
}
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
}
ssize_t mcu_factorytest_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct ssp_data *data = dev_get_drvdata(dev);
char chTempBuf[2] = {0, 10};
int iRet = 0;
if (sysfs_streq(buf, "1")) {
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
data->bMcuIRQTestSuccessed = false;
data->uTimeOutCnt = 0;
iRet = send_instruction(data, FACTORY_MODE,
MCU_FACTORY, chTempBuf, 2);
if (data->uTimeOutCnt == 0)
data->bMcuIRQTestSuccessed = true;
} else {
pr_err("[SSP]: %s - invalid value %d\n", __func__, *buf);
return -EINVAL;
}
ssp_dbg("[SSP]: MCU Factory Test Start! - %d\n", iRet);
return size;
}
char k330_gyro_get_temp(struct ssp_data *data)
{
char chTempBuf[2] = { 0, 10}, chTemp = 0;
int iDelayCnt = 0, iRet = 0;
if (!(data->uSensorState & (1 << GYROSCOPE_SENSOR)))
goto exit;
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
iRet = send_instruction(data, FACTORY_MODE, GYROSCOPE_TEMP_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << GYROSCOPE_TEMP_FACTORY))
&& (iDelayCnt++ < 150)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Gyro Temp Timeout!!\n", __func__);
goto exit;
}
mdelay(5);
chTemp = (char)data->uFactorydata[0];
ssp_dbg("[SSP]: %s - %d\n", __func__, chTemp);
exit:
return chTemp;
}
static ssize_t magnetic_get_selftest(struct device *dev,
struct device_attribute *attr, char *buf)
{
bool bSelftestPassed = false;
s16 iSF_X = 0, iSF_Y = 0, iSF_Z = 0;
int iDelayCnt = 0, iRet = 0, iReties = 0;
char chTempBuf[2] = { 0, 10 };
struct ssp_data *data = dev_get_drvdata(dev);
reties:
iDelayCnt = 0;
data->uFactorydataReady = 0;
iRet = send_instruction(data, FACTORY_MODE, GEOMAGNETIC_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << GEOMAGNETIC_FACTORY))
&& (iDelayCnt++ < 50)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 50) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Magnetic Selftest Timeout!!\n", __func__);
goto exit;
}
iSF_X = (s16)((data->uFactorydata[0] << 8) + data->uFactorydata[1]);
iSF_Y = (s16)((data->uFactorydata[2] << 8) + data->uFactorydata[3]);
iSF_Z = (s16)((data->uFactorydata[4] << 8) + data->uFactorydata[5]);
iSF_X = (s16)(((int)iSF_X * ((int)data->uFuseRomData[0] + 128)) >> 8);
iSF_Y = (s16)(((int)iSF_Y * ((int)data->uFuseRomData[1] + 128)) >> 8);
iSF_Z = (s16)(((int)iSF_Z * ((int)data->uFuseRomData[2] + 128)) >> 8);
pr_info("[SSP] %s: self test x = %d, y = %d, z = %d\n",
__func__, iSF_X, iSF_Y, iSF_Z);
if ((iSF_X >= -200) && (iSF_X <= 200))
pr_info("[SSP] x passed self test, expect -200<=x<=200\n");
else
pr_info("[SSP] x failed self test, expect -200<=x<=200\n");
if ((iSF_Y >= -200) && (iSF_Y <= 200))
pr_info("[SSP] y passed self test, expect -200<=y<=200\n");
else
pr_info("[SSP] y failed self test, expect -200<=y<=200\n");
if ((iSF_Z >= -3200) && (iSF_Z <= -800))
pr_info("[SSP] z passed self test, expect -3200<=z<=-800\n");
else
pr_info("[SSP] z failed self test, expect -3200<=z<=-800\n");
if (((iSF_X >= -200) && (iSF_X <= 200)) &&
((iSF_Y >= -200) && (iSF_Y <= 200)) &&
((iSF_Z >= -3200) && (iSF_Z <= -800)))
bSelftestPassed = true;
if ((bSelftestPassed == false) && (iReties++ < 5))
goto reties;
exit:
return sprintf(buf, "%u,%d,%d,%d\n",
bSelftestPassed, iSF_X, iSF_Y, iSF_Z);
}
static ssize_t gyro_get_temp(struct device *dev,
struct device_attribute *attr, char *buf)
{
char chTempBuf[2] = { 0, 10}, chTemp = 0;
int iDelayCnt = 0, iRet = 0;
struct ssp_data *data = dev_get_drvdata(dev);
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
iRet = send_instruction(data, FACTORY_MODE, GYROSCOPE_TEMP_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << GYROSCOPE_TEMP_FACTORY))
&& (iDelayCnt++ < 150)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Gyro Temp Timeout!!\n", __func__);
goto exit;
}
chTemp = (char)data->uFactorydata[0];
ssp_dbg("[SSP]: %s - %d\n", __func__, chTemp);
exit:
return sprintf(buf, "%d\n", chTemp);
}
uint8_t Radio_Transmit(radiopacket_t* payload, RADIO_TX_WAIT wait)
{
//if (block && transmit_lock) while (transmit_lock);
//if (!block && transmit_lock) return 0;
uint8_t len = 32;
// indicate that the driver is transmitting.
transmit_lock = 1;
// disable the radio while writing to the Tx FIFO.
ioport_set_pin_low (CE);
set_tx_mode();
// for auto-ack to work, the pipe0 address must be set to the Tx address while the radio is transmitting.
// The register will be set back to the original pipe 0 address when the TX_DS or MAX_RT interrupt is asserted.
set_register(RX_ADDR_P0, (uint8_t*)tx_address, ADDRESS_LENGTH);
// transfer the packet to the radio's Tx FIFO for transmission
send_instruction(W_TX_PAYLOAD, payload, NULL, len);
// start the transmission.
ioport_set_pin_high (CE);
if (wait == RADIO_WAIT_FOR_TX)
{
while (transmit_lock);
return tx_last_status;
}
return RADIO_TX_SUCCESS;
}
static ssize_t eeprom_check_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
bool bSuccess = false;
char chTempBuf[2] = {0, 10};
int iRet, iDelayCnt = 0;
struct ssp_data *data = dev_get_drvdata(dev);
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
iRet = send_instruction(data, FACTORY_MODE, PRESSURE_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << PRESSURE_FACTORY))
&& (iDelayCnt++ < 150)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Pressure Selftest Timeout!!\n",
__func__);
goto exit;
}
bSuccess = (bool)(!!data->uFactorydata[0]);
ssp_dbg("[SSP]: %s - %u\n", __func__, bSuccess);
exit:
return snprintf(buf, PAGE_SIZE, "%d", bSuccess);
}
short mpu6500_gyro_get_temp(struct ssp_data *data)
{
char chTempBuf[2] = { 0, 10};
unsigned char reg[2];
short temperature = 0;
int iDelayCnt = 0, iRet = 0;
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
iRet = send_instruction(data, FACTORY_MODE, GYROSCOPE_TEMP_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << GYROSCOPE_TEMP_FACTORY))
&& (iDelayCnt++ < 150)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Gyro Temp Timeout!!\n", __func__);
goto exit;
}
reg[0] = data->uFactorydata[1];
reg[1] = data->uFactorydata[0];
temperature = (short) (((reg[0]) << 8) | reg[1]);
temperature = (((temperature + 521) / 340) + 35);
ssp_dbg("[SSP]: %s - %d\n", __func__, temperature);
exit:
return temperature;
}
void wake_funcs_set_prox(bool state)
{
if (main_prox_data != NULL)
{
char chTempbuf[4] = { 0 };
s32 dMsDelay = 20;
memcpy(&chTempbuf[0], &dMsDelay, 4);
if (state)
send_instruction(main_prox_data, ADD_SENSOR, PROXIMITY_RAW, chTempbuf, 4);
else
send_instruction(main_prox_data, REMOVE_SENSOR, PROXIMITY_RAW, chTempbuf, 4);
main_prox_data->bProximityRawEnabled = state;
}
}
static int enable_accel_for_cal(struct ssp_data *data)
{
u8 uBuf[2] = {0, 10};
if (atomic_read(&data->aSensorEnable) & (1 << ACCELEROMETER_SENSOR)) {
if (get_msdelay(data->adDelayBuf[ACCELEROMETER_SENSOR]) != 10) {
send_instruction(data, CHANGE_DELAY,
ACCELEROMETER_SENSOR, uBuf, 2);
return SUCCESS;
}
} else {
send_instruction(data, ADD_SENSOR,
ACCELEROMETER_SENSOR, uBuf, 2);
}
return FAIL;
}
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 unsigned char get_proximity_rawdata(struct ssp_data *data)
{
unsigned char uRowdata = 0;
char chTempbuf[2] = { 1, 20};
if (data->bProximityRawEnabled == false) {
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, chTempbuf, 2);
msleep(200);
uRowdata = data->buf[PROXIMITY_RAW].prox[0];
send_instruction(data, REMOVE_SENSOR, PROXIMITY_RAW,
chTempbuf, 2);
} else {
uRowdata = data->buf[PROXIMITY_RAW].prox[0];
}
return uRowdata;
}
static ssize_t adc_data_read(struct device *dev,
struct device_attribute *attr, char *buf)
{
bool bSuccess = false;
u8 chTempbuf[9] = { 0 };
s16 iSensorBuf[3] = {0, };
int iRetries = 10;
struct ssp_data *data = dev_get_drvdata(dev);
s32 dMsDelay = 20;
memcpy(&chTempbuf[0], &dMsDelay, 4);
memcpy(&chTempbuf[4], &data->batchLatencyBuf[GEOMAGNETIC_RAW], 4);
chTempbuf[8] = data->batchOptBuf[GEOMAGNETIC_RAW];
data->buf[GEOMAGNETIC_SENSOR].x = 0;
data->buf[GEOMAGNETIC_SENSOR].y = 0;
data->buf[GEOMAGNETIC_SENSOR].z = 0;
if (!(atomic_read(&data->aSensorEnable) & (1 << GEOMAGNETIC_SENSOR)))
send_instruction(data, ADD_SENSOR, GEOMAGNETIC_SENSOR,
chTempbuf, 9);
do {
msleep(60);
if (check_data_spec(data) == SUCCESS)
break;
} while (--iRetries);
if (iRetries > 0)
bSuccess = true;
iSensorBuf[0] = data->buf[GEOMAGNETIC_SENSOR].x;
iSensorBuf[1] = data->buf[GEOMAGNETIC_SENSOR].y;
iSensorBuf[2] = data->buf[GEOMAGNETIC_SENSOR].z;
if (!(atomic_read(&data->aSensorEnable) & (1 << GEOMAGNETIC_SENSOR)))
send_instruction(data, REMOVE_SENSOR, GEOMAGNETIC_SENSOR,
chTempbuf, 4);
pr_info("[SSP]: %s - x = %d, y = %d, z = %d\n", __func__,
iSensorBuf[0], iSensorBuf[1], iSensorBuf[2]);
return sprintf(buf, "%s,%d,%d,%d\n", (bSuccess ? "OK" : "NG"),
iSensorBuf[0], iSensorBuf[1], iSensorBuf[2]);
}
static int enable_accel_for_cal(struct ssp_data *data)
{
u8 uBuf[4] = { 0, };
s32 dMsDelay = get_msdelay(data->adDelayBuf[ACCELEROMETER_SENSOR]);
memcpy(&uBuf[0], &dMsDelay, 4);
if (atomic64_read(&data->aSensorEnable) & (1 << ACCELEROMETER_SENSOR)) {
if (get_msdelay(data->adDelayBuf[ACCELEROMETER_SENSOR]) != 10) {
send_instruction(data, CHANGE_DELAY,
ACCELEROMETER_SENSOR, uBuf, 4);
return SUCCESS;
}
} else {
send_instruction(data, ADD_SENSOR,
ACCELEROMETER_SENSOR, uBuf, 4);
}
return FAIL;
}
static ssize_t raw_data_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
char chTempbuf[2] = { 1, 20};
int iRet;
int64_t dEnable;
int iRetries = 50;
struct ssp_data *data = dev_get_drvdata(dev);
iRet = kstrtoll(buf, 10, &dEnable);
if (iRet < 0)
return iRet;
if (dEnable) {
data->buf[MAGNETIC_SENSOR].x = 0;
data->buf[MAGNETIC_SENSOR].y = 0;
data->buf[MAGNETIC_SENSOR].z = 0;
send_instruction(data, ADD_SENSOR, MAGNETIC_RAW,
chTempbuf, 2);
do {
msleep(20);
if (check_rawdata_spec(data) == SUCCESS)
break;
} while (--iRetries);
if (iRetries > 0) {
pr_info("[SSP] %s - success, %d\n", __func__, iRetries);
data->bGeomagneticRawEnabled = true;
} else {
pr_err("[SSP] %s - wait timeout, %d\n", __func__,
iRetries);
data->bGeomagneticRawEnabled = false;
}
} else {
send_instruction(data, REMOVE_SENSOR, MAGNETIC_RAW,
chTempbuf, 2);
data->bGeomagneticRawEnabled = false;
}
return size;
}
static void change_sensor_delay(struct ssp_data *data,
int iSensorType, int64_t dNewDelay)
{
u8 uBuf[2];
int64_t dTempDelay = data->adDelayBuf[iSensorType];
data->adDelayBuf[iSensorType] = dNewDelay;
if (iSensorType == ORIENTATION_SENSOR)
iSensorType = ACCELEROMETER_SENSOR;
switch (data->aiCheckStatus[iSensorType]) {
case ADD_SENSOR_STATE:
ssp_dbg("[SSP]: %s - add %u, New = %lldns\n",
__func__, 1 << iSensorType, dNewDelay);
uBuf[1] = (u8)get_msdelay(dNewDelay);
uBuf[0] = (u8)get_delay_cmd(uBuf[1]);
send_instruction(data, ADD_SENSOR, iSensorType, uBuf, 2);
data->aiCheckStatus[iSensorType] = RUNNING_SENSOR_STATE;
if (iSensorType == PROXIMITY_SENSOR) {
input_report_abs(data->prox_input_dev, ABS_DISTANCE, 1);
input_sync(data->prox_input_dev);
}
break;
case RUNNING_SENSOR_STATE:
if (dTempDelay == data->adDelayBuf[iSensorType])
break;
ssp_dbg("[SSP]: %s - Change %u, New = %lldns\n",
__func__, 1 << iSensorType, dNewDelay);
uBuf[1] = (u8)get_msdelay(dNewDelay);
uBuf[0] = (u8)get_delay_cmd(uBuf[1]);
send_instruction(data, CHANGE_DELAY, iSensorType, uBuf, 2);
break;
default:
data->aiCheckStatus[iSensorType] = ADD_SENSOR_STATE;
}
}
static u16 get_proximity_rawdata(struct ssp_data *data)
{
u16 uRowdata = 0;
char chTempbuf[4] = { 0 };
s32 dMsDelay = 20;
memcpy(&chTempbuf[0], &dMsDelay, 4);
if (data->bProximityRawEnabled == false) {
send_instruction(data, ADD_SENSOR, PROXIMITY_RAW, chTempbuf, 4);
msleep(200);
uRowdata = data->buf[PROXIMITY_RAW].prox[0];
send_instruction(data, REMOVE_SENSOR, PROXIMITY_RAW,
chTempbuf, 4);
} else {
uRowdata = data->buf[PROXIMITY_RAW].prox[0];
}
return uRowdata;
}
static int ssp_remove_sensor(struct ssp_data *data,
unsigned int uChangedSensor, unsigned int uNewEnable)
{
u8 uBuf[2];
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);
else if (uChangedSensor == GYROSCOPE_SENSOR)
gyro_open_calibration(data);
else if (uChangedSensor == PRESSURE_SENSOR)
pressure_open_calibration(data);
else if (uChangedSensor == PROXIMITY_SENSOR)
proximity_open_calibration(data);
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;
}
}
if (!uNewEnable) {
if (data->bCheckSuspend == false) {
disable_debug_timer(data);
data->bDebugEnabled = false;
}
}
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;
}
static ssize_t gyro_selftest_dps_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
int iNewDps = 0;
int iDelayCnt = 0, iRet = 0;
char chTempBuf[2] = { 0, 10 };
struct ssp_data *data = dev_get_drvdata(dev);
if (!(data->uSensorState & (1 << GYROSCOPE_SENSOR)))
goto exit;
sscanf(buf, "%d", &iNewDps);
if (iNewDps == GYROSCOPE_DPS250)
chTempBuf[0] = 0;
else if (iNewDps == GYROSCOPE_DPS500)
chTempBuf[0] = 1;
else if (iNewDps == GYROSCOPE_DPS2000)
chTempBuf[0] = 2;
else {
chTempBuf[0] = 1;
iNewDps = GYROSCOPE_DPS500;
}
data->uFactorydataReady = 0;
memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);
iRet = send_instruction(data, FACTORY_MODE, GYROSCOPE_DPS_FACTORY,
chTempBuf, 2);
while (!(data->uFactorydataReady & (1 << GYROSCOPE_DPS_FACTORY))
&& (iDelayCnt++ < 150)
&& (iRet == SUCCESS))
msleep(20);
if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {
pr_err("[SSP]: %s - Gyro Selftest DPS Timeout!!\n", __func__);
goto exit;
}
mdelay(5);
if (data->uFactorydata[0] != SUCCESS) {
pr_err("[SSP]: %s - Gyro Selftest DPS Error!!\n", __func__);
goto exit;
}
data->uGyroDps = (unsigned int)iNewDps;
pr_err("[SSP]: %s - %u dps stored\n", __func__, data->uGyroDps);
exit:
return count;
}
