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