marvell/mwifiex/cfg80211.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * NXP Wireless LAN device driver: CFG80211
0004  *
0005  * Copyright 2011-2020 NXP
0006  */
0007
0008 #include "cfg80211.h"
0009 #include "main.h"
0010 #include "11n.h"
0011 #include "wmm.h"
0012
0013 static char *reg_alpha2;
0014 module_param(reg_alpha2, charp, 0);
0015
0016 static const struct ieee80211_iface_limit mwifiex_ap_sta_limits[] = {
0017     {
0018         .max = MWIFIEX_MAX_BSS_NUM,
0019         .types = BIT(NL80211_IFTYPE_STATION) |
0020                    BIT(NL80211_IFTYPE_P2P_GO) |
0021                    BIT(NL80211_IFTYPE_P2P_CLIENT) |
0022                    BIT(NL80211_IFTYPE_AP),
0023     },
0024 };
0025
0026 static const struct ieee80211_iface_combination
0027 mwifiex_iface_comb_ap_sta = {
0028     .limits = mwifiex_ap_sta_limits,
0029     .num_different_channels = 1,
0030     .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
0031     .max_interfaces = MWIFIEX_MAX_BSS_NUM,
0032     .beacon_int_infra_match = true,
0033     .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
0034                 BIT(NL80211_CHAN_WIDTH_20) |
0035                 BIT(NL80211_CHAN_WIDTH_40),
0036 };
0037
0038 static const struct ieee80211_iface_combination
0039 mwifiex_iface_comb_ap_sta_vht = {
0040     .limits = mwifiex_ap_sta_limits,
0041     .num_different_channels = 1,
0042     .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
0043     .max_interfaces = MWIFIEX_MAX_BSS_NUM,
0044     .beacon_int_infra_match = true,
0045     .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
0046                 BIT(NL80211_CHAN_WIDTH_20) |
0047                 BIT(NL80211_CHAN_WIDTH_40) |
0048                 BIT(NL80211_CHAN_WIDTH_80),
0049 };
0050
0051 static const struct
0052 ieee80211_iface_combination mwifiex_iface_comb_ap_sta_drcs = {
0053     .limits = mwifiex_ap_sta_limits,
0054     .num_different_channels = 2,
0055     .n_limits = ARRAY_SIZE(mwifiex_ap_sta_limits),
0056     .max_interfaces = MWIFIEX_MAX_BSS_NUM,
0057     .beacon_int_infra_match = true,
0058 };
0059
0060 /*
0061  * This function maps the nl802.11 channel type into driver channel type.
0062  *
0063  * The mapping is as follows -
0064  *      NL80211_CHAN_NO_HT     -> IEEE80211_HT_PARAM_CHA_SEC_NONE
0065  *      NL80211_CHAN_HT20      -> IEEE80211_HT_PARAM_CHA_SEC_NONE
0066  *      NL80211_CHAN_HT40PLUS  -> IEEE80211_HT_PARAM_CHA_SEC_ABOVE
0067  *      NL80211_CHAN_HT40MINUS -> IEEE80211_HT_PARAM_CHA_SEC_BELOW
0068  *      Others                 -> IEEE80211_HT_PARAM_CHA_SEC_NONE
0069  */
0070 u8 mwifiex_chan_type_to_sec_chan_offset(enum nl80211_channel_type chan_type)
0071 {
0072     switch (chan_type) {
0073     case NL80211_CHAN_NO_HT:
0074     case NL80211_CHAN_HT20:
0075         return IEEE80211_HT_PARAM_CHA_SEC_NONE;
0076     case NL80211_CHAN_HT40PLUS:
0077         return IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
0078     case NL80211_CHAN_HT40MINUS:
0079         return IEEE80211_HT_PARAM_CHA_SEC_BELOW;
0080     default:
0081         return IEEE80211_HT_PARAM_CHA_SEC_NONE;
0082     }
0083 }
0084
0085 /* This function maps IEEE HT secondary channel type to NL80211 channel type
0086  */
0087 u8 mwifiex_get_chan_type(struct mwifiex_private *priv)
0088 {
0089     struct mwifiex_channel_band channel_band;
0090     int ret;
0091
0092     ret = mwifiex_get_chan_info(priv, &channel_band);
0093
0094     if (!ret) {
0095         switch (channel_band.band_config.chan_width) {
0096         case CHAN_BW_20MHZ:
0097             if (IS_11N_ENABLED(priv))
0098                 return NL80211_CHAN_HT20;
0099             else
0100                 return NL80211_CHAN_NO_HT;
0101         case CHAN_BW_40MHZ:
0102             if (channel_band.band_config.chan2_offset ==
0103                 SEC_CHAN_ABOVE)
0104                 return NL80211_CHAN_HT40PLUS;
0105             else
0106                 return NL80211_CHAN_HT40MINUS;
0107         default:
0108             return NL80211_CHAN_HT20;
0109         }
0110     }
0111
0112     return NL80211_CHAN_HT20;
0113 }
0114
0115 /*
0116  * This function checks whether WEP is set.
0117  */
0118 static int
0119 mwifiex_is_alg_wep(u32 cipher)
0120 {
0121     switch (cipher) {
0122     case WLAN_CIPHER_SUITE_WEP40:
0123     case WLAN_CIPHER_SUITE_WEP104:
0124         return 1;
0125     default:
0126         break;
0127     }
0128
0129     return 0;
0130 }
0131
0132 /*
0133  * This function retrieves the private structure from kernel wiphy structure.
0134  */
0135 static void *mwifiex_cfg80211_get_adapter(struct wiphy *wiphy)
0136 {
0137     return (void *) (*(unsigned long *) wiphy_priv(wiphy));
0138 }
0139
0140 /*
0141  * CFG802.11 operation handler to delete a network key.
0142  */
0143 static int
0144 mwifiex_cfg80211_del_key(struct wiphy *wiphy, struct net_device *netdev,
0145              u8 key_index, bool pairwise, const u8 *mac_addr)
0146 {
0147     struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
0148     static const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
0149     const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
0150
0151     if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index, peer_mac, 1)) {
0152         mwifiex_dbg(priv->adapter, ERROR, "deleting the crypto keys\n");
0153         return -EFAULT;
0154     }
0155
0156     mwifiex_dbg(priv->adapter, INFO, "info: crypto keys deleted\n");
0157     return 0;
0158 }
0159
0160 /*
0161  * This function forms an skb for management frame.
0162  */
0163 static int
0164 mwifiex_form_mgmt_frame(struct sk_buff *skb, const u8 *buf, size_t len)
0165 {
0166     u8 addr[ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
0167     u16 pkt_len;
0168     u32 tx_control = 0, pkt_type = PKT_TYPE_MGMT;
0169
0170     pkt_len = len + ETH_ALEN;
0171
0172     skb_reserve(skb, MWIFIEX_MIN_DATA_HEADER_LEN +
0173             MWIFIEX_MGMT_FRAME_HEADER_SIZE + sizeof(pkt_len));
0174     memcpy(skb_push(skb, sizeof(pkt_len)), &pkt_len, sizeof(pkt_len));
0175
0176     memcpy(skb_push(skb, sizeof(tx_control)),
0177            &tx_control, sizeof(tx_control));
0178
0179     memcpy(skb_push(skb, sizeof(pkt_type)), &pkt_type, sizeof(pkt_type));
0180
0181     /* Add packet data and address4 */
0182     skb_put_data(skb, buf, sizeof(struct ieee80211_hdr_3addr));
0183     skb_put_data(skb, addr, ETH_ALEN);
0184     skb_put_data(skb, buf + sizeof(struct ieee80211_hdr_3addr),
0185              len - sizeof(struct ieee80211_hdr_3addr));
0186
0187     skb->priority = LOW_PRIO_TID;
0188     __net_timestamp(skb);
0189
0190     return 0;
0191 }
0192
0193 /*
0194  * CFG802.11 operation handler to transmit a management frame.
0195  */
0196 static int
0197 mwifiex_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
0198              struct cfg80211_mgmt_tx_params *params, u64 *cookie)
0199 {
0200     const u8 *buf = params->buf;
0201     size_t len = params->len;
0202     struct sk_buff *skb;
0203     u16 pkt_len;
0204     const struct ieee80211_mgmt *mgmt;
0205     struct mwifiex_txinfo *tx_info;
0206     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
0207
0208     if (!buf || !len) {
0209         mwifiex_dbg(priv->adapter, ERROR, "invalid buffer and length\n");
0210         return -EFAULT;
0211     }
0212
0213     mgmt = (const struct ieee80211_mgmt *)buf;
0214     if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA &&
0215         ieee80211_is_probe_resp(mgmt->frame_control)) {
0216         /* Since we support offload probe resp, we need to skip probe
0217          * resp in AP or GO mode */
0218         mwifiex_dbg(priv->adapter, INFO,
0219                 "info: skip to send probe resp in AP or GO mode\n");
0220         return 0;
0221     }
0222
0223     pkt_len = len + ETH_ALEN;
0224     skb = dev_alloc_skb(MWIFIEX_MIN_DATA_HEADER_LEN +
0225                 MWIFIEX_MGMT_FRAME_HEADER_SIZE +
0226                 pkt_len + sizeof(pkt_len));
0227
0228     if (!skb) {
0229         mwifiex_dbg(priv->adapter, ERROR,
0230                 "allocate skb failed for management frame\n");
0231         return -ENOMEM;
0232     }
0233
0234     tx_info = MWIFIEX_SKB_TXCB(skb);
0235     memset(tx_info, 0, sizeof(*tx_info));
0236     tx_info->bss_num = priv->bss_num;
0237     tx_info->bss_type = priv->bss_type;
0238     tx_info->pkt_len = pkt_len;
0239
0240     mwifiex_form_mgmt_frame(skb, buf, len);
0241     *cookie = prandom_u32() | 1;
0242
0243     if (ieee80211_is_action(mgmt->frame_control))
0244         skb = mwifiex_clone_skb_for_tx_status(priv,
0245                               skb,
0246                 MWIFIEX_BUF_FLAG_ACTION_TX_STATUS, cookie);
0247     else
0248         cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
0249                     GFP_ATOMIC);
0250
0251     mwifiex_queue_tx_pkt(priv, skb);
0252
0253     mwifiex_dbg(priv->adapter, INFO, "info: management frame transmitted\n");
0254     return 0;
0255 }
0256
0257 /*
0258  * CFG802.11 operation handler to register a mgmt frame.
0259  */
0260 static void
0261 mwifiex_cfg80211_update_mgmt_frame_registrations(struct wiphy *wiphy,
0262                          struct wireless_dev *wdev,
0263                          struct mgmt_frame_regs *upd)
0264 {
0265     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
0266     u32 mask = upd->interface_stypes;
0267
0268     if (mask != priv->mgmt_frame_mask) {
0269         priv->mgmt_frame_mask = mask;
0270         mwifiex_send_cmd(priv, HostCmd_CMD_MGMT_FRAME_REG,
0271                  HostCmd_ACT_GEN_SET, 0,
0272                  &priv->mgmt_frame_mask, false);
0273         mwifiex_dbg(priv->adapter, INFO, "info: mgmt frame registered\n");
0274     }
0275 }
0276
0277 /*
0278  * CFG802.11 operation handler to remain on channel.
0279  */
0280 static int
0281 mwifiex_cfg80211_remain_on_channel(struct wiphy *wiphy,
0282                    struct wireless_dev *wdev,
0283                    struct ieee80211_channel *chan,
0284                    unsigned int duration, u64 *cookie)
0285 {
0286     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
0287     int ret;
0288
0289     if (!chan || !cookie) {
0290         mwifiex_dbg(priv->adapter, ERROR, "Invalid parameter for ROC\n");
0291         return -EINVAL;
0292     }
0293
0294     if (priv->roc_cfg.cookie) {
0295         mwifiex_dbg(priv->adapter, INFO,
0296                 "info: ongoing ROC, cookie = 0x%llx\n",
0297                 priv->roc_cfg.cookie);
0298         return -EBUSY;
0299     }
0300
0301     ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_SET, chan,
0302                      duration);
0303
0304     if (!ret) {
0305         *cookie = prandom_u32() | 1;
0306         priv->roc_cfg.cookie = *cookie;
0307         priv->roc_cfg.chan = *chan;
0308
0309         cfg80211_ready_on_channel(wdev, *cookie, chan,
0310                       duration, GFP_ATOMIC);
0311
0312         mwifiex_dbg(priv->adapter, INFO,
0313                 "info: ROC, cookie = 0x%llx\n", *cookie);
0314     }
0315
0316     return ret;
0317 }
0318
0319 /*
0320  * CFG802.11 operation handler to cancel remain on channel.
0321  */
0322 static int
0323 mwifiex_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
0324                       struct wireless_dev *wdev, u64 cookie)
0325 {
0326     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
0327     int ret;
0328
0329     if (cookie != priv->roc_cfg.cookie)
0330         return -ENOENT;
0331
0332     ret = mwifiex_remain_on_chan_cfg(priv, HostCmd_ACT_GEN_REMOVE,
0333                      &priv->roc_cfg.chan, 0);
0334
0335     if (!ret) {
0336         cfg80211_remain_on_channel_expired(wdev, cookie,
0337                            &priv->roc_cfg.chan,
0338                            GFP_ATOMIC);
0339
0340         memset(&priv->roc_cfg, 0, sizeof(struct mwifiex_roc_cfg));
0341
0342         mwifiex_dbg(priv->adapter, INFO,
0343                 "info: cancel ROC, cookie = 0x%llx\n", cookie);
0344     }
0345
0346     return ret;
0347 }
0348
0349 /*
0350  * CFG802.11 operation handler to set Tx power.
0351  */
0352 static int
0353 mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy,
0354                   struct wireless_dev *wdev,
0355                   enum nl80211_tx_power_setting type,
0356                   int mbm)
0357 {
0358     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
0359     struct mwifiex_private *priv;
0360     struct mwifiex_power_cfg power_cfg;
0361     int dbm = MBM_TO_DBM(mbm);
0362
0363     switch (type) {
0364     case NL80211_TX_POWER_FIXED:
0365         power_cfg.is_power_auto = 0;
0366         power_cfg.is_power_fixed = 1;
0367         power_cfg.power_level = dbm;
0368         break;
0369     case NL80211_TX_POWER_LIMITED:
0370         power_cfg.is_power_auto = 0;
0371         power_cfg.is_power_fixed = 0;
0372         power_cfg.power_level = dbm;
0373         break;
0374     case NL80211_TX_POWER_AUTOMATIC:
0375         power_cfg.is_power_auto = 1;
0376         break;
0377     }
0378
0379     priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
0380
0381     return mwifiex_set_tx_power(priv, &power_cfg);
0382 }
0383
0384 /*
0385  * CFG802.11 operation handler to get Tx power.
0386  */
0387 static int
0388 mwifiex_cfg80211_get_tx_power(struct wiphy *wiphy,
0389                   struct wireless_dev *wdev,
0390                   int *dbm)
0391 {
0392     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
0393     struct mwifiex_private *priv = mwifiex_get_priv(adapter,
0394                             MWIFIEX_BSS_ROLE_ANY);
0395     int ret = mwifiex_send_cmd(priv, HostCmd_CMD_RF_TX_PWR,
0396                    HostCmd_ACT_GEN_GET, 0, NULL, true);
0397
0398     if (ret < 0)
0399         return ret;
0400
0401     /* tx_power_level is set in HostCmd_CMD_RF_TX_PWR command handler */
0402     *dbm = priv->tx_power_level;
0403
0404     return 0;
0405 }
0406
0407 /*
0408  * CFG802.11 operation handler to set Power Save option.
0409  *
0410  * The timeout value, if provided, is currently ignored.
0411  */
0412 static int
0413 mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy,
0414                 struct net_device *dev,
0415                 bool enabled, int timeout)
0416 {
0417     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
0418     u32 ps_mode;
0419
0420     if (timeout)
0421         mwifiex_dbg(priv->adapter, INFO,
0422                 "info: ignore timeout value for IEEE Power Save\n");
0423
0424     ps_mode = enabled;
0425
0426     return mwifiex_drv_set_power(priv, &ps_mode);
0427 }
0428
0429 /*
0430  * CFG802.11 operation handler to set the default network key.
0431  */
0432 static int
0433 mwifiex_cfg80211_set_default_key(struct wiphy *wiphy, struct net_device *netdev,
0434                  u8 key_index, bool unicast,
0435                  bool multicast)
0436 {
0437     struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
0438
0439     /* Return if WEP key not configured */
0440     if (!priv->sec_info.wep_enabled)
0441         return 0;
0442
0443     if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP) {
0444         priv->wep_key_curr_index = key_index;
0445     } else if (mwifiex_set_encode(priv, NULL, NULL, 0, key_index,
0446                       NULL, 0)) {
0447         mwifiex_dbg(priv->adapter, ERROR, "set default Tx key index\n");
0448         return -EFAULT;
0449     }
0450
0451     return 0;
0452 }
0453
0454 /*
0455  * CFG802.11 operation handler to add a network key.
0456  */
0457 static int
0458 mwifiex_cfg80211_add_key(struct wiphy *wiphy, struct net_device *netdev,
0459              u8 key_index, bool pairwise, const u8 *mac_addr,
0460              struct key_params *params)
0461 {
0462     struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
0463     struct mwifiex_wep_key *wep_key;
0464     static const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
0465     const u8 *peer_mac = pairwise ? mac_addr : bc_mac;
0466
0467     if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
0468         (params->cipher == WLAN_CIPHER_SUITE_WEP40 ||
0469          params->cipher == WLAN_CIPHER_SUITE_WEP104)) {
0470         if (params->key && params->key_len) {
0471             wep_key = &priv->wep_key[key_index];
0472             memset(wep_key, 0, sizeof(struct mwifiex_wep_key));
0473             memcpy(wep_key->key_material, params->key,
0474                    params->key_len);
0475             wep_key->key_index = key_index;
0476             wep_key->key_length = params->key_len;
0477             priv->sec_info.wep_enabled = 1;
0478         }
0479         return 0;
0480     }
0481
0482     if (mwifiex_set_encode(priv, params, params->key, params->key_len,
0483                    key_index, peer_mac, 0)) {
0484         mwifiex_dbg(priv->adapter, ERROR, "crypto keys added\n");
0485         return -EFAULT;
0486     }
0487
0488     return 0;
0489 }
0490
0491 /*
0492  * CFG802.11 operation handler to set default mgmt key.
0493  */
0494 static int
0495 mwifiex_cfg80211_set_default_mgmt_key(struct wiphy *wiphy,
0496                       struct net_device *netdev,
0497                       u8 key_index)
0498 {
0499     struct mwifiex_private *priv = mwifiex_netdev_get_priv(netdev);
0500     struct mwifiex_ds_encrypt_key encrypt_key;
0501
0502     wiphy_dbg(wiphy, "set default mgmt key, key index=%d\n", key_index);
0503
0504     memset(&encrypt_key, 0, sizeof(struct mwifiex_ds_encrypt_key));
0505     encrypt_key.key_len = WLAN_KEY_LEN_CCMP;
0506     encrypt_key.key_index = key_index;
0507     encrypt_key.is_igtk_def_key = true;
0508     eth_broadcast_addr(encrypt_key.mac_addr);
0509
0510     if (mwifiex_send_cmd(priv, HostCmd_CMD_802_11_KEY_MATERIAL,
0511                  HostCmd_ACT_GEN_SET, true, &encrypt_key, true)) {
0512         mwifiex_dbg(priv->adapter, ERROR,
0513                 "Sending KEY_MATERIAL command failed\n");
0514         return -1;
0515     }
0516
0517     return 0;
0518 }
0519
0520 /*
0521  * This function sends domain information to the firmware.
0522  *
0523  * The following information are passed to the firmware -
0524  *      - Country codes
0525  *      - Sub bands (first channel, number of channels, maximum Tx power)
0526  */
0527 int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy)
0528 {
0529     u8 no_of_triplet = 0;
0530     struct ieee80211_country_ie_triplet *t;
0531     u8 no_of_parsed_chan = 0;
0532     u8 first_chan = 0, next_chan = 0, max_pwr = 0;
0533     u8 i, flag = 0;
0534     enum nl80211_band band;
0535     struct ieee80211_supported_band *sband;
0536     struct ieee80211_channel *ch;
0537     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
0538     struct mwifiex_private *priv;
0539     struct mwifiex_802_11d_domain_reg *domain_info = &adapter->domain_reg;
0540
0541     /* Set country code */
0542     domain_info->country_code[0] = adapter->country_code[0];
0543     domain_info->country_code[1] = adapter->country_code[1];
0544     domain_info->country_code[2] = ' ';
0545
0546     band = mwifiex_band_to_radio_type(adapter->config_bands);
0547     if (!wiphy->bands[band]) {
0548         mwifiex_dbg(adapter, ERROR,
0549                 "11D: setting domain info in FW\n");
0550         return -1;
0551     }
0552
0553     sband = wiphy->bands[band];
0554
0555     for (i = 0; i < sband->n_channels ; i++) {
0556         ch = &sband->channels[i];
0557         if (ch->flags & IEEE80211_CHAN_DISABLED)
0558             continue;
0559
0560         if (!flag) {
0561             flag = 1;
0562             first_chan = (u32) ch->hw_value;
0563             next_chan = first_chan;
0564             max_pwr = ch->max_power;
0565             no_of_parsed_chan = 1;
0566             continue;
0567         }
0568
0569         if (ch->hw_value == next_chan + 1 &&
0570             ch->max_power == max_pwr) {
0571             next_chan++;
0572             no_of_parsed_chan++;
0573         } else {
0574             t = &domain_info->triplet[no_of_triplet];
0575             t->chans.first_channel = first_chan;
0576             t->chans.num_channels = no_of_parsed_chan;
0577             t->chans.max_power = max_pwr;
0578             no_of_triplet++;
0579             first_chan = (u32) ch->hw_value;
0580             next_chan = first_chan;
0581             max_pwr = ch->max_power;
0582             no_of_parsed_chan = 1;
0583         }
0584     }
0585
0586     if (flag) {
0587         t = &domain_info->triplet[no_of_triplet];
0588         t->chans.first_channel = first_chan;
0589         t->chans.num_channels = no_of_parsed_chan;
0590         t->chans.max_power = max_pwr;
0591         no_of_triplet++;
0592     }
0593
0594     domain_info->no_of_triplet = no_of_triplet;
0595
0596     priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
0597
0598     if (mwifiex_send_cmd(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,
0599                  HostCmd_ACT_GEN_SET, 0, NULL, false)) {
0600         mwifiex_dbg(adapter, INFO,
0601                 "11D: setting domain info in FW\n");
0602         return -1;
0603     }
0604
0605     return 0;
0606 }
0607
0608 static void mwifiex_reg_apply_radar_flags(struct wiphy *wiphy)
0609 {
0610     struct ieee80211_supported_band *sband;
0611     struct ieee80211_channel *chan;
0612     unsigned int i;
0613
0614     if (!wiphy->bands[NL80211_BAND_5GHZ])
0615         return;
0616     sband = wiphy->bands[NL80211_BAND_5GHZ];
0617
0618     for (i = 0; i < sband->n_channels; i++) {
0619         chan = &sband->channels[i];
0620         if ((!(chan->flags & IEEE80211_CHAN_DISABLED)) &&
0621             (chan->flags & IEEE80211_CHAN_RADAR))
0622             chan->flags |= IEEE80211_CHAN_NO_IR;
0623     }
0624 }
0625
0626 /*
0627  * CFG802.11 regulatory domain callback function.
0628  *
0629  * This function is called when the regulatory domain is changed due to the
0630  * following reasons -
0631  *      - Set by driver
0632  *      - Set by system core
0633  *      - Set by user
0634  *      - Set bt Country IE
0635  */
0636 static void mwifiex_reg_notifier(struct wiphy *wiphy,
0637                  struct regulatory_request *request)
0638 {
0639     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
0640     struct mwifiex_private *priv = mwifiex_get_priv(adapter,
0641                             MWIFIEX_BSS_ROLE_ANY);
0642     mwifiex_dbg(adapter, INFO,
0643             "info: cfg80211 regulatory domain callback for %c%c\n",
0644             request->alpha2[0], request->alpha2[1]);
0645     mwifiex_reg_apply_radar_flags(wiphy);
0646
0647     switch (request->initiator) {
0648     case NL80211_REGDOM_SET_BY_DRIVER:
0649     case NL80211_REGDOM_SET_BY_CORE:
0650     case NL80211_REGDOM_SET_BY_USER:
0651     case NL80211_REGDOM_SET_BY_COUNTRY_IE:
0652         break;
0653     default:
0654         mwifiex_dbg(adapter, ERROR,
0655                 "unknown regdom initiator: %d\n",
0656                 request->initiator);
0657         return;
0658     }
0659
0660     /* Don't send world or same regdom info to firmware */
0661     if (strncmp(request->alpha2, "00", 2) &&
0662         strncmp(request->alpha2, adapter->country_code,
0663             sizeof(request->alpha2))) {
0664         memcpy(adapter->country_code, request->alpha2,
0665                sizeof(request->alpha2));
0666         mwifiex_send_domain_info_cmd_fw(wiphy);
0667         mwifiex_dnld_txpwr_table(priv);
0668     }
0669 }
0670
0671 /*
0672  * This function sets the fragmentation threshold.
0673  *
0674  * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE
0675  * and MWIFIEX_FRAG_MAX_VALUE.
0676  */
0677 static int
0678 mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)
0679 {
0680     if (frag_thr < MWIFIEX_FRAG_MIN_VALUE ||
0681         frag_thr > MWIFIEX_FRAG_MAX_VALUE)
0682         frag_thr = MWIFIEX_FRAG_MAX_VALUE;
0683
0684     return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
0685                 HostCmd_ACT_GEN_SET, FRAG_THRESH_I,
0686                 &frag_thr, true);
0687 }
0688
0689 /*
0690  * This function sets the RTS threshold.
0691
0692  * The rts value must lie between MWIFIEX_RTS_MIN_VALUE
0693  * and MWIFIEX_RTS_MAX_VALUE.
0694  */
0695 static int
0696 mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)
0697 {
0698     if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)
0699         rts_thr = MWIFIEX_RTS_MAX_VALUE;
0700
0701     return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
0702                 HostCmd_ACT_GEN_SET, RTS_THRESH_I,
0703                 &rts_thr, true);
0704 }
0705
0706 /*
0707  * CFG802.11 operation handler to set wiphy parameters.
0708  *
0709  * This function can be used to set the RTS threshold and the
0710  * Fragmentation threshold of the driver.
0711  */
0712 static int
0713 mwifiex_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
0714 {
0715     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
0716     struct mwifiex_private *priv;
0717     struct mwifiex_uap_bss_param *bss_cfg;
0718     int ret;
0719
0720     priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
0721
0722     switch (priv->bss_role) {
0723     case MWIFIEX_BSS_ROLE_UAP:
0724         if (priv->bss_started) {
0725             mwifiex_dbg(adapter, ERROR,
0726                     "cannot change wiphy params when bss started");
0727             return -EINVAL;
0728         }
0729
0730         bss_cfg = kzalloc(sizeof(*bss_cfg), GFP_KERNEL);
0731         if (!bss_cfg)
0732             return -ENOMEM;
0733
0734         mwifiex_set_sys_config_invalid_data(bss_cfg);
0735
0736         if (changed & WIPHY_PARAM_RTS_THRESHOLD)
0737             bss_cfg->rts_threshold = wiphy->rts_threshold;
0738         if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
0739             bss_cfg->frag_threshold = wiphy->frag_threshold;
0740         if (changed & WIPHY_PARAM_RETRY_LONG)
0741             bss_cfg->retry_limit = wiphy->retry_long;
0742
0743         ret = mwifiex_send_cmd(priv, HostCmd_CMD_UAP_SYS_CONFIG,
0744                        HostCmd_ACT_GEN_SET,
0745                        UAP_BSS_PARAMS_I, bss_cfg,
0746                        false);
0747
0748         kfree(bss_cfg);
0749         if (ret) {
0750             mwifiex_dbg(adapter, ERROR,
0751                     "Failed to set wiphy phy params\n");
0752             return ret;
0753         }
0754         break;
0755
0756     case MWIFIEX_BSS_ROLE_STA:
0757         if (priv->media_connected) {
0758             mwifiex_dbg(adapter, ERROR,
0759                     "cannot change wiphy params when connected");
0760             return -EINVAL;
0761         }
0762         if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
0763             ret = mwifiex_set_rts(priv,
0764                           wiphy->rts_threshold);
0765             if (ret)
0766                 return ret;
0767         }
0768         if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
0769             ret = mwifiex_set_frag(priv,
0770                            wiphy->frag_threshold);
0771             if (ret)
0772                 return ret;
0773         }
0774         break;
0775     }
0776
0777     return 0;
0778 }
0779
0780 static int
0781 mwifiex_cfg80211_deinit_p2p(struct mwifiex_private *priv)
0782 {
0783     u16 mode = P2P_MODE_DISABLE;
0784
0785     if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
0786                  HostCmd_ACT_GEN_SET, 0, &mode, true))
0787         return -1;
0788
0789     return 0;
0790 }
0791
0792 /*
0793  * This function initializes the functionalities for P2P client.
0794  * The P2P client initialization sequence is:
0795  * disable -> device -> client
0796  */
0797 static int
0798 mwifiex_cfg80211_init_p2p_client(struct mwifiex_private *priv)
0799 {
0800     u16 mode;
0801
0802     if (mwifiex_cfg80211_deinit_p2p(priv))
0803         return -1;
0804
0805     mode = P2P_MODE_DEVICE;
0806     if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
0807                  HostCmd_ACT_GEN_SET, 0, &mode, true))
0808         return -1;
0809
0810     mode = P2P_MODE_CLIENT;
0811     if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
0812                  HostCmd_ACT_GEN_SET, 0, &mode, true))
0813         return -1;
0814
0815     return 0;
0816 }
0817
0818 /*
0819  * This function initializes the functionalities for P2P GO.
0820  * The P2P GO initialization sequence is:
0821  * disable -> device -> GO
0822  */
0823 static int
0824 mwifiex_cfg80211_init_p2p_go(struct mwifiex_private *priv)
0825 {
0826     u16 mode;
0827
0828     if (mwifiex_cfg80211_deinit_p2p(priv))
0829         return -1;
0830
0831     mode = P2P_MODE_DEVICE;
0832     if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
0833                  HostCmd_ACT_GEN_SET, 0, &mode, true))
0834         return -1;
0835
0836     mode = P2P_MODE_GO;
0837     if (mwifiex_send_cmd(priv, HostCmd_CMD_P2P_MODE_CFG,
0838                  HostCmd_ACT_GEN_SET, 0, &mode, true))
0839         return -1;
0840
0841     return 0;
0842 }
0843
0844 static int mwifiex_deinit_priv_params(struct mwifiex_private *priv)
0845 {
0846     struct mwifiex_adapter *adapter = priv->adapter;
0847     unsigned long flags;
0848
0849     priv->mgmt_frame_mask = 0;
0850     if (mwifiex_send_cmd(priv, HostCmd_CMD_MGMT_FRAME_REG,
0851                  HostCmd_ACT_GEN_SET, 0,
0852                  &priv->mgmt_frame_mask, false)) {
0853         mwifiex_dbg(adapter, ERROR,
0854                 "could not unregister mgmt frame rx\n");
0855         return -1;
0856     }
0857
0858     mwifiex_deauthenticate(priv, NULL);
0859
0860     spin_lock_irqsave(&adapter->main_proc_lock, flags);
0861     adapter->main_locked = true;
0862     if (adapter->mwifiex_processing) {
0863         spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
0864         flush_workqueue(adapter->workqueue);
0865     } else {
0866         spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
0867     }
0868
0869     spin_lock_bh(&adapter->rx_proc_lock);
0870     adapter->rx_locked = true;
0871     if (adapter->rx_processing) {
0872         spin_unlock_bh(&adapter->rx_proc_lock);
0873         flush_workqueue(adapter->rx_workqueue);
0874     } else {
0875     spin_unlock_bh(&adapter->rx_proc_lock);
0876     }
0877
0878     mwifiex_free_priv(priv);
0879     priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
0880     priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
0881     priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;
0882
0883     return 0;
0884 }
0885
0886 static int
0887 mwifiex_init_new_priv_params(struct mwifiex_private *priv,
0888                  struct net_device *dev,
0889                  enum nl80211_iftype type)
0890 {
0891     struct mwifiex_adapter *adapter = priv->adapter;
0892     unsigned long flags;
0893
0894     mwifiex_init_priv(priv);
0895
0896     priv->bss_mode = type;
0897     priv->wdev.iftype = type;
0898
0899     mwifiex_init_priv_params(priv, priv->netdev);
0900     priv->bss_started = 0;
0901
0902     switch (type) {
0903     case NL80211_IFTYPE_STATION:
0904     case NL80211_IFTYPE_ADHOC:
0905         priv->bss_role = MWIFIEX_BSS_ROLE_STA;
0906         priv->bss_type = MWIFIEX_BSS_TYPE_STA;
0907         break;
0908     case NL80211_IFTYPE_P2P_CLIENT:
0909         priv->bss_role = MWIFIEX_BSS_ROLE_STA;
0910         priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
0911         break;
0912     case NL80211_IFTYPE_P2P_GO:
0913         priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
0914         priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
0915         break;
0916     case NL80211_IFTYPE_AP:
0917         priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
0918         priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
0919         break;
0920     default:
0921         mwifiex_dbg(adapter, ERROR,
0922                 "%s: changing to %d not supported\n",
0923                 dev->name, type);
0924         return -EOPNOTSUPP;
0925     }
0926
0927     spin_lock_irqsave(&adapter->main_proc_lock, flags);
0928     adapter->main_locked = false;
0929     spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
0930
0931     spin_lock_bh(&adapter->rx_proc_lock);
0932     adapter->rx_locked = false;
0933     spin_unlock_bh(&adapter->rx_proc_lock);
0934
0935     mwifiex_set_mac_address(priv, dev, false, NULL);
0936
0937     return 0;
0938 }
0939
0940 static bool
0941 is_vif_type_change_allowed(struct mwifiex_adapter *adapter,
0942                enum nl80211_iftype old_iftype,
0943                enum nl80211_iftype new_iftype)
0944 {
0945     switch (old_iftype) {
0946     case NL80211_IFTYPE_ADHOC:
0947         switch (new_iftype) {
0948         case NL80211_IFTYPE_STATION:
0949             return true;
0950         case NL80211_IFTYPE_P2P_CLIENT:
0951         case NL80211_IFTYPE_P2P_GO:
0952             return adapter->curr_iface_comb.p2p_intf !=
0953                    adapter->iface_limit.p2p_intf;
0954         case NL80211_IFTYPE_AP:
0955             return adapter->curr_iface_comb.uap_intf !=
0956                    adapter->iface_limit.uap_intf;
0957         default:
0958             return false;
0959         }
0960
0961     case NL80211_IFTYPE_STATION:
0962         switch (new_iftype) {
0963         case NL80211_IFTYPE_ADHOC:
0964             return true;
0965         case NL80211_IFTYPE_P2P_CLIENT:
0966         case NL80211_IFTYPE_P2P_GO:
0967             return adapter->curr_iface_comb.p2p_intf !=
0968                    adapter->iface_limit.p2p_intf;
0969         case NL80211_IFTYPE_AP:
0970             return adapter->curr_iface_comb.uap_intf !=
0971                    adapter->iface_limit.uap_intf;
0972         default:
0973             return false;
0974         }
0975
0976     case NL80211_IFTYPE_AP:
0977         switch (new_iftype) {
0978         case NL80211_IFTYPE_ADHOC:
0979         case NL80211_IFTYPE_STATION:
0980             return adapter->curr_iface_comb.sta_intf !=
0981                    adapter->iface_limit.sta_intf;
0982         case NL80211_IFTYPE_P2P_CLIENT:
0983         case NL80211_IFTYPE_P2P_GO:
0984             return adapter->curr_iface_comb.p2p_intf !=
0985                    adapter->iface_limit.p2p_intf;
0986         default:
0987             return false;
0988         }
0989
0990     case NL80211_IFTYPE_P2P_CLIENT:
0991         switch (new_iftype) {
0992         case NL80211_IFTYPE_ADHOC:
0993         case NL80211_IFTYPE_STATION:
0994             return true;
0995         case NL80211_IFTYPE_P2P_GO:
0996             return true;
0997         case NL80211_IFTYPE_AP:
0998             return adapter->curr_iface_comb.uap_intf !=
0999                    adapter->iface_limit.uap_intf;
1000         default:
1001             return false;
1002         }
1003
1004     case NL80211_IFTYPE_P2P_GO:
1005         switch (new_iftype) {
1006         case NL80211_IFTYPE_ADHOC:
1007         case NL80211_IFTYPE_STATION:
1008             return true;
1009         case NL80211_IFTYPE_P2P_CLIENT:
1010             return true;
1011         case NL80211_IFTYPE_AP:
1012             return adapter->curr_iface_comb.uap_intf !=
1013                    adapter->iface_limit.uap_intf;
1014         default:
1015             return false;
1016         }
1017
1018     default:
1019         break;
1020     }
1021
1022     return false;
1023 }
1024
1025 static void
1026 update_vif_type_counter(struct mwifiex_adapter *adapter,
1027             enum nl80211_iftype iftype,
1028             int change)
1029 {
1030     switch (iftype) {
1031     case NL80211_IFTYPE_UNSPECIFIED:
1032     case NL80211_IFTYPE_ADHOC:
1033     case NL80211_IFTYPE_STATION:
1034         adapter->curr_iface_comb.sta_intf += change;
1035         break;
1036     case NL80211_IFTYPE_AP:
1037         adapter->curr_iface_comb.uap_intf += change;
1038         break;
1039     case NL80211_IFTYPE_P2P_CLIENT:
1040     case NL80211_IFTYPE_P2P_GO:
1041         adapter->curr_iface_comb.p2p_intf += change;
1042         break;
1043     default:
1044         mwifiex_dbg(adapter, ERROR,
1045                 "%s: Unsupported iftype passed: %d\n",
1046                 __func__, iftype);
1047         break;
1048     }
1049 }
1050
1051 static int
1052 mwifiex_change_vif_to_p2p(struct net_device *dev,
1053               enum nl80211_iftype curr_iftype,
1054               enum nl80211_iftype type,
1055               struct vif_params *params)
1056 {
1057     struct mwifiex_private *priv;
1058     struct mwifiex_adapter *adapter;
1059
1060     priv = mwifiex_netdev_get_priv(dev);
1061
1062     if (!priv)
1063         return -1;
1064
1065     adapter = priv->adapter;
1066
1067     mwifiex_dbg(adapter, INFO,
1068             "%s: changing role to p2p\n", dev->name);
1069
1070     if (mwifiex_deinit_priv_params(priv))
1071         return -1;
1072     if (mwifiex_init_new_priv_params(priv, dev, type))
1073         return -1;
1074
1075     update_vif_type_counter(adapter, curr_iftype, -1);
1076     update_vif_type_counter(adapter, type, +1);
1077     dev->ieee80211_ptr->iftype = type;
1078
1079     switch (type) {
1080     case NL80211_IFTYPE_P2P_CLIENT:
1081         if (mwifiex_cfg80211_init_p2p_client(priv))
1082             return -EFAULT;
1083         break;
1084     case NL80211_IFTYPE_P2P_GO:
1085         if (mwifiex_cfg80211_init_p2p_go(priv))
1086             return -EFAULT;
1087         break;
1088     default:
1089         mwifiex_dbg(adapter, ERROR,
1090                 "%s: changing to %d not supported\n",
1091                 dev->name, type);
1092         return -EOPNOTSUPP;
1093     }
1094
1095     if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1096                  HostCmd_ACT_GEN_SET, 0, NULL, true))
1097         return -1;
1098
1099     if (mwifiex_sta_init_cmd(priv, false, false))
1100         return -1;
1101
1102     return 0;
1103 }
1104
1105 static int
1106 mwifiex_change_vif_to_sta_adhoc(struct net_device *dev,
1107                 enum nl80211_iftype curr_iftype,
1108                 enum nl80211_iftype type,
1109                 struct vif_params *params)
1110 {
1111     struct mwifiex_private *priv;
1112     struct mwifiex_adapter *adapter;
1113
1114     priv = mwifiex_netdev_get_priv(dev);
1115
1116     if (!priv)
1117         return -1;
1118
1119     adapter = priv->adapter;
1120
1121     if (type == NL80211_IFTYPE_STATION)
1122         mwifiex_dbg(adapter, INFO,
1123                 "%s: changing role to station\n", dev->name);
1124     else
1125         mwifiex_dbg(adapter, INFO,
1126                 "%s: changing role to adhoc\n", dev->name);
1127
1128     if (mwifiex_deinit_priv_params(priv))
1129         return -1;
1130     if (mwifiex_init_new_priv_params(priv, dev, type))
1131         return -1;
1132
1133     update_vif_type_counter(adapter, curr_iftype, -1);
1134     update_vif_type_counter(adapter, type, +1);
1135     dev->ieee80211_ptr->iftype = type;
1136
1137     if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1138                  HostCmd_ACT_GEN_SET, 0, NULL, true))
1139         return -1;
1140     if (mwifiex_sta_init_cmd(priv, false, false))
1141         return -1;
1142
1143     return 0;
1144 }
1145
1146 static int
1147 mwifiex_change_vif_to_ap(struct net_device *dev,
1148              enum nl80211_iftype curr_iftype,
1149              enum nl80211_iftype type,
1150              struct vif_params *params)
1151 {
1152     struct mwifiex_private *priv;
1153     struct mwifiex_adapter *adapter;
1154
1155     priv = mwifiex_netdev_get_priv(dev);
1156
1157     if (!priv)
1158         return -1;
1159
1160     adapter = priv->adapter;
1161
1162     mwifiex_dbg(adapter, INFO,
1163             "%s: changing role to AP\n", dev->name);
1164
1165     if (mwifiex_deinit_priv_params(priv))
1166         return -1;
1167     if (mwifiex_init_new_priv_params(priv, dev, type))
1168         return -1;
1169
1170     update_vif_type_counter(adapter, curr_iftype, -1);
1171     update_vif_type_counter(adapter, type, +1);
1172     dev->ieee80211_ptr->iftype = type;
1173
1174     if (mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1175                  HostCmd_ACT_GEN_SET, 0, NULL, true))
1176         return -1;
1177     if (mwifiex_sta_init_cmd(priv, false, false))
1178         return -1;
1179
1180     return 0;
1181 }
1182 /*
1183  * CFG802.11 operation handler to change interface type.
1184  */
1185 static int
1186 mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy,
1187                      struct net_device *dev,
1188                      enum nl80211_iftype type,
1189                      struct vif_params *params)
1190 {
1191     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1192     enum nl80211_iftype curr_iftype = dev->ieee80211_ptr->iftype;
1193
1194     if (priv->scan_request) {
1195         mwifiex_dbg(priv->adapter, ERROR,
1196                 "change virtual interface: scan in process\n");
1197         return -EBUSY;
1198     }
1199
1200     if (type == NL80211_IFTYPE_UNSPECIFIED) {
1201         mwifiex_dbg(priv->adapter, INFO,
1202                 "%s: no new type specified, keeping old type %d\n",
1203                 dev->name, curr_iftype);
1204         return 0;
1205     }
1206
1207     if (curr_iftype == type) {
1208         mwifiex_dbg(priv->adapter, INFO,
1209                 "%s: interface already is of type %d\n",
1210                 dev->name, curr_iftype);
1211         return 0;
1212     }
1213
1214     if (!is_vif_type_change_allowed(priv->adapter, curr_iftype, type)) {
1215         mwifiex_dbg(priv->adapter, ERROR,
1216                 "%s: change from type %d to %d is not allowed\n",
1217                 dev->name, curr_iftype, type);
1218         return -EOPNOTSUPP;
1219     }
1220
1221     switch (curr_iftype) {
1222     case NL80211_IFTYPE_ADHOC:
1223         switch (type) {
1224         case NL80211_IFTYPE_STATION:
1225             priv->bss_mode = type;
1226             priv->sec_info.authentication_mode =
1227                            NL80211_AUTHTYPE_OPEN_SYSTEM;
1228             dev->ieee80211_ptr->iftype = type;
1229             mwifiex_deauthenticate(priv, NULL);
1230             return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1231                         HostCmd_ACT_GEN_SET, 0, NULL,
1232                         true);
1233         case NL80211_IFTYPE_P2P_CLIENT:
1234         case NL80211_IFTYPE_P2P_GO:
1235             return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1236                              type, params);
1237         case NL80211_IFTYPE_AP:
1238             return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1239                             params);
1240         default:
1241             goto errnotsupp;
1242         }
1243
1244     case NL80211_IFTYPE_STATION:
1245         switch (type) {
1246         case NL80211_IFTYPE_ADHOC:
1247             priv->bss_mode = type;
1248             priv->sec_info.authentication_mode =
1249                            NL80211_AUTHTYPE_OPEN_SYSTEM;
1250             dev->ieee80211_ptr->iftype = type;
1251             mwifiex_deauthenticate(priv, NULL);
1252             return mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
1253                         HostCmd_ACT_GEN_SET, 0, NULL,
1254                         true);
1255         case NL80211_IFTYPE_P2P_CLIENT:
1256         case NL80211_IFTYPE_P2P_GO:
1257             return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1258                              type, params);
1259         case NL80211_IFTYPE_AP:
1260             return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1261                             params);
1262         default:
1263             goto errnotsupp;
1264         }
1265
1266     case NL80211_IFTYPE_AP:
1267         switch (type) {
1268         case NL80211_IFTYPE_ADHOC:
1269         case NL80211_IFTYPE_STATION:
1270             return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
1271                                    type, params);
1272             break;
1273         case NL80211_IFTYPE_P2P_CLIENT:
1274         case NL80211_IFTYPE_P2P_GO:
1275             return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1276                              type, params);
1277         default:
1278             goto errnotsupp;
1279         }
1280
1281     case NL80211_IFTYPE_P2P_CLIENT:
1282         if (mwifiex_cfg80211_deinit_p2p(priv))
1283             return -EFAULT;
1284
1285         switch (type) {
1286         case NL80211_IFTYPE_ADHOC:
1287         case NL80211_IFTYPE_STATION:
1288             return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
1289                                    type, params);
1290         case NL80211_IFTYPE_P2P_GO:
1291             return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1292                              type, params);
1293         case NL80211_IFTYPE_AP:
1294             return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1295                             params);
1296         default:
1297             goto errnotsupp;
1298         }
1299
1300     case NL80211_IFTYPE_P2P_GO:
1301         if (mwifiex_cfg80211_deinit_p2p(priv))
1302             return -EFAULT;
1303
1304         switch (type) {
1305         case NL80211_IFTYPE_ADHOC:
1306         case NL80211_IFTYPE_STATION:
1307             return mwifiex_change_vif_to_sta_adhoc(dev, curr_iftype,
1308                                    type, params);
1309         case NL80211_IFTYPE_P2P_CLIENT:
1310             return mwifiex_change_vif_to_p2p(dev, curr_iftype,
1311                              type, params);
1312         case NL80211_IFTYPE_AP:
1313             return mwifiex_change_vif_to_ap(dev, curr_iftype, type,
1314                             params);
1315         default:
1316             goto errnotsupp;
1317         }
1318
1319     default:
1320         goto errnotsupp;
1321     }
1322
1323
1324     return 0;
1325
1326 errnotsupp:
1327     mwifiex_dbg(priv->adapter, ERROR,
1328             "unsupported interface type transition: %d to %d\n",
1329             curr_iftype, type);
1330     return -EOPNOTSUPP;
1331 }
1332
1333 static void
1334 mwifiex_parse_htinfo(struct mwifiex_private *priv, u8 rateinfo, u8 htinfo,
1335              struct rate_info *rate)
1336 {
1337     struct mwifiex_adapter *adapter = priv->adapter;
1338
1339     if (adapter->is_hw_11ac_capable) {
1340         /* bit[1-0]: 00=LG 01=HT 10=VHT */
1341         if (htinfo & BIT(0)) {
1342             /* HT */
1343             rate->mcs = rateinfo;
1344             rate->flags |= RATE_INFO_FLAGS_MCS;
1345         }
1346         if (htinfo & BIT(1)) {
1347             /* VHT */
1348             rate->mcs = rateinfo & 0x0F;
1349             rate->flags |= RATE_INFO_FLAGS_VHT_MCS;
1350         }
1351
1352         if (htinfo & (BIT(1) | BIT(0))) {
1353             /* HT or VHT */
1354             switch (htinfo & (BIT(3) | BIT(2))) {
1355             case 0:
1356                 rate->bw = RATE_INFO_BW_20;
1357                 break;
1358             case (BIT(2)):
1359                 rate->bw = RATE_INFO_BW_40;
1360                 break;
1361             case (BIT(3)):
1362                 rate->bw = RATE_INFO_BW_80;
1363                 break;
1364             case (BIT(3) | BIT(2)):
1365                 rate->bw = RATE_INFO_BW_160;
1366                 break;
1367             }
1368
1369             if (htinfo & BIT(4))
1370                 rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
1371
1372             if ((rateinfo >> 4) == 1)
1373                 rate->nss = 2;
1374             else
1375                 rate->nss = 1;
1376         }
1377     } else {
1378         /*
1379          * Bit 0 in htinfo indicates that current rate is 11n. Valid
1380          * MCS index values for us are 0 to 15.
1381          */
1382         if ((htinfo & BIT(0)) && (rateinfo < 16)) {
1383             rate->mcs = rateinfo;
1384             rate->flags |= RATE_INFO_FLAGS_MCS;
1385             rate->bw = RATE_INFO_BW_20;
1386             if (htinfo & BIT(1))
1387                 rate->bw = RATE_INFO_BW_40;
1388             if (htinfo & BIT(2))
1389                 rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
1390         }
1391     }
1392
1393     /* Decode legacy rates for non-HT. */
1394     if (!(htinfo & (BIT(0) | BIT(1)))) {
1395         /* Bitrates in multiples of 100kb/s. */
1396         static const int legacy_rates[] = {
1397             [0] = 10,
1398             [1] = 20,
1399             [2] = 55,
1400             [3] = 110,
1401             [4] = 60, /* MWIFIEX_RATE_INDEX_OFDM0 */
1402             [5] = 60,
1403             [6] = 90,
1404             [7] = 120,
1405             [8] = 180,
1406             [9] = 240,
1407             [10] = 360,
1408             [11] = 480,
1409             [12] = 540,
1410         };
1411         if (rateinfo < ARRAY_SIZE(legacy_rates))
1412             rate->legacy = legacy_rates[rateinfo];
1413     }
1414 }
1415
1416 /*
1417  * This function dumps the station information on a buffer.
1418  *
1419  * The following information are shown -
1420  *      - Total bytes transmitted
1421  *      - Total bytes received
1422  *      - Total packets transmitted
1423  *      - Total packets received
1424  *      - Signal quality level
1425  *      - Transmission rate
1426  */
1427 static int
1428 mwifiex_dump_station_info(struct mwifiex_private *priv,
1429               struct mwifiex_sta_node *node,
1430               struct station_info *sinfo)
1431 {
1432     u32 rate;
1433
1434     sinfo->filled = BIT_ULL(NL80211_STA_INFO_RX_BYTES) | BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
1435             BIT_ULL(NL80211_STA_INFO_RX_PACKETS) | BIT_ULL(NL80211_STA_INFO_TX_PACKETS) |
1436             BIT_ULL(NL80211_STA_INFO_TX_BITRATE) |
1437             BIT_ULL(NL80211_STA_INFO_SIGNAL) | BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
1438
1439     if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1440         if (!node)
1441             return -ENOENT;
1442
1443         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME) |
1444                 BIT_ULL(NL80211_STA_INFO_TX_FAILED);
1445         sinfo->inactive_time =
1446             jiffies_to_msecs(jiffies - node->stats.last_rx);
1447
1448         sinfo->signal = node->stats.rssi;
1449         sinfo->signal_avg = node->stats.rssi;
1450         sinfo->rx_bytes = node->stats.rx_bytes;
1451         sinfo->tx_bytes = node->stats.tx_bytes;
1452         sinfo->rx_packets = node->stats.rx_packets;
1453         sinfo->tx_packets = node->stats.tx_packets;
1454         sinfo->tx_failed = node->stats.tx_failed;
1455
1456         mwifiex_parse_htinfo(priv, priv->tx_rate,
1457                      node->stats.last_tx_htinfo,
1458                      &sinfo->txrate);
1459         sinfo->txrate.legacy = node->stats.last_tx_rate * 5;
1460
1461         return 0;
1462     }
1463
1464     /* Get signal information from the firmware */
1465     if (mwifiex_send_cmd(priv, HostCmd_CMD_RSSI_INFO,
1466                  HostCmd_ACT_GEN_GET, 0, NULL, true)) {
1467         mwifiex_dbg(priv->adapter, ERROR,
1468                 "failed to get signal information\n");
1469         return -EFAULT;
1470     }
1471
1472     if (mwifiex_drv_get_data_rate(priv, &rate)) {
1473         mwifiex_dbg(priv->adapter, ERROR,
1474                 "getting data rate error\n");
1475         return -EFAULT;
1476     }
1477
1478     /* Get DTIM period information from firmware */
1479     mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
1480              HostCmd_ACT_GEN_GET, DTIM_PERIOD_I,
1481              &priv->dtim_period, true);
1482
1483     mwifiex_parse_htinfo(priv, priv->tx_rate, priv->tx_htinfo,
1484                  &sinfo->txrate);
1485
1486     sinfo->signal_avg = priv->bcn_rssi_avg;
1487     sinfo->rx_bytes = priv->stats.rx_bytes;
1488     sinfo->tx_bytes = priv->stats.tx_bytes;
1489     sinfo->rx_packets = priv->stats.rx_packets;
1490     sinfo->tx_packets = priv->stats.tx_packets;
1491     sinfo->signal = priv->bcn_rssi_avg;
1492     /* bit rate is in 500 kb/s units. Convert it to 100kb/s units */
1493     sinfo->txrate.legacy = rate * 5;
1494
1495     sinfo->filled |= BIT(NL80211_STA_INFO_RX_BITRATE);
1496     mwifiex_parse_htinfo(priv, priv->rxpd_rate, priv->rxpd_htinfo,
1497                  &sinfo->rxrate);
1498
1499     if (priv->bss_mode == NL80211_IFTYPE_STATION) {
1500         sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BSS_PARAM);
1501         sinfo->bss_param.flags = 0;
1502         if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
1503                         WLAN_CAPABILITY_SHORT_PREAMBLE)
1504             sinfo->bss_param.flags |=
1505                     BSS_PARAM_FLAGS_SHORT_PREAMBLE;
1506         if (priv->curr_bss_params.bss_descriptor.cap_info_bitmap &
1507                         WLAN_CAPABILITY_SHORT_SLOT_TIME)
1508             sinfo->bss_param.flags |=
1509                     BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
1510         sinfo->bss_param.dtim_period = priv->dtim_period;
1511         sinfo->bss_param.beacon_interval =
1512             priv->curr_bss_params.bss_descriptor.beacon_period;
1513     }
1514
1515     return 0;
1516 }
1517
1518 /*
1519  * CFG802.11 operation handler to get station information.
1520  *
1521  * This function only works in connected mode, and dumps the
1522  * requested station information, if available.
1523  */
1524 static int
1525 mwifiex_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1526                  const u8 *mac, struct station_info *sinfo)
1527 {
1528     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1529
1530     if (!priv->media_connected)
1531         return -ENOENT;
1532     if (memcmp(mac, priv->cfg_bssid, ETH_ALEN))
1533         return -ENOENT;
1534
1535     return mwifiex_dump_station_info(priv, NULL, sinfo);
1536 }
1537
1538 /*
1539  * CFG802.11 operation handler to dump station information.
1540  */
1541 static int
1542 mwifiex_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
1543                   int idx, u8 *mac, struct station_info *sinfo)
1544 {
1545     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1546     struct mwifiex_sta_node *node;
1547     int i;
1548
1549     if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
1550         priv->media_connected && idx == 0) {
1551         ether_addr_copy(mac, priv->cfg_bssid);
1552         return mwifiex_dump_station_info(priv, NULL, sinfo);
1553     } else if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
1554         mwifiex_send_cmd(priv, HOST_CMD_APCMD_STA_LIST,
1555                  HostCmd_ACT_GEN_GET, 0, NULL, true);
1556
1557         i = 0;
1558         list_for_each_entry(node, &priv->sta_list, list) {
1559             if (i++ != idx)
1560                 continue;
1561             ether_addr_copy(mac, node->mac_addr);
1562             return mwifiex_dump_station_info(priv, node, sinfo);
1563         }
1564     }
1565
1566     return -ENOENT;
1567 }
1568
1569 static int
1570 mwifiex_cfg80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
1571                  int idx, struct survey_info *survey)
1572 {
1573     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1574     struct mwifiex_chan_stats *pchan_stats = priv->adapter->chan_stats;
1575     enum nl80211_band band;
1576
1577     mwifiex_dbg(priv->adapter, DUMP, "dump_survey idx=%d\n", idx);
1578
1579     memset(survey, 0, sizeof(struct survey_info));
1580
1581     if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
1582         priv->media_connected && idx == 0) {
1583             u8 curr_bss_band = priv->curr_bss_params.band;
1584             u32 chan = priv->curr_bss_params.bss_descriptor.channel;
1585
1586             band = mwifiex_band_to_radio_type(curr_bss_band);
1587             survey->channel = ieee80211_get_channel(wiphy,
1588                 ieee80211_channel_to_frequency(chan, band));
1589
1590             if (priv->bcn_nf_last) {
1591                 survey->filled = SURVEY_INFO_NOISE_DBM;
1592                 survey->noise = priv->bcn_nf_last;
1593             }
1594             return 0;
1595     }
1596
1597     if (idx >= priv->adapter->num_in_chan_stats)
1598         return -ENOENT;
1599
1600     if (!pchan_stats[idx].cca_scan_dur)
1601         return 0;
1602
1603     band = pchan_stats[idx].bandcfg;
1604     survey->channel = ieee80211_get_channel(wiphy,
1605         ieee80211_channel_to_frequency(pchan_stats[idx].chan_num, band));
1606     survey->filled = SURVEY_INFO_NOISE_DBM |
1607              SURVEY_INFO_TIME |
1608              SURVEY_INFO_TIME_BUSY;
1609     survey->noise = pchan_stats[idx].noise;
1610     survey->time = pchan_stats[idx].cca_scan_dur;
1611     survey->time_busy = pchan_stats[idx].cca_busy_dur;
1612
1613     return 0;
1614 }
1615
1616 /* Supported rates to be advertised to the cfg80211 */
1617 static struct ieee80211_rate mwifiex_rates[] = {
1618     {.bitrate = 10, .hw_value = 2, },
1619     {.bitrate = 20, .hw_value = 4, },
1620     {.bitrate = 55, .hw_value = 11, },
1621     {.bitrate = 110, .hw_value = 22, },
1622     {.bitrate = 60, .hw_value = 12, },
1623     {.bitrate = 90, .hw_value = 18, },
1624     {.bitrate = 120, .hw_value = 24, },
1625     {.bitrate = 180, .hw_value = 36, },
1626     {.bitrate = 240, .hw_value = 48, },
1627     {.bitrate = 360, .hw_value = 72, },
1628     {.bitrate = 480, .hw_value = 96, },
1629     {.bitrate = 540, .hw_value = 108, },
1630 };
1631
1632 /* Channel definitions to be advertised to cfg80211 */
1633 static struct ieee80211_channel mwifiex_channels_2ghz[] = {
1634     {.center_freq = 2412, .hw_value = 1, },
1635     {.center_freq = 2417, .hw_value = 2, },
1636     {.center_freq = 2422, .hw_value = 3, },
1637     {.center_freq = 2427, .hw_value = 4, },
1638     {.center_freq = 2432, .hw_value = 5, },
1639     {.center_freq = 2437, .hw_value = 6, },
1640     {.center_freq = 2442, .hw_value = 7, },
1641     {.center_freq = 2447, .hw_value = 8, },
1642     {.center_freq = 2452, .hw_value = 9, },
1643     {.center_freq = 2457, .hw_value = 10, },
1644     {.center_freq = 2462, .hw_value = 11, },
1645     {.center_freq = 2467, .hw_value = 12, },
1646     {.center_freq = 2472, .hw_value = 13, },
1647     {.center_freq = 2484, .hw_value = 14, },
1648 };
1649
1650 static struct ieee80211_supported_band mwifiex_band_2ghz = {
1651     .channels = mwifiex_channels_2ghz,
1652     .n_channels = ARRAY_SIZE(mwifiex_channels_2ghz),
1653     .bitrates = mwifiex_rates,
1654     .n_bitrates = ARRAY_SIZE(mwifiex_rates),
1655 };
1656
1657 static struct ieee80211_channel mwifiex_channels_5ghz[] = {
1658     {.center_freq = 5040, .hw_value = 8, },
1659     {.center_freq = 5060, .hw_value = 12, },
1660     {.center_freq = 5080, .hw_value = 16, },
1661     {.center_freq = 5170, .hw_value = 34, },
1662     {.center_freq = 5190, .hw_value = 38, },
1663     {.center_freq = 5210, .hw_value = 42, },
1664     {.center_freq = 5230, .hw_value = 46, },
1665     {.center_freq = 5180, .hw_value = 36, },
1666     {.center_freq = 5200, .hw_value = 40, },
1667     {.center_freq = 5220, .hw_value = 44, },
1668     {.center_freq = 5240, .hw_value = 48, },
1669     {.center_freq = 5260, .hw_value = 52, },
1670     {.center_freq = 5280, .hw_value = 56, },
1671     {.center_freq = 5300, .hw_value = 60, },
1672     {.center_freq = 5320, .hw_value = 64, },
1673     {.center_freq = 5500, .hw_value = 100, },
1674     {.center_freq = 5520, .hw_value = 104, },
1675     {.center_freq = 5540, .hw_value = 108, },
1676     {.center_freq = 5560, .hw_value = 112, },
1677     {.center_freq = 5580, .hw_value = 116, },
1678     {.center_freq = 5600, .hw_value = 120, },
1679     {.center_freq = 5620, .hw_value = 124, },
1680     {.center_freq = 5640, .hw_value = 128, },
1681     {.center_freq = 5660, .hw_value = 132, },
1682     {.center_freq = 5680, .hw_value = 136, },
1683     {.center_freq = 5700, .hw_value = 140, },
1684     {.center_freq = 5745, .hw_value = 149, },
1685     {.center_freq = 5765, .hw_value = 153, },
1686     {.center_freq = 5785, .hw_value = 157, },
1687     {.center_freq = 5805, .hw_value = 161, },
1688     {.center_freq = 5825, .hw_value = 165, },
1689 };
1690
1691 static struct ieee80211_supported_band mwifiex_band_5ghz = {
1692     .channels = mwifiex_channels_5ghz,
1693     .n_channels = ARRAY_SIZE(mwifiex_channels_5ghz),
1694     .bitrates = mwifiex_rates + 4,
1695     .n_bitrates = ARRAY_SIZE(mwifiex_rates) - 4,
1696 };
1697
1698
1699 /* Supported crypto cipher suits to be advertised to cfg80211 */
1700 static const u32 mwifiex_cipher_suites[] = {
1701     WLAN_CIPHER_SUITE_WEP40,
1702     WLAN_CIPHER_SUITE_WEP104,
1703     WLAN_CIPHER_SUITE_TKIP,
1704     WLAN_CIPHER_SUITE_CCMP,
1705     WLAN_CIPHER_SUITE_SMS4,
1706     WLAN_CIPHER_SUITE_AES_CMAC,
1707 };
1708
1709 /* Supported mgmt frame types to be advertised to cfg80211 */
1710 static const struct ieee80211_txrx_stypes
1711 mwifiex_mgmt_stypes[NUM_NL80211_IFTYPES] = {
1712     [NL80211_IFTYPE_STATION] = {
1713         .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1714               BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1715         .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1716               BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1717     },
1718     [NL80211_IFTYPE_AP] = {
1719         .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1720               BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1721         .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1722               BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1723     },
1724     [NL80211_IFTYPE_P2P_CLIENT] = {
1725         .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1726               BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1727         .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1728               BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1729     },
1730     [NL80211_IFTYPE_P2P_GO] = {
1731         .tx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1732               BIT(IEEE80211_STYPE_PROBE_RESP >> 4),
1733         .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
1734               BIT(IEEE80211_STYPE_PROBE_REQ >> 4),
1735     },
1736 };
1737
1738 /*
1739  * CFG802.11 operation handler for setting bit rates.
1740  *
1741  * Function configures data rates to firmware using bitrate mask
1742  * provided by cfg80211.
1743  */
1744 static int
1745 mwifiex_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
1746                   struct net_device *dev,
1747                   unsigned int link_id,
1748                   const u8 *peer,
1749                   const struct cfg80211_bitrate_mask *mask)
1750 {
1751     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1752     u16 bitmap_rates[MAX_BITMAP_RATES_SIZE];
1753     enum nl80211_band band;
1754     struct mwifiex_adapter *adapter = priv->adapter;
1755
1756     if (!priv->media_connected) {
1757         mwifiex_dbg(adapter, ERROR,
1758                 "Can not set Tx data rate in disconnected state\n");
1759         return -EINVAL;
1760     }
1761
1762     band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
1763
1764     memset(bitmap_rates, 0, sizeof(bitmap_rates));
1765
1766     /* Fill HR/DSSS rates. */
1767     if (band == NL80211_BAND_2GHZ)
1768         bitmap_rates[0] = mask->control[band].legacy & 0x000f;
1769
1770     /* Fill OFDM rates */
1771     if (band == NL80211_BAND_2GHZ)
1772         bitmap_rates[1] = (mask->control[band].legacy & 0x0ff0) >> 4;
1773     else
1774         bitmap_rates[1] = mask->control[band].legacy;
1775
1776     /* Fill HT MCS rates */
1777     bitmap_rates[2] = mask->control[band].ht_mcs[0];
1778     if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1779         bitmap_rates[2] |= mask->control[band].ht_mcs[1] << 8;
1780
1781        /* Fill VHT MCS rates */
1782     if (adapter->fw_api_ver == MWIFIEX_FW_V15) {
1783         bitmap_rates[10] = mask->control[band].vht_mcs[0];
1784         if (adapter->hw_dev_mcs_support == HT_STREAM_2X2)
1785             bitmap_rates[11] = mask->control[band].vht_mcs[1];
1786     }
1787
1788     return mwifiex_send_cmd(priv, HostCmd_CMD_TX_RATE_CFG,
1789                 HostCmd_ACT_GEN_SET, 0, bitmap_rates, true);
1790 }
1791
1792 /*
1793  * CFG802.11 operation handler for connection quality monitoring.
1794  *
1795  * This function subscribes/unsubscribes HIGH_RSSI and LOW_RSSI
1796  * events to FW.
1797  */
1798 static int mwifiex_cfg80211_set_cqm_rssi_config(struct wiphy *wiphy,
1799                         struct net_device *dev,
1800                         s32 rssi_thold, u32 rssi_hyst)
1801 {
1802     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1803     struct mwifiex_ds_misc_subsc_evt subsc_evt;
1804
1805     priv->cqm_rssi_thold = rssi_thold;
1806     priv->cqm_rssi_hyst = rssi_hyst;
1807
1808     memset(&subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
1809     subsc_evt.events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
1810
1811     /* Subscribe/unsubscribe low and high rssi events */
1812     if (rssi_thold && rssi_hyst) {
1813         subsc_evt.action = HostCmd_ACT_BITWISE_SET;
1814         subsc_evt.bcn_l_rssi_cfg.abs_value = abs(rssi_thold);
1815         subsc_evt.bcn_h_rssi_cfg.abs_value = abs(rssi_thold);
1816         subsc_evt.bcn_l_rssi_cfg.evt_freq = 1;
1817         subsc_evt.bcn_h_rssi_cfg.evt_freq = 1;
1818         return mwifiex_send_cmd(priv,
1819                     HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1820                     0, 0, &subsc_evt, true);
1821     } else {
1822         subsc_evt.action = HostCmd_ACT_BITWISE_CLR;
1823         return mwifiex_send_cmd(priv,
1824                     HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
1825                     0, 0, &subsc_evt, true);
1826     }
1827
1828     return 0;
1829 }
1830
1831 /* cfg80211 operation handler for change_beacon.
1832  * Function retrieves and sets modified management IEs to FW.
1833  */
1834 static int mwifiex_cfg80211_change_beacon(struct wiphy *wiphy,
1835                       struct net_device *dev,
1836                       struct cfg80211_beacon_data *data)
1837 {
1838     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1839     struct mwifiex_adapter *adapter = priv->adapter;
1840
1841     mwifiex_cancel_scan(adapter);
1842
1843     if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP) {
1844         mwifiex_dbg(priv->adapter, ERROR,
1845                 "%s: bss_type mismatched\n", __func__);
1846         return -EINVAL;
1847     }
1848
1849     if (!priv->bss_started) {
1850         mwifiex_dbg(priv->adapter, ERROR,
1851                 "%s: bss not started\n", __func__);
1852         return -EINVAL;
1853     }
1854
1855     if (mwifiex_set_mgmt_ies(priv, data)) {
1856         mwifiex_dbg(priv->adapter, ERROR,
1857                 "%s: setting mgmt ies failed\n", __func__);
1858         return -EFAULT;
1859     }
1860
1861     return 0;
1862 }
1863
1864 /* cfg80211 operation handler for del_station.
1865  * Function deauthenticates station which value is provided in mac parameter.
1866  * If mac is NULL/broadcast, all stations in associated station list are
1867  * deauthenticated. If bss is not started or there are no stations in
1868  * associated stations list, no action is taken.
1869  */
1870 static int
1871 mwifiex_cfg80211_del_station(struct wiphy *wiphy, struct net_device *dev,
1872                  struct station_del_parameters *params)
1873 {
1874     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1875     struct mwifiex_sta_node *sta_node;
1876     u8 deauth_mac[ETH_ALEN];
1877
1878     if (!priv->bss_started && priv->wdev.cac_started) {
1879         mwifiex_dbg(priv->adapter, INFO, "%s: abort CAC!\n", __func__);
1880         mwifiex_abort_cac(priv);
1881     }
1882
1883     if (list_empty(&priv->sta_list) || !priv->bss_started)
1884         return 0;
1885
1886     if (!params->mac || is_broadcast_ether_addr(params->mac))
1887         return 0;
1888
1889     mwifiex_dbg(priv->adapter, INFO, "%s: mac address %pM\n",
1890             __func__, params->mac);
1891
1892     eth_zero_addr(deauth_mac);
1893
1894     spin_lock_bh(&priv->sta_list_spinlock);
1895     sta_node = mwifiex_get_sta_entry(priv, params->mac);
1896     if (sta_node)
1897         ether_addr_copy(deauth_mac, params->mac);
1898     spin_unlock_bh(&priv->sta_list_spinlock);
1899
1900     if (is_valid_ether_addr(deauth_mac)) {
1901         if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_STA_DEAUTH,
1902                      HostCmd_ACT_GEN_SET, 0,
1903                      deauth_mac, true))
1904             return -1;
1905     }
1906
1907     return 0;
1908 }
1909
1910 static int
1911 mwifiex_cfg80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
1912 {
1913     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1914     struct mwifiex_private *priv = mwifiex_get_priv(adapter,
1915                             MWIFIEX_BSS_ROLE_ANY);
1916     struct mwifiex_ds_ant_cfg ant_cfg;
1917
1918     if (!tx_ant || !rx_ant)
1919         return -EOPNOTSUPP;
1920
1921     if (adapter->hw_dev_mcs_support != HT_STREAM_2X2) {
1922         /* Not a MIMO chip. User should provide specific antenna number
1923          * for Tx/Rx path or enable all antennas for diversity
1924          */
1925         if (tx_ant != rx_ant)
1926             return -EOPNOTSUPP;
1927
1928         if ((tx_ant & (tx_ant - 1)) &&
1929             (tx_ant != BIT(adapter->number_of_antenna) - 1))
1930             return -EOPNOTSUPP;
1931
1932         if ((tx_ant == BIT(adapter->number_of_antenna) - 1) &&
1933             (priv->adapter->number_of_antenna > 1)) {
1934             tx_ant = RF_ANTENNA_AUTO;
1935             rx_ant = RF_ANTENNA_AUTO;
1936         }
1937     } else {
1938         struct ieee80211_sta_ht_cap *ht_info;
1939         int rx_mcs_supp;
1940         enum nl80211_band band;
1941
1942         if ((tx_ant == 0x1 && rx_ant == 0x1)) {
1943             adapter->user_dev_mcs_support = HT_STREAM_1X1;
1944             if (adapter->is_hw_11ac_capable)
1945                 adapter->usr_dot_11ac_mcs_support =
1946                         MWIFIEX_11AC_MCS_MAP_1X1;
1947         } else {
1948             adapter->user_dev_mcs_support = HT_STREAM_2X2;
1949             if (adapter->is_hw_11ac_capable)
1950                 adapter->usr_dot_11ac_mcs_support =
1951                         MWIFIEX_11AC_MCS_MAP_2X2;
1952         }
1953
1954         for (band = 0; band < NUM_NL80211_BANDS; band++) {
1955             if (!adapter->wiphy->bands[band])
1956                 continue;
1957
1958             ht_info = &adapter->wiphy->bands[band]->ht_cap;
1959             rx_mcs_supp =
1960                 GET_RXMCSSUPP(adapter->user_dev_mcs_support);
1961             memset(&ht_info->mcs, 0, adapter->number_of_antenna);
1962             memset(&ht_info->mcs, 0xff, rx_mcs_supp);
1963         }
1964     }
1965
1966     ant_cfg.tx_ant = tx_ant;
1967     ant_cfg.rx_ant = rx_ant;
1968
1969     return mwifiex_send_cmd(priv, HostCmd_CMD_RF_ANTENNA,
1970                 HostCmd_ACT_GEN_SET, 0, &ant_cfg, true);
1971 }
1972
1973 static int
1974 mwifiex_cfg80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
1975 {
1976     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
1977     struct mwifiex_private *priv = mwifiex_get_priv(adapter,
1978                             MWIFIEX_BSS_ROLE_ANY);
1979     mwifiex_send_cmd(priv, HostCmd_CMD_RF_ANTENNA,
1980              HostCmd_ACT_GEN_GET, 0, NULL, true);
1981
1982     *tx_ant = priv->tx_ant;
1983     *rx_ant = priv->rx_ant;
1984
1985     return 0;
1986 }
1987
1988 /* cfg80211 operation handler for stop ap.
1989  * Function stops BSS running at uAP interface.
1990  */
1991 static int mwifiex_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *dev,
1992                     unsigned int link_id)
1993 {
1994     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
1995
1996     mwifiex_abort_cac(priv);
1997
1998     if (mwifiex_del_mgmt_ies(priv))
1999         mwifiex_dbg(priv->adapter, ERROR,
2000                 "Failed to delete mgmt IEs!\n");
2001
2002     priv->ap_11n_enabled = 0;
2003     memset(&priv->bss_cfg, 0, sizeof(priv->bss_cfg));
2004
2005     if (mwifiex_send_cmd(priv, HostCmd_CMD_UAP_BSS_STOP,
2006                  HostCmd_ACT_GEN_SET, 0, NULL, true)) {
2007         mwifiex_dbg(priv->adapter, ERROR,
2008                 "Failed to stop the BSS\n");
2009         return -1;
2010     }
2011
2012     if (mwifiex_send_cmd(priv, HOST_CMD_APCMD_SYS_RESET,
2013                  HostCmd_ACT_GEN_SET, 0, NULL, true)) {
2014         mwifiex_dbg(priv->adapter, ERROR,
2015                 "Failed to reset BSS\n");
2016         return -1;
2017     }
2018
2019     if (netif_carrier_ok(priv->netdev))
2020         netif_carrier_off(priv->netdev);
2021     mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
2022
2023     return 0;
2024 }
2025
2026 /* cfg80211 operation handler for start_ap.
2027  * Function sets beacon period, DTIM period, SSID and security into
2028  * AP config structure.
2029  * AP is configured with these settings and BSS is started.
2030  */
2031 static int mwifiex_cfg80211_start_ap(struct wiphy *wiphy,
2032                      struct net_device *dev,
2033                      struct cfg80211_ap_settings *params)
2034 {
2035     struct mwifiex_uap_bss_param *bss_cfg;
2036     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2037
2038     if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_UAP)
2039         return -1;
2040
2041     bss_cfg = kzalloc(sizeof(struct mwifiex_uap_bss_param), GFP_KERNEL);
2042     if (!bss_cfg)
2043         return -ENOMEM;
2044
2045     mwifiex_set_sys_config_invalid_data(bss_cfg);
2046
2047     if (params->beacon_interval)
2048         bss_cfg->beacon_period = params->beacon_interval;
2049     if (params->dtim_period)
2050         bss_cfg->dtim_period = params->dtim_period;
2051
2052     if (params->ssid && params->ssid_len) {
2053         memcpy(bss_cfg->ssid.ssid, params->ssid, params->ssid_len);
2054         bss_cfg->ssid.ssid_len = params->ssid_len;
2055     }
2056     if (params->inactivity_timeout > 0) {
2057         /* sta_ao_timer/ps_sta_ao_timer is in unit of 100ms */
2058         bss_cfg->sta_ao_timer = 10 * params->inactivity_timeout;
2059         bss_cfg->ps_sta_ao_timer = 10 * params->inactivity_timeout;
2060     }
2061
2062     switch (params->hidden_ssid) {
2063     case NL80211_HIDDEN_SSID_NOT_IN_USE:
2064         bss_cfg->bcast_ssid_ctl = 1;
2065         break;
2066     case NL80211_HIDDEN_SSID_ZERO_LEN:
2067         bss_cfg->bcast_ssid_ctl = 0;
2068         break;
2069     case NL80211_HIDDEN_SSID_ZERO_CONTENTS:
2070         bss_cfg->bcast_ssid_ctl = 2;
2071         break;
2072     default:
2073         kfree(bss_cfg);
2074         return -EINVAL;
2075     }
2076
2077     mwifiex_uap_set_channel(priv, bss_cfg, params->chandef);
2078     mwifiex_set_uap_rates(bss_cfg, params);
2079
2080     if (mwifiex_set_secure_params(priv, bss_cfg, params)) {
2081         mwifiex_dbg(priv->adapter, ERROR,
2082                 "Failed to parse security parameters!\n");
2083         goto out;
2084     }
2085
2086     mwifiex_set_ht_params(priv, bss_cfg, params);
2087
2088     if (priv->adapter->is_hw_11ac_capable) {
2089         mwifiex_set_vht_params(priv, bss_cfg, params);
2090         mwifiex_set_vht_width(priv, params->chandef.width,
2091                       priv->ap_11ac_enabled);
2092     }
2093
2094     if (priv->ap_11ac_enabled)
2095         mwifiex_set_11ac_ba_params(priv);
2096     else
2097         mwifiex_set_ba_params(priv);
2098
2099     mwifiex_set_wmm_params(priv, bss_cfg, params);
2100
2101     if (mwifiex_is_11h_active(priv))
2102         mwifiex_set_tpc_params(priv, bss_cfg, params);
2103
2104     if (mwifiex_is_11h_active(priv) &&
2105         !cfg80211_chandef_dfs_required(wiphy, &params->chandef,
2106                        priv->bss_mode)) {
2107         mwifiex_dbg(priv->adapter, INFO,
2108                 "Disable 11h extensions in FW\n");
2109         if (mwifiex_11h_activate(priv, false)) {
2110             mwifiex_dbg(priv->adapter, ERROR,
2111                     "Failed to disable 11h extensions!!");
2112             goto out;
2113         }
2114         priv->state_11h.is_11h_active = false;
2115     }
2116
2117     mwifiex_config_uap_11d(priv, &params->beacon);
2118
2119     if (mwifiex_config_start_uap(priv, bss_cfg)) {
2120         mwifiex_dbg(priv->adapter, ERROR,
2121                 "Failed to start AP\n");
2122         goto out;
2123     }
2124
2125     if (mwifiex_set_mgmt_ies(priv, &params->beacon))
2126         goto out;
2127
2128     if (!netif_carrier_ok(priv->netdev))
2129         netif_carrier_on(priv->netdev);
2130     mwifiex_wake_up_net_dev_queue(priv->netdev, priv->adapter);
2131
2132     memcpy(&priv->bss_cfg, bss_cfg, sizeof(priv->bss_cfg));
2133     kfree(bss_cfg);
2134     return 0;
2135
2136 out:
2137     kfree(bss_cfg);
2138     return -1;
2139 }
2140
2141 /*
2142  * CFG802.11 operation handler for disconnection request.
2143  *
2144  * This function does not work when there is already a disconnection
2145  * procedure going on.
2146  */
2147 static int
2148 mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
2149                 u16 reason_code)
2150 {
2151     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2152
2153     if (!mwifiex_stop_bg_scan(priv))
2154         cfg80211_sched_scan_stopped_locked(priv->wdev.wiphy, 0);
2155
2156     if (mwifiex_deauthenticate(priv, NULL))
2157         return -EFAULT;
2158
2159     eth_zero_addr(priv->cfg_bssid);
2160     priv->hs2_enabled = false;
2161
2162     return 0;
2163 }
2164
2165 /*
2166  * This function informs the CFG802.11 subsystem of a new IBSS.
2167  *
2168  * The following information are sent to the CFG802.11 subsystem
2169  * to register the new IBSS. If we do not register the new IBSS,
2170  * a kernel panic will result.
2171  *      - SSID
2172  *      - SSID length
2173  *      - BSSID
2174  *      - Channel
2175  */
2176 static int mwifiex_cfg80211_inform_ibss_bss(struct mwifiex_private *priv)
2177 {
2178     struct ieee80211_channel *chan;
2179     struct mwifiex_bss_info bss_info;
2180     struct cfg80211_bss *bss;
2181     int ie_len;
2182     u8 ie_buf[IEEE80211_MAX_SSID_LEN + sizeof(struct ieee_types_header)];
2183     enum nl80211_band band;
2184
2185     if (mwifiex_get_bss_info(priv, &bss_info))
2186         return -1;
2187
2188     ie_buf[0] = WLAN_EID_SSID;
2189     ie_buf[1] = bss_info.ssid.ssid_len;
2190
2191     memcpy(&ie_buf[sizeof(struct ieee_types_header)],
2192            &bss_info.ssid.ssid, bss_info.ssid.ssid_len);
2193     ie_len = ie_buf[1] + sizeof(struct ieee_types_header);
2194
2195     band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
2196     chan = ieee80211_get_channel(priv->wdev.wiphy,
2197             ieee80211_channel_to_frequency(bss_info.bss_chan,
2198                                band));
2199
2200     bss = cfg80211_inform_bss(priv->wdev.wiphy, chan,
2201                   CFG80211_BSS_FTYPE_UNKNOWN,
2202                   bss_info.bssid, 0, WLAN_CAPABILITY_IBSS,
2203                   0, ie_buf, ie_len, 0, GFP_KERNEL);
2204     if (bss) {
2205         cfg80211_put_bss(priv->wdev.wiphy, bss);
2206         ether_addr_copy(priv->cfg_bssid, bss_info.bssid);
2207     }
2208
2209     return 0;
2210 }
2211
2212 /*
2213  * This function connects with a BSS.
2214  *
2215  * This function handles both Infra and Ad-Hoc modes. It also performs
2216  * validity checking on the provided parameters, disconnects from the
2217  * current BSS (if any), sets up the association/scan parameters,
2218  * including security settings, and performs specific SSID scan before
2219  * trying to connect.
2220  *
2221  * For Infra mode, the function returns failure if the specified SSID
2222  * is not found in scan table. However, for Ad-Hoc mode, it can create
2223  * the IBSS if it does not exist. On successful completion in either case,
2224  * the function notifies the CFG802.11 subsystem of the new BSS connection.
2225  */
2226 static int
2227 mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len,
2228                const u8 *ssid, const u8 *bssid, int mode,
2229                struct ieee80211_channel *channel,
2230                struct cfg80211_connect_params *sme, bool privacy,
2231                struct cfg80211_bss **sel_bss)
2232 {
2233     struct cfg80211_ssid req_ssid;
2234     int ret, auth_type = 0;
2235     struct cfg80211_bss *bss = NULL;
2236     u8 is_scanning_required = 0;
2237
2238     memset(&req_ssid, 0, sizeof(struct cfg80211_ssid));
2239
2240     req_ssid.ssid_len = ssid_len;
2241     if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2242         mwifiex_dbg(priv->adapter, ERROR, "invalid SSID - aborting\n");
2243         return -EINVAL;
2244     }
2245
2246     memcpy(req_ssid.ssid, ssid, ssid_len);
2247     if (!req_ssid.ssid_len || req_ssid.ssid[0] < 0x20) {
2248         mwifiex_dbg(priv->adapter, ERROR, "invalid SSID - aborting\n");
2249         return -EINVAL;
2250     }
2251
2252     /* As this is new association, clear locally stored
2253      * keys and security related flags */
2254     priv->sec_info.wpa_enabled = false;
2255     priv->sec_info.wpa2_enabled = false;
2256     priv->wep_key_curr_index = 0;
2257     priv->sec_info.encryption_mode = 0;
2258     priv->sec_info.is_authtype_auto = 0;
2259     ret = mwifiex_set_encode(priv, NULL, NULL, 0, 0, NULL, 1);
2260
2261     if (mode == NL80211_IFTYPE_ADHOC) {
2262         u16 enable = true;
2263
2264         /* set ibss coalescing_status */
2265         ret = mwifiex_send_cmd(
2266                 priv,
2267                 HostCmd_CMD_802_11_IBSS_COALESCING_STATUS,
2268                 HostCmd_ACT_GEN_SET, 0, &enable, true);
2269         if (ret)
2270             return ret;
2271
2272         /* "privacy" is set only for ad-hoc mode */
2273         if (privacy) {
2274             /*
2275              * Keep WLAN_CIPHER_SUITE_WEP104 for now so that
2276              * the firmware can find a matching network from the
2277              * scan. The cfg80211 does not give us the encryption
2278              * mode at this stage so just setting it to WEP here.
2279              */
2280             priv->sec_info.encryption_mode =
2281                     WLAN_CIPHER_SUITE_WEP104;
2282             priv->sec_info.authentication_mode =
2283                     NL80211_AUTHTYPE_OPEN_SYSTEM;
2284         }
2285
2286         goto done;
2287     }
2288
2289     /* Now handle infra mode. "sme" is valid for infra mode only */
2290     if (sme->auth_type == NL80211_AUTHTYPE_AUTOMATIC) {
2291         auth_type = NL80211_AUTHTYPE_OPEN_SYSTEM;
2292         priv->sec_info.is_authtype_auto = 1;
2293     } else {
2294         auth_type = sme->auth_type;
2295     }
2296
2297     if (sme->crypto.n_ciphers_pairwise) {
2298         priv->sec_info.encryption_mode =
2299                         sme->crypto.ciphers_pairwise[0];
2300         priv->sec_info.authentication_mode = auth_type;
2301     }
2302
2303     if (sme->crypto.cipher_group) {
2304         priv->sec_info.encryption_mode = sme->crypto.cipher_group;
2305         priv->sec_info.authentication_mode = auth_type;
2306     }
2307     if (sme->ie)
2308         ret = mwifiex_set_gen_ie(priv, sme->ie, sme->ie_len);
2309
2310     if (sme->key) {
2311         if (mwifiex_is_alg_wep(priv->sec_info.encryption_mode)) {
2312             mwifiex_dbg(priv->adapter, INFO,
2313                     "info: setting wep encryption\t"
2314                     "with key len %d\n", sme->key_len);
2315             priv->wep_key_curr_index = sme->key_idx;
2316             ret = mwifiex_set_encode(priv, NULL, sme->key,
2317                          sme->key_len, sme->key_idx,
2318                          NULL, 0);
2319         }
2320     }
2321 done:
2322     /*
2323      * Scan entries are valid for some time (15 sec). So we can save one
2324      * active scan time if we just try cfg80211_get_bss first. If it fails
2325      * then request scan and cfg80211_get_bss() again for final output.
2326      */
2327     while (1) {
2328         if (is_scanning_required) {
2329             /* Do specific SSID scanning */
2330             if (mwifiex_request_scan(priv, &req_ssid)) {
2331                 mwifiex_dbg(priv->adapter, ERROR, "scan error\n");
2332                 return -EFAULT;
2333             }
2334         }
2335
2336         /* Find the BSS we want using available scan results */
2337         if (mode == NL80211_IFTYPE_ADHOC)
2338             bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
2339                            bssid, ssid, ssid_len,
2340                            IEEE80211_BSS_TYPE_IBSS,
2341                            IEEE80211_PRIVACY_ANY);
2342         else
2343             bss = cfg80211_get_bss(priv->wdev.wiphy, channel,
2344                            bssid, ssid, ssid_len,
2345                            IEEE80211_BSS_TYPE_ESS,
2346                            IEEE80211_PRIVACY_ANY);
2347
2348         if (!bss) {
2349             if (is_scanning_required) {
2350                 mwifiex_dbg(priv->adapter, MSG,
2351                         "assoc: requested bss not found in scan results\n");
2352                 break;
2353             }
2354             is_scanning_required = 1;
2355         } else {
2356             mwifiex_dbg(priv->adapter, MSG,
2357                     "info: trying to associate to bssid %pM\n",
2358                     bss->bssid);
2359             memcpy(&priv->cfg_bssid, bss->bssid, ETH_ALEN);
2360             break;
2361         }
2362     }
2363
2364     if (bss)
2365         cfg80211_ref_bss(priv->adapter->wiphy, bss);
2366
2367     ret = mwifiex_bss_start(priv, bss, &req_ssid);
2368     if (ret)
2369         goto cleanup;
2370
2371     if (mode == NL80211_IFTYPE_ADHOC) {
2372         /* Inform the BSS information to kernel, otherwise
2373          * kernel will give a panic after successful assoc */
2374         if (mwifiex_cfg80211_inform_ibss_bss(priv)) {
2375             ret = -EFAULT;
2376             goto cleanup;
2377         }
2378     }
2379
2380     /* Pass the selected BSS entry to caller. */
2381     if (sel_bss) {
2382         *sel_bss = bss;
2383         bss = NULL;
2384     }
2385
2386 cleanup:
2387     if (bss)
2388         cfg80211_put_bss(priv->adapter->wiphy, bss);
2389     return ret;
2390 }
2391
2392 /*
2393  * CFG802.11 operation handler for association request.
2394  *
2395  * This function does not work when the current mode is set to Ad-Hoc, or
2396  * when there is already an association procedure going on. The given BSS
2397  * information is used to associate.
2398  */
2399 static int
2400 mwifiex_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
2401              struct cfg80211_connect_params *sme)
2402 {
2403     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2404     struct mwifiex_adapter *adapter = priv->adapter;
2405     struct cfg80211_bss *bss = NULL;
2406     int ret;
2407
2408     if (GET_BSS_ROLE(priv) != MWIFIEX_BSS_ROLE_STA) {
2409         mwifiex_dbg(adapter, ERROR,
2410                 "%s: reject infra assoc request in non-STA role\n",
2411                 dev->name);
2412         return -EINVAL;
2413     }
2414
2415     if (priv->wdev.connected) {
2416         mwifiex_dbg(adapter, ERROR,
2417                 "%s: already connected\n", dev->name);
2418         return -EALREADY;
2419     }
2420
2421     if (priv->scan_block)
2422         priv->scan_block = false;
2423
2424     if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags) ||
2425         test_bit(MWIFIEX_IS_CMD_TIMEDOUT, &adapter->work_flags)) {
2426         mwifiex_dbg(adapter, ERROR,
2427                 "%s: Ignore connection.\t"
2428                 "Card removed or FW in bad state\n",
2429                 dev->name);
2430         return -EFAULT;
2431     }
2432
2433     mwifiex_dbg(adapter, INFO,
2434             "info: Trying to associate to bssid %pM\n", sme->bssid);
2435
2436     if (!mwifiex_stop_bg_scan(priv))
2437         cfg80211_sched_scan_stopped_locked(priv->wdev.wiphy, 0);
2438
2439     ret = mwifiex_cfg80211_assoc(priv, sme->ssid_len, sme->ssid, sme->bssid,
2440                      priv->bss_mode, sme->channel, sme, 0,
2441                      &bss);
2442     if (!ret) {
2443         cfg80211_connect_bss(priv->netdev, priv->cfg_bssid, bss, NULL,
2444                      0, NULL, 0, WLAN_STATUS_SUCCESS,
2445                      GFP_KERNEL, NL80211_TIMEOUT_UNSPECIFIED);
2446         mwifiex_dbg(priv->adapter, MSG,
2447                 "info: associated to bssid %pM successfully\n",
2448                 priv->cfg_bssid);
2449         if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
2450             priv->adapter->auto_tdls &&
2451             priv->bss_type == MWIFIEX_BSS_TYPE_STA)
2452             mwifiex_setup_auto_tdls_timer(priv);
2453     } else {
2454         mwifiex_dbg(priv->adapter, ERROR,
2455                 "info: association to bssid %pM failed\n",
2456                 priv->cfg_bssid);
2457         eth_zero_addr(priv->cfg_bssid);
2458
2459         if (ret > 0)
2460             cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
2461                         NULL, 0, NULL, 0, ret,
2462                         GFP_KERNEL);
2463         else
2464             cfg80211_connect_result(priv->netdev, priv->cfg_bssid,
2465                         NULL, 0, NULL, 0,
2466                         WLAN_STATUS_UNSPECIFIED_FAILURE,
2467                         GFP_KERNEL);
2468     }
2469
2470     return 0;
2471 }
2472
2473 /*
2474  * This function sets following parameters for ibss network.
2475  *  -  channel
2476  *  -  start band
2477  *  -  11n flag
2478  *  -  secondary channel offset
2479  */
2480 static int mwifiex_set_ibss_params(struct mwifiex_private *priv,
2481                    struct cfg80211_ibss_params *params)
2482 {
2483     struct mwifiex_adapter *adapter = priv->adapter;
2484     int index = 0, i;
2485     u8 config_bands = 0;
2486
2487     if (params->chandef.chan->band == NL80211_BAND_2GHZ) {
2488         if (!params->basic_rates) {
2489             config_bands = BAND_B | BAND_G;
2490         } else {
2491             for (i = 0; i < mwifiex_band_2ghz.n_bitrates; i++) {
2492                 /*
2493                  * Rates below 6 Mbps in the table are CCK
2494                  * rates; 802.11b and from 6 they are OFDM;
2495                  * 802.11G
2496                  */
2497                 if (mwifiex_rates[i].bitrate == 60) {
2498                     index = 1 << i;
2499                     break;
2500                 }
2501             }
2502
2503             if (params->basic_rates < index) {
2504                 config_bands = BAND_B;
2505             } else {
2506                 config_bands = BAND_G;
2507                 if (params->basic_rates % index)
2508                     config_bands |= BAND_B;
2509             }
2510         }
2511
2512         if (cfg80211_get_chandef_type(&params->chandef) !=
2513                         NL80211_CHAN_NO_HT)
2514             config_bands |= BAND_G | BAND_GN;
2515     } else {
2516         if (cfg80211_get_chandef_type(&params->chandef) ==
2517                         NL80211_CHAN_NO_HT)
2518             config_bands = BAND_A;
2519         else
2520             config_bands = BAND_AN | BAND_A;
2521     }
2522
2523     if (!((config_bands | adapter->fw_bands) & ~adapter->fw_bands)) {
2524         adapter->config_bands = config_bands;
2525         adapter->adhoc_start_band = config_bands;
2526
2527         if ((config_bands & BAND_GN) || (config_bands & BAND_AN))
2528             adapter->adhoc_11n_enabled = true;
2529         else
2530             adapter->adhoc_11n_enabled = false;
2531     }
2532
2533     adapter->sec_chan_offset =
2534         mwifiex_chan_type_to_sec_chan_offset(
2535             cfg80211_get_chandef_type(&params->chandef));
2536     priv->adhoc_channel = ieee80211_frequency_to_channel(
2537                 params->chandef.chan->center_freq);
2538
2539     mwifiex_dbg(adapter, INFO,
2540             "info: set ibss band %d, chan %d, chan offset %d\n",
2541             config_bands, priv->adhoc_channel,
2542             adapter->sec_chan_offset);
2543
2544     return 0;
2545 }
2546
2547 /*
2548  * CFG802.11 operation handler to join an IBSS.
2549  *
2550  * This function does not work in any mode other than Ad-Hoc, or if
2551  * a join operation is already in progress.
2552  */
2553 static int
2554 mwifiex_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
2555                struct cfg80211_ibss_params *params)
2556 {
2557     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2558     int ret = 0;
2559
2560     if (priv->bss_mode != NL80211_IFTYPE_ADHOC) {
2561         mwifiex_dbg(priv->adapter, ERROR,
2562                 "request to join ibss received\t"
2563                 "when station is not in ibss mode\n");
2564         goto done;
2565     }
2566
2567     mwifiex_dbg(priv->adapter, MSG, "info: trying to join to bssid %pM\n",
2568             params->bssid);
2569
2570     mwifiex_set_ibss_params(priv, params);
2571
2572     ret = mwifiex_cfg80211_assoc(priv, params->ssid_len, params->ssid,
2573                      params->bssid, priv->bss_mode,
2574                      params->chandef.chan, NULL,
2575                      params->privacy, NULL);
2576 done:
2577     if (!ret) {
2578         cfg80211_ibss_joined(priv->netdev, priv->cfg_bssid,
2579                      params->chandef.chan, GFP_KERNEL);
2580         mwifiex_dbg(priv->adapter, MSG,
2581                 "info: joined/created adhoc network with bssid\t"
2582                 "%pM successfully\n", priv->cfg_bssid);
2583     } else {
2584         mwifiex_dbg(priv->adapter, ERROR,
2585                 "info: failed creating/joining adhoc network\n");
2586     }
2587
2588     return ret;
2589 }
2590
2591 /*
2592  * CFG802.11 operation handler to leave an IBSS.
2593  *
2594  * This function does not work if a leave operation is
2595  * already in progress.
2596  */
2597 static int
2598 mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
2599 {
2600     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2601
2602     mwifiex_dbg(priv->adapter, MSG, "info: disconnecting from essid %pM\n",
2603             priv->cfg_bssid);
2604     if (mwifiex_deauthenticate(priv, NULL))
2605         return -EFAULT;
2606
2607     eth_zero_addr(priv->cfg_bssid);
2608
2609     return 0;
2610 }
2611
2612 /*
2613  * CFG802.11 operation handler for scan request.
2614  *
2615  * This function issues a scan request to the firmware based upon
2616  * the user specified scan configuration. On successful completion,
2617  * it also informs the results.
2618  */
2619 static int
2620 mwifiex_cfg80211_scan(struct wiphy *wiphy,
2621               struct cfg80211_scan_request *request)
2622 {
2623     struct net_device *dev = request->wdev->netdev;
2624     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2625     int i, offset, ret;
2626     struct ieee80211_channel *chan;
2627     struct ieee_types_header *ie;
2628     struct mwifiex_user_scan_cfg *user_scan_cfg;
2629     u8 mac_addr[ETH_ALEN];
2630
2631     mwifiex_dbg(priv->adapter, CMD,
2632             "info: received scan request on %s\n", dev->name);
2633
2634     /* Block scan request if scan operation or scan cleanup when interface
2635      * is disabled is in process
2636      */
2637     if (priv->scan_request || priv->scan_aborting) {
2638         mwifiex_dbg(priv->adapter, WARN,
2639                 "cmd: Scan already in process..\n");
2640         return -EBUSY;
2641     }
2642
2643     if (!priv->wdev.connected && priv->scan_block)
2644         priv->scan_block = false;
2645
2646     if (!mwifiex_stop_bg_scan(priv))
2647         cfg80211_sched_scan_stopped_locked(priv->wdev.wiphy, 0);
2648
2649     user_scan_cfg = kzalloc(sizeof(*user_scan_cfg), GFP_KERNEL);
2650     if (!user_scan_cfg)
2651         return -ENOMEM;
2652
2653     priv->scan_request = request;
2654
2655     if (request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
2656         get_random_mask_addr(mac_addr, request->mac_addr,
2657                      request->mac_addr_mask);
2658         ether_addr_copy(request->mac_addr, mac_addr);
2659         ether_addr_copy(user_scan_cfg->random_mac, mac_addr);
2660     }
2661
2662     user_scan_cfg->num_ssids = request->n_ssids;
2663     user_scan_cfg->ssid_list = request->ssids;
2664
2665     if (request->ie && request->ie_len) {
2666         offset = 0;
2667         for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
2668             if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
2669                 continue;
2670             priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_SCAN;
2671             ie = (struct ieee_types_header *)(request->ie + offset);
2672             memcpy(&priv->vs_ie[i].ie, ie, sizeof(*ie) + ie->len);
2673             offset += sizeof(*ie) + ie->len;
2674
2675             if (offset >= request->ie_len)
2676                 break;
2677         }
2678     }
2679
2680     for (i = 0; i < min_t(u32, request->n_channels,
2681                   MWIFIEX_USER_SCAN_CHAN_MAX); i++) {
2682         chan = request->channels[i];
2683         user_scan_cfg->chan_list[i].chan_number = chan->hw_value;
2684         user_scan_cfg->chan_list[i].radio_type = chan->band;
2685
2686         if ((chan->flags & IEEE80211_CHAN_NO_IR) || !request->n_ssids)
2687             user_scan_cfg->chan_list[i].scan_type =
2688                         MWIFIEX_SCAN_TYPE_PASSIVE;
2689         else
2690             user_scan_cfg->chan_list[i].scan_type =
2691                         MWIFIEX_SCAN_TYPE_ACTIVE;
2692
2693         user_scan_cfg->chan_list[i].scan_time = 0;
2694     }
2695
2696     if (priv->adapter->scan_chan_gap_enabled &&
2697         mwifiex_is_any_intf_active(priv))
2698         user_scan_cfg->scan_chan_gap =
2699                           priv->adapter->scan_chan_gap_time;
2700
2701     ret = mwifiex_scan_networks(priv, user_scan_cfg);
2702     kfree(user_scan_cfg);
2703     if (ret) {
2704         mwifiex_dbg(priv->adapter, ERROR,
2705                 "scan failed: %d\n", ret);
2706         priv->scan_aborting = false;
2707         priv->scan_request = NULL;
2708         return ret;
2709     }
2710
2711     if (request->ie && request->ie_len) {
2712         for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
2713             if (priv->vs_ie[i].mask == MWIFIEX_VSIE_MASK_SCAN) {
2714                 priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_CLEAR;
2715                 memset(&priv->vs_ie[i].ie, 0,
2716                        MWIFIEX_MAX_VSIE_LEN);
2717             }
2718         }
2719     }
2720     return 0;
2721 }
2722
2723 /* CFG802.11 operation handler for sched_scan_start.
2724  *
2725  * This function issues a bgscan config request to the firmware based upon
2726  * the user specified sched_scan configuration. On successful completion,
2727  * firmware will generate BGSCAN_REPORT event, driver should issue bgscan
2728  * query command to get sched_scan results from firmware.
2729  */
2730 static int
2731 mwifiex_cfg80211_sched_scan_start(struct wiphy *wiphy,
2732                   struct net_device *dev,
2733                   struct cfg80211_sched_scan_request *request)
2734 {
2735     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2736     int i, offset;
2737     struct ieee80211_channel *chan;
2738     struct mwifiex_bg_scan_cfg *bgscan_cfg;
2739     struct ieee_types_header *ie;
2740
2741     if (!request || (!request->n_ssids && !request->n_match_sets)) {
2742         wiphy_err(wiphy, "%s : Invalid Sched_scan parameters",
2743               __func__);
2744         return -EINVAL;
2745     }
2746
2747     wiphy_info(wiphy, "sched_scan start : n_ssids=%d n_match_sets=%d ",
2748            request->n_ssids, request->n_match_sets);
2749     wiphy_info(wiphy, "n_channels=%d interval=%d ie_len=%d\n",
2750            request->n_channels, request->scan_plans->interval,
2751            (int)request->ie_len);
2752
2753     bgscan_cfg = kzalloc(sizeof(*bgscan_cfg), GFP_KERNEL);
2754     if (!bgscan_cfg)
2755         return -ENOMEM;
2756
2757     if (priv->scan_request || priv->scan_aborting)
2758         bgscan_cfg->start_later = true;
2759
2760     bgscan_cfg->num_ssids = request->n_match_sets;
2761     bgscan_cfg->ssid_list = request->match_sets;
2762
2763     if (request->ie && request->ie_len) {
2764         offset = 0;
2765         for (i = 0; i < MWIFIEX_MAX_VSIE_NUM; i++) {
2766             if (priv->vs_ie[i].mask != MWIFIEX_VSIE_MASK_CLEAR)
2767                 continue;
2768             priv->vs_ie[i].mask = MWIFIEX_VSIE_MASK_BGSCAN;
2769             ie = (struct ieee_types_header *)(request->ie + offset);
2770             memcpy(&priv->vs_ie[i].ie, ie, sizeof(*ie) + ie->len);
2771             offset += sizeof(*ie) + ie->len;
2772
2773             if (offset >= request->ie_len)
2774                 break;
2775         }
2776     }
2777
2778     for (i = 0; i < min_t(u32, request->n_channels,
2779                   MWIFIEX_BG_SCAN_CHAN_MAX); i++) {
2780         chan = request->channels[i];
2781         bgscan_cfg->chan_list[i].chan_number = chan->hw_value;
2782         bgscan_cfg->chan_list[i].radio_type = chan->band;
2783
2784         if ((chan->flags & IEEE80211_CHAN_NO_IR) || !request->n_ssids)
2785             bgscan_cfg->chan_list[i].scan_type =
2786                         MWIFIEX_SCAN_TYPE_PASSIVE;
2787         else
2788             bgscan_cfg->chan_list[i].scan_type =
2789                         MWIFIEX_SCAN_TYPE_ACTIVE;
2790
2791         bgscan_cfg->chan_list[i].scan_time = 0;
2792     }
2793
2794     bgscan_cfg->chan_per_scan = min_t(u32, request->n_channels,
2795                       MWIFIEX_BG_SCAN_CHAN_MAX);
2796
2797     /* Use at least 15 second for per scan cycle */
2798     bgscan_cfg->scan_interval = (request->scan_plans->interval >
2799                      MWIFIEX_BGSCAN_INTERVAL) ?
2800                 request->scan_plans->interval :
2801                 MWIFIEX_BGSCAN_INTERVAL;
2802
2803     bgscan_cfg->repeat_count = MWIFIEX_BGSCAN_REPEAT_COUNT;
2804     bgscan_cfg->report_condition = MWIFIEX_BGSCAN_SSID_MATCH |
2805                 MWIFIEX_BGSCAN_WAIT_ALL_CHAN_DONE;
2806     bgscan_cfg->bss_type = MWIFIEX_BSS_MODE_INFRA;
2807     bgscan_cfg->action = MWIFIEX_BGSCAN_ACT_SET;
2808     bgscan_cfg->enable = true;
2809     if (request->min_rssi_thold != NL80211_SCAN_RSSI_THOLD_OFF) {
2810         bgscan_cfg->report_condition |= MWIFIEX_BGSCAN_SSID_RSSI_MATCH;
2811         bgscan_cfg->rssi_threshold = request->min_rssi_thold;
2812     }
2813
2814     if (mwifiex_send_cmd(priv, HostCmd_CMD_802_11_BG_SCAN_CONFIG,
2815                  HostCmd_ACT_GEN_SET, 0, bgscan_cfg, true)) {
2816         kfree(bgscan_cfg);
2817         return -EFAULT;
2818     }
2819
2820     priv->sched_scanning = true;
2821
2822     kfree(bgscan_cfg);
2823     return 0;
2824 }
2825
2826 /* CFG802.11 operation handler for sched_scan_stop.
2827  *
2828  * This function issues a bgscan config command to disable
2829  * previous bgscan configuration in the firmware
2830  */
2831 static int mwifiex_cfg80211_sched_scan_stop(struct wiphy *wiphy,
2832                         struct net_device *dev, u64 reqid)
2833 {
2834     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
2835
2836     wiphy_info(wiphy, "sched scan stop!");
2837     mwifiex_stop_bg_scan(priv);
2838
2839     return 0;
2840 }
2841
2842 static void mwifiex_setup_vht_caps(struct ieee80211_sta_vht_cap *vht_info,
2843                    struct mwifiex_private *priv)
2844 {
2845     struct mwifiex_adapter *adapter = priv->adapter;
2846
2847     vht_info->vht_supported = true;
2848
2849     vht_info->cap = adapter->hw_dot_11ac_dev_cap;
2850     /* Update MCS support for VHT */
2851     vht_info->vht_mcs.rx_mcs_map = cpu_to_le16(
2852                 adapter->hw_dot_11ac_mcs_support & 0xFFFF);
2853     vht_info->vht_mcs.rx_highest = 0;
2854     vht_info->vht_mcs.tx_mcs_map = cpu_to_le16(
2855                 adapter->hw_dot_11ac_mcs_support >> 16);
2856     vht_info->vht_mcs.tx_highest = 0;
2857 }
2858
2859 /*
2860  * This function sets up the CFG802.11 specific HT capability fields
2861  * with default values.
2862  *
2863  * The following default values are set -
2864  *      - HT Supported = True
2865  *      - Maximum AMPDU length factor = IEEE80211_HT_MAX_AMPDU_64K
2866  *      - Minimum AMPDU spacing = IEEE80211_HT_MPDU_DENSITY_NONE
2867  *      - HT Capabilities supported by firmware
2868  *      - MCS information, Rx mask = 0xff
2869  *      - MCD information, Tx parameters = IEEE80211_HT_MCS_TX_DEFINED (0x01)
2870  */
2871 static void
2872 mwifiex_setup_ht_caps(struct ieee80211_sta_ht_cap *ht_info,
2873               struct mwifiex_private *priv)
2874 {
2875     int rx_mcs_supp;
2876     struct ieee80211_mcs_info mcs_set;
2877     u8 *mcs = (u8 *)&mcs_set;
2878     struct mwifiex_adapter *adapter = priv->adapter;
2879
2880     ht_info->ht_supported = true;
2881     ht_info->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
2882     ht_info->ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2883
2884     memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
2885
2886     /* Fill HT capability information */
2887     if (ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2888         ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2889     else
2890         ht_info->cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2891
2892     if (ISSUPP_SHORTGI20(adapter->hw_dot_11n_dev_cap))
2893         ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
2894     else
2895         ht_info->cap &= ~IEEE80211_HT_CAP_SGI_20;
2896
2897     if (ISSUPP_SHORTGI40(adapter->hw_dot_11n_dev_cap))
2898         ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
2899     else
2900         ht_info->cap &= ~IEEE80211_HT_CAP_SGI_40;
2901
2902     if (adapter->user_dev_mcs_support == HT_STREAM_2X2)
2903         ht_info->cap |= 2 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
2904     else
2905         ht_info->cap |= 1 << IEEE80211_HT_CAP_RX_STBC_SHIFT;
2906
2907     if (ISSUPP_TXSTBC(adapter->hw_dot_11n_dev_cap))
2908         ht_info->cap |= IEEE80211_HT_CAP_TX_STBC;
2909     else
2910         ht_info->cap &= ~IEEE80211_HT_CAP_TX_STBC;
2911
2912     if (ISSUPP_GREENFIELD(adapter->hw_dot_11n_dev_cap))
2913         ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
2914     else
2915         ht_info->cap &= ~IEEE80211_HT_CAP_GRN_FLD;
2916
2917     if (ISENABLED_40MHZ_INTOLERANT(adapter->hw_dot_11n_dev_cap))
2918         ht_info->cap |= IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2919     else
2920         ht_info->cap &= ~IEEE80211_HT_CAP_40MHZ_INTOLERANT;
2921
2922     if (ISSUPP_RXLDPC(adapter->hw_dot_11n_dev_cap))
2923         ht_info->cap |= IEEE80211_HT_CAP_LDPC_CODING;
2924     else
2925         ht_info->cap &= ~IEEE80211_HT_CAP_LDPC_CODING;
2926
2927     ht_info->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
2928     ht_info->cap |= IEEE80211_HT_CAP_SM_PS;
2929
2930     rx_mcs_supp = GET_RXMCSSUPP(adapter->user_dev_mcs_support);
2931     /* Set MCS for 1x1/2x2 */
2932     memset(mcs, 0xff, rx_mcs_supp);
2933     /* Clear all the other values */
2934     memset(&mcs[rx_mcs_supp], 0,
2935            sizeof(struct ieee80211_mcs_info) - rx_mcs_supp);
2936     if (priv->bss_mode == NL80211_IFTYPE_STATION ||
2937         ISSUPP_CHANWIDTH40(adapter->hw_dot_11n_dev_cap))
2938         /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */
2939         SETHT_MCS32(mcs_set.rx_mask);
2940
2941     memcpy((u8 *) &ht_info->mcs, mcs, sizeof(struct ieee80211_mcs_info));
2942
2943     ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
2944 }
2945
2946 /*
2947  *  create a new virtual interface with the given name and name assign type
2948  */
2949 struct wireless_dev *mwifiex_add_virtual_intf(struct wiphy *wiphy,
2950                           const char *name,
2951                           unsigned char name_assign_type,
2952                           enum nl80211_iftype type,
2953                           struct vif_params *params)
2954 {
2955     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
2956     struct mwifiex_private *priv;
2957     struct net_device *dev;
2958     void *mdev_priv;
2959     int ret;
2960
2961     if (!adapter)
2962         return ERR_PTR(-EFAULT);
2963
2964     switch (type) {
2965     case NL80211_IFTYPE_UNSPECIFIED:
2966     case NL80211_IFTYPE_STATION:
2967     case NL80211_IFTYPE_ADHOC:
2968         if (adapter->curr_iface_comb.sta_intf ==
2969             adapter->iface_limit.sta_intf) {
2970             mwifiex_dbg(adapter, ERROR,
2971                     "cannot create multiple sta/adhoc ifaces\n");
2972             return ERR_PTR(-EINVAL);
2973         }
2974
2975         priv = mwifiex_get_unused_priv_by_bss_type(
2976                         adapter, MWIFIEX_BSS_TYPE_STA);
2977         if (!priv) {
2978             mwifiex_dbg(adapter, ERROR,
2979                     "could not get free private struct\n");
2980             return ERR_PTR(-EFAULT);
2981         }
2982
2983         priv->wdev.wiphy = wiphy;
2984         priv->wdev.iftype = NL80211_IFTYPE_STATION;
2985
2986         if (type == NL80211_IFTYPE_UNSPECIFIED)
2987             priv->bss_mode = NL80211_IFTYPE_STATION;
2988         else
2989             priv->bss_mode = type;
2990
2991         priv->bss_type = MWIFIEX_BSS_TYPE_STA;
2992         priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
2993         priv->bss_priority = 0;
2994         priv->bss_role = MWIFIEX_BSS_ROLE_STA;
2995
2996         break;
2997     case NL80211_IFTYPE_AP:
2998         if (adapter->curr_iface_comb.uap_intf ==
2999             adapter->iface_limit.uap_intf) {
3000             mwifiex_dbg(adapter, ERROR,
3001                     "cannot create multiple AP ifaces\n");
3002             return ERR_PTR(-EINVAL);
3003         }
3004
3005         priv = mwifiex_get_unused_priv_by_bss_type(
3006                         adapter, MWIFIEX_BSS_TYPE_UAP);
3007         if (!priv) {
3008             mwifiex_dbg(adapter, ERROR,
3009                     "could not get free private struct\n");
3010             return ERR_PTR(-EFAULT);
3011         }
3012
3013         priv->wdev.wiphy = wiphy;
3014         priv->wdev.iftype = NL80211_IFTYPE_AP;
3015
3016         priv->bss_type = MWIFIEX_BSS_TYPE_UAP;
3017         priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
3018         priv->bss_priority = 0;
3019         priv->bss_role = MWIFIEX_BSS_ROLE_UAP;
3020         priv->bss_started = 0;
3021         priv->bss_mode = type;
3022
3023         break;
3024     case NL80211_IFTYPE_P2P_CLIENT:
3025         if (adapter->curr_iface_comb.p2p_intf ==
3026             adapter->iface_limit.p2p_intf) {
3027             mwifiex_dbg(adapter, ERROR,
3028                     "cannot create multiple P2P ifaces\n");
3029             return ERR_PTR(-EINVAL);
3030         }
3031
3032         priv = mwifiex_get_unused_priv_by_bss_type(
3033                         adapter, MWIFIEX_BSS_TYPE_P2P);
3034         if (!priv) {
3035             mwifiex_dbg(adapter, ERROR,
3036                     "could not get free private struct\n");
3037             return ERR_PTR(-EFAULT);
3038         }
3039
3040         priv->wdev.wiphy = wiphy;
3041         /* At start-up, wpa_supplicant tries to change the interface
3042          * to NL80211_IFTYPE_STATION if it is not managed mode.
3043          */
3044         priv->wdev.iftype = NL80211_IFTYPE_P2P_CLIENT;
3045         priv->bss_mode = NL80211_IFTYPE_P2P_CLIENT;
3046
3047         /* Setting bss_type to P2P tells firmware that this interface
3048          * is receiving P2P peers found during find phase and doing
3049          * action frame handshake.
3050          */
3051         priv->bss_type = MWIFIEX_BSS_TYPE_P2P;
3052
3053         priv->frame_type = MWIFIEX_DATA_FRAME_TYPE_ETH_II;
3054         priv->bss_priority = 0;
3055         priv->bss_role = MWIFIEX_BSS_ROLE_STA;
3056         priv->bss_started = 0;
3057
3058         if (mwifiex_cfg80211_init_p2p_client(priv)) {
3059             memset(&priv->wdev, 0, sizeof(priv->wdev));
3060             priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
3061             return ERR_PTR(-EFAULT);
3062         }
3063
3064         break;
3065     default:
3066         mwifiex_dbg(adapter, ERROR, "type not supported\n");
3067         return ERR_PTR(-EINVAL);
3068     }
3069
3070     dev = alloc_netdev_mqs(sizeof(struct mwifiex_private *), name,
3071                    name_assign_type, ether_setup,
3072                    IEEE80211_NUM_ACS, 1);
3073     if (!dev) {
3074         mwifiex_dbg(adapter, ERROR,
3075                 "no memory available for netdevice\n");
3076         ret = -ENOMEM;
3077         goto err_alloc_netdev;
3078     }
3079
3080     mwifiex_init_priv_params(priv, dev);
3081
3082     priv->netdev = dev;
3083
3084     if (!adapter->mfg_mode) {
3085         mwifiex_set_mac_address(priv, dev, false, NULL);
3086
3087         ret = mwifiex_send_cmd(priv, HostCmd_CMD_SET_BSS_MODE,
3088                        HostCmd_ACT_GEN_SET, 0, NULL, true);
3089         if (ret)
3090             goto err_set_bss_mode;
3091
3092         ret = mwifiex_sta_init_cmd(priv, false, false);
3093         if (ret)
3094             goto err_sta_init;
3095     }
3096
3097     mwifiex_setup_ht_caps(&wiphy->bands[NL80211_BAND_2GHZ]->ht_cap, priv);
3098     if (adapter->is_hw_11ac_capable)
3099         mwifiex_setup_vht_caps(
3100             &wiphy->bands[NL80211_BAND_2GHZ]->vht_cap, priv);
3101
3102     if (adapter->config_bands & BAND_A)
3103         mwifiex_setup_ht_caps(
3104             &wiphy->bands[NL80211_BAND_5GHZ]->ht_cap, priv);
3105
3106     if ((adapter->config_bands & BAND_A) && adapter->is_hw_11ac_capable)
3107         mwifiex_setup_vht_caps(
3108             &wiphy->bands[NL80211_BAND_5GHZ]->vht_cap, priv);
3109
3110     dev_net_set(dev, wiphy_net(wiphy));
3111     dev->ieee80211_ptr = &priv->wdev;
3112     dev->ieee80211_ptr->iftype = priv->bss_mode;
3113     SET_NETDEV_DEV(dev, wiphy_dev(wiphy));
3114
3115     dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
3116     dev->watchdog_timeo = MWIFIEX_DEFAULT_WATCHDOG_TIMEOUT;
3117     dev->needed_headroom = MWIFIEX_MIN_DATA_HEADER_LEN;
3118     dev->ethtool_ops = &mwifiex_ethtool_ops;
3119
3120     mdev_priv = netdev_priv(dev);
3121     *((unsigned long *) mdev_priv) = (unsigned long) priv;
3122
3123     SET_NETDEV_DEV(dev, adapter->dev);
3124
3125     priv->dfs_cac_workqueue = alloc_workqueue("MWIFIEX_DFS_CAC%s",
3126                           WQ_HIGHPRI |
3127                           WQ_MEM_RECLAIM |
3128                           WQ_UNBOUND, 1, name);
3129     if (!priv->dfs_cac_workqueue) {
3130         mwifiex_dbg(adapter, ERROR, "cannot alloc DFS CAC queue\n");
3131         ret = -ENOMEM;
3132         goto err_alloc_cac;
3133     }
3134
3135     INIT_DELAYED_WORK(&priv->dfs_cac_work, mwifiex_dfs_cac_work_queue);
3136
3137     priv->dfs_chan_sw_workqueue = alloc_workqueue("MWIFIEX_DFS_CHSW%s",
3138                               WQ_HIGHPRI | WQ_UNBOUND |
3139                               WQ_MEM_RECLAIM, 1, name);
3140     if (!priv->dfs_chan_sw_workqueue) {
3141         mwifiex_dbg(adapter, ERROR, "cannot alloc DFS channel sw queue\n");
3142         ret = -ENOMEM;
3143         goto err_alloc_chsw;
3144     }
3145
3146     INIT_DELAYED_WORK(&priv->dfs_chan_sw_work,
3147               mwifiex_dfs_chan_sw_work_queue);
3148
3149     mutex_init(&priv->async_mutex);
3150
3151     /* Register network device */
3152     if (cfg80211_register_netdevice(dev)) {
3153         mwifiex_dbg(adapter, ERROR, "cannot register network device\n");
3154         ret = -EFAULT;
3155         goto err_reg_netdev;
3156     }
3157
3158     mwifiex_dbg(adapter, INFO,
3159             "info: %s: Marvell 802.11 Adapter\n", dev->name);
3160
3161 #ifdef CONFIG_DEBUG_FS
3162     mwifiex_dev_debugfs_init(priv);
3163 #endif
3164
3165     update_vif_type_counter(adapter, type, +1);
3166
3167     return &priv->wdev;
3168
3169 err_reg_netdev:
3170     destroy_workqueue(priv->dfs_chan_sw_workqueue);
3171     priv->dfs_chan_sw_workqueue = NULL;
3172 err_alloc_chsw:
3173     destroy_workqueue(priv->dfs_cac_workqueue);
3174     priv->dfs_cac_workqueue = NULL;
3175 err_alloc_cac:
3176     free_netdev(dev);
3177     priv->netdev = NULL;
3178 err_sta_init:
3179 err_set_bss_mode:
3180 err_alloc_netdev:
3181     memset(&priv->wdev, 0, sizeof(priv->wdev));
3182     priv->wdev.iftype = NL80211_IFTYPE_UNSPECIFIED;
3183     priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
3184     return ERR_PTR(ret);
3185 }
3186 EXPORT_SYMBOL_GPL(mwifiex_add_virtual_intf);
3187
3188 /*
3189  * del_virtual_intf: remove the virtual interface determined by dev
3190  */
3191 int mwifiex_del_virtual_intf(struct wiphy *wiphy, struct wireless_dev *wdev)
3192 {
3193     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
3194     struct mwifiex_adapter *adapter = priv->adapter;
3195     struct sk_buff *skb, *tmp;
3196
3197 #ifdef CONFIG_DEBUG_FS
3198     mwifiex_dev_debugfs_remove(priv);
3199 #endif
3200
3201     if (priv->sched_scanning)
3202         priv->sched_scanning = false;
3203
3204     mwifiex_stop_net_dev_queue(priv->netdev, adapter);
3205
3206     skb_queue_walk_safe(&priv->bypass_txq, skb, tmp) {
3207         skb_unlink(skb, &priv->bypass_txq);
3208         mwifiex_write_data_complete(priv->adapter, skb, 0, -1);
3209     }
3210
3211     if (netif_carrier_ok(priv->netdev))
3212         netif_carrier_off(priv->netdev);
3213
3214     if (wdev->netdev->reg_state == NETREG_REGISTERED)
3215         cfg80211_unregister_netdevice(wdev->netdev);
3216
3217     if (priv->dfs_cac_workqueue) {
3218         destroy_workqueue(priv->dfs_cac_workqueue);
3219         priv->dfs_cac_workqueue = NULL;
3220     }
3221
3222     if (priv->dfs_chan_sw_workqueue) {
3223         destroy_workqueue(priv->dfs_chan_sw_workqueue);
3224         priv->dfs_chan_sw_workqueue = NULL;
3225     }
3226     /* Clear the priv in adapter */
3227     priv->netdev = NULL;
3228
3229     update_vif_type_counter(adapter, priv->bss_mode, -1);
3230
3231     priv->bss_mode = NL80211_IFTYPE_UNSPECIFIED;
3232
3233     if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA ||
3234         GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP)
3235         kfree(priv->hist_data);
3236
3237     return 0;
3238 }
3239 EXPORT_SYMBOL_GPL(mwifiex_del_virtual_intf);
3240
3241 static bool
3242 mwifiex_is_pattern_supported(struct cfg80211_pkt_pattern *pat, s8 *byte_seq,
3243                  u8 max_byte_seq)
3244 {
3245     int j, k, valid_byte_cnt = 0;
3246     bool dont_care_byte = false;
3247
3248     for (j = 0; j < DIV_ROUND_UP(pat->pattern_len, 8); j++) {
3249         for (k = 0; k < 8; k++) {
3250             if (pat->mask[j] & 1 << k) {
3251                 memcpy(byte_seq + valid_byte_cnt,
3252                        &pat->pattern[j * 8 + k], 1);
3253                 valid_byte_cnt++;
3254                 if (dont_care_byte)
3255                     return false;
3256             } else {
3257                 if (valid_byte_cnt)
3258                     dont_care_byte = true;
3259             }
3260
3261             /* wildcard bytes record as the offset
3262              * before the valid byte
3263              */
3264             if (!valid_byte_cnt && !dont_care_byte)
3265                 pat->pkt_offset++;
3266
3267             if (valid_byte_cnt > max_byte_seq)
3268                 return false;
3269         }
3270     }
3271
3272     byte_seq[max_byte_seq] = valid_byte_cnt;
3273
3274     return true;
3275 }
3276
3277 #ifdef CONFIG_PM
3278 static void mwifiex_set_auto_arp_mef_entry(struct mwifiex_private *priv,
3279                        struct mwifiex_mef_entry *mef_entry)
3280 {
3281     int i, filt_num = 0, num_ipv4 = 0;
3282     struct in_device *in_dev;
3283     struct in_ifaddr *ifa;
3284     __be32 ips[MWIFIEX_MAX_SUPPORTED_IPADDR];
3285     struct mwifiex_adapter *adapter = priv->adapter;
3286
3287     mef_entry->mode = MEF_MODE_HOST_SLEEP;
3288     mef_entry->action = MEF_ACTION_AUTO_ARP;
3289
3290     /* Enable ARP offload feature */
3291     memset(ips, 0, sizeof(ips));
3292     for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
3293         if (adapter->priv[i]->netdev) {
3294             in_dev = __in_dev_get_rtnl(adapter->priv[i]->netdev);
3295             if (!in_dev)
3296                 continue;
3297             ifa = rtnl_dereference(in_dev->ifa_list);
3298             if (!ifa || !ifa->ifa_local)
3299                 continue;
3300             ips[i] = ifa->ifa_local;
3301             num_ipv4++;
3302         }
3303     }
3304
3305     for (i = 0; i < num_ipv4; i++) {
3306         if (!ips[i])
3307             continue;
3308         mef_entry->filter[filt_num].repeat = 1;
3309         memcpy(mef_entry->filter[filt_num].byte_seq,
3310                (u8 *)&ips[i], sizeof(ips[i]));
3311         mef_entry->filter[filt_num].
3312             byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
3313             sizeof(ips[i]);
3314         mef_entry->filter[filt_num].offset = 46;
3315         mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3316         if (filt_num) {
3317             mef_entry->filter[filt_num].filt_action =
3318                 TYPE_OR;
3319         }
3320         filt_num++;
3321     }
3322
3323     mef_entry->filter[filt_num].repeat = 1;
3324     mef_entry->filter[filt_num].byte_seq[0] = 0x08;
3325     mef_entry->filter[filt_num].byte_seq[1] = 0x06;
3326     mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] = 2;
3327     mef_entry->filter[filt_num].offset = 20;
3328     mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3329     mef_entry->filter[filt_num].filt_action = TYPE_AND;
3330 }
3331
3332 static int mwifiex_set_wowlan_mef_entry(struct mwifiex_private *priv,
3333                     struct mwifiex_ds_mef_cfg *mef_cfg,
3334                     struct mwifiex_mef_entry *mef_entry,
3335                     struct cfg80211_wowlan *wowlan)
3336 {
3337     int i, filt_num = 0, ret = 0;
3338     bool first_pat = true;
3339     u8 byte_seq[MWIFIEX_MEF_MAX_BYTESEQ + 1];
3340     static const u8 ipv4_mc_mac[] = {0x33, 0x33};
3341     static const u8 ipv6_mc_mac[] = {0x01, 0x00, 0x5e};
3342
3343     mef_entry->mode = MEF_MODE_HOST_SLEEP;
3344     mef_entry->action = MEF_ACTION_ALLOW_AND_WAKEUP_HOST;
3345
3346     for (i = 0; i < wowlan->n_patterns; i++) {
3347         memset(byte_seq, 0, sizeof(byte_seq));
3348         if (!mwifiex_is_pattern_supported(&wowlan->patterns[i],
3349                     byte_seq,
3350                     MWIFIEX_MEF_MAX_BYTESEQ)) {
3351             mwifiex_dbg(priv->adapter, ERROR,
3352                     "Pattern not supported\n");
3353             return -EOPNOTSUPP;
3354         }
3355
3356         if (!wowlan->patterns[i].pkt_offset) {
3357             if (!(byte_seq[0] & 0x01) &&
3358                 (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 1)) {
3359                 mef_cfg->criteria |= MWIFIEX_CRITERIA_UNICAST;
3360                 continue;
3361             } else if (is_broadcast_ether_addr(byte_seq)) {
3362                 mef_cfg->criteria |= MWIFIEX_CRITERIA_BROADCAST;
3363                 continue;
3364             } else if ((!memcmp(byte_seq, ipv4_mc_mac, 2) &&
3365                     (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 2)) ||
3366                    (!memcmp(byte_seq, ipv6_mc_mac, 3) &&
3367                     (byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] == 3))) {
3368                 mef_cfg->criteria |= MWIFIEX_CRITERIA_MULTICAST;
3369                 continue;
3370             }
3371         }
3372         mef_entry->filter[filt_num].repeat = 1;
3373         mef_entry->filter[filt_num].offset =
3374             wowlan->patterns[i].pkt_offset;
3375         memcpy(mef_entry->filter[filt_num].byte_seq, byte_seq,
3376                 sizeof(byte_seq));
3377         mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3378
3379         if (first_pat) {
3380             first_pat = false;
3381             mwifiex_dbg(priv->adapter, INFO, "Wake on patterns\n");
3382         } else {
3383             mef_entry->filter[filt_num].filt_action = TYPE_AND;
3384         }
3385
3386         filt_num++;
3387     }
3388
3389     if (wowlan->magic_pkt) {
3390         mef_cfg->criteria |= MWIFIEX_CRITERIA_UNICAST;
3391         mef_entry->filter[filt_num].repeat = 16;
3392         memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,
3393                 ETH_ALEN);
3394         mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
3395             ETH_ALEN;
3396         mef_entry->filter[filt_num].offset = 28;
3397         mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3398         if (filt_num)
3399             mef_entry->filter[filt_num].filt_action = TYPE_OR;
3400
3401         filt_num++;
3402         mef_entry->filter[filt_num].repeat = 16;
3403         memcpy(mef_entry->filter[filt_num].byte_seq, priv->curr_addr,
3404                 ETH_ALEN);
3405         mef_entry->filter[filt_num].byte_seq[MWIFIEX_MEF_MAX_BYTESEQ] =
3406             ETH_ALEN;
3407         mef_entry->filter[filt_num].offset = 56;
3408         mef_entry->filter[filt_num].filt_type = TYPE_EQ;
3409         mef_entry->filter[filt_num].filt_action = TYPE_OR;
3410         mwifiex_dbg(priv->adapter, INFO, "Wake on magic packet\n");
3411     }
3412     return ret;
3413 }
3414
3415 static int mwifiex_set_mef_filter(struct mwifiex_private *priv,
3416                   struct cfg80211_wowlan *wowlan)
3417 {
3418     int ret = 0, num_entries = 1;
3419     struct mwifiex_ds_mef_cfg mef_cfg;
3420     struct mwifiex_mef_entry *mef_entry;
3421
3422     if (wowlan->n_patterns || wowlan->magic_pkt)
3423         num_entries++;
3424
3425     mef_entry = kcalloc(num_entries, sizeof(*mef_entry), GFP_KERNEL);
3426     if (!mef_entry)
3427         return -ENOMEM;
3428
3429     memset(&mef_cfg, 0, sizeof(mef_cfg));
3430     mef_cfg.criteria |= MWIFIEX_CRITERIA_BROADCAST |
3431         MWIFIEX_CRITERIA_UNICAST;
3432     mef_cfg.num_entries = num_entries;
3433     mef_cfg.mef_entry = mef_entry;
3434
3435     mwifiex_set_auto_arp_mef_entry(priv, &mef_entry[0]);
3436
3437     if (wowlan->n_patterns || wowlan->magic_pkt) {
3438         ret = mwifiex_set_wowlan_mef_entry(priv, &mef_cfg,
3439                            &mef_entry[1], wowlan);
3440         if (ret)
3441             goto err;
3442     }
3443
3444     if (!mef_cfg.criteria)
3445         mef_cfg.criteria = MWIFIEX_CRITERIA_BROADCAST |
3446             MWIFIEX_CRITERIA_UNICAST |
3447             MWIFIEX_CRITERIA_MULTICAST;
3448
3449     ret = mwifiex_send_cmd(priv, HostCmd_CMD_MEF_CFG,
3450             HostCmd_ACT_GEN_SET, 0,
3451             &mef_cfg, true);
3452
3453 err:
3454     kfree(mef_entry);
3455     return ret;
3456 }
3457
3458 static int mwifiex_cfg80211_suspend(struct wiphy *wiphy,
3459                     struct cfg80211_wowlan *wowlan)
3460 {
3461     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3462     struct mwifiex_ds_hs_cfg hs_cfg;
3463     int i, ret = 0, retry_num = 10;
3464     struct mwifiex_private *priv;
3465     struct mwifiex_private *sta_priv =
3466             mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
3467
3468     sta_priv->scan_aborting = true;
3469     for (i = 0; i < adapter->priv_num; i++) {
3470         priv = adapter->priv[i];
3471         mwifiex_abort_cac(priv);
3472     }
3473
3474     mwifiex_cancel_all_pending_cmd(adapter);
3475
3476     for (i = 0; i < adapter->priv_num; i++) {
3477         priv = adapter->priv[i];
3478         if (priv && priv->netdev)
3479             netif_device_detach(priv->netdev);
3480     }
3481
3482     for (i = 0; i < retry_num; i++) {
3483         if (!mwifiex_wmm_lists_empty(adapter) ||
3484             !mwifiex_bypass_txlist_empty(adapter) ||
3485             !skb_queue_empty(&adapter->tx_data_q))
3486             usleep_range(10000, 15000);
3487         else
3488             break;
3489     }
3490
3491     if (!wowlan) {
3492         mwifiex_dbg(adapter, INFO,
3493                 "None of the WOWLAN triggers enabled\n");
3494         ret = 0;
3495         goto done;
3496     }
3497
3498     if (!sta_priv->media_connected && !wowlan->nd_config) {
3499         mwifiex_dbg(adapter, ERROR,
3500                 "Can not configure WOWLAN in disconnected state\n");
3501         ret = 0;
3502         goto done;
3503     }
3504
3505     ret = mwifiex_set_mef_filter(sta_priv, wowlan);
3506     if (ret) {
3507         mwifiex_dbg(adapter, ERROR, "Failed to set MEF filter\n");
3508         goto done;
3509     }
3510
3511     memset(&hs_cfg, 0, sizeof(hs_cfg));
3512     hs_cfg.conditions = le32_to_cpu(adapter->hs_cfg.conditions);
3513
3514     if (wowlan->nd_config) {
3515         mwifiex_dbg(adapter, INFO, "Wake on net detect\n");
3516         hs_cfg.conditions |= HS_CFG_COND_MAC_EVENT;
3517         mwifiex_cfg80211_sched_scan_start(wiphy, sta_priv->netdev,
3518                           wowlan->nd_config);
3519     }
3520
3521     if (wowlan->disconnect) {
3522         hs_cfg.conditions |= HS_CFG_COND_MAC_EVENT;
3523         mwifiex_dbg(sta_priv->adapter, INFO, "Wake on device disconnect\n");
3524     }
3525
3526     hs_cfg.is_invoke_hostcmd = false;
3527     hs_cfg.gpio = adapter->hs_cfg.gpio;
3528     hs_cfg.gap = adapter->hs_cfg.gap;
3529     ret = mwifiex_set_hs_params(sta_priv, HostCmd_ACT_GEN_SET,
3530                     MWIFIEX_SYNC_CMD, &hs_cfg);
3531     if (ret)
3532         mwifiex_dbg(adapter, ERROR, "Failed to set HS params\n");
3533
3534 done:
3535     sta_priv->scan_aborting = false;
3536     return ret;
3537 }
3538
3539 static int mwifiex_cfg80211_resume(struct wiphy *wiphy)
3540 {
3541     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3542     struct mwifiex_private *priv;
3543     struct mwifiex_ds_wakeup_reason wakeup_reason;
3544     struct cfg80211_wowlan_wakeup wakeup_report;
3545     int i;
3546     bool report_wakeup_reason = true;
3547
3548     for (i = 0; i < adapter->priv_num; i++) {
3549         priv = adapter->priv[i];
3550         if (priv && priv->netdev)
3551             netif_device_attach(priv->netdev);
3552     }
3553
3554     if (!wiphy->wowlan_config)
3555         goto done;
3556
3557     priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
3558     mwifiex_get_wakeup_reason(priv, HostCmd_ACT_GEN_GET, MWIFIEX_SYNC_CMD,
3559                   &wakeup_reason);
3560     memset(&wakeup_report, 0, sizeof(struct cfg80211_wowlan_wakeup));
3561
3562     wakeup_report.pattern_idx = -1;
3563
3564     switch (wakeup_reason.hs_wakeup_reason) {
3565     case NO_HSWAKEUP_REASON:
3566         break;
3567     case BCAST_DATA_MATCHED:
3568         break;
3569     case MCAST_DATA_MATCHED:
3570         break;
3571     case UCAST_DATA_MATCHED:
3572         break;
3573     case MASKTABLE_EVENT_MATCHED:
3574         break;
3575     case NON_MASKABLE_EVENT_MATCHED:
3576         if (wiphy->wowlan_config->disconnect)
3577             wakeup_report.disconnect = true;
3578         if (wiphy->wowlan_config->nd_config)
3579             wakeup_report.net_detect = adapter->nd_info;
3580         break;
3581     case NON_MASKABLE_CONDITION_MATCHED:
3582         break;
3583     case MAGIC_PATTERN_MATCHED:
3584         if (wiphy->wowlan_config->magic_pkt)
3585             wakeup_report.magic_pkt = true;
3586         if (wiphy->wowlan_config->n_patterns)
3587             wakeup_report.pattern_idx = 1;
3588         break;
3589     case GTK_REKEY_FAILURE:
3590         if (wiphy->wowlan_config->gtk_rekey_failure)
3591             wakeup_report.gtk_rekey_failure = true;
3592         break;
3593     default:
3594         report_wakeup_reason = false;
3595         break;
3596     }
3597
3598     if (report_wakeup_reason)
3599         cfg80211_report_wowlan_wakeup(&priv->wdev, &wakeup_report,
3600                           GFP_KERNEL);
3601
3602 done:
3603     if (adapter->nd_info) {
3604         for (i = 0 ; i < adapter->nd_info->n_matches ; i++)
3605             kfree(adapter->nd_info->matches[i]);
3606         kfree(adapter->nd_info);
3607         adapter->nd_info = NULL;
3608     }
3609
3610     return 0;
3611 }
3612
3613 static void mwifiex_cfg80211_set_wakeup(struct wiphy *wiphy,
3614                        bool enabled)
3615 {
3616     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3617
3618     device_set_wakeup_enable(adapter->dev, enabled);
3619 }
3620
3621 static int mwifiex_set_rekey_data(struct wiphy *wiphy, struct net_device *dev,
3622                   struct cfg80211_gtk_rekey_data *data)
3623 {
3624     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3625
3626     if (!ISSUPP_FIRMWARE_SUPPLICANT(priv->adapter->fw_cap_info))
3627         return -EOPNOTSUPP;
3628
3629     return mwifiex_send_cmd(priv, HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG,
3630                 HostCmd_ACT_GEN_SET, 0, data, true);
3631 }
3632
3633 #endif
3634
3635 static int mwifiex_get_coalesce_pkt_type(u8 *byte_seq)
3636 {
3637     static const u8 ipv4_mc_mac[] = {0x33, 0x33};
3638     static const u8 ipv6_mc_mac[] = {0x01, 0x00, 0x5e};
3639     static const u8 bc_mac[] = {0xff, 0xff, 0xff, 0xff};
3640
3641     if ((byte_seq[0] & 0x01) &&
3642         (byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 1))
3643         return PACKET_TYPE_UNICAST;
3644     else if (!memcmp(byte_seq, bc_mac, 4))
3645         return PACKET_TYPE_BROADCAST;
3646     else if ((!memcmp(byte_seq, ipv4_mc_mac, 2) &&
3647           byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 2) ||
3648          (!memcmp(byte_seq, ipv6_mc_mac, 3) &&
3649           byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ] == 3))
3650         return PACKET_TYPE_MULTICAST;
3651
3652     return 0;
3653 }
3654
3655 static int
3656 mwifiex_fill_coalesce_rule_info(struct mwifiex_private *priv,
3657                 struct cfg80211_coalesce_rules *crule,
3658                 struct mwifiex_coalesce_rule *mrule)
3659 {
3660     u8 byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ + 1];
3661     struct filt_field_param *param;
3662     int i;
3663
3664     mrule->max_coalescing_delay = crule->delay;
3665
3666     param = mrule->params;
3667
3668     for (i = 0; i < crule->n_patterns; i++) {
3669         memset(byte_seq, 0, sizeof(byte_seq));
3670         if (!mwifiex_is_pattern_supported(&crule->patterns[i],
3671                           byte_seq,
3672                         MWIFIEX_COALESCE_MAX_BYTESEQ)) {
3673             mwifiex_dbg(priv->adapter, ERROR,
3674                     "Pattern not supported\n");
3675             return -EOPNOTSUPP;
3676         }
3677
3678         if (!crule->patterns[i].pkt_offset) {
3679             u8 pkt_type;
3680
3681             pkt_type = mwifiex_get_coalesce_pkt_type(byte_seq);
3682             if (pkt_type && mrule->pkt_type) {
3683                 mwifiex_dbg(priv->adapter, ERROR,
3684                         "Multiple packet types not allowed\n");
3685                 return -EOPNOTSUPP;
3686             } else if (pkt_type) {
3687                 mrule->pkt_type = pkt_type;
3688                 continue;
3689             }
3690         }
3691
3692         if (crule->condition == NL80211_COALESCE_CONDITION_MATCH)
3693             param->operation = RECV_FILTER_MATCH_TYPE_EQ;
3694         else
3695             param->operation = RECV_FILTER_MATCH_TYPE_NE;
3696
3697         param->operand_len = byte_seq[MWIFIEX_COALESCE_MAX_BYTESEQ];
3698         memcpy(param->operand_byte_stream, byte_seq,
3699                param->operand_len);
3700         param->offset = crule->patterns[i].pkt_offset;
3701         param++;
3702
3703         mrule->num_of_fields++;
3704     }
3705
3706     if (!mrule->pkt_type) {
3707         mwifiex_dbg(priv->adapter, ERROR,
3708                 "Packet type can not be determined\n");
3709         return -EOPNOTSUPP;
3710     }
3711
3712     return 0;
3713 }
3714
3715 static int mwifiex_cfg80211_set_coalesce(struct wiphy *wiphy,
3716                      struct cfg80211_coalesce *coalesce)
3717 {
3718     struct mwifiex_adapter *adapter = mwifiex_cfg80211_get_adapter(wiphy);
3719     int i, ret;
3720     struct mwifiex_ds_coalesce_cfg coalesce_cfg;
3721     struct mwifiex_private *priv =
3722             mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
3723
3724     memset(&coalesce_cfg, 0, sizeof(coalesce_cfg));
3725     if (!coalesce) {
3726         mwifiex_dbg(adapter, WARN,
3727                 "Disable coalesce and reset all previous rules\n");
3728         return mwifiex_send_cmd(priv, HostCmd_CMD_COALESCE_CFG,
3729                     HostCmd_ACT_GEN_SET, 0,
3730                     &coalesce_cfg, true);
3731     }
3732
3733     coalesce_cfg.num_of_rules = coalesce->n_rules;
3734     for (i = 0; i < coalesce->n_rules; i++) {
3735         ret = mwifiex_fill_coalesce_rule_info(priv, &coalesce->rules[i],
3736                               &coalesce_cfg.rule[i]);
3737         if (ret) {
3738             mwifiex_dbg(adapter, ERROR,
3739                     "Recheck the patterns provided for rule %d\n",
3740                 i + 1);
3741             return ret;
3742         }
3743     }
3744
3745     return mwifiex_send_cmd(priv, HostCmd_CMD_COALESCE_CFG,
3746                 HostCmd_ACT_GEN_SET, 0, &coalesce_cfg, true);
3747 }
3748
3749 /* cfg80211 ops handler for tdls_mgmt.
3750  * Function prepares TDLS action frame packets and forwards them to FW
3751  */
3752 static int
3753 mwifiex_cfg80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
3754                const u8 *peer, u8 action_code, u8 dialog_token,
3755                u16 status_code, u32 peer_capability,
3756                bool initiator, const u8 *extra_ies,
3757                size_t extra_ies_len)
3758 {
3759     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3760     int ret;
3761
3762     if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
3763         return -EOPNOTSUPP;
3764
3765     /* make sure we are in station mode and connected */
3766     if (!(priv->bss_type == MWIFIEX_BSS_TYPE_STA && priv->media_connected))
3767         return -EOPNOTSUPP;
3768
3769     switch (action_code) {
3770     case WLAN_TDLS_SETUP_REQUEST:
3771         mwifiex_dbg(priv->adapter, MSG,
3772                 "Send TDLS Setup Request to %pM status_code=%d\n",
3773                 peer, status_code);
3774         mwifiex_add_auto_tdls_peer(priv, peer);
3775         ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3776                            dialog_token, status_code,
3777                            extra_ies, extra_ies_len);
3778         break;
3779     case WLAN_TDLS_SETUP_RESPONSE:
3780         mwifiex_add_auto_tdls_peer(priv, peer);
3781         mwifiex_dbg(priv->adapter, MSG,
3782                 "Send TDLS Setup Response to %pM status_code=%d\n",
3783                 peer, status_code);
3784         ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3785                            dialog_token, status_code,
3786                            extra_ies, extra_ies_len);
3787         break;
3788     case WLAN_TDLS_SETUP_CONFIRM:
3789         mwifiex_dbg(priv->adapter, MSG,
3790                 "Send TDLS Confirm to %pM status_code=%d\n", peer,
3791                 status_code);
3792         ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3793                            dialog_token, status_code,
3794                            extra_ies, extra_ies_len);
3795         break;
3796     case WLAN_TDLS_TEARDOWN:
3797         mwifiex_dbg(priv->adapter, MSG,
3798                 "Send TDLS Tear down to %pM\n", peer);
3799         ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3800                            dialog_token, status_code,
3801                            extra_ies, extra_ies_len);
3802         break;
3803     case WLAN_TDLS_DISCOVERY_REQUEST:
3804         mwifiex_dbg(priv->adapter, MSG,
3805                 "Send TDLS Discovery Request to %pM\n", peer);
3806         ret = mwifiex_send_tdls_data_frame(priv, peer, action_code,
3807                            dialog_token, status_code,
3808                            extra_ies, extra_ies_len);
3809         break;
3810     case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
3811         mwifiex_dbg(priv->adapter, MSG,
3812                 "Send TDLS Discovery Response to %pM\n", peer);
3813         ret = mwifiex_send_tdls_action_frame(priv, peer, action_code,
3814                            dialog_token, status_code,
3815                            extra_ies, extra_ies_len);
3816         break;
3817     default:
3818         mwifiex_dbg(priv->adapter, ERROR,
3819                 "Unknown TDLS mgmt/action frame %pM\n", peer);
3820         ret = -EINVAL;
3821         break;
3822     }
3823
3824     return ret;
3825 }
3826
3827 static int
3828 mwifiex_cfg80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
3829                const u8 *peer, enum nl80211_tdls_operation action)
3830 {
3831     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3832
3833     if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
3834         !(wiphy->flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
3835         return -EOPNOTSUPP;
3836
3837     /* make sure we are in station mode and connected */
3838     if (!(priv->bss_type == MWIFIEX_BSS_TYPE_STA && priv->media_connected))
3839         return -EOPNOTSUPP;
3840
3841     mwifiex_dbg(priv->adapter, MSG,
3842             "TDLS peer=%pM, oper=%d\n", peer, action);
3843
3844     switch (action) {
3845     case NL80211_TDLS_ENABLE_LINK:
3846         action = MWIFIEX_TDLS_ENABLE_LINK;
3847         break;
3848     case NL80211_TDLS_DISABLE_LINK:
3849         action = MWIFIEX_TDLS_DISABLE_LINK;
3850         break;
3851     case NL80211_TDLS_TEARDOWN:
3852         /* shouldn't happen!*/
3853         mwifiex_dbg(priv->adapter, ERROR,
3854                 "tdls_oper: teardown from driver not supported\n");
3855         return -EINVAL;
3856     case NL80211_TDLS_SETUP:
3857         /* shouldn't happen!*/
3858         mwifiex_dbg(priv->adapter, ERROR,
3859                 "tdls_oper: setup from driver not supported\n");
3860         return -EINVAL;
3861     case NL80211_TDLS_DISCOVERY_REQ:
3862         /* shouldn't happen!*/
3863         mwifiex_dbg(priv->adapter, ERROR,
3864                 "tdls_oper: discovery from driver not supported\n");
3865         return -EINVAL;
3866     default:
3867         mwifiex_dbg(priv->adapter, ERROR,
3868                 "tdls_oper: operation not supported\n");
3869         return -EOPNOTSUPP;
3870     }
3871
3872     return mwifiex_tdls_oper(priv, peer, action);
3873 }
3874
3875 static int
3876 mwifiex_cfg80211_tdls_chan_switch(struct wiphy *wiphy, struct net_device *dev,
3877                   const u8 *addr, u8 oper_class,
3878                   struct cfg80211_chan_def *chandef)
3879 {
3880     struct mwifiex_sta_node *sta_ptr;
3881     u16 chan;
3882     u8 second_chan_offset, band;
3883     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3884
3885     spin_lock_bh(&priv->sta_list_spinlock);
3886     sta_ptr = mwifiex_get_sta_entry(priv, addr);
3887     if (!sta_ptr) {
3888         spin_unlock_bh(&priv->sta_list_spinlock);
3889         wiphy_err(wiphy, "%s: Invalid TDLS peer %pM\n",
3890               __func__, addr);
3891         return -ENOENT;
3892     }
3893
3894     if (!(sta_ptr->tdls_cap.extcap.ext_capab[3] &
3895           WLAN_EXT_CAPA4_TDLS_CHAN_SWITCH)) {
3896         spin_unlock_bh(&priv->sta_list_spinlock);
3897         wiphy_err(wiphy, "%pM do not support tdls cs\n", addr);
3898         return -ENOENT;
3899     }
3900
3901     if (sta_ptr->tdls_status == TDLS_CHAN_SWITCHING ||
3902         sta_ptr->tdls_status == TDLS_IN_OFF_CHAN) {
3903         spin_unlock_bh(&priv->sta_list_spinlock);
3904         wiphy_err(wiphy, "channel switch is running, abort request\n");
3905         return -EALREADY;
3906     }
3907     spin_unlock_bh(&priv->sta_list_spinlock);
3908
3909     chan = chandef->chan->hw_value;
3910     second_chan_offset = mwifiex_get_sec_chan_offset(chan);
3911     band = chandef->chan->band;
3912     mwifiex_start_tdls_cs(priv, addr, chan, second_chan_offset, band);
3913
3914     return 0;
3915 }
3916
3917 static void
3918 mwifiex_cfg80211_tdls_cancel_chan_switch(struct wiphy *wiphy,
3919                      struct net_device *dev,
3920                      const u8 *addr)
3921 {
3922     struct mwifiex_sta_node *sta_ptr;
3923     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3924
3925     spin_lock_bh(&priv->sta_list_spinlock);
3926     sta_ptr = mwifiex_get_sta_entry(priv, addr);
3927     if (!sta_ptr) {
3928         spin_unlock_bh(&priv->sta_list_spinlock);
3929         wiphy_err(wiphy, "%s: Invalid TDLS peer %pM\n",
3930               __func__, addr);
3931     } else if (!(sta_ptr->tdls_status == TDLS_CHAN_SWITCHING ||
3932              sta_ptr->tdls_status == TDLS_IN_BASE_CHAN ||
3933              sta_ptr->tdls_status == TDLS_IN_OFF_CHAN)) {
3934         spin_unlock_bh(&priv->sta_list_spinlock);
3935         wiphy_err(wiphy, "tdls chan switch not initialize by %pM\n",
3936               addr);
3937     } else {
3938         spin_unlock_bh(&priv->sta_list_spinlock);
3939         mwifiex_stop_tdls_cs(priv, addr);
3940     }
3941 }
3942
3943 static int
3944 mwifiex_cfg80211_add_station(struct wiphy *wiphy, struct net_device *dev,
3945                  const u8 *mac, struct station_parameters *params)
3946 {
3947     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3948
3949     if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3950         return -EOPNOTSUPP;
3951
3952     /* make sure we are in station mode and connected */
3953     if ((priv->bss_type != MWIFIEX_BSS_TYPE_STA) || !priv->media_connected)
3954         return -EOPNOTSUPP;
3955
3956     return mwifiex_tdls_oper(priv, mac, MWIFIEX_TDLS_CREATE_LINK);
3957 }
3958
3959 static int
3960 mwifiex_cfg80211_channel_switch(struct wiphy *wiphy, struct net_device *dev,
3961                 struct cfg80211_csa_settings *params)
3962 {
3963     struct ieee_types_header *chsw_ie;
3964     struct ieee80211_channel_sw_ie *channel_sw;
3965     int chsw_msec;
3966     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
3967
3968     if (priv->adapter->scan_processing) {
3969         mwifiex_dbg(priv->adapter, ERROR,
3970                 "radar detection: scan in process...\n");
3971         return -EBUSY;
3972     }
3973
3974     if (priv->wdev.cac_started)
3975         return -EBUSY;
3976
3977     if (cfg80211_chandef_identical(&params->chandef,
3978                        &priv->dfs_chandef))
3979         return -EINVAL;
3980
3981     chsw_ie = (void *)cfg80211_find_ie(WLAN_EID_CHANNEL_SWITCH,
3982                        params->beacon_csa.tail,
3983                        params->beacon_csa.tail_len);
3984     if (!chsw_ie) {
3985         mwifiex_dbg(priv->adapter, ERROR,
3986                 "Could not parse channel switch announcement IE\n");
3987         return -EINVAL;
3988     }
3989
3990     channel_sw = (void *)(chsw_ie + 1);
3991     if (channel_sw->mode) {
3992         if (netif_carrier_ok(priv->netdev))
3993             netif_carrier_off(priv->netdev);
3994         mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
3995     }
3996
3997     if (mwifiex_del_mgmt_ies(priv))
3998         mwifiex_dbg(priv->adapter, ERROR,
3999                 "Failed to delete mgmt IEs!\n");
4000
4001     if (mwifiex_set_mgmt_ies(priv, &params->beacon_csa)) {
4002         mwifiex_dbg(priv->adapter, ERROR,
4003                 "%s: setting mgmt ies failed\n", __func__);
4004         return -EFAULT;
4005     }
4006
4007     memcpy(&priv->dfs_chandef, &params->chandef, sizeof(priv->dfs_chandef));
4008     memcpy(&priv->beacon_after, &params->beacon_after,
4009            sizeof(priv->beacon_after));
4010
4011     chsw_msec = max(channel_sw->count * priv->bss_cfg.beacon_period, 100);
4012     queue_delayed_work(priv->dfs_chan_sw_workqueue, &priv->dfs_chan_sw_work,
4013                msecs_to_jiffies(chsw_msec));
4014     return 0;
4015 }
4016
4017 static int mwifiex_cfg80211_get_channel(struct wiphy *wiphy,
4018                     struct wireless_dev *wdev,
4019                     unsigned int link_id,
4020                     struct cfg80211_chan_def *chandef)
4021 {
4022     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
4023     struct mwifiex_bssdescriptor *curr_bss;
4024     struct ieee80211_channel *chan;
4025     enum nl80211_channel_type chan_type;
4026     enum nl80211_band band;
4027     int freq;
4028     int ret = -ENODATA;
4029
4030     if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP &&
4031         cfg80211_chandef_valid(&priv->bss_chandef)) {
4032         *chandef = priv->bss_chandef;
4033         ret = 0;
4034     } else if (priv->media_connected) {
4035         curr_bss = &priv->curr_bss_params.bss_descriptor;
4036         band = mwifiex_band_to_radio_type(priv->curr_bss_params.band);
4037         freq = ieee80211_channel_to_frequency(curr_bss->channel, band);
4038         chan = ieee80211_get_channel(wiphy, freq);
4039
4040         if (priv->ht_param_present) {
4041             chan_type = mwifiex_get_chan_type(priv);
4042             cfg80211_chandef_create(chandef, chan, chan_type);
4043         } else {
4044             cfg80211_chandef_create(chandef, chan,
4045                         NL80211_CHAN_NO_HT);
4046         }
4047         ret = 0;
4048     }
4049
4050     return ret;
4051 }
4052
4053 #ifdef CONFIG_NL80211_TESTMODE
4054
4055 enum mwifiex_tm_attr {
4056     __MWIFIEX_TM_ATTR_INVALID   = 0,
4057     MWIFIEX_TM_ATTR_CMD     = 1,
4058     MWIFIEX_TM_ATTR_DATA        = 2,
4059
4060     /* keep last */
4061     __MWIFIEX_TM_ATTR_AFTER_LAST,
4062     MWIFIEX_TM_ATTR_MAX     = __MWIFIEX_TM_ATTR_AFTER_LAST - 1,
4063 };
4064
4065 static const struct nla_policy mwifiex_tm_policy[MWIFIEX_TM_ATTR_MAX + 1] = {
4066     [MWIFIEX_TM_ATTR_CMD]       = { .type = NLA_U32 },
4067     [MWIFIEX_TM_ATTR_DATA]      = { .type = NLA_BINARY,
4068                         .len = MWIFIEX_SIZE_OF_CMD_BUFFER },
4069 };
4070
4071 enum mwifiex_tm_command {
4072     MWIFIEX_TM_CMD_HOSTCMD  = 0,
4073 };
4074
4075 static int mwifiex_tm_cmd(struct wiphy *wiphy, struct wireless_dev *wdev,
4076               void *data, int len)
4077 {
4078     struct mwifiex_private *priv = mwifiex_netdev_get_priv(wdev->netdev);
4079     struct mwifiex_ds_misc_cmd *hostcmd;
4080     struct nlattr *tb[MWIFIEX_TM_ATTR_MAX + 1];
4081     struct sk_buff *skb;
4082     int err;
4083
4084     if (!priv)
4085         return -EINVAL;
4086
4087     err = nla_parse_deprecated(tb, MWIFIEX_TM_ATTR_MAX, data, len,
4088                    mwifiex_tm_policy, NULL);
4089     if (err)
4090         return err;
4091
4092     if (!tb[MWIFIEX_TM_ATTR_CMD])
4093         return -EINVAL;
4094
4095     switch (nla_get_u32(tb[MWIFIEX_TM_ATTR_CMD])) {
4096     case MWIFIEX_TM_CMD_HOSTCMD:
4097         if (!tb[MWIFIEX_TM_ATTR_DATA])
4098             return -EINVAL;
4099
4100         hostcmd = kzalloc(sizeof(*hostcmd), GFP_KERNEL);
4101         if (!hostcmd)
4102             return -ENOMEM;
4103
4104         hostcmd->len = nla_len(tb[MWIFIEX_TM_ATTR_DATA]);
4105         memcpy(hostcmd->cmd, nla_data(tb[MWIFIEX_TM_ATTR_DATA]),
4106                hostcmd->len);
4107
4108         if (mwifiex_send_cmd(priv, 0, 0, 0, hostcmd, true)) {
4109             dev_err(priv->adapter->dev, "Failed to process hostcmd\n");
4110             kfree(hostcmd);
4111             return -EFAULT;
4112         }
4113
4114         /* process hostcmd response*/
4115         skb = cfg80211_testmode_alloc_reply_skb(wiphy, hostcmd->len);
4116         if (!skb) {
4117             kfree(hostcmd);
4118             return -ENOMEM;
4119         }
4120         err = nla_put(skb, MWIFIEX_TM_ATTR_DATA,
4121                   hostcmd->len, hostcmd->cmd);
4122         if (err) {
4123             kfree(hostcmd);
4124             kfree_skb(skb);
4125             return -EMSGSIZE;
4126         }
4127
4128         err = cfg80211_testmode_reply(skb);
4129         kfree(hostcmd);
4130         return err;
4131     default:
4132         return -EOPNOTSUPP;
4133     }
4134 }
4135 #endif
4136
4137 static int
4138 mwifiex_cfg80211_start_radar_detection(struct wiphy *wiphy,
4139                        struct net_device *dev,
4140                        struct cfg80211_chan_def *chandef,
4141                        u32 cac_time_ms)
4142 {
4143     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
4144     struct mwifiex_radar_params radar_params;
4145
4146     if (priv->adapter->scan_processing) {
4147         mwifiex_dbg(priv->adapter, ERROR,
4148                 "radar detection: scan already in process...\n");
4149         return -EBUSY;
4150     }
4151
4152     if (!mwifiex_is_11h_active(priv)) {
4153         mwifiex_dbg(priv->adapter, INFO,
4154                 "Enable 11h extensions in FW\n");
4155         if (mwifiex_11h_activate(priv, true)) {
4156             mwifiex_dbg(priv->adapter, ERROR,
4157                     "Failed to activate 11h extensions!!");
4158             return -1;
4159         }
4160         priv->state_11h.is_11h_active = true;
4161     }
4162
4163     memset(&radar_params, 0, sizeof(struct mwifiex_radar_params));
4164     radar_params.chandef = chandef;
4165     radar_params.cac_time_ms = cac_time_ms;
4166
4167     memcpy(&priv->dfs_chandef, chandef, sizeof(priv->dfs_chandef));
4168
4169     if (mwifiex_send_cmd(priv, HostCmd_CMD_CHAN_REPORT_REQUEST,
4170                  HostCmd_ACT_GEN_SET, 0, &radar_params, true))
4171         return -1;
4172
4173     queue_delayed_work(priv->dfs_cac_workqueue, &priv->dfs_cac_work,
4174                msecs_to_jiffies(cac_time_ms));
4175     return 0;
4176 }
4177
4178 static int
4179 mwifiex_cfg80211_change_station(struct wiphy *wiphy, struct net_device *dev,
4180                 const u8 *mac,
4181                 struct station_parameters *params)
4182 {
4183     int ret;
4184     struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
4185
4186     /* we support change_station handler only for TDLS peers*/
4187     if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4188         return -EOPNOTSUPP;
4189
4190     /* make sure we are in station mode and connected */
4191     if ((priv->bss_type != MWIFIEX_BSS_TYPE_STA) || !priv->media_connected)
4192         return -EOPNOTSUPP;
4193
4194     priv->sta_params = params;
4195
4196     ret = mwifiex_tdls_oper(priv, mac, MWIFIEX_TDLS_CONFIG_LINK);
4197     priv->sta_params = NULL;
4198
4199     return ret;
4200 }
4201
4202 /* station cfg80211 operations */
4203 static struct cfg80211_ops mwifiex_cfg80211_ops = {
4204     .add_virtual_intf = mwifiex_add_virtual_intf,
4205     .del_virtual_intf = mwifiex_del_virtual_intf,
4206     .change_virtual_intf = mwifiex_cfg80211_change_virtual_intf,
4207     .scan = mwifiex_cfg80211_scan,
4208     .connect = mwifiex_cfg80211_connect,
4209     .disconnect = mwifiex_cfg80211_disconnect,
4210     .get_station = mwifiex_cfg80211_get_station,
4211     .dump_station = mwifiex_cfg80211_dump_station,
4212     .dump_survey = mwifiex_cfg80211_dump_survey,
4213     .set_wiphy_params = mwifiex_cfg80211_set_wiphy_params,
4214     .join_ibss = mwifiex_cfg80211_join_ibss,
4215     .leave_ibss = mwifiex_cfg80211_leave_ibss,
4216     .add_key = mwifiex_cfg80211_add_key,
4217     .del_key = mwifiex_cfg80211_del_key,
4218     .set_default_mgmt_key = mwifiex_cfg80211_set_default_mgmt_key,
4219     .mgmt_tx = mwifiex_cfg80211_mgmt_tx,
4220     .update_mgmt_frame_registrations =
4221         mwifiex_cfg80211_update_mgmt_frame_registrations,
4222     .remain_on_channel = mwifiex_cfg80211_remain_on_channel,
4223     .cancel_remain_on_channel = mwifiex_cfg80211_cancel_remain_on_channel,
4224     .set_default_key = mwifiex_cfg80211_set_default_key,
4225     .set_power_mgmt = mwifiex_cfg80211_set_power_mgmt,
4226     .set_tx_power = mwifiex_cfg80211_set_tx_power,
4227     .get_tx_power = mwifiex_cfg80211_get_tx_power,
4228     .set_bitrate_mask = mwifiex_cfg80211_set_bitrate_mask,
4229     .start_ap = mwifiex_cfg80211_start_ap,
4230     .stop_ap = mwifiex_cfg80211_stop_ap,
4231     .change_beacon = mwifiex_cfg80211_change_beacon,
4232     .set_cqm_rssi_config = mwifiex_cfg80211_set_cqm_rssi_config,
4233     .set_antenna = mwifiex_cfg80211_set_antenna,
4234     .get_antenna = mwifiex_cfg80211_get_antenna,
4235     .del_station = mwifiex_cfg80211_del_station,
4236     .sched_scan_start = mwifiex_cfg80211_sched_scan_start,
4237     .sched_scan_stop = mwifiex_cfg80211_sched_scan_stop,
4238 #ifdef CONFIG_PM
4239     .suspend = mwifiex_cfg80211_suspend,
4240     .resume = mwifiex_cfg80211_resume,
4241     .set_wakeup = mwifiex_cfg80211_set_wakeup,
4242     .set_rekey_data = mwifiex_set_rekey_data,
4243 #endif
4244     .set_coalesce = mwifiex_cfg80211_set_coalesce,
4245     .tdls_mgmt = mwifiex_cfg80211_tdls_mgmt,
4246     .tdls_oper = mwifiex_cfg80211_tdls_oper,
4247     .tdls_channel_switch = mwifiex_cfg80211_tdls_chan_switch,
4248     .tdls_cancel_channel_switch = mwifiex_cfg80211_tdls_cancel_chan_switch,
4249     .add_station = mwifiex_cfg80211_add_station,
4250     .change_station = mwifiex_cfg80211_change_station,
4251     CFG80211_TESTMODE_CMD(mwifiex_tm_cmd)
4252     .get_channel = mwifiex_cfg80211_get_channel,
4253     .start_radar_detection = mwifiex_cfg80211_start_radar_detection,
4254     .channel_switch = mwifiex_cfg80211_channel_switch,
4255 };
4256
4257 #ifdef CONFIG_PM
4258 static const struct wiphy_wowlan_support mwifiex_wowlan_support = {
4259     .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT |
4260         WIPHY_WOWLAN_NET_DETECT | WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
4261         WIPHY_WOWLAN_GTK_REKEY_FAILURE,
4262     .n_patterns = MWIFIEX_MEF_MAX_FILTERS,
4263     .pattern_min_len = 1,
4264     .pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
4265     .max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
4266     .max_nd_match_sets = MWIFIEX_MAX_ND_MATCH_SETS,
4267 };
4268
4269 static const struct wiphy_wowlan_support mwifiex_wowlan_support_no_gtk = {
4270     .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT |
4271          WIPHY_WOWLAN_NET_DETECT,
4272     .n_patterns = MWIFIEX_MEF_MAX_FILTERS,
4273     .pattern_min_len = 1,
4274     .pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
4275     .max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
4276     .max_nd_match_sets = MWIFIEX_MAX_ND_MATCH_SETS,
4277 };
4278 #endif
4279
4280 static bool mwifiex_is_valid_alpha2(const char *alpha2)
4281 {
4282     if (!alpha2 || strlen(alpha2) != 2)
4283         return false;
4284
4285     if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
4286         return true;
4287
4288     return false;
4289 }
4290
4291 static const struct wiphy_coalesce_support mwifiex_coalesce_support = {
4292     .n_rules = MWIFIEX_COALESCE_MAX_RULES,
4293     .max_delay = MWIFIEX_MAX_COALESCING_DELAY,
4294     .n_patterns = MWIFIEX_COALESCE_MAX_FILTERS,
4295     .pattern_min_len = 1,
4296     .pattern_max_len = MWIFIEX_MAX_PATTERN_LEN,
4297     .max_pkt_offset = MWIFIEX_MAX_OFFSET_LEN,
4298 };
4299
4300 int mwifiex_init_channel_scan_gap(struct mwifiex_adapter *adapter)
4301 {
4302     u32 n_channels_bg, n_channels_a = 0;
4303
4304     n_channels_bg = mwifiex_band_2ghz.n_channels;
4305
4306     if (adapter->config_bands & BAND_A)
4307         n_channels_a = mwifiex_band_5ghz.n_channels;
4308
4309     /* allocate twice the number total channels, since the driver issues an
4310      * additional active scan request for hidden SSIDs on passive channels.
4311      */
4312     adapter->num_in_chan_stats = 2 * (n_channels_bg + n_channels_a);
4313     adapter->chan_stats = vmalloc(array_size(sizeof(*adapter->chan_stats),
4314                          adapter->num_in_chan_stats));
4315
4316     if (!adapter->chan_stats)
4317         return -ENOMEM;
4318
4319     return 0;
4320 }
4321
4322 /*
4323  * This function registers the device with CFG802.11 subsystem.
4324  *
4325  * The function creates the wireless device/wiphy, populates it with
4326  * default parameters and handler function pointers, and finally
4327  * registers the device.
4328  */
4329
4330 int mwifiex_register_cfg80211(struct mwifiex_adapter *adapter)
4331 {
4332     int ret;
4333     void *wdev_priv;
4334     struct wiphy *wiphy;
4335     struct mwifiex_private *priv = adapter->priv[MWIFIEX_BSS_TYPE_STA];
4336     u8 *country_code;
4337     u32 thr, retry;
4338
4339     /* create a new wiphy for use with cfg80211 */
4340     wiphy = wiphy_new(&mwifiex_cfg80211_ops,
4341               sizeof(struct mwifiex_adapter *));
4342     if (!wiphy) {
4343         mwifiex_dbg(adapter, ERROR,
4344                 "%s: creating new wiphy\n", __func__);
4345         return -ENOMEM;
4346     }
4347     wiphy->max_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
4348     wiphy->max_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
4349     wiphy->mgmt_stypes = mwifiex_mgmt_stypes;
4350     wiphy->max_remain_on_channel_duration = 5000;
4351     wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4352                  BIT(NL80211_IFTYPE_P2P_CLIENT) |
4353                  BIT(NL80211_IFTYPE_P2P_GO) |
4354                  BIT(NL80211_IFTYPE_AP);
4355
4356     if (ISSUPP_ADHOC_ENABLED(adapter->fw_cap_info))
4357         wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
4358
4359     wiphy->bands[NL80211_BAND_2GHZ] = &mwifiex_band_2ghz;
4360     if (adapter->config_bands & BAND_A)
4361         wiphy->bands[NL80211_BAND_5GHZ] = &mwifiex_band_5ghz;
4362     else
4363         wiphy->bands[NL80211_BAND_5GHZ] = NULL;
4364
4365     if (adapter->drcs_enabled && ISSUPP_DRCS_ENABLED(adapter->fw_cap_info))
4366         wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta_drcs;
4367     else if (adapter->is_hw_11ac_capable)
4368         wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta_vht;
4369     else
4370         wiphy->iface_combinations = &mwifiex_iface_comb_ap_sta;
4371     wiphy->n_iface_combinations = 1;
4372
4373     if (adapter->max_sta_conn > adapter->max_p2p_conn)
4374         wiphy->max_ap_assoc_sta = adapter->max_sta_conn;
4375     else
4376         wiphy->max_ap_assoc_sta = adapter->max_p2p_conn;
4377
4378     /* Initialize cipher suits */
4379     wiphy->cipher_suites = mwifiex_cipher_suites;
4380     wiphy->n_cipher_suites = ARRAY_SIZE(mwifiex_cipher_suites);
4381
4382     if (adapter->regd) {
4383         wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
4384                        REGULATORY_DISABLE_BEACON_HINTS |
4385                        REGULATORY_COUNTRY_IE_IGNORE;
4386         wiphy_apply_custom_regulatory(wiphy, adapter->regd);
4387     }
4388
4389     ether_addr_copy(wiphy->perm_addr, adapter->perm_addr);
4390     wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
4391     wiphy->flags |= WIPHY_FLAG_HAVE_AP_SME |
4392             WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD |
4393             WIPHY_FLAG_AP_UAPSD |
4394             WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
4395             WIPHY_FLAG_HAS_CHANNEL_SWITCH |
4396             WIPHY_FLAG_PS_ON_BY_DEFAULT;
4397
4398     if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
4399         wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS |
4400                 WIPHY_FLAG_TDLS_EXTERNAL_SETUP;
4401
4402 #ifdef CONFIG_PM
4403     if (ISSUPP_FIRMWARE_SUPPLICANT(priv->adapter->fw_cap_info))
4404         wiphy->wowlan = &mwifiex_wowlan_support;
4405     else
4406         wiphy->wowlan = &mwifiex_wowlan_support_no_gtk;
4407 #endif
4408
4409     wiphy->coalesce = &mwifiex_coalesce_support;
4410
4411     wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
4412                     NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
4413                     NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
4414
4415     wiphy->max_sched_scan_reqs = 1;
4416     wiphy->max_sched_scan_ssids = MWIFIEX_MAX_SSID_LIST_LENGTH;
4417     wiphy->max_sched_scan_ie_len = MWIFIEX_MAX_VSIE_LEN;
4418     wiphy->max_match_sets = MWIFIEX_MAX_SSID_LIST_LENGTH;
4419
4420     wiphy->available_antennas_tx = BIT(adapter->number_of_antenna) - 1;
4421     wiphy->available_antennas_rx = BIT(adapter->number_of_antenna) - 1;
4422
4423     wiphy->features |= NL80211_FEATURE_INACTIVITY_TIMER |
4424                NL80211_FEATURE_LOW_PRIORITY_SCAN |
4425                NL80211_FEATURE_NEED_OBSS_SCAN;
4426
4427     if (ISSUPP_ADHOC_ENABLED(adapter->fw_cap_info))
4428         wiphy->features |= NL80211_FEATURE_HT_IBSS;
4429
4430     if (ISSUPP_RANDOM_MAC(adapter->fw_cap_info))
4431         wiphy->features |= NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR |
4432                    NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
4433                    NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
4434
4435     if (ISSUPP_TDLS_ENABLED(adapter->fw_cap_info))
4436         wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
4437
4438     if (adapter->fw_api_ver == MWIFIEX_FW_V15)
4439         wiphy->features |= NL80211_FEATURE_SK_TX_STATUS;
4440
4441     /* Reserve space for mwifiex specific private data for BSS */
4442     wiphy->bss_priv_size = sizeof(struct mwifiex_bss_priv);
4443
4444     wiphy->reg_notifier = mwifiex_reg_notifier;
4445
4446     /* Set struct mwifiex_adapter pointer in wiphy_priv */
4447     wdev_priv = wiphy_priv(wiphy);
4448     *(unsigned long *)wdev_priv = (unsigned long)adapter;
4449
4450     set_wiphy_dev(wiphy, priv->adapter->dev);
4451
4452     ret = wiphy_register(wiphy);
4453     if (ret < 0) {
4454         mwifiex_dbg(adapter, ERROR,
4455                 "%s: wiphy_register failed: %d\n", __func__, ret);
4456         wiphy_free(wiphy);
4457         return ret;
4458     }
4459
4460     if (!adapter->regd) {
4461         if (reg_alpha2 && mwifiex_is_valid_alpha2(reg_alpha2)) {
4462             mwifiex_dbg(adapter, INFO,
4463                     "driver hint alpha2: %2.2s\n", reg_alpha2);
4464             regulatory_hint(wiphy, reg_alpha2);
4465         } else {
4466             if (adapter->region_code == 0x00) {
4467                 mwifiex_dbg(adapter, WARN,
4468                         "Ignore world regulatory domain\n");
4469             } else {
4470                 wiphy->regulatory_flags |=
4471                     REGULATORY_DISABLE_BEACON_HINTS |
4472                     REGULATORY_COUNTRY_IE_IGNORE;
4473                 country_code =
4474                     mwifiex_11d_code_2_region(
4475                         adapter->region_code);
4476                 if (country_code &&
4477                     regulatory_hint(wiphy, country_code))
4478                     mwifiex_dbg(priv->adapter, ERROR,
4479                             "regulatory_hint() failed\n");
4480             }
4481         }
4482     }
4483
4484     mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
4485              HostCmd_ACT_GEN_GET, FRAG_THRESH_I, &thr, true);
4486     wiphy->frag_threshold = thr;
4487     mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
4488              HostCmd_ACT_GEN_GET, RTS_THRESH_I, &thr, true);
4489     wiphy->rts_threshold = thr;
4490     mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
4491              HostCmd_ACT_GEN_GET, SHORT_RETRY_LIM_I, &retry, true);
4492     wiphy->retry_short = (u8) retry;
4493     mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
4494              HostCmd_ACT_GEN_GET, LONG_RETRY_LIM_I, &retry, true);
4495     wiphy->retry_long = (u8) retry;
4496
4497     adapter->wiphy = wiphy;
4498     return ret;
4499 }