S32 CuCommon_GetTxStatistics(THandle hCuCommon, TIWLN_TX_STATISTICS* pTxCounters, U32 doReset)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_802_11_TX_STATISTICS, pTxCounters, sizeof(TIWLN_TX_STATISTICS),
pTxCounters, sizeof(TIWLN_TX_STATISTICS));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
if(doReset)
{
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TX_CTRL_RESET_COUNTERS_PARAM, NULL, 0,
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
}
return OK;
}
S32 CuCommon_SetBuffer(THandle hCuCommon, U32 PrivateIoctlId, PVOID pBuffer, U32 len)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, PrivateIoctlId, pBuffer, len,
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_Get_BssidList_Size(THandle hCuCommon, PU32 pSizeOfBssiList)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, SCAN_CNCN_BSSID_LIST_SIZE_PARAM, NULL, 0,
pSizeOfBssiList, sizeof(U32));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_GetU8(THandle hCuCommon, U32 PrivateIoctlId, PU8 pData)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, PrivateIoctlId, NULL, 0,
pData, sizeof(U8));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_GetTxRxLinkStatistics(THandle hCuCommon, TLinkDataCounters *pLinkCounters)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, ROLE_AP_GET_LINK_COUNTERS,
pLinkCounters, sizeof(TLinkDataCounters)*WLANLINKS_MAX_LINKS,
pLinkCounters, sizeof(TLinkDataCounters)*WLANLINKS_MAX_LINKS);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_GetSnr(THandle hCuCommon, PU32 pdSnr, PU32 pbSnr)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
TCuCommon_RoamingStatisticsTable buffer;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TWD_SNR_RATIO_PARAM, NULL, 0,
&buffer, sizeof(TCuCommon_RoamingStatisticsTable));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
*pdSnr = (U32)buffer.snr;
*pbSnr = (U32)buffer.snrBeacon;
return OK;
}
S32 CuCommon_GetRssi(THandle hCuCommon, PS8 pdRssi, PS8 pbRssi)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
TCuCommon_RoamingStatisticsTable buffer;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_802_11_RSSI, NULL, 0,
&buffer, sizeof(TCuCommon_RoamingStatisticsTable));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
*pdRssi = (S8)buffer.rssi;
*pbRssi = (S8)buffer.rssiBeacon;
return OK;
}
S32 CuCommon_GetPowerConsumptionStat(THandle hCuCommon, ACXPowerConsumptionTimeStat_t *pPowerstat)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
ACXPowerConsumptionTimeStat_t tStatistics;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_GET_POWER_CONSUMPTION_STATISTICS, NULL, 0,
&tStatistics, sizeof(ACXPowerConsumptionTimeStat_t));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
os_memcpy(pPowerstat, &tStatistics, sizeof(ACXPowerConsumptionTimeStat_t));
return OK;
}
S32 CuCommon_GetRxDataFiltersStatistics(THandle hCuCommon, PU32 pUnmatchedPacketsCount, PU32 pMatchedPacketsCount)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
TCuCommon_RxDataFilteringStatistics buffer;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_GET_RX_DATA_FILTERS_STATISTICS, NULL, 0,
&buffer, sizeof(TCuCommon_RxDataFilteringStatistics));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
*pUnmatchedPacketsCount = buffer.unmatchedPacketsCount;
os_memcpy(pMatchedPacketsCount, &buffer.matchedPacketsCount, MAX_DATA_FILTERS*sizeof(U32));
return OK;
}
S32 CuCommon_SetDfsChannels(THandle hCuCommon, U16 MinDfsChannel, U16 MaxDfsChannel)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
DFS_ChannelRange_t DFS_ChannelRange;
DFS_ChannelRange.maxDFS_channelNum = MaxDfsChannel;
DFS_ChannelRange.minDFS_channelNum = MinDfsChannel;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_REG_DOMAIN_SET_DFS_RANGE, &DFS_ChannelRange, sizeof(DFS_ChannelRange_t),
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_RemoveKey(THandle hCuCommon, U32 KeyIndex)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
OS_802_11_KEY key;
os_memset(&key, 0, sizeof(OS_802_11_KEY));
key.KeyIndex = KeyIndex;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, RSN_REMOVE_KEY_PARAM, &key, sizeof(OS_802_11_KEY),
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_PrintDriverDebug(THandle hCuCommon, PVOID pParams, U32 param_size)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
if ( pParams == NULL )
{
return ECUERR_CU_COMMON_ERROR;
}
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_DISPLAY_STATS, pParams, param_size,
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_Radio_Test(THandle hCuCommon,TTestCmd* data)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta,
TWD_RADIO_TEST_PARAM,
(PVOID)data,
sizeof(TTestCmd),
(PVOID)data,
sizeof(TTestCmd));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
{
os_error_printf(CU_MSG_INFO2, (PS8)"In CuCommon_Radio_Test: IPC_STA_Private_Send failed\n");
return ECUERR_CU_COMMON_ERROR;
}
return OK;
}
S32 CuCommon_PrintDriverDebugBuffer(THandle hCuCommon, U32 func_id, U32 opt_param)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res, len;
U8 buf[260]; /* no more then 256 + func id */
if (opt_param == 0)
return ECUERR_CU_ERROR;
len = os_strlen((PS8)opt_param);
*(PU32)buf = func_id;
os_memcpy((PS8)buf + sizeof(U32),(PS8)opt_param, len);
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, TIWLN_DISPLAY_STATS, buf, len + sizeof(U32),
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
S32 CuCommon_AddKey(THandle hCuCommon, OS_802_11_WEP* pKey)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
OS_802_11_KEY key;
os_memset(&key, 0, sizeof(OS_802_11_KEY));
key.Length = pKey->Length;
key.KeyIndex = (pKey->KeyIndex & 0x80000000) | (pKey->KeyIndex & 0x3FFFFFFF);
key.KeyLength = pKey->KeyLength;
os_memcpy(key.KeyMaterial, pKey->KeyMaterial, pKey->KeyLength);
res = IPC_STA_Private_Send(pCuCommon->hIpcSta, RSN_ADD_KEY_PARAM, &key, sizeof(OS_802_11_KEY),
NULL, 0);
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
return ECUERR_CU_COMMON_ERROR;
return OK;
}
/* Return '0' if success */
S32 init_driver( PS8 adapter_name, PS8 eeprom_file_name,
PS8 init_file_name, PS8 firmware_file_name )
{
PVOID f1 = NULL, f2 = NULL, f3 = NULL;
S32 eeprom_image_length = 0;
S32 init_file_length = 0;
S32 firmware_image_length = 0;
U32 req_size = 0;
TLoaderFilesData *init_info = NULL;
S32 rc = -1;
THandle hIpcSta;
if( !adapter_name || !*adapter_name )
return rc;
os_error_printf(CU_MSG_INFO1, (PS8)"+---------------------------+\n");
os_error_printf(CU_MSG_INFO1, (PS8)"| wlan_loader: initializing |\n");
os_error_printf(CU_MSG_INFO1, (PS8)"+---------------------------+\n");
hIpcSta = IpcSta_Create(adapter_name);
if (hIpcSta == NULL)
{
os_error_printf (CU_MSG_ERROR, (PS8)"wlan_loader: cant allocate IpcSta context\n", eeprom_file_name);
goto init_driver_end;
}
/* Send init request to the driver */
if ( (NULL != eeprom_file_name) &&
(f1 = os_fopen (eeprom_file_name, OS_FOPEN_READ)) != NULL)
{
eeprom_image_length = os_getFileSize(f1);
if (-1 == eeprom_image_length)
{
os_error_printf(CU_MSG_ERROR, (PS8)"Cannot get eeprom image file length <%s>\n", eeprom_file_name);
goto init_driver_end;
}
}
if ( (NULL != firmware_file_name) &&
(f2 = os_fopen (firmware_file_name, OS_FOPEN_READ)) != NULL)
{
firmware_image_length = os_getFileSize(f2);
if (-1 == firmware_image_length)
{
os_error_printf(CU_MSG_ERROR, (PS8)"Cannot get firmware image file length <%s>\n", firmware_file_name);
goto init_driver_end;
}
}
if ( (NULL != init_file_name) &&
(f3 = os_fopen (init_file_name, OS_FOPEN_READ)) != NULL)
{
init_file_length = os_getFileSize(f3);
if (-1 == init_file_length)
{
os_error_printf(CU_MSG_ERROR, (PS8)"Cannot get init file length <%s>\n", init_file_name);
goto init_driver_end;
}
}
/* Now when we can calculate the request length. allocate it and read the files */
req_size = sizeof(TLoaderFilesData) + eeprom_image_length + (init_file_length+1) + firmware_image_length;
init_info = (TLoaderFilesData *)os_MemoryAlloc(req_size);
if (!init_info)
{
os_error_printf(CU_MSG_ERROR, (PS8)"No memory to allocate init request (%d bytes)\n", req_size);
goto init_driver_end;
}
init_info->uNvsFileLength = eeprom_image_length;
init_info->uFwFileLength = firmware_image_length;
init_info->uIniFileLength = init_file_length;
if (!f1 || (eeprom_image_length &&
os_fread(&init_info->data[0], 1, eeprom_image_length, f1)<eeprom_image_length))
{
} else
os_error_printf(CU_MSG_INFO1, (PS8)"**** nvs file found %s **** \n", eeprom_file_name);
if (!f2 || (firmware_image_length &&
os_fread(&init_info->data[eeprom_image_length], 1, firmware_image_length, f2)<firmware_image_length))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Error reading firmware image %s - Aborting...\n", firmware_file_name);
goto init_driver_end;
}
if (!f3 || (init_file_length &&
os_fread(&init_info->data[eeprom_image_length+firmware_image_length], 1, init_file_length, f3)<init_file_length))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Warning: Error in reading init_file %s - Using defaults\n", init_file_name);
}
/* Load driver defaults */
if(EOALERR_IPC_STA_ERROR_SENDING_WEXT == IPC_STA_Private_Send(hIpcSta, DRIVER_INIT_PARAM, init_info, req_size, NULL, 0))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Wlan_loader: Error sending init command (DRIVER_INIT_PARAM) to driver\n");
goto init_driver_end;
}
/* No Error Found */
rc = 0;
init_driver_end:
if (f1)
os_fclose(f1);
if (f2)
os_fclose(f2);
if (f3)
os_fclose(f3);
if (init_info)
os_MemoryFree(init_info);
if (hIpcSta)
IpcSta_Destroy(hIpcSta);
return rc;
}
