/* * Function: wimaxcu_get_rf_status * Description: Get WiMAX radio status * Return: 0 for success or 1 for failure */ int wimaxcu_get_rf_status(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } printf("Radio Status: "); switch (DeviceStatus) { case WIMAX_API_DEVICE_STATUS_UnInitialized: printf("Device is not ready\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW: printf("HW and SW Radios are OFF\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW: printf("HW radio is OFF\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_SW: printf("SW radio is OFF\n"); break; default: printf("HW and SW radios are ON\n"); } return 0; }
/* * Function: wimaxcu_restore_factory_settings * Description: Reset to the factory default setting * Return: 0 for success or 1 for failure */ int wimaxcu_restore_factory_settings(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } if (DeviceStatus != WIMAX_API_DEVICE_STATUS_RF_OFF_SW) { printf("WARNING!! The radio must be turned off to reset to factory setting.\n"); printf(" This operation will erase previously stored scanned results\n"); printf(" and you will lose the ability to connect to the preferred NSP.\n"); return 1; } wmxStatus = CmdResetToFactorySettings(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } printf("WiMAX system is set to factory settings.\n"); return 0; }
/* * Function: wimaxcu_radio_on * Description: Turn on the Radio * Return: 0 for success, 1 for failure, or 2 for non-command related error */ int wimaxcu_set_radio_on(WIMAX_API_DEVICE_ID_P p_device_id) { int ret = 0; WIMAX_API_RET wmxStatus; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } if (DeviceStatus == WIMAX_API_DEVICE_STATUS_RF_OFF_SW) { wmxStatus = CmdControlPowerManagement(p_device_id, WIMAX_API_RF_ON); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); ret = 1; } else { // Wait 5 secs to get a confirmation of the updated(desired) device state before declaring success if (!wmxcu_sem_timeout(&g_semRfState, 5 * 1000)) { if ((g_devState == WIMAX_API_DEVICE_STATUS_Ready) || (g_devState == WIMAX_API_DEVICE_STATUS_Scanning) || (g_devState == WIMAX_API_DEVICE_STATUS_Connecting) || (g_devState == WIMAX_API_DEVICE_STATUS_Data_Connected)) { printf("SW Radio is turned ON.\n"); ret = 0; } else { printf ("ERROR: Failed to turn SW Radio ON.\n"); ret = 1; } } else { printf("ERROR: Failed to turn SW Radio ON.\n"); ret = 1; } } } else if (DeviceStatus == WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW || DeviceStatus == WIMAX_API_DEVICE_STATUS_RF_OFF_HW) { printf ("HW Radio is OFF.\nDisable HW Kill to turn ON the SW Radio.\n"); ret = 1; } else if (DeviceStatus == WIMAX_API_DEVICE_STATUS_UnInitialized) { printf ("ERROR: Turning the SW Radio ON unsuccessfull - Device is UnInitialized.\n"); ret = 1; } else { printf("HW and SW Radios are ON.\n"); } return ret; }
/* * Function: wimaxcu_get_stats * Description: Get statistics data * Return: 0 for success or 1 for failure */ int wimaxcu_get_stats(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus; WIMAX_API_CONNECTION_STAT Statistics; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } if (DeviceStatus != WIMAX_API_DEVICE_STATUS_Data_Connected) { // Dispaly a proper message and exit switch (DeviceStatus) { case WIMAX_API_DEVICE_STATUS_UnInitialized: printf("ERROR: Device not Initialized\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW: printf("WARNING: HW and SW Radio is turned OFF\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW: printf("WARNING: HW Radio is turned OFF\n"); break; case WIMAX_API_DEVICE_STATUS_RF_OFF_SW: printf("WARNING: SW Radio is turned OFF\n"); break; case WIMAX_API_DEVICE_STATUS_Ready: case WIMAX_API_DEVICE_STATUS_Scanning: case WIMAX_API_DEVICE_STATUS_Connecting: printf("WARNING: Network is not Connected\n"); break; default: printf("ERROR: Unknown Device Status\n"); } return 1; } wmxStatus = GetStatistics(p_device_id, &Statistics); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } printf("Statistics:\n"); printf("\tTotal RX Bytes : %lld bytes\n", Statistics.totalRxByte); printf("\tTotal TX Bytes : %lld bytes\n", Statistics.totalTxByte); printf("\tTotal RX Packets : %lld\n", Statistics.totalRxPackets); printf("\tTotal TX Packets : %lld\n", Statistics.totalTxPackets); return 0; }
/* * Get the device's status from the device * * Does NOT cache the result * Does NOT trigger a state change in NetworkManager * * Returns < 0 errno code on error, status code if ok. */ static WIMAX_API_DEVICE_STATUS iwmx_sdk_get_device_status(struct wmxsdk *wmxsdk) { WIMAX_API_RET r; char errstr[512]; UINT32 errstr_size = sizeof(errstr); WIMAX_API_DEVICE_STATUS dev_status; WIMAX_API_CONNECTION_PROGRESS_INFO pi; r = GetDeviceStatus(&wmxsdk->device_id, &dev_status, &pi); if (r != WIMAX_API_RET_SUCCESS) { GetErrorString(&wmxsdk->device_id, r, errstr, &errstr_size); nm_log_err(LOGD_WIMAX, "wmxsdk: Cannot read device state: %d (%s)", r, errstr); dev_status = -EIO; } return dev_status; }
/* * Function: wimaxcu_get_system_status * Description: Get the WiMAX device status from the GetDeviceStatus API * Return: 0 for success or 1 for failure */ int wimaxcu_get_system_status(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } PrintDeviceStatus(DeviceStatus); return 0; }
int wimaxcu_stop_scan(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus = WIMAX_API_RET_SUCCESS; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus =GetDeviceStatus(p_device_id, &DeviceStatus,&ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } if (DeviceStatus == WIMAX_API_DEVICE_STATUS_Scanning) { wmxStatus = CmdStopScan(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { printf("ERROR: Failed to stop scanning.\n"); return 1; } } return 0; }
/* * Function: wimaxcu_get_connect_status * Description: Get the current connection status of WiMAX Device * Return: 0 for success or 1 for failure */ int wimaxcu_get_connect_status(WIMAX_API_DEVICE_ID_P p_device_id) { WIMAX_API_RET wmxStatus; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } PrintDeviceStatus(DeviceStatus); // if connected or idle, display connected NSP info if (DeviceStatus == WIMAX_API_DEVICE_STATUS_Data_Connected) { wimaxcu_get_conn_nsp(p_device_id); wimaxcu_get_conn_time(p_device_id); } return 0; }
/************************************************************************** * * Function: ubsec_ioctl * *************************************************************************/ static int ubsec_ioctl(struct inode *inode,struct file *filp,unsigned int cmd, unsigned long arg) { long Retval=0; int status = 0; int deadlockctr = 0; unsigned short value; /* Simple round robin scheduling of device. We need to increment first since the keysetup command may block. */ TheBeginning: deadlockctr = 0; do { /* For diagnostic related stuff do not try any available devices */ /* Try the intended device or all devices as directed by the command */ if (cmd >= UBSEC_DEVICEDUMP || cmd == UBSEC_SELFTEST || cmd == UBSEC_FAILDEVICE) { break; } if(++deadlockctr == (NumDevices * 2)) { /* to be conservative... */ #ifdef DEBUG_FAILOVER PRINTK("dispatch found no more devices.\n"); #endif return 1; /* error: no more devices */ } if ((++SelectedDevice) == NumDevices) SelectedDevice=0; } while(GetDeviceStatus(DeviceInfoList[SelectedDevice])); #ifdef DEBUG_FAILOVER printk("\n"); PRINTK("dsptch-pre: SltdDev=%d,DevStati=%d %d\n", SelectedDevice, DeviceInfoList[0].DeviceStatus, DeviceInfoList[1].DeviceStatus); #endif switch(cmd) { #ifdef BCM_OEM_1 case BCM_OEM_1_IOCTL1: BCM_OEM1_IOCTL1_HANDLER(); break; case BCM_OEM_1_IOCTL2: BCM_OEM1_IOCTL2_HANDLER(); break; #endif /* BCM_OEM_1 */ case UBSEC_ENCRYPT_DECRYPT_FUNC: status = do_encrypt(DeviceInfoList[SelectedDevice].Context, (void *)arg, DeviceInfoList[SelectedDevice].Features); break; case UBSEC_KEY_SETUP_FUNC: status = ubsec_keysetup(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_MATH_FUNC: status = ubsec_math(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_RNG_FUNC: if (DeviceInfoList[SelectedDevice].Features & UBSEC_EXTCHIPINFO_RNG) status = ubsec_rng(DeviceInfoList[SelectedDevice].Context, (void *)arg); else status = UBSEC_STATUS_NO_DEVICE; break; case UBSEC_TLS_HMAC_FUNC: status = ubsec_tlsmac(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_SSL_MAC_FUNC: status = ubsec_sslmac(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_SSL_HASH_FUNC: status = ubsec_hash(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_SSL_DES_FUNC: status = ubsec_sslcipher(DeviceInfoList[SelectedDevice].Context, (void *)arg, DeviceInfoList[SelectedDevice].Features); break; case UBSEC_SSL_ARC4_FUNC: if (DeviceInfoList[SelectedDevice].Features & UBSEC_EXTCHIPINFO_ARC4) status = ubsec_sslarc4(DeviceInfoList[SelectedDevice].Context, (void *)arg); else status = UBSEC_STATUS_NO_DEVICE; break; case UBSEC_CHIPINFO_FUNC: status = obsolete_chipinfo(DeviceInfoList[SelectedDevice].Context, (void *)arg); break; case UBSEC_STATS_FUNC: { ubsec_stats_io_t IOInfo; int device_num; if (copy_from_user((void *) &IOInfo,(void *) arg, sizeof(ubsec_stats_io_t))) return -EFAULT; device_num = IOInfo.device_num; if ( (device_num >= NumDevices) || (device_num < 0) ) return -1; ubsec_GetStatistics(DeviceInfoList[device_num].Context, &IOInfo.dev_stats); if (copy_to_user((void *) arg, (void *) &IOInfo, sizeof(ubsec_stats_io_t))) return -EFAULT; } break; case UBSEC_EXTCHIPINFO_FUNC: if (copy_from_user((void *)&ExtChipInfo, (void *)arg, sizeof(ubsec_chipinfo_io_t))) return -EFAULT; if (ExtChipInfo.Status !=sizeof(ubsec_chipinfo_io_t)) { UserCopySize = sizeof(ubsec_chipinfo_io_t); if (UserCopySize > ExtChipInfo.Status) UserCopySize = ExtChipInfo.Status; ExtChipInfo.Status = UBSEC_STATUS_NO_DEVICE; if (copy_to_user((void *)arg, (void *)&ExtChipInfo, UserCopySize)) return -EFAULT; return(-1); } else if ((ExtChipInfo.CardNum >= NumDevices) || (ExtChipInfo.CardNum < 0)) { ExtChipInfo.CardNum = NumDevices; ExtChipInfo.Status = UBSEC_STATUS_INVALID_PARAMETER; } else { status = ubsec_chipinfo(DeviceInfoList[ExtChipInfo.CardNum].Context, &ExtChipInfo); ExtChipInfo.NumDevices = NumDevices; ExtChipInfo.Features &= DeviceInfoList[ExtChipInfo.CardNum].Features; ExtChipInfo.Status = UBSEC_STATUS_SUCCESS; } if (copy_to_user((void *)arg, (void *)&ExtChipInfo, sizeof(ubsec_chipinfo_io_t))) return -EFAULT; if (ExtChipInfo.Status != UBSEC_STATUS_SUCCESS) return(-1); else return(0); break; case UBSEC_DEVICEDUMP: if (copy_from_user((void *)&PInt_Contents, (void *)arg, sizeof(int))) return -EFAULT; Retval=DumpDeviceInfo((PInt)&PInt_Contents); if (Retval) return(-1); /* Error */ break; case UBSEC_FAILDEVICE: if (copy_from_user((void *)&PInt_Contents, (void *)arg, sizeof(int))) return -EFAULT; Retval=FailDevices((PInt)&PInt_Contents); if (Retval) return(-1); /* Error */ break; case UBSEC_SELFTEST: #ifdef BCM_OEM_1 DISABLE_BCM_OEM1(); #endif /*BCM_OEM_1 */ if (copy_from_user((void *)&PInt_Contents, (void *)arg, sizeof(int))) return -EFAULT; Retval=TestDevices((PInt)&PInt_Contents); #ifdef BCM_OEM_1 ENABLE_BCM_OEM1(); #endif /*BCM_OEM_1 */ if (Retval) return (Retval); /* Error */ case UBSEC_GETVERSION: if (copy_from_user((void *)&PInt_Contents, (void *)arg, sizeof(int))) return -EFAULT; Retval=GetHardwareVersion((PInt)&PInt_Contents); /* For the moment one card */ Retval=Retval<<16; Retval+=Version; #ifdef LINUX_IA64 return Retval; #else return(-Retval); #endif break; case UBSEC_GETNUMCARDS: if (copy_to_user((void *)arg,&NumDevices,sizeof(int))) return -EFAULT; return NumDevices; case UBSEC_GET_FUNCTION_PTRS: { ubsec_Function_Ptrs_t fptrs; get_ubsec_Function_Ptrs(&fptrs); if (copy_to_user((void *) arg, (void *) &fptrs, sizeof(ubsec_Function_Ptrs_t))) return -EFAULT; } break; #ifdef DVT case UBSEC_RESERVED: if (copy_from_user((void *)&DVTparams, (void *)arg, sizeof(DVT_Params_t))) return -EFAULT; if ((DVTparams.CardNum >= NumDevices) || (DVTparams.CardNum < 0)) { {PRINTK("Invalid CardNum (%d), must be 0",DVTparams.CardNum);} if (NumDevices == 1) printk("\n"); else printk("-%d\n",NumDevices-1); return -1; } switch (DVTparams.Command) { case UBSEC_DVT_PAGESIZE: /* Wrapper command */ DVTparams.OutParameter = Page_Size; if (!DVTparams.InParameter) { DVTparams.OutParameter = Page_Size = PAGE_SIZE; DVTparams.Status = UBSEC_STATUS_SUCCESS; Retval = UBSEC_STATUS_SUCCESS; } else if ((DVTparams.InParameter > PAGE_SIZE) || (DVTparams.InParameter < 2)) { DVTparams.Status = UBSEC_STATUS_INVALID_PARAMETER; } else { if (!power_of_2(DVTparams.InParameter)) DVTparams.InParameter = next_smaller_power_of_2(DVTparams.InParameter); DVTparams.OutParameter = Page_Size; Page_Size = DVTparams.InParameter; DVTparams.Status = UBSEC_STATUS_SUCCESS; Retval = UBSEC_STATUS_SUCCESS; } break; default: /* Pass all other commands down to the SRL */ Retval=ubsec_dvt_handler((void *)DeviceInfoList[DVTparams.CardNum].Context,(void *)&DVTparams); }; if (copy_to_user((void *)arg, (void *)&DVTparams, sizeof(DVT_Params_t))) return -EFAULT; return(Retval); break; #endif /* DVT */ default: return -EINVAL; } #ifdef DEBUG_FAILOVER PRINTK("dsptch-pst: SltdDev=%d,DevStati=%d %d\n", SelectedDevice, DeviceInfoList[0].DeviceStatus, DeviceInfoList[1].DeviceStatus); if((status == ETIMEDOUT) || (status == -ETIMEDOUT)) { PRINTK("dispatch.c: TIMED OUT SelectedDevice=%d, DeviceStatus=%d\n", SelectedDevice, DeviceInfoList[SelectedDevice].DeviceStatus); } #endif switch(status) { case 0: break; case (ETIMEDOUT): status = -ETIMEDOUT; case (-ETIMEDOUT): DeviceInfoList[SelectedDevice].DeviceStatus = TestDevice(SelectedDevice); /* goto TheBeginning; */ return(status); break; default: /* goto TheBeginning; */ return(status); break; } return 0; }
int wimaxcu_find_network(WIMAX_API_DEVICE_ID_P p_device_id, int profileId, WIMAX_API_NSP_INFO_P nspInfo) { WIMAX_API_RET wmxStatus = WIMAX_API_RET_SUCCESS; UINT32 numProfileList = MAX_PROFILE; int i = 0, j = 0,ret = 0; int time_out = 0; UINT32 numOfNSPs = MAX_DEVICE; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; WIMAX_API_NSP_INFO_P pNspInfo = (WIMAX_API_NSP_INFO_P) malloc(MAX_LEN * sizeof(WIMAX_API_NSP_INFO)); WIMAX_API_PROFILE_INFO_P profilelist = (WIMAX_API_PROFILE_INFO_P) malloc(sizeof(WIMAX_API_PROFILE_INFO) * MAX_PROFILE); memset(profilelist, 0, sizeof(WIMAX_API_PROFILE_INFO) * MAX_PROFILE); //1. Get the profile list and network list wmxStatus = GetSelectProfileList(p_device_id, profilelist, &numProfileList); if (wmxStatus != WIMAX_API_RET_SUCCESS) { printf("ERROR: Could not fetch the profile list- "); PrintWmxStatus(wmxStatus); return 0; } if (numProfileList == 0) { printf("WARNING: Profile list is empty \n"); return 0; } for (i = 0; i < numProfileList; i++) { // check the match if (profileId == profilelist[i].profileID) { // // zero the memory memset(pNspInfo, 0, sizeof(WIMAX_API_NSP_INFO) * MAX_LEN); wmxStatus = GetNetworkList(p_device_id, pNspInfo, &numOfNSPs); if (WIMAX_API_RET_SUCCESS != wmxStatus) { printf ("ERROR: Could not fetch network list - "); PrintWmxStatus(wmxStatus); free(pNspInfo); free(profilelist); return 0; } if(numOfNSPs == 0) { //numOfNSPs is 0 now - it should be set to MAX numOfNSPs=MAX_DEVICE; printf("Searching....\n"); wmxStatus = SubscribeNetworkSearch(p_device_id, &ind_network_search_cb ); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } wmxStatus = CmdNetworkSearch(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } printf("Scanning %2d%% Done ", g_searchProgress); fflush(stdout); do { if (wmxcu_sem_timeout(&g_semConnectionUtility,5*1000) == 1 ) { time_out++; //if (pthread_mutex_trylock(&g_console_owner_mutex) == 0) { printf("\r"); printf("Scanning %2d%% Done ", g_searchProgress); // printf("Scanning %2d% Done [", g_searchProgress); for(i = 0; i<=time_out; i++) { printf("="); } printf("-"); // for(i = 0; i<=SCAN_TIMEOUT_IN_10SEC_ITREATIONS - time_out; i++) // { // printf(" "); // } // printf("]"); fflush(stdout); // pthread_mutex_unlock(&g_console_owner_mutex); //} wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } if (DeviceStatus == WIMAX_API_DEVICE_STATUS_Ready) { if (g_noNetworksFound == 1) printf("\nNo networks found.\n"); break; } if (time_out > SCAN_TIMEOUT_IN_10SEC_ITREATIONS) { if (g_noNetworksFound == 1) { printf("\nNo networks found.\n"); } else { printf("\nScan Operation timeout.\n"); // As Scan operation timed out ret = 1; } break; } } else { break; } } while (1); wmxStatus = GetNetworkList(p_device_id, pNspInfo, &numOfNSPs); if (WIMAX_API_RET_SUCCESS != wmxStatus) { printf("ERROR: Attempt to connect not successfull - "); PrintWmxStatus(wmxStatus); free(pNspInfo); return 2; } wmxStatus = UnsubscribeNetworkSearch(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } } if (numOfNSPs == 0) { printf("No available networks.\n"); free(profilelist); free(pNspInfo); return 0; } for (j = 0; j < numOfNSPs; j++) { if ((pNspInfo[j].NSPid & 0xffffff) == profileId) { // match with nspid, if there copy the nsp name and send it back memcpy(nspInfo, &pNspInfo[j], sizeof(WIMAX_API_NSP_INFO)); free(pNspInfo); free(profilelist); return 1; } } } } // return the proper status of this function free(profilelist); free(pNspInfo); // get the profile list and compare with nspid and return the result return 0; }
int wimaxcu_get_network_list_ex(WIMAX_API_DEVICE_ID_P p_device_id, CMD_ARGS scan_mode) { int ret = 0; WIMAX_API_RET wmxStatus; int time_out = 0; WIMAX_API_CONNECTION_MODE connectMode; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; WIMAX_API_NSP_INFO_EX_P pNspInfo; UINT32 numOfNSPs = 20; int i = 0; // initialize the variable as No Networks found g_noNetworksFound = 1; g_searchProgress = 0; // get the device status wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } switch (DeviceStatus) { case WIMAX_API_DEVICE_STATUS_UnInitialized: /**< Device is uninitialized */ printf("ERROR: Device not Initialized\n"); return 2; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW: /**< Device RF Off(both H/W and S/W) */ printf ("WARNING: HW and SW Radios are OFF.\nPlease turn ON the HW and SW Radios to perform a scan.\n"); return 2; case WIMAX_API_DEVICE_STATUS_RF_OFF_HW: /**< Device RF Off(via H/W switch) */ printf ("WARNING: HW Radio is OFF.\nPlease turn ON the HW Radio to perform a scan.\n"); return 2; case WIMAX_API_DEVICE_STATUS_RF_OFF_SW: /**< Device RF Off(via S/W switch) */ printf ("WARNING: SW Radio is OFF.\nPlease turn ON the SW Radio to perform a scan.\n"); return 2; case WIMAX_API_DEVICE_STATUS_Ready: /**< Device is ready */ case WIMAX_API_DEVICE_STATUS_Scanning: /**< Device is scanning */ break; case WIMAX_API_DEVICE_STATUS_Connecting: /**< Connection in progress */ printf("WARNING: Connection is in progress\n"); return 2; case WIMAX_API_DEVICE_STATUS_Data_Connected: /**< Layer 2 connected */ printf ("WARNING: Connection already established!\nPlease disconnect, before attempting to scan.\n"); return 2; default: printf("ERROR: Device status Unknown.\n"); return 2; } wmxStatus = SubscribeRfTaken(p_device_id, &ind_rf_taken_cb); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } wmxStatus = GetConnectionMode(p_device_id, &connectMode); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } if (connectMode == WIMAX_API_CONNECTION_MANUAL_SCAN_MANUAL_CONNECT && DeviceStatus == WIMAX_API_DEVICE_STATUS_Scanning) { printf ("WARNING: Scanning is in progress\nPlease wait for the current scan to complete.\n"); return 2; } if (scan_mode == CMD_SCAN_ARG_PREFERRED) { wmxStatus = SubscribeNetworkSearchEx(p_device_id, &ind_network_search_cb_ex); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } /* In Manual mode always scan do not read the cache as we don't know when cache was updated */ if (connectMode != WIMAX_API_CONNECTION_MANUAL_SCAN_MANUAL_CONNECT) { pNspInfo = (WIMAX_API_NSP_INFO_EX_P) malloc(MAX_LEN * sizeof (WIMAX_API_NSP_INFO_EX)); memset(pNspInfo, 0, sizeof(WIMAX_API_NSP_INFO_EX) * MAX_LEN); wmxStatus = GetNetworkListEx(p_device_id, pNspInfo, &numOfNSPs); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); /* If the Device is already scanning, it won't allow one more AppSrv will reject it with the Operation Falied error */ free(pNspInfo); return 1; } if (numOfNSPs != 0) { for (i = 0; i < numOfNSPs; i++) { printf("\nNetwork found.\n"); PrintNSPInfoEx(&pNspInfo[i]); if (wimaxcu_is_network_activated_ex (p_device_id, &pNspInfo[i])) printf("\tActivated\n"); else printf("\tNot Activated\n"); } return 0; } } wmxStatus = CmdNetworkSearch(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); if ((DeviceStatus == WIMAX_API_DEVICE_STATUS_Scanning) && (wmxStatus == WIMAX_API_RET_FAILED)) { printf ("WARNING: Scanning is in progress\nPlease wait for the current scan to complete.\n"); } return 1; } printf("Scanning %2d%% Done ", g_searchProgress); fflush(stdout); do { if (wmxcu_sem_timeout(&g_semConnectionUtility, 5 * 1000) == 1) { time_out++; //if (pthread_mutex_trylock(&g_console_owner_mutex) == 0) { printf("\r"); printf("Scanning %2d%% Done ", g_searchProgress); // printf("Scanning %2d% Done [", g_searchProgress); for (i = 0; i <= time_out; i++) { printf("="); } printf("-"); // for(i = 0; i<=SCAN_TIMEOUT_IN_10SEC_ITREATIONS - time_out; i++) // { // printf(" "); // } // printf("]"); fflush(stdout); //pthread_mutex_unlock(&g_console_owner_mutex); //} wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } if (DeviceStatus == WIMAX_API_DEVICE_STATUS_Ready) { if (g_noNetworksFound == 1) printf("\nNo networks found.\n"); break; } if (time_out > SCAN_TIMEOUT_IN_10SEC_ITREATIONS) { if (g_noNetworksFound == 1) { printf ("\nNo networks found.\n"); } else { printf ("\nScan Operation timeout.\n"); // As Scan operation timed out ret = 1; } break; } } else { break; } } while (1); } else if (scan_mode == CMD_SCAN_ARG_WIDE) { wmxStatus = SubscribeNetworkSearchWideScanEx(p_device_id, &ind_network_search_wide_scan_cb_ex); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } // Display the warning message: printf("WARNING: Wide scan may take upto 2 minutes... \n"); wmxStatus = CmdNetworkSearchWideScan(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); /* If the Device is already scanning, it won't allow one more AppSrv will reject it with the Operation Falied wrror */ if ((DeviceStatus == WIMAX_API_DEVICE_STATUS_Scanning) && (wmxStatus == WIMAX_API_RET_FAILED)) { printf ("WARNING: Scanning is in progress\nPlease wait for the current scan to complete.\n "); } return 1; } if (wmxcu_sem_timeout(&g_semConnectionUtility, 120 * 1000) == 1) printf("No networks found.\n"); } wmxStatus = UnsubscribeRfTaken(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } wmxStatus = UnsubscribeNetworkSearchEx(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } wmxStatus = UnsubscribeNetworkSearchWideScanEx(p_device_id); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } return ret; }
//------------------------------------------------------------------------------ /// Handles the given request if it is standard, otherwise STALLs it. /// \param pDriver Pointer to a USBDDriver instance. /// \param pRequest Pointer to a USBGenericRequest instance. //------------------------------------------------------------------------------ void USBDDriver_RequestHandler( USBDDriver *pDriver, const USBGenericRequest *pRequest) { unsigned char cfgnum; unsigned char infnum; unsigned char eptnum; unsigned char setting; unsigned char type; unsigned char indexDesc; unsigned int length; unsigned int address; TRACE_INFO_WP("Std "); // Check request code switch (USBGenericRequest_GetRequest(pRequest)) { case USBGenericRequest_GETDESCRIPTOR: TRACE_INFO_WP("gDesc "); // Send the requested descriptor type = USBGetDescriptorRequest_GetDescriptorType(pRequest); indexDesc = USBGetDescriptorRequest_GetDescriptorIndex(pRequest); length = USBGenericRequest_GetLength(pRequest); GetDescriptor(pDriver, type, indexDesc, length); break; case USBGenericRequest_SETADDRESS: TRACE_INFO_WP("sAddr "); // Sends a zero-length packet and then set the device address address = USBSetAddressRequest_GetAddress(pRequest); USBD_Write(0, 0, 0, (TransferCallback) USBD_SetAddress, (void *) address); break; case USBGenericRequest_SETCONFIGURATION: TRACE_INFO_WP("sCfg "); // Set the requested configuration cfgnum = USBSetConfigurationRequest_GetConfiguration(pRequest); SetConfiguration(pDriver, cfgnum); break; case USBGenericRequest_GETCONFIGURATION: TRACE_INFO_WP("gCfg "); // Send the current configuration number GetConfiguration(pDriver); break; case USBGenericRequest_GETSTATUS: TRACE_INFO_WP("gSta "); // Check who is the recipient switch (USBGenericRequest_GetRecipient(pRequest)) { case USBGenericRequest_DEVICE: TRACE_INFO_WP("Dev "); // Send the device status GetDeviceStatus(pDriver); break; case USBGenericRequest_ENDPOINT: TRACE_INFO_WP("Ept "); // Send the endpoint status eptnum = USBGenericRequest_GetEndpointNumber(pRequest); GetEndpointStatus(eptnum); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown recipient (%d)\n\r", USBGenericRequest_GetRecipient(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_CLEARFEATURE: TRACE_INFO_WP("cFeat "); // Check which is the requested feature switch (USBFeatureRequest_GetFeatureSelector(pRequest)) { case USBFeatureRequest_ENDPOINTHALT: TRACE_INFO_WP("Hlt "); // Unhalt endpoint and send a zero-length packet USBD_Unhalt(USBGenericRequest_GetEndpointNumber(pRequest)); USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_DEVICEREMOTEWAKEUP: TRACE_INFO_WP("RmWU "); // Disable remote wake-up and send a zero-length packet pDriver->isRemoteWakeUpEnabled = 0; USBD_Write(0, 0, 0, 0, 0); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown feature selector (%d)\n\r", USBFeatureRequest_GetFeatureSelector(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_SETFEATURE: TRACE_INFO_WP("sFeat "); // Check which is the selected feature switch (USBFeatureRequest_GetFeatureSelector(pRequest)) { case USBFeatureRequest_DEVICEREMOTEWAKEUP: TRACE_INFO_WP("RmWU "); // Enable remote wake-up and send a ZLP pDriver->isRemoteWakeUpEnabled = 1; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_ENDPOINTHALT: TRACE_INFO_WP("Halt "); // Halt endpoint USBD_Halt(USBGenericRequest_GetEndpointNumber(pRequest)); USBD_Write(0, 0, 0, 0, 0); break; #if defined(CHIP_USB_UDPHS) || defined(CHIP_USB_OTGHS) case USBFeatureRequest_TESTMODE: // 7.1.20 Test Mode Support if ((USBGenericRequest_GetType(pRequest) == USBGenericRequest_DEVICE) && ((USBGenericRequest_GetIndex(pRequest) & 0x000F) == 0)) { // Handle test request USBDDriver_Test(USBFeatureRequest_GetTestSelector(pRequest)); } else { USBD_Stall(0); } break; #endif #if defined(CHIP_USB_OTGHS) case USBFeatureRequest_OTG_B_HNP_ENABLE: TRACE_INFO_WP("OTG_B_HNP_ENABLE "); otg_features_supported |= 1<<USBFeatureRequest_OTG_B_HNP_ENABLE; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_OTG_A_HNP_SUPPORT: TRACE_INFO_WP("OTG_A_HNP_SUPPORT "); otg_features_supported |= 1<<USBFeatureRequest_OTG_A_HNP_SUPPORT; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_OTG_A_ALT_HNP_SUPPORT: TRACE_INFO_WP("OTG_A_ALT_HNP_SUPPORT "); otg_features_supported |= 1<<USBFeatureRequest_OTG_A_ALT_HNP_SUPPORT; USBD_Write(0, 0, 0, 0, 0); break; #endif default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown feature selector (%d)\n\r", USBFeatureRequest_GetFeatureSelector(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_SETINTERFACE: TRACE_INFO_WP("sInterface "); infnum = USBInterfaceRequest_GetInterface(pRequest); setting = USBInterfaceRequest_GetAlternateSetting(pRequest); SetInterface(pDriver, infnum, setting); break; case USBGenericRequest_GETINTERFACE: TRACE_INFO_WP("gInterface "); infnum = USBInterfaceRequest_GetInterface(pRequest); GetInterface(pDriver, infnum); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown request code (%d)\n\r", USBGenericRequest_GetRequest(pRequest)); USBD_Stall(0); } }
/* * Function: SetUserConnectMode * Description: Change the user connect mode * Return: 0 for success or 1 for failure */ int wimaxcu_set_user_connect_mode(WIMAX_API_DEVICE_ID_P p_device_id, char *connect_mode, char *scan_mode) { int ret; WIMAX_API_RET wmxStatus; WIMAX_API_CONNECTION_MODE userConnectMode, currentConnectMode; WIMAX_API_DEVICE_STATUS DeviceStatus; WIMAX_API_CONNECTION_PROGRESS_INFO ConnectionProgressInfo; wmxStatus = GetConnectionMode(p_device_id, ¤tConnectMode); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 1; } userConnectMode = currentConnectMode; ret = ConvertCharToConnectionMode(connect_mode, scan_mode, &userConnectMode); if (ret == -1) { printf("Specified Scan/Connect mode(s) not recognized.\n"); PrintUserConnectionMode(currentConnectMode); return 1; } else if (ret == -2) { printf("WARNING: Invalid connect and scan combination.\n"); printf("Auto connection requires semi scan mode.\n"); PrintUserConnectionMode(currentConnectMode); return 1; } if (userConnectMode == currentConnectMode) { printf("The specified connect mode is already in place.\n"); PrintUserConnectionMode(currentConnectMode); return 1; } if (ret == 1) { wmxStatus = GetDeviceStatus(p_device_id, &DeviceStatus, &ConnectionProgressInfo); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); return 2; } } if((userConnectMode == WIMAX_API_CONNECTION_SEMI_MANUAL_SCAN_AUTO_CONNECT)&&((DeviceStatus==WIMAX_API_DEVICE_STATUS_RF_OFF_SW)||(DeviceStatus==WIMAX_API_DEVICE_STATUS_RF_OFF_HW)||(DeviceStatus==WIMAX_API_DEVICE_STATUS_RF_OFF_HW_SW))){ printf("Error:Please turn the Radio On\n"); return 1; } wmxStatus = SetConnectionMode(p_device_id, userConnectMode); if (WIMAX_API_RET_SUCCESS != wmxStatus) { // PrintWmxStatus(wmxStatus); if (WIMAX_API_RET_FAILED == wmxStatus) { BOOL isEnable; wmxStatus = GetConnectedAsCurrentPreferredCapabilityStatus (p_device_id, &isEnable); if (wmxStatus == WIMAX_API_RET_SUCCESS) { if (isEnable == FALSE) { printf ("Current Connected Network Preferred settings are disabled\n"); printf ("Hence could not set the connect mode to Auto \n"); printf ("Going back to the pprevious connect mode \n"); wmxStatus = SetConnectionMode(p_device_id, currentConnectMode); if (WIMAX_API_RET_SUCCESS != wmxStatus) { PrintWmxStatus(wmxStatus); } else { PrintUserConnectionMode (currentConnectMode); } return 1; } else { printf("Operation Failed \n"); return 1; } } } PrintWmxStatus(wmxStatus); return 1; } // Unset the preferred NSP if (userConnectMode == WIMAX_API_CONNECTION_MANUAL_SCAN_MANUAL_CONNECT) { g_preferred_NSP_ID = 0; SetCurrentPreferredProfiles(p_device_id, &g_preferred_NSP_ID, 0); } PrintUserConnectionMode(userConnectMode); return 0; }
/** * Handles the given request if it is standard, otherwise STALLs it. * \param pDriver Pointer to a USBDDriver instance. * \param pRequest Pointer to a USBGenericRequest instance. */ void USBDDriver_RequestHandler( USBDDriver *pDriver, const USBGenericRequest *pRequest) { uint8_t cfgnum; uint8_t infnum; uint8_t eptnum; uint8_t setting; uint8_t type; uint8_t indexDesc; uint32_t length; uint32_t address; TRACE_INFO_WP("Std "); /* Check request code */ switch (USBGenericRequest_GetRequest(pRequest)) { case USBGenericRequest_GETDESCRIPTOR: TRACE_INFO_WP("gDesc "); /* Send the requested descriptor */ type = USBGetDescriptorRequest_GetDescriptorType(pRequest); indexDesc = USBGetDescriptorRequest_GetDescriptorIndex(pRequest); length = USBGenericRequest_GetLength(pRequest); GetDescriptor(pDriver, type, indexDesc, length); break; case USBGenericRequest_SETADDRESS: TRACE_INFO_WP("sAddr "); /* Sends a zero-length packet and then set the device address */ address = USBSetAddressRequest_GetAddress(pRequest); USBD_Write(0, 0, 0, (TransferCallback) USBD_SetAddress, (void *) address); break; case USBGenericRequest_SETCONFIGURATION: TRACE_INFO_WP("sCfg "); /* Set the requested configuration */ cfgnum = USBSetConfigurationRequest_GetConfiguration(pRequest); SetConfiguration(pDriver, cfgnum); break; case USBGenericRequest_GETCONFIGURATION: TRACE_INFO_WP("gCfg "); /* Send the current configuration number */ GetConfiguration(pDriver); break; case USBGenericRequest_GETSTATUS: TRACE_INFO_WP("gSta "); /* Check who is the recipient */ switch (USBGenericRequest_GetRecipient(pRequest)) { case USBGenericRequest_DEVICE: TRACE_INFO_WP("Dev "); /* Send the device status */ GetDeviceStatus(pDriver); break; case USBGenericRequest_ENDPOINT: TRACE_INFO_WP("Ept "); /* Send the endpoint status */ eptnum = USBGenericRequest_GetEndpointNumber(pRequest); GetEndpointStatus(eptnum); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown recipient (%d)\n\r", USBGenericRequest_GetRecipient(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_CLEARFEATURE: TRACE_INFO_WP("cFeat "); /* Check which is the requested feature */ switch (USBFeatureRequest_GetFeatureSelector(pRequest)) { case USBFeatureRequest_ENDPOINTHALT: TRACE_INFO_WP("Hlt "); /* Unhalt endpoint and send a zero-length packet */ USBD_Unhalt(USBGenericRequest_GetEndpointNumber(pRequest)); USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_DEVICEREMOTEWAKEUP: TRACE_INFO_WP("RmWU "); /* Disable remote wake-up and send a zero-length packet */ pDriver->isRemoteWakeUpEnabled = 0; USBD_Write(0, 0, 0, 0, 0); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown feature selector (%d)\n\r", USBFeatureRequest_GetFeatureSelector(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_SETFEATURE: TRACE_INFO_WP("sFeat "); /* Check which is the selected feature */ switch (USBFeatureRequest_GetFeatureSelector(pRequest)) { case USBFeatureRequest_DEVICEREMOTEWAKEUP: TRACE_INFO_WP("RmWU "); /* Enable remote wake-up and send a ZLP */ pDriver->isRemoteWakeUpEnabled = 1; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_ENDPOINTHALT: TRACE_INFO_WP("Halt "); /* Halt endpoint */ USBD_Halt(USBGenericRequest_GetEndpointNumber(pRequest)); USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_OTG_B_HNP_ENABLE: TRACE_INFO_WP("OTG_B_HNP_ENABLE "); pDriver->otg_features_supported |= 1<<USBFeatureRequest_OTG_B_HNP_ENABLE; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_OTG_A_HNP_SUPPORT: TRACE_INFO_WP("OTG_A_HNP_SUPPORT "); pDriver->otg_features_supported |= 1<<USBFeatureRequest_OTG_A_HNP_SUPPORT; USBD_Write(0, 0, 0, 0, 0); break; case USBFeatureRequest_OTG_A_ALT_HNP_SUPPORT: TRACE_INFO_WP("OTG_A_ALT_HNP_SUPPORT "); pDriver->otg_features_supported |= 1<<USBFeatureRequest_OTG_A_ALT_HNP_SUPPORT; USBD_Write(0, 0, 0, 0, 0); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown feature selector (%d)\n\r", USBFeatureRequest_GetFeatureSelector(pRequest)); USBD_Stall(0); } break; case USBGenericRequest_SETINTERFACE: TRACE_INFO_WP("sInterface "); infnum = USBInterfaceRequest_GetInterface(pRequest); setting = USBInterfaceRequest_GetAlternateSetting(pRequest); SetInterface(pDriver, infnum, setting); break; case USBGenericRequest_GETINTERFACE: TRACE_INFO_WP("gInterface "); infnum = USBInterfaceRequest_GetInterface(pRequest); GetInterface(pDriver, infnum); break; default: TRACE_WARNING( "USBDDriver_RequestHandler: Unknown request code (%d)\n\r", USBGenericRequest_GetRequest(pRequest)); USBD_Stall(0); } }