diff --git a/drivers/staging/wilc1000/host_interface.c b/drivers/staging/wilc1000/host_interface.c
index 2df22e2..ce09879 100644
--- a/drivers/staging/wilc1000/host_interface.c
+++ b/drivers/staging/wilc1000/host_interface.c
@@ -1004,31 +1004,31 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
 	}
 
 	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;
@@ -1051,40 +1051,40 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
 	{
 		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;
+		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].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;
@@ -1141,7 +1141,7 @@ static s32 Handle_Connect(struct host_if_drv *hif_drv,
 	*(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));
@@ -1331,25 +1331,25 @@ static s32 Handle_ConnectTimeout(struct host_if_drv *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;
@@ -1369,11 +1369,11 @@ static s32 Handle_ConnectTimeout(struct host_if_drv *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);
 
@@ -1498,7 +1498,7 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
 	    (hif_drv->enuHostIFstate == HOST_IF_CONNECTED) ||
 	    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;
 		}
@@ -1573,31 +1573,31 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
 				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))	{
@@ -1621,11 +1621,11 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
 
 			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");
@@ -1642,27 +1642,26 @@ static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
 			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);
@@ -2005,16 +2004,16 @@ static void Handle_Disconnect(struct host_if_drv *hif_drv)
 			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;
@@ -2023,11 +2022,11 @@ static void Handle_Disconnect(struct host_if_drv *hif_drv)
 
 		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);
@@ -4292,7 +4291,7 @@ void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length)
 		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;
diff --git a/drivers/staging/wilc1000/host_interface.h b/drivers/staging/wilc1000/host_interface.h
index fc9e96c..e9bc83a 100644
--- a/drivers/staging/wilc1000/host_interface.h
+++ b/drivers/staging/wilc1000/host_interface.h
@@ -293,7 +293,7 @@ enum p2p_listen_state {
 
 struct host_if_drv {
 	struct user_scan_req usr_scan_req;
-	struct user_conn_req strWILC_UsrConnReq;
+	struct user_conn_req usr_conn_req;
 
 	/*Remain on channel struvture*/
 	struct remain_ch strHostIfRemainOnChan;
