staging: wilc1000: rename strWILC_UsrConnReq of struct host_if_drv (f8b17132) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/staging/wilc1000/host_interface.c

+83 −84

Original line number	Original line	Diff line number	Diff line
	@@ -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;

drivers/staging/wilc1000/host_interface.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -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;