| /* |
| * MBTK Basic AT Process. |
| * |
| * Author : lb |
| * Date : 2021/11/5 10:14:32 |
| * |
| */ |
| #include "mbtk_at.h" |
| #include "mbtk_device_info.h" |
| #include "mbtk/mbtk_type.h" |
| #include "mbtk/mbtk_device.h" |
| #include <dlfcn.h> |
| |
| //#include <sys/statfs.h> |
| #include <sys/vfs.h> |
| #include <errno.h> |
| #include <linux/magic.h> |
| #include <time.h> |
| #include <sys/time.h> |
| #include <signal.h> |
| #include <pthread.h> |
| #include <time.h> |
| #include <sys/time.h> |
| #include <cutils/properties.h> |
| #include "configwrapper.h" |
| #include<linux/msg.h> |
| |
| //#include "gps.h" |
| #include "atcmdsvr_ubus.h" |
| |
| #define MAX_GPIO_TEST_NUM 60 |
| |
| typedef int (*mbtk_dev_info_read_func)(mbtk_device_info_item_enum, void *, int); |
| |
| #define MBTK_LIB_PATH "/lib/libmbtk_lib.so" |
| const struct blobmsg_policy gps_user_cb_policy1[] = { |
| [0] = { |
| .name = "event", |
| .type = BLOBMSG_TYPE_INT32, |
| }, |
| }; |
| |
| bool mbtk_urc_enable = TRUE; |
| |
| int mbtk_at_loopback(int type); |
| int mbtk_at_play(const char *args); |
| int mbtk_at_rec(const char *args); |
| |
| typedef struct |
| { |
| int gpio; |
| bool busy; |
| bool state; |
| } mbtk_gpio_state_t; |
| |
| static bool gpio_test_usable = true; |
| |
| static mbtk_gpio_state_t gpio_pins[] = |
| { |
| {22, FALSE, FALSE}, // IN |
| {33,FALSE,FALSE}, |
| {35,FALSE,FALSE}, |
| {36,FALSE,FALSE}, |
| {34,FALSE,FALSE}, |
| {21,FALSE,FALSE}, |
| {4,FALSE,FALSE}, |
| {123,FALSE,FALSE}, |
| {20,FALSE,FALSE}, |
| {43,FALSE,FALSE}, |
| {13,FALSE,FALSE}, |
| // {12,FALSE,FALSE}, |
| {14,FALSE,FALSE}, |
| {118,FALSE,FALSE}, |
| // {19,FALSE,FALSE}, |
| {120,FALSE,FALSE}, |
| {49,FALSE,FALSE}, |
| {50,FALSE,FALSE}, |
| {32,FALSE,FALSE}, |
| {31,FALSE,FALSE}, |
| {51,FALSE,FALSE}, |
| // {23,FALSE,FALSE}, |
| {24,FALSE,FALSE}, |
| {52,FALSE,FALSE}, |
| {27,FALSE,FALSE}, |
| {28,FALSE,FALSE}, |
| {26,FALSE,FALSE}, |
| {25,FALSE,FALSE}, |
| {5,FALSE,FALSE}, |
| {0,FALSE,FALSE}, |
| {1,FALSE,FALSE}, |
| {2,FALSE,FALSE}, |
| {3,FALSE,FALSE}, |
| {6,FALSE,FALSE}, |
| {7,FALSE,FALSE}, |
| {15,FALSE,FALSE}, |
| {18,FALSE,FALSE}, |
| {16,FALSE,FALSE}, |
| {17,FALSE,FALSE}, |
| {54,FALSE,FALSE}, |
| {53,FALSE,FALSE}, |
| {48,FALSE,FALSE}, |
| {55,FALSE,FALSE}, |
| {58,FALSE,FALSE}, |
| {57,FALSE,FALSE}, |
| {29,FALSE,FALSE}, |
| {30,FALSE,FALSE}, |
| {99,FALSE,FALSE}, |
| {126,FALSE,FALSE}, |
| {125,FALSE,FALSE}, |
| {56,FALSE,FALSE}, |
| {59,FALSE,FALSE}, |
| {117,FALSE,FALSE}, |
| // {122,FALSE,FALSE} |
| }; |
| |
| int gpio_register_auto_test_out(int *result); |
| |
| #define MBTK_GPIO_NUM (sizeof(gpio_pins)/sizeof(mbtk_gpio_state_t)) |
| |
| static bool dev_info_inited = FALSE; |
| static mbtk_device_info_basic_t info_basic; |
| static mbtk_device_info_modem_t info_modem; |
| |
| static int dev_info_get() |
| { |
| if(dev_info_inited) { |
| return 0; |
| } |
| void *handle = dlopen(MBTK_LIB_PATH , RTLD_LAZY); |
| if(handle == NULL) |
| { |
| DBGMSG(MBTK_AT, "dlopen() %s fail : %d", MBTK_LIB_PATH, errno); |
| return -1; |
| } |
| |
| mbtk_dev_info_read_func dev_info_read = (mbtk_dev_info_read_func)dlsym(handle, "mbtk_dev_info_read"); |
| if(dev_info_read == NULL) |
| { |
| DBGMSG(MBTK_AT, "dlsym(mbtk_dev_info_read) fail : %d", errno); |
| return -1; |
| } |
| |
| memset(&info_basic, 0, sizeof(mbtk_device_info_basic_t)); |
| memset(&info_modem, 0, sizeof(mbtk_device_info_modem_t)); |
| |
| // mbtk_dev_info_read() |
| int result = dev_info_read(MBTK_DEVICE_INFO_ITEM_BASIC, &info_basic, sizeof(mbtk_device_info_basic_t)); |
| if(result) { |
| DBGMSG(MBTK_AT, "mbtk_dev_info_read(BASIC) fail."); |
| return -1; |
| } |
| |
| result = dev_info_read(MBTK_DEVICE_INFO_ITEM_MODEM, &info_modem, sizeof(mbtk_device_info_modem_t)); |
| if(result) { |
| DBGMSG(MBTK_AT, "mbtk_dev_info_read(MODEM) fail."); |
| return -1; |
| } |
| |
| dev_info_inited = TRUE; |
| return 0; |
| } |
| |
| static char* band_area_2_str(mbtk_modem_band_area_enum band_area) |
| { |
| switch(band_area) { |
| case MBTK_MODEM_BAND_AREA_CN: |
| return "CN"; |
| case MBTK_MODEM_BAND_AREA_EU: |
| return "EU"; |
| case MBTK_MODEM_BAND_AREA_SA: |
| return "SA"; |
| default: |
| return "DEF"; |
| } |
| } |
| |
| static int gpio_export(void) |
| { |
| int index=0; |
| int file=-1; |
| int result =-1; |
| char pin_index_buffer[5]= {0}; |
| |
| for(index = 0; index < MBTK_GPIO_NUM; index++) |
| { |
| file = open("/sys/class/gpio/export",O_WRONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio export file fail."); |
| return -1; |
| } |
| |
| memset(pin_index_buffer,0,5); |
| sprintf(pin_index_buffer,"%d",gpio_pins[index].gpio); |
| result = write(file,pin_index_buffer,strlen(pin_index_buffer)); |
| if(result < 0) |
| { |
| LOG("Gpio[%d] export fail.", gpio_pins[index].gpio); |
| gpio_pins[index].busy = TRUE; |
| } |
| close(file); |
| } |
| |
| return 0; |
| } |
| |
| static int gpio_unexport(void) |
| { |
| int index=0; |
| int file=-1; |
| int result =-1; |
| char pin_index_buffer[5]= {0}; |
| |
| for(index = 0; index < MBTK_GPIO_NUM; index++) |
| { |
| if(!gpio_pins[index].busy) |
| { |
| file = open("/sys/class/gpio/unexport",O_WRONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio unexport file fail."); |
| return -1; |
| } |
| |
| memset(pin_index_buffer,0,5); |
| sprintf(pin_index_buffer,"%d",gpio_pins[index].gpio); |
| result=write(file,pin_index_buffer,strlen(pin_index_buffer)); |
| if(result < 0) |
| { |
| close(file); |
| LOG("Gpio[%d] unexport fail.",gpio_pins[index].gpio); |
| return -1; |
| } |
| close(file); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int gpio_direct_set(char *value,int gpio) |
| { |
| char buffer[50]= {0}; |
| int file =-1; |
| int result =-1; |
| |
| memset(buffer,0,50); |
| sprintf(buffer,"/sys/class/gpio/gpio%d/direction", gpio); |
| file = open(buffer, O_WRONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio[%d] direct fail.", gpio); |
| return -1; |
| } |
| |
| result = write(file,value,strlen(value)); |
| if(result != strlen(value)) |
| { |
| LOG("Set gpio[%d] direct fail.", gpio); |
| close(file); |
| return -1; |
| } |
| close(file); |
| |
| return 0; |
| } |
| |
| static int gpio_value_get(int gpio) |
| { |
| char buffer[50]; |
| char path[10]; |
| int file =-1; |
| int result =-1; |
| int value; |
| |
| memset(path,0,50); |
| memset(buffer,0,10); |
| sprintf(path,"/sys/class/gpio/gpio%d/value", gpio); |
| file = open(path,O_RDONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio[%d] fail.", gpio); |
| return -1; |
| } |
| result = read(file,buffer,5); |
| if(result <= 0) |
| { |
| LOG("Get gpio[%d] value fail", gpio); |
| close(file); |
| return -1; |
| } |
| close(file); |
| value = atoi(buffer); |
| return value; |
| } |
| |
| static int gpio_value_set(int value, int gpio) |
| { |
| char buffer[50]= {0}; |
| int file =-1; |
| int result =-1; |
| |
| memset(buffer,0,50); |
| sprintf(buffer,"/sys/class/gpio/gpio%d/value", gpio); |
| file = open(buffer,O_WRONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio[%d] value fail.", gpio); |
| return -1; |
| } |
| if(value == 0) { |
| result = write(file,"0",1); |
| } else { |
| result = write(file,"1",1); |
| } |
| if(result != 1) |
| { |
| LOG("Set gpio[%d] value fail.", gpio); |
| close(file); |
| return -1; |
| } |
| close(file); |
| |
| return 0; |
| } |
| |
| //type:0 value 0 |
| //type:1 value 1 |
| //type:2 direction "out" |
| //type:3 direction "in" |
| |
| static int one_gpio_export(int gpio, int type) |
| { |
| int index=0; |
| int file=-1; |
| int file1=-1; |
| int result =-1; |
| char pin_index_buffer[5]= {0}; |
| char buffer[50]= {0}; |
| int ret =0; |
| |
| file = open("/sys/class/gpio/export",O_WRONLY); |
| if(file == -1) |
| { |
| LOG("Open gpio export file fail."); |
| return -1; |
| } |
| |
| memset(buffer,0,50); |
| sprintf(buffer,"/sys/class/gpio/gpio%d", gpio); |
| file1 = open(buffer,O_RDONLY); |
| if(file1 != -1) |
| { |
| //file is created |
| } |
| else{ // create gpio |
| memset(pin_index_buffer,0,5); |
| sprintf(pin_index_buffer,"%d",gpio); |
| result = write(file,pin_index_buffer,strlen(pin_index_buffer)); |
| if(result < 0) |
| { |
| ATRESP(IND_REQ_HANDLE , ATCI_RESULT_CODE_NULL, 0, "Gpio export fail"); |
| LOG("Gpio[%d] export fail.", gpio); |
| return -1; |
| } |
| } |
| |
| close(file); |
| |
| |
| switch(type) |
| { |
| case 0 : |
| { |
| ret = gpio_value_set(0, gpio); |
| break; |
| } |
| case 1: |
| { |
| ret = gpio_value_set(1, gpio); |
| break; |
| } |
| case 2: |
| { |
| ret = gpio_direct_set("out", gpio); |
| break; |
| } |
| case 3: |
| { |
| ret = gpio_direct_set("in", gpio); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| |
| return ret; |
| } |
| |
| |
| static int gpio_test(void) |
| { |
| int index = 0; |
| int fail_count = 0; |
| gpio_export(); |
| |
| gpio_direct_set("in", gpio_pins[0].gpio); |
| //set all gpio low level start |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| if(!gpio_pins[index].busy) |
| { |
| gpio_direct_set("out", gpio_pins[index].gpio); |
| gpio_value_set(0, gpio_pins[index].gpio); |
| } |
| } |
| |
| if(gpio_value_get(gpio_pins[0].gpio) != 0) |
| { |
| LOG("gpio_test set all gpio level[%d] fail", gpio_pins[0].gpio); |
| gpio_unexport(); |
| return -1; |
| } |
| //set all gpio low level end |
| |
| #if 1 |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| if(!gpio_pins[index].busy) |
| { |
| gpio_value_set(1, gpio_pins[index].gpio); |
| if(gpio_value_get(gpio_pins[index].gpio) == 1 && gpio_value_get(gpio_pins[0].gpio) == 1) |
| { |
| gpio_pins[index].state = TRUE; |
| } |
| else |
| { |
| LOG("gpio[%d] input not match output level [1]", gpio_pins[index].gpio); |
| gpio_pins[index].state = FALSE; |
| fail_count++; |
| continue; |
| } |
| } |
| } |
| |
| if(fail_count > 0) { |
| gpio_unexport(); |
| return fail_count; |
| } |
| |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| if(!gpio_pins[index].busy) |
| { |
| gpio_value_set(0, gpio_pins[index].gpio); |
| if(gpio_value_get(gpio_pins[index].gpio) == 0 && gpio_value_get(gpio_pins[0].gpio) == 0) |
| { |
| gpio_pins[index].state = TRUE; |
| } |
| else |
| { |
| LOG("gpio[%d] input not match output level [0]", gpio_pins[index].gpio); |
| gpio_pins[index].state = FALSE; |
| fail_count++; |
| continue; |
| } |
| } |
| } |
| |
| gpio_unexport(); |
| #endif |
| return fail_count; |
| } |
| |
| static int gpio_test2(void) |
| { |
| int index=0; |
| int value=0; |
| int fail_count = 0; |
| //export all test gpio |
| gpio_export(); |
| |
| |
| //set main control gpio in |
| gpio_direct_set("in", gpio_pins[0].gpio); |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| gpio_direct_set("out",gpio_pins[index].gpio); |
| gpio_value_set(1, gpio_pins[index].gpio); |
| } |
| |
| if(gpio_value_get(gpio_pins[0].gpio) != 1) |
| { |
| LOG("gpio_test set all gpio level[%d] fail", gpio_pins[0].gpio); |
| gpio_unexport(); |
| return -1; |
| } |
| |
| //set all gpio value as 0 |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| gpio_value_set(0, gpio_pins[index].gpio); |
| } |
| |
| //set gpio direct in except main control gpio |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| gpio_direct_set("in",gpio_pins[index].gpio); |
| } |
| |
| //set main control gpio out |
| gpio_direct_set("out",gpio_pins[0].gpio); |
| gpio_value_set(1,gpio_pins[0].gpio); |
| for(index = 1; index < MBTK_GPIO_NUM; index++) |
| { |
| value = -1; |
| value=gpio_value_get(gpio_pins[index].gpio); |
| if(1==value) |
| { |
| gpio_pins[index].state = TRUE; |
| } |
| else |
| { |
| LOG("gpio[%d] input not match output level [0]", gpio_pins[index].gpio); |
| gpio_pins[index].state = FALSE; |
| fail_count++; |
| continue; |
| } |
| } |
| //unexport gpio |
| gpio_unexport(); |
| |
| return fail_count; |
| //set main |
| } |
| |
| |
| uint64 partion_space_get(const char *path) |
| { |
| unsigned long long totle = 0; |
| unsigned long long blocksize = 0; |
| struct statfs diskInfo; |
| |
| if(path == NULL){ |
| return 0; |
| } |
| memset(&diskInfo, 0, sizeof(diskInfo)); |
| |
| if(statfs(path, &diskInfo)){ |
| LOG("statfs() fail - %d.", errno); |
| return 0; |
| } |
| blocksize = diskInfo.f_bsize; |
| LOG("path=%s [totle=%lld MB] :f_type= %lld, f_bsize=%lld, f_blocks=%lld, f_bfree=%lld, f_bavail%lld\n", path,totle, |
| diskInfo.f_type, diskInfo.f_bsize,diskInfo.f_blocks,diskInfo.f_bfree, diskInfo.f_bavail); |
| |
| // MSDOS_SUPER_MAGIC 0x4d44 |
| if((diskInfo.f_type & 0x0ffff) == MSDOS_SUPER_MAGIC) { |
| totle = (diskInfo.f_blocks * blocksize) >> 20; |
| return totle; |
| } else { |
| LOG("Unknow fs type : %x", diskInfo.f_type); |
| return 0; |
| } |
| } |
| |
| static unsigned int shell_at_handle; |
| static void shell_cb_func(char *buf,int buf_size) |
| { |
| if(buf && buf_size > 0) |
| { |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "+MSHELL: %d\r\n%s\r\n", |
| buf_size, buf); |
| //MBTK_FUNC(log_hex)("+MSHELL", buf, buf_size); |
| ATRESP(shell_at_handle, ATCI_RESULT_CODE_NULL, 0, resp_buf); |
| } |
| } |
| |
| int metis_strptime(char *str_time) |
| { |
| struct tm stm; |
| char dateTime[30]; |
| struct timeval tv; |
| if( strptime(str_time, "%Y-%m-%d %H:%M:%S",&stm) != NULL) |
| { |
| printf("success\n"); |
| } |
| else{ |
| printf("error\n"); |
| return -1; |
| } |
| |
| // printf("设置系统时间前的时间是：\n"); |
| // system("date"); |
| time_t _t = mktime(&stm); |
| // stime(&_t); |
| tv.tv_sec = _t; |
| // tv.tv_usec = USEC(pnew_time_packet->transmit_timestamp.fine); |
| settimeofday(&tv, NULL); |
| |
| printf("设置系统时间HOU的时间是：\n"); |
| // system("date"); |
| |
| return 0; |
| } |
| |
| extern int mbtk_time_type; |
| |
| #if 0 |
| static void gpio_timer_alrm_func(int signo) |
| { |
| LOG("TIMEOUT : %d", signo); |
| if(SIGALRM == signo) { |
| gpio_test_usable = true; |
| LOG("gpio_test_usable has reset to true."); |
| } |
| } |
| #else |
| static void* gpio_thread_func(void *arg) |
| { |
| sleep(1); |
| gpio_test_usable = true; |
| LOG("gpio_test_usable has reset to true."); |
| return NULL; |
| } |
| #endif |
| #ifdef MBTK_DATA_MODE_SUPPORT |
| static void data_mode_callback_cb(const char *data, int data_len) |
| { |
| LOG("DATA - %d:%s", data_len, data); |
| } |
| #endif |
| |
| utlReturnCode_T MBTK_AT_MTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlSUCCESS; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| unsigned int svc_id = 0; |
| *xid_p = At_handle; |
| |
| const static int arg2_len_max = 10; |
| static int arg1 = 0; |
| static char arg2[MBTK_AT_RESP_LEN_MAX]; |
| |
| LOG("MBTK_AT_MTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| sprintf(resp_buf, "%s : %d,\"%s\"\r\n", command_name_p, arg1, arg2); |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 1, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| int len = 0; |
| memset(arg2, 0x0, MBTK_AT_RESP_LEN_MAX); |
| if(!getExtString(parameter_values_p, 1, arg2, arg2_len_max, &len, "test")) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| break; |
| } |
| case TEL_EXT_ACTION_CMD : |
| { |
| // ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, "ACTION_OK"); |
| #ifdef MBTK_DATA_MODE_SUPPORT |
| ret = mbtk_data_mode_enter(sAtp_index, data_mode_callback_cb); |
| #else |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, "ACTION_OK"); |
| #endif |
| break; |
| } |
| |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| |
| } |
| |
| |
| utlReturnCode_T MBTK_AT_MINFO_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("%s enter with command_op [%s]", command_name_p, op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| if(!dev_info_get()) { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, |
| "Revision:%s\r\n" |
| "Custom_Model:%s\r\n" |
| "Module_Type:%s\r\n", |
| strlen(info_basic.revision_out) > 0 ? info_basic.revision_out: "Unknown", |
| strlen(info_basic.project_cust) > 0 ? info_basic.project_cust: "Unknown", |
| band_area_2_str(info_modem.band_area)); |
| } else { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, |
| "Revision:%s\r\n" |
| "Custom_Model:%s\r\n" |
| "Module_Type:%s\r\n", |
| "Unknown", "Unknown", "Unknown"); |
| } |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_SYSTIME_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlSUCCESS; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| unsigned int svc_id = 0; |
| *xid_p = At_handle; |
| |
| const static int arg2_len_max = 10; |
| static int arg1 = 0; |
| |
| printf("MBTK_AT_SYSTIME_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| char time_type[10] = {0}; |
| property_get("persist.mbtk.time_type", time_type, "0"); |
| mbtk_time_type = atoi(time_type); |
| sprintf(resp_buf, "%s: %d\r\n", command_name_p, mbtk_time_type); |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 2, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| if(num_parameters > 1) { |
| const static int cmd_len_max = MBTK_AT_RESP_LEN_MAX; |
| static char time_str[MBTK_AT_RESP_LEN_MAX]; |
| int len = 0; |
| memset(time_str, 0x0, MBTK_AT_RESP_LEN_MAX); |
| if(!getExtString(parameter_values_p, 1, time_str, cmd_len_max, &len, "")) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| LOG("Get CMD Fail."); |
| break; |
| } |
| |
| if(strlen(time_str) > 0) |
| { |
| ret = metis_strptime(time_str); |
| } |
| } |
| |
| mbtk_time_type = arg1; |
| char type_str[10] = {0}; |
| sprintf(type_str, "%d", mbtk_time_type); |
| property_set("persist.mbtk.time_type", type_str); |
| if(ret < 0) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } |
| else |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_MTESTF_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlSUCCESS; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| unsigned int svc_id = 0; |
| *xid_p = At_handle; |
| |
| const static int arg2_len_max = 10; |
| static int arg1 = 0; |
| static char arg2[MBTK_AT_RESP_LEN_MAX]; |
| |
| LOG("MBTK_AT_MTESTF_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| sprintf(resp_buf, "%s : %d,\"%s\"\r\n", command_name_p, arg1, arg2); |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 1, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| int len = 0; |
| memset(arg2, 0x0, MBTK_AT_RESP_LEN_MAX); |
| if(!getExtString(parameter_values_p, 1, arg2, arg2_len_max, &len, "test")) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| break; |
| } |
| case TEL_EXT_TEST_CMD : |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, "+MTESTF=(0,1),\"\""); |
| break; |
| } |
| case TEL_EXT_ACTION_CMD : |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, "ACTION_OK"); |
| break; |
| } |
| |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| |
| } |
| |
| |
| utlReturnCode_T MBTK_AT_MSHELL_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| shell_at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = shell_at_handle; |
| |
| LOG("MBTK_AT_MSHELL_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD : |
| { |
| const static int cmd_len_max = MBTK_AT_RESP_LEN_MAX; |
| static char cmd[MBTK_AT_RESP_LEN_MAX]; |
| int len = 0; |
| memset(cmd, 0x0, MBTK_AT_RESP_LEN_MAX); |
| if(!getExtString(parameter_values_p, 0, cmd, cmd_len_max, &len, "")) |
| { |
| ret = ATRESP(shell_at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| LOG("Get CMD Fail."); |
| break; |
| } |
| |
| //if(strlen(cmd) > 0 && mbtk_cmd_line_ex(cmd, shell_cb_func)) |
| if(strlen(cmd) > 0 && MBTK_FUNC(mbtk_cmd_line_ex)(cmd, shell_cb_func)) |
| { |
| ret = ATRESP(shell_at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| else |
| { |
| LOG("CMD length error."); |
| break; |
| } |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| |
| } |
| |
| utlReturnCode_T MBTK_AT_ISLKVRSCAN_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_ISLKVRSCAN_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| #ifndef MBTK_BUILD_TIME |
| #define MBTK_BUILD_TIME "Unknown" |
| #endif |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| if(!dev_info_get()) { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "Version: %s\r\nBuild time: %s\r\n", |
| strlen(info_basic.revision_out) > 0 ? info_basic.revision_out: "Unknown", |
| strlen(info_basic.build_time) > 0 ? info_basic.build_time: "Unknown"); |
| } else { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "Version: %s\r\nBuild time: %s\r\n", |
| "Unknown", "Unknown"); |
| } |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| |
| } |
| |
| utlReturnCode_T MBTK_AT_SDTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("%s enter with command_op [%s]", command_name_p, op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| // SDVOLUME:xxxMB |
| // OK |
| // /mnt/mmcblk0p1 |
| #if (defined(MBTK_PROJECT_L508_X6) || defined(MBTK_PROJECT_T108) || defined(MBTK_PROJECT_L509) || defined(MBTK_PROJECT_L508)) |
| int i =0 ; |
| uint64 size = 0; |
| for(i = 0; i < 3; i++) |
| { |
| if(i == 0) |
| { |
| size = partion_space_get("/sdcard"); |
| } |
| else if(i == 1) |
| { |
| size = partion_space_get("/system/etc/www/webdav/sdcard"); |
| } |
| else |
| { |
| system("mkfs.vfat -F 32 /dev/mmcblk0"); |
| system("mount -t vfat /dev/mmcblk0 /mnt"); |
| size = partion_space_get("/mnt"); |
| } |
| |
| if(size > 0) |
| { |
| LOG("[SDTEST] i = %d, size = %d", i, size); |
| break; |
| } |
| |
| size = 0; |
| } |
| #else |
| uint64 size = partion_space_get("/mnt/mmcblk0p1"); |
| #endif |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| if(size > 0) { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "SDVOLUME:%lldMB\r\n", size); |
| } else { |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "SDVOLUME:0MB\r\n"); |
| } |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| utlReturnCode_T MBTK_AT_SPKTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_SPKTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| // SDVOLUME:MB |
| // OK |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| |
| mbtk_at_play(NULL); |
| |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "Audio spk test.\r\nBuild time: %s\r\n", |
| MBTK_BUILD_TIME); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_MICTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_MICTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| // SDVOLUME:MB |
| // OK |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| |
| mbtk_at_rec(NULL); |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "Audio record test.\r\nBuild time: %s\r\n", |
| MBTK_BUILD_TIME); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_REVTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int arg1 = 0; |
| |
| static bool loopback_running = FALSE; |
| |
| LOG("MBTK_AT_REVTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| sprintf(resp_buf, "%s : %d\r\n", command_name_p, arg1); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 1, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| #if (defined(MBTK_PROJECT_L508_X6) || defined(MBTK_PROJECT_T108)) |
| if(arg1 == 1) |
| { |
| system("ubus call audio_if loopback_enable '{\"param0\":1}'"); |
| } |
| else |
| { |
| system("ubus call audio_if loopback_disable"); |
| } |
| #else |
| LOG("MBTK_AT_REVTEST_PROCESS arg1 [%d]", arg1); |
| mbtk_at_loopback(arg1); |
| //sprintf(resp_buf, "%s : ,\"%s\"\r\n", command_name_p, "TEL_EXT_SET_CMD"); |
| #endif |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| break; |
| } |
| case TEL_EXT_ACTION_CMD : |
| { |
| if(!loopback_running) { |
| #if (defined(MBTK_PROJECT_L508_X6) || defined(MBTK_PROJECT_T108)) |
| system("ubus call audio_if loopback_enable '{\"param0\":1}'"); |
| #else |
| mbtk_at_loopback(1); |
| #endif |
| loopback_running = TRUE; |
| } else { |
| #if (defined(MBTK_PROJECT_L508_X6) || defined(MBTK_PROJECT_T108)) |
| system("ubus call audio_if loopback_disable"); |
| #else |
| mbtk_at_loopback(0); |
| #endif |
| loopback_running = FALSE; |
| } |
| //snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "Audio loopback test.\r\nBuild time: %s\r\n", |
| // MBTK_BUILD_TIME); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_GPIOTEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| int gnss_support = 0; |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_GPIOTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &gnss_support, 0, 1, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| } |
| case TEL_EXT_ACTION_CMD : |
| { |
| if(gpio_test_usable) { |
| gpio_test_usable = false; |
| } else { // GPIO test is busy. |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_SUPPRESS, 0, NULL); |
| break; |
| } |
| |
| #if 1 |
| int test_result[MAX_GPIO_TEST_NUM]; |
| memset(test_result,0,sizeof(test_result)); |
| int result = mbtk_at_gpio((bool)gnss_support, test_result); |
| if(result < 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "GPIO TEST FAIL\r\n"); |
| } |
| else if(result == 0) { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "ALL GPIO TEST PASS\r\n"); |
| } |
| else |
| { |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int index; |
| sprintf(resp_buf, "GPIOTEST Fail %02d PINs:", result); |
| for(index = 0; index < result &&index < MAX_GPIO_TEST_NUM; index++) |
| { |
| sprintf(resp_buf + strlen(resp_buf), "%03d,", test_result[index]); |
| } |
| resp_buf[strlen(resp_buf) - 1] = '\r'; |
| resp_buf[strlen(resp_buf)] = '\n'; |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| } |
| #else |
| int fail_count = gpio_test(); |
| if(fail_count < 0) { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "GPIO TEST FAIL\r\n"); |
| } else if(fail_count == 0){ |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "ALL GPIO TEST PASS\r\n"); |
| } else { |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int index; |
| sprintf(resp_buf, "GPIOTEST Fail %02d PINs:", fail_count); |
| for(index = 0; index < MBTK_GPIO_NUM; index++) |
| { |
| if(!gpio_pins[index].state) { |
| sprintf(resp_buf + strlen(resp_buf), "%03d,", gpio_pins[index].gpio); |
| } |
| } |
| resp_buf[strlen(resp_buf) - 1] = '\r'; |
| resp_buf[strlen(resp_buf)] = '\n'; |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| } |
| #endif |
| |
| // Set gpio_test_usable to true after 1s. |
| #if 0 |
| signal(SIGALRM, gpio_timer_alrm_func); |
| struct itimerval val; |
| // Only time |
| val.it_interval.tv_sec = 0; |
| val.it_interval.tv_usec = 0; |
| // Time |
| val.it_value.tv_sec = 1; |
| val.it_value.tv_usec = 0; |
| if (setitimer(ITIMER_REAL, &val, NULL) == -1) |
| { |
| LOG("setitimer fail.[errno - %d]",errno); |
| } |
| #else |
| pthread_t gpio_thread_id; |
| if (pthread_create(&gpio_thread_id, NULL, gpio_thread_func, NULL) != 0) |
| { |
| LOG("%s errno: %d (%s)",__func__, errno, strerror(errno)); |
| } |
| #endif |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_ADCGETV_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int arg1 = 0; |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_ADCGETV_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| // SDVOLUME:MB |
| // OK |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "ADC Version: %s\r\nBuild time: %s\r\n", |
| MBTK_DEVICES_REVISION, MBTK_BUILD_TIME); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| int adc_ret; |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 2, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| adc_ret = mbtk_at_adc(arg1); |
| LOG("MBTK_AT_ADC_PROCESS adc [%d]", adc_ret); |
| sprintf(resp_buf, "%s:%d,%d\r\n", command_name_p, arg1, adc_ret); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_RGMIITEST_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_RGMIITEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_ACTION_CMD : |
| { |
| #if defined(MBTK_PROJECT_T108) |
| int result = -1; |
| int rgmii_test_num = 0; |
| char buf[50] = {0}; |
| static char rgmii_flag = 0; |
| //mbtk_mdio("eth0", 0, 0x9800, 0xc834); |
| //mbtk_mdio("eth0", 0, 0x0, 0xa000); |
| for(rgmii_test_num = 0; rgmii_test_num < 3; rgmii_test_num++) |
| { |
| if(!rgmii_flag) |
| { |
| system("/bin/mbtk_mdio eth0 0x9800 0xc834"); |
| system("/bin/mbtk_mdio eth0 0x0 0xa000"); |
| } |
| result = mbtk_rgmii_loopback(); |
| if(result < 0) |
| { |
| // |
| } |
| else |
| { |
| memcpy(buf, "+RGMIITEST: phy loopback ok", strlen("+RGMIITEST: phy loopback ok")); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, buf); |
| rgmii_flag = 1; |
| break; |
| } |
| } |
| |
| if(result < 0) |
| { |
| memcpy(buf, "+RGMIITEST: phy loopback fail", strlen("+RGMIITEST: phy loopback fail")); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, buf); |
| } |
| break; |
| #endif |
| } |
| default: |
| { |
| ret = ATRESP( at_handle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL); |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_MGPSC_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int arg1 = 0; |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_MGPSC_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD : |
| { |
| int gnss_ret; |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 11, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| #if 1 |
| if (arg1 == 5 || arg1 == 1 || arg1 ==0) |
| { |
| if (1 == arg1) |
| { |
| gnss_ret = mbtk_mgpsc_set(arg1); |
| if (gnss_ret < 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: init fail.\r\n"); |
| } |
| else |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "+GPS: init success.\r\n"); |
| } |
| } |
| else if (arg1 == 5) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| else |
| { |
| gnss_ret = mbtk_mgpsc_set(arg1); |
| if (gnss_ret < 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, "+GPS: deinit fail.\r\n"); |
| } |
| else |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, "+GPS: deinit success.\r\n"); |
| } } |
| } |
| else |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| #else |
| if(1 == arg1 || 11 == arg1 || 10 == arg1 || 9 == arg1) |
| gnss_ret = MBTK_FUNC(mbtk_at_gnss)(arg1, at_gnss_handler_function); |
| else if (6 == arg1) |
| gnss_ret = at_gnss_firmware_update(); |
| else |
| gnss_ret = MBTK_FUNC(mbtk_at_gnss)(arg1, NULL); |
| |
| LOG("%s gnss [%d]", __FUNCTION__, gnss_ret); |
| sprintf(resp_buf, "%s:%d,%d\r\n", command_name_p, arg1, gnss_ret); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| #endif |
| |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_CGNETLED_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_CGNETLED_PROCESS enter with command_op [%s]", op2str(op)); |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD : |
| { |
| int led_switch; |
| if(!getExtValue(parameter_values_p, 0, &led_switch, 0, 1, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| if(led_switch == 0 || led_switch == 1) { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_SYSSLEEP_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| |
| TelAtParserID origParserId = *(TelAtParserID *)arg_p; |
| |
| LOG("MBTK_AT_SYSSLEEP_PROCESS enter with command_op [%s]", op2str(op)); |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD: |
| case TEL_EXT_ACTION_CMD: |
| { |
| // [ -e /sys/class/devfreq/devfreq-ddr/polling_interval ] && { |
| // echo 50 > /sys/class/devfreq/devfreq-ddr/polling_interval |
| // } |
| |
| // [ -e /sys/power/autosleep ] && { |
| // echo booting 8000000000 > /sys/power/wake_lock |
| // echo mem > /sys/power/autosleep |
| // } |
| |
| //close GPS set gpio 21/118: out / 0 |
| int result = -1; |
| result = mbtk_system_sleep(); |
| if(result != 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } |
| else |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| #if 0 |
| int ubus_ret = 0; |
| ubus_ret = invoke_reply_data_cb(origParserId, "gps", "gnss_deinit", NULL, (ubus_data_handler_t *)gps_usr_callback_hdl, &at_handle, 4000); |
| if(ubus_ret < 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_SUPPRESS, 0, "BUSY"); |
| break; |
| } |
| else if(ubus_ret > 0) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| #ifdef MBTK_PROJECT_L508 |
| system("echo 0 > /sys/class/gpio/gpio119/value"); |
| #else |
| #ifdef MBTK_PROJECT_PN1803 |
| system("echo 0 > /sys/class/gpio/gpio119/value"); |
| #else |
| #ifdef MBTK_PROJECT_L509 |
| system("echo 0 > /sys/class/gpio/gpio120/value"); |
| #endif |
| #endif |
| #endif |
| |
| #ifdef MBTK_PROJECT_L508_X6 |
| //close Ldo6 |
| system("i2cset -y -f 2 0x31 0x18 0x0f"); |
| //GPS_WAKE_HOST to GPIO |
| system("hwacc w 0xd401e198 0x1040"); |
| //HOST_WAKE_GPS to GPIO |
| //system("hwacc w 0xd401e0c0 0x1040"); |
| //gpio34 to GPIO |
| #if 1 |
| system("hwacc w 0xd401e164 0x1040"); |
| system("hwacc w 0xd401e166 0x1040"); |
| system("hwacc w 0xd401e1b4 0x1040"); |
| |
| system("hwacc w 0xd401e2ec 0xa441"); |
| system("hwacc w 0xd401e2f0 0xa441"); |
| system("hwacc w 0xd401e2f4 0xa441"); |
| system("hwacc w 0xd401e2f8 0xa441"); |
| system("hwacc w 0xd401e2fc 0xa441"); |
| system("hwacc w 0xd401e300 0xa441"); |
| |
| if(one_gpio_export(117, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(117, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(119, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(119, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| |
| |
| if(one_gpio_export(127, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(127, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(34, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(34, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(33, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(33, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(54, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(54, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| |
| #endif |
| #endif |
| |
| #ifdef MBTK_PROJECT_T108 |
| |
| #else |
| if(one_gpio_export(21, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(21, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(118, 2)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| if(one_gpio_export(118, 0)) |
| { |
| LOG("GPIO SET ERROR."); |
| } |
| #endif |
| // echo off > /sys/devices/mbtk-dev-op.10/gps_power && echo mem > /sys/power/autosleep |
| // echo 1 > /sys/devices/asr-rfkill.0/pwr_ctrl && sleep 2 && echo 0 > /sys/devices/asr-rfkill.0/pwr_ctrl |
| |
| if(!access("/sys/power/autosleep", W_OK)) |
| system("echo mem > /sys/power/autosleep"); |
| else |
| LOG("/sys/power/autosleep can not write."); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| #endif |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int port_config(mbtk_port_type_enum type, mbtk_port_mode_enum mode) { |
| |
| char type_buff[32] = {0}; |
| char mode_buff[32] = {0}; |
| switch(type) |
| { |
| case MBTK_PORT_TYPE_UART1: |
| strcpy(type_buff, "persist.mbtk.dev_ttyS1"); |
| break; |
| case MBTK_PORT_TYPE_USB1: |
| strcpy(type_buff, "persist.mbtk.dev_ttyGS0"); |
| break; |
| case MBTK_PORT_TYPE_USB2: |
| strcpy(type_buff, "persist.mbtk.dev_ttymodem0"); |
| break; |
| default: |
| return -1; |
| } |
| switch(mode) |
| { |
| case MBTK_PORT_MODE_AT: |
| strcpy(mode_buff, "at"); |
| break; |
| case MBTK_PORT_MODE_ADB: |
| strcpy(mode_buff, "adb"); |
| break; |
| case MBTK_PORT_MODE_CUSTOM: |
| strcpy(mode_buff, "custom"); |
| break; |
| default: |
| return -1; |
| } |
| return property_set(type_buff, mode_buff); |
| } |
| |
| utlReturnCode_T MBTK_AT_MPORTCFG_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = at_handle; |
| char resp_buf[1024] = {0}; |
| |
| LOG("MBTK_AT_MPORTCFG_PROCESS enter with command_op [%s]", op2str(op)); |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD: |
| { |
| int arg; |
| if(!getExtValue(parameter_values_p, 0, &arg, 0, 2, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| mbtk_port_type_enum type = (mbtk_port_type_enum)arg; |
| if(!getExtValue(parameter_values_p, 1, &arg, 0, 2, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| mbtk_port_mode_enum mode = (mbtk_port_mode_enum)arg; |
| |
| if(port_config(type, mode)) { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } else { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| |
| break; |
| } |
| case TEL_EXT_GET_CMD : |
| { |
| int len = 0; |
| char port_config[32] = {0}; |
| property_get("persist.mbtk.dev_ttyS1", port_config, "at"); |
| if(!strcmp(port_config, "adb")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_UART1, MBTK_PORT_MODE_ADB); |
| } else if(!strcmp(port_config, "custom")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_UART1, MBTK_PORT_MODE_CUSTOM); |
| } else { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_UART1, MBTK_PORT_MODE_AT); |
| } |
| |
| memset(port_config, 0, 32); |
| property_get("persist.mbtk.dev_ttyGS0", port_config, "at"); |
| if(!strcmp(port_config, "adb")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB1, MBTK_PORT_MODE_ADB); |
| } else if(!strcmp(port_config, "custom")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB1, MBTK_PORT_MODE_CUSTOM); |
| } else { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB1, MBTK_PORT_MODE_AT); |
| } |
| |
| memset(port_config, 0, 32); |
| property_get("persist.mbtk.dev_ttymodem0", port_config, "at"); |
| if(!strcmp(port_config, "adb")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB2, MBTK_PORT_MODE_ADB); |
| } else if(!strcmp(port_config, "custom")) { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB2, MBTK_PORT_MODE_CUSTOM); |
| } else { |
| len += sprintf(resp_buf + len, "%s : %d,%d\r\n", command_name_p, MBTK_PORT_TYPE_USB2, MBTK_PORT_MODE_AT); |
| } |
| |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_MURCECHO_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = At_handle; |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| |
| static int arg1 = 0; |
| |
| LOG("MBTK_AT_MTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| sprintf(resp_buf, "%s : %d\r\n", command_name_p, mbtk_urc_enable); |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 1, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| mbtk_urc_enable = (bool)arg1; |
| |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| RETURNCODE_T MBTK_AT_READVER_PROCESS( const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(parameter_values_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| /* |
| * Put parser index into the variable |
| */ |
| RETURNCODE_T rc = INITIAL_RETURN_CODE; |
| CiReturnCode ret = CIRC_FAIL; |
| UINT32 atHandle = MAKE_AT_HANDLE(* (TelAtParserID *) arg_p); |
| |
| *xid_p = atHandle; |
| // DBGMSG("%s: atHandle = %d.\n", __FUNCTION__, atHandle); |
| |
| /* |
| * process operation |
| */ |
| switch ( op ) |
| { |
| case TEL_EXT_ACTION_CMD: /* AT*READVER */ |
| { |
| char tmpBuf[512]; |
| #if 0 |
| sprintf(tmpBuf, "*READVER: \r\nrelease_version:%s\r\nrelease_time:%s\r\n", SYSTEM_RELEASE_NAME, SYSTEM_RELEASE_CREATION_DATE); |
| #else |
| { |
| char rel_version[128] = {0}; |
| char sdk[64] = {0}; |
| char rel_date[64] = {0}; |
| char dsp_version[128]={0}; |
| char dsp_date[64]={0}; |
| char rf_version[128] = {0}; |
| int num = 0; |
| |
| char internalRevisionId[400 + 1] = {0}; |
| char buildTimeStr[100 + 1] = {0}; |
| |
| //GetDspFWVersionAndDate(dsp_version1,dsp_date1); |
| //p_string = GetRFBinFWVersion(); |
| //p_string2 = GetRFBinFWDate(); |
| property_get("dev.cp.rel.revision", rel_version, "NULL"); |
| property_get("dev.cp.dsp.revision", dsp_version, "NULL"); |
| property_get("dev.cp.rf.revision", rf_version, "NULL"); |
| property_get("dev.cp.rel.time", rel_date, "NULL"); |
| property_get("dev.cp.dsp.time", dsp_date, "NULL"); |
| |
| #if 1 |
| if(strncmp(rel_version, "NULL", strlen("NULL")) != 0) |
| { |
| char *p1 = NULL; |
| p1 = strstr(rel_version, "SDK"); |
| if(p1 != NULL) |
| { |
| memcpy(sdk, p1, strlen(p1)); |
| p1 = strstr(sdk, "_"); |
| if(p1 != NULL) |
| { |
| *p1 = '\0'; |
| } |
| } |
| else |
| { |
| strcpy(sdk, "NULL"); |
| } |
| } |
| else |
| { |
| strcpy(sdk, "NULL"); |
| } |
| #endif |
| |
| sprintf(tmpBuf, "*READVER: \r\nRelease_Version: %s (SDK %s)\r\nRelease_Time: %s\r\n(DSP: %s %s)\r\n(RF: %s %s)\r\n(HW: %s by %s)\r\n", |
| rel_version,sdk,rel_date, |
| dsp_version,dsp_date, |
| rf_version,"NULL", |
| "NULL","NULL"); |
| } |
| #endif |
| ret = ATRESP( atHandle, ATCI_RESULT_CODE_OK, 0, tmpBuf); |
| break; |
| } |
| |
| |
| default: |
| ret = ATRESP( atHandle, ATCI_RESULT_CODE_CME_ERROR, CME_OPERATION_NOT_SUPPORTED, NULL ); |
| break; |
| } |
| |
| |
| rc = HANDLE_RETURN_VALUE(ret); |
| return(rc); |
| } |
| |
| utlReturnCode_T MBTK_AT_CGDRT_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = At_handle; |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| |
| static int mode = 0; |
| static int cert = 0; |
| |
| LOG("MBTK_AT_MTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &mode, 0, 139, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| if(!getExtValue(parameter_values_p, 1, &cert, 0, 1, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| |
| if(cert) //out |
| { |
| ret = one_gpio_export(mode, 2); |
| } |
| else //in |
| { |
| ret = one_gpio_export(mode, 3); |
| } |
| |
| |
| if(ret) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } |
| else |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| utlReturnCode_T MBTK_AT_CGSETV_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int At_handle = MAKE_AT_HANDLE(sAtp_index); |
| *xid_p = At_handle; |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| |
| static int mode = 0; |
| static int cert = 0; |
| |
| LOG("MBTK_AT_MTEST_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_SET_CMD : |
| { |
| if(!getExtValue(parameter_values_p, 0, &mode, 0, 139, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| if(!getExtValue(parameter_values_p, 1, &cert, 0, 1, 0)) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| |
| if(cert) //hight |
| { |
| ret = one_gpio_export(mode, 1); |
| } |
| else //low |
| { |
| ret = one_gpio_export(mode, 0); |
| } |
| |
| |
| if(ret) |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } |
| else |
| { |
| ret = ATRESP(At_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| utlReturnCode_T MBTK_AT_MDUMP_PROCESS(const utlAtParameterOp_T op, |
| const char *command_name_p, |
| const utlAtParameterValue_P2c parameter_values_p, |
| const size_t num_parameters, |
| const char *info_text_p, |
| unsigned int *xid_p, |
| void *arg_p) |
| { |
| UNUSEDPARAM(command_name_p); |
| UNUSEDPARAM(num_parameters); |
| UNUSEDPARAM(info_text_p); |
| |
| utlReturnCode_T ret = utlFAILED; |
| TelAtParserID sAtp_index = *(TelAtParserID *)arg_p; |
| unsigned int at_handle = MAKE_AT_HANDLE(sAtp_index); |
| char resp_buf[MBTK_AT_RESP_LEN_MAX] = {0}; |
| int arg1 = 0; |
| *xid_p = at_handle; |
| |
| LOG("MBTK_AT_MDUMP_PROCESS enter with command_op [%s]", op2str(op)); |
| |
| switch(op) |
| { |
| case TEL_EXT_GET_CMD : |
| { |
| char dump[10]; |
| memset(dump, 0, 10); |
| property_get("persist.mbtk.dump", dump, "0"); |
| snprintf(resp_buf, MBTK_AT_RESP_LEN_MAX, "+MDUMP: %d\r\n", atoi(dump)); |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, resp_buf); |
| break; |
| } |
| case TEL_EXT_SET_CMD : |
| { |
| int adc_ret; |
| if(!getExtValue(parameter_values_p, 0, &arg1, 0, 1, 0)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| break; |
| } |
| char dump[10]; |
| memset(dump, 0, 10); |
| if(arg1 == 1) { |
| memcpy(dump, "1", 1); |
| } else { |
| memcpy(dump, "0", 1); |
| } |
| if(property_set("persist.mbtk.dump", dump)) |
| { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_ERROR, 0, NULL); |
| } else { |
| ret = ATRESP(at_handle, ATCI_RESULT_CODE_OK, 0, NULL); |
| } |
| break; |
| } |
| default: |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |