static void ssp_shutdown(struct spi_device *spi)
{
struct ssp_data *data = spi_get_drvdata(spi);
pr_err("[SSP] %s, data->fw_dl_state[%d]*******************!\n",
__func__,data->fw_dl_state);
pr_err("[SSP] lpm %d recovery \n",lpcharge /*, recovery_mode*/);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
disable_debug_timer(data);
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("[SSP] %s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SHUTDOWN, 0))
pr_err("[SSP]: %s MSG2SSP_AP_STATUS_SHUTDOWN failed\n",
__func__);
ssp_enable(data, false);
clean_pending_list(data);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
free_irq(data->iIrq, data);
gpio_free(data->mcu_int1);
remove_event_symlink(data);
remove_sysfs(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
cancel_delayed_work_sync(&data->work_refresh);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->bulk_temp_read_lock);
mutex_destroy(&data->cp_temp_adc_lock);
#endif
#ifdef CONFIG_SENSORS_SSP_ATMEL
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
#endif
toggle_mcu_reset(data);
pr_info("[SSP] %s done\n", __func__);
exit:
kfree(data);
}
void debug_init(void)
{
/* 18432000 / 8 = 2304000
2304000 / 30 = 76800
so if we overflow every 30 ticks
that makes 76800 times per second,
or 2 samples per bit at 38400 baud */
OCR2A = (30-1);
TCCR2A = 1 << WGM21;
TIMSK2 = (1 << OCIE2A);
PCICR |= (1 << PCIE1);
/* detect activity on debug rx pin */
disable_debug_timer();
/* tx */
DDRC |= (1 << PORTC0);
PORTC |= (1 << PORTC0);
/* rx */
DDRC &= ~(1 << PORTC1);
PORTC |= (1 << PORTC1);
stdout = &mystdout;
stdin = &mystdout;
}
static void ssp_shutdown(struct i2c_client *client)
{
struct ssp_data *data = i2c_get_clientdata(client);
func_dbg();
disable_debug_timer(data);
disable_irq_wake(data->iIrq);
disable_irq(data->iIrq);
free_irq(data->iIrq, data);
gpio_free(data->client->irq);
toggle_mcu_reset(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_remove_sensorhub(data);
#endif
remove_event_symlink(data);
remove_sysfs(data);
remove_input_dev(data);
misc_deregister(&data->akmd_device);
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
kfree(data);
}
static void ssp_shutdown(struct spi_device *spi)
{
struct ssp_data *data = spi_get_drvdata(spi);
pr_err("[SSP] lpm %d recovery\n", lpcharge);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
disable_debug_timer(data);
//hoi
// if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SHUTDOWN, 0))
// pr_err("[SSP]: %s MSG2SSP_AP_STATUS_SHUTDOWN failed\n",
// __func__);
ssp_enable(data, false);
clean_pending_list(data);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
bbd_register(NULL, NULL);
//hoi
cancel_work_sync(&data->work_bbd_on_packet); // should be cancelled before removing iio dev
destroy_workqueue(data->bbd_on_packet_wq);
cancel_work_sync(&data->work_bbd_mcu_ready);
destroy_workqueue(data->bbd_mcu_ready_wq);
//hoi
remove_event_symlink(data);
remove_sysfs(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->bulk_temp_read_lock);
mutex_destroy(&data->cp_temp_adc_lock);
#endif
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
mutex_destroy(&data->enable_mutex);
pr_info("[SSP] %s done\n", __func__);
exit:
kfree(data);
}
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 void ssp_shutdown(struct spi_device *spi_dev)
{
struct ssp_data *data = spi_get_drvdata(spi_dev);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("%s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
ssp_enable(data, false);
clean_pending_list(data);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
disable_debug_timer(data);
free_irq(data->iIrq, data);
gpio_free(data->mcu_int1);
remove_event_symlink(data);
remove_sysfs(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->cp_temp_adc_lock);
mutex_destroy(&data->bulk_temp_read_lock);
#endif
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
#if defined(CONFIG_MACH_VIKALCU)
proximity_ldo_enable(0);
#endif
toggle_mcu_reset(data);
/* gpio_set_value_cansleep(data->rst, 0); */
pr_info("[SSP]: %s done\n", __func__);
exit:
kfree(data);
}
static int ssp_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct ssp_data *data = i2c_get_clientdata(client);
func_dbg();
disable_debug_timer(data);
if (atomic_read(&data->aSensorEnable) > 0)
ssp_sleep_mode(data);
data->bCheckSuspend = true;
return 0;
}
static void ssp_early_suspend(struct early_suspend *handler)
{
struct ssp_data *data;
data = container_of(handler, struct ssp_data, early_suspend);
func_dbg();
disable_debug_timer(data);
/* give notice to user that AP goes to sleep */
ssp_sensorhub_report_notice(data, MSG2SSP_AP_STATUS_SLEEP);
ssp_send_status_cmd(data, MSG2SSP_AP_STATUS_SLEEP);
data->bCheckSuspend = true;
}
static int ssp_suspend(struct device *dev)
{
struct spi_device *spi_dev = to_spi_device(dev);
struct ssp_data *data = spi_get_drvdata(spi_dev);
func_dbg();
disable_debug_timer(data);
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SUSPEND, 0))
pr_err("[SSP]: %s MSG2SSP_AP_STATUS_SUSPEND failed\n",
__func__);
data->uLastResumeState = MSG2SSP_AP_STATUS_SUSPEND;
disable_irq(data->iIrq);
return 0;
}
static int ssp_suspend(struct device *dev)
{
struct spi_device *spi_dev = to_spi_device(dev);
struct ssp_data *data = spi_get_drvdata(spi_dev);
ssp_infof();
data->uLastResumeState = MSG2SSP_AP_STATUS_SUSPEND;
disable_debug_timer(data);
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SUSPEND, 0))
ssp_errf("MSG2SSP_AP_STATUS_SUSPEND failed");
data->bTimeSyncing = false;
disable_irq(data->iIrq);
return 0;
}
static void ssp_shutdown(struct i2c_client *client)
{
struct ssp_data *data = i2c_get_clientdata(client);
func_dbg();
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("%s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&data->early_suspend);
#endif
disable_debug_timer(data);
if (data->bSspShutdown == false) {
data->bSspShutdown = true;
disable_irq_wake(data->iIrq);
disable_irq(data->iIrq);
}
free_irq(data->iIrq, data);
gpio_free(data->client->irq);
remove_sysfs(data);
remove_event_symlink(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
misc_deregister(&data->akmd_device);
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
toggle_mcu_reset(data);
kfree(data);
}
static void ssp_power_suspend(struct power_suspend *handler)
{
struct ssp_data *data;
data = container_of(handler, struct ssp_data, power_suspend);
func_dbg();
disable_debug_timer(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
/* give notice to user that AP goes to sleep */
ssp_sensorhub_report_notice(data, MSG2SSP_AP_STATUS_SLEEP);
ssp_sleep_mode(data);
#else
if (atomic_read(&data->aSensorEnable) > 0)
ssp_sleep_mode(data);
#endif
}
static void ssp_shutdown(struct i2c_client *client)
{
struct ssp_data *data = i2c_get_clientdata(client);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("%s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
ssp_enable(data, false);
#ifdef CONFIG_POWERSUSPEND
unregister_power_suspend(&data->power_suspend);
#endif
disable_debug_timer(data);
free_irq(data->iIrq, data);
gpio_free(data->client->irq);
remove_sysfs(data);
remove_event_symlink(data);
remove_input_dev(data);
#ifdef CONFIG_SENSORS_SSP_SENSORHUB
ssp_sensorhub_remove(data);
#endif
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
#ifdef CONFIG_SENSORS_SSP_SHTC1
mutex_destroy(&data->cp_temp_adc_lock);
#endif
toggle_mcu_reset(data);
// data->set_mcu_reset(0);
exit:
kfree(data);
}
static void ssp_shutdown(struct spi_device *spi_dev)
{
struct ssp_data *data = spi_get_drvdata(spi_dev);
ssp_infof();
if (data->bProbeIsDone == false)
goto exit;
disable_debug_timer(data);
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
ssp_errf("cancel_delayed_work_sync state = %d",
data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SHUTDOWN, 0))
ssp_errf("MSG2SSP_AP_STATUS_SHUTDOWN failed");
ssp_enable(data, false);
clean_pending_list(data);
free_irq(data->iIrq, data);
gpio_free(data->mcu_int1);
remove_sysfs(data);
remove_indio_dev(data);
ssp_sensorhub_remove(data);
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
cancel_delayed_work_sync(&data->work_refresh);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
mutex_destroy(&data->comm_mutex);
mutex_destroy(&data->pending_mutex);
toggle_mcu_reset(data);
ssp_infof("done");
exit:
kfree(data);
}
static int ssp_suspend(struct device *dev)
{
struct spi_device *spi = to_spi_device(dev);
struct ssp_data *data = spi_get_drvdata(spi);
func_dbg();
data->uLastResumeState = MSG2SSP_AP_STATUS_SUSPEND;
disable_debug_timer(data);
#if SSP_STATUS_MONITOR
cancel_delayed_work_sync(&data->polling_work);
#endif
if (SUCCESS != ssp_send_cmd(data, MSG2SSP_AP_STATUS_SUSPEND, 0))
pr_err("[SSP]: %s MSG2SSP_AP_STATUS_SUSPEND failed\n",
__func__);
data->bSuspended = true;
data->bTimeSyncing = false;
disable_irq(data->iIrq);
return 0;
}
static ssize_t set_enable_irq(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
u8 dTemp;
struct ssp_data *data = dev_get_drvdata(dev);
if (kstrtou8(buf, 10, &dTemp) < 0)
return -1;
pr_info("[SSP] %s - %d start\n", __func__, dTemp);
if (dTemp) {
reset_mcu(data);
enable_debug_timer(data);
} else if (!dTemp) {
disable_debug_timer(data);
ssp_enable(data, 0);
} else
pr_err("[SSP] %s - invalid value\n", __func__);
pr_info("[SSP] %s - %d end\n", __func__, dTemp);
return size;
}
static void ssp_shutdown(struct spi_device *spi)
{
struct ssp_data *data = spi_get_drvdata(spi);
func_dbg();
if (data->bProbeIsDone == false)
goto exit;
if (data->fw_dl_state >= FW_DL_STATE_SCHEDULED &&
data->fw_dl_state < FW_DL_STATE_DONE) {
pr_err("%s, cancel_delayed_work_sync state = %d\n",
__func__, data->fw_dl_state);
cancel_delayed_work_sync(&data->work_firmware);
}
ssp_enable(data, false);
disable_debug_timer(data);
free_irq(data->iIrq, data);
gpio_free(data->spi->irq);
remove_sensors(data);
ssp_sensorhub_remove(data);
cancel_work_sync(&data->work_reset);
del_timer_sync(&data->debug_timer);
cancel_work_sync(&data->work_debug);
destroy_workqueue(data->debug_wq);
wake_lock_destroy(&data->ssp_wake_lock);
toggle_mcu_reset(data);
mutex_destroy(&data->reset_mutex);
mutex_destroy(&data->enable_mutex);
mutex_destroy(&data->wakeup_mutex);
mutex_destroy(&data->comm_mutex);
exit:
kfree(data);
}
