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) {
}
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++;
}
{
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;
}
if (pstrHostIFconnectAttr->bssid) {
- hif_drv->strWILC_UsrConnReq.pu8bssid = kmalloc(6, GFP_KERNEL);
- memcpy(hif_drv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->bssid, 6);
+ hif_drv->usr_conn_req.pu8bssid = kmalloc(6, GFP_KERNEL);
+ memcpy(hif_drv->usr_conn_req.pu8bssid, pstrHostIFconnectAttr->bssid, 6);
}
- hif_drv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssid_len;
+ hif_drv->usr_conn_req.ssidLen = pstrHostIFconnectAttr->ssid_len;
if (pstrHostIFconnectAttr->ssid) {
- hif_drv->strWILC_UsrConnReq.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
- memcpy(hif_drv->strWILC_UsrConnReq.pu8ssid,
+ hif_drv->usr_conn_req.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
+ memcpy(hif_drv->usr_conn_req.pu8ssid,
pstrHostIFconnectAttr->ssid,
pstrHostIFconnectAttr->ssid_len);
- hif_drv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssid_len] = '\0';
+ hif_drv->usr_conn_req.pu8ssid[pstrHostIFconnectAttr->ssid_len] = '\0';
}
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->ies_len;
+ hif_drv->usr_conn_req.ConnReqIEsLen = pstrHostIFconnectAttr->ies_len;
if (pstrHostIFconnectAttr->ies) {
- hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
- memcpy(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
+ hif_drv->usr_conn_req.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
+ memcpy(hif_drv->usr_conn_req.pu8ConnReqIEs,
pstrHostIFconnectAttr->ies,
pstrHostIFconnectAttr->ies_len);
}
- hif_drv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->security;
- hif_drv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->auth_type;
- hif_drv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->result;
- hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->arg;
+ hif_drv->usr_conn_req.u8security = pstrHostIFconnectAttr->security;
+ hif_drv->usr_conn_req.tenuAuth_type = pstrHostIFconnectAttr->auth_type;
+ hif_drv->usr_conn_req.pfUserConnectResult = pstrHostIFconnectAttr->result;
+ hif_drv->usr_conn_req.u32UserConnectPvoid = pstrHostIFconnectAttr->arg;
strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
{
strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
strWIDList[u32WidsCount].type = WID_BIN_DATA;
- strWIDList[u32WidsCount].val = hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs;
- strWIDList[u32WidsCount].size = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
+ strWIDList[u32WidsCount].val = hif_drv->usr_conn_req.pu8ConnReqIEs;
+ strWIDList[u32WidsCount].size = hif_drv->usr_conn_req.ConnReqIEsLen;
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
- info_element_size = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
+ info_element_size = hif_drv->usr_conn_req.ConnReqIEsLen;
info_element = kmalloc(info_element_size, GFP_KERNEL);
- memcpy(info_element, hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
+ memcpy(info_element, hif_drv->usr_conn_req.pu8ConnReqIEs,
info_element_size);
}
}
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->usr_conn_req.u8security;
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
- mode_11i = hif_drv->strWILC_UsrConnReq.u8security;
-
- PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->strWILC_UsrConnReq.u8security);
+ mode_11i = hif_drv->usr_conn_req.u8security;
+ PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->usr_conn_req.u8security);
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&hif_drv->strWILC_UsrConnReq.tenuAuth_type);
+ strWIDList[u32WidsCount].val = (s8 *)(&hif_drv->usr_conn_req.tenuAuth_type);
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
- auth_type = (u8)hif_drv->strWILC_UsrConnReq.tenuAuth_type;
+ auth_type = (u8)hif_drv->usr_conn_req.tenuAuth_type;
- PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", hif_drv->strWILC_UsrConnReq.tenuAuth_type);
+ PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", hif_drv->usr_conn_req.tenuAuth_type);
PRINT_D(HOSTINF_DBG, "Connecting to network of SSID %s on channel %d\n",
- hif_drv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->ch);
+ hif_drv->usr_conn_req.pu8ssid, pstrHostIFconnectAttr->ch);
strWIDList[u32WidsCount].id = (u16)WID_JOIN_REQ_EXTENDED;
strWIDList[u32WidsCount].type = WID_STR;
*(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap;
*(pu8CurrByte++) = ptstrJoinBssParam->ht_capable;
- hif_drv->strWILC_UsrConnReq.IsHTCapable = ptstrJoinBssParam->ht_capable;
+ hif_drv->usr_conn_req.IsHTCapable = ptstrJoinBssParam->ht_capable;
*(pu8CurrByte++) = ptstrJoinBssParam->rsn_found;
PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1));
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) {
memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
- if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
- if (hif_drv->strWILC_UsrConnReq.pu8bssid) {
+ if (hif_drv->usr_conn_req.pfUserConnectResult) {
+ if (hif_drv->usr_conn_req.pu8bssid) {
memcpy(strConnectInfo.au8bssid,
- hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
+ hif_drv->usr_conn_req.pu8bssid, 6);
}
- if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) {
- strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
- strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
+ if (hif_drv->usr_conn_req.pu8ConnReqIEs) {
+ strConnectInfo.ReqIEsLen = hif_drv->usr_conn_req.ConnReqIEsLen;
+ strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->usr_conn_req.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs,
- hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
+ hif_drv->usr_conn_req.pu8ConnReqIEs,
+ hif_drv->usr_conn_req.ConnReqIEsLen);
}
- hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
- &strConnectInfo,
- MAC_DISCONNECTED,
- NULL,
- hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
+ hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
+ &strConnectInfo,
+ MAC_DISCONNECTED,
+ NULL,
+ hif_drv->usr_conn_req.u32UserConnectPvoid);
kfree(strConnectInfo.pu8ReqIEs);
strConnectInfo.pu8ReqIEs = NULL;
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");
- hif_drv->strWILC_UsrConnReq.ssidLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
- kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
+ hif_drv->usr_conn_req.ssidLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ssid);
+ kfree(hif_drv->usr_conn_req.pu8bssid);
+ hif_drv->usr_conn_req.ConnReqIEsLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
eth_zero_addr(u8ConnectedSSID);
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) {
+ !hif_drv->usr_conn_req.pfUserConnectResult) {
PRINT_ER("driver is null\n");
return -EINVAL;
}
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);
eth_zero_addr(u8ConnectedSSID);
}
- if (hif_drv->strWILC_UsrConnReq.pu8bssid) {
+ if (hif_drv->usr_conn_req.pu8bssid) {
PRINT_D(HOSTINF_DBG, "Retrieving actual BSSID from AP\n");
- memcpy(strConnectInfo.au8bssid, hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
+ memcpy(strConnectInfo.au8bssid, hif_drv->usr_conn_req.pu8bssid, 6);
if ((u8MacStatus == MAC_CONNECTED) &&
(strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
memcpy(hif_drv->au8AssociatedBSSID,
- hif_drv->strWILC_UsrConnReq.pu8bssid, ETH_ALEN);
+ hif_drv->usr_conn_req.pu8bssid, ETH_ALEN);
}
}
-
- if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) {
- strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
- strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
+ if (hif_drv->usr_conn_req.pu8ConnReqIEs) {
+ strConnectInfo.ReqIEsLen = hif_drv->usr_conn_req.ConnReqIEsLen;
+ strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->usr_conn_req.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs,
- hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
+ hif_drv->usr_conn_req.pu8ConnReqIEs,
+ hif_drv->usr_conn_req.ConnReqIEsLen);
}
-
del_timer(&hif_drv->hConnectTimer);
- hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
- &strConnectInfo,
- u8MacStatus,
- NULL,
- hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
+ hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
+ &strConnectInfo,
+ u8MacStatus,
+ NULL,
+ hif_drv->usr_conn_req.u32UserConnectPvoid);
if ((u8MacStatus == MAC_CONNECTED) &&
(strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
kfree(strConnectInfo.pu8ReqIEs);
strConnectInfo.pu8ReqIEs = NULL;
- hif_drv->strWILC_UsrConnReq.ssidLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
- kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
+ hif_drv->usr_conn_req.ssidLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ssid);
+ kfree(hif_drv->usr_conn_req.pu8bssid);
+ hif_drv->usr_conn_req.ConnReqIEsLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
} else if ((u8MacStatus == MAC_DISCONNECTED) &&
(hif_drv->enuHostIFstate == HOST_IF_CONNECTED)) {
PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n");
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);
strDisconnectNotifInfo.ie = NULL;
strDisconnectNotifInfo.ie_len = 0;
- if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
+ if (hif_drv->usr_conn_req.pfUserConnectResult) {
g_obtainingIP = false;
host_int_set_power_mgmt(hif_drv, 0, 0);
- hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF,
- NULL,
- 0,
- &strDisconnectNotifInfo,
- hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
-
+ hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF,
+ NULL,
+ 0,
+ &strDisconnectNotifInfo,
+ hif_drv->usr_conn_req.u32UserConnectPvoid);
} else {
PRINT_ER("Connect result callback function is NULL\n");
}
eth_zero_addr(hif_drv->au8AssociatedBSSID);
- hif_drv->strWILC_UsrConnReq.ssidLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
- kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
+ hif_drv->usr_conn_req.ssidLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ssid);
+ kfree(hif_drv->usr_conn_req.pu8bssid);
+ hif_drv->usr_conn_req.ConnReqIEsLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
if (join_req && join_req_drv == hif_drv) {
kfree(join_req);
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);
}
}
struct key_attr *pstrHostIFkeyAttr)
{
s32 result = 0;
- struct wid strWID;
+ struct wid wid;
struct wid strWIDList[5];
u8 i;
u8 *pu8keybuf;
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);
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);
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) {
+ if (hif_drv->usr_conn_req.pfUserConnectResult) {
if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
del_timer(&hif_drv->hConnectTimer);
}
- hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
- 0, &strDisconnectNotifInfo, hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid);
+ hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
+ 0, &strDisconnectNotifInfo, hif_drv->usr_conn_req.u32UserConnectPvoid);
} else {
- PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n");
+ PRINT_ER("usr_conn_req.pfUserConnectResult = NULL\n");
}
scan_while_connected = false;
eth_zero_addr(hif_drv->au8AssociatedBSSID);
- hif_drv->strWILC_UsrConnReq.ssidLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ssid);
- kfree(hif_drv->strWILC_UsrConnReq.pu8bssid);
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
- kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
+ hif_drv->usr_conn_req.ssidLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ssid);
+ kfree(hif_drv->usr_conn_req.pu8bssid);
+ hif_drv->usr_conn_req.ConnReqIEsLen = 0;
+ kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
if (join_req && join_req_drv == hif_drv) {
kfree(join_req);
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");
{
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;
-
- if (!hif_drv->u8RemainOnChan_pendingreq) {
- hif_drv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid;
- hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired = pstrHostIfRemainOnChan->pRemainOnChanExpired;
- hif_drv->strHostIfRemainOnChan.pRemainOnChanReady = pstrHostIfRemainOnChan->pRemainOnChanReady;
- hif_drv->strHostIfRemainOnChan.u16Channel = pstrHostIfRemainOnChan->u16Channel;
- hif_drv->strHostIfRemainOnChan.u32ListenSessionID = pstrHostIfRemainOnChan->u32ListenSessionID;
+ struct wid wid;
+
+ if (!hif_drv->remain_on_ch_pending) {
+ hif_drv->remain_on_ch.pVoid = pstrHostIfRemainOnChan->pVoid;
+ hif_drv->remain_on_ch.pRemainOnChanExpired = pstrHostIfRemainOnChan->pRemainOnChanExpired;
+ hif_drv->remain_on_ch.pRemainOnChanReady = pstrHostIfRemainOnChan->pRemainOnChanReady;
+ hif_drv->remain_on_ch.u16Channel = pstrHostIfRemainOnChan->u16Channel;
+ hif_drv->remain_on_ch.u32ListenSessionID = pstrHostIfRemainOnChan->u32ListenSessionID;
} else {
- pstrHostIfRemainOnChan->u16Channel = hif_drv->strHostIfRemainOnChan.u16Channel;
+ pstrHostIfRemainOnChan->u16Channel = hif_drv->remain_on_ch.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;
+ hif_drv->remain_on_ch_pending = 1;
result = -EBUSY;
goto ERRORHANDLER;
}
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");
jiffies +
msecs_to_jiffies(pstrHostIfRemainOnChan->u32duration));
- if (hif_drv->strHostIfRemainOnChan.pRemainOnChanReady)
- hif_drv->strHostIfRemainOnChan.pRemainOnChanReady(hif_drv->strHostIfRemainOnChan.pVoid);
+ if (hif_drv->remain_on_ch.pRemainOnChanReady)
+ hif_drv->remain_on_ch.pRemainOnChanReady(hif_drv->remain_on_ch.pVoid);
- if (hif_drv->u8RemainOnChan_pendingreq)
- hif_drv->u8RemainOnChan_pendingreq = 0;
+ if (hif_drv->remain_on_ch_pending)
+ hif_drv->remain_on_ch_pending = 0;
}
return result;
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));
- 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");
goto _done_;
}
- if (hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired) {
- hif_drv->strHostIfRemainOnChan.pRemainOnChanExpired(hif_drv->strHostIfRemainOnChan.pVoid
- , pstrHostIfRemainOnChan->u32ListenSessionID);
+ if (hif_drv->remain_on_ch.pRemainOnChanExpired) {
+ hif_drv->remain_on_ch.pRemainOnChanExpired(hif_drv->remain_on_ch.pVoid,
+ pstrHostIfRemainOnChan->u32ListenSessionID);
}
P2P_LISTEN_STATE = 0;
} else {
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_LISTEN_TIMER_FIRED;
msg.drv = hif_drv;
- msg.body.remain_on_ch.u32ListenSessionID = hif_drv->strHostIfRemainOnChan.u32ListenSessionID;
+ msg.body.remain_on_ch.u32ListenSessionID = hif_drv->remain_on_ch.u32ListenSessionID;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
if (result)
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;
}
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);
Handle_ScanDone(msg.drv, SCAN_EVENT_DONE);
- if (hif_drv->u8RemainOnChan_pendingreq)
+ if (hif_drv->remain_on_ch_pending)
Handle_RemainOnChan(msg.drv, &msg.body.remain_on_ch);
break;
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;
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) {
{
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;
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;
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;
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);
return;
}
- if (!hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
+ if (!hif_drv->usr_conn_req.pfUserConnectResult) {
PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
up(&hif_sema_deinit);
return;
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;
}
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;
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;
projects / firefly-linux-kernel-4.4.55.git / blobdiff