#include "wilc_wfi_cfgoperations.h"

  #include "host_interface.h"

  #include <linux/errno.h>

  #define NO_ENCRYPT		0
  #define ENCRYPT_ENABLED		BIT(0)
  #define WEP			BIT(1)
  #define WEP_EXTENDED		BIT(2)
  #define WPA			BIT(3)
  #define WPA2			BIT(4)
  #define AES			BIT(5)
  #define TKIP			BIT(6)

  #define FRAME_TYPE_ID			0
  #define ACTION_CAT_ID			24
  #define ACTION_SUBTYPE_ID		25
  #define P2P_PUB_ACTION_SUBTYPE		30

  #define ACTION_FRAME			0xd0
  #define GO_INTENT_ATTR_ID		0x04
  #define CHANLIST_ATTR_ID		0x0b
  #define OPERCHAN_ATTR_ID		0x11
  #define PUB_ACTION_ATTR_ID		0x04
  #define P2PELEM_ATTR_ID			0xdd

  #define GO_NEG_REQ			0x00
  #define GO_NEG_RSP			0x01
  #define GO_NEG_CONF			0x02
  #define P2P_INV_REQ			0x03
  #define P2P_INV_RSP			0x04
  #define PUBLIC_ACT_VENDORSPEC		0x09
  #define GAS_INTIAL_REQ			0x0a
  #define GAS_INTIAL_RSP			0x0b
  
  #define INVALID_CHANNEL			0
  
  #define nl80211_SCAN_RESULT_EXPIRE	(3 * HZ)
  #define SCAN_RESULT_EXPIRE		(40 * HZ)
  
  static const u32 cipher_suites[] = {
  	WLAN_CIPHER_SUITE_WEP40,
  	WLAN_CIPHER_SUITE_WEP104,
  	WLAN_CIPHER_SUITE_TKIP,
  	WLAN_CIPHER_SUITE_CCMP,
  	WLAN_CIPHER_SUITE_AES_CMAC,
  };
  
  static const struct ieee80211_txrx_stypes
  	wilc_wfi_cfg80211_mgmt_types[NUM_NL80211_IFTYPES] = {
  	[NL80211_IFTYPE_STATION] = {
  		.tx = 0xffff,
  		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  			BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
  	},
  	[NL80211_IFTYPE_AP] = {
  		.tx = 0xffff,
  		.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  			BIT(IEEE80211_STYPE_AUTH >> 4) |
  			BIT(IEEE80211_STYPE_DEAUTH >> 4) |
  			BIT(IEEE80211_STYPE_ACTION >> 4)
  	},
  	[NL80211_IFTYPE_P2P_CLIENT] = {
  		.tx = 0xffff,
  		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
  			BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
  			BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
  			BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
  			BIT(IEEE80211_STYPE_DISASSOC >> 4) |
  			BIT(IEEE80211_STYPE_AUTH >> 4) |
  			BIT(IEEE80211_STYPE_DEAUTH >> 4)
  	}
  };

  static const struct wiphy_wowlan_support wowlan_support = {
  	.flags = WIPHY_WOWLAN_ANY
  };

  #define WILC_WFI_DWELL_PASSIVE 100
  #define WILC_WFI_DWELL_ACTIVE  40
  
  #define TCP_ACK_FILTER_LINK_SPEED_THRESH	54
  #define DEFAULT_LINK_SPEED			72

  #define IS_MANAGMEMENT				0x100
  #define IS_MANAGMEMENT_CALLBACK			0x080
  #define IS_MGMT_STATUS_SUCCES			0x040
  #define GET_PKT_OFFSET(a) (((a) >> 22) & 0x1ff)

  extern int wilc_mac_open(struct net_device *ndev);
  extern int wilc_mac_close(struct net_device *ndev);

  static struct network_info last_scanned_shadow[MAX_NUM_SCANNED_NETWORKS_SHADOW];

  static u32 last_scanned_cnt;

  struct timer_list wilc_during_ip_timer;

  static struct timer_list hAgingTimer;

  static u8 op_ifcs;

  u8 wilc_initialized = 1;

  
  #define CHAN2G(_channel, _freq, _flags) {	 \

  		.band             = NL80211_BAND_2GHZ, \

  		.center_freq      = (_freq),		 \
  		.hw_value         = (_channel),		 \
  		.flags            = (_flags),		 \
  		.max_antenna_gain = 0,			 \
  		.max_power        = 30,			 \
  }

  static struct ieee80211_channel ieee80211_2ghz_channels[] = {

  	CHAN2G(1,  2412, 0),
  	CHAN2G(2,  2417, 0),
  	CHAN2G(3,  2422, 0),
  	CHAN2G(4,  2427, 0),
  	CHAN2G(5,  2432, 0),
  	CHAN2G(6,  2437, 0),
  	CHAN2G(7,  2442, 0),
  	CHAN2G(8,  2447, 0),
  	CHAN2G(9,  2452, 0),
  	CHAN2G(10, 2457, 0),
  	CHAN2G(11, 2462, 0),
  	CHAN2G(12, 2467, 0),
  	CHAN2G(13, 2472, 0),
  	CHAN2G(14, 2484, 0),
  };
  
  #define RATETAB_ENT(_rate, _hw_value, _flags) {	\
  		.bitrate  = (_rate),			\
  		.hw_value = (_hw_value),		\
  		.flags    = (_flags),			\
  }

  static struct ieee80211_rate ieee80211_bitrates[] = {

  	RATETAB_ENT(10,  0,  0),
  	RATETAB_ENT(20,  1,  0),
  	RATETAB_ENT(55,  2,  0),
  	RATETAB_ENT(110, 3,  0),
  	RATETAB_ENT(60,  9,  0),
  	RATETAB_ENT(90,  6,  0),
  	RATETAB_ENT(120, 7,  0),
  	RATETAB_ENT(180, 8,  0),
  	RATETAB_ENT(240, 9,  0),
  	RATETAB_ENT(360, 10, 0),
  	RATETAB_ENT(480, 11, 0),
  	RATETAB_ENT(540, 12, 0),
  };

  struct p2p_mgmt_data {
  	int size;
  	u8 *buff;
  };

  static u8 wlan_channel = INVALID_CHANNEL;

  static u8 curr_channel;

  static u8 p2p_oui[] = {0x50, 0x6f, 0x9A, 0x09};

  static u8 p2p_local_random = 0x01;

  static u8 p2p_recv_random;

  static u8 p2p_vendor_spec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};

  static bool wilc_ie;

  
  static struct ieee80211_supported_band WILC_WFI_band_2ghz = {

  	.channels = ieee80211_2ghz_channels,
  	.n_channels = ARRAY_SIZE(ieee80211_2ghz_channels),

  	.bitrates = ieee80211_bitrates,
  	.n_bitrates = ARRAY_SIZE(ieee80211_bitrates),

  };

  struct add_key_params {
  	u8 key_idx;

  	bool pairwise;

  	u8 *mac_addr;
  };

  static struct add_key_params g_add_gtk_key_params;
  static struct wilc_wfi_key g_key_gtk_params;
  static struct add_key_params g_add_ptk_key_params;
  static struct wilc_wfi_key g_key_ptk_params;
  static struct wilc_wfi_wep_key g_key_wep_params;
  static bool g_ptk_keys_saved;
  static bool g_gtk_keys_saved;
  static bool g_wep_keys_saved;

  
  #define AGING_TIME	(9 * 1000)

  #define during_ip_time	15000

  static void clear_shadow_scan(void)

  {

  	int i;

  	if (op_ifcs == 0) {

  		del_timer_sync(&hAgingTimer);

  		for (i = 0; i < last_scanned_cnt; i++) {

  			if (last_scanned_shadow[last_scanned_cnt].ies) {
  				kfree(last_scanned_shadow[i].ies);
  				last_scanned_shadow[last_scanned_cnt].ies = NULL;

  			}

  			kfree(last_scanned_shadow[i].join_params);
  			last_scanned_shadow[i].join_params = NULL;

  		}

  		last_scanned_cnt = 0;

  	}

  }

  static u32 get_rssi_avg(struct network_info *network_info)

  {

  	u8 i;

  	int rssi_v = 0;

  	u8 num_rssi = (network_info->str_rssi.u8Full) ?
  		       NUM_RSSI : (network_info->str_rssi.u8Index);

  
  	for (i = 0; i < num_rssi; i++)

  		rssi_v += network_info->str_rssi.as8RSSI[i];

  
  	rssi_v /= num_rssi;
  	return rssi_v;
  }

  static void refresh_scan(void *user_void, u8 all, bool direct_scan)

  {

  	struct wilc_priv *priv;

  	struct wiphy *wiphy;
  	struct cfg80211_bss *bss = NULL;
  	int i;
  	int rssi = 0;

  	priv = user_void;

  	wiphy = priv->dev->ieee80211_ptr->wiphy;

  	for (i = 0; i < last_scanned_cnt; i++) {

  		struct network_info *network_info;

  		network_info = &last_scanned_shadow[i];

  		if (!network_info->found || all) {

  			s32 freq;

  			struct ieee80211_channel *channel;

  			if (network_info) {

  				freq = ieee80211_channel_to_frequency((s32)network_info->ch, NL80211_BAND_2GHZ);

  				channel = ieee80211_get_channel(wiphy, freq);

  				rssi = get_rssi_avg(network_info);

  				if (memcmp("DIRECT-", network_info->ssid, 7) ||

  				    direct_scan) {

  					bss = cfg80211_inform_bss(wiphy,
  								  channel,
  								  CFG80211_BSS_FTYPE_UNKNOWN,

  								  network_info->bssid,

  								  network_info->tsf_hi,

  								  network_info->cap_info,

  								  network_info->beacon_period,

  								  (const u8 *)network_info->ies,
  								  (size_t)network_info->ies_len,

  								  (s32)rssi * 100,
  								  GFP_KERNEL);

  					cfg80211_put_bss(wiphy, bss);

  				}
  			}

  		}
  	}

  }

  static void reset_shadow_found(void)

  {

  	int i;

  	for (i = 0; i < last_scanned_cnt; i++)

  		last_scanned_shadow[i].found = 0;

  }

  static void update_scan_time(void)

  {

  	int i;

  	for (i = 0; i < last_scanned_cnt; i++)

  		last_scanned_shadow[i].time_scan = jiffies;

  }

  static void remove_network_from_shadow(unsigned long arg)

  {

  	unsigned long now = jiffies;
  	int i, j;

  	for (i = 0; i < last_scanned_cnt; i++) {

  		if (time_after(now, last_scanned_shadow[i].time_scan +
  			       (unsigned long)(SCAN_RESULT_EXPIRE))) {

  			kfree(last_scanned_shadow[i].ies);
  			last_scanned_shadow[i].ies = NULL;

  			kfree(last_scanned_shadow[i].join_params);

  			for (j = i; (j < last_scanned_cnt - 1); j++)

  				last_scanned_shadow[j] = last_scanned_shadow[j + 1];

  
  			last_scanned_cnt--;

  		}
  	}

  	if (last_scanned_cnt != 0) {

  		hAgingTimer.data = arg;
  		mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));

  	}

  }

  static void clear_duringIP(unsigned long arg)

  {

  	wilc_optaining_ip = false;

  }

  static int is_network_in_shadow(struct network_info *pstrNetworkInfo,

  				void *user_void)

  {

  	int state = -1;

  	int i;

  	if (last_scanned_cnt == 0) {

  		hAgingTimer.data = (unsigned long)user_void;

  		mod_timer(&hAgingTimer, jiffies + msecs_to_jiffies(AGING_TIME));

  		state = -1;
  	} else {

  		for (i = 0; i < last_scanned_cnt; i++) {

  			if (memcmp(last_scanned_shadow[i].bssid,
  				   pstrNetworkInfo->bssid, 6) == 0) {

  				state = i;
  				break;
  			}
  		}
  	}
  	return state;
  }

  static void add_network_to_shadow(struct network_info *pstrNetworkInfo,

  				  void *user_void, void *pJoinParams)

  {

  	int ap_found = is_network_in_shadow(pstrNetworkInfo, user_void);

  	u32 ap_index = 0;

  	u8 rssi_index = 0;

  	if (last_scanned_cnt >= MAX_NUM_SCANNED_NETWORKS_SHADOW)

  		return;

  	if (ap_found == -1) {

  		ap_index = last_scanned_cnt;
  		last_scanned_cnt++;

  	} else {
  		ap_index = ap_found;
  	}

  	rssi_index = last_scanned_shadow[ap_index].str_rssi.u8Index;
  	last_scanned_shadow[ap_index].str_rssi.as8RSSI[rssi_index++] = pstrNetworkInfo->rssi;

  	if (rssi_index == NUM_RSSI) {
  		rssi_index = 0;

  		last_scanned_shadow[ap_index].str_rssi.u8Full = 1;

  	}

  	last_scanned_shadow[ap_index].str_rssi.u8Index = rssi_index;

  	last_scanned_shadow[ap_index].rssi = pstrNetworkInfo->rssi;

  	last_scanned_shadow[ap_index].cap_info = pstrNetworkInfo->cap_info;

  	last_scanned_shadow[ap_index].ssid_len = pstrNetworkInfo->ssid_len;

  	memcpy(last_scanned_shadow[ap_index].ssid,

  	       pstrNetworkInfo->ssid, pstrNetworkInfo->ssid_len);

  	memcpy(last_scanned_shadow[ap_index].bssid,
  	       pstrNetworkInfo->bssid, ETH_ALEN);

  	last_scanned_shadow[ap_index].beacon_period = pstrNetworkInfo->beacon_period;

  	last_scanned_shadow[ap_index].dtim_period = pstrNetworkInfo->dtim_period;

  	last_scanned_shadow[ap_index].ch = pstrNetworkInfo->ch;

  	last_scanned_shadow[ap_index].ies_len = pstrNetworkInfo->ies_len;

  	last_scanned_shadow[ap_index].tsf_hi = pstrNetworkInfo->tsf_hi;

  	if (ap_found != -1)

  		kfree(last_scanned_shadow[ap_index].ies);
  	last_scanned_shadow[ap_index].ies = kmalloc(pstrNetworkInfo->ies_len,
  						    GFP_KERNEL);
  	memcpy(last_scanned_shadow[ap_index].ies,
  	       pstrNetworkInfo->ies, pstrNetworkInfo->ies_len);

  	last_scanned_shadow[ap_index].time_scan = jiffies;
  	last_scanned_shadow[ap_index].time_scan_cached = jiffies;

  	last_scanned_shadow[ap_index].found = 1;

  	if (ap_found != -1)

  		kfree(last_scanned_shadow[ap_index].join_params);
  	last_scanned_shadow[ap_index].join_params = pJoinParams;

  }

  static void CfgScanResult(enum scan_event scan_event,

  			  struct network_info *network_info,

  			  void *user_void,

  			  void *join_params)

  {

  	struct wilc_priv *priv;

  	struct wiphy *wiphy;

  	s32 s32Freq;

  	struct ieee80211_channel *channel;

  	struct cfg80211_bss *bss = NULL;

  	priv = user_void;

  	if (priv->bCfgScanning) {

  		if (scan_event == SCAN_EVENT_NETWORK_FOUND) {

  			wiphy = priv->dev->ieee80211_ptr->wiphy;

  
  			if (!wiphy)
  				return;

  			if (wiphy->signal_type == CFG80211_SIGNAL_TYPE_UNSPEC &&

  			    (((s32)network_info->rssi * 100) < 0 ||
  			    ((s32)network_info->rssi * 100) > 100))

  				return;

  			if (network_info) {

  				s32Freq = ieee80211_channel_to_frequency((s32)network_info->ch, NL80211_BAND_2GHZ);

  				channel = ieee80211_get_channel(wiphy, s32Freq);

  				if (!channel)
  					return;

  				if (network_info->new_network) {

  					if (priv->u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {

  						priv->u32RcvdChCount++;

  						add_network_to_shadow(network_info, priv, join_params);

  						if (!(memcmp("DIRECT-", network_info->ssid, 7))) {

  							bss = cfg80211_inform_bss(wiphy,
  										  channel,
  										  CFG80211_BSS_FTYPE_UNKNOWN,

  										  network_info->bssid,

  										  network_info->tsf_hi,

  										  network_info->cap_info,

  										  network_info->beacon_period,

  										  (const u8 *)network_info->ies,
  										  (size_t)network_info->ies_len,

  										  (s32)network_info->rssi * 100,
  										  GFP_KERNEL);

  							cfg80211_put_bss(wiphy, bss);

  						}

  					}
  				} else {

  					u32 i;

  					for (i = 0; i < priv->u32RcvdChCount; i++) {

  						if (memcmp(last_scanned_shadow[i].bssid, network_info->bssid, 6) == 0) {

  							last_scanned_shadow[i].rssi = network_info->rssi;

  							last_scanned_shadow[i].time_scan = jiffies;

  							break;
  						}
  					}
  				}
  			}

  		} else if (scan_event == SCAN_EVENT_DONE) {

  			refresh_scan(priv, 1, false);

  			mutex_lock(&priv->scan_req_lock);

  			if (priv->pstrScanReq) {

  				struct cfg80211_scan_info info = {
  					.aborted = false,
  				};
  
  				cfg80211_scan_done(priv->pstrScanReq, &info);

  				priv->u32RcvdChCount = 0;

  				priv->bCfgScanning = false;

  				priv->pstrScanReq = NULL;

  			}

  			mutex_unlock(&priv->scan_req_lock);

  		} else if (scan_event == SCAN_EVENT_ABORTED) {

  			mutex_lock(&priv->scan_req_lock);

  			if (priv->pstrScanReq) {

  				struct cfg80211_scan_info info = {
  					.aborted = false,
  				};

  				update_scan_time();

  				refresh_scan(priv, 1, false);

  				cfg80211_scan_done(priv->pstrScanReq, &info);

  				priv->bCfgScanning = false;

  				priv->pstrScanReq = NULL;

  			}

  			mutex_unlock(&priv->scan_req_lock);

  		}
  	}

  }

  int wilc_connecting;

  static void CfgConnectResult(enum conn_event enuConnDisconnEvent,

  			     struct connect_info *pstrConnectInfo,

  			     u8 u8MacStatus,

  			     struct disconnect_info *pstrDisconnectNotifInfo,

  			     void *pUserVoid)
  {

  	struct wilc_priv *priv;

  	struct net_device *dev;

  	struct host_if_drv *pstrWFIDrv;

  	u8 NullBssid[ETH_ALEN] = {0};

  	struct wilc *wl;

  	struct wilc_vif *vif;

  	wilc_connecting = 0;

  	priv = pUserVoid;

  	dev = priv->dev;

  	vif = netdev_priv(dev);
  	wl = vif->wilc;

  	pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;

  
  	if (enuConnDisconnEvent == CONN_DISCONN_EVENT_CONN_RESP) {

  		u16 u16ConnectStatus;

  		u16ConnectStatus = pstrConnectInfo->status;

  		if ((u8MacStatus == MAC_DISCONNECTED) &&

  		    (pstrConnectInfo->status == SUCCESSFUL_STATUSCODE)) {

  			u16ConnectStatus = WLAN_STATUS_UNSPECIFIED_FAILURE;

  			wilc_wlan_set_bssid(priv->dev, NullBssid,
  					    STATION_MODE);

  			eth_zero_addr(wilc_connected_ssid);

  			if (!pstrWFIDrv->p2p_connect)

  				wlan_channel = INVALID_CHANNEL;

  			netdev_err(dev, "Unspecified failure
  ");

  		}
  
  		if (u16ConnectStatus == WLAN_STATUS_SUCCESS) {

  			bool bNeedScanRefresh = false;

  			u32 i;

  			memcpy(priv->au8AssociatedBss, pstrConnectInfo->bssid, ETH_ALEN);

  			for (i = 0; i < last_scanned_cnt; i++) {

  				if (memcmp(last_scanned_shadow[i].bssid,

  					   pstrConnectInfo->bssid,

  					   ETH_ALEN) == 0) {

  					unsigned long now = jiffies;
  
  					if (time_after(now,

  						       last_scanned_shadow[i].time_scan_cached +
  						       (unsigned long)(nl80211_SCAN_RESULT_EXPIRE - (1 * HZ))))

  						bNeedScanRefresh = true;

  
  					break;
  				}
  			}

  			if (bNeedScanRefresh)

  				refresh_scan(priv, 1, true);

  		}

  		cfg80211_connect_result(dev, pstrConnectInfo->bssid,

  					pstrConnectInfo->req_ies, pstrConnectInfo->req_ies_len,

  					pstrConnectInfo->resp_ies, pstrConnectInfo->resp_ies_len,

  					u16ConnectStatus, GFP_KERNEL);

  	} else if (enuConnDisconnEvent == CONN_DISCONN_EVENT_DISCONN_NOTIF)    {

  		wilc_optaining_ip = false;

  		p2p_local_random = 0x01;

  		p2p_recv_random = 0x00;

  		wilc_ie = false;

  		eth_zero_addr(priv->au8AssociatedBss);

  		wilc_wlan_set_bssid(priv->dev, NullBssid, STATION_MODE);

  		eth_zero_addr(wilc_connected_ssid);

  		if (!pstrWFIDrv->p2p_connect)

  			wlan_channel = INVALID_CHANNEL;

  		if ((pstrWFIDrv->IFC_UP) && (dev == wl->vif[1]->ndev))

  			pstrDisconnectNotifInfo->reason = 3;

  		else if ((!pstrWFIDrv->IFC_UP) && (dev == wl->vif[1]->ndev))

  			pstrDisconnectNotifInfo->reason = 1;

  		cfg80211_disconnected(dev, pstrDisconnectNotifInfo->reason, pstrDisconnectNotifInfo->ie,

  				      pstrDisconnectNotifInfo->ie_len, false,
  				      GFP_KERNEL);

  	}

  }

  static int set_channel(struct wiphy *wiphy,
  		       struct cfg80211_chan_def *chandef)

  {

  	u32 channelnum = 0;

  	struct wilc_priv *priv;

  	int result = 0;

  	struct wilc_vif *vif;

  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(priv->dev);

  	channelnum = ieee80211_frequency_to_channel(chandef->chan->center_freq);

  	curr_channel = channelnum;

  	result = wilc_set_mac_chnl_num(vif, channelnum);

  	if (result != 0)

  		netdev_err(priv->dev, "Error in setting channel
  ");

  	return result;

  }

  static int scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)

  {

  	struct wilc_priv *priv;

  	u32 i;

  	s32 s32Error = 0;

  	u8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];

  	struct hidden_network strHiddenNetwork;

  	struct wilc_vif *vif;

  
  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(priv->dev);

  	priv->pstrScanReq = request;
  
  	priv->u32RcvdChCount = 0;

  	reset_shadow_found();

  	priv->bCfgScanning = true;

  	if (request->n_channels <= MAX_NUM_SCANNED_NETWORKS) {

  		for (i = 0; i < request->n_channels; i++)

  			au8ScanChanList[i] = (u8)ieee80211_frequency_to_channel(request->channels[i]->center_freq);

  
  		if (request->n_ssids >= 1) {

  			strHiddenNetwork.net_info =
  				kmalloc_array(request->n_ssids,
  					      sizeof(struct hidden_network),
  					      GFP_KERNEL);

  			if (!strHiddenNetwork.net_info)
  				return -ENOMEM;

  			strHiddenNetwork.n_ssids = request->n_ssids;

  			for (i = 0; i < request->n_ssids; i++) {

  				if (request->ssids[i].ssid_len != 0) {

  					strHiddenNetwork.net_info[i].ssid = kmalloc(request->ssids[i].ssid_len, GFP_KERNEL);
  					memcpy(strHiddenNetwork.net_info[i].ssid, request->ssids[i].ssid, request->ssids[i].ssid_len);
  					strHiddenNetwork.net_info[i].ssid_len = request->ssids[i].ssid_len;

  				} else {

  					strHiddenNetwork.n_ssids -= 1;

  				}
  			}

  			s32Error = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
  					     au8ScanChanList,
  					     request->n_channels,
  					     (const u8 *)request->ie,
  					     request->ie_len, CfgScanResult,
  					     (void *)priv, &strHiddenNetwork);

  		} else {

  			s32Error = wilc_scan(vif, USER_SCAN, ACTIVE_SCAN,
  					     au8ScanChanList,
  					     request->n_channels,
  					     (const u8 *)request->ie,
  					     request->ie_len, CfgScanResult,
  					     (void *)priv, NULL);

  		}

  	} else {

  		netdev_err(priv->dev, "Requested scanned channels over
  ");

  	}

  	if (s32Error != 0)

  		s32Error = -EBUSY;

  
  	return s32Error;
  }

  static int connect(struct wiphy *wiphy, struct net_device *dev,
  		   struct cfg80211_connect_params *sme)

  {

  	s32 s32Error = 0;

  	u32 i;

  	u8 u8security = NO_ENCRYPT;

  	enum AUTHTYPE tenuAuth_type = ANY;

  	struct wilc_priv *priv;

  	struct host_if_drv *pstrWFIDrv;

  	struct network_info *pstrNetworkInfo = NULL;

  	struct wilc_vif *vif;

  	wilc_connecting = 1;

  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(priv->dev);

  	pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;

  	if (!(strncmp(sme->ssid, "DIRECT-", 7)))

  		pstrWFIDrv->p2p_connect = 1;

  	else

  		pstrWFIDrv->p2p_connect = 0;

  	for (i = 0; i < last_scanned_cnt; i++) {

  		if ((sme->ssid_len == last_scanned_shadow[i].ssid_len) &&

  		    memcmp(last_scanned_shadow[i].ssid,

  			   sme->ssid,
  			   sme->ssid_len) == 0) {

  			if (!sme->bssid)

  				break;

  			else

  				if (memcmp(last_scanned_shadow[i].bssid,

  					   sme->bssid,

  					   ETH_ALEN) == 0)

  					break;

  		}
  	}

  	if (i < last_scanned_cnt) {

  		pstrNetworkInfo = &last_scanned_shadow[i];

  	} else {
  		s32Error = -ENOENT;

  		wilc_connecting = 0;
  		return s32Error;

  	}

  	memset(priv->WILC_WFI_wep_key, 0, sizeof(priv->WILC_WFI_wep_key));
  	memset(priv->WILC_WFI_wep_key_len, 0, sizeof(priv->WILC_WFI_wep_key_len));

  	if (sme->crypto.cipher_group != NO_ENCRYPT) {

  		if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP40) {

  			u8security = ENCRYPT_ENABLED | WEP;

  			priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;

  			memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);

  			g_key_wep_params.key_len = sme->key_len;

  			g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);

  			memcpy(g_key_wep_params.key, sme->key, sme->key_len);
  			g_key_wep_params.key_idx = sme->key_idx;

  			g_wep_keys_saved = true;

  			wilc_set_wep_default_keyid(vif, sme->key_idx);
  			wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
  						 sme->key_idx);

  		} else if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_WEP104)   {

  			u8security = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;

  			priv->WILC_WFI_wep_key_len[sme->key_idx] = sme->key_len;

  			memcpy(priv->WILC_WFI_wep_key[sme->key_idx], sme->key, sme->key_len);

  			g_key_wep_params.key_len = sme->key_len;

  			g_key_wep_params.key = kmalloc(sme->key_len, GFP_KERNEL);

  			memcpy(g_key_wep_params.key, sme->key, sme->key_len);
  			g_key_wep_params.key_idx = sme->key_idx;

  			g_wep_keys_saved = true;

  			wilc_set_wep_default_keyid(vif, sme->key_idx);
  			wilc_add_wep_key_bss_sta(vif, sme->key, sme->key_len,
  						 sme->key_idx);

  		} else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)   {

  			if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP)

  				u8security = ENCRYPT_ENABLED | WPA2 | TKIP;

  			else

  				u8security = ENCRYPT_ENABLED | WPA2 | AES;

  		} else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)   {

  			if (sme->crypto.cipher_group == WLAN_CIPHER_SUITE_TKIP)

  				u8security = ENCRYPT_ENABLED | WPA | TKIP;

  			else

  				u8security = ENCRYPT_ENABLED | WPA | AES;

  		} else {
  			s32Error = -ENOTSUPP;

  			netdev_err(dev, "Not supported cipher
  ");

  			wilc_connecting = 0;
  			return s32Error;

  		}

  	}

  	if ((sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
  	    || (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)) {
  		for (i = 0; i < sme->crypto.n_ciphers_pairwise; i++) {

  			if (sme->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP)

  				u8security = u8security | TKIP;

  			else

  				u8security = u8security | AES;

  		}
  	}

  	switch (sme->auth_type)	{
  	case NL80211_AUTHTYPE_OPEN_SYSTEM:

  		tenuAuth_type = OPEN_SYSTEM;
  		break;
  
  	case NL80211_AUTHTYPE_SHARED_KEY:
  		tenuAuth_type = SHARED_KEY;

  		break;
  
  	default:

  		break;

  	}

  	if (sme->crypto.n_akm_suites) {
  		switch (sme->crypto.akm_suites[0]) {
  		case WLAN_AKM_SUITE_8021X:
  			tenuAuth_type = IEEE8021;
  			break;
  
  		default:
  			break;
  		}
  	}

  	curr_channel = pstrNetworkInfo->ch;

  	if (!pstrWFIDrv->p2p_connect)

  		wlan_channel = pstrNetworkInfo->ch;

  	wilc_wlan_set_bssid(dev, pstrNetworkInfo->bssid, STATION_MODE);

  	s32Error = wilc_set_join_req(vif, pstrNetworkInfo->bssid, sme->ssid,

  				     sme->ssid_len, sme->ie, sme->ie_len,
  				     CfgConnectResult, (void *)priv,
  				     u8security, tenuAuth_type,

  				     pstrNetworkInfo->ch,

  				     pstrNetworkInfo->join_params);

  	if (s32Error != 0) {

  		netdev_err(dev, "wilc_set_join_req(): Error
  ");

  		s32Error = -ENOENT;

  		wilc_connecting = 0;
  		return s32Error;

  	}

  	return s32Error;
  }

  static int disconnect(struct wiphy *wiphy, struct net_device *dev, u16 reason_code)

  {

  	s32 s32Error = 0;

  	struct wilc_priv *priv;

  	struct host_if_drv *pstrWFIDrv;

  	struct wilc_vif *vif;

  	struct wilc *wilc;

  	u8 NullBssid[ETH_ALEN] = {0};

  	wilc_connecting = 0;

  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(priv->dev);

  	wilc = vif->wilc;
  
  	if (!wilc)
  		return -EIO;
  
  	if (wilc->close) {
  		/* already disconnected done */
  		cfg80211_disconnected(dev, 0, NULL, 0, true, GFP_KERNEL);
  		return 0;
  	}

  	pstrWFIDrv = (struct host_if_drv *)priv->hif_drv;

  	if (!pstrWFIDrv->p2p_connect)

  		wlan_channel = INVALID_CHANNEL;

  	wilc_wlan_set_bssid(priv->dev, NullBssid, STATION_MODE);

  	p2p_local_random = 0x01;

  	p2p_recv_random = 0x00;

  	wilc_ie = false;

  	pstrWFIDrv->p2p_timeout = 0;

  	s32Error = wilc_disconnect(vif, reason_code);

  	if (s32Error != 0) {

  		netdev_err(priv->dev, "Error in disconnecting
  ");

  		s32Error = -EINVAL;
  	}
  
  	return s32Error;
  }

  static int add_key(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
  		   bool pairwise,
  		   const u8 *mac_addr, struct key_params *params)

  
  {

  	s32 s32Error = 0, KeyLen = params->key_len;

  	struct wilc_priv *priv;

  	const u8 *pu8RxMic = NULL;
  	const u8 *pu8TxMic = NULL;

  	u8 u8mode = NO_ENCRYPT;

  	u8 u8gmode = NO_ENCRYPT;
  	u8 u8pmode = NO_ENCRYPT;

  	enum AUTHTYPE tenuAuth_type = ANY;

  	struct wilc *wl;

  	struct wilc_vif *vif;

  
  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(netdev);
  	wl = vif->wilc;

  	switch (params->cipher)	{
  	case WLAN_CIPHER_SUITE_WEP40:
  	case WLAN_CIPHER_SUITE_WEP104:

  		if (priv->wdev->iftype == NL80211_IFTYPE_AP) {

  			priv->WILC_WFI_wep_key_len[key_index] = params->key_len;

  			memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);

  			tenuAuth_type = OPEN_SYSTEM;
  
  			if (params->cipher == WLAN_CIPHER_SUITE_WEP40)
  				u8mode = ENCRYPT_ENABLED | WEP;
  			else
  				u8mode = ENCRYPT_ENABLED | WEP | WEP_EXTENDED;

  			wilc_add_wep_key_bss_ap(vif, params->key,
  						params->key_len, key_index,
  						u8mode, tenuAuth_type);

  			break;
  		}

  		if (memcmp(params->key, priv->WILC_WFI_wep_key[key_index], params->key_len)) {

  			priv->WILC_WFI_wep_key_len[key_index] = params->key_len;

  			memcpy(priv->WILC_WFI_wep_key[key_index], params->key, params->key_len);

  			wilc_add_wep_key_bss_sta(vif, params->key,
  						 params->key_len, key_index);

  		}
  
  		break;
  
  	case WLAN_CIPHER_SUITE_TKIP:
  	case WLAN_CIPHER_SUITE_CCMP:

  		if (priv->wdev->iftype == NL80211_IFTYPE_AP || priv->wdev->iftype == NL80211_IFTYPE_P2P_GO) {

  			if (!priv->wilc_gtk[key_index]) {

  				priv->wilc_gtk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);

  				priv->wilc_gtk[key_index]->key = NULL;
  				priv->wilc_gtk[key_index]->seq = NULL;

  			}

  			if (!priv->wilc_ptk[key_index]) {

  				priv->wilc_ptk[key_index] = kmalloc(sizeof(struct wilc_wfi_key), GFP_KERNEL);

  				priv->wilc_ptk[key_index]->key = NULL;
  				priv->wilc_ptk[key_index]->seq = NULL;

  			}

  			if (!pairwise) {

  				if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
  					u8gmode = ENCRYPT_ENABLED | WPA | TKIP;
  				else
  					u8gmode = ENCRYPT_ENABLED | WPA2 | AES;
  
  				priv->wilc_groupkey = u8gmode;
  
  				if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {

  					pu8TxMic = params->key + 24;
  					pu8RxMic = params->key + 16;
  					KeyLen = params->key_len - 16;
  				}

  				kfree(priv->wilc_gtk[key_index]->key);

  				priv->wilc_gtk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);

  				memcpy(priv->wilc_gtk[key_index]->key, params->key, params->key_len);

  				kfree(priv->wilc_gtk[key_index]->seq);

  
  				if ((params->seq_len) > 0) {

  					priv->wilc_gtk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);

  					memcpy(priv->wilc_gtk[key_index]->seq, params->seq, params->seq_len);

  				}
  
  				priv->wilc_gtk[key_index]->cipher = params->cipher;
  				priv->wilc_gtk[key_index]->key_len = params->key_len;
  				priv->wilc_gtk[key_index]->seq_len = params->seq_len;

  				wilc_add_rx_gtk(vif, params->key, KeyLen,
  						key_index, params->seq_len,
  						params->seq, pu8RxMic,
  						pu8TxMic, AP_MODE, u8gmode);

  
  			} else {

  				if (params->cipher == WLAN_CIPHER_SUITE_TKIP)
  					u8pmode = ENCRYPT_ENABLED | WPA | TKIP;
  				else
  					u8pmode = priv->wilc_groupkey | AES;
  
  
  				if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {

  					pu8TxMic = params->key + 24;
  					pu8RxMic = params->key + 16;
  					KeyLen = params->key_len - 16;
  				}

  				kfree(priv->wilc_ptk[key_index]->key);

  				priv->wilc_ptk[key_index]->key = kmalloc(params->key_len, GFP_KERNEL);

  				kfree(priv->wilc_ptk[key_index]->seq);

  
  				if ((params->seq_len) > 0)

  					priv->wilc_ptk[key_index]->seq = kmalloc(params->seq_len, GFP_KERNEL);

  				memcpy(priv->wilc_ptk[key_index]->key, params->key, params->key_len);

  
  				if ((params->seq_len) > 0)

  					memcpy(priv->wilc_ptk[key_index]->seq, params->seq, params->seq_len);

  
  				priv->wilc_ptk[key_index]->cipher = params->cipher;
  				priv->wilc_ptk[key_index]->key_len = params->key_len;
  				priv->wilc_ptk[key_index]->seq_len = params->seq_len;

  				wilc_add_ptk(vif, params->key, KeyLen,
  					     mac_addr, pu8RxMic, pu8TxMic,
  					     AP_MODE, u8pmode, key_index);

  			}
  			break;
  		}

  
  		{
  			u8mode = 0;

  			if (!pairwise) {

  				if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {

  					pu8RxMic = params->key + 24;
  					pu8TxMic = params->key + 16;
  					KeyLen = params->key_len - 16;
  				}

  				if (!g_gtk_keys_saved && netdev == wl->vif[0]->ndev) {

  					g_add_gtk_key_params.key_idx = key_index;

  					g_add_gtk_key_params.pairwise = pairwise;

  					if (!mac_addr) {
  						g_add_gtk_key_params.mac_addr = NULL;
  					} else {

  						g_add_gtk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);

  						memcpy(g_add_gtk_key_params.mac_addr, mac_addr, ETH_ALEN);
  					}
  					g_key_gtk_params.key_len = params->key_len;
  					g_key_gtk_params.seq_len = params->seq_len;

  					g_key_gtk_params.key =  kmalloc(params->key_len, GFP_KERNEL);

  					memcpy(g_key_gtk_params.key, params->key, params->key_len);
  					if (params->seq_len > 0) {

  						g_key_gtk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);

  						memcpy(g_key_gtk_params.seq, params->seq, params->seq_len);
  					}
  					g_key_gtk_params.cipher = params->cipher;

  					g_gtk_keys_saved = true;

  				}

  				wilc_add_rx_gtk(vif, params->key, KeyLen,
  						key_index, params->seq_len,
  						params->seq, pu8RxMic,
  						pu8TxMic, STATION_MODE,
  						u8mode);

  			} else {
  				if (params->key_len > 16 && params->cipher == WLAN_CIPHER_SUITE_TKIP) {

  					pu8RxMic = params->key + 24;
  					pu8TxMic = params->key + 16;
  					KeyLen = params->key_len - 16;
  				}

  				if (!g_ptk_keys_saved && netdev == wl->vif[0]->ndev) {

  					g_add_ptk_key_params.key_idx = key_index;

  					g_add_ptk_key_params.pairwise = pairwise;

  					if (!mac_addr) {
  						g_add_ptk_key_params.mac_addr = NULL;
  					} else {

  						g_add_ptk_key_params.mac_addr = kmalloc(ETH_ALEN, GFP_KERNEL);

  						memcpy(g_add_ptk_key_params.mac_addr, mac_addr, ETH_ALEN);
  					}
  					g_key_ptk_params.key_len = params->key_len;
  					g_key_ptk_params.seq_len = params->seq_len;

  					g_key_ptk_params.key =  kmalloc(params->key_len, GFP_KERNEL);

  					memcpy(g_key_ptk_params.key, params->key, params->key_len);
  					if (params->seq_len > 0) {

  						g_key_ptk_params.seq =  kmalloc(params->seq_len, GFP_KERNEL);

  						memcpy(g_key_ptk_params.seq, params->seq, params->seq_len);
  					}
  					g_key_ptk_params.cipher = params->cipher;

  					g_ptk_keys_saved = true;

  				}

  				wilc_add_ptk(vif, params->key, KeyLen,
  					     mac_addr, pu8RxMic, pu8TxMic,
  					     STATION_MODE, u8mode, key_index);

  			}
  		}
  		break;
  
  	default:

  		netdev_err(netdev, "Not supported cipher
  ");

  		s32Error = -ENOTSUPP;

  	}
  
  	return s32Error;
  }

  static int del_key(struct wiphy *wiphy, struct net_device *netdev,
  		   u8 key_index,
  		   bool pairwise,
  		   const u8 *mac_addr)

  {

  	struct wilc_priv *priv;

  	struct wilc *wl;

  	struct wilc_vif *vif;

  
  	priv = wiphy_priv(wiphy);

  	vif = netdev_priv(netdev);
  	wl = vif->wilc;

  	if (netdev == wl->vif[0]->ndev) {

  		g_ptk_keys_saved = false;
  		g_gtk_keys_saved = false;
  		g_wep_keys_saved = false;

  		kfree(g_key_wep_params.key);
  		g_key_wep_params.key = NULL;

  		if ((priv->wilc_gtk[key_index]) != NULL) {

  			kfree(priv->wilc_gtk[key_index]->key);
  			priv->wilc_gtk[key_index]->key = NULL;
  			kfree(priv->wilc_gtk[key_index]->seq);
  			priv->wilc_gtk[key_index]->seq = NULL;

  			kfree(priv->wilc_gtk[key_index]);

  			priv->wilc_gtk[key_index] = NULL;

  		}
  
  		if ((priv->wilc_ptk[key_index]) != NULL) {

  			kfree(priv->wilc_ptk[key_index]->key);
  			priv->wilc_ptk[key_index]->key = NULL;
  			kfree(priv->wilc_ptk[key_index]->seq);
  			priv->wilc_ptk[key_index]->seq = NULL;

  			kfree(priv->wilc_ptk[key_index]);

  			priv->wilc_ptk[key_index] = NULL;
  		}

  		kfree(g_key_ptk_params.key);
  		g_key_ptk_params.key = NULL;
  		kfree(g_key_ptk_params.seq);
  		g_key_ptk_params.seq = NULL;
  
  		kfree(g_key_gtk_params.key);
  		g_key_gtk_params.key = NULL;
  		kfree(g_key_gtk_params.seq);
  		g_key_gtk_params.seq = NULL;

  	}
  
  	if (key_index >= 0 && key_index <= 3) {

  		if (priv->WILC_WFI_wep_key_len[key_index]) {
  			memset(priv->WILC_WFI_wep_key[key_index], 0,
  			       priv->WILC_WFI_wep_key_len[key_index]);
  			priv->WILC_WFI_wep_key_len[key_index] = 0;
  			wilc_remove_wep_key(vif, key_index);
  		}