/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #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 "/mnt/vendor/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 "/mnt/vendor/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 -v \n\ 2) oslo_config_test -g \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 \n\ 4) oslo_config_test -r <1/0>\n\ 5) oslo_config_test -d \n\ 6) oslo_config_test -w -v \n\ 7) oslo_config_test -c 'V: M: ' \n\ 8) oslo_config_test -t -v \n\ 9) oslo_config_test -i <0/1/2> # 0:off 1:entrance 2:interactive \n\ 10) oslo_config_test -e ''\n\ ", stdout); fputs("\n\ OPTIONS - \n\ ---------\n\ -s Set a parameter using its .\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 .\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 \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 \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; }