1 /*
2  * Marvell Wireless LAN device driver: CFG80211
3  *
4  * Copyright (C) 2011-2014, Marvell International Ltd.
5  *
6  * This software file (the "File") is distributed by Marvell International
7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License").  You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
17  * this warranty disclaimer.
18  */
19 
20 #include "cfg80211.h"
21 #include "main.h"
22 #include "11n.h"
23 
24 static char *reg_alpha2;
25 module_param(reg_alpha2, charp, 0);
26 
27 static const struct ieee80211_iface_limit mwifiex_ap_sta_limits[] = {
28 	{
29 		.max = 2, .types = BIT(NL80211_IFTYPE_STATION) |
30 				   BIT(NL80211_IFTYPE_P2P_GO) |
31 				   BIT(NL80211_IFTYPE_P2P_CLIENT),
32 	},
33 	{
34 		.max = 1, .types = BIT(NL80211_IFTYPE_AP),
35 	},
36 };
37 
38 static const struct ieee80211_iface_combination
39 mwifiex_iface_comb_ap_sta = {
40 	.limits = mwifiex_ap_sta_limits,
41 	.num_different_channels = 1,
42 	.n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
43 	.max_interfaces = MWIFIEX_MAX_BSS_NUM,
44 	.beacon_int_infra_match = true,
45 	.radar_detect_widths =	BIT(NL80211_CHAN_WIDTH_20_NOHT) |
46 				BIT(NL80211_CHAN_WIDTH_20) |
47 				BIT(NL80211_CHAN_WIDTH_40),
48 };
49 
50 static const struct ieee80211_iface_combination
51 mwifiex_iface_comb_ap_sta_vht = {
52 	.limits = mwifiex_ap_sta_limits,
53 	.num_different_channels = 1,
54 	.n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
55 	.max_interfaces = MWIFIEX_MAX_BSS_NUM,
56 	.beacon_int_infra_match = true,
57 	.radar_detect_widths =	BIT(NL80211_CHAN_WIDTH_20_NOHT) |
58 				BIT(NL80211_CHAN_WIDTH_20) |
59 				BIT(NL80211_CHAN_WIDTH_40) |
60 				BIT(NL80211_CHAN_WIDTH_80),
61 };
62 
63 static const struct
64 ieee80211_iface_combination mwifiex_iface_comb_ap_sta_drcs = {
65 	.limits = mwifiex_ap_sta_limits,
66 	.num_different_channels = 2,
67 	.n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
68 	.max_interfaces = MWIFIEX_MAX_BSS_NUM,
69 	.beacon_int_infra_match = true,
70 };
71 
72 /*
73  * This function maps the nl802.11 channel type into driver channel type.
74  *
75  * The mapping is as follows -
76  *      NL80211_CHAN_NO_HT     -> IEEE80211_HT_PARAM_CHA_SEC_NONE
77  *      NL80211_CHAN_HT20      -> IEEE80211_HT_PARAM_CHA_SEC_NONE
78  *      NL80211_CHAN_HT40PLUS  -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE
79  *      NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW
80  *      Others                 -> IEEE80211_HT_PARAM_CHA_SEC_NONE
81  */
mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type)82 u8 mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type)
83 {
84 	switch (chan_type) {
85 	case NL80211_CHAN_NO_HT:
86 	case NL80211_CHAN_HT20:
87 		return IEEE80211_HT_PARAM_CHA_SEC_NONE;
88 	case NL80211_CHAN_HT40PLUS:
89 		return IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
90 	case NL80211_CHAN_HT40MINUS:
91 		return IEEE80211_HT_PARAM_CHA_SEC_BELOW;
92 	default:
93 		return IEEE80211_HT_PARAM_CHA_SEC_NONE;
94 	}
95 }
96 
97 /* This function maps IEEE HT secondary channel type to NL80211 channel type
98  */
mwifiex_sec_chan_offset_to_chan_type(u8 second_chan_offset)99 u8 mwifiex_sec_chan_offset_to_chan_type(u8 second_chan_offset)
100 {
101 	switch (second_chan_offset) {
102 	case IEEE80211_HT_PARAM_CHA_SEC_NONE:
103 		return NL80211_CHAN_HT20;
104 	case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
105 		return NL80211_CHAN_HT40PLUS;
106 	case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
107 		return NL80211_CHAN_HT40MINUS;
108 	default:
109 		return NL80211_CHAN_HT20;
110 	}
111 }
112 
113 /*
114  * This function checks whether WEP is set.
115  */
116 static int
mwifiex_is_alg_wep(u32 cipher)117 mwifiex_is_alg_wep(u32 cipher)
118 {
119 	switch (cipher) {
120 	case WLAN_CIPHER_SUITE_WEP40:
121 	case WLAN_CIPHER_SUITE_WEP104:
122 		return 1;
123 	default:
124 		break;
125 	}
126 
127 	return 0;
128 }
129 
130 /*
131  * This function retrieves the private structure from kernel wiphy structure.
132  */
mwifiex_cfg80211_get_adapter(struct wiphy * wiphy)133 static void *mwifiex_cfg80211_get_adapter(struct wiphy *wiphy)
134 {
135 	return (void *) (*(unsigned long *) wiphy_priv(wiphy));
136 }
137 
138 /*
139  * CFG802.11 operation handler to delete a network key.
140  */
141 static int
mwifiex_cfg80211_del_key(struct wiphy * wiphy,struct net_device * netdev,u8 key_index,bool pairwise,const u8 * mac_addr)142 mwifiex_cfg80211_del_key(struct wiphy *wiphy, struct net_device *netdev,
143 			 u8 key_index, bool pairwise, const u8 *mac_addr)
144 {
145 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
146 	const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
147 	const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
148 
149 	if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index, peer_mac, 1)) {
150 		mwifiex_dbg(priv->adapter, ERROR, "deleting the crypto keys\n");
151 		return -EFAULT;
152 	}
153 
154 	mwifiex_dbg(priv->adapter, INFO, "info: crypto keys deleted\n");
155 	return 0;
156 }
157 
158 /*
159  * This function forms an skb for management frame.
160  */
161 static int
mwifiex_form_mgmt_frame(struct sk_buff * skb,const u8 * buf,size_t len)162 mwifiex_form_mgmt_frame(struct sk_buff *skb, const u8 *buf, size_t len)
163 {
164 	u8 addr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
165 	u16 pkt_len;
166 	u32 tx_control = 0, pkt_type = PKT_TYPE_MGMT;
167 
168 	pkt_len = len + ETH_ALEN;
169 
170 	skb_reserve(skb, MWIFIEX_MIN_DATA_HEADER_LEN +
171 		    MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(pkt_len));
172 	memcpy(skb_push(skb, sizeof(pkt_len)), &pkt_len, sizeof(pkt_len));
173 
174 	memcpy(skb_push(skb, sizeof(tx_control)),
175 	       &tx_control, sizeof(tx_control));
176 
177 	memcpy(skb_push(skb, sizeof(pkt_type)), &pkt_type, sizeof(pkt_type));
178 
179 	/* Add packet data and address4 */
180 	memcpy(skb_put(skb, sizeof(struct ieee80211_hdr_3addr)), buf,
181 	       sizeof(struct ieee80211_hdr_3addr));
182 	memcpy(skb_put(skb, ETH_ALEN), addr, ETH_ALEN);
183 	memcpy(skb_put(skb, len - sizeof(struct ieee80211_hdr_3addr)),
184 	       buf + sizeof(struct ieee80211_hdr_3addr),
185 	       len - sizeof(struct ieee80211_hdr_3addr));
186 
187 	skb->priority = LOW_PRIO_TID;
188 	__net_timestamp(skb);
189 
190 	return 0;
191 }
192 
193 /*
194  * CFG802.11 operation handler to transmit a management frame.
195  */
196 static int
mwifiex_cfg80211_mgmt_tx(struct wiphy * wiphy,struct wireless_dev * wdev,struct cfg80211_mgmt_tx_params * params,u64 * cookie)197 mwifiex_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
198 			 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
199 {
200 	const u8 *buf = params->buf;
201 	size_t len = params->len;
202 	struct sk_buff *skb;
203 	u16 pkt_len;
204 	const struct ieee80211_mgmt *mgmt;
205 	struct mwifiex_txinfo *tx_info;
206 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
207 
208 	if (!buf || !len) {
209 		mwifiex_dbg(priv->adapter, ERROR, "invalid buffer and length\n");
210 		return -EFAULT;
211 	}
212 
213 	mgmt = (const struct ieee80211_mgmt *)buf;
214 	if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA &&
215 	    ieee80211_is_probe_resp(mgmt->frame_control)) {
216 		/* Since we support offload probe resp, we need to skip probe
217 		 * resp in AP or GO mode */
218 		mwifiex_dbg(priv->adapter, INFO,
219 			    "info: skip to send probe resp in AP or GO mode\n");
220 		return 0;
221 	}
222 
223 	pkt_len = len + ETH_ALEN;
224 	skb = dev_alloc_skb(MWIFIEX_MIN_DATA_HEADER_LEN +
225 			    MWIFIEX_MGMT_FRAME_HEADER_SIZE +
226 			    pkt_len + sizeof(pkt_len));
227 
228 	if (!skb) {
229 		mwifiex_dbg(priv->adapter, ERROR,
230 			    "allocate skb failed for management frame\n");
231 		return -ENOMEM;
232 	}
233 
234 	tx_info = MWIFIEX_SKB_TXCB(skb);
235 	memset(tx_info, 0, sizeof(*tx_info));
236 	tx_info->bss_num = priv->bss_num;
237 	tx_info->bss_type = priv->bss_type;
238 	tx_info->pkt_len = pkt_len;
239 
240 	mwifiex_form_mgmt_frame(skb, buf, len);
241 	*cookie = prandom_u32() | 1;
242 
243 	if (ieee80211_is_action(mgmt->frame_control))
244 		skb = mwifiex_clone_skb_for_tx_status(priv,
245 						      skb,
246 				MWIFIEX_BUF_FLAG_ACTION_TX_STATUS, cookie);
247 	else
248 		cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
249 					GFP_ATOMIC);
250 
251 	mwifiex_queue_tx_pkt(priv, skb);
252 
253 	mwifiex_dbg(priv->adapter, INFO, "info: management frame transmitted\n");
254 	return 0;
255 }
256 
257 /*
258  * CFG802.11 operation handler to register a mgmt frame.
259  */
260 static void
mwifiex_cfg80211_mgmt_frame_register(struct wiphy * wiphy,struct wireless_dev * wdev,u16 frame_type,bool reg)261 mwifiex_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
262 				     struct wireless_dev *wdev,
263 				     u16 frame_type, bool reg)
264 {
265 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
266 	u32 mask;
267 
268 	if (reg)
269 		mask = priv->mgmt_frame_mask | BIT(frame_type >> 4);
270 	else
271 		mask = priv->mgmt_frame_mask & ~BIT(frame_type >> 4);
272 
273 	if (mask != priv->mgmt_frame_mask) {
274 		priv->mgmt_frame_mask = mask;
275 		mwifiex_send_cmd(priv, HostCmd_CMD_MGMT_FRAME_REG,
276 				 HostCmd_ACT_GEN_SET, 0,
277 				 &priv->mgmt_frame_mask, false);
278 		mwifiex_dbg(priv->adapter, INFO, "info: mgmt frame registered\n");
279 	}
280 }
281 
282 /*
283  * CFG802.11 operation handler to remain on channel.
284  */
285 static int
mwifiex_cfg80211_remain_on_channel(struct wiphy * wiphy,struct wireless_dev * wdev,struct ieee80211_channel * chan,unsigned int duration,u64 * cookie)286 mwifiex_cfg80211_remain_on_channel(struct wiphy *wiphy,
287 				   struct wireless_dev *wdev,
288 				   struct ieee80211_channel *chan,
289 				   unsigned int duration, u64 *cookie)
290 {
291 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
292 	int ret;
293 
294 	if (!chan || !cookie) {
295 		mwifiex_dbg(priv->adapter, ERROR, "Invalid parameter for ROC\n");
296 		return -EINVAL;
297 	}
298 
299 	if (priv->roc_cfg.cookie) {
300 		mwifiex_dbg(priv->adapter, INFO,
301 			    "info: ongoing ROC, cookie = 0x%llx\n",
302 			    priv->roc_cfg.cookie);
303 		return -EBUSY;
304 	}
305 
306 	ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_SET, chan,
307 					 duration);
308 
309 	if (!ret) {
310 		*cookie = prandom_u32() | 1;
311 		priv->roc_cfg.cookie = *cookie;
312 		priv->roc_cfg.chan = *chan;
313 
314 		cfg80211_ready_on_channel(wdev, *cookie, chan,
315 					  duration, GFP_ATOMIC);
316 
317 		mwifiex_dbg(priv->adapter, INFO,
318 			    "info: ROC, cookie = 0x%llx\n", *cookie);
319 	}
320 
321 	return ret;
322 }
323 
324 /*
325  * CFG802.11 operation handler to cancel remain on channel.
326  */
327 static int
mwifiex_cfg80211_cancel_remain_on_channel(struct wiphy * wiphy,struct wireless_dev * wdev,u64 cookie)328 mwifiex_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
329 					  struct wireless_dev *wdev, u64 cookie)
330 {
331 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
332 	int ret;
333 
334 	if (cookie != priv->roc_cfg.cookie)
335 		return -ENOENT;
336 
337 	ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_REMOVE,
338 					 &priv->roc_cfg.chan, 0);
339 
340 	if (!ret) {
341 		cfg80211_remain_on_channel_expired(wdev, cookie,
342 						   &priv->roc_cfg.chan,
343 						   GFP_ATOMIC);
344 
345 		memset(&priv->roc_cfg, 0, sizeof(struct mwifiex_roc_cfg));
346 
347 		mwifiex_dbg(priv->adapter, INFO,
348 			    "info: cancel ROC, cookie = 0x%llx\n", cookie);
349 	}
350 
351 	return ret;
352 }
353 
354 /*
355  * CFG802.11 operation handler to set Tx power.
356  */
357 static int
mwifiex_cfg80211_set_tx_power(struct wiphy * wiphy,struct wireless_dev * wdev,enum nl80211_tx_power_setting type,int mbm)358 mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy,
359 			      struct wireless_dev *wdev,
360 			      enum nl80211_tx_power_setting type,
361 			      int mbm)
362 {
363 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
364 	struct mwifiex_private *priv;
365 	struct mwifiex_power_cfg power_cfg;
366 	int dbm = MBM_TO_DBM(mbm);
367 
368 	if (type == NL80211_TX_POWER_FIXED) {
369 		power_cfg.is_power_auto = 0;
370 		power_cfg.power_level = dbm;
371 	} else {
372 		power_cfg.is_power_auto = 1;
373 	}
374 
375 	priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
376 
377 	return mwifiex_set_tx_power(priv, &power_cfg);
378 }
379 
380 /*
381  * CFG802.11 operation handler to set Power Save option.
382  *
383  * The timeout value, if provided, is currently ignored.
384  */
385 static int
mwifiex_cfg80211_set_power_mgmt(struct wiphy * wiphy,struct net_device * dev,bool enabled,int timeout)386 mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy,
387 				struct net_device *dev,
388 				bool enabled, int timeout)
389 {
390 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
391 	u32 ps_mode;
392 
393 	if (timeout)
394 		mwifiex_dbg(priv->adapter, INFO,
395 			    "info: ignore timeout value for IEEE Power Save\n");
396 
397 	ps_mode = enabled;
398 
399 	return mwifiex_drv_set_power(priv, &ps_mode);
400 }
401 
402 /*
403  * CFG802.11 operation handler to set the default network key.
404  */
405 static int
mwifiex_cfg80211_set_default_key(struct wiphy * wiphy,struct net_device * netdev,u8 key_index,bool unicast,bool multicast)406 mwifiex_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
407 				 u8 key_index, bool unicast,
408 				 bool multicast)
409 {
410 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
411 
412 	/* Return if WEP key not configured */
413 	if (!priv->sec_info.wep_enabled)
414 		return 0;
415 
416 	if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP) {
417 		priv->wep_key_curr_index = key_index;
418 	} else if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index,
419 				      NULL, 0)) {
420 		mwifiex_dbg(priv->adapter, ERROR, "set default Tx key index\n");
421 		return -EFAULT;
422 	}
423 
424 	return 0;
425 }
426 
427 /*
428  * CFG802.11 operation handler to add a network key.
429  */
430 static int
mwifiex_cfg80211_add_key(struct wiphy * wiphy,struct net_device * netdev,u8 key_index,bool pairwise,const u8 * mac_addr,struct key_params * params)431 mwifiex_cfg80211_add_key(struct wiphy *wiphy, struct net_device *netdev,
432 			 u8 key_index, bool pairwise, const u8 *mac_addr,
433 			 struct key_params *params)
434 {
435 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
436 	struct mwifiex_wep_key *wep_key;
437 	const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
438 	const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
439 
440 	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
441 	    (params->cipher == WLAN_CIPHER_SUITE_WEP40 ||
442 	     params->cipher == WLAN_CIPHER_SUITE_WEP104)) {
443 		if (params->key && params->key_len) {
444 			wep_key = &priv->wep_key[key_index];
445 			memset(wep_key, 0, sizeof(struct mwifiex_wep_key));
446 			memcpy(wep_key->key_material, params->key,
447 			       params->key_len);
448 			wep_key->key_index = key_index;
449 			wep_key->key_length = params->key_len;
450 			priv->sec_info.wep_enabled = 1;
451 		}
452 		return 0;
453 	}
454 
455 	if (mwifiex_set_encode(priv, params, params->key, params->key_len,
456 			       key_index, peer_mac, 0)) {
457 		mwifiex_dbg(priv->adapter, ERROR, "crypto keys added\n");
458 		return -EFAULT;
459 	}
460 
461 	return 0;
462 }
463 
464 /*
465  * This function sends domain information to the firmware.
466  *
467  * The following information are passed to the firmware -
468  *      - Country codes
469  *      - Sub bands (first channel, number of channels, maximum Tx power)
470  */
mwifiex_send_domain_info_cmd_fw(struct wiphy * wiphy)471 int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
472 {
473 	u8 no_of_triplet = 0;
474 	struct ieee80211_country_ie_triplet *t;
475 	u8 no_of_parsed_chan = 0;
476 	u8 first_chan = 0, next_chan = 0, max_pwr = 0;
477 	u8 i, flag = 0;
478 	enum ieee80211_band band;
479 	struct ieee80211_supported_band *sband;
480 	struct ieee80211_channel *ch;
481 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
482 	struct mwifiex_private *priv;
483 	struct mwifiex_802_11d_domain_reg *domain_info = &adapter->domain_reg;
484 
485 	/* Set country code */
486 	domain_info->country_code[0] = adapter->country_code[0];
487 	domain_info->country_code[1] = adapter->country_code[1];
488 	domain_info->country_code[2] = ' ';
489 
490 	band = mwifiex_band_to_radio_type(adapter->config_bands);
491 	if (!wiphy->bands[band]) {
492 		mwifiex_dbg(adapter, ERROR,
493 			    "11D: setting domain info in FW\n");
494 		return -1;
495 	}
496 
497 	sband = wiphy->bands[band];
498 
499 	for (i = 0; i < sband->n_channels ; i++) {
500 		ch = &sband->channels[i];
501 		if (ch->flags & IEEE80211_CHAN_DISABLED)
502 			continue;
503 
504 		if (!flag) {
505 			flag = 1;
506 			first_chan = (u32) ch->hw_value;
507 			next_chan = first_chan;
508 			max_pwr = ch->max_power;
509 			no_of_parsed_chan = 1;
510 			continue;
511 		}
512 
513 		if (ch->hw_value == next_chan + 1 &&
514 		    ch->max_power == max_pwr) {
515 			next_chan++;
516 			no_of_parsed_chan++;
517 		} else {
518 			t = &domain_info->triplet[no_of_triplet];
519 			t->chans.first_channel = first_chan;
520 			t->chans.num_channels = no_of_parsed_chan;
521 			t->chans.max_power = max_pwr;
522 			no_of_triplet++;
523 			first_chan = (u32) ch->hw_value;
524 			next_chan = first_chan;
525 			max_pwr = ch->max_power;
526 			no_of_parsed_chan = 1;
527 		}
528 	}
529 
530 	if (flag) {
531 		t = &domain_info->triplet[no_of_triplet];
532 		t->chans.first_channel = first_chan;
533 		t->chans.num_channels = no_of_parsed_chan;
534 		t->chans.max_power = max_pwr;
535 		no_of_triplet++;
536 	}
537 
538 	domain_info->no_of_triplet = no_of_triplet;
539 
540 	priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
541 
542 	if (mwifiex_send_cmd(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,
543 			     HostCmd_ACT_GEN_SET, 0, NULL, false)) {
544 		mwifiex_dbg(adapter, INFO,
545 			    "11D: setting domain info in FW\n");
546 		return -1;
547 	}
548 
549 	return 0;
550 }
551 
552 /*
553  * CFG802.11 regulatory domain callback function.
554  *
555  * This function is called when the regulatory domain is changed due to the
556  * following reasons -
557  *      - Set by driver
558  *      - Set by system core
559  *      - Set by user
560  *      - Set bt Country IE
561  */
mwifiex_reg_notifier(struct wiphy * wiphy,struct regulatory_request * request)562 static void mwifiex_reg_notifier(struct wiphy *wiphy,
563 				 struct regulatory_request *request)
564 {
565 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
566 	struct mwifiex_private *priv = mwifiex_get_priv(adapter,
567 							MWIFIEX_BSS_ROLE_ANY);
568 	mwifiex_dbg(adapter, INFO,
569 		    "info: cfg80211 regulatory domain callback for %c%c\n",
570 		    request->alpha2[0], request->alpha2[1]);
571 
572 	switch (request->initiator) {
573 	case NL80211_REGDOM_SET_BY_DRIVER:
574 	case NL80211_REGDOM_SET_BY_CORE:
575 	case NL80211_REGDOM_SET_BY_USER:
576 	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
577 		break;
578 	default:
579 		mwifiex_dbg(adapter, ERROR,
580 			    "unknown regdom initiator: %d\n",
581 			    request->initiator);
582 		return;
583 	}
584 
585 	/* Don't send world or same regdom info to firmware */
586 	if (strncmp(request->alpha2, "00", 2) &&
587 	    strncmp(request->alpha2, adapter->country_code,
588 		    sizeof(request->alpha2))) {
589 		memcpy(adapter->country_code, request->alpha2,
590 		       sizeof(request->alpha2));
591 		mwifiex_send_domain_info_cmd_fw(wiphy);
592 		mwifiex_dnld_txpwr_table(priv);
593 	}
594 }
595 
596 /*
597  * This function sets the fragmentation threshold.
598  *
599  * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE
600  * and MWIFIEX_FRAG_MAX_VALUE.
601  */
602 static int
mwifiex_set_frag(struct mwifiex_private * priv,u32 frag_thr)603 mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)
604 {
605 	if (frag_thr < MWIFIEX_FRAG_MIN_VALUE ||
606 	    frag_thr > MWIFIEX_FRAG_MAX_VALUE)
607 		frag_thr = MWIFIEX_FRAG_MAX_VALUE;
608 
609 	return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
610 				HostCmd_ACT_GEN_SET, FRAG_THRESH_I,
611 				&frag_thr, true);
612 }
613 
614 /*
615  * This function sets the RTS threshold.
616 
617  * The rts value must lie between MWIFIEX_RTS_MIN_VALUE
618  * and MWIFIEX_RTS_MAX_VALUE.
619  */
620 static int
mwifiex_set_rts(struct mwifiex_private * priv,u32 rts_thr)621 mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)
622 {
623 	if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)
624 		rts_thr = MWIFIEX_RTS_MAX_VALUE;
625 
626 	return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
627 				HostCmd_ACT_GEN_SET, RTS_THRESH_I,
628 				&rts_thr, true);
629 }
630 
631 /*
632  * CFG802.11 operation handler to set wiphy parameters.
633  *
634  * This function can be used to set the RTS threshold and the
635  * Fragmentation threshold of the driver.
636  */
637 static int
mwifiex_cfg80211_set_wiphy_params(struct wiphy * wiphy,u32 changed)638 mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
639 {
640 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
641 	struct mwifiex_private *priv;
642 	struct mwifiex_uap_bss_param *bss_cfg;
643 	int ret;
644 
645 	priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
646 
647 	switch (priv->bss_role) {
648 	case MWIFIEX_BSS_ROLE_UAP:
649 		if (priv->bss_started) {
650 			mwifiex_dbg(adapter, ERROR,
651 				    "cannot change wiphy params when bss started");
652 			return -EINVAL;
653 		}
654 
655 		bss_cfg = kzalloc(sizeof(*bss_cfg), GFP_KERNEL);
656 		if (!bss_cfg)
657 			return -ENOMEM;
658 
659 		mwifiex_set_sys_config_invalid_data(bss_cfg);
660 
661 		if (changed & WIPHY_PARAM_RTS_THRESHOLD)
662 			bss_cfg->rts_threshold = wiphy->rts_threshold;
663 		if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
664 			bss_cfg->frag_threshold = wiphy->frag_threshold;
665 		if (changed & WIPHY_PARAM_RETRY_LONG)
666 			bss_cfg->retry_limit = wiphy->retry_long;
667 
668 		ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_SYS_CONFIG,
669 				       HostCmd_ACT_GEN_SET,
670 				       UAP_BSS_PARAMS_I, bss_cfg,
671 				       false);
672 
673 		kfree(bss_cfg);
674 		if (ret) {
675 			mwifiex_dbg(adapter, ERROR,
676 				    "Failed to set wiphy phy params\n");
677 			return ret;
678 		}
679 		break;
680 
681 		case MWIFIEX_BSS_ROLE_STA:
682 		if (priv->media_connected) {
683 			mwifiex_dbg(adapter, ERROR,
684 				    "cannot change wiphy params when connected");
685 			return -EINVAL;
686 		}
687 		if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
688 			ret = mwifiex_set_rts(priv,
689 					      wiphy->rts_threshold);
690 			if (ret)
691 				return ret;
692 		}
693 		if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
694 			ret = mwifiex_set_frag(priv,
695 					       wiphy->frag_threshold);
696 			if (ret)
697 				return ret;
698 		}
699 		break;
700 	}
701 
702 	return 0;
703 }
704 
705 static int
mwifiex_cfg80211_deinit_p2p(struct mwifiex_private * priv)706 mwifiex_cfg80211_deinit_p2p(struct mwifiex_private *priv)
707 {
708 	u16 mode = P2P_MODE_DISABLE;
709 
710 	if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
711 			     HostCmd_ACT_GEN_SET, 0, &mode, true))
712 		return -1;
713 
714 	return 0;
715 }
716 
717 /*
718  * This function initializes the functionalities for P2P client.
719  * The P2P client initialization sequence is:
720  * disable -> device -> client
721  */
722 static int
mwifiex_cfg80211_init_p2p_client(struct mwifiex_private * priv)723 mwifiex_cfg80211_init_p2p_client(struct mwifiex_private *priv)
724 {
725 	u16 mode;
726 
727 	if (mwifiex_cfg80211_deinit_p2p(priv))
728 		return -1;
729 
730 	mode = P2P_MODE_DEVICE;
731 	if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
732 			     HostCmd_ACT_GEN_SET, 0, &mode, true))
733 		return -1;
734 
735 	mode = P2P_MODE_CLIENT;
736 	if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
737 			     HostCmd_ACT_GEN_SET, 0, &mode, true))
738 		return -1;
739 
740 	return 0;
741 }
742 
743 /*
744  * This function initializes the functionalities for P2P GO.
745  * The P2P GO initialization sequence is:
746  * disable -> device -> GO
747  */
748 static int
mwifiex_cfg80211_init_p2p_go(struct mwifiex_private * priv)749 mwifiex_cfg80211_init_p2p_go(struct mwifiex_private *priv)
750 {
751 	u16 mode;
752 
753 	if (mwifiex_cfg80211_deinit_p2p(priv))
754 		return -1;
755 
756 	mode = P2P_MODE_DEVICE;
757 	if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
758 			     HostCmd_ACT_GEN_SET, 0, &mode, true))
759 		return -1;
760 
761 	mode = P2P_MODE_GO;
762 	if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
763 			     HostCmd_ACT_GEN_SET, 0, &mode, true))
764 		return -1;
765 
766 	return 0;
767 }
768 
mwifiex_deinit_priv_params(struct mwifiex_private * priv)769 static int mwifiex_deinit_priv_params(struct mwifiex_private *priv)
770 {
771 	struct mwifiex_adapter *adapter = priv->adapter;
772 	unsigned long flags;
773 
774 	priv->mgmt_frame_mask = 0;
775 	if (mwifiex_send_cmd(priv, HostCmd_CMD_MGMT_FRAME_REG,
776 			     HostCmd_ACT_GEN_SET, 0,
777 			     &priv->mgmt_frame_mask, false)) {
778 		mwifiex_dbg(adapter, ERROR,
779 			    "could not unregister mgmt frame rx\n");
780 		return -1;
781 	}
782 
783 	mwifiex_deauthenticate(priv, NULL);
784 
785 	spin_lock_irqsave(&adapter->main_proc_lock, flags);
786 	adapter->main_locked = true;
787 	if (adapter->mwifiex_processing) {
788 		spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
789 		flush_workqueue(adapter->workqueue);
790 	} else {
791 		spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
792 	}
793 
794 	spin_lock_irqsave(&adapter->rx_proc_lock, flags);
795 	adapter->rx_locked = true;
796 	if (adapter->rx_processing) {
797 		spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
798 		flush_workqueue(adapter->rx_workqueue);
799 	} else {
800 	spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
801 	}
802 
803 	mwifiex_free_priv(priv);
804 	priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
805 	priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
806 	priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
807 
808 	return 0;
809 }
810 
811 static int
mwifiex_init_new_priv_params(struct mwifiex_private * priv,struct net_device * dev,enum nl80211_iftype type)812 mwifiex_init_new_priv_params(struct mwifiex_private *priv,
813 			     struct net_device *dev,
814 			     enum nl80211_iftype type)
815 {
816 	struct mwifiex_adapter *adapter = priv->adapter;
817 	unsigned long flags;
818 
819 	mwifiex_init_priv(priv);
820 
821 	priv->bss_mode = type;
822 	priv->wdev.iftype = type;
823 
824 	mwifiex_init_priv_params(priv, priv->netdev);
825 	priv->bss_started = 0;
826 
827 	switch (type) {
828 	case NL80211_IFTYPE_STATION:
829 	case NL80211_IFTYPE_ADHOC:
830 		priv->bss_role =  MWIFIEX_BSS_ROLE_STA;
831 		priv->bss_type = MWIFIEX_BSS_TYPE_STA;
832 		break;
833 	case NL80211_IFTYPE_P2P_CLIENT:
834 		priv->bss_role =  MWIFIEX_BSS_ROLE_STA;
835 		priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
836 		break;
837 	case NL80211_IFTYPE_P2P_GO:
838 		priv->bss_role =  MWIFIEX_BSS_ROLE_UAP;
839 		priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
840 		break;
841 	case NL80211_IFTYPE_AP:
842 		priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
843 		priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
844 		break;
845 	default:
846 		mwifiex_dbg(adapter, ERROR,
847 			    "%s: changing to %d not supported\n",
848 			    dev->name, type);
849 		return -EOPNOTSUPP;
850 	}
851 
852 	spin_lock_irqsave(&adapter->main_proc_lock, flags);
853 	adapter->main_locked = false;
854 	spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
855 
856 	spin_lock_irqsave(&adapter->rx_proc_lock, flags);
857 	adapter->rx_locked = false;
858 	spin_unlock_irqrestore(&adapter->rx_proc_lock, flags);
859 
860 	return 0;
861 }
862 
863 static int
mwifiex_change_vif_to_p2p(struct net_device * dev,enum nl80211_iftype curr_iftype,enum nl80211_iftype type,u32 * flags,struct vif_params * params)864 mwifiex_change_vif_to_p2p(struct net_device *dev,
865 			  enum nl80211_iftype curr_iftype,
866 			  enum nl80211_iftype type, u32 *flags,
867 			  struct vif_params *params)
868 {
869 	struct mwifiex_private *priv;
870 	struct mwifiex_adapter *adapter;
871 
872 	priv = mwifiex_netdev_get_priv(dev);
873 
874 	if (!priv)
875 		return -1;
876 
877 	adapter = priv->adapter;
878 
879 	if (adapter->curr_iface_comb.p2p_intf ==
880 	    adapter->iface_limit.p2p_intf) {
881 		mwifiex_dbg(adapter, ERROR,
882 			    "cannot create multiple P2P ifaces\n");
883 		return -1;
884 	}
885 
886 	mwifiex_dbg(adapter, INFO,
887 		    "%s: changing role to p2p\n", dev->name);
888 
889 	if (mwifiex_deinit_priv_params(priv))
890 		return -1;
891 	if (mwifiex_init_new_priv_params(priv, dev, type))
892 		return -1;
893 
894 	switch (type) {
895 	case NL80211_IFTYPE_P2P_CLIENT:
896 		if (mwifiex_cfg80211_init_p2p_client(priv))
897 			return -EFAULT;
898 		break;
899 	case NL80211_IFTYPE_P2P_GO:
900 		if (mwifiex_cfg80211_init_p2p_go(priv))
901 			return -EFAULT;
902 		break;
903 	default:
904 		mwifiex_dbg(adapter, ERROR,
905 			    "%s: changing to %d not supported\n",
906 			    dev->name, type);
907 		return -EOPNOTSUPP;
908 	}
909 
910 	if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
911 			     HostCmd_ACT_GEN_SET, 0, NULL, true))
912 		return -1;
913 
914 	if (mwifiex_sta_init_cmd(priv, false, false))
915 		return -1;
916 
917 	switch (curr_iftype) {
918 	case NL80211_IFTYPE_STATION:
919 	case NL80211_IFTYPE_ADHOC:
920 		adapter->curr_iface_comb.sta_intf--;
921 		break;
922 	case NL80211_IFTYPE_AP:
923 		adapter->curr_iface_comb.uap_intf--;
924 		break;
925 	default:
926 		break;
927 	}
928 
929 	adapter->curr_iface_comb.p2p_intf++;
930 	dev->ieee80211_ptr->iftype = type;
931 
932 	return 0;
933 }
934 
935 static int
mwifiex_change_vif_to_sta_adhoc(struct net_device * dev,enum nl80211_iftype curr_iftype,enum nl80211_iftype type,u32 * flags,struct vif_params * params)936 mwifiex_change_vif_to_sta_adhoc(struct net_device *dev,
937 				enum nl80211_iftype curr_iftype,
938 				enum nl80211_iftype type, u32 *flags,
939 				struct vif_params *params)
940 {
941 	struct mwifiex_private *priv;
942 	struct mwifiex_adapter *adapter;
943 
944 	priv = mwifiex_netdev_get_priv(dev);
945 
946 	if (!priv)
947 		return -1;
948 
949 	adapter = priv->adapter;
950 
951 	if ((curr_iftype != NL80211_IFTYPE_P2P_CLIENT &&
952 	     curr_iftype != NL80211_IFTYPE_P2P_GO) &&
953 	    (adapter->curr_iface_comb.sta_intf ==
954 	     adapter->iface_limit.sta_intf)) {
955 		mwifiex_dbg(adapter, ERROR,
956 			    "cannot create multiple station/adhoc ifaces\n");
957 		return -1;
958 	}
959 
960 	if (type == NL80211_IFTYPE_STATION)
961 		mwifiex_dbg(adapter, INFO,
962 			    "%s: changing role to station\n", dev->name);
963 	else
964 		mwifiex_dbg(adapter, INFO,
965 			    "%s: changing role to adhoc\n", dev->name);
966 
967 	if (mwifiex_deinit_priv_params(priv))
968 		return -1;
969 	if (mwifiex_init_new_priv_params(priv, dev, type))
970 		return -1;
971 	if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
972 			     HostCmd_ACT_GEN_SET, 0, NULL, true))
973 		return -1;
974 	if (mwifiex_sta_init_cmd(priv, false, false))
975 		return -1;
976 
977 	switch (curr_iftype) {
978 	case NL80211_IFTYPE_P2P_CLIENT:
979 	case NL80211_IFTYPE_P2P_GO:
980 		adapter->curr_iface_comb.p2p_intf--;
981 		break;
982 	case NL80211_IFTYPE_AP:
983 		adapter->curr_iface_comb.uap_intf--;
984 		break;
985 	default:
986 		break;
987 	}
988 
989 	adapter->curr_iface_comb.sta_intf++;
990 	dev->ieee80211_ptr->iftype = type;
991 	return 0;
992 }
993 
994 static int
mwifiex_change_vif_to_ap(struct net_device * dev,enum nl80211_iftype curr_iftype,enum nl80211_iftype type,u32 * flags,struct vif_params * params)995 mwifiex_change_vif_to_ap(struct net_device *dev,
996 			 enum nl80211_iftype curr_iftype,
997 			 enum nl80211_iftype type, u32 *flags,
998 			 struct vif_params *params)
999 {
1000 	struct mwifiex_private *priv;
1001 	struct mwifiex_adapter *adapter;
1002 
1003 	priv = mwifiex_netdev_get_priv(dev);
1004 
1005 	if (!priv)
1006 		return -1;
1007 
1008 	adapter = priv->adapter;
1009 
1010 	if (adapter->curr_iface_comb.uap_intf ==
1011 	    adapter->iface_limit.uap_intf) {
1012 		mwifiex_dbg(adapter, ERROR,
1013 			    "cannot create multiple AP ifaces\n");
1014 		return -1;
1015 	}
1016 
1017 	mwifiex_dbg(adapter, INFO,
1018 		    "%s: changing role to AP\n", dev->name);
1019 
1020 	if (mwifiex_deinit_priv_params(priv))
1021 		return -1;
1022 	if (mwifiex_init_new_priv_params(priv, dev, type))
1023 		return -1;
1024 	if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1025 			     HostCmd_ACT_GEN_SET, 0, NULL, true))
1026 		return -1;
1027 	if (mwifiex_sta_init_cmd(priv, false, false))
1028 		return -1;
1029 
1030 	switch (curr_iftype) {
1031 	case NL80211_IFTYPE_P2P_CLIENT:
1032 	case NL80211_IFTYPE_P2P_GO:
1033 		adapter->curr_iface_comb.p2p_intf--;
1034 		break;
1035 	case NL80211_IFTYPE_STATION:
1036 	case NL80211_IFTYPE_ADHOC:
1037 		adapter->curr_iface_comb.sta_intf--;
1038 		break;
1039 	default:
1040 		break;
1041 	}
1042 
1043 	adapter->curr_iface_comb.uap_intf++;
1044 	dev->ieee80211_ptr->iftype = type;
1045 	return 0;
1046 }
1047 /*
1048  * CFG802.11 operation handler to change interface type.
1049  */
1050 static int
mwifiex_cfg80211_change_virtual_intf(struct wiphy * wiphy,struct net_device * dev,enum nl80211_iftype type,u32 * flags,struct vif_params * params)1051 mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
1052 				     struct net_device *dev,
1053 				     enum nl80211_iftype type, u32 *flags,
1054 				     struct vif_params *params)
1055 {
1056 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1057 	enum nl80211_iftype curr_iftype = dev->ieee80211_ptr->iftype;
1058 
1059 	switch (curr_iftype) {
1060 	case NL80211_IFTYPE_ADHOC:
1061 		switch (type) {
1062 		case NL80211_IFTYPE_STATION:
1063 			priv->bss_mode = type;
1064 			priv->sec_info.authentication_mode =
1065 						   NL80211_AUTHTYPE_OPEN_SYSTEM;
1066 			dev->ieee80211_ptr->iftype = type;
1067 			mwifiex_deauthenticate(priv, NULL);
1068 			return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1069 						HostCmd_ACT_GEN_SET, 0, NULL,
1070 						true);
1071 		case NL80211_IFTYPE_P2P_CLIENT:
1072 		case NL80211_IFTYPE_P2P_GO:
1073 			return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1074 							 type, flags, params);
1075 		case NL80211_IFTYPE_AP:
1076 			return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1077 							flags, params);
1078 		case NL80211_IFTYPE_UNSPECIFIED:
1079 			mwifiex_dbg(priv->adapter, INFO,
1080 				    "%s: kept type as IBSS\n", dev->name);
1081 		case NL80211_IFTYPE_ADHOC:	/* This shouldn't happen */
1082 			return 0;
1083 		default:
1084 			mwifiex_dbg(priv->adapter, ERROR,
1085 				    "%s: changing to %d not supported\n",
1086 				    dev->name, type);
1087 			return -EOPNOTSUPP;
1088 		}
1089 		break;
1090 	case NL80211_IFTYPE_STATION:
1091 		switch (type) {
1092 		case NL80211_IFTYPE_ADHOC:
1093 			priv->bss_mode = type;
1094 			priv->sec_info.authentication_mode =
1095 						   NL80211_AUTHTYPE_OPEN_SYSTEM;
1096 			dev->ieee80211_ptr->iftype = type;
1097 			mwifiex_deauthenticate(priv, NULL);
1098 			return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1099 						HostCmd_ACT_GEN_SET, 0, NULL,
1100 						true);
1101 		case NL80211_IFTYPE_P2P_CLIENT:
1102 		case NL80211_IFTYPE_P2P_GO:
1103 			return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1104 							 type, flags, params);
1105 		case NL80211_IFTYPE_AP:
1106 			return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1107 							flags, params);
1108 		case NL80211_IFTYPE_UNSPECIFIED:
1109 			mwifiex_dbg(priv->adapter, INFO,
1110 				    "%s: kept type as STA\n", dev->name);
1111 		case NL80211_IFTYPE_STATION:	/* This shouldn't happen */
1112 			return 0;
1113 		default:
1114 			mwifiex_dbg(priv->adapter, ERROR,
1115 				    "%s: changing to %d not supported\n",
1116 				    dev->name, type);
1117 			return -EOPNOTSUPP;
1118 		}
1119 		break;
1120 	case NL80211_IFTYPE_AP:
1121 		switch (type) {
1122 		case NL80211_IFTYPE_ADHOC:
1123 		case NL80211_IFTYPE_STATION:
1124 			return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
1125 							       type, flags,
1126 							       params);
1127 			break;
1128 		case NL80211_IFTYPE_P2P_CLIENT:
1129 		case NL80211_IFTYPE_P2P_GO:
1130 			return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1131 							 type, flags, params);
1132 		case NL80211_IFTYPE_UNSPECIFIED:
1133 			mwifiex_dbg(priv->adapter, INFO,
1134 				    "%s: kept type as AP\n", dev->name);
1135 		case NL80211_IFTYPE_AP:		/* This shouldn't happen */
1136 			return 0;
1137 		default:
1138 			mwifiex_dbg(priv->adapter, ERROR,
1139 				    "%s: changing to %d not supported\n",
1140 				    dev->name, type);
1141 			return -EOPNOTSUPP;
1142 		}
1143 		break;
1144 	case NL80211_IFTYPE_P2P_CLIENT:
1145 	case NL80211_IFTYPE_P2P_GO:
1146 		switch (type) {
1147 		case NL80211_IFTYPE_STATION:
1148 			if (mwifiex_cfg80211_deinit_p2p(priv))
1149 				return -EFAULT;
1150 			priv->adapter->curr_iface_comb.p2p_intf--;
1151 			priv->adapter->curr_iface_comb.sta_intf++;
1152 			dev->ieee80211_ptr->iftype = type;
1153 			break;
1154 		case NL80211_IFTYPE_ADHOC:
1155 			if (mwifiex_cfg80211_deinit_p2p(priv))
1156 				return -EFAULT;
1157 			return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
1158 							       type, flags,
1159 							       params);
1160 			break;
1161 		case NL80211_IFTYPE_AP:
1162 			if (mwifiex_cfg80211_deinit_p2p(priv))
1163 				return -EFAULT;
1164 			return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1165 							flags, params);
1166 		case NL80211_IFTYPE_UNSPECIFIED:
1167 			mwifiex_dbg(priv->adapter, INFO,
1168 				    "%s: kept type as P2P\n", dev->name);
1169 		case NL80211_IFTYPE_P2P_CLIENT:
1170 		case NL80211_IFTYPE_P2P_GO:
1171 			return 0;
1172 		default:
1173 			mwifiex_dbg(priv->adapter, ERROR,
1174 				    "%s: changing to %d not supported\n",
1175 				    dev->name, type);
1176 			return -EOPNOTSUPP;
1177 		}
1178 		break;
1179 	default:
1180 		mwifiex_dbg(priv->adapter, ERROR,
1181 			    "%s: unknown iftype: %d\n",
1182 			    dev->name, dev->ieee80211_ptr->iftype);
1183 		return -EOPNOTSUPP;
1184 	}
1185 
1186 
1187 	return 0;
1188 }
1189 
1190 static void
mwifiex_parse_htinfo(struct mwifiex_private * priv,u8 tx_htinfo,struct rate_info * rate)1191 mwifiex_parse_htinfo(struct mwifiex_private *priv, u8 tx_htinfo,
1192 		     struct rate_info *rate)
1193 {
1194 	struct mwifiex_adapter *adapter = priv->adapter;
1195 
1196 	if (adapter->is_hw_11ac_capable) {
1197 		/* bit[1-0]: 00=LG 01=HT 10=VHT */
1198 		if (tx_htinfo & BIT(0)) {
1199 			/* HT */
1200 			rate->mcs = priv->tx_rate;
1201 			rate->flags |= RATE_INFO_FLAGS_MCS;
1202 		}
1203 		if (tx_htinfo & BIT(1)) {
1204 			/* VHT */
1205 			rate->mcs = priv->tx_rate & 0x0F;
1206 			rate->flags |= RATE_INFO_FLAGS_VHT_MCS;
1207 		}
1208 
1209 		if (tx_htinfo & (BIT(1) | BIT(0))) {
1210 			/* HT or VHT */
1211 			switch (tx_htinfo & (BIT(3) | BIT(2))) {
1212 			case 0:
1213 				rate->bw = RATE_INFO_BW_20;
1214 				break;
1215 			case (BIT(2)):
1216 				rate->bw = RATE_INFO_BW_40;
1217 				break;
1218 			case (BIT(3)):
1219 				rate->bw = RATE_INFO_BW_80;
1220 				break;
1221 			case (BIT(3) | BIT(2)):
1222 				rate->bw = RATE_INFO_BW_160;
1223 				break;
1224 			}
1225 
1226 			if (tx_htinfo & BIT(4))
1227 				rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
1228 
1229 			if ((priv->tx_rate >> 4) == 1)
1230 				rate->nss = 2;
1231 			else
1232 				rate->nss = 1;
1233 		}
1234 	} else {
1235 		/*
1236 		 * Bit 0 in tx_htinfo indicates that current Tx rate
1237 		 * is 11n rate. Valid MCS index values for us are 0 to 15.
1238 		 */
1239 		if ((tx_htinfo & BIT(0)) && (priv->tx_rate < 16)) {
1240 			rate->mcs = priv->tx_rate;
1241 			rate->flags |= RATE_INFO_FLAGS_MCS;
1242 			rate->bw = RATE_INFO_BW_20;
1243 			if (tx_htinfo & BIT(1))
1244 				rate->bw = RATE_INFO_BW_40;
1245 			if (tx_htinfo & BIT(2))
1246 				rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
1247 		}
1248 	}
1249 }
1250 
1251 /*
1252  * This function dumps the station information on a buffer.
1253  *
1254  * The following information are shown -
1255  *      - Total bytes transmitted
1256  *      - Total bytes received
1257  *      - Total packets transmitted
1258  *      - Total packets received
1259  *      - Signal quality level
1260  *      - Transmission rate
1261  */
1262 static int
mwifiex_dump_station_info(struct mwifiex_private * priv,struct mwifiex_sta_node * node,struct station_info * sinfo)1263 mwifiex_dump_station_info(struct mwifiex_private *priv,
1264 			  struct mwifiex_sta_node *node,
1265 			  struct station_info *sinfo)
1266 {
1267 	u32 rate;
1268 
1269 	sinfo->filled = BIT(NL80211_STA_INFO_RX_BYTES) | BIT(NL80211_STA_INFO_TX_BYTES) |
1270 			BIT(NL80211_STA_INFO_RX_PACKETS) | BIT(NL80211_STA_INFO_TX_PACKETS) |
1271 			BIT(NL80211_STA_INFO_TX_BITRATE) |
1272 			BIT(NL80211_STA_INFO_SIGNAL) | BIT(NL80211_STA_INFO_SIGNAL_AVG);
1273 
1274 	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1275 		if (!node)
1276 			return -ENOENT;
1277 
1278 		sinfo->filled |= BIT(NL80211_STA_INFO_INACTIVE_TIME) |
1279 				BIT(NL80211_STA_INFO_TX_FAILED);
1280 		sinfo->inactive_time =
1281 			jiffies_to_msecs(jiffies - node->stats.last_rx);
1282 
1283 		sinfo->signal = node->stats.rssi;
1284 		sinfo->signal_avg = node->stats.rssi;
1285 		sinfo->rx_bytes = node->stats.rx_bytes;
1286 		sinfo->tx_bytes = node->stats.tx_bytes;
1287 		sinfo->rx_packets = node->stats.rx_packets;
1288 		sinfo->tx_packets = node->stats.tx_packets;
1289 		sinfo->tx_failed = node->stats.tx_failed;
1290 
1291 		mwifiex_parse_htinfo(priv, node->stats.last_tx_htinfo,
1292 				     &sinfo->txrate);
1293 		sinfo->txrate.legacy = node->stats.last_tx_rate * 5;
1294 
1295 		return 0;
1296 	}
1297 
1298 	/* Get signal information from the firmware */
1299 	if (mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO,
1300 			     HostCmd_ACT_GEN_GET, 0, NULL, true)) {
1301 		mwifiex_dbg(priv->adapter, ERROR,
1302 			    "failed to get signal information\n");
1303 		return -EFAULT;
1304 	}
1305 
1306 	if (mwifiex_drv_get_data_rate(priv, &rate)) {
1307 		mwifiex_dbg(priv->adapter, ERROR,
1308 			    "getting data rate error\n");
1309 		return -EFAULT;
1310 	}
1311 
1312 	/* Get DTIM period information from firmware */
1313 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
1314 			 HostCmd_ACT_GEN_GET, DTIM_PERIOD_I,
1315 			 &priv->dtim_period, true);
1316 
1317 	mwifiex_parse_htinfo(priv, priv->tx_htinfo, &sinfo->txrate);
1318 
1319 	sinfo->signal_avg = priv->bcn_rssi_avg;
1320 	sinfo->rx_bytes = priv->stats.rx_bytes;
1321 	sinfo->tx_bytes = priv->stats.tx_bytes;
1322 	sinfo->rx_packets = priv->stats.rx_packets;
1323 	sinfo->tx_packets = priv->stats.tx_packets;
1324 	sinfo->signal = priv->bcn_rssi_avg;
1325 	/* bit rate is in 500 kb/s units. Convert it to 100kb/s units */
1326 	sinfo->txrate.legacy = rate * 5;
1327 
1328 	if (priv->bss_mode == NL80211_IFTYPE_STATION) {
1329 		sinfo->filled |= BIT(NL80211_STA_INFO_BSS_PARAM);
1330 		sinfo->bss_param.flags = 0;
1331 		if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
1332 						WLAN_CAPABILITY_SHORT_PREAMBLE)
1333 			sinfo->bss_param.flags |=
1334 					BSS_PARAM_FLAGS_SHORT_PREAMBLE;
1335 		if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
1336 						WLAN_CAPABILITY_SHORT_SLOT_TIME)
1337 			sinfo->bss_param.flags |=
1338 					BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
1339 		sinfo->bss_param.dtim_period = priv->dtim_period;
1340 		sinfo->bss_param.beacon_interval =
1341 			priv->curr_bss_params.bss_descriptor.beacon_period;
1342 	}
1343 
1344 	return 0;
1345 }
1346 
1347 /*
1348  * CFG802.11 operation handler to get station information.
1349  *
1350  * This function only works in connected mode, and dumps the
1351  * requested station information, if available.
1352  */
1353 static int
mwifiex_cfg80211_get_station(struct wiphy * wiphy,struct net_device * dev,const u8 * mac,struct station_info * sinfo)1354 mwifiex_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1355 			     const u8 *mac, struct station_info *sinfo)
1356 {
1357 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1358 
1359 	if (!priv->media_connected)
1360 		return -ENOENT;
1361 	if (memcmp(mac, priv->cfg_bssid, ETH_ALEN))
1362 		return -ENOENT;
1363 
1364 	return mwifiex_dump_station_info(priv, NULL, sinfo);
1365 }
1366 
1367 /*
1368  * CFG802.11 operation handler to dump station information.
1369  */
1370 static int
mwifiex_cfg80211_dump_station(struct wiphy * wiphy,struct net_device * dev,int idx,u8 * mac,struct station_info * sinfo)1371 mwifiex_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
1372 			      int idx, u8 *mac, struct station_info *sinfo)
1373 {
1374 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1375 	static struct mwifiex_sta_node *node;
1376 
1377 	if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
1378 	    priv->media_connected && idx == 0) {
1379 		ether_addr_copy(mac, priv->cfg_bssid);
1380 		return mwifiex_dump_station_info(priv, NULL, sinfo);
1381 	} else if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1382 		mwifiex_send_cmd(priv, HOST_CMD_APCMD_STA_LIST,
1383 				 HostCmd_ACT_GEN_GET, 0, NULL, true);
1384 
1385 		if (node && (&node->list == &priv->sta_list)) {
1386 			node = NULL;
1387 			return -ENOENT;
1388 		}
1389 
1390 		node = list_prepare_entry(node, &priv->sta_list, list);
1391 		list_for_each_entry_continue(node, &priv->sta_list, list) {
1392 			ether_addr_copy(mac, node->mac_addr);
1393 			return mwifiex_dump_station_info(priv, node, sinfo);
1394 		}
1395 	}
1396 
1397 	return -ENOENT;
1398 }
1399 
1400 static int
mwifiex_cfg80211_dump_survey(struct wiphy * wiphy,struct net_device * dev,int idx,struct survey_info * survey)1401 mwifiex_cfg80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
1402 			     int idx, struct survey_info *survey)
1403 {
1404 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1405 	struct mwifiex_chan_stats *pchan_stats = priv->adapter->chan_stats;
1406 	enum ieee80211_band band;
1407 
1408 	mwifiex_dbg(priv->adapter, DUMP, "dump_survey idx=%d\n", idx);
1409 
1410 	memset(survey, 0, sizeof(struct survey_info));
1411 
1412 	if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
1413 	    priv->media_connected && idx == 0) {
1414 			u8 curr_bss_band = priv->curr_bss_params.band;
1415 			u32 chan = priv->curr_bss_params.bss_descriptor.channel;
1416 
1417 			band = mwifiex_band_to_radio_type(curr_bss_band);
1418 			survey->channel = ieee80211_get_channel(wiphy,
1419 				ieee80211_channel_to_frequency(chan, band));
1420 
1421 			if (priv->bcn_nf_last) {
1422 				survey->filled = SURVEY_INFO_NOISE_DBM;
1423 				survey->noise = priv->bcn_nf_last;
1424 			}
1425 			return 0;
1426 	}
1427 
1428 	if (idx >= priv->adapter->num_in_chan_stats)
1429 		return -ENOENT;
1430 
1431 	if (!pchan_stats[idx].cca_scan_dur)
1432 		return 0;
1433 
1434 	band = pchan_stats[idx].bandcfg;
1435 	survey->channel = ieee80211_get_channel(wiphy,
1436 	    ieee80211_channel_to_frequency(pchan_stats[idx].chan_num, band));
1437 	survey->filled = SURVEY_INFO_NOISE_DBM |
1438 			 SURVEY_INFO_TIME |
1439 			 SURVEY_INFO_TIME_BUSY;
1440 	survey->noise = pchan_stats[idx].noise;
1441 	survey->time = pchan_stats[idx].cca_scan_dur;
1442 	survey->time_busy = pchan_stats[idx].cca_busy_dur;
1443 
1444 	return 0;
1445 }
1446 
1447 /* Supported rates to be advertised to the cfg80211 */
1448 static struct ieee80211_rate mwifiex_rates[] = {
1449 	{.bitrate = 10, .hw_value = 2, },
1450 	{.bitrate = 20, .hw_value = 4, },
1451 	{.bitrate = 55, .hw_value = 11, },
1452 	{.bitrate = 110, .hw_value = 22, },
1453 	{.bitrate = 60, .hw_value = 12, },
1454 	{.bitrate = 90, .hw_value = 18, },
1455 	{.bitrate = 120, .hw_value = 24, },
1456 	{.bitrate = 180, .hw_value = 36, },
1457 	{.bitrate = 240, .hw_value = 48, },
1458 	{.bitrate = 360, .hw_value = 72, },
1459 	{.bitrate = 480, .hw_value = 96, },
1460 	{.bitrate = 540, .hw_value = 108, },
1461 };
1462 
1463 /* Channel definitions to be advertised to cfg80211 */
1464 static struct ieee80211_channel mwifiex_channels_2ghz[] = {
1465 	{.center_freq = 2412, .hw_value = 1, },
1466 	{.center_freq = 2417, .hw_value = 2, },
1467 	{.center_freq = 2422, .hw_value = 3, },
1468 	{.center_freq = 2427, .hw_value = 4, },
1469 	{.center_freq = 2432, .hw_value = 5, },
1470 	{.center_freq = 2437, .hw_value = 6, },
1471 	{.center_freq = 2442, .hw_value = 7, },
1472 	{.center_freq = 2447, .hw_value = 8, },
1473 	{.center_freq = 2452, .hw_value = 9, },
1474 	{.center_freq = 2457, .hw_value = 10, },
1475 	{.center_freq = 2462, .hw_value = 11, },
1476 	{.center_freq = 2467, .hw_value = 12, },
1477 	{.center_freq = 2472, .hw_value = 13, },
1478 	{.center_freq = 2484, .hw_value = 14, },
1479 };
1480 
1481 static struct ieee80211_supported_band mwifiex_band_2ghz = {
1482 	.channels = mwifiex_channels_2ghz,
1483 	.n_channels = ARRAY_SIZE(mwifiex_channels_2ghz),
1484 	.bitrates = mwifiex_rates,
1485 	.n_bitrates = ARRAY_SIZE(mwifiex_rates),
1486 };
1487 
1488 static struct ieee80211_channel mwifiex_channels_5ghz[] = {
1489 	{.center_freq = 5040, .hw_value = 8, },
1490 	{.center_freq = 5060, .hw_value = 12, },
1491 	{.center_freq = 5080, .hw_value = 16, },
1492 	{.center_freq = 5170, .hw_value = 34, },
1493 	{.center_freq = 5190, .hw_value = 38, },
1494 	{.center_freq = 5210, .hw_value = 42, },
1495 	{.center_freq = 5230, .hw_value = 46, },
1496 	{.center_freq = 5180, .hw_value = 36, },
1497 	{.center_freq = 5200, .hw_value = 40, },
1498 	{.center_freq = 5220, .hw_value = 44, },
1499 	{.center_freq = 5240, .hw_value = 48, },
1500 	{.center_freq = 5260, .hw_value = 52, },
1501 	{.center_freq = 5280, .hw_value = 56, },
1502 	{.center_freq = 5300, .hw_value = 60, },
1503 	{.center_freq = 5320, .hw_value = 64, },
1504 	{.center_freq = 5500, .hw_value = 100, },
1505 	{.center_freq = 5520, .hw_value = 104, },
1506 	{.center_freq = 5540, .hw_value = 108, },
1507 	{.center_freq = 5560, .hw_value = 112, },
1508 	{.center_freq = 5580, .hw_value = 116, },
1509 	{.center_freq = 5600, .hw_value = 120, },
1510 	{.center_freq = 5620, .hw_value = 124, },
1511 	{.center_freq = 5640, .hw_value = 128, },
1512 	{.center_freq = 5660, .hw_value = 132, },
1513 	{.center_freq = 5680, .hw_value = 136, },
1514 	{.center_freq = 5700, .hw_value = 140, },
1515 	{.center_freq = 5745, .hw_value = 149, },
1516 	{.center_freq = 5765, .hw_value = 153, },
1517 	{.center_freq = 5785, .hw_value = 157, },
1518 	{.center_freq = 5805, .hw_value = 161, },
1519 	{.center_freq = 5825, .hw_value = 165, },
1520 };
1521 
1522 static struct ieee80211_supported_band mwifiex_band_5ghz = {
1523 	.channels = mwifiex_channels_5ghz,
1524 	.n_channels = ARRAY_SIZE(mwifiex_channels_5ghz),
1525 	.bitrates = mwifiex_rates + 4,
1526 	.n_bitrates = ARRAY_SIZE(mwifiex_rates) - 4,
1527 };
1528 
1529 
1530 /* Supported crypto cipher suits to be advertised to cfg80211 */
1531 static const u32 mwifiex_cipher_suites[] = {
1532 	WLAN_CIPHER_SUITE_WEP40,
1533 	WLAN_CIPHER_SUITE_WEP104,
1534 	WLAN_CIPHER_SUITE_TKIP,
1535 	WLAN_CIPHER_SUITE_CCMP,
1536 	WLAN_CIPHER_SUITE_AES_CMAC,
1537 };
1538 
1539 /* Supported mgmt frame types to be advertised to cfg80211 */
1540 static const struct ieee80211_txrx_stypes
1541 mwifiex_mgmt_stypes[NUM_NL80211_IFTYPES] = {
1542 	[NL80211_IFTYPE_STATION] = {
1543 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1544 		      BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1545 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1546 		      BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1547 	},
1548 	[NL80211_IFTYPE_AP] = {
1549 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1550 		      BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1551 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1552 		      BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1553 	},
1554 	[NL80211_IFTYPE_P2P_CLIENT] = {
1555 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1556 		      BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1557 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1558 		      BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1559 	},
1560 	[NL80211_IFTYPE_P2P_GO] = {
1561 		.tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1562 		      BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1563 		.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1564 		      BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1565 	},
1566 };
1567 
1568 /*
1569  * CFG802.11 operation handler for setting bit rates.
1570  *
1571  * Function configures data rates to firmware using bitrate mask
1572  * provided by cfg80211.
1573  */
mwifiex_cfg80211_set_bitrate_mask(struct wiphy * wiphy,struct net_device * dev,const u8 * peer,const struct cfg80211_bitrate_mask * mask)1574 static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
1575 				struct net_device *dev,
1576 				const u8 *peer,
1577 				const struct cfg80211_bitrate_mask *mask)
1578 {
1579 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1580 	u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
1581 	enum ieee80211_band band;
1582 	struct mwifiex_adapter *adapter = priv->adapter;
1583 
1584 	if (!priv->media_connected) {
1585 		mwifiex_dbg(adapter, ERROR,
1586 			    "Can not set Tx data rate in disconnected state\n");
1587 		return -EINVAL;
1588 	}
1589 
1590 	band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
1591 
1592 	memset(bitmap_rates, 0, sizeof(bitmap_rates));
1593 
1594 	/* Fill HR/DSSS rates. */
1595 	if (band == IEEE80211_BAND_2GHZ)
1596 		bitmap_rates[0] = mask->control[band].legacy & 0x000f;
1597 
1598 	/* Fill OFDM rates */
1599 	if (band == IEEE80211_BAND_2GHZ)
1600 		bitmap_rates[1] = (mask->control[band].legacy & 0x0ff0) >> 4;
1601 	else
1602 		bitmap_rates[1] = mask->control[band].legacy;
1603 
1604 	/* Fill HT MCS rates */
1605 	bitmap_rates[2] = mask->control[band].ht_mcs[0];
1606 	if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1607 		bitmap_rates[2] |= mask->control[band].ht_mcs[1] << 8;
1608 
1609        /* Fill VHT MCS rates */
1610 	if (adapter->fw_api_ver == MWIFIEX_FW_V15) {
1611 		bitmap_rates[10] = mask->control[band].vht_mcs[0];
1612 		if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1613 			bitmap_rates[11] = mask->control[band].vht_mcs[1];
1614 	}
1615 
1616 	return mwifiex_send_cmd(priv, HostCmd_CMD_TX_RATE_CFG,
1617 				HostCmd_ACT_GEN_SET, 0, bitmap_rates, true);
1618 }
1619 
1620 /*
1621  * CFG802.11 operation handler for connection quality monitoring.
1622  *
1623  * This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI
1624  * events to FW.
1625  */
mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy * wiphy,struct net_device * dev,s32 rssi_thold,u32 rssi_hyst)1626 static int mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy *wiphy,
1627 						struct net_device *dev,
1628 						s32 rssi_thold, u32 rssi_hyst)
1629 {
1630 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1631 	struct mwifiex_ds_misc_subsc_evt subsc_evt;
1632 
1633 	priv->cqm_rssi_thold = rssi_thold;
1634 	priv->cqm_rssi_hyst = rssi_hyst;
1635 
1636 	memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
1637 	subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
1638 
1639 	/* Subscribe/unsubscribe low and high rssi events */
1640 	if (rssi_thold && rssi_hyst) {
1641 		subsc_evt.action = HostCmd_ACT_BITWISE_SET;
1642 		subsc_evt.bcn_l_rssi_cfg.abs_value = abs(rssi_thold);
1643 		subsc_evt.bcn_h_rssi_cfg.abs_value = abs(rssi_thold);
1644 		subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
1645 		subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
1646 		return mwifiex_send_cmd(priv,
1647 					HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1648 					0, 0, &subsc_evt, true);
1649 	} else {
1650 		subsc_evt.action = HostCmd_ACT_BITWISE_CLR;
1651 		return mwifiex_send_cmd(priv,
1652 					HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1653 					0, 0, &subsc_evt, true);
1654 	}
1655 
1656 	return 0;
1657 }
1658 
1659 /* cfg80211 operation handler for change_beacon.
1660  * Function retrieves and sets modified management IEs to FW.
1661  */
mwifiex_cfg80211_change_beacon(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_beacon_data * data)1662 static int mwifiex_cfg80211_change_beacon(struct wiphy *wiphy,
1663 					  struct net_device *dev,
1664 					  struct cfg80211_beacon_data *data)
1665 {
1666 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1667 
1668 	if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP) {
1669 		mwifiex_dbg(priv->adapter, ERROR,
1670 			    "%s: bss_type mismatched\n", __func__);
1671 		return -EINVAL;
1672 	}
1673 
1674 	if (!priv->bss_started) {
1675 		mwifiex_dbg(priv->adapter, ERROR,
1676 			    "%s: bss not started\n", __func__);
1677 		return -EINVAL;
1678 	}
1679 
1680 	if (mwifiex_set_mgmt_ies(priv, data)) {
1681 		mwifiex_dbg(priv->adapter, ERROR,
1682 			    "%s: setting mgmt ies failed\n", __func__);
1683 		return -EFAULT;
1684 	}
1685 
1686 	return 0;
1687 }
1688 
1689 /* cfg80211 operation handler for del_station.
1690  * Function deauthenticates station which value is provided in mac parameter.
1691  * If mac is NULL/broadcast, all stations in associated station list are
1692  * deauthenticated. If bss is not started or there are no stations in
1693  * associated stations list, no action is taken.
1694  */
1695 static int
mwifiex_cfg80211_del_station(struct wiphy * wiphy,struct net_device * dev,struct station_del_parameters * params)1696 mwifiex_cfg80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1697 			     struct station_del_parameters *params)
1698 {
1699 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1700 	struct mwifiex_sta_node *sta_node;
1701 	u8 deauth_mac[ETH_ALEN];
1702 	unsigned long flags;
1703 
1704 	if (list_empty(&priv->sta_list) || !priv->bss_started)
1705 		return 0;
1706 
1707 	if (!params->mac || is_broadcast_ether_addr(params->mac))
1708 		return 0;
1709 
1710 	mwifiex_dbg(priv->adapter, INFO, "%s: mac address %pM\n",
1711 		    __func__, params->mac);
1712 
1713 	eth_zero_addr(deauth_mac);
1714 
1715 	spin_lock_irqsave(&priv->sta_list_spinlock, flags);
1716 	sta_node = mwifiex_get_sta_entry(priv, params->mac);
1717 	if (sta_node)
1718 		ether_addr_copy(deauth_mac, params->mac);
1719 	spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
1720 
1721 	if (is_valid_ether_addr(deauth_mac)) {
1722 		if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_STA_DEAUTH,
1723 				     HostCmd_ACT_GEN_SET, 0,
1724 				     deauth_mac, true))
1725 			return -1;
1726 	}
1727 
1728 	return 0;
1729 }
1730 
1731 static int
mwifiex_cfg80211_set_antenna(struct wiphy * wiphy,u32 tx_ant,u32 rx_ant)1732 mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
1733 {
1734 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1735 	struct mwifiex_private *priv = mwifiex_get_priv(adapter,
1736 							MWIFIEX_BSS_ROLE_ANY);
1737 	struct mwifiex_ds_ant_cfg ant_cfg;
1738 
1739 	if (!tx_ant || !rx_ant)
1740 		return -EOPNOTSUPP;
1741 
1742 	if (adapter->hw_dev_mcs_support != HT_STREAM_2X2) {
1743 		/* Not a MIMO chip. User should provide specific antenna number
1744 		 * for Tx/Rx path or enable all antennas for diversity
1745 		 */
1746 		if (tx_ant != rx_ant)
1747 			return -EOPNOTSUPP;
1748 
1749 		if ((tx_ant & (tx_ant - 1)) &&
1750 		    (tx_ant != BIT(adapter->number_of_antenna) - 1))
1751 			return -EOPNOTSUPP;
1752 
1753 		if ((tx_ant == BIT(adapter->number_of_antenna) - 1) &&
1754 		    (priv->adapter->number_of_antenna > 1)) {
1755 			tx_ant = RF_ANTENNA_AUTO;
1756 			rx_ant = RF_ANTENNA_AUTO;
1757 		}
1758 	} else {
1759 		struct ieee80211_sta_ht_cap *ht_info;
1760 		int rx_mcs_supp;
1761 		enum ieee80211_band band;
1762 
1763 		if ((tx_ant == 0x1 && rx_ant == 0x1)) {
1764 			adapter->user_dev_mcs_support = HT_STREAM_1X1;
1765 			if (adapter->is_hw_11ac_capable)
1766 				adapter->usr_dot_11ac_mcs_support =
1767 						MWIFIEX_11AC_MCS_MAP_1X1;
1768 		} else {
1769 			adapter->user_dev_mcs_support = HT_STREAM_2X2;
1770 			if (adapter->is_hw_11ac_capable)
1771 				adapter->usr_dot_11ac_mcs_support =
1772 						MWIFIEX_11AC_MCS_MAP_2X2;
1773 		}
1774 
1775 		for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1776 			if (!adapter->wiphy->bands[band])
1777 				continue;
1778 
1779 			ht_info = &adapter->wiphy->bands[band]->ht_cap;
1780 			rx_mcs_supp =
1781 				GET_RXMCSSUPP(adapter->user_dev_mcs_support);
1782 			memset(&ht_info->mcs, 0, adapter->number_of_antenna);
1783 			memset(&ht_info->mcs, 0xff, rx_mcs_supp);
1784 		}
1785 	}
1786 
1787 	ant_cfg.tx_ant = tx_ant;
1788 	ant_cfg.rx_ant = rx_ant;
1789 
1790 	return mwifiex_send_cmd(priv, HostCmd_CMD_RF_ANTENNA,
1791 				HostCmd_ACT_GEN_SET, 0, &ant_cfg, true);
1792 }
1793 
1794 /* cfg80211 operation handler for stop ap.
1795  * Function stops BSS running at uAP interface.
1796  */
mwifiex_cfg80211_stop_ap(struct wiphy * wiphy,struct net_device * dev)1797 static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1798 {
1799 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1800 
1801 	mwifiex_abort_cac(priv);
1802 
1803 	if (mwifiex_del_mgmt_ies(priv))
1804 		mwifiex_dbg(priv->adapter, ERROR,
1805 			    "Failed to delete mgmt IEs!\n");
1806 
1807 	priv->ap_11n_enabled = 0;
1808 	memset(&priv->bss_cfg, 0, sizeof(priv->bss_cfg));
1809 
1810 	if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_STOP,
1811 			     HostCmd_ACT_GEN_SET, 0, NULL, true)) {
1812 		mwifiex_dbg(priv->adapter, ERROR,
1813 			    "Failed to stop the BSS\n");
1814 		return -1;
1815 	}
1816 
1817 	if (mwifiex_send_cmd(priv, HOST_CMD_APCMD_SYS_RESET,
1818 			     HostCmd_ACT_GEN_SET, 0, NULL, true)) {
1819 		mwifiex_dbg(priv->adapter, ERROR,
1820 			    "Failed to reset BSS\n");
1821 		return -1;
1822 	}
1823 
1824 	if (netif_carrier_ok(priv->netdev))
1825 		netif_carrier_off(priv->netdev);
1826 	mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
1827 
1828 	return 0;
1829 }
1830 
1831 /* cfg80211 operation handler for start_ap.
1832  * Function sets beacon period, DTIM period, SSID and security into
1833  * AP config structure.
1834  * AP is configured with these settings and BSS is started.
1835  */
mwifiex_cfg80211_start_ap(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_ap_settings * params)1836 static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
1837 				     struct net_device *dev,
1838 				     struct cfg80211_ap_settings *params)
1839 {
1840 	struct mwifiex_uap_bss_param *bss_cfg;
1841 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1842 
1843 	if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
1844 		return -1;
1845 
1846 	bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
1847 	if (!bss_cfg)
1848 		return -ENOMEM;
1849 
1850 	mwifiex_set_sys_config_invalid_data(bss_cfg);
1851 
1852 	if (params->beacon_interval)
1853 		bss_cfg->beacon_period = params->beacon_interval;
1854 	if (params->dtim_period)
1855 		bss_cfg->dtim_period = params->dtim_period;
1856 
1857 	if (params->ssid && params->ssid_len) {
1858 		memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
1859 		bss_cfg->ssid.ssid_len = params->ssid_len;
1860 	}
1861 	if (params->inactivity_timeout > 0) {
1862 		/* sta_ao_timer/ps_sta_ao_timer is in unit of 100ms */
1863 		bss_cfg->sta_ao_timer = 10 * params->inactivity_timeout;
1864 		bss_cfg->ps_sta_ao_timer = 10 * params->inactivity_timeout;
1865 	}
1866 
1867 	switch (params->hidden_ssid) {
1868 	case NL80211_HIDDEN_SSID_NOT_IN_USE:
1869 		bss_cfg->bcast_ssid_ctl = 1;
1870 		break;
1871 	case NL80211_HIDDEN_SSID_ZERO_LEN:
1872 		bss_cfg->bcast_ssid_ctl = 0;
1873 		break;
1874 	case NL80211_HIDDEN_SSID_ZERO_CONTENTS:
1875 		/* firmware doesn't support this type of hidden SSID */
1876 	default:
1877 		kfree(bss_cfg);
1878 		return -EINVAL;
1879 	}
1880 
1881 	mwifiex_uap_set_channel(priv, bss_cfg, params->chandef);
1882 	mwifiex_set_uap_rates(bss_cfg, params);
1883 
1884 	if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
1885 		kfree(bss_cfg);
1886 		mwifiex_dbg(priv->adapter, ERROR,
1887 			    "Failed to parse secuirty parameters!\n");
1888 		return -1;
1889 	}
1890 
1891 	mwifiex_set_ht_params(priv, bss_cfg, params);
1892 
1893 	if (priv->adapter->is_hw_11ac_capable) {
1894 		mwifiex_set_vht_params(priv, bss_cfg, params);
1895 		mwifiex_set_vht_width(priv, params->chandef.width,
1896 				      priv->ap_11ac_enabled);
1897 	}
1898 
1899 	if (priv->ap_11ac_enabled)
1900 		mwifiex_set_11ac_ba_params(priv);
1901 	else
1902 		mwifiex_set_ba_params(priv);
1903 
1904 	mwifiex_set_wmm_params(priv, bss_cfg, params);
1905 
1906 	if (mwifiex_is_11h_active(priv))
1907 		mwifiex_set_tpc_params(priv, bss_cfg, params);
1908 
1909 	if (mwifiex_is_11h_active(priv) &&
1910 	    !cfg80211_chandef_dfs_required(wiphy, &params->chandef,
1911 					   priv->bss_mode)) {
1912 		mwifiex_dbg(priv->adapter, INFO,
1913 			    "Disable 11h extensions in FW\n");
1914 		if (mwifiex_11h_activate(priv, false)) {
1915 			mwifiex_dbg(priv->adapter, ERROR,
1916 				    "Failed to disable 11h extensions!!");
1917 			return -1;
1918 		}
1919 		priv->state_11h.is_11h_active = false;
1920 	}
1921 
1922 	if (mwifiex_config_start_uap(priv, bss_cfg)) {
1923 		mwifiex_dbg(priv->adapter, ERROR,
1924 			    "Failed to start AP\n");
1925 		kfree(bss_cfg);
1926 		return -1;
1927 	}
1928 
1929 	if (mwifiex_set_mgmt_ies(priv, &params->beacon))
1930 		return -1;
1931 
1932 	if (!netif_carrier_ok(priv->netdev))
1933 		netif_carrier_on(priv->netdev);
1934 	mwifiex_wake_up_net_dev_queue(priv->netdev, priv->adapter);
1935 
1936 	memcpy(&priv->bss_cfg, bss_cfg, sizeof(priv->bss_cfg));
1937 	kfree(bss_cfg);
1938 	return 0;
1939 }
1940 
1941 /*
1942  * CFG802.11 operation handler for disconnection request.
1943  *
1944  * This function does not work when there is already a disconnection
1945  * procedure going on.
1946  */
1947 static int
mwifiex_cfg80211_disconnect(struct wiphy * wiphy,struct net_device * dev,u16 reason_code)1948 mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1949 			    u16 reason_code)
1950 {
1951 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1952 
1953 	if (mwifiex_deauthenticate(priv, NULL))
1954 		return -EFAULT;
1955 
1956 	mwifiex_dbg(priv->adapter, MSG,
1957 		    "info: successfully disconnected from %pM:\t"
1958 		    "reason code %d\n", priv->cfg_bssid, reason_code);
1959 
1960 	eth_zero_addr(priv->cfg_bssid);
1961 	priv->hs2_enabled = false;
1962 
1963 	return 0;
1964 }
1965 
1966 /*
1967  * This function informs the CFG802.11 subsystem of a new IBSS.
1968  *
1969  * The following information are sent to the CFG802.11 subsystem
1970  * to register the new IBSS. If we do not register the new IBSS,
1971  * a kernel panic will result.
1972  *      - SSID
1973  *      - SSID length
1974  *      - BSSID
1975  *      - Channel
1976  */
mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private * priv)1977 static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
1978 {
1979 	struct ieee80211_channel *chan;
1980 	struct mwifiex_bss_info bss_info;
1981 	struct cfg80211_bss *bss;
1982 	int ie_len;
1983 	u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
1984 	enum ieee80211_band band;
1985 
1986 	if (mwifiex_get_bss_info(priv, &bss_info))
1987 		return -1;
1988 
1989 	ie_buf[0] = WLAN_EID_SSID;
1990 	ie_buf[1] = bss_info.ssid.ssid_len;
1991 
1992 	memcpy(&ie_buf[sizeof(struct ieee_types_header)],
1993 	       &bss_info.ssid.ssid, bss_info.ssid.ssid_len);
1994 	ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
1995 
1996 	band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
1997 	chan = __ieee80211_get_channel(priv->wdev.wiphy,
1998 			ieee80211_channel_to_frequency(bss_info.bss_chan,
1999 						       band));
2000 
2001 	bss = cfg80211_inform_bss(priv->wdev.wiphy, chan,
2002 				  CFG80211_BSS_FTYPE_UNKNOWN,
2003 				  bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
2004 				  0, ie_buf, ie_len, 0, GFP_KERNEL);
2005 	if (bss) {
2006 		cfg80211_put_bss(priv->wdev.wiphy, bss);
2007 		ether_addr_copy(priv->cfg_bssid, bss_info.bssid);
2008 	}
2009 
2010 	return 0;
2011 }
2012 
2013 /*
2014  * This function connects with a BSS.
2015  *
2016  * This function handles both Infra and Ad-Hoc modes. It also performs
2017  * validity checking on the provided parameters, disconnects from the
2018  * current BSS (if any), sets up the association/scan parameters,
2019  * including security settings, and performs specific SSID scan before
2020  * trying to connect.
2021  *
2022  * For Infra mode, the function returns failure if the specified SSID
2023  * is not found in scan table. However, for Ad-Hoc mode, it can create
2024  * the IBSS if it does not exist. On successful completion in either case,
2025  * the function notifies the CFG802.11 subsystem of the new BSS connection.
2026  */
2027 static int
mwifiex_cfg80211_assoc(struct mwifiex_private * priv,size_t ssid_len,const u8 * ssid,const u8 * bssid,int mode,struct ieee80211_channel * channel,struct cfg80211_connect_params * sme,bool privacy)2028 mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len,
2029 		       const u8 *ssid, const u8 *bssid, int mode,
2030 		       struct ieee80211_channel *channel,
2031 		       struct cfg80211_connect_params *sme, bool privacy)
2032 {
2033 	struct cfg80211_ssid req_ssid;
2034 	int ret, auth_type = 0;
2035 	struct cfg80211_bss *bss = NULL;
2036 	u8 is_scanning_required = 0;
2037 
2038 	memset(&req_ssid, 0, sizeof(struct cfg80211_ssid));
2039 
2040 	req_ssid.ssid_len = ssid_len;
2041 	if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2042 		mwifiex_dbg(priv->adapter, ERROR, "invalid SSID - aborting\n");
2043 		return -EINVAL;
2044 	}
2045 
2046 	memcpy(req_ssid.ssid, ssid, ssid_len);
2047 	if (!req_ssid.ssid_len || req_ssid.ssid[0] < 0x20) {
2048 		mwifiex_dbg(priv->adapter, ERROR, "invalid SSID - aborting\n");
2049 		return -EINVAL;
2050 	}
2051 
2052 	/* As this is new association, clear locally stored
2053 	 * keys and security related flags */
2054 	priv->sec_info.wpa_enabled = false;
2055 	priv->sec_info.wpa2_enabled = false;
2056 	priv->wep_key_curr_index = 0;
2057 	priv->sec_info.encryption_mode = 0;
2058 	priv->sec_info.is_authtype_auto = 0;
2059 	ret = mwifiex_set_encode(priv, NULL, NULL, 0, 0, NULL, 1);
2060 
2061 	if (mode == NL80211_IFTYPE_ADHOC) {
2062 		/* "privacy" is set only for ad-hoc mode */
2063 		if (privacy) {
2064 			/*
2065 			 * Keep WLAN_CIPHER_SUITE_WEP104 for now so that
2066 			 * the firmware can find a matching network from the
2067 			 * scan. The cfg80211 does not give us the encryption
2068 			 * mode at this stage so just setting it to WEP here.
2069 			 */
2070 			priv->sec_info.encryption_mode =
2071 					WLAN_CIPHER_SUITE_WEP104;
2072 			priv->sec_info.authentication_mode =
2073 					NL80211_AUTHTYPE_OPEN_SYSTEM;
2074 		}
2075 
2076 		goto done;
2077 	}
2078 
2079 	/* Now handle infra mode. "sme" is valid for infra mode only */
2080 	if (sme->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
2081 		auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
2082 		priv->sec_info.is_authtype_auto = 1;
2083 	} else {
2084 		auth_type = sme->auth_type;
2085 	}
2086 
2087 	if (sme->crypto.n_ciphers_pairwise) {
2088 		priv->sec_info.encryption_mode =
2089 						sme->crypto.ciphers_pairwise[0];
2090 		priv->sec_info.authentication_mode = auth_type;
2091 	}
2092 
2093 	if (sme->crypto.cipher_group) {
2094 		priv->sec_info.encryption_mode = sme->crypto.cipher_group;
2095 		priv->sec_info.authentication_mode = auth_type;
2096 	}
2097 	if (sme->ie)
2098 		ret = mwifiex_set_gen_ie(priv, sme->ie, sme->ie_len);
2099 
2100 	if (sme->key) {
2101 		if (mwifiex_is_alg_wep(priv->sec_info.encryption_mode)) {
2102 			mwifiex_dbg(priv->adapter, INFO,
2103 				    "info: setting wep encryption\t"
2104 				    "with key len %d\n", sme->key_len);
2105 			priv->wep_key_curr_index = sme->key_idx;
2106 			ret = mwifiex_set_encode(priv, NULL, sme->key,
2107 						 sme->key_len, sme->key_idx,
2108 						 NULL, 0);
2109 		}
2110 	}
2111 done:
2112 	/*
2113 	 * Scan entries are valid for some time (15 sec). So we can save one
2114 	 * active scan time if we just try cfg80211_get_bss first. If it fails
2115 	 * then request scan and cfg80211_get_bss() again for final output.
2116 	 */
2117 	while (1) {
2118 		if (is_scanning_required) {
2119 			/* Do specific SSID scanning */
2120 			if (mwifiex_request_scan(priv, &req_ssid)) {
2121 				mwifiex_dbg(priv->adapter, ERROR, "scan error\n");
2122 				return -EFAULT;
2123 			}
2124 		}
2125 
2126 		/* Find the BSS we want using available scan results */
2127 		if (mode == NL80211_IFTYPE_ADHOC)
2128 			bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
2129 					       bssid, ssid, ssid_len,
2130 					       IEEE80211_BSS_TYPE_IBSS,
2131 					       IEEE80211_PRIVACY_ANY);
2132 		else
2133 			bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
2134 					       bssid, ssid, ssid_len,
2135 					       IEEE80211_BSS_TYPE_ESS,
2136 					       IEEE80211_PRIVACY_ANY);
2137 
2138 		if (!bss) {
2139 			if (is_scanning_required) {
2140 				mwifiex_dbg(priv->adapter, WARN,
2141 					    "assoc: requested bss not found in scan results\n");
2142 				break;
2143 			}
2144 			is_scanning_required = 1;
2145 		} else {
2146 			mwifiex_dbg(priv->adapter, MSG,
2147 				    "info: trying to associate to '%s' bssid %pM\n",
2148 				    (char *)req_ssid.ssid, bss->bssid);
2149 			memcpy(&priv->cfg_bssid, bss->bssid, ETH_ALEN);
2150 			break;
2151 		}
2152 	}
2153 
2154 	ret = mwifiex_bss_start(priv, bss, &req_ssid);
2155 	if (ret)
2156 		return ret;
2157 
2158 	if (mode == NL80211_IFTYPE_ADHOC) {
2159 		/* Inform the BSS information to kernel, otherwise
2160 		 * kernel will give a panic after successful assoc */
2161 		if (mwifiex_cfg80211_inform_ibss_bss(priv))
2162 			return -EFAULT;
2163 	}
2164 
2165 	return ret;
2166 }
2167 
2168 /*
2169  * CFG802.11 operation handler for association request.
2170  *
2171  * This function does not work when the current mode is set to Ad-Hoc, or
2172  * when there is already an association procedure going on. The given BSS
2173  * information is used to associate.
2174  */
2175 static int
mwifiex_cfg80211_connect(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_connect_params * sme)2176 mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
2177 			 struct cfg80211_connect_params *sme)
2178 {
2179 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2180 	struct mwifiex_adapter *adapter = priv->adapter;
2181 	int ret;
2182 
2183 	if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA) {
2184 		mwifiex_dbg(adapter, ERROR,
2185 			    "%s: reject infra assoc request in non-STA role\n",
2186 			    dev->name);
2187 		return -EINVAL;
2188 	}
2189 
2190 	if (priv->wdev.current_bss) {
2191 		mwifiex_dbg(adapter, ERROR,
2192 			    "%s: already connected\n", dev->name);
2193 		return -EALREADY;
2194 	}
2195 
2196 	if (adapter->surprise_removed || adapter->is_cmd_timedout) {
2197 		mwifiex_dbg(adapter, ERROR,
2198 			    "%s: Ignore connection.\t"
2199 			    "Card removed or FW in bad state\n",
2200 			    dev->name);
2201 		return -EFAULT;
2202 	}
2203 
2204 	mwifiex_dbg(adapter, INFO,
2205 		    "info: Trying to associate to %s and bssid %pM\n",
2206 		    (char *)sme->ssid, sme->bssid);
2207 
2208 	ret = mwifiex_cfg80211_assoc(priv, sme->ssid_len, sme->ssid, sme->bssid,
2209 				     priv->bss_mode, sme->channel, sme, 0);
2210 	if (!ret) {
2211 		cfg80211_connect_result(priv->netdev, priv->cfg_bssid, NULL, 0,
2212 					NULL, 0, WLAN_STATUS_SUCCESS,
2213 					GFP_KERNEL);
2214 		mwifiex_dbg(priv->adapter, MSG,
2215 			    "info: associated to bssid %pM successfully\n",
2216 			    priv->cfg_bssid);
2217 		if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
2218 		    priv->adapter->auto_tdls &&
2219 		    priv->bss_type == MWIFIEX_BSS_TYPE_STA)
2220 			mwifiex_setup_auto_tdls_timer(priv);
2221 	} else {
2222 		mwifiex_dbg(priv->adapter, ERROR,
2223 			    "info: association to bssid %pM failed\n",
2224 			    priv->cfg_bssid);
2225 		eth_zero_addr(priv->cfg_bssid);
2226 
2227 		if (ret > 0)
2228 			cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
2229 						NULL, 0, NULL, 0, ret,
2230 						GFP_KERNEL);
2231 		else
2232 			cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
2233 						NULL, 0, NULL, 0,
2234 						WLAN_STATUS_UNSPECIFIED_FAILURE,
2235 						GFP_KERNEL);
2236 	}
2237 
2238 	return 0;
2239 }
2240 
2241 /*
2242  * This function sets following parameters for ibss network.
2243  *  -  channel
2244  *  -  start band
2245  *  -  11n flag
2246  *  -  secondary channel offset
2247  */
mwifiex_set_ibss_params(struct mwifiex_private * priv,struct cfg80211_ibss_params * params)2248 static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
2249 				   struct cfg80211_ibss_params *params)
2250 {
2251 	struct mwifiex_adapter *adapter = priv->adapter;
2252 	int index = 0, i;
2253 	u8 config_bands = 0;
2254 
2255 	if (params->chandef.chan->band == IEEE80211_BAND_2GHZ) {
2256 		if (!params->basic_rates) {
2257 			config_bands = BAND_B | BAND_G;
2258 		} else {
2259 			for (i = 0; i < mwifiex_band_2ghz.n_bitrates; i++) {
2260 				/*
2261 				 * Rates below 6 Mbps in the table are CCK
2262 				 * rates; 802.11b and from 6 they are OFDM;
2263 				 * 802.11G
2264 				 */
2265 				if (mwifiex_rates[i].bitrate == 60) {
2266 					index = 1 << i;
2267 					break;
2268 				}
2269 			}
2270 
2271 			if (params->basic_rates < index) {
2272 				config_bands = BAND_B;
2273 			} else {
2274 				config_bands = BAND_G;
2275 				if (params->basic_rates % index)
2276 					config_bands |= BAND_B;
2277 			}
2278 		}
2279 
2280 		if (cfg80211_get_chandef_type(&params->chandef) !=
2281 						NL80211_CHAN_NO_HT)
2282 			config_bands |= BAND_G | BAND_GN;
2283 	} else {
2284 		if (cfg80211_get_chandef_type(&params->chandef) ==
2285 						NL80211_CHAN_NO_HT)
2286 			config_bands = BAND_A;
2287 		else
2288 			config_bands = BAND_AN | BAND_A;
2289 	}
2290 
2291 	if (!((config_bands | adapter->fw_bands) & ~adapter->fw_bands)) {
2292 		adapter->config_bands = config_bands;
2293 		adapter->adhoc_start_band = config_bands;
2294 
2295 		if ((config_bands & BAND_GN) || (config_bands & BAND_AN))
2296 			adapter->adhoc_11n_enabled = true;
2297 		else
2298 			adapter->adhoc_11n_enabled = false;
2299 	}
2300 
2301 	adapter->sec_chan_offset =
2302 		mwifiex_chan_type_to_sec_chan_offset(
2303 			cfg80211_get_chandef_type(&params->chandef));
2304 	priv->adhoc_channel = ieee80211_frequency_to_channel(
2305 				params->chandef.chan->center_freq);
2306 
2307 	mwifiex_dbg(adapter, INFO,
2308 		    "info: set ibss band %d, chan %d, chan offset %d\n",
2309 		    config_bands, priv->adhoc_channel,
2310 		    adapter->sec_chan_offset);
2311 
2312 	return 0;
2313 }
2314 
2315 /*
2316  * CFG802.11 operation handler to join an IBSS.
2317  *
2318  * This function does not work in any mode other than Ad-Hoc, or if
2319  * a join operation is already in progress.
2320  */
2321 static int
mwifiex_cfg80211_join_ibss(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_ibss_params * params)2322 mwifiex_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
2323 			   struct cfg80211_ibss_params *params)
2324 {
2325 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2326 	int ret = 0;
2327 
2328 	if (priv->bss_mode != NL80211_IFTYPE_ADHOC) {
2329 		mwifiex_dbg(priv->adapter, ERROR,
2330 			    "request to join ibss received\t"
2331 			    "when station is not in ibss mode\n");
2332 		goto done;
2333 	}
2334 
2335 	mwifiex_dbg(priv->adapter, MSG,
2336 		    "info: trying to join to %s and bssid %pM\n",
2337 		    (char *)params->ssid, params->bssid);
2338 
2339 	mwifiex_set_ibss_params(priv, params);
2340 
2341 	ret = mwifiex_cfg80211_assoc(priv, params->ssid_len, params->ssid,
2342 				     params->bssid, priv->bss_mode,
2343 				     params->chandef.chan, NULL,
2344 				     params->privacy);
2345 done:
2346 	if (!ret) {
2347 		cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid,
2348 				     params->chandef.chan, GFP_KERNEL);
2349 		mwifiex_dbg(priv->adapter, MSG,
2350 			    "info: joined/created adhoc network with bssid\t"
2351 			    "%pM successfully\n", priv->cfg_bssid);
2352 	} else {
2353 		mwifiex_dbg(priv->adapter, ERROR,
2354 			    "info: failed creating/joining adhoc network\n");
2355 	}
2356 
2357 	return ret;
2358 }
2359 
2360 /*
2361  * CFG802.11 operation handler to leave an IBSS.
2362  *
2363  * This function does not work if a leave operation is
2364  * already in progress.
2365  */
2366 static int
mwifiex_cfg80211_leave_ibss(struct wiphy * wiphy,struct net_device * dev)2367 mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
2368 {
2369 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2370 
2371 	mwifiex_dbg(priv->adapter, MSG, "info: disconnecting from essid %pM\n",
2372 		    priv->cfg_bssid);
2373 	if (mwifiex_deauthenticate(priv, NULL))
2374 		return -EFAULT;
2375 
2376 	eth_zero_addr(priv->cfg_bssid);
2377 
2378 	return 0;
2379 }
2380 
2381 /*
2382  * CFG802.11 operation handler for scan request.
2383  *
2384  * This function issues a scan request to the firmware based upon
2385  * the user specified scan configuration. On successful completion,
2386  * it also informs the results.
2387  */
2388 static int
mwifiex_cfg80211_scan(struct wiphy * wiphy,struct cfg80211_scan_request * request)2389 mwifiex_cfg80211_scan(struct wiphy *wiphy,
2390 		      struct cfg80211_scan_request *request)
2391 {
2392 	struct net_device *dev = request->wdev->netdev;
2393 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2394 	int i, offset, ret;
2395 	struct ieee80211_channel *chan;
2396 	struct ieee_types_header *ie;
2397 	struct mwifiex_user_scan_cfg *user_scan_cfg;
2398 
2399 	mwifiex_dbg(priv->adapter, CMD,
2400 		    "info: received scan request on %s\n", dev->name);
2401 
2402 	/* Block scan request if scan operation or scan cleanup when interface
2403 	 * is disabled is in process
2404 	 */
2405 	if (priv->scan_request || priv->scan_aborting) {
2406 		mwifiex_dbg(priv->adapter, WARN,
2407 			    "cmd: Scan already in process..\n");
2408 		return -EBUSY;
2409 	}
2410 
2411 	user_scan_cfg = kzalloc(sizeof(*user_scan_cfg), GFP_KERNEL);
2412 	if (!user_scan_cfg)
2413 		return -ENOMEM;
2414 
2415 	priv->scan_request = request;
2416 
2417 	user_scan_cfg->num_ssids = request->n_ssids;
2418 	user_scan_cfg->ssid_list = request->ssids;
2419 
2420 	if (request->ie && request->ie_len) {
2421 		offset = 0;
2422 		for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
2423 			if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
2424 				continue;
2425 			priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_SCAN;
2426 			ie = (struct ieee_types_header *)(request->ie + offset);
2427 			memcpy(&priv->vs_ie[i].ie, ie, sizeof(*ie) + ie->len);
2428 			offset += sizeof(*ie) + ie->len;
2429 
2430 			if (offset >= request->ie_len)
2431 				break;
2432 		}
2433 	}
2434 
2435 	for (i = 0; i < min_t(u32, request->n_channels,
2436 			      MWIFIEX_USER_SCAN_CHAN_MAX); i++) {
2437 		chan = request->channels[i];
2438 		user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
2439 		user_scan_cfg->chan_list[i].radio_type = chan->band;
2440 
2441 		if ((chan->flags & IEEE80211_CHAN_NO_IR) || !request->n_ssids)
2442 			user_scan_cfg->chan_list[i].scan_type =
2443 						MWIFIEX_SCAN_TYPE_PASSIVE;
2444 		else
2445 			user_scan_cfg->chan_list[i].scan_type =
2446 						MWIFIEX_SCAN_TYPE_ACTIVE;
2447 
2448 		user_scan_cfg->chan_list[i].scan_time = 0;
2449 	}
2450 
2451 	if (priv->adapter->scan_chan_gap_enabled &&
2452 	    mwifiex_is_any_intf_active(priv))
2453 		user_scan_cfg->scan_chan_gap =
2454 					      priv->adapter->scan_chan_gap_time;
2455 
2456 	ret = mwifiex_scan_networks(priv, user_scan_cfg);
2457 	kfree(user_scan_cfg);
2458 	if (ret) {
2459 		mwifiex_dbg(priv->adapter, ERROR,
2460 			    "scan failed: %d\n", ret);
2461 		priv->scan_aborting = false;
2462 		priv->scan_request = NULL;
2463 		return ret;
2464 	}
2465 
2466 	if (request->ie && request->ie_len) {
2467 		for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
2468 			if (priv->vs_ie[i].mask == MWIFIEX_VSIE_MASK_SCAN) {
2469 				priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_CLEAR;
2470 				memset(&priv->vs_ie[i].ie, 0,
2471 				       MWIFIEX_MAX_VSIE_LEN);
2472 			}
2473 		}
2474 	}
2475 	return 0;
2476 }
2477 
mwifiex_setup_vht_caps(struct ieee80211_sta_vht_cap * vht_info,struct mwifiex_private * priv)2478 static void mwifiex_setup_vht_caps(struct ieee80211_sta_vht_cap *vht_info,
2479 				   struct mwifiex_private *priv)
2480 {
2481 	struct mwifiex_adapter *adapter = priv->adapter;
2482 
2483 	vht_info->vht_supported = true;
2484 
2485 	vht_info->cap = adapter->hw_dot_11ac_dev_cap;
2486 	/* Update MCS support for VHT */
2487 	vht_info->vht_mcs.rx_mcs_map = cpu_to_le16(
2488 				adapter->hw_dot_11ac_mcs_support & 0xFFFF);
2489 	vht_info->vht_mcs.rx_highest = 0;
2490 	vht_info->vht_mcs.tx_mcs_map = cpu_to_le16(
2491 				adapter->hw_dot_11ac_mcs_support >> 16);
2492 	vht_info->vht_mcs.tx_highest = 0;
2493 }
2494 
2495 /*
2496  * This function sets up the CFG802.11 specific HT capability fields
2497  * with default values.
2498  *
2499  * The following default values are set -
2500  *      - HT Supported = True
2501  *      - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K
2502  *      - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE
2503  *      - HT Capabilities supported by firmware
2504  *      - MCS information, Rx mask = 0xff
2505  *      - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01)
2506  */
2507 static void
mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap * ht_info,struct mwifiex_private * priv)2508 mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
2509 		      struct mwifiex_private *priv)
2510 {
2511 	int rx_mcs_supp;
2512 	struct ieee80211_mcs_info mcs_set;
2513 	u8 *mcs = (u8 *)&mcs_set;
2514 	struct mwifiex_adapter *adapter = priv->adapter;
2515 
2516 	ht_info->ht_supported = true;
2517 	ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
2518 	ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2519 
2520 	memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
2521 
2522 	/* Fill HT capability information */
2523 	if (ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2524 		ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2525 	else
2526 		ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2527 
2528 	if (ISSUPP_SHORTGI20(adapter->hw_dot_11n_dev_cap))
2529 		ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
2530 	else
2531 		ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20;
2532 
2533 	if (ISSUPP_SHORTGI40(adapter->hw_dot_11n_dev_cap))
2534 		ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
2535 	else
2536 		ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40;
2537 
2538 	if (adapter->user_dev_mcs_support == HT_STREAM_2X2)
2539 		ht_info->cap |= 3 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
2540 	else
2541 		ht_info->cap |= 1 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
2542 
2543 	if (ISSUPP_TXSTBC(adapter->hw_dot_11n_dev_cap))
2544 		ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
2545 	else
2546 		ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC;
2547 
2548 	if (ISSUPP_GREENFIELD(adapter->hw_dot_11n_dev_cap))
2549 		ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
2550 	else
2551 		ht_info->cap &= ~IEEE80211_HT_CAP_GRN_FLD;
2552 
2553 	if (ISENABLED_40MHZ_INTOLERANT(adapter->hw_dot_11n_dev_cap))
2554 		ht_info->cap |= IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2555 	else
2556 		ht_info->cap &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2557 
2558 	if (ISSUPP_RXLDPC(adapter->hw_dot_11n_dev_cap))
2559 		ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
2560 	else
2561 		ht_info->cap &= ~IEEE80211_HT_CAP_LDPC_CODING;
2562 
2563 	ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
2564 	ht_info->cap |= IEEE80211_HT_CAP_SM_PS;
2565 
2566 	rx_mcs_supp = GET_RXMCSSUPP(adapter->user_dev_mcs_support);
2567 	/* Set MCS for 1x1/2x2 */
2568 	memset(mcs, 0xff, rx_mcs_supp);
2569 	/* Clear all the other values */
2570 	memset(&mcs[rx_mcs_supp], 0,
2571 	       sizeof(struct ieee80211_mcs_info) - rx_mcs_supp);
2572 	if (priv->bss_mode == NL80211_IFTYPE_STATION ||
2573 	    ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2574 		/* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
2575 		SETHT_MCS32(mcs_set.rx_mask);
2576 
2577 	memcpy((u8 *) &ht_info->mcs, mcs, sizeof(struct ieee80211_mcs_info));
2578 
2579 	ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2580 }
2581 
2582 /*
2583  *  create a new virtual interface with the given name and name assign type
2584  */
mwifiex_add_virtual_intf(struct wiphy * wiphy,const char * name,unsigned char name_assign_type,enum nl80211_iftype type,u32 * flags,struct vif_params * params)2585 struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
2586 					      const char *name,
2587 					      unsigned char name_assign_type,
2588 					      enum nl80211_iftype type,
2589 					      u32 *flags,
2590 					      struct vif_params *params)
2591 {
2592 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
2593 	struct mwifiex_private *priv;
2594 	struct net_device *dev;
2595 	void *mdev_priv;
2596 
2597 	if (!adapter)
2598 		return ERR_PTR(-EFAULT);
2599 
2600 	switch (type) {
2601 	case NL80211_IFTYPE_UNSPECIFIED:
2602 	case NL80211_IFTYPE_STATION:
2603 	case NL80211_IFTYPE_ADHOC:
2604 		if (adapter->curr_iface_comb.sta_intf ==
2605 		    adapter->iface_limit.sta_intf) {
2606 			mwifiex_dbg(adapter, ERROR,
2607 				    "cannot create multiple sta/adhoc ifaces\n");
2608 			return ERR_PTR(-EINVAL);
2609 		}
2610 
2611 		priv = mwifiex_get_unused_priv(adapter);
2612 		if (!priv) {
2613 			mwifiex_dbg(adapter, ERROR,
2614 				    "could not get free private struct\n");
2615 			return ERR_PTR(-EFAULT);
2616 		}
2617 
2618 		priv->wdev.wiphy = wiphy;
2619 		priv->wdev.iftype = NL80211_IFTYPE_STATION;
2620 
2621 		if (type == NL80211_IFTYPE_UNSPECIFIED)
2622 			priv->bss_mode = NL80211_IFTYPE_STATION;
2623 		else
2624 			priv->bss_mode = type;
2625 
2626 		priv->bss_type = MWIFIEX_BSS_TYPE_STA;
2627 		priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2628 		priv->bss_priority = 0;
2629 		priv->bss_role = MWIFIEX_BSS_ROLE_STA;
2630 		priv->bss_num = adapter->curr_iface_comb.sta_intf;
2631 
2632 		break;
2633 	case NL80211_IFTYPE_AP:
2634 		if (adapter->curr_iface_comb.uap_intf ==
2635 		    adapter->iface_limit.uap_intf) {
2636 			mwifiex_dbg(adapter, ERROR,
2637 				    "cannot create multiple AP ifaces\n");
2638 			return ERR_PTR(-EINVAL);
2639 		}
2640 
2641 		priv = mwifiex_get_unused_priv(adapter);
2642 		if (!priv) {
2643 			mwifiex_dbg(adapter, ERROR,
2644 				    "could not get free private struct\n");
2645 			return ERR_PTR(-EFAULT);
2646 		}
2647 
2648 		priv->wdev.wiphy = wiphy;
2649 		priv->wdev.iftype = NL80211_IFTYPE_AP;
2650 
2651 		priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
2652 		priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2653 		priv->bss_priority = 0;
2654 		priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
2655 		priv->bss_started = 0;
2656 		priv->bss_num = adapter->curr_iface_comb.uap_intf;
2657 		priv->bss_mode = type;
2658 
2659 		break;
2660 	case NL80211_IFTYPE_P2P_CLIENT:
2661 		if (adapter->curr_iface_comb.p2p_intf ==
2662 		    adapter->iface_limit.p2p_intf) {
2663 			mwifiex_dbg(adapter, ERROR,
2664 				    "cannot create multiple P2P ifaces\n");
2665 			return ERR_PTR(-EINVAL);
2666 		}
2667 
2668 		priv = mwifiex_get_unused_priv(adapter);
2669 		if (!priv) {
2670 			mwifiex_dbg(adapter, ERROR,
2671 				    "could not get free private struct\n");
2672 			return ERR_PTR(-EFAULT);
2673 		}
2674 
2675 		priv->wdev.wiphy = wiphy;
2676 		/* At start-up, wpa_supplicant tries to change the interface
2677 		 * to NL80211_IFTYPE_STATION if it is not managed mode.
2678 		 */
2679 		priv->wdev.iftype = NL80211_IFTYPE_P2P_CLIENT;
2680 		priv->bss_mode = NL80211_IFTYPE_P2P_CLIENT;
2681 
2682 		/* Setting bss_type to P2P tells firmware that this interface
2683 		 * is receiving P2P peers found during find phase and doing
2684 		 * action frame handshake.
2685 		 */
2686 		priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
2687 
2688 		priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2689 		priv->bss_priority = MWIFIEX_BSS_ROLE_STA;
2690 		priv->bss_role = MWIFIEX_BSS_ROLE_STA;
2691 		priv->bss_started = 0;
2692 		priv->bss_num = adapter->curr_iface_comb.p2p_intf;
2693 
2694 		if (mwifiex_cfg80211_init_p2p_client(priv)) {
2695 			memset(&priv->wdev, 0, sizeof(priv->wdev));
2696 			priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2697 			return ERR_PTR(-EFAULT);
2698 		}
2699 
2700 		break;
2701 	default:
2702 		mwifiex_dbg(adapter, ERROR, "type not supported\n");
2703 		return ERR_PTR(-EINVAL);
2704 	}
2705 
2706 	dev = alloc_netdev_mqs(sizeof(struct mwifiex_private *), name,
2707 			       name_assign_type, ether_setup,
2708 			       IEEE80211_NUM_ACS, 1);
2709 	if (!dev) {
2710 		mwifiex_dbg(adapter, ERROR,
2711 			    "no memory available for netdevice\n");
2712 		memset(&priv->wdev, 0, sizeof(priv->wdev));
2713 		priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2714 		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2715 		return ERR_PTR(-ENOMEM);
2716 	}
2717 
2718 	mwifiex_init_priv_params(priv, dev);
2719 	priv->netdev = dev;
2720 
2721 	mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);
2722 	if (adapter->is_hw_11ac_capable)
2723 		mwifiex_setup_vht_caps(
2724 			&wiphy->bands[IEEE80211_BAND_2GHZ]->vht_cap, priv);
2725 
2726 	if (adapter->config_bands & BAND_A)
2727 		mwifiex_setup_ht_caps(
2728 			&wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);
2729 
2730 	if ((adapter->config_bands & BAND_A) && adapter->is_hw_11ac_capable)
2731 		mwifiex_setup_vht_caps(
2732 			&wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap, priv);
2733 
2734 	dev_net_set(dev, wiphy_net(wiphy));
2735 	dev->ieee80211_ptr = &priv->wdev;
2736 	dev->ieee80211_ptr->iftype = priv->bss_mode;
2737 	memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
2738 	SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
2739 
2740 	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
2741 	dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;
2742 	dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN;
2743 	dev->ethtool_ops = &mwifiex_ethtool_ops;
2744 
2745 	mdev_priv = netdev_priv(dev);
2746 	*((unsigned long *) mdev_priv) = (unsigned long) priv;
2747 
2748 	SET_NETDEV_DEV(dev, adapter->dev);
2749 
2750 	/* Register network device */
2751 	if (register_netdevice(dev)) {
2752 		mwifiex_dbg(adapter, ERROR,
2753 			    "cannot register virtual network device\n");
2754 		free_netdev(dev);
2755 		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2756 		priv->netdev = NULL;
2757 		memset(&priv->wdev, 0, sizeof(priv->wdev));
2758 		priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2759 		return ERR_PTR(-EFAULT);
2760 	}
2761 
2762 	priv->dfs_cac_workqueue = alloc_workqueue("MWIFIEX_DFS_CAC%s",
2763 						  WQ_HIGHPRI |
2764 						  WQ_MEM_RECLAIM |
2765 						  WQ_UNBOUND, 1, name);
2766 	if (!priv->dfs_cac_workqueue) {
2767 		mwifiex_dbg(adapter, ERROR,
2768 			    "cannot register virtual network device\n");
2769 		free_netdev(dev);
2770 		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2771 		priv->netdev = NULL;
2772 		memset(&priv->wdev, 0, sizeof(priv->wdev));
2773 		priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2774 		return ERR_PTR(-ENOMEM);
2775 	}
2776 
2777 	INIT_DELAYED_WORK(&priv->dfs_cac_work, mwifiex_dfs_cac_work_queue);
2778 
2779 	priv->dfs_chan_sw_workqueue = alloc_workqueue("MWIFIEX_DFS_CHSW%s",
2780 						      WQ_HIGHPRI | WQ_UNBOUND |
2781 						      WQ_MEM_RECLAIM, 1, name);
2782 	if (!priv->dfs_chan_sw_workqueue) {
2783 		mwifiex_dbg(adapter, ERROR,
2784 			    "cannot register virtual network device\n");
2785 		free_netdev(dev);
2786 		priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2787 		priv->netdev = NULL;
2788 		memset(&priv->wdev, 0, sizeof(priv->wdev));
2789 		priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2790 		return ERR_PTR(-ENOMEM);
2791 	}
2792 
2793 	INIT_DELAYED_WORK(&priv->dfs_chan_sw_work,
2794 			  mwifiex_dfs_chan_sw_work_queue);
2795 
2796 	sema_init(&priv->async_sem, 1);
2797 
2798 	mwifiex_dbg(adapter, INFO,
2799 		    "info: %s: Marvell 802.11 Adapter\n", dev->name);
2800 
2801 #ifdef CONFIG_DEBUG_FS
2802 	mwifiex_dev_debugfs_init(priv);
2803 #endif
2804 
2805 	switch (type) {
2806 	case NL80211_IFTYPE_UNSPECIFIED:
2807 	case NL80211_IFTYPE_STATION:
2808 	case NL80211_IFTYPE_ADHOC:
2809 		adapter->curr_iface_comb.sta_intf++;
2810 		break;
2811 	case NL80211_IFTYPE_AP:
2812 		adapter->curr_iface_comb.uap_intf++;
2813 		break;
2814 	case NL80211_IFTYPE_P2P_CLIENT:
2815 		adapter->curr_iface_comb.p2p_intf++;
2816 		break;
2817 	default:
2818 		mwifiex_dbg(adapter, ERROR, "type not supported\n");
2819 		return ERR_PTR(-EINVAL);
2820 	}
2821 
2822 	return &priv->wdev;
2823 }
2824 EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
2825 
2826 /*
2827  * del_virtual_intf: remove the virtual interface determined by dev
2828  */
mwifiex_del_virtual_intf(struct wiphy * wiphy,struct wireless_dev * wdev)2829 int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
2830 {
2831 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
2832 	struct mwifiex_adapter *adapter = priv->adapter;
2833 	struct sk_buff *skb, *tmp;
2834 
2835 #ifdef CONFIG_DEBUG_FS
2836 	mwifiex_dev_debugfs_remove(priv);
2837 #endif
2838 
2839 	mwifiex_stop_net_dev_queue(priv->netdev, adapter);
2840 
2841 	skb_queue_walk_safe(&priv->bypass_txq, skb, tmp)
2842 		mwifiex_write_data_complete(priv->adapter, skb, 0, -1);
2843 
2844 	if (netif_carrier_ok(priv->netdev))
2845 		netif_carrier_off(priv->netdev);
2846 
2847 	if (wdev->netdev->reg_state == NETREG_REGISTERED)
2848 		unregister_netdevice(wdev->netdev);
2849 
2850 	if (priv->dfs_cac_workqueue) {
2851 		flush_workqueue(priv->dfs_cac_workqueue);
2852 		destroy_workqueue(priv->dfs_cac_workqueue);
2853 		priv->dfs_cac_workqueue = NULL;
2854 	}
2855 
2856 	if (priv->dfs_chan_sw_workqueue) {
2857 		flush_workqueue(priv->dfs_chan_sw_workqueue);
2858 		destroy_workqueue(priv->dfs_chan_sw_workqueue);
2859 		priv->dfs_chan_sw_workqueue = NULL;
2860 	}
2861 	/* Clear the priv in adapter */
2862 	priv->netdev->ieee80211_ptr = NULL;
2863 	priv->netdev = NULL;
2864 	priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
2865 
2866 	priv->media_connected = false;
2867 
2868 	switch (priv->bss_mode) {
2869 	case NL80211_IFTYPE_UNSPECIFIED:
2870 	case NL80211_IFTYPE_STATION:
2871 	case NL80211_IFTYPE_ADHOC:
2872 		adapter->curr_iface_comb.sta_intf--;
2873 		break;
2874 	case NL80211_IFTYPE_AP:
2875 		adapter->curr_iface_comb.uap_intf--;
2876 		break;
2877 	case NL80211_IFTYPE_P2P_CLIENT:
2878 	case NL80211_IFTYPE_P2P_GO:
2879 		adapter->curr_iface_comb.p2p_intf--;
2880 		break;
2881 	default:
2882 		mwifiex_dbg(adapter, ERROR,
2883 			    "del_virtual_intf: type not supported\n");
2884 		break;
2885 	}
2886 
2887 	priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2888 
2889 	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
2890 	    GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP)
2891 		kfree(priv->hist_data);
2892 
2893 	return 0;
2894 }
2895 EXPORT_SYMBOL_GPL(mwifiex_del_virtual_intf);
2896 
2897 static bool
mwifiex_is_pattern_supported(struct cfg80211_pkt_pattern * pat,s8 * byte_seq,u8 max_byte_seq)2898 mwifiex_is_pattern_supported(struct cfg80211_pkt_pattern *pat, s8 *byte_seq,
2899 			     u8 max_byte_seq)
2900 {
2901 	int j, k, valid_byte_cnt = 0;
2902 	bool dont_care_byte = false;
2903 
2904 	for (j = 0; j < DIV_ROUND_UP(pat->pattern_len, 8); j++) {
2905 		for (k = 0; k < 8; k++) {
2906 			if (pat->mask[j] & 1 << k) {
2907 				memcpy(byte_seq + valid_byte_cnt,
2908 				       &pat->pattern[j * 8 + k], 1);
2909 				valid_byte_cnt++;
2910 				if (dont_care_byte)
2911 					return false;
2912 			} else {
2913 				if (valid_byte_cnt)
2914 					dont_care_byte = true;
2915 			}
2916 
2917 			if (valid_byte_cnt > max_byte_seq)
2918 				return false;
2919 		}
2920 	}
2921 
2922 	byte_seq[max_byte_seq] = valid_byte_cnt;
2923 
2924 	return true;
2925 }
2926 
2927 #ifdef CONFIG_PM
mwifiex_set_auto_arp_mef_entry(struct mwifiex_private * priv,struct mwifiex_mef_entry * mef_entry)2928 static void mwifiex_set_auto_arp_mef_entry(struct mwifiex_private *priv,
2929 					   struct mwifiex_mef_entry *mef_entry)
2930 {
2931 	int i, filt_num = 0, num_ipv4 = 0;
2932 	struct in_device *in_dev;
2933 	struct in_ifaddr *ifa;
2934 	__be32 ips[MWIFIEX_MAX_SUPPORTED_IPADDR];
2935 	struct mwifiex_adapter *adapter = priv->adapter;
2936 
2937 	mef_entry->mode = MEF_MODE_HOST_SLEEP;
2938 	mef_entry->action = MEF_ACTION_AUTO_ARP;
2939 
2940 	/* Enable ARP offload feature */
2941 	memset(ips, 0, sizeof(ips));
2942 	for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
2943 		if (adapter->priv[i]->netdev) {
2944 			in_dev = __in_dev_get_rtnl(adapter->priv[i]->netdev);
2945 			if (!in_dev)
2946 				continue;
2947 			ifa = in_dev->ifa_list;
2948 			if (!ifa || !ifa->ifa_local)
2949 				continue;
2950 			ips[i] = ifa->ifa_local;
2951 			num_ipv4++;
2952 		}
2953 	}
2954 
2955 	for (i = 0; i < num_ipv4; i++) {
2956 		if (!ips[i])
2957 			continue;
2958 		mef_entry->filter[filt_num].repeat = 1;
2959 		memcpy(mef_entry->filter[filt_num].byte_seq,
2960 		       (u8 *)&ips[i], sizeof(ips[i]));
2961 		mef_entry->filter[filt_num].
2962 			byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
2963 			sizeof(ips[i]);
2964 		mef_entry->filter[filt_num].offset = 46;
2965 		mef_entry->filter[filt_num].filt_type = TYPE_EQ;
2966 		if (filt_num) {
2967 			mef_entry->filter[filt_num].filt_action =
2968 				TYPE_OR;
2969 		}
2970 		filt_num++;
2971 	}
2972 
2973 	mef_entry->filter[filt_num].repeat = 1;
2974 	mef_entry->filter[filt_num].byte_seq[0] = 0x08;
2975 	mef_entry->filter[filt_num].byte_seq[1] = 0x06;
2976 	mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] = 2;
2977 	mef_entry->filter[filt_num].offset = 20;
2978 	mef_entry->filter[filt_num].filt_type = TYPE_EQ;
2979 	mef_entry->filter[filt_num].filt_action = TYPE_AND;
2980 }
2981 
mwifiex_set_wowlan_mef_entry(struct mwifiex_private * priv,struct mwifiex_ds_mef_cfg * mef_cfg,struct mwifiex_mef_entry * mef_entry,struct cfg80211_wowlan * wowlan)2982 static int mwifiex_set_wowlan_mef_entry(struct mwifiex_private *priv,
2983 					struct mwifiex_ds_mef_cfg *mef_cfg,
2984 					struct mwifiex_mef_entry *mef_entry,
2985 					struct cfg80211_wowlan *wowlan)
2986 {
2987 	int i, filt_num = 0, ret = 0;
2988 	bool first_pat = true;
2989 	u8 byte_seq[MWIFIEX_MEF_MAX_BYTESEQ + 1];
2990 	const u8 ipv4_mc_mac[] = {0x33, 0x33};
2991 	const u8 ipv6_mc_mac[] = {0x01, 0x00, 0x5e};
2992 
2993 	mef_entry->mode = MEF_MODE_HOST_SLEEP;
2994 	mef_entry->action = MEF_ACTION_ALLOW_AND_WAKEUP_HOST;
2995 
2996 	for (i = 0; i < wowlan->n_patterns; i++) {
2997 		memset(byte_seq, 0, sizeof(byte_seq));
2998 		if (!mwifiex_is_pattern_supported(&wowlan->patterns[i],
2999 					byte_seq,
3000 					MWIFIEX_MEF_MAX_BYTESEQ)) {
3001 			mwifiex_dbg(priv->adapter, ERROR,
3002 				    "Pattern not supported\n");
3003 			return -EOPNOTSUPP;
3004 		}
3005 
3006 		if (!wowlan->patterns[i].pkt_offset) {
3007 			if (!(byte_seq[0] & 0x01) &&
3008 			    (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 1)) {
3009 				mef_cfg->criteria |= MWIFIEX_CRITERIA_UNICAST;
3010 				continue;
3011 			} else if (is_broadcast_ether_addr(byte_seq)) {
3012 				mef_cfg->criteria |= MWIFIEX_CRITERIA_BROADCAST;
3013 				continue;
3014 			} else if ((!memcmp(byte_seq, ipv4_mc_mac, 2) &&
3015 				    (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 2)) ||
3016 				   (!memcmp(byte_seq, ipv6_mc_mac, 3) &&
3017 				    (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 3))) {
3018 				mef_cfg->criteria |= MWIFIEX_CRITERIA_MULTICAST;
3019 				continue;
3020 			}
3021 		}
3022 		mef_entry->filter[filt_num].repeat = 1;
3023 		mef_entry->filter[filt_num].offset =
3024 			wowlan->patterns[i].pkt_offset;
3025 		memcpy(mef_entry->filter[filt_num].byte_seq, byte_seq,
3026 				sizeof(byte_seq));
3027 		mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3028 
3029 		if (first_pat)
3030 			first_pat = false;
3031 		else
3032 			mef_entry->filter[filt_num].filt_action = TYPE_AND;
3033 
3034 		filt_num++;
3035 	}
3036 
3037 	if (wowlan->magic_pkt) {
3038 		mef_cfg->criteria |= MWIFIEX_CRITERIA_UNICAST;
3039 		mef_entry->filter[filt_num].repeat = 16;
3040 		memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,
3041 				ETH_ALEN);
3042 		mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
3043 			ETH_ALEN;
3044 		mef_entry->filter[filt_num].offset = 28;
3045 		mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3046 		if (filt_num)
3047 			mef_entry->filter[filt_num].filt_action = TYPE_OR;
3048 
3049 		filt_num++;
3050 		mef_entry->filter[filt_num].repeat = 16;
3051 		memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,
3052 				ETH_ALEN);
3053 		mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
3054 			ETH_ALEN;
3055 		mef_entry->filter[filt_num].offset = 56;
3056 		mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3057 		mef_entry->filter[filt_num].filt_action = TYPE_OR;
3058 	}
3059 	return ret;
3060 }
3061 
mwifiex_set_mef_filter(struct mwifiex_private * priv,struct cfg80211_wowlan * wowlan)3062 static int mwifiex_set_mef_filter(struct mwifiex_private *priv,
3063 				  struct cfg80211_wowlan *wowlan)
3064 {
3065 	int ret = 0, num_entries = 1;
3066 	struct mwifiex_ds_mef_cfg mef_cfg;
3067 	struct mwifiex_mef_entry *mef_entry;
3068 
3069 	if (wowlan->n_patterns || wowlan->magic_pkt)
3070 		num_entries++;
3071 
3072 	mef_entry = kcalloc(num_entries, sizeof(*mef_entry), GFP_KERNEL);
3073 	if (!mef_entry)
3074 		return -ENOMEM;
3075 
3076 	memset(&mef_cfg, 0, sizeof(mef_cfg));
3077 	mef_cfg.criteria |= MWIFIEX_CRITERIA_BROADCAST |
3078 		MWIFIEX_CRITERIA_UNICAST;
3079 	mef_cfg.num_entries = num_entries;
3080 	mef_cfg.mef_entry = mef_entry;
3081 
3082 	mwifiex_set_auto_arp_mef_entry(priv, &mef_entry[0]);
3083 
3084 	if (wowlan->n_patterns || wowlan->magic_pkt) {
3085 		ret = mwifiex_set_wowlan_mef_entry(priv, &mef_cfg,
3086 						   &mef_entry[1], wowlan);
3087 		if (ret)
3088 			goto err;
3089 	}
3090 
3091 	if (!mef_cfg.criteria)
3092 		mef_cfg.criteria = MWIFIEX_CRITERIA_BROADCAST |
3093 			MWIFIEX_CRITERIA_UNICAST |
3094 			MWIFIEX_CRITERIA_MULTICAST;
3095 
3096 	ret = mwifiex_send_cmd(priv, HostCmd_CMD_MEF_CFG,
3097 			HostCmd_ACT_GEN_SET, 0,
3098 			&mef_cfg, true);
3099 
3100 err:
3101 	kfree(mef_entry);
3102 	return ret;
3103 }
3104 
mwifiex_cfg80211_suspend(struct wiphy * wiphy,struct cfg80211_wowlan * wowlan)3105 static int mwifiex_cfg80211_suspend(struct wiphy *wiphy,
3106 				    struct cfg80211_wowlan *wowlan)
3107 {
3108 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3109 	struct mwifiex_ds_hs_cfg hs_cfg;
3110 	int i, ret = 0;
3111 	struct mwifiex_private *priv;
3112 
3113 	for (i = 0; i < adapter->priv_num; i++) {
3114 		priv = adapter->priv[i];
3115 		mwifiex_abort_cac(priv);
3116 	}
3117 
3118 	mwifiex_cancel_all_pending_cmd(adapter);
3119 
3120 	if (!wowlan) {
3121 		mwifiex_dbg(adapter, ERROR,
3122 			    "None of the WOWLAN triggers enabled\n");
3123 		return 0;
3124 	}
3125 
3126 	priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
3127 
3128 	if (!priv->media_connected) {
3129 		mwifiex_dbg(adapter, ERROR,
3130 			    "Can not configure WOWLAN in disconnected state\n");
3131 		return 0;
3132 	}
3133 
3134 	ret = mwifiex_set_mef_filter(priv, wowlan);
3135 	if (ret) {
3136 		mwifiex_dbg(adapter, ERROR, "Failed to set MEF filter\n");
3137 		return ret;
3138 	}
3139 
3140 	if (wowlan->disconnect) {
3141 		memset(&hs_cfg, 0, sizeof(hs_cfg));
3142 		hs_cfg.is_invoke_hostcmd = false;
3143 		hs_cfg.conditions = HS_CFG_COND_MAC_EVENT;
3144 		hs_cfg.gpio = HS_CFG_GPIO_DEF;
3145 		hs_cfg.gap = HS_CFG_GAP_DEF;
3146 		ret = mwifiex_set_hs_params(priv, HostCmd_ACT_GEN_SET,
3147 					    MWIFIEX_SYNC_CMD, &hs_cfg);
3148 		if (ret) {
3149 			mwifiex_dbg(adapter, ERROR,
3150 				    "Failed to set HS params\n");
3151 			return ret;
3152 		}
3153 	}
3154 
3155 	return ret;
3156 }
3157 
mwifiex_cfg80211_resume(struct wiphy * wiphy)3158 static int mwifiex_cfg80211_resume(struct wiphy *wiphy)
3159 {
3160 	return 0;
3161 }
3162 
mwifiex_cfg80211_set_wakeup(struct wiphy * wiphy,bool enabled)3163 static void mwifiex_cfg80211_set_wakeup(struct wiphy *wiphy,
3164 				       bool enabled)
3165 {
3166 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3167 
3168 	device_set_wakeup_enable(adapter->dev, enabled);
3169 }
3170 #endif
3171 
mwifiex_get_coalesce_pkt_type(u8 * byte_seq)3172 static int mwifiex_get_coalesce_pkt_type(u8 *byte_seq)
3173 {
3174 	const u8 ipv4_mc_mac[] = {0x33, 0x33};
3175 	const u8 ipv6_mc_mac[] = {0x01, 0x00, 0x5e};
3176 	const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff};
3177 
3178 	if ((byte_seq[0] & 0x01) &&
3179 	    (byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 1))
3180 		return PACKET_TYPE_UNICAST;
3181 	else if (!memcmp(byte_seq, bc_mac, 4))
3182 		return PACKET_TYPE_BROADCAST;
3183 	else if ((!memcmp(byte_seq, ipv4_mc_mac, 2) &&
3184 		  byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 2) ||
3185 		 (!memcmp(byte_seq, ipv6_mc_mac, 3) &&
3186 		  byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 3))
3187 		return PACKET_TYPE_MULTICAST;
3188 
3189 	return 0;
3190 }
3191 
3192 static int
mwifiex_fill_coalesce_rule_info(struct mwifiex_private * priv,struct cfg80211_coalesce_rules * crule,struct mwifiex_coalesce_rule * mrule)3193 mwifiex_fill_coalesce_rule_info(struct mwifiex_private *priv,
3194 				struct cfg80211_coalesce_rules *crule,
3195 				struct mwifiex_coalesce_rule *mrule)
3196 {
3197 	u8 byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ + 1];
3198 	struct filt_field_param *param;
3199 	int i;
3200 
3201 	mrule->max_coalescing_delay = crule->delay;
3202 
3203 	param = mrule->params;
3204 
3205 	for (i = 0; i < crule->n_patterns; i++) {
3206 		memset(byte_seq, 0, sizeof(byte_seq));
3207 		if (!mwifiex_is_pattern_supported(&crule->patterns[i],
3208 						  byte_seq,
3209 						MWIFIEX_COALESCE_MAX_BYTESEQ)) {
3210 			mwifiex_dbg(priv->adapter, ERROR,
3211 				    "Pattern not supported\n");
3212 			return -EOPNOTSUPP;
3213 		}
3214 
3215 		if (!crule->patterns[i].pkt_offset) {
3216 			u8 pkt_type;
3217 
3218 			pkt_type = mwifiex_get_coalesce_pkt_type(byte_seq);
3219 			if (pkt_type && mrule->pkt_type) {
3220 				mwifiex_dbg(priv->adapter, ERROR,
3221 					    "Multiple packet types not allowed\n");
3222 				return -EOPNOTSUPP;
3223 			} else if (pkt_type) {
3224 				mrule->pkt_type = pkt_type;
3225 				continue;
3226 			}
3227 		}
3228 
3229 		if (crule->condition == NL80211_COALESCE_CONDITION_MATCH)
3230 			param->operation = RECV_FILTER_MATCH_TYPE_EQ;
3231 		else
3232 			param->operation = RECV_FILTER_MATCH_TYPE_NE;
3233 
3234 		param->operand_len = byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ];
3235 		memcpy(param->operand_byte_stream, byte_seq,
3236 		       param->operand_len);
3237 		param->offset = crule->patterns[i].pkt_offset;
3238 		param++;
3239 
3240 		mrule->num_of_fields++;
3241 	}
3242 
3243 	if (!mrule->pkt_type) {
3244 		mwifiex_dbg(priv->adapter, ERROR,
3245 			    "Packet type can not be determined\n");
3246 		return -EOPNOTSUPP;
3247 	}
3248 
3249 	return 0;
3250 }
3251 
mwifiex_cfg80211_set_coalesce(struct wiphy * wiphy,struct cfg80211_coalesce * coalesce)3252 static int mwifiex_cfg80211_set_coalesce(struct wiphy *wiphy,
3253 					 struct cfg80211_coalesce *coalesce)
3254 {
3255 	struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3256 	int i, ret;
3257 	struct mwifiex_ds_coalesce_cfg coalesce_cfg;
3258 	struct mwifiex_private *priv =
3259 			mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
3260 
3261 	memset(&coalesce_cfg, 0, sizeof(coalesce_cfg));
3262 	if (!coalesce) {
3263 		mwifiex_dbg(adapter, WARN,
3264 			    "Disable coalesce and reset all previous rules\n");
3265 		return mwifiex_send_cmd(priv, HostCmd_CMD_COALESCE_CFG,
3266 					HostCmd_ACT_GEN_SET, 0,
3267 					&coalesce_cfg, true);
3268 	}
3269 
3270 	coalesce_cfg.num_of_rules = coalesce->n_rules;
3271 	for (i = 0; i < coalesce->n_rules; i++) {
3272 		ret = mwifiex_fill_coalesce_rule_info(priv, &coalesce->rules[i],
3273 						      &coalesce_cfg.rule[i]);
3274 		if (ret) {
3275 			mwifiex_dbg(adapter, ERROR,
3276 				    "Recheck the patterns provided for rule %d\n",
3277 				i + 1);
3278 			return ret;
3279 		}
3280 	}
3281 
3282 	return mwifiex_send_cmd(priv, HostCmd_CMD_COALESCE_CFG,
3283 				HostCmd_ACT_GEN_SET, 0, &coalesce_cfg, true);
3284 }
3285 
3286 /* cfg80211 ops handler for tdls_mgmt.
3287  * Function prepares TDLS action frame packets and forwards them to FW
3288  */
3289 static int
mwifiex_cfg80211_tdls_mgmt(struct wiphy * wiphy,struct net_device * dev,const u8 * peer,u8 action_code,u8 dialog_token,u16 status_code,u32 peer_capability,bool initiator,const u8 * extra_ies,size_t extra_ies_len)3290 mwifiex_cfg80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
3291 			   const u8 *peer, u8 action_code, u8 dialog_token,
3292 			   u16 status_code, u32 peer_capability,
3293 			   bool initiator, const u8 *extra_ies,
3294 			   size_t extra_ies_len)
3295 {
3296 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3297 	int ret;
3298 
3299 	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
3300 		return -ENOTSUPP;
3301 
3302 	/* make sure we are in station mode and connected */
3303 	if (!(priv->bss_type == MWIFIEX_BSS_TYPE_STA && priv->media_connected))
3304 		return -ENOTSUPP;
3305 
3306 	switch (action_code) {
3307 	case WLAN_TDLS_SETUP_REQUEST:
3308 		mwifiex_dbg(priv->adapter, MSG,
3309 			    "Send TDLS Setup Request to %pM status_code=%d\n",
3310 			    peer, status_code);
3311 		mwifiex_add_auto_tdls_peer(priv, peer);
3312 		ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3313 						   dialog_token, status_code,
3314 						   extra_ies, extra_ies_len);
3315 		break;
3316 	case WLAN_TDLS_SETUP_RESPONSE:
3317 		mwifiex_add_auto_tdls_peer(priv, peer);
3318 		mwifiex_dbg(priv->adapter, MSG,
3319 			    "Send TDLS Setup Response to %pM status_code=%d\n",
3320 			    peer, status_code);
3321 		ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3322 						   dialog_token, status_code,
3323 						   extra_ies, extra_ies_len);
3324 		break;
3325 	case WLAN_TDLS_SETUP_CONFIRM:
3326 		mwifiex_dbg(priv->adapter, MSG,
3327 			    "Send TDLS Confirm to %pM status_code=%d\n", peer,
3328 			    status_code);
3329 		ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3330 						   dialog_token, status_code,
3331 						   extra_ies, extra_ies_len);
3332 		break;
3333 	case WLAN_TDLS_TEARDOWN:
3334 		mwifiex_dbg(priv->adapter, MSG,
3335 			    "Send TDLS Tear down to %pM\n", peer);
3336 		ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3337 						   dialog_token, status_code,
3338 						   extra_ies, extra_ies_len);
3339 		break;
3340 	case WLAN_TDLS_DISCOVERY_REQUEST:
3341 		mwifiex_dbg(priv->adapter, MSG,
3342 			    "Send TDLS Discovery Request to %pM\n", peer);
3343 		ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3344 						   dialog_token, status_code,
3345 						   extra_ies, extra_ies_len);
3346 		break;
3347 	case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
3348 		mwifiex_dbg(priv->adapter, MSG,
3349 			    "Send TDLS Discovery Response to %pM\n", peer);
3350 		ret = mwifiex_send_tdls_action_frame(priv, peer, action_code,
3351 						   dialog_token, status_code,
3352 						   extra_ies, extra_ies_len);
3353 		break;
3354 	default:
3355 		mwifiex_dbg(priv->adapter, ERROR,
3356 			    "Unknown TDLS mgmt/action frame %pM\n", peer);
3357 		ret = -EINVAL;
3358 		break;
3359 	}
3360 
3361 	return ret;
3362 }
3363 
3364 static int
mwifiex_cfg80211_tdls_oper(struct wiphy * wiphy,struct net_device * dev,const u8 * peer,enum nl80211_tdls_operation action)3365 mwifiex_cfg80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
3366 			   const u8 *peer, enum nl80211_tdls_operation action)
3367 {
3368 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3369 
3370 	if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
3371 	    !(wiphy->flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
3372 		return -ENOTSUPP;
3373 
3374 	/* make sure we are in station mode and connected */
3375 	if (!(priv->bss_type == MWIFIEX_BSS_TYPE_STA && priv->media_connected))
3376 		return -ENOTSUPP;
3377 
3378 	mwifiex_dbg(priv->adapter, MSG,
3379 		    "TDLS peer=%pM, oper=%d\n", peer, action);
3380 
3381 	switch (action) {
3382 	case NL80211_TDLS_ENABLE_LINK:
3383 		action = MWIFIEX_TDLS_ENABLE_LINK;
3384 		break;
3385 	case NL80211_TDLS_DISABLE_LINK:
3386 		action = MWIFIEX_TDLS_DISABLE_LINK;
3387 		break;
3388 	case NL80211_TDLS_TEARDOWN:
3389 		/* shouldn't happen!*/
3390 		mwifiex_dbg(priv->adapter, ERROR,
3391 			    "tdls_oper: teardown from driver not supported\n");
3392 		return -EINVAL;
3393 	case NL80211_TDLS_SETUP:
3394 		/* shouldn't happen!*/
3395 		mwifiex_dbg(priv->adapter, ERROR,
3396 			    "tdls_oper: setup from driver not supported\n");
3397 		return -EINVAL;
3398 	case NL80211_TDLS_DISCOVERY_REQ:
3399 		/* shouldn't happen!*/
3400 		mwifiex_dbg(priv->adapter, ERROR,
3401 			    "tdls_oper: discovery from driver not supported\n");
3402 		return -EINVAL;
3403 	default:
3404 		mwifiex_dbg(priv->adapter, ERROR,
3405 			    "tdls_oper: operation not supported\n");
3406 		return -ENOTSUPP;
3407 	}
3408 
3409 	return mwifiex_tdls_oper(priv, peer, action);
3410 }
3411 
3412 static int
mwifiex_cfg80211_tdls_chan_switch(struct wiphy * wiphy,struct net_device * dev,const u8 * addr,u8 oper_class,struct cfg80211_chan_def * chandef)3413 mwifiex_cfg80211_tdls_chan_switch(struct wiphy *wiphy, struct net_device *dev,
3414 				  const u8 *addr, u8 oper_class,
3415 				  struct cfg80211_chan_def *chandef)
3416 {
3417 	struct mwifiex_sta_node *sta_ptr;
3418 	unsigned long flags;
3419 	u16 chan;
3420 	u8 second_chan_offset, band;
3421 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3422 
3423 	spin_lock_irqsave(&priv->sta_list_spinlock, flags);
3424 	sta_ptr = mwifiex_get_sta_entry(priv, addr);
3425 	spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
3426 
3427 	if (!sta_ptr) {
3428 		wiphy_err(wiphy, "%s: Invalid TDLS peer %pM\n",
3429 			  __func__, addr);
3430 		return -ENOENT;
3431 	}
3432 
3433 	if (!(sta_ptr->tdls_cap.extcap.ext_capab[3] &
3434 	      WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH)) {
3435 		wiphy_err(wiphy, "%pM do not support tdls cs\n", addr);
3436 		return -ENOENT;
3437 	}
3438 
3439 	if (sta_ptr->tdls_status == TDLS_CHAN_SWITCHING ||
3440 	    sta_ptr->tdls_status == TDLS_IN_OFF_CHAN) {
3441 		wiphy_err(wiphy, "channel switch is running, abort request\n");
3442 		return -EALREADY;
3443 	}
3444 
3445 	chan = chandef->chan->hw_value;
3446 	second_chan_offset = mwifiex_get_sec_chan_offset(chan);
3447 	band = chandef->chan->band;
3448 	mwifiex_start_tdls_cs(priv, addr, chan, second_chan_offset, band);
3449 
3450 	return 0;
3451 }
3452 
3453 static void
mwifiex_cfg80211_tdls_cancel_chan_switch(struct wiphy * wiphy,struct net_device * dev,const u8 * addr)3454 mwifiex_cfg80211_tdls_cancel_chan_switch(struct wiphy *wiphy,
3455 					 struct net_device *dev,
3456 					 const u8 *addr)
3457 {
3458 	struct mwifiex_sta_node *sta_ptr;
3459 	unsigned long flags;
3460 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3461 
3462 	spin_lock_irqsave(&priv->sta_list_spinlock, flags);
3463 	sta_ptr = mwifiex_get_sta_entry(priv, addr);
3464 	spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
3465 
3466 	if (!sta_ptr) {
3467 		wiphy_err(wiphy, "%s: Invalid TDLS peer %pM\n",
3468 			  __func__, addr);
3469 	} else if (!(sta_ptr->tdls_status == TDLS_CHAN_SWITCHING ||
3470 		     sta_ptr->tdls_status == TDLS_IN_BASE_CHAN ||
3471 		     sta_ptr->tdls_status == TDLS_IN_OFF_CHAN)) {
3472 		wiphy_err(wiphy, "tdls chan switch not initialize by %pM\n",
3473 			  addr);
3474 	} else
3475 		mwifiex_stop_tdls_cs(priv, addr);
3476 }
3477 
3478 static int
mwifiex_cfg80211_add_station(struct wiphy * wiphy,struct net_device * dev,const u8 * mac,struct station_parameters * params)3479 mwifiex_cfg80211_add_station(struct wiphy *wiphy, struct net_device *dev,
3480 			     const u8 *mac, struct station_parameters *params)
3481 {
3482 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3483 
3484 	if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3485 		return -ENOTSUPP;
3486 
3487 	/* make sure we are in station mode and connected */
3488 	if ((priv->bss_type != MWIFIEX_BSS_TYPE_STA) || !priv->media_connected)
3489 		return -ENOTSUPP;
3490 
3491 	return mwifiex_tdls_oper(priv, mac, MWIFIEX_TDLS_CREATE_LINK);
3492 }
3493 
3494 static int
mwifiex_cfg80211_channel_switch(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_csa_settings * params)3495 mwifiex_cfg80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
3496 				struct cfg80211_csa_settings *params)
3497 {
3498 	struct ieee_types_header *chsw_ie;
3499 	struct ieee80211_channel_sw_ie *channel_sw;
3500 	int chsw_msec;
3501 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3502 
3503 	if (priv->adapter->scan_processing) {
3504 		mwifiex_dbg(priv->adapter, ERROR,
3505 			    "radar detection: scan in process...\n");
3506 		return -EBUSY;
3507 	}
3508 
3509 	if (priv->wdev.cac_started)
3510 		return -EBUSY;
3511 
3512 	if (cfg80211_chandef_identical(&params->chandef,
3513 				       &priv->dfs_chandef))
3514 		return -EINVAL;
3515 
3516 	chsw_ie = (void *)cfg80211_find_ie(WLAN_EID_CHANNEL_SWITCH,
3517 					   params->beacon_csa.tail,
3518 					   params->beacon_csa.tail_len);
3519 	if (!chsw_ie) {
3520 		mwifiex_dbg(priv->adapter, ERROR,
3521 			    "Could not parse channel switch announcement IE\n");
3522 		return -EINVAL;
3523 	}
3524 
3525 	channel_sw = (void *)(chsw_ie + 1);
3526 	if (channel_sw->mode) {
3527 		if (netif_carrier_ok(priv->netdev))
3528 			netif_carrier_off(priv->netdev);
3529 		mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
3530 	}
3531 
3532 	if (mwifiex_del_mgmt_ies(priv))
3533 		mwifiex_dbg(priv->adapter, ERROR,
3534 			    "Failed to delete mgmt IEs!\n");
3535 
3536 	if (mwifiex_set_mgmt_ies(priv, &params->beacon_csa)) {
3537 		mwifiex_dbg(priv->adapter, ERROR,
3538 			    "%s: setting mgmt ies failed\n", __func__);
3539 		return -EFAULT;
3540 	}
3541 
3542 	memcpy(&priv->dfs_chandef, &params->chandef, sizeof(priv->dfs_chandef));
3543 	memcpy(&priv->beacon_after, &params->beacon_after,
3544 	       sizeof(priv->beacon_after));
3545 
3546 	chsw_msec = max(channel_sw->count * priv->bss_cfg.beacon_period, 100);
3547 	queue_delayed_work(priv->dfs_chan_sw_workqueue, &priv->dfs_chan_sw_work,
3548 			   msecs_to_jiffies(chsw_msec));
3549 	return 0;
3550 }
3551 
mwifiex_cfg80211_get_channel(struct wiphy * wiphy,struct wireless_dev * wdev,struct cfg80211_chan_def * chandef)3552 static int mwifiex_cfg80211_get_channel(struct wiphy *wiphy,
3553 					struct wireless_dev *wdev,
3554 					struct cfg80211_chan_def *chandef)
3555 {
3556 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
3557 	struct mwifiex_bssdescriptor *curr_bss;
3558 	struct ieee80211_channel *chan;
3559 	u8 second_chan_offset;
3560 	enum nl80211_channel_type chan_type;
3561 	enum ieee80211_band band;
3562 	int freq;
3563 	int ret = -ENODATA;
3564 
3565 	if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
3566 	    cfg80211_chandef_valid(&priv->bss_chandef)) {
3567 		*chandef = priv->bss_chandef;
3568 		ret = 0;
3569 	} else if (priv->media_connected) {
3570 		curr_bss = &priv->curr_bss_params.bss_descriptor;
3571 		band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
3572 		freq = ieee80211_channel_to_frequency(curr_bss->channel, band);
3573 		chan = ieee80211_get_channel(wiphy, freq);
3574 
3575 		if (curr_bss->bcn_ht_oper) {
3576 			second_chan_offset = curr_bss->bcn_ht_oper->ht_param &
3577 					IEEE80211_HT_PARAM_CHA_SEC_OFFSET;
3578 			chan_type = mwifiex_sec_chan_offset_to_chan_type
3579 							(second_chan_offset);
3580 			cfg80211_chandef_create(chandef, chan, chan_type);
3581 		} else {
3582 			cfg80211_chandef_create(chandef, chan,
3583 						NL80211_CHAN_NO_HT);
3584 		}
3585 		ret = 0;
3586 	}
3587 
3588 	return ret;
3589 }
3590 
3591 static int
mwifiex_cfg80211_start_radar_detection(struct wiphy * wiphy,struct net_device * dev,struct cfg80211_chan_def * chandef,u32 cac_time_ms)3592 mwifiex_cfg80211_start_radar_detection(struct wiphy *wiphy,
3593 				       struct net_device *dev,
3594 				       struct cfg80211_chan_def *chandef,
3595 				       u32 cac_time_ms)
3596 {
3597 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3598 	struct mwifiex_radar_params radar_params;
3599 
3600 	if (priv->adapter->scan_processing) {
3601 		mwifiex_dbg(priv->adapter, ERROR,
3602 			    "radar detection: scan already in process...\n");
3603 		return -EBUSY;
3604 	}
3605 
3606 	if (!mwifiex_is_11h_active(priv)) {
3607 		mwifiex_dbg(priv->adapter, INFO,
3608 			    "Enable 11h extensions in FW\n");
3609 		if (mwifiex_11h_activate(priv, true)) {
3610 			mwifiex_dbg(priv->adapter, ERROR,
3611 				    "Failed to activate 11h extensions!!");
3612 			return -1;
3613 		}
3614 		priv->state_11h.is_11h_active = true;
3615 	}
3616 
3617 	memset(&radar_params, 0, sizeof(struct mwifiex_radar_params));
3618 	radar_params.chandef = chandef;
3619 	radar_params.cac_time_ms = cac_time_ms;
3620 
3621 	memcpy(&priv->dfs_chandef, chandef, sizeof(priv->dfs_chandef));
3622 
3623 	if (mwifiex_send_cmd(priv, HostCmd_CMD_CHAN_REPORT_REQUEST,
3624 			     HostCmd_ACT_GEN_SET, 0, &radar_params, true))
3625 		return -1;
3626 
3627 	queue_delayed_work(priv->dfs_cac_workqueue, &priv->dfs_cac_work,
3628 			   msecs_to_jiffies(cac_time_ms));
3629 	return 0;
3630 }
3631 
3632 static int
mwifiex_cfg80211_change_station(struct wiphy * wiphy,struct net_device * dev,const u8 * mac,struct station_parameters * params)3633 mwifiex_cfg80211_change_station(struct wiphy *wiphy, struct net_device *dev,
3634 				const u8 *mac,
3635 				struct station_parameters *params)
3636 {
3637 	int ret;
3638 	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3639 
3640 	/* we support change_station handler only for TDLS peers*/
3641 	if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3642 		return -ENOTSUPP;
3643 
3644 	/* make sure we are in station mode and connected */
3645 	if ((priv->bss_type != MWIFIEX_BSS_TYPE_STA) || !priv->media_connected)
3646 		return -ENOTSUPP;
3647 
3648 	priv->sta_params = params;
3649 
3650 	ret = mwifiex_tdls_oper(priv, mac, MWIFIEX_TDLS_CONFIG_LINK);
3651 	priv->sta_params = NULL;
3652 
3653 	return ret;
3654 }
3655 
3656 /* station cfg80211 operations */
3657 static struct cfg80211_ops mwifiex_cfg80211_ops = {
3658 	.add_virtual_intf = mwifiex_add_virtual_intf,
3659 	.del_virtual_intf = mwifiex_del_virtual_intf,
3660 	.change_virtual_intf = mwifiex_cfg80211_change_virtual_intf,
3661 	.scan = mwifiex_cfg80211_scan,
3662 	.connect = mwifiex_cfg80211_connect,
3663 	.disconnect = mwifiex_cfg80211_disconnect,
3664 	.get_station = mwifiex_cfg80211_get_station,
3665 	.dump_station = mwifiex_cfg80211_dump_station,
3666 	.dump_survey = mwifiex_cfg80211_dump_survey,
3667 	.set_wiphy_params = mwifiex_cfg80211_set_wiphy_params,
3668 	.join_ibss = mwifiex_cfg80211_join_ibss,
3669 	.leave_ibss = mwifiex_cfg80211_leave_ibss,
3670 	.add_key = mwifiex_cfg80211_add_key,
3671 	.del_key = mwifiex_cfg80211_del_key,
3672 	.mgmt_tx = mwifiex_cfg80211_mgmt_tx,
3673 	.mgmt_frame_register = mwifiex_cfg80211_mgmt_frame_register,
3674 	.remain_on_channel = mwifiex_cfg80211_remain_on_channel,
3675 	.cancel_remain_on_channel = mwifiex_cfg80211_cancel_remain_on_channel,
3676 	.set_default_key = mwifiex_cfg80211_set_default_key,
3677 	.set_power_mgmt = mwifiex_cfg80211_set_power_mgmt,
3678 	.set_tx_power = mwifiex_cfg80211_set_tx_power,
3679 	.set_bitrate_mask = mwifiex_cfg80211_set_bitrate_mask,
3680 	.start_ap = mwifiex_cfg80211_start_ap,
3681 	.stop_ap = mwifiex_cfg80211_stop_ap,
3682 	.change_beacon = mwifiex_cfg80211_change_beacon,
3683 	.set_cqm_rssi_config = mwifiex_cfg80211_set_cqm_rssi_config,
3684 	.set_antenna = mwifiex_cfg80211_set_antenna,
3685 	.del_station = mwifiex_cfg80211_del_station,
3686 #ifdef CONFIG_PM
3687 	.suspend = mwifiex_cfg80211_suspend,
3688 	.resume = mwifiex_cfg80211_resume,
3689 	.set_wakeup = mwifiex_cfg80211_set_wakeup,
3690 #endif
3691 	.set_coalesce = mwifiex_cfg80211_set_coalesce,
3692 	.tdls_mgmt = mwifiex_cfg80211_tdls_mgmt,
3693 	.tdls_oper = mwifiex_cfg80211_tdls_oper,
3694 	.tdls_channel_switch = mwifiex_cfg80211_tdls_chan_switch,
3695 	.tdls_cancel_channel_switch = mwifiex_cfg80211_tdls_cancel_chan_switch,
3696 	.add_station = mwifiex_cfg80211_add_station,
3697 	.change_station = mwifiex_cfg80211_change_station,
3698 	.get_channel = mwifiex_cfg80211_get_channel,
3699 	.start_radar_detection = mwifiex_cfg80211_start_radar_detection,
3700 	.channel_switch = mwifiex_cfg80211_channel_switch,
3701 };
3702 
3703 #ifdef CONFIG_PM
3704 static const struct wiphy_wowlan_support mwifiex_wowlan_support = {
3705 	.flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
3706 	.n_patterns = MWIFIEX_MEF_MAX_FILTERS,
3707 	.pattern_min_len = 1,
3708 	.pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
3709 	.max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
3710 };
3711 #endif
3712 
mwifiex_is_valid_alpha2(const char * alpha2)3713 static bool mwifiex_is_valid_alpha2(const char *alpha2)
3714 {
3715 	if (!alpha2 || strlen(alpha2) != 2)
3716 		return false;
3717 
3718 	if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
3719 		return true;
3720 
3721 	return false;
3722 }
3723 
3724 static const struct wiphy_coalesce_support mwifiex_coalesce_support = {
3725 	.n_rules = MWIFIEX_COALESCE_MAX_RULES,
3726 	.max_delay = MWIFIEX_MAX_COALESCING_DELAY,
3727 	.n_patterns = MWIFIEX_COALESCE_MAX_FILTERS,
3728 	.pattern_min_len = 1,
3729 	.pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
3730 	.max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
3731 };
3732 
mwifiex_init_channel_scan_gap(struct mwifiex_adapter * adapter)3733 int mwifiex_init_channel_scan_gap(struct mwifiex_adapter *adapter)
3734 {
3735 	u32 n_channels_bg, n_channels_a = 0;
3736 
3737 	n_channels_bg = mwifiex_band_2ghz.n_channels;
3738 
3739 	if (adapter->config_bands & BAND_A)
3740 		n_channels_a = mwifiex_band_5ghz.n_channels;
3741 
3742 	adapter->num_in_chan_stats = max_t(u32, n_channels_bg, n_channels_a);
3743 	adapter->chan_stats = vmalloc(sizeof(*adapter->chan_stats) *
3744 				      adapter->num_in_chan_stats);
3745 
3746 	if (!adapter->chan_stats)
3747 		return -ENOMEM;
3748 
3749 	return 0;
3750 }
3751 
3752 /*
3753  * This function registers the device with CFG802.11 subsystem.
3754  *
3755  * The function creates the wireless device/wiphy, populates it with
3756  * default parameters and handler function pointers, and finally
3757  * registers the device.
3758  */
3759 
mwifiex_register_cfg80211(struct mwifiex_adapter * adapter)3760 int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
3761 {
3762 	int ret;
3763 	void *wdev_priv;
3764 	struct wiphy *wiphy;
3765 	struct mwifiex_private *priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
3766 	u8 *country_code;
3767 	u32 thr, retry;
3768 
3769 	/* create a new wiphy for use with cfg80211 */
3770 	wiphy = wiphy_new(&mwifiex_cfg80211_ops,
3771 			  sizeof(struct mwifiex_adapter *));
3772 	if (!wiphy) {
3773 		mwifiex_dbg(adapter, ERROR,
3774 			    "%s: creating new wiphy\n", __func__);
3775 		return -ENOMEM;
3776 	}
3777 	wiphy->max_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
3778 	wiphy->max_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
3779 	wiphy->mgmt_stypes = mwifiex_mgmt_stypes;
3780 	wiphy->max_remain_on_channel_duration = 5000;
3781 	wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3782 				 BIT(NL80211_IFTYPE_ADHOC) |
3783 				 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3784 				 BIT(NL80211_IFTYPE_P2P_GO) |
3785 				 BIT(NL80211_IFTYPE_AP);
3786 
3787 	wiphy->bands[IEEE80211_BAND_2GHZ] = &mwifiex_band_2ghz;
3788 	if (adapter->config_bands & BAND_A)
3789 		wiphy->bands[IEEE80211_BAND_5GHZ] = &mwifiex_band_5ghz;
3790 	else
3791 		wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
3792 
3793 	if (adapter->drcs_enabled && ISSUPP_DRCS_ENABLED(adapter->fw_cap_info))
3794 		wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta_drcs;
3795 	else if (adapter->is_hw_11ac_capable)
3796 		wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta_vht;
3797 	else
3798 		wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta;
3799 	wiphy->n_iface_combinations = 1;
3800 
3801 	/* Initialize cipher suits */
3802 	wiphy->cipher_suites = mwifiex_cipher_suites;
3803 	wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
3804 
3805 	ether_addr_copy(wiphy->perm_addr, adapter->perm_addr);
3806 	wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
3807 	wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
3808 			WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD |
3809 			WIPHY_FLAG_AP_UAPSD |
3810 			WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
3811 			WIPHY_FLAG_HAS_CHANNEL_SWITCH |
3812 			WIPHY_FLAG_PS_ON_BY_DEFAULT;
3813 
3814 	if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
3815 		wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
3816 				WIPHY_FLAG_TDLS_EXTERNAL_SETUP;
3817 
3818 #ifdef CONFIG_PM
3819 	wiphy->wowlan = &mwifiex_wowlan_support;
3820 #endif
3821 
3822 	wiphy->coalesce = &mwifiex_coalesce_support;
3823 
3824 	wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
3825 				    NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
3826 				    NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
3827 
3828 	wiphy->available_antennas_tx = BIT(adapter->number_of_antenna) - 1;
3829 	wiphy->available_antennas_rx = BIT(adapter->number_of_antenna) - 1;
3830 
3831 	wiphy->features |= NL80211_FEATURE_HT_IBSS |
3832 			   NL80211_FEATURE_INACTIVITY_TIMER |
3833 			   NL80211_FEATURE_NEED_OBSS_SCAN;
3834 
3835 	if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
3836 		wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
3837 
3838 	if (adapter->fw_api_ver == MWIFIEX_FW_V15)
3839 		wiphy->features |= NL80211_FEATURE_SK_TX_STATUS;
3840 
3841 	/* Reserve space for mwifiex specific private data for BSS */
3842 	wiphy->bss_priv_size = sizeof(struct mwifiex_bss_priv);
3843 
3844 	wiphy->reg_notifier = mwifiex_reg_notifier;
3845 
3846 	/* Set struct mwifiex_adapter pointer in wiphy_priv */
3847 	wdev_priv = wiphy_priv(wiphy);
3848 	*(unsigned long *)wdev_priv = (unsigned long)adapter;
3849 
3850 	set_wiphy_dev(wiphy, priv->adapter->dev);
3851 
3852 	ret = wiphy_register(wiphy);
3853 	if (ret < 0) {
3854 		mwifiex_dbg(adapter, ERROR,
3855 			    "%s: wiphy_register failed: %d\n", __func__, ret);
3856 		wiphy_free(wiphy);
3857 		return ret;
3858 	}
3859 
3860 	if (reg_alpha2 && mwifiex_is_valid_alpha2(reg_alpha2)) {
3861 		mwifiex_dbg(adapter, INFO,
3862 			    "driver hint alpha2: %2.2s\n", reg_alpha2);
3863 		regulatory_hint(wiphy, reg_alpha2);
3864 	} else {
3865 		country_code = mwifiex_11d_code_2_region(adapter->region_code);
3866 		if (country_code)
3867 			mwifiex_dbg(adapter, WARN,
3868 				    "ignoring F/W country code %2.2s\n",
3869 				    country_code);
3870 	}
3871 
3872 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
3873 			 HostCmd_ACT_GEN_GET, FRAG_THRESH_I, &thr, true);
3874 	wiphy->frag_threshold = thr;
3875 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
3876 			 HostCmd_ACT_GEN_GET, RTS_THRESH_I, &thr, true);
3877 	wiphy->rts_threshold = thr;
3878 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
3879 			 HostCmd_ACT_GEN_GET, SHORT_RETRY_LIM_I, &retry, true);
3880 	wiphy->retry_short = (u8) retry;
3881 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
3882 			 HostCmd_ACT_GEN_GET, LONG_RETRY_LIM_I, &retry, true);
3883 	wiphy->retry_long = (u8) retry;
3884 
3885 	adapter->wiphy = wiphy;
3886 	return ret;
3887 }
3888