Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
0002 /* Copyright(c) 2018-2019  Realtek Corporation
0003  */
0004 
0005 #include "main.h"
0006 #include "sec.h"
0007 #include "tx.h"
0008 #include "fw.h"
0009 #include "mac.h"
0010 #include "coex.h"
0011 #include "ps.h"
0012 #include "reg.h"
0013 #include "bf.h"
0014 #include "debug.h"
0015 #include "wow.h"
0016 #include "sar.h"
0017 
0018 static void rtw_ops_tx(struct ieee80211_hw *hw,
0019                struct ieee80211_tx_control *control,
0020                struct sk_buff *skb)
0021 {
0022     struct rtw_dev *rtwdev = hw->priv;
0023 
0024     if (!test_bit(RTW_FLAG_RUNNING, rtwdev->flags)) {
0025         ieee80211_free_txskb(hw, skb);
0026         return;
0027     }
0028 
0029     rtw_tx(rtwdev, control, skb);
0030 }
0031 
0032 static void rtw_ops_wake_tx_queue(struct ieee80211_hw *hw,
0033                   struct ieee80211_txq *txq)
0034 {
0035     struct rtw_dev *rtwdev = hw->priv;
0036     struct rtw_txq *rtwtxq = (struct rtw_txq *)txq->drv_priv;
0037 
0038     if (!test_bit(RTW_FLAG_RUNNING, rtwdev->flags))
0039         return;
0040 
0041     spin_lock_bh(&rtwdev->txq_lock);
0042     if (list_empty(&rtwtxq->list))
0043         list_add_tail(&rtwtxq->list, &rtwdev->txqs);
0044     spin_unlock_bh(&rtwdev->txq_lock);
0045 
0046     queue_work(rtwdev->tx_wq, &rtwdev->tx_work);
0047 }
0048 
0049 static int rtw_ops_start(struct ieee80211_hw *hw)
0050 {
0051     struct rtw_dev *rtwdev = hw->priv;
0052     int ret;
0053 
0054     mutex_lock(&rtwdev->mutex);
0055     ret = rtw_core_start(rtwdev);
0056     mutex_unlock(&rtwdev->mutex);
0057 
0058     return ret;
0059 }
0060 
0061 static void rtw_ops_stop(struct ieee80211_hw *hw)
0062 {
0063     struct rtw_dev *rtwdev = hw->priv;
0064 
0065     mutex_lock(&rtwdev->mutex);
0066     rtw_core_stop(rtwdev);
0067     mutex_unlock(&rtwdev->mutex);
0068 }
0069 
0070 static int rtw_ops_config(struct ieee80211_hw *hw, u32 changed)
0071 {
0072     struct rtw_dev *rtwdev = hw->priv;
0073     int ret = 0;
0074 
0075     /* let previous ips work finish to ensure we don't leave ips twice */
0076     cancel_work_sync(&rtwdev->ips_work);
0077 
0078     mutex_lock(&rtwdev->mutex);
0079 
0080     rtw_leave_lps_deep(rtwdev);
0081 
0082     if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
0083         !(hw->conf.flags & IEEE80211_CONF_IDLE)) {
0084         ret = rtw_leave_ips(rtwdev);
0085         if (ret) {
0086             rtw_err(rtwdev, "failed to leave idle state\n");
0087             goto out;
0088         }
0089     }
0090 
0091     if (changed & IEEE80211_CONF_CHANGE_PS) {
0092         if (hw->conf.flags & IEEE80211_CONF_PS) {
0093             rtwdev->ps_enabled = true;
0094         } else {
0095             rtwdev->ps_enabled = false;
0096             rtw_leave_lps(rtwdev);
0097         }
0098     }
0099 
0100     if (changed & IEEE80211_CONF_CHANGE_CHANNEL)
0101         rtw_set_channel(rtwdev);
0102 
0103     if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
0104         (hw->conf.flags & IEEE80211_CONF_IDLE))
0105         rtw_enter_ips(rtwdev);
0106 
0107 out:
0108     mutex_unlock(&rtwdev->mutex);
0109     return ret;
0110 }
0111 
0112 static const struct rtw_vif_port rtw_vif_port[] = {
0113     [0] = {
0114         .mac_addr   = {.addr = 0x0610},
0115         .bssid      = {.addr = 0x0618},
0116         .net_type   = {.addr = 0x0100, .mask = 0x30000},
0117         .aid        = {.addr = 0x06a8, .mask = 0x7ff},
0118         .bcn_ctrl   = {.addr = 0x0550, .mask = 0xff},
0119     },
0120     [1] = {
0121         .mac_addr   = {.addr = 0x0700},
0122         .bssid      = {.addr = 0x0708},
0123         .net_type   = {.addr = 0x0100, .mask = 0xc0000},
0124         .aid        = {.addr = 0x0710, .mask = 0x7ff},
0125         .bcn_ctrl   = {.addr = 0x0551, .mask = 0xff},
0126     },
0127     [2] = {
0128         .mac_addr   = {.addr = 0x1620},
0129         .bssid      = {.addr = 0x1628},
0130         .net_type   = {.addr = 0x1100, .mask = 0x3},
0131         .aid        = {.addr = 0x1600, .mask = 0x7ff},
0132         .bcn_ctrl   = {.addr = 0x0578, .mask = 0xff},
0133     },
0134     [3] = {
0135         .mac_addr   = {.addr = 0x1630},
0136         .bssid      = {.addr = 0x1638},
0137         .net_type   = {.addr = 0x1100, .mask = 0xc},
0138         .aid        = {.addr = 0x1604, .mask = 0x7ff},
0139         .bcn_ctrl   = {.addr = 0x0579, .mask = 0xff},
0140     },
0141     [4] = {
0142         .mac_addr   = {.addr = 0x1640},
0143         .bssid      = {.addr = 0x1648},
0144         .net_type   = {.addr = 0x1100, .mask = 0x30},
0145         .aid        = {.addr = 0x1608, .mask = 0x7ff},
0146         .bcn_ctrl   = {.addr = 0x057a, .mask = 0xff},
0147     },
0148 };
0149 
0150 static int rtw_ops_add_interface(struct ieee80211_hw *hw,
0151                  struct ieee80211_vif *vif)
0152 {
0153     struct rtw_dev *rtwdev = hw->priv;
0154     struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv;
0155     enum rtw_net_type net_type;
0156     u32 config = 0;
0157     u8 port = 0;
0158     u8 bcn_ctrl = 0;
0159 
0160     if (rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_BCN_FILTER))
0161         vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
0162                      IEEE80211_VIF_SUPPORTS_CQM_RSSI;
0163     rtwvif->port = port;
0164     rtwvif->stats.tx_unicast = 0;
0165     rtwvif->stats.rx_unicast = 0;
0166     rtwvif->stats.tx_cnt = 0;
0167     rtwvif->stats.rx_cnt = 0;
0168     rtwvif->scan_req = NULL;
0169     memset(&rtwvif->bfee, 0, sizeof(struct rtw_bfee));
0170     rtwvif->conf = &rtw_vif_port[port];
0171     rtw_txq_init(rtwdev, vif->txq);
0172     INIT_LIST_HEAD(&rtwvif->rsvd_page_list);
0173 
0174     mutex_lock(&rtwdev->mutex);
0175 
0176     rtw_leave_lps_deep(rtwdev);
0177 
0178     switch (vif->type) {
0179     case NL80211_IFTYPE_AP:
0180     case NL80211_IFTYPE_MESH_POINT:
0181         rtw_add_rsvd_page_bcn(rtwdev, rtwvif);
0182         net_type = RTW_NET_AP_MODE;
0183         bcn_ctrl = BIT_EN_BCN_FUNCTION | BIT_DIS_TSF_UDT;
0184         break;
0185     case NL80211_IFTYPE_ADHOC:
0186         rtw_add_rsvd_page_bcn(rtwdev, rtwvif);
0187         net_type = RTW_NET_AD_HOC;
0188         bcn_ctrl = BIT_EN_BCN_FUNCTION | BIT_DIS_TSF_UDT;
0189         break;
0190     case NL80211_IFTYPE_STATION:
0191         rtw_add_rsvd_page_sta(rtwdev, rtwvif);
0192         net_type = RTW_NET_NO_LINK;
0193         bcn_ctrl = BIT_EN_BCN_FUNCTION;
0194         break;
0195     default:
0196         WARN_ON(1);
0197         mutex_unlock(&rtwdev->mutex);
0198         return -EINVAL;
0199     }
0200 
0201     ether_addr_copy(rtwvif->mac_addr, vif->addr);
0202     config |= PORT_SET_MAC_ADDR;
0203     rtwvif->net_type = net_type;
0204     config |= PORT_SET_NET_TYPE;
0205     rtwvif->bcn_ctrl = bcn_ctrl;
0206     config |= PORT_SET_BCN_CTRL;
0207     rtw_vif_port_config(rtwdev, rtwvif, config);
0208 
0209     mutex_unlock(&rtwdev->mutex);
0210 
0211     rtw_dbg(rtwdev, RTW_DBG_STATE, "start vif %pM on port %d\n", vif->addr, rtwvif->port);
0212     return 0;
0213 }
0214 
0215 static void rtw_ops_remove_interface(struct ieee80211_hw *hw,
0216                      struct ieee80211_vif *vif)
0217 {
0218     struct rtw_dev *rtwdev = hw->priv;
0219     struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv;
0220     u32 config = 0;
0221 
0222     rtw_dbg(rtwdev, RTW_DBG_STATE, "stop vif %pM on port %d\n", vif->addr, rtwvif->port);
0223 
0224     mutex_lock(&rtwdev->mutex);
0225 
0226     rtw_leave_lps_deep(rtwdev);
0227 
0228     rtw_txq_cleanup(rtwdev, vif->txq);
0229     rtw_remove_rsvd_page(rtwdev, rtwvif);
0230 
0231     eth_zero_addr(rtwvif->mac_addr);
0232     config |= PORT_SET_MAC_ADDR;
0233     rtwvif->net_type = RTW_NET_NO_LINK;
0234     config |= PORT_SET_NET_TYPE;
0235     rtwvif->bcn_ctrl = 0;
0236     config |= PORT_SET_BCN_CTRL;
0237     rtw_vif_port_config(rtwdev, rtwvif, config);
0238 
0239     mutex_unlock(&rtwdev->mutex);
0240 }
0241 
0242 static int rtw_ops_change_interface(struct ieee80211_hw *hw,
0243                     struct ieee80211_vif *vif,
0244                     enum nl80211_iftype type, bool p2p)
0245 {
0246     struct rtw_dev *rtwdev = hw->priv;
0247 
0248     rtw_dbg(rtwdev, RTW_DBG_STATE, "change vif %pM (%d)->(%d), p2p (%d)->(%d)\n",
0249         vif->addr, vif->type, type, vif->p2p, p2p);
0250 
0251     rtw_ops_remove_interface(hw, vif);
0252 
0253     vif->type = type;
0254     vif->p2p = p2p;
0255 
0256     return rtw_ops_add_interface(hw, vif);
0257 }
0258 
0259 static void rtw_ops_configure_filter(struct ieee80211_hw *hw,
0260                      unsigned int changed_flags,
0261                      unsigned int *new_flags,
0262                      u64 multicast)
0263 {
0264     struct rtw_dev *rtwdev = hw->priv;
0265 
0266     *new_flags &= FIF_ALLMULTI | FIF_OTHER_BSS | FIF_FCSFAIL |
0267               FIF_BCN_PRBRESP_PROMISC;
0268 
0269     mutex_lock(&rtwdev->mutex);
0270 
0271     rtw_leave_lps_deep(rtwdev);
0272 
0273     if (changed_flags & FIF_ALLMULTI) {
0274         if (*new_flags & FIF_ALLMULTI)
0275             rtwdev->hal.rcr |= BIT_AM | BIT_AB;
0276         else
0277             rtwdev->hal.rcr &= ~(BIT_AM | BIT_AB);
0278     }
0279     if (changed_flags & FIF_FCSFAIL) {
0280         if (*new_flags & FIF_FCSFAIL)
0281             rtwdev->hal.rcr |= BIT_ACRC32;
0282         else
0283             rtwdev->hal.rcr &= ~(BIT_ACRC32);
0284     }
0285     if (changed_flags & FIF_OTHER_BSS) {
0286         if (*new_flags & FIF_OTHER_BSS)
0287             rtwdev->hal.rcr |= BIT_AAP;
0288         else
0289             rtwdev->hal.rcr &= ~(BIT_AAP);
0290     }
0291     if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
0292         if (*new_flags & FIF_BCN_PRBRESP_PROMISC)
0293             rtwdev->hal.rcr &= ~(BIT_CBSSID_BCN | BIT_CBSSID_DATA);
0294         else
0295             rtwdev->hal.rcr |= BIT_CBSSID_BCN;
0296     }
0297 
0298     rtw_dbg(rtwdev, RTW_DBG_RX,
0299         "config rx filter, changed=0x%08x, new=0x%08x, rcr=0x%08x\n",
0300         changed_flags, *new_flags, rtwdev->hal.rcr);
0301 
0302     rtw_write32(rtwdev, REG_RCR, rtwdev->hal.rcr);
0303 
0304     mutex_unlock(&rtwdev->mutex);
0305 }
0306 
0307 /* Only have one group of EDCA parameters now */
0308 static const u32 ac_to_edca_param[IEEE80211_NUM_ACS] = {
0309     [IEEE80211_AC_VO] = REG_EDCA_VO_PARAM,
0310     [IEEE80211_AC_VI] = REG_EDCA_VI_PARAM,
0311     [IEEE80211_AC_BE] = REG_EDCA_BE_PARAM,
0312     [IEEE80211_AC_BK] = REG_EDCA_BK_PARAM,
0313 };
0314 
0315 static u8 rtw_aifsn_to_aifs(struct rtw_dev *rtwdev,
0316                 struct rtw_vif *rtwvif, u8 aifsn)
0317 {
0318     struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif);
0319     u8 slot_time;
0320     u8 sifs;
0321 
0322     slot_time = vif->bss_conf.use_short_slot ? 9 : 20;
0323     sifs = rtwdev->hal.current_band_type == RTW_BAND_5G ? 16 : 10;
0324 
0325     return aifsn * slot_time + sifs;
0326 }
0327 
0328 static void __rtw_conf_tx(struct rtw_dev *rtwdev,
0329               struct rtw_vif *rtwvif, u16 ac)
0330 {
0331     struct ieee80211_tx_queue_params *params = &rtwvif->tx_params[ac];
0332     u32 edca_param = ac_to_edca_param[ac];
0333     u8 ecw_max, ecw_min;
0334     u8 aifs;
0335 
0336     /* 2^ecw - 1 = cw; ecw = log2(cw + 1) */
0337     ecw_max = ilog2(params->cw_max + 1);
0338     ecw_min = ilog2(params->cw_min + 1);
0339     aifs = rtw_aifsn_to_aifs(rtwdev, rtwvif, params->aifs);
0340     rtw_write32_mask(rtwdev, edca_param, BIT_MASK_TXOP_LMT, params->txop);
0341     rtw_write32_mask(rtwdev, edca_param, BIT_MASK_CWMAX, ecw_max);
0342     rtw_write32_mask(rtwdev, edca_param, BIT_MASK_CWMIN, ecw_min);
0343     rtw_write32_mask(rtwdev, edca_param, BIT_MASK_AIFS, aifs);
0344 }
0345 
0346 static void rtw_conf_tx(struct rtw_dev *rtwdev,
0347             struct rtw_vif *rtwvif)
0348 {
0349     u16 ac;
0350 
0351     for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
0352         __rtw_conf_tx(rtwdev, rtwvif, ac);
0353 }
0354 
0355 static void rtw_ops_bss_info_changed(struct ieee80211_hw *hw,
0356                      struct ieee80211_vif *vif,
0357                      struct ieee80211_bss_conf *conf,
0358                      u64 changed)
0359 {
0360     struct rtw_dev *rtwdev = hw->priv;
0361     struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv;
0362     struct rtw_coex *coex = &rtwdev->coex;
0363     struct rtw_coex_stat *coex_stat = &coex->stat;
0364     u32 config = 0;
0365 
0366     mutex_lock(&rtwdev->mutex);
0367 
0368     rtw_leave_lps_deep(rtwdev);
0369 
0370     if (changed & BSS_CHANGED_ASSOC) {
0371         rtw_vif_assoc_changed(rtwvif, conf);
0372         if (vif->cfg.assoc) {
0373             rtw_coex_connect_notify(rtwdev, COEX_ASSOCIATE_FINISH);
0374 
0375             rtw_fw_download_rsvd_page(rtwdev);
0376             rtw_send_rsvd_page_h2c(rtwdev);
0377             rtw_coex_media_status_notify(rtwdev, vif->cfg.assoc);
0378             if (rtw_bf_support)
0379                 rtw_bf_assoc(rtwdev, vif, conf);
0380             rtw_store_op_chan(rtwdev);
0381         } else {
0382             rtw_leave_lps(rtwdev);
0383             rtw_bf_disassoc(rtwdev, vif, conf);
0384             /* Abort ongoing scan if cancel_scan isn't issued
0385              * when disconnected by peer
0386              */
0387             if (test_bit(RTW_FLAG_SCANNING, rtwdev->flags))
0388                 rtw_hw_scan_abort(rtwdev, vif);
0389         }
0390 
0391         config |= PORT_SET_NET_TYPE;
0392         config |= PORT_SET_AID;
0393     }
0394 
0395     if (changed & BSS_CHANGED_BSSID) {
0396         ether_addr_copy(rtwvif->bssid, conf->bssid);
0397         config |= PORT_SET_BSSID;
0398     }
0399 
0400     if (changed & BSS_CHANGED_BEACON_INT) {
0401         if (ieee80211_vif_type_p2p(vif) == NL80211_IFTYPE_STATION)
0402             coex_stat->wl_beacon_interval = conf->beacon_int;
0403     }
0404 
0405     if (changed & BSS_CHANGED_BEACON) {
0406         rtw_set_dtim_period(rtwdev, conf->dtim_period);
0407         rtw_fw_download_rsvd_page(rtwdev);
0408     }
0409 
0410     if (changed & BSS_CHANGED_BEACON_ENABLED) {
0411         if (conf->enable_beacon)
0412             rtw_write32_set(rtwdev, REG_FWHW_TXQ_CTRL,
0413                     BIT_EN_BCNQ_DL);
0414         else
0415             rtw_write32_clr(rtwdev, REG_FWHW_TXQ_CTRL,
0416                     BIT_EN_BCNQ_DL);
0417     }
0418     if (changed & BSS_CHANGED_CQM)
0419         rtw_fw_beacon_filter_config(rtwdev, true, vif);
0420 
0421     if (changed & BSS_CHANGED_MU_GROUPS)
0422         rtw_chip_set_gid_table(rtwdev, vif, conf);
0423 
0424     if (changed & BSS_CHANGED_ERP_SLOT)
0425         rtw_conf_tx(rtwdev, rtwvif);
0426 
0427     rtw_vif_port_config(rtwdev, rtwvif, config);
0428 
0429     mutex_unlock(&rtwdev->mutex);
0430 }
0431 
0432 static int rtw_ops_start_ap(struct ieee80211_hw *hw,
0433                 struct ieee80211_vif *vif,
0434                 struct ieee80211_bss_conf *link_conf)
0435 {
0436     struct rtw_dev *rtwdev = hw->priv;
0437     struct rtw_chip_info *chip = rtwdev->chip;
0438 
0439     mutex_lock(&rtwdev->mutex);
0440     chip->ops->phy_calibration(rtwdev);
0441     mutex_unlock(&rtwdev->mutex);
0442 
0443     return 0;
0444 }
0445 
0446 static int rtw_ops_conf_tx(struct ieee80211_hw *hw,
0447                struct ieee80211_vif *vif,
0448                unsigned int link_id, u16 ac,
0449                const struct ieee80211_tx_queue_params *params)
0450 {
0451     struct rtw_dev *rtwdev = hw->priv;
0452     struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv;
0453 
0454     mutex_lock(&rtwdev->mutex);
0455 
0456     rtw_leave_lps_deep(rtwdev);
0457 
0458     rtwvif->tx_params[ac] = *params;
0459     __rtw_conf_tx(rtwdev, rtwvif, ac);
0460 
0461     mutex_unlock(&rtwdev->mutex);
0462 
0463     return 0;
0464 }
0465 
0466 static int rtw_ops_sta_add(struct ieee80211_hw *hw,
0467                struct ieee80211_vif *vif,
0468                struct ieee80211_sta *sta)
0469 {
0470     struct rtw_dev *rtwdev = hw->priv;
0471     int ret = 0;
0472 
0473     mutex_lock(&rtwdev->mutex);
0474     ret = rtw_sta_add(rtwdev, sta, vif);
0475     mutex_unlock(&rtwdev->mutex);
0476 
0477     return ret;
0478 }
0479 
0480 static int rtw_ops_sta_remove(struct ieee80211_hw *hw,
0481                   struct ieee80211_vif *vif,
0482                   struct ieee80211_sta *sta)
0483 {
0484     struct rtw_dev *rtwdev = hw->priv;
0485 
0486     rtw_fw_beacon_filter_config(rtwdev, false, vif);
0487     mutex_lock(&rtwdev->mutex);
0488     rtw_sta_remove(rtwdev, sta, true);
0489     mutex_unlock(&rtwdev->mutex);
0490 
0491     return 0;
0492 }
0493 
0494 static int rtw_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
0495                bool set)
0496 {
0497     struct rtw_dev *rtwdev = hw->priv;
0498 
0499     ieee80211_queue_work(hw, &rtwdev->update_beacon_work);
0500 
0501     return 0;
0502 }
0503 
0504 static int rtw_ops_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
0505                struct ieee80211_vif *vif, struct ieee80211_sta *sta,
0506                struct ieee80211_key_conf *key)
0507 {
0508     struct rtw_dev *rtwdev = hw->priv;
0509     struct rtw_sec_desc *sec = &rtwdev->sec;
0510     u8 hw_key_type;
0511     u8 hw_key_idx;
0512     int ret = 0;
0513 
0514     switch (key->cipher) {
0515     case WLAN_CIPHER_SUITE_WEP40:
0516         hw_key_type = RTW_CAM_WEP40;
0517         break;
0518     case WLAN_CIPHER_SUITE_WEP104:
0519         hw_key_type = RTW_CAM_WEP104;
0520         break;
0521     case WLAN_CIPHER_SUITE_TKIP:
0522         hw_key_type = RTW_CAM_TKIP;
0523         key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
0524         break;
0525     case WLAN_CIPHER_SUITE_CCMP:
0526         hw_key_type = RTW_CAM_AES;
0527         key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
0528         break;
0529     case WLAN_CIPHER_SUITE_AES_CMAC:
0530     case WLAN_CIPHER_SUITE_BIP_CMAC_256:
0531     case WLAN_CIPHER_SUITE_BIP_GMAC_128:
0532     case WLAN_CIPHER_SUITE_BIP_GMAC_256:
0533     case WLAN_CIPHER_SUITE_CCMP_256:
0534     case WLAN_CIPHER_SUITE_GCMP:
0535     case WLAN_CIPHER_SUITE_GCMP_256:
0536         /* suppress error messages */
0537         return -EOPNOTSUPP;
0538     default:
0539         return -ENOTSUPP;
0540     }
0541 
0542     mutex_lock(&rtwdev->mutex);
0543 
0544     rtw_leave_lps_deep(rtwdev);
0545 
0546     if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
0547         hw_key_idx = rtw_sec_get_free_cam(sec);
0548     } else {
0549         /* multiple interfaces? */
0550         hw_key_idx = key->keyidx;
0551     }
0552 
0553     if (hw_key_idx > sec->total_cam_num) {
0554         ret = -ENOSPC;
0555         goto out;
0556     }
0557 
0558     switch (cmd) {
0559     case SET_KEY:
0560         /* need sw generated IV */
0561         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
0562         key->hw_key_idx = hw_key_idx;
0563         rtw_sec_write_cam(rtwdev, sec, sta, key,
0564                   hw_key_type, hw_key_idx);
0565         break;
0566     case DISABLE_KEY:
0567         rtw_hci_flush_all_queues(rtwdev, false);
0568         rtw_mac_flush_all_queues(rtwdev, false);
0569         rtw_sec_clear_cam(rtwdev, sec, key->hw_key_idx);
0570         break;
0571     }
0572 
0573     /* download new cam settings for PG to backup */
0574     if (rtw_get_lps_deep_mode(rtwdev) == LPS_DEEP_MODE_PG)
0575         rtw_fw_download_rsvd_page(rtwdev);
0576 
0577 out:
0578     mutex_unlock(&rtwdev->mutex);
0579 
0580     return ret;
0581 }
0582 
0583 static int rtw_ops_ampdu_action(struct ieee80211_hw *hw,
0584                 struct ieee80211_vif *vif,
0585                 struct ieee80211_ampdu_params *params)
0586 {
0587     struct ieee80211_sta *sta = params->sta;
0588     u16 tid = params->tid;
0589     struct ieee80211_txq *txq = sta->txq[tid];
0590     struct rtw_txq *rtwtxq = (struct rtw_txq *)txq->drv_priv;
0591 
0592     switch (params->action) {
0593     case IEEE80211_AMPDU_TX_START:
0594         return IEEE80211_AMPDU_TX_START_IMMEDIATE;
0595     case IEEE80211_AMPDU_TX_STOP_CONT:
0596     case IEEE80211_AMPDU_TX_STOP_FLUSH:
0597     case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
0598         clear_bit(RTW_TXQ_AMPDU, &rtwtxq->flags);
0599         ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
0600         break;
0601     case IEEE80211_AMPDU_TX_OPERATIONAL:
0602         set_bit(RTW_TXQ_AMPDU, &rtwtxq->flags);
0603         break;
0604     case IEEE80211_AMPDU_RX_START:
0605     case IEEE80211_AMPDU_RX_STOP:
0606         break;
0607     default:
0608         WARN_ON(1);
0609         return -ENOTSUPP;
0610     }
0611 
0612     return 0;
0613 }
0614 
0615 static bool rtw_ops_can_aggregate_in_amsdu(struct ieee80211_hw *hw,
0616                        struct sk_buff *head,
0617                        struct sk_buff *skb)
0618 {
0619     struct rtw_dev *rtwdev = hw->priv;
0620     struct rtw_hal *hal = &rtwdev->hal;
0621 
0622     /* we don't want to enable TX AMSDU on 2.4G */
0623     if (hal->current_band_type == RTW_BAND_2G)
0624         return false;
0625 
0626     return true;
0627 }
0628 
0629 static void rtw_ops_sw_scan_start(struct ieee80211_hw *hw,
0630                   struct ieee80211_vif *vif,
0631                   const u8 *mac_addr)
0632 {
0633     struct rtw_dev *rtwdev = hw->priv;
0634     struct rtw_vif *rtwvif = (struct rtw_vif *)vif->drv_priv;
0635 
0636     mutex_lock(&rtwdev->mutex);
0637     rtw_core_scan_start(rtwdev, rtwvif, mac_addr, false);
0638     mutex_unlock(&rtwdev->mutex);
0639 }
0640 
0641 static void rtw_ops_sw_scan_complete(struct ieee80211_hw *hw,
0642                      struct ieee80211_vif *vif)
0643 {
0644     struct rtw_dev *rtwdev = hw->priv;
0645 
0646     mutex_lock(&rtwdev->mutex);
0647     rtw_core_scan_complete(rtwdev, vif, false);
0648     mutex_unlock(&rtwdev->mutex);
0649 }
0650 
0651 static void rtw_ops_mgd_prepare_tx(struct ieee80211_hw *hw,
0652                    struct ieee80211_vif *vif,
0653                    struct ieee80211_prep_tx_info *info)
0654 {
0655     struct rtw_dev *rtwdev = hw->priv;
0656 
0657     mutex_lock(&rtwdev->mutex);
0658     rtw_leave_lps_deep(rtwdev);
0659     rtw_coex_connect_notify(rtwdev, COEX_ASSOCIATE_START);
0660     rtw_chip_prepare_tx(rtwdev);
0661     mutex_unlock(&rtwdev->mutex);
0662 }
0663 
0664 static int rtw_ops_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
0665 {
0666     struct rtw_dev *rtwdev = hw->priv;
0667 
0668     mutex_lock(&rtwdev->mutex);
0669     rtwdev->rts_threshold = value;
0670     mutex_unlock(&rtwdev->mutex);
0671 
0672     return 0;
0673 }
0674 
0675 static void rtw_ops_sta_statistics(struct ieee80211_hw *hw,
0676                    struct ieee80211_vif *vif,
0677                    struct ieee80211_sta *sta,
0678                    struct station_info *sinfo)
0679 {
0680     struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv;
0681 
0682     sinfo->txrate = si->ra_report.txrate;
0683     sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
0684 }
0685 
0686 static void rtw_ops_flush(struct ieee80211_hw *hw,
0687               struct ieee80211_vif *vif,
0688               u32 queues, bool drop)
0689 {
0690     struct rtw_dev *rtwdev = hw->priv;
0691 
0692     mutex_lock(&rtwdev->mutex);
0693     rtw_leave_lps_deep(rtwdev);
0694 
0695     rtw_hci_flush_queues(rtwdev, queues, drop);
0696     rtw_mac_flush_queues(rtwdev, queues, drop);
0697     mutex_unlock(&rtwdev->mutex);
0698 }
0699 
0700 struct rtw_iter_bitrate_mask_data {
0701     struct rtw_dev *rtwdev;
0702     struct ieee80211_vif *vif;
0703     const struct cfg80211_bitrate_mask *mask;
0704 };
0705 
0706 static void rtw_ra_mask_info_update_iter(void *data, struct ieee80211_sta *sta)
0707 {
0708     struct rtw_iter_bitrate_mask_data *br_data = data;
0709     struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv;
0710 
0711     if (si->vif != br_data->vif)
0712         return;
0713 
0714     /* free previous mask setting */
0715     kfree(si->mask);
0716     si->mask = kmemdup(br_data->mask, sizeof(struct cfg80211_bitrate_mask),
0717                GFP_ATOMIC);
0718     if (!si->mask) {
0719         si->use_cfg_mask = false;
0720         return;
0721     }
0722 
0723     si->use_cfg_mask = true;
0724     rtw_update_sta_info(br_data->rtwdev, si, true);
0725 }
0726 
0727 static void rtw_ra_mask_info_update(struct rtw_dev *rtwdev,
0728                     struct ieee80211_vif *vif,
0729                     const struct cfg80211_bitrate_mask *mask)
0730 {
0731     struct rtw_iter_bitrate_mask_data br_data;
0732 
0733     br_data.rtwdev = rtwdev;
0734     br_data.vif = vif;
0735     br_data.mask = mask;
0736     rtw_iterate_stas_atomic(rtwdev, rtw_ra_mask_info_update_iter, &br_data);
0737 }
0738 
0739 static int rtw_ops_set_bitrate_mask(struct ieee80211_hw *hw,
0740                     struct ieee80211_vif *vif,
0741                     const struct cfg80211_bitrate_mask *mask)
0742 {
0743     struct rtw_dev *rtwdev = hw->priv;
0744 
0745     rtw_ra_mask_info_update(rtwdev, vif, mask);
0746 
0747     return 0;
0748 }
0749 
0750 static int rtw_ops_set_antenna(struct ieee80211_hw *hw,
0751                    u32 tx_antenna,
0752                    u32 rx_antenna)
0753 {
0754     struct rtw_dev *rtwdev = hw->priv;
0755     struct rtw_chip_info *chip = rtwdev->chip;
0756     int ret;
0757 
0758     if (!chip->ops->set_antenna)
0759         return -EOPNOTSUPP;
0760 
0761     mutex_lock(&rtwdev->mutex);
0762     ret = chip->ops->set_antenna(rtwdev, tx_antenna, rx_antenna);
0763     mutex_unlock(&rtwdev->mutex);
0764 
0765     return ret;
0766 }
0767 
0768 static int rtw_ops_get_antenna(struct ieee80211_hw *hw,
0769                    u32 *tx_antenna,
0770                    u32 *rx_antenna)
0771 {
0772     struct rtw_dev *rtwdev = hw->priv;
0773     struct rtw_hal *hal = &rtwdev->hal;
0774 
0775     *tx_antenna = hal->antenna_tx;
0776     *rx_antenna = hal->antenna_rx;
0777 
0778     return 0;
0779 }
0780 
0781 #ifdef CONFIG_PM
0782 static int rtw_ops_suspend(struct ieee80211_hw *hw,
0783                struct cfg80211_wowlan *wowlan)
0784 {
0785     struct rtw_dev *rtwdev = hw->priv;
0786     int ret;
0787 
0788     mutex_lock(&rtwdev->mutex);
0789     ret = rtw_wow_suspend(rtwdev, wowlan);
0790     if (ret)
0791         rtw_err(rtwdev, "failed to suspend for wow %d\n", ret);
0792     mutex_unlock(&rtwdev->mutex);
0793 
0794     return ret ? 1 : 0;
0795 }
0796 
0797 static int rtw_ops_resume(struct ieee80211_hw *hw)
0798 {
0799     struct rtw_dev *rtwdev = hw->priv;
0800     int ret;
0801 
0802     mutex_lock(&rtwdev->mutex);
0803     ret = rtw_wow_resume(rtwdev);
0804     if (ret)
0805         rtw_err(rtwdev, "failed to resume for wow %d\n", ret);
0806     mutex_unlock(&rtwdev->mutex);
0807 
0808     return ret ? 1 : 0;
0809 }
0810 
0811 static void rtw_ops_set_wakeup(struct ieee80211_hw *hw, bool enabled)
0812 {
0813     struct rtw_dev *rtwdev = hw->priv;
0814 
0815     device_set_wakeup_enable(rtwdev->dev, enabled);
0816 }
0817 #endif
0818 
0819 static void rtw_reconfig_complete(struct ieee80211_hw *hw,
0820                   enum ieee80211_reconfig_type reconfig_type)
0821 {
0822     struct rtw_dev *rtwdev = hw->priv;
0823 
0824     mutex_lock(&rtwdev->mutex);
0825     if (reconfig_type == IEEE80211_RECONFIG_TYPE_RESTART)
0826         clear_bit(RTW_FLAG_RESTARTING, rtwdev->flags);
0827     mutex_unlock(&rtwdev->mutex);
0828 }
0829 
0830 static int rtw_ops_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
0831                struct ieee80211_scan_request *req)
0832 {
0833     struct rtw_dev *rtwdev = hw->priv;
0834     int ret;
0835 
0836     if (!rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_SCAN_OFFLOAD))
0837         return 1;
0838 
0839     if (test_bit(RTW_FLAG_SCANNING, rtwdev->flags))
0840         return -EBUSY;
0841 
0842     mutex_lock(&rtwdev->mutex);
0843     rtw_hw_scan_start(rtwdev, vif, req);
0844     ret = rtw_hw_scan_offload(rtwdev, vif, true);
0845     if (ret) {
0846         rtw_hw_scan_abort(rtwdev, vif);
0847         rtw_err(rtwdev, "HW scan failed with status: %d\n", ret);
0848     }
0849     mutex_unlock(&rtwdev->mutex);
0850 
0851     return ret;
0852 }
0853 
0854 static void rtw_ops_cancel_hw_scan(struct ieee80211_hw *hw,
0855                    struct ieee80211_vif *vif)
0856 {
0857     struct rtw_dev *rtwdev = hw->priv;
0858 
0859     if (!rtw_fw_feature_check(&rtwdev->fw, FW_FEATURE_SCAN_OFFLOAD))
0860         return;
0861 
0862     if (!test_bit(RTW_FLAG_SCANNING, rtwdev->flags))
0863         return;
0864 
0865     mutex_lock(&rtwdev->mutex);
0866     rtw_hw_scan_abort(rtwdev, vif);
0867     mutex_unlock(&rtwdev->mutex);
0868 }
0869 
0870 static int rtw_ops_set_sar_specs(struct ieee80211_hw *hw,
0871                  const struct cfg80211_sar_specs *sar)
0872 {
0873     struct rtw_dev *rtwdev = hw->priv;
0874 
0875     rtw_set_sar_specs(rtwdev, sar);
0876 
0877     return 0;
0878 }
0879 
0880 static void rtw_ops_sta_rc_update(struct ieee80211_hw *hw,
0881                   struct ieee80211_vif *vif,
0882                   struct ieee80211_sta *sta, u32 changed)
0883 {
0884     struct rtw_dev *rtwdev = hw->priv;
0885     struct rtw_sta_info *si = (struct rtw_sta_info *)sta->drv_priv;
0886 
0887     if (changed & IEEE80211_RC_BW_CHANGED)
0888         rtw_update_sta_info(rtwdev, si, true);
0889 }
0890 
0891 const struct ieee80211_ops rtw_ops = {
0892     .tx         = rtw_ops_tx,
0893     .wake_tx_queue      = rtw_ops_wake_tx_queue,
0894     .start          = rtw_ops_start,
0895     .stop           = rtw_ops_stop,
0896     .config         = rtw_ops_config,
0897     .add_interface      = rtw_ops_add_interface,
0898     .remove_interface   = rtw_ops_remove_interface,
0899     .change_interface   = rtw_ops_change_interface,
0900     .configure_filter   = rtw_ops_configure_filter,
0901     .bss_info_changed   = rtw_ops_bss_info_changed,
0902     .start_ap       = rtw_ops_start_ap,
0903     .conf_tx        = rtw_ops_conf_tx,
0904     .sta_add        = rtw_ops_sta_add,
0905     .sta_remove     = rtw_ops_sta_remove,
0906     .set_tim        = rtw_ops_set_tim,
0907     .set_key        = rtw_ops_set_key,
0908     .ampdu_action       = rtw_ops_ampdu_action,
0909     .can_aggregate_in_amsdu = rtw_ops_can_aggregate_in_amsdu,
0910     .sw_scan_start      = rtw_ops_sw_scan_start,
0911     .sw_scan_complete   = rtw_ops_sw_scan_complete,
0912     .mgd_prepare_tx     = rtw_ops_mgd_prepare_tx,
0913     .set_rts_threshold  = rtw_ops_set_rts_threshold,
0914     .sta_statistics     = rtw_ops_sta_statistics,
0915     .flush          = rtw_ops_flush,
0916     .set_bitrate_mask   = rtw_ops_set_bitrate_mask,
0917     .set_antenna        = rtw_ops_set_antenna,
0918     .get_antenna        = rtw_ops_get_antenna,
0919     .reconfig_complete  = rtw_reconfig_complete,
0920     .hw_scan        = rtw_ops_hw_scan,
0921     .cancel_hw_scan     = rtw_ops_cancel_hw_scan,
0922     .sta_rc_update      = rtw_ops_sta_rc_update,
0923     .set_sar_specs          = rtw_ops_set_sar_specs,
0924 #ifdef CONFIG_PM
0925     .suspend        = rtw_ops_suspend,
0926     .resume         = rtw_ops_resume,
0927     .set_wakeup     = rtw_ops_set_wakeup,
0928 #endif
0929 };
0930 EXPORT_SYMBOL(rtw_ops);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!