| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "oslo_config_test" |
| |
| #include <errno.h> |
| #include <getopt.h> |
| #include <inttypes.h> |
| #include <limits.h> |
| #include <log/log.h> |
| #include <math.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <time.h> |
| #include <unistd.h> |
| |
| #include "oslo_iaxxx_sensor_control.h" |
| #include "oslo_sound_model_control.h" |
| |
| #define GETOPT_HELP_CHAR (CHAR_MIN - 2) |
| |
| #define BGT60TR24C_NUM_REGISTERS 0x60 |
| |
| /* Oslo Calibration */ |
| #define CAL_FILE "/persist/oslo/oslo.cal" |
| #define CAL_MODES_MAX 10 |
| #define CAL_INVALID_MODE -1 |
| #define CAL_MODE_IS_VALID(x) (x >= 0 && x < CAL_MODES_MAX) |
| #define CAL_VERSION_DEFAULT 1.0f |
| |
| /* Transmit power */ |
| #define TX_CAL_FILE "/persist/oslo/tx_power.cal" |
| |
| typedef enum { |
| INJECT_MODE_OFF = 0, |
| INJECT_MODE_PRESENCE, |
| INJECT_MODE_REACH, |
| INJECT_MODE_NUM, |
| } oslo_inject_mode_t; |
| |
| typedef struct { |
| int setting_id; |
| char *setting_name; |
| } oslo_settings_t; |
| |
| /* map oslo driver setting name to param id */ |
| static const oslo_settings_t oslo_driver_settings[] = |
| { |
| {SENSOR_PARAM_FRAMES_PROCESSED, "frames_processed"}, |
| {SENSOR_PARAM_PRESET_RADAR_CONFIG, "preset_radar_config"}, |
| {OSLO_CONFIG_DEFAULT, "config_default"}, |
| {OSLO_CONFIG_PRESENCE, "config_presence"}, |
| {OSLO_CONFIG_CONTINUOUS, "config_continuous"}, |
| {OSLO_CONFIG_PRESENCE_SLOW, "config_presence_slow"}, |
| {OSLO_CONFIG_FACTORY_PRESENCE, "config_factory_presence"}, |
| {OSLO_CONFIG_FACTORY_REACH, "config_factory_reach"}, |
| {OSLO_CONFIG_CW_MODE, "config_cw_mode"}, |
| {OSLO_CONFIG_FACTORY_PRESENCE_V1, "config_factory_presence_v1"}, |
| {OSLO_CONFIG_FACTORY_REACH_V1, "config_factory_reach_v1"}, |
| {OSLO_CONFIG_REACH, "config_reach"}, |
| {OSLO_CONFIG_PRESENCE_V1, "config_presence_v1"}, |
| {OSLO_CONFIG_REACH_V1, "config_reach_v1"}, |
| {OSLO_CONFIG_OFF, "config_off"}, |
| {OSLO_CONTROL_RESTART, "oslo_control_restart"}, |
| {OSLO_CONTROL_STRIP_HEADERS, "oslo_control_strip_headers"}, |
| {OSLO_CONTROL_SLPI_INT, "oslo_control_slpi_interrupt"}, |
| {OSLO_CONTROL_STOP, "oslo_control_stop"}, |
| {OSLO_CONTROL_SIMULATE_RADAR_DATA, "oslo_control_simulate_radar_data"}, |
| {OSLO_CONTROL_ASSERT_RESET, "oslo_control_assert_reset"}, |
| {OSLO_PARAM_REQUEST_RATE, "param_request_rate"}, |
| {OSLO_PARAM_REQUEST_ANTENNA_MASK, "param_request_antenna_mask"}, |
| {OSLO_PARAM_TX_POWER, "param_tx_power"}, |
| {OSLO_PARAM_LOWER_FREQ, "param_lower_freq"}, |
| {OSLO_PARAM_UPPER_FREQ, "param_upper_freq"}, |
| {OSLO_PARAM_SAMPLES_PER_CHIRP, "param_samples_per_chirp"}, |
| {OSLO_PARAM_VGA_GAIN_CH1, "param_vga_gain_ch1"}, |
| {OSLO_PARAM_VGA_GAIN_CH2, "param_vga_gain_ch2"}, |
| {OSLO_PARAM_VGA_GAIN_CH3, "param_vga_gain_ch3"}, |
| {OSLO_PARAM_VGA_GAIN_CH4, "param_vga_gain_ch4"}, |
| {OSLO_PARAM_BURST_CHIRP_COUNT, "param_burst_chirp_count"}, |
| {OSLO_PARAM_BURST_CHIRP_RATE, "param_burst_chirp_rate"}, |
| {OSLO_PARAM_BURST_POWER_MODE, "param_burst_power_mode"}, |
| {OSLO_PARAM_BURST_INTERCHIRP_POWER_MODE, "param_burst_interchirp_power_mode"}, |
| {OSLO_PARAM_STARTUP_TIMING_WAKE_UP_TIME_100NS, "param_startup_timing_wake_up_time_100ns"}, |
| {OSLO_PARAM_STARTUP_TIMING_PLL_SETTLE_TIME_COARSE_100NS,"param_startup_timing_pll_settle_time_coarse_100ns"}, |
| {OSLO_PARAM_STARTUP_TIMING_PLL_SETTLE_TIME_FINE_100NS, "param_startup_timing_pll_settle_time_fine_100ns"}, |
| {OSLO_PARAM_STARTUP_TIMING_OSCILLATOR_USEC, "param_startup_timing_oscillator_usec"}, |
| {OSLO_PARAM_PRE_CHIRP_DELAY_100NS, "param_pre_chirp_delay_100ns"}, |
| {OSLO_PARAM_POST_CHIRP_DELAY_100NS, "param_post_chirp_delay_100ns"}, |
| {OSLO_PARAM_CHIRP_PA_DELAY_100NS, "param_chirp_pa_delay_100ns"}, |
| {OSLO_PARAM_CHIRP_ADC_DELAY_100NS, "param_chirp_adc_delay_100ns"}, |
| {OSLO_PARAM_VISUALIZER_DATA_TYPE, "param_visualizer_data_type"}, |
| {OSLO_PARAM_OSCILLATOR_MODE, "param_oscillator_mode"}, |
| {OSLO_PARAM_HP_GAIN_CH1, "param_hp_gain_ch1"}, |
| {OSLO_PARAM_HP_GAIN_CH2, "param_hp_gain_ch2"}, |
| {OSLO_PARAM_HP_GAIN_CH3, "param_hp_gain_ch3"}, |
| {OSLO_PARAM_HP_GAIN_CH4, "param_hp_gain_ch4"}, |
| {OSLO_PARAM_BASEBAND_RESET_PERIOD_1NS, "param_baseband_reset_period_1ns"}, |
| {OSLO_PARAM_HP_CUTOFF_CH1, "param_hp_cutoff_ch1"}, |
| {OSLO_PARAM_HP_CUTOFF_CH2, "param_hp_cutoff_ch2"}, |
| {OSLO_PARAM_HP_CUTOFF_CH3, "param_hp_cutoff_ch3"}, |
| {OSLO_PARAM_HP_CUTOFF_CH4, "param_hp_cutoff_ch4"}, |
| {OSLO_PARAM_PHASE_CONFIG, "param_phase_config"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_PLL, "param_idle_settings_enable_pll"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_VCO, "param_idle_settings_enable_vco"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_FDIV, "param_idle_settings_enable_fdiv"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_BASEBAND, "param_idle_settings_enable_baseband"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_RF, "param_idle_settings_enable_rf"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_MADC, "param_idle_settings_enable_madc"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_MADC_BANDGAP, "param_idle_settings_enable_madc_bandgap"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_SADC, "param_idle_settings_enable_sadc"}, |
| {OSLO_PARAM_IDLE_SETTINGS_ENABLE_SADC_BANDGAP, "param_idle_settings_enable_sadc_bandgap"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_PLL, "param_deep_sleep_settings_enable_pll"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_VCO, "param_deep_sleep_settings_enable_vco"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_FDIV, "param_deep_sleep_settings_enable_fdiv"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_BASEBAND, "param_deep_sleep_settings_enable_baseband"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_RF, "param_deep_sleep_settings_enable_rf"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_MADC, "param_deep_sleep_settings_enable_madc"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_MADC_BANDGAP, "param_deep_sleep_settings_enable_madc_bandgap"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_SADC, "param_deep_sleep_settings_enable_sadc"}, |
| {OSLO_PARAM_DEEP_SLEEP_SETTINGS_ENABLE_SADC_BANDGAP, "param_deep_sleep_settings_enable_sadc_bandgap"}, |
| {OSLO_PARAM_CHIRP_DIRECTION, "param_chirp_direction"}, |
| {OSLO_PARAM_ADC_SAMPLE_RATE, "param_adc_sample_rate"}, |
| {OSLO_PARAM_CHARGE_PUMP, "param_charge_pump"}, |
| }; |
| |
| /* map oslo plugin setting name to param id */ |
| static const oslo_settings_t oslo_plugin_settings[] = |
| { |
| {OSLO_SENSOR_PARAM_MODE, "plugin_mode"}, |
| {OSLO_SENSOR_PARAM_SLPY_STATE, "plugin_slpy_state"}, |
| {OSLO_SENSOR_PARAM_ENABLE_SLPY_RAW, "plugin_slpy_raw"}, |
| {OSLO_SENSOR_PARAM_HOST, "plugin_set_host"}, |
| {OSLO_SENSOR_STATE, "plugin_oslo_state"}, |
| {OSLO_SENSOR_CONFIG_RECOVERY_COUNTER, "plugin_config_retries"}, |
| {OSLO_SENSOR_PARAM_ENABLE_PRESENCE, "plugin_enable_presence"}, |
| {OSLO_SENSOR_PARAM_ENABLE_REACH, "plugin_enable_reach"}, |
| {OSLO_SENSOR_PARAM_ENABLE_FLICK, "plugin_enable_flick"}, |
| {OSLO_SENSOR_PARAM_ENABLE_SWIPE, "plugin_enable_swipe"}, |
| {OSLO_SENSOR_PARAM_ENABLE_TAP, "plugin_enable_tap"}, |
| {OSLO_SENSOR_PARAM_ENABLE_AUDIO_FILTER, "plugin_enable_audio_filter"}, |
| {OSLO_SENSOR_PARAM_ENABLE_WLC_FILTER, "plugin_enable_wlc_filter"}, |
| {OSLO_SENSOR_PARAM_CPS, "plugin_cps"}, |
| {OSLO_SENSOR_MAX_POWER_MODE, "plugin_max_power_mode"}, |
| {OSLO_SENSOR_PARAM_SLPY_TEST_MODE, "plugin_slpy_test_mode"}, |
| }; |
| |
| /* map oslo plugin test mode name to param id */ |
| static const oslo_settings_t oslo_plugin_test_mode[] = |
| { |
| {OSLO_TESTMODE_RESET, "reset"}, |
| {OSLO_TESTMODE_PRESENCE_ON, "presence_on"}, |
| {OSLO_TESTMODE_PRESENCE_OFF, "presence_off"}, |
| {OSLO_TESTMODE_SWIPE, "swipe"}, |
| {OSLO_TESTMODE_FLICK, "flick"}, |
| {OSLO_TESTMODE_REACH_IN, "reach_in"}, |
| {OSLO_TESTMODE_REACH_OUT, "reach_out"}, |
| {OSLO_TESTMODE_REACH_SWIPE, "reach+swipe"}, |
| {OSLO_TESTMODE_REACH_FLICK, "reach+flick"}, |
| {OSLO_TESTMODE_REACH_SWIPE_FLICK, "reach+swipe+flick"}, |
| }; |
| #define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x]))))) |
| #define OSLO_DRIVER_SETTINGS_SIZE COUNT_OF(oslo_driver_settings) |
| #define OSLO_PLUGIN_SETTINGS_SIZE COUNT_OF(oslo_plugin_settings) |
| #define OSLO_PLUGIN_TESTMODE_SIZE COUNT_OF(oslo_plugin_test_mode) |
| |
| struct cal_coefficient { |
| float version; |
| int mode; |
| float ch1_i_val; |
| float ch1_q_val; |
| float ch2_i_val; |
| float ch2_q_val; |
| float ch3_i_val; |
| float ch3_q_val; |
| }; |
| static struct cal_coefficient cal_table[CAL_MODES_MAX]; |
| static uint32_t tx_power_cal; |
| |
| static struct option const long_options[] = |
| { |
| {"setparamid", required_argument, NULL, 's'}, |
| {"value", required_argument, NULL, 'v'}, |
| {"getparamid", required_argument, NULL, 'g'}, |
| {"ping", required_argument, NULL, 'p'}, |
| {"route", required_argument, NULL, 'r'}, |
| {"readregister", required_argument, NULL, 'd'}, |
| {"writeregister", required_argument, NULL, 'w'}, |
| {"calibration", required_argument, NULL, 'c'}, |
| {"tx power cal", required_argument, NULL, 'e'}, |
| {"injection", required_argument, NULL, 'i'}, |
| {"help", no_argument, NULL, GETOPT_HELP_CHAR}, |
| {NULL, 0, NULL, 0} |
| }; |
| |
| void usage() { |
| fputs("\ |
| USAGE -\n\ |
| -------\n\ |
| 1) oslo_config_test -s <param_name> -v <param_val>\n\ |
| 2) oslo_config_test -g <param_name>\n\ |
| \n\ |
| In the first form, set a parameter with a value.\n\ |
| In the second form, get a value of a parameter\n\ |
| \n\ |
| 3) oslo_config_test -p <timeout>\n\ |
| 4) oslo_config_test -r <1/0>\n\ |
| 5) oslo_config_test -d <reg_addr>\n\ |
| 6) oslo_config_test -w <reg_addr> -v <reg_val>\n\ |
| 7) oslo_config_test -c 'V:<ver> M:<mode> <ch1 I_val> <ch1 Q_val> <ch2 I_val> <ch2 Q_val> <ch3 I_val> <ch3 Q_val>' \n\ |
| 8) oslo_config_test -t <test_mode> -v <elapsed time>\n\ |
| 9) oslo_config_test -i <0/1/2> # 0:off 1:entrance 2:interactive \n\ |
| 10) oslo_config_test -e '<tx_val>'\n\ |
| ", stdout); |
| |
| fputs("\n\ |
| OPTIONS - \n\ |
| ---------\n\ |
| -s Set a parameter using its <param_name>.\n\ |
| -v Set this value for the parameter ID that was passed with\n\ |
| the option '-s'. Using this option alone is invalid.\n\ |
| -g Get the value of a parameter using its <param_name>.\n\ |
| -p Ping oslo sensor.\n\ |
| -r Set sensor route.\n\ |
| -d Read register.\n\ |
| -w Write register.\n\ |
| -c Store Calibration coefficients to persist file.\n\ |
| -t Set the system into a test mode with optional gesture detection spoofing.\n\ |
| -i Set the system into data injection mode.\n\ |
| -e Store Tx power calibration to persist file.\n\ |
| ", stdout); |
| |
| fputs("\n\ |
| List of all <param_name>\n\ |
| ---------\ |
| ", stdout); |
| fputs("\n", stdout); |
| |
| unsigned int i; |
| for (i = 0; i < OSLO_DRIVER_SETTINGS_SIZE; i++) { |
| fprintf(stdout, " %s\n", oslo_driver_settings[i].setting_name, stdout); |
| } |
| for (i = 0; i < OSLO_PLUGIN_SETTINGS_SIZE; i++) { |
| fprintf(stdout, " %s\n", oslo_plugin_settings[i].setting_name, stdout); |
| } |
| |
| fputs("\n\ |
| List of all <test_mode>\n\ |
| ---------\ |
| ", stdout); |
| fputs("\n", stdout); |
| |
| for (i = 0; i < OSLO_PLUGIN_TESTMODE_SIZE; i++) { |
| fprintf(stdout, " %s\n", oslo_plugin_test_mode[i].setting_name, stdout); |
| } |
| |
| exit(EXIT_FAILURE); |
| } |
| |
| int oslo_driver_setting_lookup(char *in) |
| { |
| unsigned int i; |
| int ret = -1; |
| |
| for (i = 0; i < OSLO_DRIVER_SETTINGS_SIZE; i++) |
| { |
| if (strcmp(in, oslo_driver_settings[i].setting_name) == 0) |
| { |
| ret = oslo_driver_settings[i].setting_id; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| int oslo_plugin_setting_lookup(char *in) |
| { |
| unsigned int i; |
| int ret = -1; |
| |
| for (i = 0; i < OSLO_PLUGIN_SETTINGS_SIZE; i++) |
| { |
| if (strcmp(in, oslo_plugin_settings[i].setting_name) == 0) |
| { |
| ret = oslo_plugin_settings[i].setting_id; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| int oslo_plugin_test_mode_lookup(char *in) |
| { |
| unsigned int i; |
| int ret = -1; |
| |
| for (i = 0; i < OSLO_PLUGIN_TESTMODE_SIZE; i++) |
| { |
| if (strcmp(in, oslo_plugin_test_mode[i].setting_name) == 0) |
| { |
| ret = oslo_plugin_test_mode[i].setting_id; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| void oslo_enable(struct ia_sensor_mgr *smd, bool enable) { |
| if (enable) { |
| osloSoundModelEnable(true); |
| oslo_driver_set_param(smd, OSLO_CONTROL_RESTART, 1); |
| } |
| else { |
| oslo_driver_set_param(smd, OSLO_CONTROL_STOP, 0); |
| sleep(1); |
| osloSoundModelEnable(false); |
| } |
| } |
| |
| bool ping_test(struct ia_sensor_mgr *smd, uint32_t ping_timeout_sec) { |
| bool ret = false; |
| uint32_t radar_frames_initial; |
| time_t start_time; |
| |
| oslo_enable(smd, true); |
| |
| start_time = time(NULL); |
| radar_frames_initial = oslo_driver_get_param(smd, SENSOR_PARAM_FRAMES_PROCESSED); |
| |
| do { |
| uint32_t radar_frames = oslo_driver_get_param(smd, SENSOR_PARAM_FRAMES_PROCESSED); |
| if (radar_frames > radar_frames_initial) { |
| ALOGD("%s: frame number increased (%d, %d)", |
| __func__, radar_frames_initial, radar_frames); |
| ret = true; |
| break; |
| } |
| else |
| usleep(50 * 1000); // 50ms |
| } while (difftime(time(NULL), start_time) <= ping_timeout_sec); |
| |
| oslo_enable(smd, false); |
| |
| ALOGD("%s: %s", __func__, (ret ? "PASS" : "FAIL")); |
| fprintf(stdout, "%s: %s\n", __func__, (ret ? "PASS" : "FAIL")); |
| |
| return ret; |
| } |
| |
| void read_register(struct ia_sensor_mgr *smd, uint32_t reg_addr) { |
| uint32_t reg_val; |
| |
| if (reg_addr >= BGT60TR24C_NUM_REGISTERS) { |
| fprintf(stdout, "Invalid reg addr:0x%02x\n", reg_addr); |
| return; |
| } |
| |
| reg_val = oslo_driver_get_param(smd, OSLO_REGISTER_MIN + reg_addr); |
| |
| ALOGD("reg[0x%02x]: 0x%06x\n", reg_addr, reg_val); |
| fprintf(stdout, "reg[0x%02x]: 0x%06x\n", reg_addr, reg_val); |
| } |
| |
| void write_register(struct ia_sensor_mgr *smd, uint32_t reg_addr, uint32_t reg_val) { |
| if (reg_addr >= BGT60TR24C_NUM_REGISTERS) { |
| fprintf(stdout, "Invalid reg addr:0x%02x\n", reg_addr); |
| return; |
| } |
| |
| oslo_driver_set_param(smd, OSLO_REGISTER_MIN + reg_addr, reg_val); |
| |
| ALOGD("Write reg[0x%02x] val:0x%06x\n", reg_addr, reg_val); |
| fprintf(stdout, "Write reg[0x%02x] val:0x%06x\n", reg_addr, reg_val); |
| } |
| |
| int cal_read_persist(void) { |
| FILE *fid; |
| struct cal_coefficient coef; |
| |
| fid = fopen(CAL_FILE, "r"); |
| if (fid == NULL) { |
| ALOGD("%s: Cannot open '%s'\n", __func__, CAL_FILE); |
| return -errno; |
| } |
| |
| while (!feof(fid)) { |
| int num; |
| |
| memset(&coef, 0, sizeof(coef)); |
| coef.mode = CAL_INVALID_MODE; |
| |
| num = fscanf(fid, "Version: %f\n", &coef.version); |
| if (num != 1) { |
| ALOGE("%s: Parse Version failed, num:%d\n", __func__, num); |
| coef.version = CAL_VERSION_DEFAULT; |
| } |
| |
| num = fscanf(fid, "Mode: %d\n", &coef.mode); |
| if (num != 1) { |
| ALOGE("%s: Parse Mode failed, num:%d\n", __func__, num); |
| break; |
| } |
| |
| num = fscanf(fid, "ch1: %f %f\n", &coef.ch1_i_val, &coef.ch1_q_val); |
| if (num != 2) { |
| ALOGE("%s: Parse ch1 failed, num:%d\n", __func__, num); |
| break; |
| } |
| |
| num = fscanf(fid, "ch2: %f %f\n", &coef.ch2_i_val, &coef.ch2_q_val); |
| if (num != 2) { |
| ALOGE("%s: Parse ch2 failed, num:%d\n", __func__, num); |
| break; |
| } |
| |
| num = fscanf(fid, "ch3: %f %f\n", &coef.ch3_i_val, &coef.ch3_q_val); |
| if (num != 2) { |
| ALOGE("%s: Parse ch3 failed, num:%d\n", __func__, num); |
| break; |
| } |
| |
| if (CAL_MODE_IS_VALID(coef.mode)) { |
| memcpy(&cal_table[coef.mode], &coef, sizeof(coef)); |
| ALOGD("%s: %.1f %d %f %f %f %f %f %f\n", __func__, |
| coef.version, |
| coef.mode, |
| coef.ch1_i_val, coef.ch1_q_val, |
| coef.ch2_i_val, coef.ch2_q_val, |
| coef.ch3_i_val, coef.ch3_q_val); |
| } else { |
| ALOGE("%s: Invalid mode:%d\n", __func__, coef.mode); |
| } |
| } |
| |
| fclose(fid); |
| |
| return 0; |
| } |
| |
| int cal_write_persist(const struct cal_coefficient* coef) { |
| FILE *fid; |
| |
| if (!coef) { |
| ALOGE("%s: Invalid coef", __func__); |
| fprintf(stdout, "%s: Invalid coef\n", __func__); |
| return -EINVAL; |
| } |
| |
| if (!CAL_MODE_IS_VALID(coef->mode)) { |
| ALOGE("%s: Invalid mode:%d", __func__, coef->mode); |
| fprintf(stdout, "%s: Invalid mode:%d\n", __func__, coef->mode); |
| return -EINVAL; |
| } |
| |
| fid = fopen(CAL_FILE, "w"); |
| if (fid == NULL) { |
| ALOGE("Cannot open '%s' (%s)\n", CAL_FILE, strerror(errno)); |
| fprintf(stdout, "Cannot open '%s' (%s)\n", CAL_FILE, strerror(errno)); |
| return -errno; |
| } |
| |
| memcpy(&cal_table[coef->mode], coef, sizeof(struct cal_coefficient)); |
| for (int i = 0; i < CAL_MODES_MAX; i++) { |
| if (CAL_MODE_IS_VALID(cal_table[i].mode)) { |
| fprintf(fid, "Version: %.1f\n", cal_table[i].version); |
| fprintf(fid, "Mode: %u\n", cal_table[i].mode); |
| fprintf(fid, "ch1: %f %f\n", |
| cal_table[i].ch1_i_val, |
| cal_table[i].ch1_q_val); |
| fprintf(fid, "ch2: %f %f\n", |
| cal_table[i].ch2_i_val, |
| cal_table[i].ch2_q_val); |
| fprintf(fid, "ch3: %f %f\n", |
| cal_table[i].ch3_i_val, |
| cal_table[i].ch3_q_val); |
| ALOGD("%s: %.1f %d %f %f %f %f %f %f\n", __func__, |
| cal_table[i].version, |
| cal_table[i].mode, |
| cal_table[i].ch1_i_val, cal_table[i].ch1_q_val, |
| cal_table[i].ch2_i_val, cal_table[i].ch2_q_val, |
| cal_table[i].ch3_i_val, cal_table[i].ch3_q_val); |
| } |
| } |
| |
| fclose(fid); |
| |
| return 0; |
| } |
| |
| static int read_tx_power_from_persist(void) { |
| FILE *fid; |
| uint32_t tx_power = 0; |
| |
| fid = fopen(TX_CAL_FILE, "r"); |
| if (fid == NULL) { |
| ALOGD("%s: Cannot open '%s'\n", __func__, TX_CAL_FILE); |
| return -errno; |
| } |
| |
| while (!feof(fid)) { |
| int num; |
| num = fscanf(fid, "tx_power: %d\n", &tx_power); |
| if (num != 1) { |
| ALOGE("%s: Parse tx power failed, num:%d\n", __func__, num); |
| break; |
| } |
| |
| memcpy(&tx_power_cal, &tx_power, sizeof(tx_power)); |
| ALOGD("%s: tx_power: %d\n", __func__, tx_power); |
| } |
| |
| fclose(fid); |
| return 0; |
| } |
| |
| static int write_tx_power_to_persist(const uint32_t* tx_power) { |
| FILE *fid; |
| |
| if (!tx_power) { |
| ALOGE("%s: Invalid tx power", __func__); |
| fprintf(stdout, "%s: Invalid tx power\n", __func__); |
| return -EINVAL; |
| } |
| |
| fid = fopen(TX_CAL_FILE, "w"); |
| if (fid == NULL) { |
| ALOGE("Cannot open '%s' (%s)\n", TX_CAL_FILE, strerror(errno)); |
| fprintf(stdout, "Cannot open '%s' (%s)\n", TX_CAL_FILE, strerror(errno)); |
| return -errno; |
| } |
| |
| memcpy(&tx_power_cal, tx_power, sizeof(tx_power_cal)); |
| fprintf(fid, "tx_power: %u\n", tx_power_cal); |
| ALOGD("%s: %d\n", __func__, tx_power_cal); |
| fclose(fid); |
| return 0; |
| } |
| |
| int main(int argc, char *argv[]) { |
| struct ia_sensor_mgr * smd; |
| char use_case; |
| int driver_param_id = -1; |
| int plugin_param_id = -1; |
| int c; |
| float param_val = 0.0; |
| uint32_t ping_timeout_sec; |
| bool route_enable; |
| uint32_t reg_addr; |
| uint32_t reg_val; |
| bool reg_val_set = false; |
| struct cal_coefficient cal_coef = { .mode = CAL_INVALID_MODE }; |
| uint32_t tx_power = 0; |
| int test_mode_param_id = -1; |
| oslo_inject_mode_t inject_mode = INJECT_MODE_OFF; |
| |
| if (argc <= 1) { |
| usage(); |
| } |
| |
| while ((c = getopt_long (argc, argv, "s:v:g:p:r:d:w:c:t:i:e:", long_options, NULL)) != -1) { |
| switch (c) { |
| case 's': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, s option requires an argument"); |
| usage(); |
| } else { |
| driver_param_id = oslo_driver_setting_lookup(optarg); |
| plugin_param_id = oslo_plugin_setting_lookup(optarg); |
| if (driver_param_id == -1 && plugin_param_id == -1) { |
| fprintf(stderr, "Invalid setting %s", optarg); |
| usage(); |
| } else { |
| use_case = 's'; |
| } |
| } |
| break; |
| case 'v': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, v option requires an argument"); |
| usage(); |
| } else { |
| if ('s' == use_case) { |
| param_val = strtof(optarg, NULL); |
| use_case = 'v'; |
| } else if ('w' == use_case) { |
| reg_val = strtoul(optarg, NULL, 0); |
| reg_val_set = true; |
| } else if ('t' == use_case) { |
| param_val = strtof(optarg, NULL); |
| use_case = 'v'; |
| } else { |
| fprintf(stderr, "Incorrect usage, v option should be the second option"); |
| usage(); |
| } |
| } |
| break; |
| case 'g': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, g option requires an argument"); |
| usage(); |
| } else { |
| driver_param_id = oslo_driver_setting_lookup(optarg); |
| plugin_param_id = oslo_plugin_setting_lookup(optarg); |
| if (driver_param_id == -1 && plugin_param_id == -1) { |
| fprintf(stderr, "Invalid setting %s", optarg); |
| usage(); |
| } else { |
| use_case = 'g'; |
| } |
| } |
| break; |
| case 'p': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, p option requires an argument"); |
| usage(); |
| } else { |
| ping_timeout_sec = strtoul(optarg, NULL, 0); |
| use_case = 'p'; |
| } |
| break; |
| case 'r': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, r option requires an argument"); |
| usage(); |
| } else { |
| route_enable = (strtoul(optarg, NULL, 0) != 0) ? true : false; |
| use_case = 'r'; |
| } |
| break; |
| case 'd': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, d option requires an argument"); |
| usage(); |
| } else { |
| reg_addr = strtoul(optarg, NULL, 0); |
| use_case = 'd'; |
| } |
| break; |
| case 'w': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, w option requires an argument"); |
| usage(); |
| } else { |
| reg_addr = strtoul(optarg, NULL, 0); |
| use_case = 'w'; |
| } |
| break; |
| case 'c': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, c option requires an argument"); |
| usage(); |
| } else { |
| int num_matched; |
| num_matched = sscanf(optarg, "V:%f M:%d %f %f %f %f %f %f", |
| &cal_coef.version, |
| &cal_coef.mode, |
| &cal_coef.ch1_i_val, &cal_coef.ch1_q_val, |
| &cal_coef.ch2_i_val, &cal_coef.ch2_q_val, |
| &cal_coef.ch3_i_val, &cal_coef.ch3_q_val); |
| if (num_matched == 8) { |
| use_case = 'c'; |
| } else { |
| fprintf(stderr, "Incorrect -c arguments %s\n", optarg); |
| usage(); |
| } |
| } |
| break; |
| case 'e': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, e option requires an argument"); |
| usage(); |
| } else { |
| int num_matched; |
| num_matched = sscanf(optarg, "%d", &tx_power); |
| if (num_matched == 1) { |
| use_case = 'e'; |
| } else { |
| fprintf(stderr, "Incorrect -e arguments %s \n", optarg); |
| usage(); |
| } |
| } |
| break; |
| case 't': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, t option requires an argument"); |
| usage(); |
| } else { |
| test_mode_param_id = oslo_plugin_test_mode_lookup(optarg); |
| if (test_mode_param_id == -1) { |
| fprintf(stderr, "Invalid setting %s", optarg); |
| usage(); |
| } else { |
| use_case = 't'; |
| fprintf(stderr, "Executing test mode %s\n", optarg); |
| } |
| } |
| break; |
| case 'i': |
| if (NULL == optarg) { |
| fprintf(stderr, "Incorrect usage, i option requires an argument"); |
| usage(); |
| } else { |
| inject_mode = strtoul(optarg, NULL, 0); |
| if (inject_mode >= INJECT_MODE_NUM) { |
| fprintf(stderr, "Invalid setting %s", optarg); |
| usage(); |
| } else { |
| use_case = 'i'; |
| } |
| } |
| break; |
| case GETOPT_HELP_CHAR: |
| default: |
| usage(); |
| break; |
| } |
| |
| smd = iaxxx_sensor_mgr_init(); |
| if (NULL == smd) { |
| ALOGE("%s: ERROR Failed to init ia_sensor_mgr", __func__); |
| return -EINVAL; |
| } |
| |
| if ('v' == use_case) { |
| if (driver_param_id != -1) { |
| oslo_driver_set_param(smd, driver_param_id, param_val); |
| } else if (plugin_param_id != -1) { |
| oslo_plugin_set_param(plugin_param_id, param_val); |
| } else if (test_mode_param_id != -1) { |
| uint32_t integer_param = (uint32_t)lrintf(param_val); |
| if (param_val < 0) { |
| ALOGD("%s: Test mode: %d with no event", __func__, test_mode_param_id); |
| integer_param = UINT32_MAX; |
| } else if (param_val > 0) { |
| ALOGD("%s: Test mode: %d with duration: %" PRIu32, __func__, test_mode_param_id, integer_param); |
| } else { |
| ALOGD("%s: Test mode: %d with no duration", __func__, test_mode_param_id); |
| } |
| oslo_plugin_set_param(test_mode_param_id, integer_param); |
| } |
| } else if ('g' == use_case) { |
| if (driver_param_id != -1) { |
| oslo_driver_get_param(smd, driver_param_id); |
| } else if (plugin_param_id != -1) { |
| oslo_plugin_get_param(plugin_param_id); |
| } |
| } else if ('p' == use_case) { |
| ping_test(smd, ping_timeout_sec); |
| } else if ('r' == use_case) { |
| route_enable ? osloSoundModelEnable(true) : oslo_enable(smd, false); |
| } else if ('d' == use_case) { |
| read_register(smd, reg_addr); |
| } else if ('w' == use_case) { |
| if (reg_val_set) |
| write_register(smd, reg_addr, reg_val); |
| } else if ('c' == use_case) { |
| for (int i = 0; i < CAL_MODES_MAX; i++) { |
| cal_table[i].mode = CAL_INVALID_MODE; |
| } |
| cal_read_persist(); |
| cal_write_persist(&cal_coef); |
| } else if ('e' == use_case) { |
| read_tx_power_from_persist(); |
| write_tx_power_to_persist(&tx_power); |
| } else if ('i' == use_case) { |
| oslo_plugin_set_param(OSLO_SENSOR_PARAM_SLPY_STATE, 0); |
| oslo_driver_set_param(smd, OSLO_CONTROL_INJECT_RADAR_DATA, inject_mode); |
| oslo_plugin_set_param(OSLO_SENSOR_PARAM_SLPY_STATE, inject_mode); |
| } |
| |
| iaxxx_sensor_mgr_deinit(smd); |
| } |
| |
| return 0; |
| } |
