自学教程：C++ ssp_dbg函数代码示例

int print_mcu_debug(char *pchRcvDataFrame, int *pDataIdx,		int iRcvDataFrameLength){	u16 length;	int cur = *pDataIdx;	memcpy(&length, pchRcvDataFrame + *pDataIdx, 2);	*pDataIdx += 2;	if (length > iRcvDataFrameLength - *pDataIdx || length <= 0) {		ssp_dbg("[SSP]: MSG From MCU - invalid debug length(%u/%d/%d)/n",			length, iRcvDataFrameLength, cur);		return length ? length : ERROR;	}	ssp_dbg("[SSP]: MSG From MCU - %s/n", &pchRcvDataFrame[*pDataIdx]);	*pDataIdx += length;	return 0;}

static ssize_t proximity_thresh_show(struct device *dev,	struct device_attribute *attr, char *buf){	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: uProxThresh = %u/n", data->uProxThresh);	return sprintf(buf, "%u/n", data->uProxThresh);}

static ssize_t accel_reactive_alert_store(struct device *dev,	struct device_attribute *attr, const char *buf, size_t size){	char chTempBuf[2] = {0, 10};	int iRet, iDelayCnt = 0;	struct ssp_data *data = dev_get_drvdata(dev);	if (sysfs_streq(buf, "1"))		ssp_dbg("[SSP]: %s - on/n", __func__);	else if (sysfs_streq(buf, "0"))		ssp_dbg("[SSP]: %s - off/n", __func__);	else if (sysfs_streq(buf, "2")) {		ssp_dbg("[SSP]: %s - factory/n", __func__);		data->uFactorydataReady = 0;		memset(data->uFactorydata, 0, sizeof(char) * FACTORY_DATA_MAX);		data->bAccelAlert = false;		iRet = send_instruction(data, FACTORY_MODE,				ACCELEROMETER_FACTORY, chTempBuf, 2);		while (!(data->uFactorydataReady & (1 << ACCELEROMETER_FACTORY))			&& (iDelayCnt++ < 150)			&& (iRet == SUCCESS))			msleep(20);		if ((iDelayCnt >= 150) || (iRet != SUCCESS)) {			pr_err("[SSP]: %s - accel Selftest Timeout!!/n",				__func__);			goto exit;		}		mdelay(5);		data->bAccelAlert = data->uFactorydata[0];		ssp_dbg("[SSP]: %s factory test success!/n", __func__);	} else {		pr_err("[SSP]: %s - invalid value %d/n", __func__, *buf);		return -EINVAL;	}exit:	return size;}

static ssize_t show_sensors_enable(struct device *dev,	struct device_attribute *attr, char *buf){	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: %s - cur_enable = %d/n", __func__,		 atomic_read(&data->aSensorEnable));	return sprintf(buf, "%9u/n", atomic_read(&data->aSensorEnable));}

void print_mcu_debug(char *pchRcvDataFrame, int *pDataIdx){	int iLength;	iLength = pchRcvDataFrame[0];	pchRcvDataFrame[iLength] = 0;	*pDataIdx = *pDataIdx + iLength + 2;	ssp_dbg("[SSP] MSG From MCU : %s/n", pchRcvDataFrame + 1);}

static ssize_t ir_current_show(struct device *dev,	struct device_attribute *attr, char *buf){	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: %s - Ir_Current Setting = %d/n",		__func__, data->uIr_Current);	return sprintf(buf, "%d/n", data->uIr_Current);}

static void get_factory_data(struct ssp_data *data, int iSensorData,	char *pchRcvDataFrame, int *iDataIdx){	int iIdx, iTotalLenth = 0;	unsigned int uTemp = 0;	switch (iSensorData) {	case ACCELEROMETER_FACTORY:		uTemp = (1 << ACCELEROMETER_FACTORY);		iTotalLenth = ACCEL_FACTORY_DATA_LENGTH;		break;	case GYROSCOPE_FACTORY:		uTemp = (1 << GYROSCOPE_FACTORY);		iTotalLenth = GYRO_FACTORY_DATA_LENGTH;		break;	case GEOMAGNETIC_FACTORY:		uTemp = (1 << GEOMAGNETIC_FACTORY);		iTotalLenth = MAGNETIC_FACTORY_DATA_LENGTH;		break;	case PRESSURE_FACTORY:		uTemp = (1 << PRESSURE_FACTORY);		iTotalLenth = PRESSURE_FACTORY_DATA_LENGTH;		break;	case MCU_FACTORY:		uTemp = (1 << MCU_FACTORY);		iTotalLenth = MCU_FACTORY_DATA_LENGTH;		break;	case GYROSCOPE_TEMP_FACTORY:		uTemp = (1 << GYROSCOPE_TEMP_FACTORY);		iTotalLenth = GYRO_TEMP_FACTORY_DATA_LENGTH;		break;	case GYROSCOPE_DPS_FACTORY:		uTemp = (1 << GYROSCOPE_DPS_FACTORY);		iTotalLenth = GYRO_DPS_FACTORY_DATA_LENGTH;		break;	case MCU_SLEEP_FACTORY:		uTemp = (1 << MCU_SLEEP_FACTORY);		iTotalLenth = MCU_SLEEP_FACTORY_DATA_LENGTH;		break;	case GESTURE_FACTORY:		uTemp = (1 << GESTURE_FACTORY);		iTotalLenth = GESTURE_FACTORY_DATA_LENGTH;		break;	case TEMPHUMIDITY_CRC_FACTORY:		uTemp = (1 << TEMPHUMIDITY_CRC_FACTORY);		iTotalLenth = TEMPHUMIDITY_FACTORY_DATA_LENGTH;		break;	}	ssp_dbg("[SSP]: %s - Factory test data %d/n", __func__, iSensorData);	for (iIdx = 0; iIdx < iTotalLenth; iIdx++)		data->uFactorydata[iIdx] = (u8)pchRcvDataFrame[(*iDataIdx)++];	data->uFactorydataReady = uTemp;}

static void debug_work_func(struct work_struct *work){	unsigned int uSensorCnt;	struct ssp_data *data = container_of(work, struct ssp_data, work_debug);	ssp_dbg("[SSP]: %s(%u) - Sensor state: 0x%x, RC: %u, MS: %u/n",		__func__, data->uIrqCnt, data->uSensorState, data->uResetCnt,		data->uMissSensorCnt);	if (data->fw_dl_state >= FW_DL_STATE_DOWNLOADING &&		data->fw_dl_state < FW_DL_STATE_DONE) {		pr_info("[SSP] : %s firmware downloading state = %d/n",			__func__, data->fw_dl_state);		return;	} else if (data->fw_dl_state == FW_DL_STATE_FAIL) {		pr_err("[SSP] : %s firmware download failed = %d/n",			__func__, data->fw_dl_state);		return;	}	for (uSensorCnt = 0; uSensorCnt < (SENSOR_MAX - 1); uSensorCnt++)		if (atomic_read(&data->aSensorEnable) & (1 << uSensorCnt))			print_sensordata(data, uSensorCnt);	if ((atomic_read(&data->aSensorEnable) & SSP_BYPASS_SENSORS_EN_ALL)/			&& (data->uIrqCnt == 0))		data->uIrqFailCnt++;	else		data->uIrqFailCnt = 0;	if (((data->uSsdFailCnt >= LIMIT_SSD_FAIL_CNT)		|| (data->uInstFailCnt >= LIMIT_INSTRUCTION_FAIL_CNT)		|| (data->uIrqFailCnt >= LIMIT_IRQ_FAIL_CNT)		|| ((data->uTimeOutCnt + data->uBusyCnt) > LIMIT_TIMEOUT_CNT))		&& (data->bSspShutdown == false)) {		if (data->uResetCnt < LIMIT_RESET_CNT) {			pr_info("[SSP] : %s - uSsdFailCnt(%u), uInstFailCnt(%u),"/				"uIrqFailCnt(%u), uTimeOutCnt(%u), uBusyCnt(%u)/n",				__func__, data->uSsdFailCnt, data->uInstFailCnt, data->uIrqFailCnt,				data->uTimeOutCnt, data->uBusyCnt);			reset_mcu(data);			data->uResetCnt++;		} else			ssp_enable(data, false);		data->uSsdFailCnt = 0;		data->uInstFailCnt = 0;		data->uTimeOutCnt = 0;		data->uBusyCnt = 0;		data->uIrqFailCnt = 0;	}	data->uIrqCnt = 0;}

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

int forced_to_download_binary(struct ssp_data *data, int iBinType){	int iRet = 0;	ssp_dbg("[SSP]: %s - mcu binany update!/n", __func__);	if (data->bSspShutdown == false) {		data->bSspShutdown = true;		disable_irq_wake(data->iIrq);		disable_irq(data->iIrq);	}	iRet = update_mcu_bin(data, iBinType);	if (iRet < 0) {		iRet = ERROR;		ssp_dbg("[SSP]: %s - update_mcu_bin failed!/n", __func__);		goto out;	}	iRet = initialize_mcu(data);	if (iRet < 0) {		iRet = ERROR;		ssp_dbg("[SSP]: %s - initialize_mcu failed!/n", __func__);		goto out;	}	sync_sensor_state(data);#ifdef CONFIG_SENSORS_SSP_SENSORHUB	ssp_sensorhub_report_notice(data, MSG2SSP_AP_STATUS_RESET);#endif	if (data->bSspShutdown == true) {		data->bSspShutdown = false;		enable_irq(data->iIrq);		enable_irq_wake(data->iIrq);	}	iRet = SUCCESS;out:	return iRet;}

static ssize_t proximity_cancel_show(struct device *dev,	struct device_attribute *attr, char *buf){	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: uProxThresh : hi : %u lo : %u, uProxCanc = %u/n",		data->uProxHiThresh, data->uProxLoThresh, data->uProxCanc);	return sprintf(buf, "%u,%u,%u/n", data->uProxCanc,		data->uProxHiThresh, data->uProxLoThresh);}

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

int forced_to_download_binary(struct ssp_data *data, int iBinType){	int iRet = 0;	ssp_dbg("[SSP]: %s - mcu binany update!/n", __func__);	ssp_enable(data, false);	data->fw_dl_state = FW_DL_STATE_DOWNLOADING;	pr_info("[SSP] %s, DL state = %d/n", __func__,	data->fw_dl_state);	iRet = update_mcu_bin(data, iBinType);	if (iRet < 0) {		ssp_dbg("[SSP]: %s - update_mcu_bin failed!/n", __func__);		goto out;	}	data->fw_dl_state = FW_DL_STATE_SYNC;	pr_info("[SSP] %s, DL state = %d/n", __func__, data->fw_dl_state);	iRet = initialize_mcu(data);	if (iRet < 0) {		iRet = ERROR;		ssp_dbg("[SSP]: %s - initialize_mcu failed!/n", __func__);		goto out;	}	ssp_enable(data, true);	sync_sensor_state(data);#ifdef CONFIG_SENSORS_SSP_SENSORHUB	ssp_sensorhub_report_notice(data, MSG2SSP_AP_STATUS_RESET);#endif	data->fw_dl_state = FW_DL_STATE_DONE;	pr_info("[SSP] %s, DL state = %d/n", __func__, data->fw_dl_state);	iRet = SUCCESS;out:	return iRet;}

static ssize_t accel_reactive_alert_store(struct device *dev,	struct device_attribute *attr, const char *buf, size_t size){	int iRet = 0;	char chTempBuf = 1;	struct ssp_data *data = dev_get_drvdata(dev);	struct ssp_msg *msg;	if (sysfs_streq(buf, "1"))		ssp_dbg("[SSP]: %s - on/n", __func__);	else if (sysfs_streq(buf, "0"))		ssp_dbg("[SSP]: %s - off/n", __func__);	else if (sysfs_streq(buf, "2")) {		ssp_dbg("[SSP]: %s - factory/n", __func__);		data->bAccelAlert = 0;		msg = kzalloc(sizeof(*msg), GFP_KERNEL);		msg->cmd = ACCELEROMETER_FACTORY;		msg->length = 1;		msg->options = AP2HUB_READ;		msg->data = chTempBuf;		msg->buffer = &chTempBuf;		msg->free_buffer = 0;		iRet = ssp_spi_sync(data, msg, 3000);		data->bAccelAlert = chTempBuf;		if (iRet != SUCCESS) {			pr_err("[SSP]: %s - accel Selftest Timeout!!/n", __func__);			goto exit;		}		ssp_dbg("[SSP]: %s factory test success!/n", __func__);	} else {		pr_err("[SSP]: %s - invalid value %d/n", __func__, *buf);		return -EINVAL;	}	exit: return size;}

ssize_t mcu_sleep_factorytest_show(struct device *dev,	struct device_attribute *attr, char *buf){	int iDataIdx, iSensorData = 0;	struct ssp_data *data = dev_get_drvdata(dev);	struct sensor_value fsb[SENSOR_MAX];	if (!(data->uFactorydataReady & (1 << MCU_SLEEP_FACTORY))) {		pr_err("[SSP]: %s - The Sensorhub is not ready/n", __func__);		goto exit;	}	for (iDataIdx = 0; iDataIdx < FACTORY_DATA_MAX;) {		iSensorData = (int)data->uFactorydata[iDataIdx++];		if ((iSensorData < 0) ||			(iSensorData >= (SENSOR_MAX - 1))) {			pr_err("[SSP]: %s - Mcu data frame error %d/n",				__func__, iSensorData);			goto exit;		}		data->get_sensor_data[iSensorData]((char *)data->uFactorydata,			&iDataIdx, &(fsb[iSensorData]));	}	convert_acc_data(&fsb[ACCELEROMETER_SENSOR].x);	convert_acc_data(&fsb[ACCELEROMETER_SENSOR].y);	convert_acc_data(&fsb[ACCELEROMETER_SENSOR].z);exit:	ssp_dbg("[SSP]: %s Result - "		"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%u,%u,%u,%u,%u/n", __func__,		fsb[ACCELEROMETER_SENSOR].x, fsb[ACCELEROMETER_SENSOR].y,		fsb[ACCELEROMETER_SENSOR].z, fsb[GYROSCOPE_SENSOR].x,		fsb[GYROSCOPE_SENSOR].y, fsb[GYROSCOPE_SENSOR].z,		fsb[GEOMAGNETIC_SENSOR].x, fsb[GEOMAGNETIC_SENSOR].y,		fsb[GEOMAGNETIC_SENSOR].z, fsb[PRESSURE_SENSOR].pressure[0],		fsb[PRESSURE_SENSOR].pressure[1], fsb[PROXIMITY_SENSOR].prox[1],		fsb[LIGHT_SENSOR].r, fsb[LIGHT_SENSOR].g, fsb[LIGHT_SENSOR].b,		fsb[LIGHT_SENSOR].w);	return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%u,%u,%u,%u,%u/n",		fsb[ACCELEROMETER_SENSOR].x, fsb[ACCELEROMETER_SENSOR].y,		fsb[ACCELEROMETER_SENSOR].z, fsb[GYROSCOPE_SENSOR].x,		fsb[GYROSCOPE_SENSOR].y, fsb[GYROSCOPE_SENSOR].z,		fsb[GEOMAGNETIC_SENSOR].x, fsb[GEOMAGNETIC_SENSOR].y,		fsb[GEOMAGNETIC_SENSOR].z, fsb[PRESSURE_SENSOR].pressure[0],		fsb[PRESSURE_SENSOR].pressure[1], fsb[PROXIMITY_SENSOR].prox[1],		fsb[LIGHT_SENSOR].r, fsb[LIGHT_SENSOR].g, fsb[LIGHT_SENSOR].b,		fsb[LIGHT_SENSOR].w);}

static ssize_t raw_data_logging_store(struct device *dev,	struct device_attribute *attr, const char *buf, size_t size){	u8 uBuf[4] = {0, };	int iRet;	int64_t dEnable;	struct ssp_data *data = dev_get_drvdata(dev);	s32 dMsDelay = 10;	memcpy(&uBuf[0], &dMsDelay, 4);	iRet = kstrtoll(buf, 10, &dEnable);	if (iRet < 0)		return iRet;	if (dEnable) {		ssp_dbg("[SSP]: %s - add %u, New = %dns/n",			 __func__, 1 << GEOMAGNETIC_SENSOR, dMsDelay);		iRet = send_instruction(data, GET_LOGGING, GEOMAGNETIC_SENSOR, uBuf, 4);		if (iRet == SUCCESS) {			pr_info("[SSP] %s - success/n", __func__);			data->bGeomagneticLogged = true;		} else {			pr_err("[SSP] %s - failed, %d/n", __func__, iRet);			data->bGeomagneticLogged = false;		}	} else {		iRet = send_instruction(data, REMOVE_SENSOR, GEOMAGNETIC_SENSOR, uBuf, 4);		if (iRet == SUCCESS) {			pr_info("[SSP] %s - success/n", __func__);			data->bGeomagneticLogged = false;		}		ssp_dbg("[SSP]: %s - remove sensor = %d/n",			__func__, (1 << GEOMAGNETIC_SENSOR));	}	return size;}

ssize_t mcu_update_show(struct device *dev,	struct device_attribute *attr, char *buf){	bool bSuccess = false;	int iRet = 0;	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: %s - mcu binany update!/n", __func__);	disable_irq(data->iIrq);	disable_irq_wake(data->iIrq);	iRet = update_mcu_bin(data);	if (iRet < 0) {		ssp_dbg("[SSP]: %s - update_mcu_bin failed!/n", __func__);		goto exit;	}	iRet = initialize_mcu(data);	if (iRet < 0) {		ssp_dbg("[SSP]: %s - initialize_mcu failed!/n", __func__);		goto exit;	}	sync_sensor_state(data);	enable_irq(data->iIrq);	enable_irq_wake(data->iIrq);#ifdef CONFIG_SENSORS_SSP_SENSORHUB	ssp_report_sensorhub_notice(data, MSG2SSP_AP_STATUS_RESET);#endif	bSuccess = true;exit:	return sprintf(buf, "%s/n", (bSuccess ? "OK" : "NG"));}

int remove_af_noise_register(struct remove_af_noise *af_cam){	if (af_cam->af_pdata)		af_sensor.af_pdata = af_cam->af_pdata;	if (af_cam->af_func)		af_sensor.af_func = af_cam->af_func;	if (!af_cam->af_pdata || !af_cam->af_func) {		ssp_dbg("[SSP]: %s - no af struct/n", __func__);		return ERROR;	}	return 0;}

static ssize_t set_sensors_enable(struct device *dev,	struct device_attribute *attr, const char *buf, size_t size){	int64_t dTemp;	unsigned int uNewEnable = 0, uChangedSensor = 0;	struct ssp_data *data = dev_get_drvdata(dev);	int iRet;	if (strict_strtoll(buf, 10, &dTemp) < 0)		return -1;	uNewEnable = (unsigned int)dTemp;	ssp_dbg("[SSP]: %s - new_enable = %u, old_enable = %u/n", __func__,		 uNewEnable, atomic_read(&data->aSensorEnable));	if (uNewEnable == atomic_read(&data->aSensorEnable))		return 0;	for (uChangedSensor = 0; uChangedSensor < SENSOR_MAX; uChangedSensor++)		if ((atomic_read(&data->aSensorEnable) & (1 << uChangedSensor))			!= (uNewEnable & (1 << uChangedSensor))) {		        if (!(uNewEnable & (1 << uChangedSensor)))                                ssp_remove_sensor(data, uChangedSensor,					uNewEnable); /* disable */			else { /* Change to ADD_SENSOR_STATE from KitKat */			      if (data->aiCheckStatus[uChangedSensor] == INITIALIZATION_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_lcd_ldi(data);                                               proximity_open_calibration(data);                                      }                             }                             data->aiCheckStatus[uChangedSensor] = ADD_SENSOR_STATE;			}			break;		}	atomic_set(&data->aSensorEnable, uNewEnable);	return size;}

ssize_t mcu_update_ums_bin_show(struct device *dev,	struct device_attribute *attr, char *buf){	bool bSuccess = false;	int iRet = 0;	struct ssp_data *data = dev_get_drvdata(dev);	ssp_dbg("[SSP]: %s - mcu binany update!/n", __func__);	iRet = forced_to_download_binary(data, UMS_BINARY);	if (iRet == SUCCESS)		bSuccess = true;	else		bSuccess = false;	return sprintf(buf, "%s/n", (bSuccess ? "OK" : "NG"));}

int ssp_parse_motion(struct ssp_data *data, char *dataframe, int start, int end){	int length = end - start;	char *buf = dataframe + start;;	if (length != 4)		return FAIL;	if ((buf[0] == 1) && (buf[1] == 1) && (buf[2] == SMART_ALERT_MOTION)) {		ssp_dbg("[SSP]: %s - LP MODE WAKEUP/n", __func__);		queue_work(data->lpm_motion_wq, &data->work_lpm_motion);		//report_key_event(data);		return SUCCESS;	}	return FAIL;}

static void work_function_firmware_update(struct work_struct *work){	struct ssp_data *data = container_of((struct delayed_work *)work,	struct ssp_data, work_firmware);	int iRet = 0;	pr_info("[SSP] : %s/n", __func__);	iRet = forced_to_download_binary(data, KERNEL_BINARY);	if (iRet < 0) {		ssp_dbg("[SSP]: %s - forced_to_download_binary failed!/n",			__func__);		return;	}	if (data->uCurFirmRev == SSP_INVALID_REVISION)		queue_refresh_task(data, SSP_SW_RESET_TIME);}

static ssize_t accel_calibration_show(struct device *dev,	struct device_attribute *attr, char *buf){	int iRet;	int iCount = 0;	struct ssp_data *data = dev_get_drvdata(dev);	iRet = accel_open_calibration(data);	if (iRet < 0)		pr_err("[SSP]: %s - calibration open failed/n", __func__);	ssp_dbg("[SSP] Cal data : %d %d %d - %d/n",		data->accelcal.x, data->accelcal.y, data->accelcal.z, iRet);	iCount = sprintf(buf, "%d %d %d %d/n", iRet, data->accelcal.x,			data->accelcal.y, data->accelcal.z);	return iCount;}

static void work_function_firmware_update(struct work_struct *work){	struct ssp_data *data = container_of((struct delayed_work *)work,	struct ssp_data, work_firmware);	int iRet = 0;	pr_info("[SSP] : %s/n", __func__);	iRet = forced_to_download_binary(data, KERNEL_BINARY);	if (iRet < 0) {		ssp_dbg("[SSP]: %s - forced_to_download_binary failed!/n",			__func__);		return;	}	data->uCurFirmRev = get_firmware_rev(data);	pr_info("[SSP] MCU Firm Rev : New = %8u/n", data->uCurFirmRev);}

static ssize_t proximity_thresh_store(struct device *dev,	struct device_attribute *attr, const char *buf, size_t size){	struct ssp_data *data = dev_get_drvdata(dev);	u8 uNewThresh = 0x09;	int iRet = 0;	iRet = kstrtou8(buf, 10, &uNewThresh);	if (iRet < 0)		pr_err("[SSP]: %s - kstrtoint failed.", __func__);	data->uProxThresh = uNewThresh;	set_proximity_threshold(data);	ssp_dbg("[SSP]: %s - new prox threshold = 0x%x/n",		__func__, data->uProxThresh);	return size;}