openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

staging: wilc1000: rename strWILC_UsrConnReq of struct host_if_drv 

This patch renames strWILC_UsrConnReq of struct host_if_drv to usr_conn_req
to avoid CamelCase naming convention.

Signed-off-by: Leo Kim <leo.kim@atmel.com>
Signed-off-by: Glen Lee <glen.lee@atmel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Leo Kim 2015-10-28 15:59:34 +09:00 committed by Greg Kroah-Hartman
parent 70793b2ab4
commit f8b1713246
2 changed files with 84 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
drivers/staging/wilc1000/host_interface.c
View File

@ -1004,31 +1004,31 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
} }
if (pstrHostIFconnectAttr->bssid) { if (pstrHostIFconnectAttr->bssid) {
hif_drv->strWILC_UsrConnReq.pu8bssid = kmalloc(6, GFP_KERNEL); hif_drv->usr_conn_req.pu8bssid = kmalloc(6, GFP_KERNEL);
memcpy(hif_drv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->bssid, 6); 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) { if (pstrHostIFconnectAttr->ssid) {
hif_drv->strWILC_UsrConnReq.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL); hif_drv->usr_conn_req.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
memcpy(hif_drv->strWILC_UsrConnReq.pu8ssid, memcpy(hif_drv->usr_conn_req.pu8ssid,
pstrHostIFconnectAttr->ssid, pstrHostIFconnectAttr->ssid,
pstrHostIFconnectAttr->ssid_len); 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) { if (pstrHostIFconnectAttr->ies) {
hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL); hif_drv->usr_conn_req.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
memcpy(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs, memcpy(hif_drv->usr_conn_req.pu8ConnReqIEs,
pstrHostIFconnectAttr->ies, pstrHostIFconnectAttr->ies,
pstrHostIFconnectAttr->ies_len); pstrHostIFconnectAttr->ies_len);
} }
hif_drv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->security; hif_drv->usr_conn_req.u8security = pstrHostIFconnectAttr->security;
hif_drv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->auth_type; hif_drv->usr_conn_req.tenuAuth_type = pstrHostIFconnectAttr->auth_type;
hif_drv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->result; hif_drv->usr_conn_req.pfUserConnectResult = pstrHostIFconnectAttr->result;
hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->arg; hif_drv->usr_conn_req.u32UserConnectPvoid = pstrHostIFconnectAttr->arg;
strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT; strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].type = WID_INT; strWIDList[u32WidsCount].type = WID_INT;
@ -1051,40 +1051,40 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
{ {
strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE; strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
strWIDList[u32WidsCount].type = WID_BIN_DATA; strWIDList[u32WidsCount].type = WID_BIN_DATA;
strWIDList[u32WidsCount].val = hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs; strWIDList[u32WidsCount].val = hif_drv->usr_conn_req.pu8ConnReqIEs;
strWIDList[u32WidsCount].size = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen; strWIDList[u32WidsCount].size = hif_drv->usr_conn_req.ConnReqIEsLen;
u32WidsCount++; u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) { 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); 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); info_element_size);
} }
} }
strWIDList[u32WidsCount].id = (u16)WID_11I_MODE; strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].type = WID_CHAR; strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(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++; u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
mode_11i = hif_drv->strWILC_UsrConnReq.u8security; mode_11i = hif_drv->usr_conn_req.u8security;
PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->strWILC_UsrConnReq.u8security); PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->usr_conn_req.u8security);
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE; strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR; strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(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++; u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) 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", 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].id = (u16)WID_JOIN_REQ_EXTENDED;
strWIDList[u32WidsCount].type = WID_STR; strWIDList[u32WidsCount].type = WID_STR;
@ -1141,7 +1141,7 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
*(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap; *(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap;
*(pu8CurrByte++) = ptstrJoinBssParam->ht_capable; *(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; *(pu8CurrByte++) = ptstrJoinBssParam->rsn_found;
PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1)); PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1));
@ -1331,25 +1331,25 @@ static s32 Handle_ConnectTimeout(struct host_if_drv *hif_drv)
memset(&strConnectInfo, 0, sizeof(tstrConnectInfo)); memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) { if (hif_drv->usr_conn_req.pfUserConnectResult) {
if (hif_drv->strWILC_UsrConnReq.pu8bssid) { if (hif_drv->usr_conn_req.pu8bssid) {
memcpy(strConnectInfo.au8bssid, memcpy(strConnectInfo.au8bssid,
hif_drv->strWILC_UsrConnReq.pu8bssid, 6); hif_drv->usr_conn_req.pu8bssid, 6);
} }
if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) { if (hif_drv->usr_conn_req.pu8ConnReqIEs) {
strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen; strConnectInfo.ReqIEsLen = hif_drv->usr_conn_req.ConnReqIEsLen;
strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL); strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->usr_conn_req.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs, memcpy(strConnectInfo.pu8ReqIEs,
hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs, hif_drv->usr_conn_req.pu8ConnReqIEs,
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen); hif_drv->usr_conn_req.ConnReqIEsLen);
} }
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP, hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
&strConnectInfo, &strConnectInfo,
MAC_DISCONNECTED, MAC_DISCONNECTED,
NULL, NULL,
hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid); hif_drv->usr_conn_req.u32UserConnectPvoid);
kfree(strConnectInfo.pu8ReqIEs); kfree(strConnectInfo.pu8ReqIEs);
strConnectInfo.pu8ReqIEs = NULL; strConnectInfo.pu8ReqIEs = NULL;
@ -1369,11 +1369,11 @@ static s32 Handle_ConnectTimeout(struct host_if_drv *hif_drv)
if (result) if (result)
PRINT_ER("Failed to send dissconect config packet\n"); PRINT_ER("Failed to send dissconect config packet\n");
hif_drv->strWILC_UsrConnReq.ssidLen = 0; hif_drv->usr_conn_req.ssidLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ssid); kfree(hif_drv->usr_conn_req.pu8ssid);
kfree(hif_drv->strWILC_UsrConnReq.pu8bssid); kfree(hif_drv->usr_conn_req.pu8bssid);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0; hif_drv->usr_conn_req.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs); kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
eth_zero_addr(u8ConnectedSSID); eth_zero_addr(u8ConnectedSSID);
@ -1498,7 +1498,7 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
(hif_drv->enuHostIFstate == HOST_IF_CONNECTED) || (hif_drv->enuHostIFstate == HOST_IF_CONNECTED) ||
hif_drv->usr_scan_req.pfUserScanResult) { hif_drv->usr_scan_req.pfUserScanResult) {
if (!pstrRcvdGnrlAsyncInfo->buffer || if (!pstrRcvdGnrlAsyncInfo->buffer ||
!hif_drv->strWILC_UsrConnReq.pfUserConnectResult) { !hif_drv->usr_conn_req.pfUserConnectResult) {
PRINT_ER("driver is null\n"); PRINT_ER("driver is null\n");
return -EINVAL; return -EINVAL;
} }
@ -1573,31 +1573,31 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
eth_zero_addr(u8ConnectedSSID); 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"); 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) && if ((u8MacStatus == MAC_CONNECTED) &&
(strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) { (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
memcpy(hif_drv->au8AssociatedBSSID, 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) { if (hif_drv->usr_conn_req.pu8ConnReqIEs) {
strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen; strConnectInfo.ReqIEsLen = hif_drv->usr_conn_req.ConnReqIEsLen;
strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL); strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->usr_conn_req.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs, memcpy(strConnectInfo.pu8ReqIEs,
hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs, hif_drv->usr_conn_req.pu8ConnReqIEs,
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen); hif_drv->usr_conn_req.ConnReqIEsLen);
} }
del_timer(&hif_drv->hConnectTimer); del_timer(&hif_drv->hConnectTimer);
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP, hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
&strConnectInfo, &strConnectInfo,
u8MacStatus, u8MacStatus,
NULL, NULL,
hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid); hif_drv->usr_conn_req.u32UserConnectPvoid);
if ((u8MacStatus == MAC_CONNECTED) && if ((u8MacStatus == MAC_CONNECTED) &&
(strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) { (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) {
@ -1621,11 +1621,11 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
kfree(strConnectInfo.pu8ReqIEs); kfree(strConnectInfo.pu8ReqIEs);
strConnectInfo.pu8ReqIEs = NULL; strConnectInfo.pu8ReqIEs = NULL;
hif_drv->strWILC_UsrConnReq.ssidLen = 0; hif_drv->usr_conn_req.ssidLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ssid); kfree(hif_drv->usr_conn_req.pu8ssid);
kfree(hif_drv->strWILC_UsrConnReq.pu8bssid); kfree(hif_drv->usr_conn_req.pu8bssid);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0; hif_drv->usr_conn_req.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs); kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
} else if ((u8MacStatus == MAC_DISCONNECTED) && } else if ((u8MacStatus == MAC_DISCONNECTED) &&
(hif_drv->enuHostIFstate == HOST_IF_CONNECTED)) { (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)) {
PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n"); PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n");
@ -1642,27 +1642,26 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
strDisconnectNotifInfo.ie = NULL; strDisconnectNotifInfo.ie = NULL;
strDisconnectNotifInfo.ie_len = 0; strDisconnectNotifInfo.ie_len = 0;
if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) { if (hif_drv->usr_conn_req.pfUserConnectResult) {
g_obtainingIP = false; g_obtainingIP = false;
host_int_set_power_mgmt(hif_drv, 0, 0); host_int_set_power_mgmt(hif_drv, 0, 0);
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF,
NULL, NULL,
0, 0,
&strDisconnectNotifInfo, &strDisconnectNotifInfo,
hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid); hif_drv->usr_conn_req.u32UserConnectPvoid);
} else { } else {
PRINT_ER("Connect result callback function is NULL\n"); PRINT_ER("Connect result callback function is NULL\n");
} }
eth_zero_addr(hif_drv->au8AssociatedBSSID); eth_zero_addr(hif_drv->au8AssociatedBSSID);
hif_drv->strWILC_UsrConnReq.ssidLen = 0; hif_drv->usr_conn_req.ssidLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ssid); kfree(hif_drv->usr_conn_req.pu8ssid);
kfree(hif_drv->strWILC_UsrConnReq.pu8bssid); kfree(hif_drv->usr_conn_req.pu8bssid);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0; hif_drv->usr_conn_req.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs); kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
if (join_req && join_req_drv == hif_drv) { if (join_req && join_req_drv == hif_drv) {
kfree(join_req); kfree(join_req);
@ -2005,16 +2004,16 @@ static void Handle_Disconnect(struct host_if_drv *hif_drv)
hif_drv->usr_scan_req.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) { if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n"); PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
del_timer(&hif_drv->hConnectTimer); del_timer(&hif_drv->hConnectTimer);
} }
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL, hif_drv->usr_conn_req.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
0, &strDisconnectNotifInfo, hif_drv->strWILC_UsrConnReq.u32UserConnectPvoid); 0, &strDisconnectNotifInfo, hif_drv->usr_conn_req.u32UserConnectPvoid);
} else { } else {
PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n"); PRINT_ER("usr_conn_req.pfUserConnectResult = NULL\n");
} }
scan_while_connected = false; scan_while_connected = false;
@ -2023,11 +2022,11 @@ static void Handle_Disconnect(struct host_if_drv *hif_drv)
eth_zero_addr(hif_drv->au8AssociatedBSSID); eth_zero_addr(hif_drv->au8AssociatedBSSID);
hif_drv->strWILC_UsrConnReq.ssidLen = 0; hif_drv->usr_conn_req.ssidLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ssid); kfree(hif_drv->usr_conn_req.pu8ssid);
kfree(hif_drv->strWILC_UsrConnReq.pu8bssid); kfree(hif_drv->usr_conn_req.pu8bssid);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0; hif_drv->usr_conn_req.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs); kfree(hif_drv->usr_conn_req.pu8ConnReqIEs);
if (join_req && join_req_drv == hif_drv) { if (join_req && join_req_drv == hif_drv) {
kfree(join_req); kfree(join_req);
@ -4292,7 +4291,7 @@ void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length)
return; 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"); PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
up(&hif_sema_deinit); up(&hif_sema_deinit);
return; return;

2
drivers/staging/wilc1000/host_interface.h
View File

@ -293,7 +293,7 @@ enum p2p_listen_state {
struct host_if_drv { struct host_if_drv {
struct user_scan_req usr_scan_req; struct user_scan_req usr_scan_req;
struct user_conn_req strWILC_UsrConnReq; struct user_conn_req usr_conn_req;
/*Remain on channel struvture*/ /*Remain on channel struvture*/
struct remain_ch strHostIfRemainOnChan; struct remain_ch strHostIfRemainOnChan;