projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mwifiex: check for bss_role instead of bss_mode for STA operations
[deliverable/linux.git] / drivers / net / wireless / mwifiex / cfg80211.c
1 /*
2 * Marvell Wireless LAN device driver: CFG80211
3 *
4 * Copyright (C) 2011, 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
23 static char *reg_alpha2;
24 module_param(reg_alpha2, charp, 0);
25
26 static const struct ieee80211_iface_limit mwifiex_ap_sta_limits[] = {
27 {
28 .max = 2, .types = BIT(NL80211_IFTYPE_STATION),
29 },
30 {
31 .max = 1, .types = BIT(NL80211_IFTYPE_AP),
32 },
33 };
34
35 static const struct ieee80211_iface_combination mwifiex_iface_comb_ap_sta = {
36 .limits = mwifiex_ap_sta_limits,
37 .num_different_channels = 1,
38 .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
39 .max_interfaces = MWIFIEX_MAX_BSS_NUM,
40 .beacon_int_infra_match = true,
41 };
42
43 static const struct ieee80211_regdomain mwifiex_world_regdom_custom = {
44 .n_reg_rules = 7,
45 .alpha2 = "99",
46 .reg_rules = {
47 /* Channel 1 - 11 */
48 REG_RULE(2412-10, 2462+10, 40, 3, 20, 0),
49 /* Channel 12 - 13 */
50 REG_RULE(2467-10, 2472+10, 20, 3, 20,
51 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
52 /* Channel 14 */
53 REG_RULE(2484-10, 2484+10, 20, 3, 20,
54 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
55 NL80211_RRF_NO_OFDM),
56 /* Channel 36 - 48 */
57 REG_RULE(5180-10, 5240+10, 40, 3, 20,
58 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
59 /* Channel 149 - 165 */
60 REG_RULE(5745-10, 5825+10, 40, 3, 20,
61 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS),
62 /* Channel 52 - 64 */
63 REG_RULE(5260-10, 5320+10, 40, 3, 30,
64 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
65 NL80211_RRF_DFS),
66 /* Channel 100 - 140 */
67 REG_RULE(5500-10, 5700+10, 40, 3, 30,
68 NL80211_RRF_PASSIVE_SCAN | NL80211_RRF_NO_IBSS |
69 NL80211_RRF_DFS),
70 }
71 };
72
73 /*
74 * This function maps the nl802.11 channel type into driver channel type.
75 *
76 * The mapping is as follows -
77 * NL80211_CHAN_NO_HT -> IEEE80211_HT_PARAM_CHA_SEC_NONE
78 * NL80211_CHAN_HT20 -> IEEE80211_HT_PARAM_CHA_SEC_NONE
79 * NL80211_CHAN_HT40PLUS -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE
80 * NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW
81 * Others -> IEEE80211_HT_PARAM_CHA_SEC_NONE
82 */
83 u8 mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type)
84 {
85 switch (chan_type) {
86 case NL80211_CHAN_NO_HT:
87 case NL80211_CHAN_HT20:
88 return IEEE80211_HT_PARAM_CHA_SEC_NONE;
89 case NL80211_CHAN_HT40PLUS:
90 return IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
91 case NL80211_CHAN_HT40MINUS:
92 return IEEE80211_HT_PARAM_CHA_SEC_BELOW;
93 default:
94 return IEEE80211_HT_PARAM_CHA_SEC_NONE;
95 }
96 }
97
98 /*
99 * This function checks whether WEP is set.
100 */
101 static int
102 mwifiex_is_alg_wep(u32 cipher)
103 {
104 switch (cipher) {
105 case WLAN_CIPHER_SUITE_WEP40:
106 case WLAN_CIPHER_SUITE_WEP104:
107 return 1;
108 default:
109 break;
110 }
111
112 return 0;
113 }
114
115 /*
116 * This function retrieves the private structure from kernel wiphy structure.
117 */
118 static void *mwifiex_cfg80211_get_adapter(struct wiphy *wiphy)
119 {
120 return (void *) (*(unsigned long *) wiphy_priv(wiphy));
121 }
122
123 /*
124 * CFG802.11 operation handler to delete a network key.
125 */
126 static int
127 mwifiex_cfg80211_del_key(struct wiphy *wiphy, struct net_device *netdev,
128 u8 key_index, bool pairwise, const u8 *mac_addr)
129 {
130 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
131 const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
132 const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
133
134 if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index, peer_mac, 1)) {
135 wiphy_err(wiphy, "deleting the crypto keys\n");
136 return -EFAULT;
137 }
138
139 wiphy_dbg(wiphy, "info: crypto keys deleted\n");
140 return 0;
141 }
142
143 /*
144 * This function forms an skb for management frame.
145 */
146 static int
147 mwifiex_form_mgmt_frame(struct sk_buff *skb, const u8 *buf, size_t len)
148 {
149 u8 addr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
150 u16 pkt_len;
151 u32 tx_control = 0, pkt_type = PKT_TYPE_MGMT;
152 struct timeval tv;
153
154 pkt_len = len + ETH_ALEN;
155
156 skb_reserve(skb, MWIFIEX_MIN_DATA_HEADER_LEN +
157 MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(pkt_len));
158 memcpy(skb_push(skb, sizeof(pkt_len)), &pkt_len, sizeof(pkt_len));
159
160 memcpy(skb_push(skb, sizeof(tx_control)),
161 &tx_control, sizeof(tx_control));
162
163 memcpy(skb_push(skb, sizeof(pkt_type)), &pkt_type, sizeof(pkt_type));
164
165 /* Add packet data and address4 */
166 memcpy(skb_put(skb, sizeof(struct ieee80211_hdr_3addr)), buf,
167 sizeof(struct ieee80211_hdr_3addr));
168 memcpy(skb_put(skb, ETH_ALEN), addr, ETH_ALEN);
169 memcpy(skb_put(skb, len - sizeof(struct ieee80211_hdr_3addr)),
170 buf + sizeof(struct ieee80211_hdr_3addr),
171 len - sizeof(struct ieee80211_hdr_3addr));
172
173 skb->priority = LOW_PRIO_TID;
174 do_gettimeofday(&tv);
175 skb->tstamp = timeval_to_ktime(tv);
176
177 return 0;
178 }
179
180 /*
181 * CFG802.11 operation handler to transmit a management frame.
182 */
183 static int
184 mwifiex_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
185 struct ieee80211_channel *chan, bool offchan,
186 unsigned int wait, const u8 *buf, size_t len,
187 bool no_cck, bool dont_wait_for_ack, u64 *cookie)
188 {
189 struct sk_buff *skb;
190 u16 pkt_len;
191 const struct ieee80211_mgmt *mgmt;
192 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
193
194 if (!buf || !len) {
195 wiphy_err(wiphy, "invalid buffer and length\n");
196 return -EFAULT;
197 }
198
199 mgmt = (const struct ieee80211_mgmt *)buf;
200 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA &&
201 ieee80211_is_probe_resp(mgmt->frame_control)) {
202 /* Since we support offload probe resp, we need to skip probe
203 * resp in AP or GO mode */
204 wiphy_dbg(wiphy,
205 "info: skip to send probe resp in AP or GO mode\n");
206 return 0;
207 }
208
209 pkt_len = len + ETH_ALEN;
210 skb = dev_alloc_skb(MWIFIEX_MIN_DATA_HEADER_LEN +
211 MWIFIEX_MGMT_FRAME_HEADER_SIZE +
212 pkt_len + sizeof(pkt_len));
213
214 if (!skb) {
215 wiphy_err(wiphy, "allocate skb failed for management frame\n");
216 return -ENOMEM;
217 }
218
219 mwifiex_form_mgmt_frame(skb, buf, len);
220 mwifiex_queue_tx_pkt(priv, skb);
221
222 *cookie = prandom_u32() | 1;
223 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true, GFP_ATOMIC);
224
225 wiphy_dbg(wiphy, "info: management frame transmitted\n");
226 return 0;
227 }
228
229 /*
230 * CFG802.11 operation handler to register a mgmt frame.
231 */
232 static void
233 mwifiex_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
234 struct wireless_dev *wdev,
235 u16 frame_type, bool reg)
236 {
237 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
238
239 if (reg)
240 priv->mgmt_frame_mask |= BIT(frame_type >> 4);
241 else
242 priv->mgmt_frame_mask &= ~BIT(frame_type >> 4);
243
244 mwifiex_send_cmd_async(priv, HostCmd_CMD_MGMT_FRAME_REG,
245 HostCmd_ACT_GEN_SET, 0, &priv->mgmt_frame_mask);
246
247 wiphy_dbg(wiphy, "info: mgmt frame registered\n");
248 }
249
250 /*
251 * CFG802.11 operation handler to remain on channel.
252 */
253 static int
254 mwifiex_cfg80211_remain_on_channel(struct wiphy *wiphy,
255 struct wireless_dev *wdev,
256 struct ieee80211_channel *chan,
257 unsigned int duration, u64 *cookie)
258 {
259 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
260 int ret;
261
262 if (!chan || !cookie) {
263 wiphy_err(wiphy, "Invalid parameter for ROC\n");
264 return -EINVAL;
265 }
266
267 if (priv->roc_cfg.cookie) {
268 wiphy_dbg(wiphy, "info: ongoing ROC, cookie = 0x%llu\n",
269 priv->roc_cfg.cookie);
270 return -EBUSY;
271 }
272
273 ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_SET, chan,
274 duration);
275
276 if (!ret) {
277 *cookie = prandom_u32() | 1;
278 priv->roc_cfg.cookie = *cookie;
279 priv->roc_cfg.chan = *chan;
280
281 cfg80211_ready_on_channel(wdev, *cookie, chan,
282 duration, GFP_ATOMIC);
283
284 wiphy_dbg(wiphy, "info: ROC, cookie = 0x%llx\n", *cookie);
285 }
286
287 return ret;
288 }
289
290 /*
291 * CFG802.11 operation handler to cancel remain on channel.
292 */
293 static int
294 mwifiex_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
295 struct wireless_dev *wdev, u64 cookie)
296 {
297 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
298 int ret;
299
300 if (cookie != priv->roc_cfg.cookie)
301 return -ENOENT;
302
303 ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_REMOVE,
304 &priv->roc_cfg.chan, 0);
305
306 if (!ret) {
307 cfg80211_remain_on_channel_expired(wdev, cookie,
308 &priv->roc_cfg.chan,
309 GFP_ATOMIC);
310
311 memset(&priv->roc_cfg, 0, sizeof(struct mwifiex_roc_cfg));
312
313 wiphy_dbg(wiphy, "info: cancel ROC, cookie = 0x%llx\n", cookie);
314 }
315
316 return ret;
317 }
318
319 /*
320 * CFG802.11 operation handler to set Tx power.
321 */
322 static int
323 mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy,
324 struct wireless_dev *wdev,
325 enum nl80211_tx_power_setting type,
326 int mbm)
327 {
328 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
329 struct mwifiex_private *priv;
330 struct mwifiex_power_cfg power_cfg;
331 int dbm = MBM_TO_DBM(mbm);
332
333 if (type == NL80211_TX_POWER_FIXED) {
334 power_cfg.is_power_auto = 0;
335 power_cfg.power_level = dbm;
336 } else {
337 power_cfg.is_power_auto = 1;
338 }
339
340 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
341
342 return mwifiex_set_tx_power(priv, &power_cfg);
343 }
344
345 /*
346 * CFG802.11 operation handler to set Power Save option.
347 *
348 * The timeout value, if provided, is currently ignored.
349 */
350 static int
351 mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy,
352 struct net_device *dev,
353 bool enabled, int timeout)
354 {
355 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
356 u32 ps_mode;
357
358 if (timeout)
359 wiphy_dbg(wiphy,
360 "info: ignore timeout value for IEEE Power Save\n");
361
362 ps_mode = enabled;
363
364 return mwifiex_drv_set_power(priv, &ps_mode);
365 }
366
367 /*
368 * CFG802.11 operation handler to set the default network key.
369 */
370 static int
371 mwifiex_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
372 u8 key_index, bool unicast,
373 bool multicast)
374 {
375 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
376
377 /* Return if WEP key not configured */
378 if (!priv->sec_info.wep_enabled)
379 return 0;
380
381 if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP) {
382 priv->wep_key_curr_index = key_index;
383 } else if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index,
384 NULL, 0)) {
385 wiphy_err(wiphy, "set default Tx key index\n");
386 return -EFAULT;
387 }
388
389 return 0;
390 }
391
392 /*
393 * CFG802.11 operation handler to add a network key.
394 */
395 static int
396 mwifiex_cfg80211_add_key(struct wiphy *wiphy, struct net_device *netdev,
397 u8 key_index, bool pairwise, const u8 *mac_addr,
398 struct key_params *params)
399 {
400 struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
401 struct mwifiex_wep_key *wep_key;
402 const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
403 const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
404
405 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
406 (params->cipher == WLAN_CIPHER_SUITE_WEP40 ||
407 params->cipher == WLAN_CIPHER_SUITE_WEP104)) {
408 if (params->key && params->key_len) {
409 wep_key = &priv->wep_key[key_index];
410 memset(wep_key, 0, sizeof(struct mwifiex_wep_key));
411 memcpy(wep_key->key_material, params->key,
412 params->key_len);
413 wep_key->key_index = key_index;
414 wep_key->key_length = params->key_len;
415 priv->sec_info.wep_enabled = 1;
416 }
417 return 0;
418 }
419
420 if (mwifiex_set_encode(priv, params, params->key, params->key_len,
421 key_index, peer_mac, 0)) {
422 wiphy_err(wiphy, "crypto keys added\n");
423 return -EFAULT;
424 }
425
426 return 0;
427 }
428
429 /*
430 * This function sends domain information to the firmware.
431 *
432 * The following information are passed to the firmware -
433 * - Country codes
434 * - Sub bands (first channel, number of channels, maximum Tx power)
435 */
436 static int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
437 {
438 u8 no_of_triplet = 0;
439 struct ieee80211_country_ie_triplet *t;
440 u8 no_of_parsed_chan = 0;
441 u8 first_chan = 0, next_chan = 0, max_pwr = 0;
442 u8 i, flag = 0;
443 enum ieee80211_band band;
444 struct ieee80211_supported_band *sband;
445 struct ieee80211_channel *ch;
446 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
447 struct mwifiex_private *priv;
448 struct mwifiex_802_11d_domain_reg *domain_info = &adapter->domain_reg;
449
450 /* Set country code */
451 domain_info->country_code[0] = adapter->country_code[0];
452 domain_info->country_code[1] = adapter->country_code[1];
453 domain_info->country_code[2] = ' ';
454
455 band = mwifiex_band_to_radio_type(adapter->config_bands);
456 if (!wiphy->bands[band]) {
457 wiphy_err(wiphy, "11D: setting domain info in FW\n");
458 return -1;
459 }
460
461 sband = wiphy->bands[band];
462
463 for (i = 0; i < sband->n_channels ; i++) {
464 ch = &sband->channels[i];
465 if (ch->flags & IEEE80211_CHAN_DISABLED)
466 continue;
467
468 if (!flag) {
469 flag = 1;
470 first_chan = (u32) ch->hw_value;
471 next_chan = first_chan;
472 max_pwr = ch->max_power;
473 no_of_parsed_chan = 1;
474 continue;
475 }
476
477 if (ch->hw_value == next_chan + 1 &&
478 ch->max_power == max_pwr) {
479 next_chan++;
480 no_of_parsed_chan++;
481 } else {
482 t = &domain_info->triplet[no_of_triplet];
483 t->chans.first_channel = first_chan;
484 t->chans.num_channels = no_of_parsed_chan;
485 t->chans.max_power = max_pwr;
486 no_of_triplet++;
487 first_chan = (u32) ch->hw_value;
488 next_chan = first_chan;
489 max_pwr = ch->max_power;
490 no_of_parsed_chan = 1;
491 }
492 }
493
494 if (flag) {
495 t = &domain_info->triplet[no_of_triplet];
496 t->chans.first_channel = first_chan;
497 t->chans.num_channels = no_of_parsed_chan;
498 t->chans.max_power = max_pwr;
499 no_of_triplet++;
500 }
501
502 domain_info->no_of_triplet = no_of_triplet;
503
504 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
505
506 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,
507 HostCmd_ACT_GEN_SET, 0, NULL)) {
508 wiphy_err(wiphy, "11D: setting domain info in FW\n");
509 return -1;
510 }
511
512 return 0;
513 }
514
515 /*
516 * CFG802.11 regulatory domain callback function.
517 *
518 * This function is called when the regulatory domain is changed due to the
519 * following reasons -
520 * - Set by driver
521 * - Set by system core
522 * - Set by user
523 * - Set bt Country IE
524 */
525 static void mwifiex_reg_notifier(struct wiphy *wiphy,
526 struct regulatory_request *request)
527 {
528 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
529
530 wiphy_dbg(wiphy, "info: cfg80211 regulatory domain callback for %c%c\n",
531 request->alpha2[0], request->alpha2[1]);
532
533 memcpy(adapter->country_code, request->alpha2, sizeof(request->alpha2));
534
535 switch (request->initiator) {
536 case NL80211_REGDOM_SET_BY_DRIVER:
537 case NL80211_REGDOM_SET_BY_CORE:
538 case NL80211_REGDOM_SET_BY_USER:
539 break;
540 /* Todo: apply driver specific changes in channel flags based
541 on the request initiator if necessary. */
542 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
543 break;
544 }
545 mwifiex_send_domain_info_cmd_fw(wiphy);
546 }
547
548 /*
549 * This function sets the fragmentation threshold.
550 *
551 * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE
552 * and MWIFIEX_FRAG_MAX_VALUE.
553 */
554 static int
555 mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)
556 {
557 if (frag_thr < MWIFIEX_FRAG_MIN_VALUE ||
558 frag_thr > MWIFIEX_FRAG_MAX_VALUE)
559 frag_thr = MWIFIEX_FRAG_MAX_VALUE;
560
561 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
562 HostCmd_ACT_GEN_SET, FRAG_THRESH_I,
563 &frag_thr);
564 }
565
566 /*
567 * This function sets the RTS threshold.
568
569 * The rts value must lie between MWIFIEX_RTS_MIN_VALUE
570 * and MWIFIEX_RTS_MAX_VALUE.
571 */
572 static int
573 mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)
574 {
575 if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)
576 rts_thr = MWIFIEX_RTS_MAX_VALUE;
577
578 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
579 HostCmd_ACT_GEN_SET, RTS_THRESH_I,
580 &rts_thr);
581 }
582
583 /*
584 * CFG802.11 operation handler to set wiphy parameters.
585 *
586 * This function can be used to set the RTS threshold and the
587 * Fragmentation threshold of the driver.
588 */
589 static int
590 mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
591 {
592 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
593 struct mwifiex_private *priv;
594 struct mwifiex_uap_bss_param *bss_cfg;
595 int ret, bss_started, i;
596
597 for (i = 0; i < adapter->priv_num; i++) {
598 priv = adapter->priv[i];
599
600 switch (priv->bss_role) {
601 case MWIFIEX_BSS_ROLE_UAP:
602 bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param),
603 GFP_KERNEL);
604 if (!bss_cfg)
605 return -ENOMEM;
606
607 mwifiex_set_sys_config_invalid_data(bss_cfg);
608
609 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
610 bss_cfg->rts_threshold = wiphy->rts_threshold;
611 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
612 bss_cfg->frag_threshold = wiphy->frag_threshold;
613 if (changed & WIPHY_PARAM_RETRY_LONG)
614 bss_cfg->retry_limit = wiphy->retry_long;
615
616 bss_started = priv->bss_started;
617
618 ret = mwifiex_send_cmd_sync(priv,
619 HostCmd_CMD_UAP_BSS_STOP,
620 HostCmd_ACT_GEN_SET, 0,
621 NULL);
622 if (ret) {
623 wiphy_err(wiphy, "Failed to stop the BSS\n");
624 kfree(bss_cfg);
625 return ret;
626 }
627
628 ret = mwifiex_send_cmd_async(priv,
629 HostCmd_CMD_UAP_SYS_CONFIG,
630 HostCmd_ACT_GEN_SET,
631 UAP_BSS_PARAMS_I, bss_cfg);
632
633 kfree(bss_cfg);
634
635 if (ret) {
636 wiphy_err(wiphy, "Failed to set bss config\n");
637 return ret;
638 }
639
640 if (!bss_started)
641 break;
642
643 ret = mwifiex_send_cmd_async(priv,
644 HostCmd_CMD_UAP_BSS_START,
645 HostCmd_ACT_GEN_SET, 0,
646 NULL);
647 if (ret) {
648 wiphy_err(wiphy, "Failed to start BSS\n");
649 return ret;
650 }
651
652 break;
653 case MWIFIEX_BSS_ROLE_STA:
654 if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
655 ret = mwifiex_set_rts(priv,
656 wiphy->rts_threshold);
657 if (ret)
658 return ret;
659 }
660 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
661 ret = mwifiex_set_frag(priv,
662 wiphy->frag_threshold);
663 if (ret)
664 return ret;
665 }
666 break;
667 }
668 }
669
670 return 0;
671 }
672
673 static int
674 mwifiex_cfg80211_deinit_p2p(struct mwifiex_private *priv)
675 {
676 u16 mode = P2P_MODE_DISABLE;
677
678 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA)
679 mwifiex_set_bss_role(priv, MWIFIEX_BSS_ROLE_STA);
680
681 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_P2P_MODE_CFG,
682 HostCmd_ACT_GEN_SET, 0, &mode))
683 return -1;
684
685 return 0;
686 }
687
688 /*
689 * This function initializes the functionalities for P2P client.
690 * The P2P client initialization sequence is:
691 * disable -> device -> client
692 */
693 static int
694 mwifiex_cfg80211_init_p2p_client(struct mwifiex_private *priv)
695 {
696 u16 mode;
697
698 if (mwifiex_cfg80211_deinit_p2p(priv))
699 return -1;
700
701 mode = P2P_MODE_DEVICE;
702 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_P2P_MODE_CFG,
703 HostCmd_ACT_GEN_SET, 0, &mode))
704 return -1;
705
706 mode = P2P_MODE_CLIENT;
707 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_P2P_MODE_CFG,
708 HostCmd_ACT_GEN_SET, 0, &mode))
709 return -1;
710
711 return 0;
712 }
713
714 /*
715 * This function initializes the functionalities for P2P GO.
716 * The P2P GO initialization sequence is:
717 * disable -> device -> GO
718 */
719 static int
720 mwifiex_cfg80211_init_p2p_go(struct mwifiex_private *priv)
721 {
722 u16 mode;
723
724 if (mwifiex_cfg80211_deinit_p2p(priv))
725 return -1;
726
727 mode = P2P_MODE_DEVICE;
728 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_P2P_MODE_CFG,
729 HostCmd_ACT_GEN_SET, 0, &mode))
730 return -1;
731
732 mode = P2P_MODE_GO;
733 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_P2P_MODE_CFG,
734 HostCmd_ACT_GEN_SET, 0, &mode))
735 return -1;
736
737 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
738 mwifiex_set_bss_role(priv, MWIFIEX_BSS_ROLE_UAP);
739
740 return 0;
741 }
742
743 /*
744 * CFG802.11 operation handler to change interface type.
745 */
746 static int
747 mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
748 struct net_device *dev,
749 enum nl80211_iftype type, u32 *flags,
750 struct vif_params *params)
751 {
752 int ret;
753 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
754
755 switch (dev->ieee80211_ptr->iftype) {
756 case NL80211_IFTYPE_ADHOC:
757 switch (type) {
758 case NL80211_IFTYPE_STATION:
759 break;
760 case NL80211_IFTYPE_UNSPECIFIED:
761 wiphy_warn(wiphy, "%s: kept type as IBSS\n", dev->name);
762 case NL80211_IFTYPE_ADHOC: /* This shouldn't happen */
763 return 0;
764 case NL80211_IFTYPE_AP:
765 default:
766 wiphy_err(wiphy, "%s: changing to %d not supported\n",
767 dev->name, type);
768 return -EOPNOTSUPP;
769 }
770 break;
771 case NL80211_IFTYPE_STATION:
772 switch (type) {
773 case NL80211_IFTYPE_ADHOC:
774 break;
775 case NL80211_IFTYPE_P2P_CLIENT:
776 if (mwifiex_cfg80211_init_p2p_client(priv))
777 return -EFAULT;
778 dev->ieee80211_ptr->iftype = type;
779 return 0;
780 case NL80211_IFTYPE_P2P_GO:
781 if (mwifiex_cfg80211_init_p2p_go(priv))
782 return -EFAULT;
783 dev->ieee80211_ptr->iftype = type;
784 return 0;
785 case NL80211_IFTYPE_UNSPECIFIED:
786 wiphy_warn(wiphy, "%s: kept type as STA\n", dev->name);
787 case NL80211_IFTYPE_STATION: /* This shouldn't happen */
788 return 0;
789 case NL80211_IFTYPE_AP:
790 default:
791 wiphy_err(wiphy, "%s: changing to %d not supported\n",
792 dev->name, type);
793 return -EOPNOTSUPP;
794 }
795 break;
796 case NL80211_IFTYPE_AP:
797 switch (type) {
798 case NL80211_IFTYPE_UNSPECIFIED:
799 wiphy_warn(wiphy, "%s: kept type as AP\n", dev->name);
800 case NL80211_IFTYPE_AP: /* This shouldn't happen */
801 return 0;
802 case NL80211_IFTYPE_ADHOC:
803 case NL80211_IFTYPE_STATION:
804 default:
805 wiphy_err(wiphy, "%s: changing to %d not supported\n",
806 dev->name, type);
807 return -EOPNOTSUPP;
808 }
809 break;
810 case NL80211_IFTYPE_P2P_CLIENT:
811 case NL80211_IFTYPE_P2P_GO:
812 switch (type) {
813 case NL80211_IFTYPE_STATION:
814 if (mwifiex_cfg80211_deinit_p2p(priv))
815 return -EFAULT;
816 dev->ieee80211_ptr->iftype = type;
817 return 0;
818 default:
819 return -EOPNOTSUPP;
820 }
821 break;
822 default:
823 wiphy_err(wiphy, "%s: unknown iftype: %d\n",
824 dev->name, dev->ieee80211_ptr->iftype);
825 return -EOPNOTSUPP;
826 }
827
828 dev->ieee80211_ptr->iftype = type;
829 priv->bss_mode = type;
830 mwifiex_deauthenticate(priv, NULL);
831
832 priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
833
834 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_SET_BSS_MODE,
835 HostCmd_ACT_GEN_SET, 0, NULL);
836
837 return ret;
838 }
839
840 static void
841 mwifiex_parse_htinfo(struct mwifiex_private *priv, u8 tx_htinfo,
842 struct rate_info *rate)
843 {
844 struct mwifiex_adapter *adapter = priv->adapter;
845
846 if (adapter->is_hw_11ac_capable) {
847 /* bit[1-0]: 00=LG 01=HT 10=VHT */
848 if (tx_htinfo & BIT(0)) {
849 /* HT */
850 rate->mcs = priv->tx_rate;
851 rate->flags |= RATE_INFO_FLAGS_MCS;
852 }
853 if (tx_htinfo & BIT(1)) {
854 /* VHT */
855 rate->mcs = priv->tx_rate & 0x0F;
856 rate->flags |= RATE_INFO_FLAGS_VHT_MCS;
857 }
858
859 if (tx_htinfo & (BIT(1) | BIT(0))) {
860 /* HT or VHT */
861 switch (tx_htinfo & (BIT(3) | BIT(2))) {
862 case 0:
863 /* This will be 20MHz */
864 break;
865 case (BIT(2)):
866 rate->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
867 break;
868 case (BIT(3)):
869 rate->flags |= RATE_INFO_FLAGS_80_MHZ_WIDTH;
870 break;
871 case (BIT(3) | BIT(2)):
872 rate->flags |= RATE_INFO_FLAGS_160_MHZ_WIDTH;
873 break;
874 }
875
876 if (tx_htinfo & BIT(4))
877 rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
878
879 if ((priv->tx_rate >> 4) == 1)
880 rate->nss = 2;
881 else
882 rate->nss = 1;
883 }
884 } else {
885 /*
886 * Bit 0 in tx_htinfo indicates that current Tx rate
887 * is 11n rate. Valid MCS index values for us are 0 to 15.
888 */
889 if ((tx_htinfo & BIT(0)) && (priv->tx_rate < 16)) {
890 rate->mcs = priv->tx_rate;
891 rate->flags |= RATE_INFO_FLAGS_MCS;
892 if (tx_htinfo & BIT(1))
893 rate->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
894 if (tx_htinfo & BIT(2))
895 rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
896 }
897 }
898 }
899
900 /*
901 * This function dumps the station information on a buffer.
902 *
903 * The following information are shown -
904 * - Total bytes transmitted
905 * - Total bytes received
906 * - Total packets transmitted
907 * - Total packets received
908 * - Signal quality level
909 * - Transmission rate
910 */
911 static int
912 mwifiex_dump_station_info(struct mwifiex_private *priv,
913 struct station_info *sinfo)
914 {
915 u32 rate;
916
917 sinfo->filled = STATION_INFO_RX_BYTES | STATION_INFO_TX_BYTES |
918 STATION_INFO_RX_PACKETS | STATION_INFO_TX_PACKETS |
919 STATION_INFO_TX_BITRATE |
920 STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
921
922 /* Get signal information from the firmware */
923 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_RSSI_INFO,
924 HostCmd_ACT_GEN_GET, 0, NULL)) {
925 dev_err(priv->adapter->dev, "failed to get signal information\n");
926 return -EFAULT;
927 }
928
929 if (mwifiex_drv_get_data_rate(priv, &rate)) {
930 dev_err(priv->adapter->dev, "getting data rate\n");
931 return -EFAULT;
932 }
933
934 /* Get DTIM period information from firmware */
935 mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,
936 HostCmd_ACT_GEN_GET, DTIM_PERIOD_I,
937 &priv->dtim_period);
938
939 mwifiex_parse_htinfo(priv, priv->tx_htinfo, &sinfo->txrate);
940
941 sinfo->signal_avg = priv->bcn_rssi_avg;
942 sinfo->rx_bytes = priv->stats.rx_bytes;
943 sinfo->tx_bytes = priv->stats.tx_bytes;
944 sinfo->rx_packets = priv->stats.rx_packets;
945 sinfo->tx_packets = priv->stats.tx_packets;
946 sinfo->signal = priv->bcn_rssi_avg;
947 /* bit rate is in 500 kb/s units. Convert it to 100kb/s units */
948 sinfo->txrate.legacy = rate * 5;
949
950 if (priv->bss_mode == NL80211_IFTYPE_STATION) {
951 sinfo->filled |= STATION_INFO_BSS_PARAM;
952 sinfo->bss_param.flags = 0;
953 if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
954 WLAN_CAPABILITY_SHORT_PREAMBLE)
955 sinfo->bss_param.flags |=
956 BSS_PARAM_FLAGS_SHORT_PREAMBLE;
957 if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
958 WLAN_CAPABILITY_SHORT_SLOT_TIME)
959 sinfo->bss_param.flags |=
960 BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
961 sinfo->bss_param.dtim_period = priv->dtim_period;
962 sinfo->bss_param.beacon_interval =
963 priv->curr_bss_params.bss_descriptor.beacon_period;
964 }
965
966 return 0;
967 }
968
969 /*
970 * CFG802.11 operation handler to get station information.
971 *
972 * This function only works in connected mode, and dumps the
973 * requested station information, if available.
974 */
975 static int
976 mwifiex_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
977 u8 *mac, struct station_info *sinfo)
978 {
979 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
980
981 if (!priv->media_connected)
982 return -ENOENT;
983 if (memcmp(mac, priv->cfg_bssid, ETH_ALEN))
984 return -ENOENT;
985
986 return mwifiex_dump_station_info(priv, sinfo);
987 }
988
989 /*
990 * CFG802.11 operation handler to dump station information.
991 */
992 static int
993 mwifiex_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
994 int idx, u8 *mac, struct station_info *sinfo)
995 {
996 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
997
998 if (!priv->media_connected || idx)
999 return -ENOENT;
1000
1001 memcpy(mac, priv->cfg_bssid, ETH_ALEN);
1002
1003 return mwifiex_dump_station_info(priv, sinfo);
1004 }
1005
1006 /* Supported rates to be advertised to the cfg80211 */
1007 static struct ieee80211_rate mwifiex_rates[] = {
1008 {.bitrate = 10, .hw_value = 2, },
1009 {.bitrate = 20, .hw_value = 4, },
1010 {.bitrate = 55, .hw_value = 11, },
1011 {.bitrate = 110, .hw_value = 22, },
1012 {.bitrate = 60, .hw_value = 12, },
1013 {.bitrate = 90, .hw_value = 18, },
1014 {.bitrate = 120, .hw_value = 24, },
1015 {.bitrate = 180, .hw_value = 36, },
1016 {.bitrate = 240, .hw_value = 48, },
1017 {.bitrate = 360, .hw_value = 72, },
1018 {.bitrate = 480, .hw_value = 96, },
1019 {.bitrate = 540, .hw_value = 108, },
1020 };
1021
1022 /* Channel definitions to be advertised to cfg80211 */
1023 static struct ieee80211_channel mwifiex_channels_2ghz[] = {
1024 {.center_freq = 2412, .hw_value = 1, },
1025 {.center_freq = 2417, .hw_value = 2, },
1026 {.center_freq = 2422, .hw_value = 3, },
1027 {.center_freq = 2427, .hw_value = 4, },
1028 {.center_freq = 2432, .hw_value = 5, },
1029 {.center_freq = 2437, .hw_value = 6, },
1030 {.center_freq = 2442, .hw_value = 7, },
1031 {.center_freq = 2447, .hw_value = 8, },
1032 {.center_freq = 2452, .hw_value = 9, },
1033 {.center_freq = 2457, .hw_value = 10, },
1034 {.center_freq = 2462, .hw_value = 11, },
1035 {.center_freq = 2467, .hw_value = 12, },
1036 {.center_freq = 2472, .hw_value = 13, },
1037 {.center_freq = 2484, .hw_value = 14, },
1038 };
1039
1040 static struct ieee80211_supported_band mwifiex_band_2ghz = {
1041 .channels = mwifiex_channels_2ghz,
1042 .n_channels = ARRAY_SIZE(mwifiex_channels_2ghz),
1043 .bitrates = mwifiex_rates,
1044 .n_bitrates = ARRAY_SIZE(mwifiex_rates),
1045 };
1046
1047 static struct ieee80211_channel mwifiex_channels_5ghz[] = {
1048 {.center_freq = 5040, .hw_value = 8, },
1049 {.center_freq = 5060, .hw_value = 12, },
1050 {.center_freq = 5080, .hw_value = 16, },
1051 {.center_freq = 5170, .hw_value = 34, },
1052 {.center_freq = 5190, .hw_value = 38, },
1053 {.center_freq = 5210, .hw_value = 42, },
1054 {.center_freq = 5230, .hw_value = 46, },
1055 {.center_freq = 5180, .hw_value = 36, },
1056 {.center_freq = 5200, .hw_value = 40, },
1057 {.center_freq = 5220, .hw_value = 44, },
1058 {.center_freq = 5240, .hw_value = 48, },
1059 {.center_freq = 5260, .hw_value = 52, },
1060 {.center_freq = 5280, .hw_value = 56, },
1061 {.center_freq = 5300, .hw_value = 60, },
1062 {.center_freq = 5320, .hw_value = 64, },
1063 {.center_freq = 5500, .hw_value = 100, },
1064 {.center_freq = 5520, .hw_value = 104, },
1065 {.center_freq = 5540, .hw_value = 108, },
1066 {.center_freq = 5560, .hw_value = 112, },
1067 {.center_freq = 5580, .hw_value = 116, },
1068 {.center_freq = 5600, .hw_value = 120, },
1069 {.center_freq = 5620, .hw_value = 124, },
1070 {.center_freq = 5640, .hw_value = 128, },
1071 {.center_freq = 5660, .hw_value = 132, },
1072 {.center_freq = 5680, .hw_value = 136, },
1073 {.center_freq = 5700, .hw_value = 140, },
1074 {.center_freq = 5745, .hw_value = 149, },
1075 {.center_freq = 5765, .hw_value = 153, },
1076 {.center_freq = 5785, .hw_value = 157, },
1077 {.center_freq = 5805, .hw_value = 161, },
1078 {.center_freq = 5825, .hw_value = 165, },
1079 };
1080
1081 static struct ieee80211_supported_band mwifiex_band_5ghz = {
1082 .channels = mwifiex_channels_5ghz,
1083 .n_channels = ARRAY_SIZE(mwifiex_channels_5ghz),
1084 .bitrates = mwifiex_rates + 4,
1085 .n_bitrates = ARRAY_SIZE(mwifiex_rates) - 4,
1086 };
1087
1088
1089 /* Supported crypto cipher suits to be advertised to cfg80211 */
1090 static const u32 mwifiex_cipher_suites[] = {
1091 WLAN_CIPHER_SUITE_WEP40,
1092 WLAN_CIPHER_SUITE_WEP104,
1093 WLAN_CIPHER_SUITE_TKIP,
1094 WLAN_CIPHER_SUITE_CCMP,
1095 WLAN_CIPHER_SUITE_AES_CMAC,
1096 };
1097
1098 /* Supported mgmt frame types to be advertised to cfg80211 */
1099 static const struct ieee80211_txrx_stypes
1100 mwifiex_mgmt_stypes[NUM_NL80211_IFTYPES] = {
1101 [NL80211_IFTYPE_STATION] = {
1102 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1103 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1104 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1105 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1106 },
1107 [NL80211_IFTYPE_AP] = {
1108 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1109 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1110 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1111 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1112 },
1113 [NL80211_IFTYPE_P2P_CLIENT] = {
1114 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1115 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1116 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1117 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1118 },
1119 [NL80211_IFTYPE_P2P_GO] = {
1120 .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1121 BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1122 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1123 BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1124 },
1125 };
1126
1127 /*
1128 * CFG802.11 operation handler for setting bit rates.
1129 *
1130 * Function configures data rates to firmware using bitrate mask
1131 * provided by cfg80211.
1132 */
1133 static int mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
1134 struct net_device *dev,
1135 const u8 *peer,
1136 const struct cfg80211_bitrate_mask *mask)
1137 {
1138 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1139 u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
1140 enum ieee80211_band band;
1141
1142 if (!priv->media_connected) {
1143 dev_err(priv->adapter->dev,
1144 "Can not set Tx data rate in disconnected state\n");
1145 return -EINVAL;
1146 }
1147
1148 band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
1149
1150 memset(bitmap_rates, 0, sizeof(bitmap_rates));
1151
1152 /* Fill HR/DSSS rates. */
1153 if (band == IEEE80211_BAND_2GHZ)
1154 bitmap_rates[0] = mask->control[band].legacy & 0x000f;
1155
1156 /* Fill OFDM rates */
1157 if (band == IEEE80211_BAND_2GHZ)
1158 bitmap_rates[1] = (mask->control[band].legacy & 0x0ff0) >> 4;
1159 else
1160 bitmap_rates[1] = mask->control[band].legacy;
1161
1162 /* Fill MCS rates */
1163 bitmap_rates[2] = mask->control[band].mcs[0];
1164 if (priv->adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1165 bitmap_rates[2] |= mask->control[band].mcs[1] << 8;
1166
1167 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_TX_RATE_CFG,
1168 HostCmd_ACT_GEN_SET, 0, bitmap_rates);
1169 }
1170
1171 /*
1172 * CFG802.11 operation handler for connection quality monitoring.
1173 *
1174 * This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI
1175 * events to FW.
1176 */
1177 static int mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy *wiphy,
1178 struct net_device *dev,
1179 s32 rssi_thold, u32 rssi_hyst)
1180 {
1181 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1182 struct mwifiex_ds_misc_subsc_evt subsc_evt;
1183
1184 priv->cqm_rssi_thold = rssi_thold;
1185 priv->cqm_rssi_hyst = rssi_hyst;
1186
1187 memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
1188 subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
1189
1190 /* Subscribe/unsubscribe low and high rssi events */
1191 if (rssi_thold && rssi_hyst) {
1192 subsc_evt.action = HostCmd_ACT_BITWISE_SET;
1193 subsc_evt.bcn_l_rssi_cfg.abs_value = abs(rssi_thold);
1194 subsc_evt.bcn_h_rssi_cfg.abs_value = abs(rssi_thold);
1195 subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
1196 subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
1197 return mwifiex_send_cmd_sync(priv,
1198 HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1199 0, 0, &subsc_evt);
1200 } else {
1201 subsc_evt.action = HostCmd_ACT_BITWISE_CLR;
1202 return mwifiex_send_cmd_sync(priv,
1203 HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1204 0, 0, &subsc_evt);
1205 }
1206
1207 return 0;
1208 }
1209
1210 /* cfg80211 operation handler for change_beacon.
1211 * Function retrieves and sets modified management IEs to FW.
1212 */
1213 static int mwifiex_cfg80211_change_beacon(struct wiphy *wiphy,
1214 struct net_device *dev,
1215 struct cfg80211_beacon_data *data)
1216 {
1217 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1218
1219 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP) {
1220 wiphy_err(wiphy, "%s: bss_type mismatched\n", __func__);
1221 return -EINVAL;
1222 }
1223
1224 if (!priv->bss_started) {
1225 wiphy_err(wiphy, "%s: bss not started\n", __func__);
1226 return -EINVAL;
1227 }
1228
1229 if (mwifiex_set_mgmt_ies(priv, data)) {
1230 wiphy_err(wiphy, "%s: setting mgmt ies failed\n", __func__);
1231 return -EFAULT;
1232 }
1233
1234 return 0;
1235 }
1236
1237 /* cfg80211 operation handler for del_station.
1238 * Function deauthenticates station which value is provided in mac parameter.
1239 * If mac is NULL/broadcast, all stations in associated station list are
1240 * deauthenticated. If bss is not started or there are no stations in
1241 * associated stations list, no action is taken.
1242 */
1243 static int
1244 mwifiex_cfg80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1245 u8 *mac)
1246 {
1247 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1248 struct mwifiex_sta_node *sta_node;
1249 unsigned long flags;
1250
1251 if (list_empty(&priv->sta_list) || !priv->bss_started)
1252 return 0;
1253
1254 if (!mac || is_broadcast_ether_addr(mac)) {
1255 wiphy_dbg(wiphy, "%s: NULL/broadcast mac address\n", __func__);
1256 list_for_each_entry(sta_node, &priv->sta_list, list) {
1257 if (mwifiex_send_cmd_sync(priv,
1258 HostCmd_CMD_UAP_STA_DEAUTH,
1259 HostCmd_ACT_GEN_SET, 0,
1260 sta_node->mac_addr))
1261 return -1;
1262 mwifiex_uap_del_sta_data(priv, sta_node);
1263 }
1264 } else {
1265 wiphy_dbg(wiphy, "%s: mac address %pM\n", __func__, mac);
1266 spin_lock_irqsave(&priv->sta_list_spinlock, flags);
1267 sta_node = mwifiex_get_sta_entry(priv, mac);
1268 spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
1269 if (sta_node) {
1270 if (mwifiex_send_cmd_sync(priv,
1271 HostCmd_CMD_UAP_STA_DEAUTH,
1272 HostCmd_ACT_GEN_SET, 0,
1273 sta_node->mac_addr))
1274 return -1;
1275 mwifiex_uap_del_sta_data(priv, sta_node);
1276 }
1277 }
1278
1279 return 0;
1280 }
1281
1282 static int
1283 mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
1284 {
1285 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1286 struct mwifiex_private *priv = mwifiex_get_priv(adapter,
1287 MWIFIEX_BSS_ROLE_ANY);
1288 struct mwifiex_ds_ant_cfg ant_cfg;
1289
1290 if (!tx_ant || !rx_ant)
1291 return -EOPNOTSUPP;
1292
1293 if (adapter->hw_dev_mcs_support != HT_STREAM_2X2) {
1294 /* Not a MIMO chip. User should provide specific antenna number
1295 * for Tx/Rx path or enable all antennas for diversity
1296 */
1297 if (tx_ant != rx_ant)
1298 return -EOPNOTSUPP;
1299
1300 if ((tx_ant & (tx_ant - 1)) &&
1301 (tx_ant != BIT(adapter->number_of_antenna) - 1))
1302 return -EOPNOTSUPP;
1303
1304 if ((tx_ant == BIT(adapter->number_of_antenna) - 1) &&
1305 (priv->adapter->number_of_antenna > 1)) {
1306 tx_ant = RF_ANTENNA_AUTO;
1307 rx_ant = RF_ANTENNA_AUTO;
1308 }
1309 }
1310
1311 ant_cfg.tx_ant = tx_ant;
1312 ant_cfg.rx_ant = rx_ant;
1313
1314 return mwifiex_send_cmd_sync(priv, HostCmd_CMD_RF_ANTENNA,
1315 HostCmd_ACT_GEN_SET, 0, &ant_cfg);
1316 }
1317
1318 /* cfg80211 operation handler for stop ap.
1319 * Function stops BSS running at uAP interface.
1320 */
1321 static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
1322 {
1323 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1324
1325 if (mwifiex_del_mgmt_ies(priv))
1326 wiphy_err(wiphy, "Failed to delete mgmt IEs!\n");
1327
1328 priv->ap_11n_enabled = 0;
1329
1330 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
1331 HostCmd_ACT_GEN_SET, 0, NULL)) {
1332 wiphy_err(wiphy, "Failed to stop the BSS\n");
1333 return -1;
1334 }
1335
1336 return 0;
1337 }
1338
1339 /* cfg80211 operation handler for start_ap.
1340 * Function sets beacon period, DTIM period, SSID and security into
1341 * AP config structure.
1342 * AP is configured with these settings and BSS is started.
1343 */
1344 static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
1345 struct net_device *dev,
1346 struct cfg80211_ap_settings *params)
1347 {
1348 struct mwifiex_uap_bss_param *bss_cfg;
1349 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1350 u8 config_bands = 0;
1351
1352 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
1353 return -1;
1354 if (mwifiex_set_mgmt_ies(priv, &params->beacon))
1355 return -1;
1356
1357 bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
1358 if (!bss_cfg)
1359 return -ENOMEM;
1360
1361 mwifiex_set_sys_config_invalid_data(bss_cfg);
1362
1363 if (params->beacon_interval)
1364 bss_cfg->beacon_period = params->beacon_interval;
1365 if (params->dtim_period)
1366 bss_cfg->dtim_period = params->dtim_period;
1367
1368 if (params->ssid && params->ssid_len) {
1369 memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
1370 bss_cfg->ssid.ssid_len = params->ssid_len;
1371 }
1372
1373 switch (params->hidden_ssid) {
1374 case NL80211_HIDDEN_SSID_NOT_IN_USE:
1375 bss_cfg->bcast_ssid_ctl = 1;
1376 break;
1377 case NL80211_HIDDEN_SSID_ZERO_LEN:
1378 bss_cfg->bcast_ssid_ctl = 0;
1379 break;
1380 case NL80211_HIDDEN_SSID_ZERO_CONTENTS:
1381 /* firmware doesn't support this type of hidden SSID */
1382 default:
1383 kfree(bss_cfg);
1384 return -EINVAL;
1385 }
1386
1387 bss_cfg->channel = ieee80211_frequency_to_channel(
1388 params->chandef.chan->center_freq);
1389
1390 /* Set appropriate bands */
1391 if (params->chandef.chan->band == IEEE80211_BAND_2GHZ) {
1392 bss_cfg->band_cfg = BAND_CONFIG_BG;
1393 config_bands = BAND_B | BAND_G;
1394
1395 if (params->chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
1396 config_bands |= BAND_GN;
1397
1398 if (params->chandef.width > NL80211_CHAN_WIDTH_40)
1399 config_bands |= BAND_GAC;
1400 } else {
1401 bss_cfg->band_cfg = BAND_CONFIG_A;
1402 config_bands = BAND_A;
1403
1404 if (params->chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
1405 config_bands |= BAND_AN;
1406
1407 if (params->chandef.width > NL80211_CHAN_WIDTH_40)
1408 config_bands |= BAND_AAC;
1409 }
1410
1411 if (!((config_bands | priv->adapter->fw_bands) &
1412 ~priv->adapter->fw_bands))
1413 priv->adapter->config_bands = config_bands;
1414
1415 mwifiex_set_uap_rates(bss_cfg, params);
1416 mwifiex_send_domain_info_cmd_fw(wiphy);
1417
1418 if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
1419 kfree(bss_cfg);
1420 wiphy_err(wiphy, "Failed to parse secuirty parameters!\n");
1421 return -1;
1422 }
1423
1424 mwifiex_set_ht_params(priv, bss_cfg, params);
1425
1426 if (priv->adapter->is_hw_11ac_capable) {
1427 mwifiex_set_vht_params(priv, bss_cfg, params);
1428 mwifiex_set_vht_width(priv, params->chandef.width,
1429 priv->ap_11ac_enabled);
1430 }
1431
1432 if (priv->ap_11ac_enabled)
1433 mwifiex_set_11ac_ba_params(priv);
1434 else
1435 mwifiex_set_ba_params(priv);
1436
1437 mwifiex_set_wmm_params(priv, bss_cfg, params);
1438
1439 if (params->inactivity_timeout > 0) {
1440 /* sta_ao_timer/ps_sta_ao_timer is in unit of 100ms */
1441 bss_cfg->sta_ao_timer = 10 * params->inactivity_timeout;
1442 bss_cfg->ps_sta_ao_timer = 10 * params->inactivity_timeout;
1443 }
1444
1445 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_UAP_BSS_STOP,
1446 HostCmd_ACT_GEN_SET, 0, NULL)) {
1447 wiphy_err(wiphy, "Failed to stop the BSS\n");
1448 kfree(bss_cfg);
1449 return -1;
1450 }
1451
1452 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_SYS_CONFIG,
1453 HostCmd_ACT_GEN_SET,
1454 UAP_BSS_PARAMS_I, bss_cfg)) {
1455 wiphy_err(wiphy, "Failed to set the SSID\n");
1456 kfree(bss_cfg);
1457 return -1;
1458 }
1459
1460 kfree(bss_cfg);
1461
1462 if (mwifiex_send_cmd_async(priv, HostCmd_CMD_UAP_BSS_START,
1463 HostCmd_ACT_GEN_SET, 0, NULL)) {
1464 wiphy_err(wiphy, "Failed to start the BSS\n");
1465 return -1;
1466 }
1467
1468 if (priv->sec_info.wep_enabled)
1469 priv->curr_pkt_filter |= HostCmd_ACT_MAC_WEP_ENABLE;
1470 else
1471 priv->curr_pkt_filter &= ~HostCmd_ACT_MAC_WEP_ENABLE;
1472
1473 if (mwifiex_send_cmd_sync(priv, HostCmd_CMD_MAC_CONTROL,
1474 HostCmd_ACT_GEN_SET, 0,
1475 &priv->curr_pkt_filter))
1476 return -1;
1477
1478 return 0;
1479 }
1480
1481 /*
1482 * CFG802.11 operation handler for disconnection request.
1483 *
1484 * This function does not work when there is already a disconnection
1485 * procedure going on.
1486 */
1487 static int
1488 mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1489 u16 reason_code)
1490 {
1491 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1492
1493 if (mwifiex_deauthenticate(priv, NULL))
1494 return -EFAULT;
1495
1496 wiphy_dbg(wiphy, "info: successfully disconnected from %pM:"
1497 " reason code %d\n", priv->cfg_bssid, reason_code);
1498
1499 memset(priv->cfg_bssid, 0, ETH_ALEN);
1500
1501 return 0;
1502 }
1503
1504 /*
1505 * This function informs the CFG802.11 subsystem of a new IBSS.
1506 *
1507 * The following information are sent to the CFG802.11 subsystem
1508 * to register the new IBSS. If we do not register the new IBSS,
1509 * a kernel panic will result.
1510 * - SSID
1511 * - SSID length
1512 * - BSSID
1513 * - Channel
1514 */
1515 static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
1516 {
1517 struct ieee80211_channel *chan;
1518 struct mwifiex_bss_info bss_info;
1519 struct cfg80211_bss *bss;
1520 int ie_len;
1521 u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
1522 enum ieee80211_band band;
1523
1524 if (mwifiex_get_bss_info(priv, &bss_info))
1525 return -1;
1526
1527 ie_buf[0] = WLAN_EID_SSID;
1528 ie_buf[1] = bss_info.ssid.ssid_len;
1529
1530 memcpy(&ie_buf[sizeof(struct ieee_types_header)],
1531 &bss_info.ssid.ssid, bss_info.ssid.ssid_len);
1532 ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
1533
1534 band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
1535 chan = __ieee80211_get_channel(priv->wdev->wiphy,
1536 ieee80211_channel_to_frequency(bss_info.bss_chan,
1537 band));
1538
1539 bss = cfg80211_inform_bss(priv->wdev->wiphy, chan,
1540 bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
1541 0, ie_buf, ie_len, 0, GFP_KERNEL);
1542 cfg80211_put_bss(priv->wdev->wiphy, bss);
1543 memcpy(priv->cfg_bssid, bss_info.bssid, ETH_ALEN);
1544
1545 return 0;
1546 }
1547
1548 /*
1549 * This function connects with a BSS.
1550 *
1551 * This function handles both Infra and Ad-Hoc modes. It also performs
1552 * validity checking on the provided parameters, disconnects from the
1553 * current BSS (if any), sets up the association/scan parameters,
1554 * including security settings, and performs specific SSID scan before
1555 * trying to connect.
1556 *
1557 * For Infra mode, the function returns failure if the specified SSID
1558 * is not found in scan table. However, for Ad-Hoc mode, it can create
1559 * the IBSS if it does not exist. On successful completion in either case,
1560 * the function notifies the CFG802.11 subsystem of the new BSS connection.
1561 */
1562 static int
1563 mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid,
1564 u8 *bssid, int mode, struct ieee80211_channel *channel,
1565 struct cfg80211_connect_params *sme, bool privacy)
1566 {
1567 struct cfg80211_ssid req_ssid;
1568 int ret, auth_type = 0;
1569 struct cfg80211_bss *bss = NULL;
1570 u8 is_scanning_required = 0;
1571
1572 memset(&req_ssid, 0, sizeof(struct cfg80211_ssid));
1573
1574 req_ssid.ssid_len = ssid_len;
1575 if (ssid_len > IEEE80211_MAX_SSID_LEN) {
1576 dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
1577 return -EINVAL;
1578 }
1579
1580 memcpy(req_ssid.ssid, ssid, ssid_len);
1581 if (!req_ssid.ssid_len || req_ssid.ssid[0] < 0x20) {
1582 dev_err(priv->adapter->dev, "invalid SSID - aborting\n");
1583 return -EINVAL;
1584 }
1585
1586 /* disconnect before try to associate */
1587 mwifiex_deauthenticate(priv, NULL);
1588
1589 /* As this is new association, clear locally stored
1590 * keys and security related flags */
1591 priv->sec_info.wpa_enabled = false;
1592 priv->sec_info.wpa2_enabled = false;
1593 priv->wep_key_curr_index = 0;
1594 priv->sec_info.encryption_mode = 0;
1595 priv->sec_info.is_authtype_auto = 0;
1596 ret = mwifiex_set_encode(priv, NULL, NULL, 0, 0, NULL, 1);
1597
1598 if (mode == NL80211_IFTYPE_ADHOC) {
1599 /* "privacy" is set only for ad-hoc mode */
1600 if (privacy) {
1601 /*
1602 * Keep WLAN_CIPHER_SUITE_WEP104 for now so that
1603 * the firmware can find a matching network from the
1604 * scan. The cfg80211 does not give us the encryption
1605 * mode at this stage so just setting it to WEP here.
1606 */
1607 priv->sec_info.encryption_mode =
1608 WLAN_CIPHER_SUITE_WEP104;
1609 priv->sec_info.authentication_mode =
1610 NL80211_AUTHTYPE_OPEN_SYSTEM;
1611 }
1612
1613 goto done;
1614 }
1615
1616 /* Now handle infra mode. "sme" is valid for infra mode only */
1617 if (sme->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
1618 auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
1619 priv->sec_info.is_authtype_auto = 1;
1620 } else {
1621 auth_type = sme->auth_type;
1622 }
1623
1624 if (sme->crypto.n_ciphers_pairwise) {
1625 priv->sec_info.encryption_mode =
1626 sme->crypto.ciphers_pairwise[0];
1627 priv->sec_info.authentication_mode = auth_type;
1628 }
1629
1630 if (sme->crypto.cipher_group) {
1631 priv->sec_info.encryption_mode = sme->crypto.cipher_group;
1632 priv->sec_info.authentication_mode = auth_type;
1633 }
1634 if (sme->ie)
1635 ret = mwifiex_set_gen_ie(priv, sme->ie, sme->ie_len);
1636
1637 if (sme->key) {
1638 if (mwifiex_is_alg_wep(priv->sec_info.encryption_mode)) {
1639 dev_dbg(priv->adapter->dev,
1640 "info: setting wep encryption"
1641 " with key len %d\n", sme->key_len);
1642 priv->wep_key_curr_index = sme->key_idx;
1643 ret = mwifiex_set_encode(priv, NULL, sme->key,
1644 sme->key_len, sme->key_idx,
1645 NULL, 0);
1646 }
1647 }
1648 done:
1649 /*
1650 * Scan entries are valid for some time (15 sec). So we can save one
1651 * active scan time if we just try cfg80211_get_bss first. If it fails
1652 * then request scan and cfg80211_get_bss() again for final output.
1653 */
1654 while (1) {
1655 if (is_scanning_required) {
1656 /* Do specific SSID scanning */
1657 if (mwifiex_request_scan(priv, &req_ssid)) {
1658 dev_err(priv->adapter->dev, "scan error\n");
1659 return -EFAULT;
1660 }
1661 }
1662
1663 /* Find the BSS we want using available scan results */
1664 if (mode == NL80211_IFTYPE_ADHOC)
1665 bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
1666 bssid, ssid, ssid_len,
1667 WLAN_CAPABILITY_IBSS,
1668 WLAN_CAPABILITY_IBSS);
1669 else
1670 bss = cfg80211_get_bss(priv->wdev->wiphy, channel,
1671 bssid, ssid, ssid_len,
1672 WLAN_CAPABILITY_ESS,
1673 WLAN_CAPABILITY_ESS);
1674
1675 if (!bss) {
1676 if (is_scanning_required) {
1677 dev_warn(priv->adapter->dev,
1678 "assoc: requested bss not found in scan results\n");
1679 break;
1680 }
1681 is_scanning_required = 1;
1682 } else {
1683 dev_dbg(priv->adapter->dev,
1684 "info: trying to associate to '%s' bssid %pM\n",
1685 (char *) req_ssid.ssid, bss->bssid);
1686 memcpy(&priv->cfg_bssid, bss->bssid, ETH_ALEN);
1687 break;
1688 }
1689 }
1690
1691 ret = mwifiex_bss_start(priv, bss, &req_ssid);
1692 if (ret)
1693 return ret;
1694
1695 if (mode == NL80211_IFTYPE_ADHOC) {
1696 /* Inform the BSS information to kernel, otherwise
1697 * kernel will give a panic after successful assoc */
1698 if (mwifiex_cfg80211_inform_ibss_bss(priv))
1699 return -EFAULT;
1700 }
1701
1702 return ret;
1703 }
1704
1705 /*
1706 * CFG802.11 operation handler for association request.
1707 *
1708 * This function does not work when the current mode is set to Ad-Hoc, or
1709 * when there is already an association procedure going on. The given BSS
1710 * information is used to associate.
1711 */
1712 static int
1713 mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1714 struct cfg80211_connect_params *sme)
1715 {
1716 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1717 int ret;
1718
1719 if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA) {
1720 wiphy_err(wiphy,
1721 "%s: reject infra assoc request in non-STA role\n",
1722 dev->name);
1723 return -EINVAL;
1724 }
1725
1726 wiphy_dbg(wiphy, "info: Trying to associate to %s and bssid %pM\n",
1727 (char *) sme->ssid, sme->bssid);
1728
1729 ret = mwifiex_cfg80211_assoc(priv, sme->ssid_len, sme->ssid, sme->bssid,
1730 priv->bss_mode, sme->channel, sme, 0);
1731 if (!ret) {
1732 cfg80211_connect_result(priv->netdev, priv->cfg_bssid, NULL, 0,
1733 NULL, 0, WLAN_STATUS_SUCCESS,
1734 GFP_KERNEL);
1735 dev_dbg(priv->adapter->dev,
1736 "info: associated to bssid %pM successfully\n",
1737 priv->cfg_bssid);
1738 } else {
1739 dev_dbg(priv->adapter->dev,
1740 "info: association to bssid %pM failed\n",
1741 priv->cfg_bssid);
1742 memset(priv->cfg_bssid, 0, ETH_ALEN);
1743
1744 if (ret > 0)
1745 cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
1746 NULL, 0, NULL, 0, ret,
1747 GFP_KERNEL);
1748 else
1749 cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
1750 NULL, 0, NULL, 0,
1751 WLAN_STATUS_UNSPECIFIED_FAILURE,
1752 GFP_KERNEL);
1753 }
1754
1755 return 0;
1756 }
1757
1758 /*
1759 * This function sets following parameters for ibss network.
1760 * - channel
1761 * - start band
1762 * - 11n flag
1763 * - secondary channel offset
1764 */
1765 static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
1766 struct cfg80211_ibss_params *params)
1767 {
1768 struct wiphy *wiphy = priv->wdev->wiphy;
1769 struct mwifiex_adapter *adapter = priv->adapter;
1770 int index = 0, i;
1771 u8 config_bands = 0;
1772
1773 if (params->chandef.chan->band == IEEE80211_BAND_2GHZ) {
1774 if (!params->basic_rates) {
1775 config_bands = BAND_B | BAND_G;
1776 } else {
1777 for (i = 0; i < mwifiex_band_2ghz.n_bitrates; i++) {
1778 /*
1779 * Rates below 6 Mbps in the table are CCK
1780 * rates; 802.11b and from 6 they are OFDM;
1781 * 802.11G
1782 */
1783 if (mwifiex_rates[i].bitrate == 60) {
1784 index = 1 << i;
1785 break;
1786 }
1787 }
1788
1789 if (params->basic_rates < index) {
1790 config_bands = BAND_B;
1791 } else {
1792 config_bands = BAND_G;
1793 if (params->basic_rates % index)
1794 config_bands |= BAND_B;
1795 }
1796 }
1797
1798 if (cfg80211_get_chandef_type(&params->chandef) !=
1799 NL80211_CHAN_NO_HT)
1800 config_bands |= BAND_G | BAND_GN;
1801 } else {
1802 if (cfg80211_get_chandef_type(&params->chandef) ==
1803 NL80211_CHAN_NO_HT)
1804 config_bands = BAND_A;
1805 else
1806 config_bands = BAND_AN | BAND_A;
1807 }
1808
1809 if (!((config_bands | adapter->fw_bands) & ~adapter->fw_bands)) {
1810 adapter->config_bands = config_bands;
1811 adapter->adhoc_start_band = config_bands;
1812
1813 if ((config_bands & BAND_GN) || (config_bands & BAND_AN))
1814 adapter->adhoc_11n_enabled = true;
1815 else
1816 adapter->adhoc_11n_enabled = false;
1817 }
1818
1819 adapter->sec_chan_offset =
1820 mwifiex_chan_type_to_sec_chan_offset(
1821 cfg80211_get_chandef_type(&params->chandef));
1822 priv->adhoc_channel = ieee80211_frequency_to_channel(
1823 params->chandef.chan->center_freq);
1824
1825 wiphy_dbg(wiphy, "info: set ibss band %d, chan %d, chan offset %d\n",
1826 config_bands, priv->adhoc_channel, adapter->sec_chan_offset);
1827
1828 return 0;
1829 }
1830
1831 /*
1832 * CFG802.11 operation handler to join an IBSS.
1833 *
1834 * This function does not work in any mode other than Ad-Hoc, or if
1835 * a join operation is already in progress.
1836 */
1837 static int
1838 mwifiex_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
1839 struct cfg80211_ibss_params *params)
1840 {
1841 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1842 int ret = 0;
1843
1844 if (priv->bss_mode != NL80211_IFTYPE_ADHOC) {
1845 wiphy_err(wiphy, "request to join ibss received "
1846 "when station is not in ibss mode\n");
1847 goto done;
1848 }
1849
1850 wiphy_dbg(wiphy, "info: trying to join to %s and bssid %pM\n",
1851 (char *) params->ssid, params->bssid);
1852
1853 mwifiex_set_ibss_params(priv, params);
1854
1855 ret = mwifiex_cfg80211_assoc(priv, params->ssid_len, params->ssid,
1856 params->bssid, priv->bss_mode,
1857 params->chandef.chan, NULL,
1858 params->privacy);
1859 done:
1860 if (!ret) {
1861 cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid, GFP_KERNEL);
1862 dev_dbg(priv->adapter->dev,
1863 "info: joined/created adhoc network with bssid"
1864 " %pM successfully\n", priv->cfg_bssid);
1865 } else {
1866 dev_dbg(priv->adapter->dev,
1867 "info: failed creating/joining adhoc network\n");
1868 }
1869
1870 return ret;
1871 }
1872
1873 /*
1874 * CFG802.11 operation handler to leave an IBSS.
1875 *
1876 * This function does not work if a leave operation is
1877 * already in progress.
1878 */
1879 static int
1880 mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1881 {
1882 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1883
1884 wiphy_dbg(wiphy, "info: disconnecting from essid %pM\n",
1885 priv->cfg_bssid);
1886 if (mwifiex_deauthenticate(priv, NULL))
1887 return -EFAULT;
1888
1889 memset(priv->cfg_bssid, 0, ETH_ALEN);
1890
1891 return 0;
1892 }
1893
1894 /*
1895 * CFG802.11 operation handler for scan request.
1896 *
1897 * This function issues a scan request to the firmware based upon
1898 * the user specified scan configuration. On successfull completion,
1899 * it also informs the results.
1900 */
1901 static int
1902 mwifiex_cfg80211_scan(struct wiphy *wiphy,
1903 struct cfg80211_scan_request *request)
1904 {
1905 struct net_device *dev = request->wdev->netdev;
1906 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1907 int i, offset, ret;
1908 struct ieee80211_channel *chan;
1909 struct ieee_types_header *ie;
1910 struct mwifiex_user_scan_cfg *user_scan_cfg;
1911
1912 wiphy_dbg(wiphy, "info: received scan request on %s\n", dev->name);
1913
1914 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
1915 atomic_read(&priv->wmm.tx_pkts_queued) >=
1916 MWIFIEX_MIN_TX_PENDING_TO_CANCEL_SCAN) {
1917 dev_dbg(priv->adapter->dev, "scan rejected due to traffic\n");
1918 return -EBUSY;
1919 }
1920
1921 /* Block scan request if scan operation or scan cleanup when interface
1922 * is disabled is in process
1923 */
1924 if (priv->scan_request || priv->scan_aborting) {
1925 dev_err(priv->adapter->dev, "cmd: Scan already in process..\n");
1926 return -EBUSY;
1927 }
1928
1929 user_scan_cfg = kzalloc(sizeof(*user_scan_cfg), GFP_KERNEL);
1930 if (!user_scan_cfg)
1931 return -ENOMEM;
1932
1933 priv->scan_request = request;
1934
1935 user_scan_cfg->num_ssids = request->n_ssids;
1936 user_scan_cfg->ssid_list = request->ssids;
1937
1938 if (request->ie && request->ie_len) {
1939 offset = 0;
1940 for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
1941 if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
1942 continue;
1943 priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_SCAN;
1944 ie = (struct ieee_types_header *)(request->ie + offset);
1945 memcpy(&priv->vs_ie[i].ie, ie, sizeof(*ie) + ie->len);
1946 offset += sizeof(*ie) + ie->len;
1947
1948 if (offset >= request->ie_len)
1949 break;
1950 }
1951 }
1952
1953 for (i = 0; i < min_t(u32, request->n_channels,
1954 MWIFIEX_USER_SCAN_CHAN_MAX); i++) {
1955 chan = request->channels[i];
1956 user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
1957 user_scan_cfg->chan_list[i].radio_type = chan->band;
1958
1959 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
1960 user_scan_cfg->chan_list[i].scan_type =
1961 MWIFIEX_SCAN_TYPE_PASSIVE;
1962 else
1963 user_scan_cfg->chan_list[i].scan_type =
1964 MWIFIEX_SCAN_TYPE_ACTIVE;
1965
1966 user_scan_cfg->chan_list[i].scan_time = 0;
1967 }
1968
1969 ret = mwifiex_scan_networks(priv, user_scan_cfg);
1970 kfree(user_scan_cfg);
1971 if (ret) {
1972 dev_err(priv->adapter->dev, "scan failed: %d\n", ret);
1973 priv->scan_aborting = false;
1974 priv->scan_request = NULL;
1975 return ret;
1976 }
1977
1978 if (request->ie && request->ie_len) {
1979 for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
1980 if (priv->vs_ie[i].mask == MWIFIEX_VSIE_MASK_SCAN) {
1981 priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_CLEAR;
1982 memset(&priv->vs_ie[i].ie, 0,
1983 MWIFIEX_MAX_VSIE_LEN);
1984 }
1985 }
1986 }
1987 return 0;
1988 }
1989
1990 static void mwifiex_setup_vht_caps(struct ieee80211_sta_vht_cap *vht_info,
1991 struct mwifiex_private *priv)
1992 {
1993 struct mwifiex_adapter *adapter = priv->adapter;
1994
1995 vht_info->vht_supported = true;
1996
1997 vht_info->cap = adapter->hw_dot_11ac_dev_cap;
1998 /* Update MCS support for VHT */
1999 vht_info->vht_mcs.rx_mcs_map = cpu_to_le16(
2000 adapter->hw_dot_11ac_mcs_support & 0xFFFF);
2001 vht_info->vht_mcs.rx_highest = 0;
2002 vht_info->vht_mcs.tx_mcs_map = cpu_to_le16(
2003 adapter->hw_dot_11ac_mcs_support >> 16);
2004 vht_info->vht_mcs.tx_highest = 0;
2005 }
2006
2007 /*
2008 * This function sets up the CFG802.11 specific HT capability fields
2009 * with default values.
2010 *
2011 * The following default values are set -
2012 * - HT Supported = True
2013 * - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K
2014 * - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE
2015 * - HT Capabilities supported by firmware
2016 * - MCS information, Rx mask = 0xff
2017 * - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01)
2018 */
2019 static void
2020 mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
2021 struct mwifiex_private *priv)
2022 {
2023 int rx_mcs_supp;
2024 struct ieee80211_mcs_info mcs_set;
2025 u8 *mcs = (u8 *)&mcs_set;
2026 struct mwifiex_adapter *adapter = priv->adapter;
2027
2028 ht_info->ht_supported = true;
2029 ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
2030 ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2031
2032 memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
2033
2034 /* Fill HT capability information */
2035 if (ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2036 ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2037 else
2038 ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2039
2040 if (ISSUPP_SHORTGI20(adapter->hw_dot_11n_dev_cap))
2041 ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
2042 else
2043 ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20;
2044
2045 if (ISSUPP_SHORTGI40(adapter->hw_dot_11n_dev_cap))
2046 ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
2047 else
2048 ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40;
2049
2050 if (ISSUPP_RXSTBC(adapter->hw_dot_11n_dev_cap))
2051 ht_info->cap |= 1 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
2052 else
2053 ht_info->cap &= ~(3 << IEEE80211_HT_CAP_RX_STBC_SHIFT);
2054
2055 if (ISSUPP_TXSTBC(adapter->hw_dot_11n_dev_cap))
2056 ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
2057 else
2058 ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC;
2059
2060 if (ISSUPP_GREENFIELD(adapter->hw_dot_11n_dev_cap))
2061 ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
2062 else
2063 ht_info->cap &= ~IEEE80211_HT_CAP_GRN_FLD;
2064
2065 if (ISENABLED_40MHZ_INTOLERANT(adapter->hw_dot_11n_dev_cap))
2066 ht_info->cap |= IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2067 else
2068 ht_info->cap &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2069
2070 if (ISSUPP_RXLDPC(adapter->hw_dot_11n_dev_cap))
2071 ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
2072 else
2073 ht_info->cap &= ~IEEE80211_HT_CAP_LDPC_CODING;
2074
2075 ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
2076 ht_info->cap |= IEEE80211_HT_CAP_SM_PS;
2077
2078 rx_mcs_supp = GET_RXMCSSUPP(adapter->hw_dev_mcs_support);
2079 /* Set MCS for 1x1 */
2080 memset(mcs, 0xff, rx_mcs_supp);
2081 /* Clear all the other values */
2082 memset(&mcs[rx_mcs_supp], 0,
2083 sizeof(struct ieee80211_mcs_info) - rx_mcs_supp);
2084 if (priv->bss_mode == NL80211_IFTYPE_STATION ||
2085 ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2086 /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
2087 SETHT_MCS32(mcs_set.rx_mask);
2088
2089 memcpy((u8 *) &ht_info->mcs, mcs, sizeof(struct ieee80211_mcs_info));
2090
2091 ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2092 }
2093
2094 /*
2095 * create a new virtual interface with the given name
2096 */
2097 struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
2098 const char *name,
2099 enum nl80211_iftype type,
2100 u32 *flags,
2101 struct vif_params *params)
2102 {
2103 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
2104 struct mwifiex_private *priv;
2105 struct net_device *dev;
2106 void *mdev_priv;
2107 struct wireless_dev *wdev;
2108
2109 if (!adapter)
2110 return ERR_PTR(-EFAULT);
2111
2112 switch (type) {
2113 case NL80211_IFTYPE_UNSPECIFIED:
2114 case NL80211_IFTYPE_STATION:
2115 case NL80211_IFTYPE_ADHOC:
2116 priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
2117 if (priv->bss_mode) {
2118 wiphy_err(wiphy,
2119 "cannot create multiple sta/adhoc ifaces\n");
2120 return ERR_PTR(-EINVAL);
2121 }
2122
2123 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
2124 if (!wdev)
2125 return ERR_PTR(-ENOMEM);
2126
2127 wdev->wiphy = wiphy;
2128 priv->wdev = wdev;
2129 wdev->iftype = NL80211_IFTYPE_STATION;
2130
2131 if (type == NL80211_IFTYPE_UNSPECIFIED)
2132 priv->bss_mode = NL80211_IFTYPE_STATION;
2133 else
2134 priv->bss_mode = type;
2135
2136 priv->bss_type = MWIFIEX_BSS_TYPE_STA;
2137 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2138 priv->bss_priority = 0;
2139 priv->bss_role = MWIFIEX_BSS_ROLE_STA;
2140 priv->bss_num = 0;
2141
2142 break;
2143 case NL80211_IFTYPE_AP:
2144 priv = adapter->priv[MWIFIEX_BSS_TYPE_UAP];
2145
2146 if (priv->bss_mode) {
2147 wiphy_err(wiphy, "Can't create multiple AP interfaces");
2148 return ERR_PTR(-EINVAL);
2149 }
2150
2151 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
2152 if (!wdev)
2153 return ERR_PTR(-ENOMEM);
2154
2155 priv->wdev = wdev;
2156 wdev->wiphy = wiphy;
2157 wdev->iftype = NL80211_IFTYPE_AP;
2158
2159 priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
2160 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2161 priv->bss_priority = 0;
2162 priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
2163 priv->bss_started = 0;
2164 priv->bss_num = 0;
2165 priv->bss_mode = type;
2166
2167 break;
2168 case NL80211_IFTYPE_P2P_CLIENT:
2169 priv = adapter->priv[MWIFIEX_BSS_TYPE_P2P];
2170
2171 if (priv->bss_mode) {
2172 wiphy_err(wiphy, "Can't create multiple P2P ifaces");
2173 return ERR_PTR(-EINVAL);
2174 }
2175
2176 wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
2177 if (!wdev)
2178 return ERR_PTR(-ENOMEM);
2179
2180 priv->wdev = wdev;
2181 wdev->wiphy = wiphy;
2182
2183 /* At start-up, wpa_supplicant tries to change the interface
2184 * to NL80211_IFTYPE_STATION if it is not managed mode.
2185 */
2186 wdev->iftype = NL80211_IFTYPE_P2P_CLIENT;
2187 priv->bss_mode = NL80211_IFTYPE_P2P_CLIENT;
2188
2189 /* Setting bss_type to P2P tells firmware that this interface
2190 * is receiving P2P peers found during find phase and doing
2191 * action frame handshake.
2192 */
2193 priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
2194
2195 priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2196 priv->bss_priority = MWIFIEX_BSS_ROLE_STA;
2197 priv->bss_role = MWIFIEX_BSS_ROLE_STA;
2198 priv->bss_started = 0;
2199 priv->bss_num = 0;
2200
2201 if (mwifiex_cfg80211_init_p2p_client(priv))
2202 return ERR_PTR(-EFAULT);
2203
2204 break;
2205 default:
2206 wiphy_err(wiphy, "type not supported\n");
2207 return ERR_PTR(-EINVAL);
2208 }
2209
2210 dev = alloc_netdev_mqs(sizeof(struct mwifiex_private *), name,
2211 ether_setup, IEEE80211_NUM_ACS, 1);
2212 if (!dev) {
2213 wiphy_err(wiphy, "no memory available for netdevice\n");
2214 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2215 return ERR_PTR(-ENOMEM);
2216 }
2217
2218 mwifiex_init_priv_params(priv, dev);
2219 priv->netdev = dev;
2220
2221 mwifiex_setup_ht_caps(&wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap, priv);
2222 if (adapter->is_hw_11ac_capable)
2223 mwifiex_setup_vht_caps(
2224 &wiphy->bands[IEEE80211_BAND_2GHZ]->vht_cap, priv);
2225
2226 if (adapter->config_bands & BAND_A)
2227 mwifiex_setup_ht_caps(
2228 &wiphy->bands[IEEE80211_BAND_5GHZ]->ht_cap, priv);
2229
2230 if ((adapter->config_bands & BAND_A) && adapter->is_hw_11ac_capable)
2231 mwifiex_setup_vht_caps(
2232 &wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap, priv);
2233
2234 dev_net_set(dev, wiphy_net(wiphy));
2235 dev->ieee80211_ptr = priv->wdev;
2236 dev->ieee80211_ptr->iftype = priv->bss_mode;
2237 memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
2238 SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
2239
2240 dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
2241 dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;
2242 dev->hard_header_len += MWIFIEX_MIN_DATA_HEADER_LEN;
2243 dev->ethtool_ops = &mwifiex_ethtool_ops;
2244
2245 mdev_priv = netdev_priv(dev);
2246 *((unsigned long *) mdev_priv) = (unsigned long) priv;
2247
2248 SET_NETDEV_DEV(dev, adapter->dev);
2249
2250 /* Register network device */
2251 if (register_netdevice(dev)) {
2252 wiphy_err(wiphy, "cannot register virtual network device\n");
2253 free_netdev(dev);
2254 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2255 return ERR_PTR(-EFAULT);
2256 }
2257
2258 sema_init(&priv->async_sem, 1);
2259
2260 dev_dbg(adapter->dev, "info: %s: Marvell 802.11 Adapter\n", dev->name);
2261
2262 #ifdef CONFIG_DEBUG_FS
2263 mwifiex_dev_debugfs_init(priv);
2264 #endif
2265 return wdev;
2266 }
2267 EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
2268
2269 /*
2270 * del_virtual_intf: remove the virtual interface determined by dev
2271 */
2272 int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
2273 {
2274 struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
2275
2276 #ifdef CONFIG_DEBUG_FS
2277 mwifiex_dev_debugfs_remove(priv);
2278 #endif
2279
2280 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
2281
2282 if (netif_carrier_ok(priv->netdev))
2283 netif_carrier_off(priv->netdev);
2284
2285 if (wdev->netdev->reg_state == NETREG_REGISTERED)
2286 unregister_netdevice(wdev->netdev);
2287
2288 /* Clear the priv in adapter */
2289 priv->netdev = NULL;
2290
2291 priv->media_connected = false;
2292
2293 priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
2294
2295 return 0;
2296 }
2297 EXPORT_SYMBOL_GPL(mwifiex_del_virtual_intf);
2298
2299 #ifdef CONFIG_PM
2300 static bool
2301 mwifiex_is_pattern_supported(struct cfg80211_wowlan_trig_pkt_pattern *pat,
2302 s8 *byte_seq)
2303 {
2304 int j, k, valid_byte_cnt = 0;
2305 bool dont_care_byte = false;
2306
2307 for (j = 0; j < DIV_ROUND_UP(pat->pattern_len, 8); j++) {
2308 for (k = 0; k < 8; k++) {
2309 if (pat->mask[j] & 1 << k) {
2310 memcpy(byte_seq + valid_byte_cnt,
2311 &pat->pattern[j * 8 + k], 1);
2312 valid_byte_cnt++;
2313 if (dont_care_byte)
2314 return false;
2315 } else {
2316 if (valid_byte_cnt)
2317 dont_care_byte = true;
2318 }
2319
2320 if (valid_byte_cnt > MAX_BYTESEQ)
2321 return false;
2322 }
2323 }
2324
2325 byte_seq[MAX_BYTESEQ] = valid_byte_cnt;
2326
2327 return true;
2328 }
2329
2330 static int mwifiex_cfg80211_suspend(struct wiphy *wiphy,
2331 struct cfg80211_wowlan *wowlan)
2332 {
2333 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
2334 struct mwifiex_ds_mef_cfg mef_cfg;
2335 struct mwifiex_mef_entry *mef_entry;
2336 int i, filt_num = 0, ret;
2337 bool first_pat = true;
2338 u8 byte_seq[MAX_BYTESEQ + 1];
2339 const u8 ipv4_mc_mac[] = {0x33, 0x33};
2340 const u8 ipv6_mc_mac[] = {0x01, 0x00, 0x5e};
2341 struct mwifiex_private *priv =
2342 mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
2343
2344 if (!wowlan) {
2345 dev_warn(adapter->dev, "None of the WOWLAN triggers enabled\n");
2346 return 0;
2347 }
2348
2349 if (!priv->media_connected) {
2350 dev_warn(adapter->dev,
2351 "Can not configure WOWLAN in disconnected state\n");
2352 return 0;
2353 }
2354
2355 mef_entry = kzalloc(sizeof(*mef_entry), GFP_KERNEL);
2356 if (!mef_entry)
2357 return -ENOMEM;
2358
2359 memset(&mef_cfg, 0, sizeof(mef_cfg));
2360 mef_cfg.num_entries = 1;
2361 mef_cfg.mef_entry = mef_entry;
2362 mef_entry->mode = MEF_MODE_HOST_SLEEP;
2363 mef_entry->action = MEF_ACTION_ALLOW_AND_WAKEUP_HOST;
2364
2365 for (i = 0; i < wowlan->n_patterns; i++) {
2366 memset(byte_seq, 0, sizeof(byte_seq));
2367 if (!mwifiex_is_pattern_supported(&wowlan->patterns[i],
2368 byte_seq)) {
2369 wiphy_err(wiphy, "Pattern not supported\n");
2370 kfree(mef_entry);
2371 return -EOPNOTSUPP;
2372 }
2373
2374 if (!wowlan->patterns[i].pkt_offset) {
2375 if (!(byte_seq[0] & 0x01) &&
2376 (byte_seq[MAX_BYTESEQ] == 1)) {
2377 mef_cfg.criteria |= MWIFIEX_CRITERIA_UNICAST;
2378 continue;
2379 } else if (is_broadcast_ether_addr(byte_seq)) {
2380 mef_cfg.criteria |= MWIFIEX_CRITERIA_BROADCAST;
2381 continue;
2382 } else if ((!memcmp(byte_seq, ipv4_mc_mac, 2) &&
2383 (byte_seq[MAX_BYTESEQ] == 2)) ||
2384 (!memcmp(byte_seq, ipv6_mc_mac, 3) &&
2385 (byte_seq[MAX_BYTESEQ] == 3))) {
2386 mef_cfg.criteria |= MWIFIEX_CRITERIA_MULTICAST;
2387 continue;
2388 }
2389 }
2390
2391 mef_entry->filter[filt_num].repeat = 1;
2392 mef_entry->filter[filt_num].offset =
2393 wowlan->patterns[i].pkt_offset;
2394 memcpy(mef_entry->filter[filt_num].byte_seq, byte_seq,
2395 sizeof(byte_seq));
2396 mef_entry->filter[filt_num].filt_type = TYPE_EQ;
2397
2398 if (first_pat)
2399 first_pat = false;
2400 else
2401 mef_entry->filter[filt_num].filt_action = TYPE_AND;
2402
2403 filt_num++;
2404 }
2405
2406 if (wowlan->magic_pkt) {
2407 mef_cfg.criteria |= MWIFIEX_CRITERIA_UNICAST;
2408 mef_entry->filter[filt_num].repeat = 16;
2409 memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,
2410 ETH_ALEN);
2411 mef_entry->filter[filt_num].byte_seq[MAX_BYTESEQ] = ETH_ALEN;
2412 mef_entry->filter[filt_num].offset = 14;
2413 mef_entry->filter[filt_num].filt_type = TYPE_EQ;
2414 if (filt_num)
2415 mef_entry->filter[filt_num].filt_action = TYPE_OR;
2416 }
2417
2418 if (!mef_cfg.criteria)
2419 mef_cfg.criteria = MWIFIEX_CRITERIA_BROADCAST |
2420 MWIFIEX_CRITERIA_UNICAST |
2421 MWIFIEX_CRITERIA_MULTICAST;
2422
2423 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_MEF_CFG,
2424 HostCmd_ACT_GEN_SET, 0,
2425 &mef_cfg);
2426
2427 kfree(mef_entry);
2428 return ret;
2429 }
2430
2431 static int mwifiex_cfg80211_resume(struct wiphy *wiphy)
2432 {
2433 return 0;
2434 }
2435
2436 static void mwifiex_cfg80211_set_wakeup(struct wiphy *wiphy,
2437 bool enabled)
2438 {
2439 struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
2440
2441 device_set_wakeup_enable(adapter->dev, enabled);
2442 }
2443 #endif
2444
2445 /* station cfg80211 operations */
2446 static struct cfg80211_ops mwifiex_cfg80211_ops = {
2447 .add_virtual_intf = mwifiex_add_virtual_intf,
2448 .del_virtual_intf = mwifiex_del_virtual_intf,
2449 .change_virtual_intf = mwifiex_cfg80211_change_virtual_intf,
2450 .scan = mwifiex_cfg80211_scan,
2451 .connect = mwifiex_cfg80211_connect,
2452 .disconnect = mwifiex_cfg80211_disconnect,
2453 .get_station = mwifiex_cfg80211_get_station,
2454 .dump_station = mwifiex_cfg80211_dump_station,
2455 .set_wiphy_params = mwifiex_cfg80211_set_wiphy_params,
2456 .join_ibss = mwifiex_cfg80211_join_ibss,
2457 .leave_ibss = mwifiex_cfg80211_leave_ibss,
2458 .add_key = mwifiex_cfg80211_add_key,
2459 .del_key = mwifiex_cfg80211_del_key,
2460 .mgmt_tx = mwifiex_cfg80211_mgmt_tx,
2461 .mgmt_frame_register = mwifiex_cfg80211_mgmt_frame_register,
2462 .remain_on_channel = mwifiex_cfg80211_remain_on_channel,
2463 .cancel_remain_on_channel = mwifiex_cfg80211_cancel_remain_on_channel,
2464 .set_default_key = mwifiex_cfg80211_set_default_key,
2465 .set_power_mgmt = mwifiex_cfg80211_set_power_mgmt,
2466 .set_tx_power = mwifiex_cfg80211_set_tx_power,
2467 .set_bitrate_mask = mwifiex_cfg80211_set_bitrate_mask,
2468 .start_ap = mwifiex_cfg80211_start_ap,
2469 .stop_ap = mwifiex_cfg80211_stop_ap,
2470 .change_beacon = mwifiex_cfg80211_change_beacon,
2471 .set_cqm_rssi_config = mwifiex_cfg80211_set_cqm_rssi_config,
2472 .set_antenna = mwifiex_cfg80211_set_antenna,
2473 .del_station = mwifiex_cfg80211_del_station,
2474 #ifdef CONFIG_PM
2475 .suspend = mwifiex_cfg80211_suspend,
2476 .resume = mwifiex_cfg80211_resume,
2477 .set_wakeup = mwifiex_cfg80211_set_wakeup,
2478 #endif
2479 };
2480
2481 #ifdef CONFIG_PM
2482 static const struct wiphy_wowlan_support mwifiex_wowlan_support = {
2483 .flags = WIPHY_WOWLAN_MAGIC_PKT,
2484 .n_patterns = MWIFIEX_MAX_FILTERS,
2485 .pattern_min_len = 1,
2486 .pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
2487 .max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
2488 };
2489 #endif
2490
2491 static bool mwifiex_is_valid_alpha2(const char *alpha2)
2492 {
2493 if (!alpha2 || strlen(alpha2) != 2)
2494 return false;
2495
2496 if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
2497 return true;
2498
2499 return false;
2500 }
2501
2502 /*
2503 * This function registers the device with CFG802.11 subsystem.
2504 *
2505 * The function creates the wireless device/wiphy, populates it with
2506 * default parameters and handler function pointers, and finally
2507 * registers the device.
2508 */
2509
2510 int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
2511 {
2512 int ret;
2513 void *wdev_priv;
2514 struct wiphy *wiphy;
2515 struct mwifiex_private *priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
2516 u8 *country_code;
2517
2518 /* create a new wiphy for use with cfg80211 */
2519 wiphy = wiphy_new(&mwifiex_cfg80211_ops,
2520 sizeof(struct mwifiex_adapter *));
2521 if (!wiphy) {
2522 dev_err(adapter->dev, "%s: creating new wiphy\n", __func__);
2523 return -ENOMEM;
2524 }
2525 wiphy->max_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
2526 wiphy->max_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
2527 wiphy->mgmt_stypes = mwifiex_mgmt_stypes;
2528 wiphy->max_remain_on_channel_duration = 5000;
2529 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
2530 BIT(NL80211_IFTYPE_ADHOC) |
2531 BIT(NL80211_IFTYPE_P2P_CLIENT) |
2532 BIT(NL80211_IFTYPE_P2P_GO) |
2533 BIT(NL80211_IFTYPE_AP);
2534
2535 wiphy->bands[IEEE80211_BAND_2GHZ] = &mwifiex_band_2ghz;
2536 if (adapter->config_bands & BAND_A)
2537 wiphy->bands[IEEE80211_BAND_5GHZ] = &mwifiex_band_5ghz;
2538 else
2539 wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
2540
2541 wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta;
2542 wiphy->n_iface_combinations = 1;
2543
2544 /* Initialize cipher suits */
2545 wiphy->cipher_suites = mwifiex_cipher_suites;
2546 wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
2547
2548 memcpy(wiphy->perm_addr, priv->curr_addr, ETH_ALEN);
2549 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2550 wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
2551 WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD |
2552 WIPHY_FLAG_AP_UAPSD |
2553 WIPHY_FLAG_CUSTOM_REGULATORY |
2554 WIPHY_FLAG_STRICT_REGULATORY |
2555 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
2556
2557 wiphy_apply_custom_regulatory(wiphy, &mwifiex_world_regdom_custom);
2558
2559 #ifdef CONFIG_PM
2560 wiphy->wowlan = &mwifiex_wowlan_support;
2561 #endif
2562
2563 wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
2564 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
2565 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
2566
2567 wiphy->available_antennas_tx = BIT(adapter->number_of_antenna) - 1;
2568 wiphy->available_antennas_rx = BIT(adapter->number_of_antenna) - 1;
2569
2570 wiphy->features |= NL80211_FEATURE_HT_IBSS |
2571 NL80211_FEATURE_INACTIVITY_TIMER |
2572 NL80211_FEATURE_LOW_PRIORITY_SCAN;
2573
2574 /* Reserve space for mwifiex specific private data for BSS */
2575 wiphy->bss_priv_size = sizeof(struct mwifiex_bss_priv);
2576
2577 wiphy->reg_notifier = mwifiex_reg_notifier;
2578
2579 /* Set struct mwifiex_adapter pointer in wiphy_priv */
2580 wdev_priv = wiphy_priv(wiphy);
2581 *(unsigned long *)wdev_priv = (unsigned long)adapter;
2582
2583 set_wiphy_dev(wiphy, priv->adapter->dev);
2584
2585 ret = wiphy_register(wiphy);
2586 if (ret < 0) {
2587 dev_err(adapter->dev,
2588 "%s: wiphy_register failed: %d\n", __func__, ret);
2589 wiphy_free(wiphy);
2590 return ret;
2591 }
2592
2593 if (reg_alpha2 && mwifiex_is_valid_alpha2(reg_alpha2)) {
2594 wiphy_info(wiphy, "driver hint alpha2: %2.2s\n", reg_alpha2);
2595 regulatory_hint(wiphy, reg_alpha2);
2596 } else {
2597 country_code = mwifiex_11d_code_2_region(adapter->region_code);
2598 if (country_code)
2599 wiphy_info(wiphy, "ignoring F/W country code %2.2s\n",
2600 country_code);
2601 }
2602
2603 adapter->wiphy = wiphy;
2604 return ret;
2605 }
Linux kernel - Deliverables
This page took 0.116331 seconds and 5 git commands to generate.