u8 idx;
u8 duration[4];
u8 interval[4];
- u8 au8StartTime[4];
+ u8 start_time[4];
};
static struct host_if_drv *wfidrv_list[NUM_CONCURRENT_IFC + 1];
struct channel_attr *pstrHostIFSetChan)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_CURRENT_CHANNEL;
- strWID.type = WID_CHAR;
- strWID.val = (char *)&(pstrHostIFSetChan->set_ch);
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_CURRENT_CHANNEL;
+ wid.type = WID_CHAR;
+ wid.val = (char *)&pstrHostIFSetChan->set_ch;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Setting channel\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
struct drv_handler *pstrHostIfSetDrvHandler)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_SET_DRV_HANDLER;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&(pstrHostIfSetDrvHandler->u32Address);
- strWID.size = sizeof(u32);
+ wid.id = (u16)WID_SET_DRV_HANDLER;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&pstrHostIfSetDrvHandler->handler;
+ wid.size = sizeof(u32);
- result = send_config_pkt(SET_CFG, &strWID, 1,
- pstrHostIfSetDrvHandler->u32Address);
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ pstrHostIfSetDrvHandler->handler);
if (!hif_drv)
up(&hif_sema_driver);
struct op_mode *pstrHostIfSetOperationMode)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_SET_OPERATION_MODE;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&(pstrHostIfSetOperationMode->u32Mode);
- strWID.size = sizeof(u32);
+ wid.id = (u16)WID_SET_OPERATION_MODE;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&pstrHostIfSetOperationMode->mode;
+ wid.size = sizeof(u32);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
- if ((pstrHostIfSetOperationMode->u32Mode) == IDLE_MODE)
+ if ((pstrHostIfSetOperationMode->mode) == IDLE_MODE)
up(&hif_sema_driver);
if (result) {
s32 Handle_set_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
char firmwareIPAddress[4] = {0};
if (pu8IPAddr[0] < 192)
memcpy(set_ip[idx], pu8IPAddr, IP_ALEN);
- strWID.id = (u16)WID_IP_ADDRESS;
- strWID.type = WID_STR;
- strWID.val = (u8 *)pu8IPAddr;
- strWID.size = IP_ALEN;
+ wid.id = (u16)WID_IP_ADDRESS;
+ wid.type = WID_STR;
+ wid.val = (u8 *)pu8IPAddr;
+ wid.size = IP_ALEN;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
host_int_get_ipaddress(hif_drv, firmwareIPAddress, idx);
s32 Handle_get_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_IP_ADDRESS;
- strWID.type = WID_STR;
- strWID.val = kmalloc(IP_ALEN, GFP_KERNEL);
- strWID.size = IP_ALEN;
+ wid.id = (u16)WID_IP_ADDRESS;
+ wid.type = WID_STR;
+ wid.val = kmalloc(IP_ALEN, GFP_KERNEL);
+ wid.size = IP_ALEN;
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
- PRINT_INFO(HOSTINF_DBG, "%pI4\n", strWID.val);
+ PRINT_INFO(HOSTINF_DBG, "%pI4\n", wid.val);
- memcpy(get_ip[idx], strWID.val, IP_ALEN);
+ memcpy(get_ip[idx], wid.val, IP_ALEN);
- kfree(strWID.val);
+ kfree(wid.val);
if (memcmp(get_ip[idx], set_ip[idx], IP_ALEN) != 0)
host_int_setup_ipaddress(hif_drv, set_ip[idx], idx);
struct set_mac_addr *pstrHostIfSetMacAddress)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *mac_buf = kmalloc(ETH_ALEN, GFP_KERNEL);
+
if (!mac_buf) {
PRINT_ER("No buffer to send mac address\n");
return -EFAULT;
}
- memcpy(mac_buf, pstrHostIfSetMacAddress->u8MacAddress, ETH_ALEN);
+ memcpy(mac_buf, pstrHostIfSetMacAddress->mac_addr, ETH_ALEN);
- strWID.id = (u16)WID_MAC_ADDR;
- strWID.type = WID_STR;
- strWID.val = mac_buf;
- strWID.size = ETH_ALEN;
- PRINT_D(GENERIC_DBG, "mac addr = :%pM\n", strWID.val);
+ wid.id = (u16)WID_MAC_ADDR;
+ wid.type = WID_STR;
+ wid.val = mac_buf;
+ wid.size = ETH_ALEN;
+ PRINT_D(GENERIC_DBG, "mac addr = :%pM\n", wid.val);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
PRINT_ER("Failed to set mac address\n");
struct get_mac_addr *pstrHostIfGetMacAddress)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_MAC_ADDR;
- strWID.type = WID_STR;
- strWID.val = pstrHostIfGetMacAddress->u8MacAddress;
- strWID.size = ETH_ALEN;
+ wid.id = (u16)WID_MAC_ADDR;
+ wid.type = WID_STR;
+ wid.val = pstrHostIfGetMacAddress->mac_addr;
+ wid.size = ETH_ALEN;
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
down(&hif_drv->gtOsCfgValuesSem);
-
PRINT_D(HOSTINF_DBG, "Setting CFG params\n");
if (strHostIFCfgParamAttr->cfg_attr_info.flag & BSS_TYPE) {
u8WidCnt++;
}
if (strHostIFCfgParamAttr->cfg_attr_info.flag & FRAG_THRESHOLD) {
-
if (strHostIFCfgParamAttr->cfg_attr_info.frag_threshold > 255 && strHostIFCfgParamAttr->cfg_attr_info.frag_threshold < 7937) {
strWIDList[u8WidCnt].id = WID_FRAG_THRESHOLD;
strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.frag_threshold;
}
if (strHostIFCfgParamAttr->cfg_attr_info.flag & CURRENT_TX_RATE) {
enum CURRENT_TXRATE curr_tx_rate = strHostIFCfgParamAttr->cfg_attr_info.curr_tx_rate;
+
if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1
|| curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5
|| curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6
PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
PRINT_D(HOSTINF_DBG, "Scanning: In [%d] state\n", hif_drv->enuHostIFstate);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = pstrHostIFscanAttr->result;
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid = pstrHostIFscanAttr->arg;
+ hif_drv->usr_scan_req.pfUserScanResult = pstrHostIFscanAttr->result;
+ hif_drv->usr_scan_req.u32UserScanPvoid = pstrHostIFscanAttr->arg;
if ((hif_drv->enuHostIFstate >= HOST_IF_SCANNING) && (hif_drv->enuHostIFstate < HOST_IF_CONNECTED)) {
PRINT_D(GENERIC_DBG, "Don't scan we are already in [%d] state\n", hif_drv->enuHostIFstate);
PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
-
- hif_drv->strWILC_UsrScanReq.u32RcvdChCount = 0;
+ hif_drv->usr_scan_req.u32RcvdChCount = 0;
strWIDList[u32WidsCount].id = (u16)WID_SSID_PROBE_REQ;
strWIDList[u32WidsCount].type = WID_STR;
pu8Buffer += pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen;
}
-
-
strWIDList[u32WidsCount].size = (s32)(valuesize + 1);
u32WidsCount++;
}
strWIDList[u32WidsCount].id = WID_SCAN_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->type));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrHostIFscanAttr->type;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_SCAN_CHANNEL_LIST;
strWIDList[u32WidsCount].id = WID_START_SCAN_REQ;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->src));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrHostIFscanAttr->src;
u32WidsCount++;
if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)
{
s32 result = 0;
u8 u8abort_running_scan;
- struct wid strWID;
-
+ struct wid wid;
PRINT_D(HOSTINF_DBG, "in Handle_ScanDone()\n");
if (enuEvent == SCAN_EVENT_ABORTED) {
PRINT_D(GENERIC_DBG, "Abort running scan\n");
u8abort_running_scan = 1;
- strWID.id = (u16)WID_ABORT_RUNNING_SCAN;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u8abort_running_scan;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_ABORT_RUNNING_SCAN;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u8abort_running_scan;
+ wid.size = sizeof(char);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
return result;
}
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult(enuEvent, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
return result;
strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(hif_drv->strWILC_UsrConnReq.u8security));
+ strWIDList[u32WidsCount].val = (s8 *)&hif_drv->strWILC_UsrConnReq.u8security;
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->strWILC_UsrConnReq.u8security);
-
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
memcpy(pu8CurrByte, ptstrJoinBssParam->interval, sizeof(ptstrJoinBssParam->interval));
pu8CurrByte += sizeof(ptstrJoinBssParam->interval);
- memcpy(pu8CurrByte, ptstrJoinBssParam->au8StartTime, sizeof(ptstrJoinBssParam->au8StartTime));
-
- pu8CurrByte += sizeof(ptstrJoinBssParam->au8StartTime);
-
+ memcpy(pu8CurrByte, ptstrJoinBssParam->start_time, sizeof(ptstrJoinBssParam->start_time));
+ pu8CurrByte += sizeof(ptstrJoinBssParam->start_time);
} else
PRINT_D(HOSTINF_DBG, "NOA not present\n");
strWIDList[u32WidsCount].val = (s8 *)(&(mode_11i));
u32WidsCount++;
-
-
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
{
s32 result = 0;
tstrConnectInfo strConnectInfo;
- struct wid strWID;
+ struct wid wid;
u16 u16DummyReasonCode = 0;
if (!hif_drv) {
PRINT_ER("Connect callback function pointer is NULL\n");
}
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u16DummyReasonCode;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u16DummyReasonCode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send dissconect config packet\n");
bNewNtwrkFound = true;
PRINT_INFO(HOSTINF_DBG, "Handling received network info\n");
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n");
parse_network_info(pstrRcvdNetworkInfo->buffer, &pstrNetworkInfo);
if ((!pstrNetworkInfo) ||
- (!hif_drv->strWILC_UsrScanReq.pfUserScanResult)) {
+ (!hif_drv->usr_scan_req.pfUserScanResult)) {
PRINT_ER("driver is null\n");
result = -EINVAL;
goto done;
}
- for (i = 0; i < hif_drv->strWILC_UsrScanReq.u32RcvdChCount; i++) {
-
- if ((hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid) &&
+ for (i = 0; i < hif_drv->usr_scan_req.u32RcvdChCount; i++) {
+ if ((hif_drv->usr_scan_req.astrFoundNetworkInfo[i].au8bssid) &&
(pstrNetworkInfo->au8bssid)) {
- if (memcmp(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid,
+ if (memcmp(hif_drv->usr_scan_req.astrFoundNetworkInfo[i].au8bssid,
pstrNetworkInfo->au8bssid, 6) == 0) {
- if (pstrNetworkInfo->s8rssi <= hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi) {
+ if (pstrNetworkInfo->s8rssi <= hif_drv->usr_scan_req.astrFoundNetworkInfo[i].s8rssi) {
PRINT_D(HOSTINF_DBG, "Network previously discovered\n");
goto done;
} else {
- hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
+ hif_drv->usr_scan_req.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
bNewNtwrkFound = false;
break;
}
if (bNewNtwrkFound) {
PRINT_D(HOSTINF_DBG, "New network found\n");
- if (hif_drv->strWILC_UsrScanReq.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
- hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
+ if (hif_drv->usr_scan_req.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
+ hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
- if (hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid &&
+ if (hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].au8bssid &&
pstrNetworkInfo->au8bssid) {
- memcpy(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid,
+ memcpy(hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].au8bssid,
pstrNetworkInfo->au8bssid, 6);
- hif_drv->strWILC_UsrScanReq.u32RcvdChCount++;
+ hif_drv->usr_scan_req.u32RcvdChCount++;
pstrNetworkInfo->bNewNetwork = true;
pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid,
- pJoinParams);
-
-
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
+ hif_drv->usr_scan_req.u32UserScanPvoid,
+ pJoinParams);
}
} else {
PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit\n");
}
} else {
pstrNetworkInfo->bNewNetwork = false;
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
}
}
if ((hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) ||
(hif_drv->enuHostIFstate == HOST_IF_CONNECTED) ||
- hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult) {
if (!pstrRcvdGnrlAsyncInfo->buffer ||
!hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
PRINT_ER("driver is null\n");
PRINT_INFO(HOSTINF_DBG, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen);
if (u32RcvdAssocRespInfoLen != 0) {
-
PRINT_D(HOSTINF_DBG, "Parsing association response\n");
s32Err = ParseAssocRespInfo(rcv_assoc_resp, u32RcvdAssocRespInfoLen,
&pstrConnectRespInfo);
PRINT_INFO(HOSTINF_DBG, "Association response received : Successful connection status\n");
if (pstrConnectRespInfo->pu8RespIEs) {
strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen;
-
-
strConnectInfo.pu8RespIEs = kmalloc(pstrConnectRespInfo->u16RespIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs,
pstrConnectRespInfo->u16RespIEsLen);
}
}
-
if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) {
strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
}
-
del_timer(&hif_drv->hConnectTimer);
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
&strConnectInfo,
memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >>\n\n");
del_timer(&hif_drv->hScanTimer);
Handle_ScanDone((void *)hif_drv, SCAN_EVENT_ABORTED);
scan_while_connected = false;
} else if ((u8MacStatus == MAC_DISCONNECTED) &&
- (hif_drv->strWILC_UsrScanReq.pfUserScanResult)) {
+ (hif_drv->usr_scan_req.pfUserScanResult)) {
PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW while scanning\n");
PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running Scan >>\n\n");
del_timer(&hif_drv->hScanTimer);
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult)
+ if (hif_drv->usr_scan_req.pfUserScanResult)
Handle_ScanDone(hif_drv, SCAN_EVENT_ABORTED);
-
}
-
}
kfree(pstrRcvdGnrlAsyncInfo->buffer);
struct key_attr *pstrHostIFkeyAttr)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
struct wid strWIDList[5];
u8 i;
u8 *pu8keybuf;
s8 ret = 0;
switch (pstrHostIFkeyAttr->type) {
-
-
case WEP:
if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
-
PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
- PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", (pstrHostIFkeyAttr->attr.wep.index));
+ PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", pstrHostIFkeyAttr->attr.wep.index);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.mode;
strWIDList[1].id = WID_AUTH_TYPE;
strWIDList[1].type = WID_CHAR;
strWIDList[1].size = sizeof(char);
- strWIDList[1].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.auth_type));
+ strWIDList[1].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.auth_type;
strWIDList[2].id = (u16)WID_KEY_ID;
strWIDList[2].type = WID_CHAR;
- strWIDList[2].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
+ strWIDList[2].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.index;
strWIDList[2].size = sizeof(char);
pu8keybuf = kmemdup(pstrHostIFkeyAttr->attr.wep.key,
result = send_config_pkt(SET_CFG, strWIDList, 4,
get_id_from_handler(hif_drv));
kfree(pu8keybuf);
-
-
}
if (pstrHostIFkeyAttr->action & ADDKEY) {
pstrHostIFkeyAttr->attr.wep.key_len);
kfree(pstrHostIFkeyAttr->attr.wep.key);
- strWID.id = (u16)WID_ADD_WEP_KEY;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
+ wid.id = (u16)WID_ADD_WEP_KEY;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
kfree(pu8keybuf);
} else if (pstrHostIFkeyAttr->action & REMOVEKEY) {
-
PRINT_D(HOSTINF_DBG, "Removing key\n");
- strWID.id = (u16)WID_REMOVE_WEP_KEY;
- strWID.type = WID_STR;
+ wid.id = (u16)WID_REMOVE_WEP_KEY;
+ wid.type = WID_STR;
s8idxarray[0] = (s8)pstrHostIFkeyAttr->attr.wep.index;
- strWID.val = s8idxarray;
- strWID.size = 1;
+ wid.val = s8idxarray;
+ wid.size = 1;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
} else {
- strWID.id = (u16)WID_KEY_ID;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_KEY_ID;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&pstrHostIFkeyAttr->attr.wep.index;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Setting default key index\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
}
up(&hif_drv->hSemTestKeyBlock);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
strWIDList[1].id = (u16)WID_ADD_RX_GTK;
strWIDList[1].type = WID_STR;
memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
pstrHostIFkeyAttr->attr.wpa.key_len);
- strWID.id = (u16)WID_ADD_RX_GTK;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = RX_MIC_KEY_MSG_LEN;
+ wid.id = (u16)WID_ADD_RX_GTK;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = RX_MIC_KEY_MSG_LEN;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
kfree(pu8keybuf);
case WPAPtk:
if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
-
-
pu8keybuf = kmalloc(PTK_KEY_MSG_LEN + 1, GFP_KERNEL);
if (!pu8keybuf) {
PRINT_ER("No buffer to send PTK Key\n");
ret = -ENOMEM;
goto _WPAPtk_end_case_;
-
}
memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
strWIDList[1].id = (u16)WID_ADD_PTK;
strWIDList[1].type = WID_STR;
up(&hif_drv->hSemTestKeyBlock);
}
if (pstrHostIFkeyAttr->action & ADDKEY) {
-
-
pu8keybuf = kmalloc(PTK_KEY_MSG_LEN, GFP_KERNEL);
if (!pu8keybuf) {
PRINT_ER("No buffer to send PTK Key\n");
ret = -ENOMEM;
goto _WPAPtk_end_case_;
-
}
memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->attr.wpa.key,
pstrHostIFkeyAttr->attr.wpa.key_len);
- strWID.id = (u16)WID_ADD_PTK;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = PTK_KEY_MSG_LEN;
+ wid.id = (u16)WID_ADD_PTK;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = PTK_KEY_MSG_LEN;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
kfree(pu8keybuf);
up(&hif_drv->hSemTestKeyBlock);
break;
-
case PMKSA:
PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n");
memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].pmkid, PMKID_LEN);
}
- strWID.id = (u16)WID_PMKID_INFO;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
+ wid.id = (u16)WID_PMKID_INFO;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
kfree(pu8keybuf);
static void Handle_Disconnect(struct host_if_drv *hif_drv)
{
- struct wid strWID;
+ struct wid wid;
s32 result = 0;
u16 u16DummyReasonCode = 0;
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u16DummyReasonCode;
- strWID.size = sizeof(char);
-
-
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u16DummyReasonCode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
eth_zero_addr(u8ConnectedSSID);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
strDisconnectNotifInfo.ie = NULL;
strDisconnectNotifInfo.ie_len = 0;
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
del_timer(&hif_drv->hScanTimer);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
kfree(info_element);
info_element = NULL;
}
-
}
up(&hif_drv->hSemTestDisconnectBlock);
}
-
void resolve_disconnect_aberration(struct host_if_drv *hif_drv)
{
if (!hif_drv)
static s32 Handle_GetChnl(struct host_if_drv *hif_drv)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_CURRENT_CHANNEL;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&ch_no;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_CURRENT_CHANNEL;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&ch_no;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting channel value\n");
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
static void Handle_GetRssi(struct host_if_drv *hif_drv)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_RSSI;
- strWID.type = WID_CHAR;
- strWID.val = &rssi;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_RSSI;
+ wid.type = WID_CHAR;
+ wid.val = &rssi;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting RSSI value\n");
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
PRINT_ER("Failed to get RSSI value\n");
}
up(&hif_drv->hSemGetRSSI);
-
-
}
-
static void Handle_GetLinkspeed(struct host_if_drv *hif_drv)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
link_speed = 0;
- strWID.id = (u16)WID_LINKSPEED;
- strWID.type = WID_CHAR;
- strWID.val = &link_speed;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_LINKSPEED;
+ wid.type = WID_CHAR;
+ wid.val = &link_speed;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n");
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
PRINT_ER("Failed to get LINKSPEED value\n");
result = -EFAULT;
}
- up(&(hif_drv->hSemGetLINKSPEED));
-
-
+ up(&hif_drv->hSemGetLINKSPEED);
}
s32 Handle_GetStatistics(struct host_if_drv *hif_drv, struct rf_info *pstrStatistics)
strWIDList[u32WidsCount].id = WID_LINKSPEED;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u8LinkSpeed));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u8LinkSpeed;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_RSSI;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->s8RSSI));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->s8RSSI;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32TxCount;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32RxCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32RxCount;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxFailureCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32TxFailureCount;
u32WidsCount++;
result = send_config_pkt(GET_CFG, strWIDList, u32WidsCount,
up(&hif_sema_wait_response);
return 0;
-
}
static s32 Handle_Get_InActiveTime(struct host_if_drv *hif_drv,
{
s32 result = 0;
u8 *stamac;
- struct wid strWID;
-
- strWID.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
- strWID.type = WID_STR;
- strWID.size = ETH_ALEN;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
+ struct wid wid;
+ wid.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
+ wid.type = WID_STR;
+ wid.size = ETH_ALEN;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
- stamac = strWID.val;
+ stamac = wid.val;
memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN);
-
PRINT_D(CFG80211_DBG, "SETING STA inactive time\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
return -EFAULT;
}
+ wid.id = (u16)WID_GET_INACTIVE_TIME;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&inactive_time;
+ wid.size = sizeof(u32);
- strWID.id = (u16)WID_GET_INACTIVE_TIME;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&inactive_time;
- strWID.size = sizeof(u32);
-
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
struct beacon_attr *pstrSetBeaconParam)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Adding BEACON\n");
- strWID.id = (u16)WID_ADD_BEACON;
- strWID.type = WID_BIN;
- strWID.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val)
+ wid.id = (u16)WID_ADD_BEACON;
+ wid.type = WID_BIN;
+ wid.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = (pstrSetBeaconParam->interval & 0xFF);
*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 8) & 0xFF);
*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 16) & 0xFF);
memcpy(pu8CurrByte, pstrSetBeaconParam->tail, pstrSetBeaconParam->tail_len);
pu8CurrByte += pstrSetBeaconParam->tail_len;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send add beacon config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
kfree(pstrSetBeaconParam->head);
kfree(pstrSetBeaconParam->tail);
}
static void Handle_DelBeacon(struct host_if_drv *hif_drv)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_DEL_BEACON;
- strWID.type = WID_CHAR;
- strWID.size = sizeof(char);
- strWID.val = &del_beacon;
+ wid.id = (u16)WID_DEL_BEACON;
+ wid.type = WID_CHAR;
+ wid.size = sizeof(char);
+ wid.val = &del_beacon;
- if (!strWID.val)
+ if (!wid.val)
return;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
PRINT_D(HOSTINF_DBG, "Deleting BEACON\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send delete beacon config packet\n");
struct add_sta_param *pstrStationParam)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Handling add station\n");
- strWID.id = (u16)WID_ADD_STA;
- strWID.type = WID_BIN;
- strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
+ wid.id = (u16)WID_ADD_STA;
+ wid.type = WID_BIN;
+ wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result != 0)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
kfree(pstrStationParam->pu8Rates);
- kfree(strWID.val);
+ kfree(wid.val);
}
static void Handle_DelAllSta(struct host_if_drv *hif_drv,
struct del_all_sta *pstrDelAllStaParam)
{
s32 result = 0;
-
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
u8 i;
u8 au8Zero_Buff[6] = {0};
- strWID.id = (u16)WID_DEL_ALL_STA;
- strWID.type = WID_STR;
- strWID.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
+ wid.id = (u16)WID_DEL_ALL_STA;
+ wid.type = WID_STR;
+ wid.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
PRINT_D(HOSTINF_DBG, "Handling delete station\n");
- strWID.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
- if (!strWID.val)
+ wid.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*(pu8CurrByte++) = pstrDelAllStaParam->assoc_sta;
pu8CurrByte += ETH_ALEN;
}
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
up(&hif_sema_wait_response);
}
struct del_sta *pstrDelStaParam)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_REMOVE_STA;
- strWID.type = WID_BIN;
- strWID.size = ETH_ALEN;
+ wid.id = (u16)WID_REMOVE_STA;
+ wid.type = WID_BIN;
+ wid.size = ETH_ALEN;
PRINT_D(HOSTINF_DBG, "Handling delete station\n");
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
memcpy(pu8CurrByte, pstrDelStaParam->mac_addr, ETH_ALEN);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
}
static void Handle_EditStation(struct host_if_drv *hif_drv,
struct add_sta_param *pstrStationParam)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_EDIT_STA;
- strWID.type = WID_BIN;
- strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
+ wid.id = (u16)WID_EDIT_STA;
+ wid.type = WID_BIN;
+ wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
PRINT_D(HOSTINF_DBG, "Handling edit station\n");
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send edit station config packet\n");
ERRORHANDLER:
kfree(pstrStationParam->pu8Rates);
- kfree(strWID.val);
+ kfree(wid.val);
}
static int Handle_RemainOnChan(struct host_if_drv *hif_drv,
{
s32 result = 0;
u8 u8remain_on_chan_flag;
- struct wid strWID;
+ struct wid wid;
if (!hif_drv->u8RemainOnChan_pendingreq) {
hif_drv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid;
pstrHostIfRemainOnChan->u16Channel = hif_drv->strHostIfRemainOnChan.u16Channel;
}
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_INFO(GENERIC_DBG, "Required to remain on chan while scanning return\n");
hif_drv->u8RemainOnChan_pendingreq = 1;
result = -EBUSY;
PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel);
u8remain_on_chan_flag = true;
- strWID.id = (u16)WID_REMAIN_ON_CHAN;
- strWID.type = WID_STR;
- strWID.size = 2;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val) {
+ wid.id = (u16)WID_REMAIN_ON_CHAN;
+ wid.type = WID_STR;
+ wid.size = 2;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val) {
result = -ENOMEM;
goto ERRORHANDLER;
}
- strWID.val[0] = u8remain_on_chan_flag;
- strWID.val[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
+ wid.val[0] = u8remain_on_chan_flag;
+ wid.val[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result != 0)
PRINT_ER("Failed to set remain on channel\n");
struct reg_frame *pstrHostIfRegisterFrame)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType);
- strWID.id = (u16)WID_REGISTER_FRAME;
- strWID.type = WID_STR;
- strWID.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
- if (!strWID.val)
+ wid.id = (u16)WID_REGISTER_FRAME;
+ wid.type = WID_STR;
+ wid.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
+ if (!wid.val)
return -ENOMEM;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = pstrHostIfRegisterFrame->bReg;
*pu8CurrByte++ = pstrHostIfRegisterFrame->u8Regid;
- memcpy(pu8CurrByte, &(pstrHostIfRegisterFrame->u16FrameType), sizeof(u16));
-
+ memcpy(pu8CurrByte, &pstrHostIfRegisterFrame->u16FrameType,
+ sizeof(u16));
- strWID.size = sizeof(u16) + 2;
+ wid.size = sizeof(u16) + 2;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
PRINT_ER("Failed to frame register config packet\n");
struct remain_ch *pstrHostIfRemainOnChan)
{
u8 u8remain_on_chan_flag;
- struct wid strWID;
+ struct wid wid;
s32 result = 0;
PRINT_D(HOSTINF_DBG, "CANCEL REMAIN ON CHAN\n");
if (P2P_LISTEN_STATE) {
u8remain_on_chan_flag = false;
- strWID.id = (u16)WID_REMAIN_ON_CHAN;
- strWID.type = WID_STR;
- strWID.size = 2;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
+ wid.id = (u16)WID_REMAIN_ON_CHAN;
+ wid.type = WID_STR;
+ wid.size = 2;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
- if (!strWID.val)
+ if (!wid.val)
PRINT_ER("Failed to allocate memory\n");
- strWID.val[0] = u8remain_on_chan_flag;
- strWID.val[1] = FALSE_FRMWR_CHANNEL;
+ wid.val[0] = u8remain_on_chan_flag;
+ wid.val[1] = FALSE_FRMWR_CHANNEL;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result != 0) {
PRINT_ER("Failed to set remain on channel\n");
struct power_mgmt_param *strPowerMgmtParam)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
s8 s8PowerMode;
- strWID.id = (u16)WID_POWER_MANAGEMENT;
+ wid.id = (u16)WID_POWER_MANAGEMENT;
if (strPowerMgmtParam->enabled)
s8PowerMode = MIN_FAST_PS;
else
s8PowerMode = NO_POWERSAVE;
PRINT_D(HOSTINF_DBG, "Handling power mgmt to %d\n", s8PowerMode);
- strWID.val = &s8PowerMode;
- strWID.size = sizeof(char);
+ wid.val = &s8PowerMode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Handling Power Management\n");
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send power management config packet\n");
struct set_multicast *strHostIfSetMulti)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n");
- strWID.id = (u16)WID_SETUP_MULTICAST_FILTER;
- strWID.type = WID_BIN;
- strWID.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (!strWID.val)
+ wid.id = (u16)WID_SETUP_MULTICAST_FILTER;
+ wid.type = WID_BIN;
+ wid.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = (strHostIfSetMulti->enabled & 0xFF);
*pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 8) & 0xFF);
*pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 16) & 0xFF);
if ((strHostIfSetMulti->cnt) > 0)
memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->cnt) * ETH_ALEN));
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_ER("Failed to send setup multicast config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
-
+ kfree(wid.val);
}
static s32 Handle_AddBASession(struct host_if_drv *hif_drv,
struct ba_session_info *strHostIfBASessionInfo)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
int AddbaTimeout = 100;
char *ptr = NULL;
strHostIfBASessionInfo->u16SessionTimeout,
strHostIfBASessionInfo->u8Ted);
- strWID.id = (u16)WID_11E_P_ACTION_REQ;
- strWID.type = WID_STR;
- strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
- strWID.size = BLOCK_ACK_REQ_SIZE;
- ptr = strWID.val;
+ wid.id = (u16)WID_11E_P_ACTION_REQ;
+ wid.type = WID_STR;
+ wid.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
+ wid.size = BLOCK_ACK_REQ_SIZE;
+ ptr = wid.val;
*ptr++ = 0x14;
*ptr++ = 0x3;
*ptr++ = 0x0;
*ptr++ = 8;
*ptr++ = 0;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n");
-
- strWID.id = (u16)WID_11E_P_ACTION_REQ;
- strWID.type = WID_STR;
- strWID.size = 15;
- ptr = strWID.val;
+ wid.id = (u16)WID_11E_P_ACTION_REQ;
+ wid.type = WID_STR;
+ wid.size = 15;
+ ptr = wid.val;
*ptr++ = 15;
*ptr++ = 7;
*ptr++ = 0x2;
*ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
*ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
*ptr++ = 3;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
- kfree(strWID.val);
+ kfree(wid.val);
return result;
-
}
static s32 Handle_DelAllRxBASessions(struct host_if_drv *hif_drv,
struct ba_session_info *strHostIfBASessionInfo)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
char *ptr = NULL;
PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
strHostIfBASessionInfo->au8Bssid[2],
strHostIfBASessionInfo->u8Ted);
- strWID.id = (u16)WID_DEL_ALL_RX_BA;
- strWID.type = WID_STR;
- strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
- strWID.size = BLOCK_ACK_REQ_SIZE;
- ptr = strWID.val;
+ wid.id = (u16)WID_DEL_ALL_RX_BA;
+ wid.type = WID_STR;
+ wid.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
+ wid.size = BLOCK_ACK_REQ_SIZE;
+ ptr = wid.val;
*ptr++ = 0x14;
*ptr++ = 0x3;
*ptr++ = 0x2;
*ptr++ = 0;
*ptr++ = 32;
- result = send_config_pkt(SET_CFG, &strWID, 1,
+ result = send_config_pkt(SET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result)
PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
-
- kfree(strWID.val);
+ kfree(wid.val);
up(&hif_sema_wait_response);
}
if (msg.id == HOST_IF_MSG_CONNECT &&
- hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n");
wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
usleep_range(2 * 1000, 2 * 1000);
s32 host_int_remove_key(struct host_if_drv *hif_drv, const u8 *pu8StaAddress)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_REMOVE_KEY;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8StaAddress;
- strWID.size = 6;
+ wid.id = (u16)WID_REMOVE_KEY;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8StaAddress;
+ wid.size = 6;
return 0;
}
int result = 0;
struct host_if_msg msg;
-
if (!hif_drv) {
result = -EFAULT;
PRINT_ER("driver is null\n");
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WEP;
msg.body.key_info.action = DEFAULTKEY;
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WEP;
msg.body.key_info.action = ADDKEY;
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WPAPtk;
if (mode == AP_MODE) {
memcpy(msg.body.key_info.attr.wpa.seq, KeyRSC, u32KeyRSClen);
}
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WPARxGtk;
msg.drv = hif_drv;
msg.body.key_info.attr.wpa.key = kmalloc(u8KeyLen, GFP_KERNEL);
memcpy(msg.body.key_info.attr.wpa.key, pu8RxGtk, u8GtkKeylen);
- if (pu8RxMic) {
- memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic, RX_MIC_KEY_LEN);
- }
+ if (pu8RxMic)
+ memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic,
+ RX_MIC_KEY_LEN);
- if (pu8TxMic) {
- memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic, TX_MIC_KEY_LEN);
- }
+ if (pu8TxMic)
+ memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic,
+ TX_MIC_KEY_LEN);
msg.body.key_info.attr.wpa.index = u8KeyIdx;
msg.body.key_info.attr.wpa.key_len = u8KeyLen;
struct host_if_msg msg;
u32 i;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
u8 *pu8PmkidInfoArray,
u32 u32PmkidInfoLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_PMKID_INFO;
- strWID.type = WID_STR;
- strWID.size = u32PmkidInfoLen;
- strWID.val = pu8PmkidInfoArray;
+ wid.id = (u16)WID_PMKID_INFO;
+ wid.type = WID_STR;
+ wid.size = u32PmkidInfoLen;
+ wid.val = pu8PmkidInfoArray;
return 0;
}
u8 *pu8PassPhrase,
u8 u8Psklength)
{
- struct wid strWID;
+ struct wid wid;
if ((u8Psklength > 7) && (u8Psklength < 65)) {
- strWID.id = (u16)WID_11I_PSK;
- strWID.type = WID_STR;
- strWID.val = pu8PassPhrase;
- strWID.size = u8Psklength;
+ wid.id = (u16)WID_11I_PSK;
+ wid.type = WID_STR;
+ wid.val = pu8PassPhrase;
+ wid.size = u8Psklength;
}
return 0;
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_MAC_ADDRESS;
- msg.body.get_mac_info.u8MacAddress = pu8MacAddress;
+ msg.body.get_mac_info.mac_addr = pu8MacAddress;
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_MAC_ADDRESS;
- memcpy(msg.body.set_mac_info.u8MacAddress, pu8MacAddress, ETH_ALEN);
+ memcpy(msg.body.set_mac_info.mac_addr, pu8MacAddress, ETH_ALEN);
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
s32 host_int_get_RSNAConfigPSKPassPhrase(struct host_if_drv *hif_drv,
u8 *pu8PassPhrase, u8 u8Psklength)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_11I_PSK;
- strWID.type = WID_STR;
- strWID.size = u8Psklength;
- strWID.val = pu8PassPhrase;
+ wid.id = (u16)WID_11I_PSK;
+ wid.type = WID_STR;
+ wid.size = u8Psklength;
+ wid.val = pu8PassPhrase;
return 0;
}
s32 host_int_set_start_scan_req(struct host_if_drv *hif_drv, u8 scanSource)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_START_SCAN_REQ;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&scanSource;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_START_SCAN_REQ;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&scanSource;
+ wid.size = sizeof(char);
return 0;
}
s32 host_int_get_start_scan_req(struct host_if_drv *hif_drv, u8 *pu8ScanSource)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_START_SCAN_REQ;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)pu8ScanSource;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_START_SCAN_REQ;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)pu8ScanSource;
+ wid.size = sizeof(char);
return 0;
}
s32 host_int_disconnect_station(struct host_if_drv *hif_drv, u8 assoc_id)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&assoc_id;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&assoc_id;
+ wid.size = sizeof(char);
return 0;
}
u8 *pu8AssocReqInfo,
u32 u32AssocReqInfoLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_ASSOC_REQ_INFO;
- strWID.type = WID_STR;
- strWID.val = pu8AssocReqInfo;
- strWID.size = u32AssocReqInfoLen;
+ wid.id = (u16)WID_ASSOC_REQ_INFO;
+ wid.type = WID_STR;
+ wid.val = pu8AssocReqInfo;
+ wid.size = u32AssocReqInfoLen;
return 0;
}
u32 *pu32RcvdAssocRespInfoLen)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
if (!hif_drv) {
PRINT_ER("Driver is null\n");
return -EFAULT;
}
- strWID.id = (u16)WID_ASSOC_RES_INFO;
- strWID.type = WID_STR;
- strWID.val = pu8AssocRespInfo;
- strWID.size = u32MaxAssocRespInfoLen;
+ wid.id = (u16)WID_ASSOC_RES_INFO;
+ wid.type = WID_STR;
+ wid.val = pu8AssocRespInfo;
+ wid.size = u32MaxAssocRespInfoLen;
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
*pu32RcvdAssocRespInfoLen = 0;
PRINT_ER("Failed to send association response config packet\n");
return -EINVAL;
} else {
- *pu32RcvdAssocRespInfoLen = strWID.size;
+ *pu32RcvdAssocRespInfoLen = wid.size;
}
return result;
u8 *pu8RxPowerLevel,
u32 u32RxPowerLevelLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_RX_POWER_LEVEL;
- strWID.type = WID_STR;
- strWID.val = pu8RxPowerLevel;
- strWID.size = u32RxPowerLevelLen;
+ wid.id = (u16)WID_RX_POWER_LEVEL;
+ wid.type = WID_STR;
+ wid.val = pu8RxPowerLevel;
+ wid.size = u32RxPowerLevelLen;
return 0;
}
int host_int_wait_msg_queue_idle(void)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_Q_IDLE;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
int host_int_set_wfi_drv_handler(struct host_if_drv *hif_drv)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_WFIDRV_HANDLER;
- msg.body.drv.u32Address = get_id_from_handler(hif_drv);
+ msg.body.drv.handler = get_id_from_handler(hif_drv);
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
int host_int_set_operation_mode(struct host_if_drv *hif_drv, u32 mode)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_OPERATION_MODE;
- msg.body.mode.u32Mode = mode;
+ msg.body.mode.mode = mode;
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
s32 host_int_test_get_int_wid(struct host_if_drv *hif_drv, u32 *pu32TestMemAddr)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
}
- strWID.id = (u16)WID_MEMORY_ADDRESS;
- strWID.type = WID_INT;
- strWID.val = (s8 *)pu32TestMemAddr;
- strWID.size = sizeof(u32);
+ wid.id = (u16)WID_MEMORY_ADDRESS;
+ wid.type = WID_INT;
+ wid.val = (s8 *)pu32TestMemAddr;
+ wid.size = sizeof(u32);
- result = send_config_pkt(GET_CFG, &strWID, 1,
+ result = send_config_pkt(GET_CFG, &wid, 1,
get_id_from_handler(hif_drv));
if (result) {
return -EINVAL;
} else {
PRINT_D(HOSTINF_DBG, "Successfully got wid value\n");
-
}
return result;
{
s32 result = 0;
struct host_if_msg msg;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_RSSI;
msg.drv = hif_drv;
{
struct host_if_msg msg;
s32 result = 0;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_LINKSPEED;
msg.drv = hif_drv;
{
s32 result = 0;
struct host_if_msg msg;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_STATISTICS;
msg.body.data = (char *)pstrStatistics;
msg.drv = hif_drv;
s32 result = 0;
struct host_if_msg msg;
-
if (!hif_drv) {
PRINT_ER("hif_drv NULL\n");
return -EFAULT;
}
PRINT_D(HOSTINF_DBG, "Getting configuration parameters\n");
switch (u16WID) {
-
case WID_BSS_TYPE:
*pu16WID_Value = (u16)hif_drv->strCfgValues.bss_type;
break;
return result;
}
-void host_int_send_join_leave_info_to_host
- (u16 assocId, u8 *stationAddr, bool joining)
-{
-}
-
static void GetPeriodicRSSI(unsigned long arg)
{
struct host_if_drv *hif_drv = (struct host_if_drv *)arg;
mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
}
-
-void host_int_send_network_info_to_host
- (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi)
-{
-}
-
s32 host_int_init(struct net_device *dev, struct host_if_drv **hif_drv_handler)
{
s32 result = 0;
setup_timer(&hif_drv->hRemainOnChannel, ListenTimerCB, 0);
- sema_init(&(hif_drv->gtOsCfgValuesSem), 1);
+ sema_init(&hif_drv->gtOsCfgValuesSem, 1);
down(&hif_drv->gtOsCfgValuesSem);
hif_drv->enuHostIFstate = HOST_IF_IDLE;
terminated_handle = hif_drv;
PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count);
- if (del_timer_sync(&hif_drv->hScanTimer)) {
+ if (del_timer_sync(&hif_drv->hScanTimer))
PRINT_D(HOSTINF_DBG, ">> Scan timer is active\n");
- }
- if (del_timer_sync(&hif_drv->hConnectTimer)) {
+ if (del_timer_sync(&hif_drv->hConnectTimer))
PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
- }
if (del_timer_sync(&periodic_rssi))
PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
host_int_set_wfi_drv_handler(NULL);
down(&hif_sema_driver);
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
hif_drv->enuHostIFstate = HOST_IF_IDLE;
wilc_mq_destroy(&hif_msg_q);
}
- down(&(hif_drv->gtOsCfgValuesSem));
+ down(&hif_drv->gtOsCfgValuesSem);
ret = remove_handler_in_list(hif_drv);
if (ret)
id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
hif_drv = get_handler_from_id(id);
-
-
-
if (!hif_drv || hif_drv == terminated_handle) {
PRINT_ER("NetworkInfo received but driver not init[%p]\n", hif_drv);
return;
hif_drv = get_handler_from_id(id);
PRINT_D(HOSTINF_DBG, "General asynchronous info packet received\n");
-
if (!hif_drv || hif_drv == terminated_handle) {
PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n");
up(&hif_sema_deinit);
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO;
msg.drv = hif_drv;
id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
hif_drv = get_handler_from_id(id);
-
PRINT_D(GENERIC_DBG, "Scan notification received %p\n", hif_drv);
if (!hif_drv || hif_drv == terminated_handle)
return;
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_RCVD_SCAN_COMPLETE;
PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", result);
}
-
return;
-
}
s32 host_int_remain_on_channel(struct host_if_drv *hif_drv, u32 u32SessionID,
}
return result;
-
}
s32 host_int_del_beacon(struct host_if_drv *hif_drv)
struct host_if_msg msg;
struct add_sta_param *pstrAddStationMsg = &msg.body.add_sta_info;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
memcpy(pstrAddStationMsg, pstrStaParams, sizeof(struct add_sta_param));
if (pstrAddStationMsg->u8NumRates > 0) {
u8 *rates = kmalloc(pstrAddStationMsg->u8NumRates, GFP_KERNEL);
+
if (!rates)
return -ENOMEM;
u32 i;
u8 u8AssocNumb = 0;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
memcpy(pstrAddStationMsg, pstrStaParams, sizeof(struct add_sta_param));
if (pstrAddStationMsg->u8NumRates > 0) {
u8 *rates = kmalloc(pstrAddStationMsg->u8NumRates, GFP_KERNEL);
+
if (!rates)
return -ENOMEM;
struct host_if_msg msg;
struct set_multicast *pstrMulticastFilterParam = &msg.body.multicast_info;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
pNewJoinBssParam->supp_rates[0] = suppRatesNo;
index += 2;
- for (i = 0; i < suppRatesNo; i++) {
+ for (i = 0; i < suppRatesNo; i++)
pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i];
- }
+
index += suppRatesNo;
continue;
} else if (pu8IEs[index] == EXT_SUPP_RATES_IE) {
else
pNewJoinBssParam->supp_rates[0] += extSuppRatesNo;
index += 2;
- for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++) {
+ for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++)
pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i];
- }
+
index += extSuppRatesNo;
continue;
} else if (pu8IEs[index] == HT_CAPABILITY_IE) {
memcpy(pNewJoinBssParam->interval, pu8IEs + u16P2P_count, 4);
u16P2P_count += 4;
- memcpy(pNewJoinBssParam->au8StartTime, pu8IEs + u16P2P_count, 4);
+ memcpy(pNewJoinBssParam->start_time, pu8IEs + u16P2P_count, 4);
index += pu8IEs[index + 1] + 2;
continue;
pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
rsnIndex += 2;
- for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++) {
+ for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++)
pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
- }
+
pcipherTotalCount += pcipherCount;
rsnIndex += jumpOffset;
authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
rsnIndex += 2;
- for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++) {
+ for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++)
pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
- }
+
authTotalCount += authCount;
rsnIndex += jumpOffset;
continue;
} else
index += pu8IEs[index + 1] + 2;
-
}
-
-
}
return (void *)pNewJoinBssParam;
-
}
void host_int_freeJoinParams(void *pJoinParams)