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