Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright(c) 2009-2012  Realtek Corporation.*/
0003 
0004 #include "../wifi.h"
0005 #include "../pci.h"
0006 #include "../base.h"
0007 #include "../stats.h"
0008 #include "reg.h"
0009 #include "def.h"
0010 #include "phy.h"
0011 #include "trx.h"
0012 #include "led.h"
0013 
0014 static u8 _rtl92de_map_hwqueue_to_fwqueue(struct sk_buff *skb, u8 hw_queue)
0015 {
0016     __le16 fc = rtl_get_fc(skb);
0017 
0018     if (unlikely(ieee80211_is_beacon(fc)))
0019         return QSLT_BEACON;
0020     if (ieee80211_is_mgmt(fc))
0021         return QSLT_MGNT;
0022 
0023     return skb->priority;
0024 }
0025 
0026 static long _rtl92de_translate_todbm(struct ieee80211_hw *hw,
0027                      u8 signal_strength_index)
0028 {
0029     long signal_power;
0030 
0031     signal_power = (long)((signal_strength_index + 1) >> 1);
0032     signal_power -= 95;
0033     return signal_power;
0034 }
0035 
0036 static void _rtl92de_query_rxphystatus(struct ieee80211_hw *hw,
0037                        struct rtl_stats *pstats,
0038                        struct rx_desc_92d *pdesc,
0039                        struct rx_fwinfo_92d *p_drvinfo,
0040                        bool packet_match_bssid,
0041                        bool packet_toself,
0042                        bool packet_beacon)
0043 {
0044     struct rtl_priv *rtlpriv = rtl_priv(hw);
0045     struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
0046     struct phy_sts_cck_8192d *cck_buf;
0047     s8 rx_pwr_all, rx_pwr[4];
0048     u8 rf_rx_num = 0, evm, pwdb_all;
0049     u8 i, max_spatial_stream;
0050     u32 rssi, total_rssi = 0;
0051     bool is_cck_rate;
0052 
0053     is_cck_rate = RX_HAL_IS_CCK_RATE(pdesc->rxmcs);
0054     pstats->packet_matchbssid = packet_match_bssid;
0055     pstats->packet_toself = packet_toself;
0056     pstats->packet_beacon = packet_beacon;
0057     pstats->is_cck = is_cck_rate;
0058     pstats->rx_mimo_sig_qual[0] = -1;
0059     pstats->rx_mimo_sig_qual[1] = -1;
0060 
0061     if (is_cck_rate) {
0062         u8 report, cck_highpwr;
0063         cck_buf = (struct phy_sts_cck_8192d *)p_drvinfo;
0064         if (ppsc->rfpwr_state == ERFON)
0065             cck_highpwr = (u8) rtl_get_bbreg(hw,
0066                          RFPGA0_XA_HSSIPARAMETER2,
0067                          BIT(9));
0068         else
0069             cck_highpwr = false;
0070         if (!cck_highpwr) {
0071             u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
0072             report = cck_buf->cck_agc_rpt & 0xc0;
0073             report = report >> 6;
0074             switch (report) {
0075             case 0x3:
0076                 rx_pwr_all = -46 - (cck_agc_rpt & 0x3e);
0077                 break;
0078             case 0x2:
0079                 rx_pwr_all = -26 - (cck_agc_rpt & 0x3e);
0080                 break;
0081             case 0x1:
0082                 rx_pwr_all = -12 - (cck_agc_rpt & 0x3e);
0083                 break;
0084             case 0x0:
0085                 rx_pwr_all = 16 - (cck_agc_rpt & 0x3e);
0086                 break;
0087             }
0088         } else {
0089             u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
0090             report = p_drvinfo->cfosho[0] & 0x60;
0091             report = report >> 5;
0092             switch (report) {
0093             case 0x3:
0094                 rx_pwr_all = -46 - ((cck_agc_rpt & 0x1f) << 1);
0095                 break;
0096             case 0x2:
0097                 rx_pwr_all = -26 - ((cck_agc_rpt & 0x1f) << 1);
0098                 break;
0099             case 0x1:
0100                 rx_pwr_all = -12 - ((cck_agc_rpt & 0x1f) << 1);
0101                 break;
0102             case 0x0:
0103                 rx_pwr_all = 16 - ((cck_agc_rpt & 0x1f) << 1);
0104                 break;
0105             }
0106         }
0107         pwdb_all = rtl_query_rxpwrpercentage(rx_pwr_all);
0108         /* CCK gain is smaller than OFDM/MCS gain,  */
0109         /* so we add gain diff by experiences, the val is 6 */
0110         pwdb_all += 6;
0111         if (pwdb_all > 100)
0112             pwdb_all = 100;
0113         /* modify the offset to make the same gain index with OFDM. */
0114         if (pwdb_all > 34 && pwdb_all <= 42)
0115             pwdb_all -= 2;
0116         else if (pwdb_all > 26 && pwdb_all <= 34)
0117             pwdb_all -= 6;
0118         else if (pwdb_all > 14 && pwdb_all <= 26)
0119             pwdb_all -= 8;
0120         else if (pwdb_all > 4 && pwdb_all <= 14)
0121             pwdb_all -= 4;
0122         pstats->rx_pwdb_all = pwdb_all;
0123         pstats->recvsignalpower = rx_pwr_all;
0124         if (packet_match_bssid) {
0125             u8 sq;
0126             if (pstats->rx_pwdb_all > 40) {
0127                 sq = 100;
0128             } else {
0129                 sq = cck_buf->sq_rpt;
0130                 if (sq > 64)
0131                     sq = 0;
0132                 else if (sq < 20)
0133                     sq = 100;
0134                 else
0135                     sq = ((64 - sq) * 100) / 44;
0136             }
0137             pstats->signalquality = sq;
0138             pstats->rx_mimo_sig_qual[0] = sq;
0139             pstats->rx_mimo_sig_qual[1] = -1;
0140         }
0141     } else {
0142         rtlpriv->dm.rfpath_rxenable[0] = true;
0143         rtlpriv->dm.rfpath_rxenable[1] = true;
0144         for (i = RF90_PATH_A; i < RF6052_MAX_PATH; i++) {
0145             if (rtlpriv->dm.rfpath_rxenable[i])
0146                 rf_rx_num++;
0147             rx_pwr[i] = ((p_drvinfo->gain_trsw[i] & 0x3f) * 2)
0148                     - 110;
0149             rssi = rtl_query_rxpwrpercentage(rx_pwr[i]);
0150             total_rssi += rssi;
0151             rtlpriv->stats.rx_snr_db[i] =
0152                      (long)(p_drvinfo->rxsnr[i] / 2);
0153             if (packet_match_bssid)
0154                 pstats->rx_mimo_signalstrength[i] = (u8) rssi;
0155         }
0156         rx_pwr_all = ((p_drvinfo->pwdb_all >> 1) & 0x7f) - 106;
0157         pwdb_all = rtl_query_rxpwrpercentage(rx_pwr_all);
0158         pstats->rx_pwdb_all = pwdb_all;
0159         pstats->rxpower = rx_pwr_all;
0160         pstats->recvsignalpower = rx_pwr_all;
0161         if (pdesc->rxht && pdesc->rxmcs >= DESC_RATEMCS8 &&
0162             pdesc->rxmcs <= DESC_RATEMCS15)
0163             max_spatial_stream = 2;
0164         else
0165             max_spatial_stream = 1;
0166         for (i = 0; i < max_spatial_stream; i++) {
0167             evm = rtl_evm_db_to_percentage(p_drvinfo->rxevm[i]);
0168             if (packet_match_bssid) {
0169                 if (i == 0)
0170                     pstats->signalquality =
0171                          (u8)(evm & 0xff);
0172                 pstats->rx_mimo_sig_qual[i] =
0173                          (u8)(evm & 0xff);
0174             }
0175         }
0176     }
0177     if (is_cck_rate)
0178         pstats->signalstrength = (u8)(rtl_signal_scale_mapping(hw,
0179                 pwdb_all));
0180     else if (rf_rx_num != 0)
0181         pstats->signalstrength = (u8)(rtl_signal_scale_mapping(hw,
0182                 total_rssi /= rf_rx_num));
0183 }
0184 
0185 static void rtl92d_loop_over_paths(struct ieee80211_hw *hw,
0186                    struct rtl_stats *pstats)
0187 {
0188     struct rtl_priv *rtlpriv = rtl_priv(hw);
0189     struct rtl_phy *rtlphy = &(rtlpriv->phy);
0190     u8 rfpath;
0191 
0192     for (rfpath = RF90_PATH_A; rfpath < rtlphy->num_total_rfpath;
0193          rfpath++) {
0194         if (rtlpriv->stats.rx_rssi_percentage[rfpath] == 0) {
0195             rtlpriv->stats.rx_rssi_percentage[rfpath] =
0196                 pstats->rx_mimo_signalstrength[rfpath];
0197 
0198         }
0199         if (pstats->rx_mimo_signalstrength[rfpath] >
0200             rtlpriv->stats.rx_rssi_percentage[rfpath]) {
0201             rtlpriv->stats.rx_rssi_percentage[rfpath] =
0202                 ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
0203                   (RX_SMOOTH_FACTOR - 1)) +
0204                  (pstats->rx_mimo_signalstrength[rfpath])) /
0205                 (RX_SMOOTH_FACTOR);
0206             rtlpriv->stats.rx_rssi_percentage[rfpath] =
0207                 rtlpriv->stats.rx_rssi_percentage[rfpath] + 1;
0208         } else {
0209             rtlpriv->stats.rx_rssi_percentage[rfpath] =
0210                 ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
0211                   (RX_SMOOTH_FACTOR - 1)) +
0212                  (pstats->rx_mimo_signalstrength[rfpath])) /
0213                 (RX_SMOOTH_FACTOR);
0214         }
0215     }
0216 }
0217 
0218 static void _rtl92de_process_ui_rssi(struct ieee80211_hw *hw,
0219                      struct rtl_stats *pstats)
0220 {
0221     struct rtl_priv *rtlpriv = rtl_priv(hw);
0222     u32 last_rssi, tmpval;
0223 
0224     if (pstats->packet_toself || pstats->packet_beacon) {
0225         rtlpriv->stats.rssi_calculate_cnt++;
0226         if (rtlpriv->stats.ui_rssi.total_num++ >=
0227             PHY_RSSI_SLID_WIN_MAX) {
0228             rtlpriv->stats.ui_rssi.total_num =
0229                          PHY_RSSI_SLID_WIN_MAX;
0230             last_rssi = rtlpriv->stats.ui_rssi.elements[
0231                 rtlpriv->stats.ui_rssi.index];
0232             rtlpriv->stats.ui_rssi.total_val -= last_rssi;
0233         }
0234         rtlpriv->stats.ui_rssi.total_val += pstats->signalstrength;
0235         rtlpriv->stats.ui_rssi.elements
0236             [rtlpriv->stats.ui_rssi.index++] =
0237             pstats->signalstrength;
0238         if (rtlpriv->stats.ui_rssi.index >= PHY_RSSI_SLID_WIN_MAX)
0239             rtlpriv->stats.ui_rssi.index = 0;
0240         tmpval = rtlpriv->stats.ui_rssi.total_val /
0241             rtlpriv->stats.ui_rssi.total_num;
0242         rtlpriv->stats.signal_strength = _rtl92de_translate_todbm(hw,
0243             (u8) tmpval);
0244         pstats->rssi = rtlpriv->stats.signal_strength;
0245     }
0246     if (!pstats->is_cck && pstats->packet_toself)
0247         rtl92d_loop_over_paths(hw, pstats);
0248 }
0249 
0250 static void _rtl92de_update_rxsignalstatistics(struct ieee80211_hw *hw,
0251                            struct rtl_stats *pstats)
0252 {
0253     struct rtl_priv *rtlpriv = rtl_priv(hw);
0254     int weighting = 0;
0255 
0256     if (rtlpriv->stats.recv_signal_power == 0)
0257         rtlpriv->stats.recv_signal_power = pstats->recvsignalpower;
0258     if (pstats->recvsignalpower > rtlpriv->stats.recv_signal_power)
0259         weighting = 5;
0260     else if (pstats->recvsignalpower < rtlpriv->stats.recv_signal_power)
0261         weighting = (-5);
0262     rtlpriv->stats.recv_signal_power = (rtlpriv->stats.recv_signal_power *
0263         5 + pstats->recvsignalpower + weighting) / 6;
0264 }
0265 
0266 static void _rtl92de_process_pwdb(struct ieee80211_hw *hw,
0267                   struct rtl_stats *pstats)
0268 {
0269     struct rtl_priv *rtlpriv = rtl_priv(hw);
0270     struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
0271     long undec_sm_pwdb;
0272 
0273     if (mac->opmode == NL80211_IFTYPE_ADHOC ||
0274         mac->opmode == NL80211_IFTYPE_AP)
0275         return;
0276     else
0277         undec_sm_pwdb = rtlpriv->dm.undec_sm_pwdb;
0278 
0279     if (pstats->packet_toself || pstats->packet_beacon) {
0280         if (undec_sm_pwdb < 0)
0281             undec_sm_pwdb = pstats->rx_pwdb_all;
0282         if (pstats->rx_pwdb_all > (u32) undec_sm_pwdb) {
0283             undec_sm_pwdb = (((undec_sm_pwdb) *
0284                   (RX_SMOOTH_FACTOR - 1)) +
0285                   (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
0286             undec_sm_pwdb = undec_sm_pwdb + 1;
0287         } else {
0288             undec_sm_pwdb = (((undec_sm_pwdb) *
0289                   (RX_SMOOTH_FACTOR - 1)) +
0290                   (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
0291         }
0292         rtlpriv->dm.undec_sm_pwdb = undec_sm_pwdb;
0293         _rtl92de_update_rxsignalstatistics(hw, pstats);
0294     }
0295 }
0296 
0297 static void rtl92d_loop_over_streams(struct ieee80211_hw *hw,
0298                      struct rtl_stats *pstats)
0299 {
0300     struct rtl_priv *rtlpriv = rtl_priv(hw);
0301     int stream;
0302 
0303     for (stream = 0; stream < 2; stream++) {
0304         if (pstats->rx_mimo_sig_qual[stream] != -1) {
0305             if (rtlpriv->stats.rx_evm_percentage[stream] == 0) {
0306                 rtlpriv->stats.rx_evm_percentage[stream] =
0307                     pstats->rx_mimo_sig_qual[stream];
0308             }
0309             rtlpriv->stats.rx_evm_percentage[stream] =
0310                 ((rtlpriv->stats.rx_evm_percentage[stream]
0311                   * (RX_SMOOTH_FACTOR - 1)) +
0312                  (pstats->rx_mimo_sig_qual[stream] * 1)) /
0313                 (RX_SMOOTH_FACTOR);
0314         }
0315     }
0316 }
0317 
0318 static void _rtl92de_process_ui_link_quality(struct ieee80211_hw *hw,
0319                          struct rtl_stats *pstats)
0320 {
0321     struct rtl_priv *rtlpriv = rtl_priv(hw);
0322     u32 last_evm, tmpval;
0323 
0324     if (pstats->signalquality == 0)
0325         return;
0326     if (pstats->packet_toself || pstats->packet_beacon) {
0327         if (rtlpriv->stats.ui_link_quality.total_num++ >=
0328             PHY_LINKQUALITY_SLID_WIN_MAX) {
0329             rtlpriv->stats.ui_link_quality.total_num =
0330                 PHY_LINKQUALITY_SLID_WIN_MAX;
0331             last_evm = rtlpriv->stats.ui_link_quality.elements[
0332                 rtlpriv->stats.ui_link_quality.index];
0333             rtlpriv->stats.ui_link_quality.total_val -= last_evm;
0334         }
0335         rtlpriv->stats.ui_link_quality.total_val +=
0336                          pstats->signalquality;
0337         rtlpriv->stats.ui_link_quality.elements[
0338             rtlpriv->stats.ui_link_quality.index++] =
0339                          pstats->signalquality;
0340         if (rtlpriv->stats.ui_link_quality.index >=
0341             PHY_LINKQUALITY_SLID_WIN_MAX)
0342             rtlpriv->stats.ui_link_quality.index = 0;
0343         tmpval = rtlpriv->stats.ui_link_quality.total_val /
0344             rtlpriv->stats.ui_link_quality.total_num;
0345         rtlpriv->stats.signal_quality = tmpval;
0346         rtlpriv->stats.last_sigstrength_inpercent = tmpval;
0347         rtl92d_loop_over_streams(hw, pstats);
0348     }
0349 }
0350 
0351 static void _rtl92de_process_phyinfo(struct ieee80211_hw *hw,
0352                      u8 *buffer,
0353                      struct rtl_stats *pcurrent_stats)
0354 {
0355 
0356     if (!pcurrent_stats->packet_matchbssid &&
0357         !pcurrent_stats->packet_beacon)
0358         return;
0359 
0360     _rtl92de_process_ui_rssi(hw, pcurrent_stats);
0361     _rtl92de_process_pwdb(hw, pcurrent_stats);
0362     _rtl92de_process_ui_link_quality(hw, pcurrent_stats);
0363 }
0364 
0365 static void _rtl92de_translate_rx_signal_stuff(struct ieee80211_hw *hw,
0366                            struct sk_buff *skb,
0367                            struct rtl_stats *pstats,
0368                            struct rx_desc_92d *pdesc,
0369                            struct rx_fwinfo_92d *p_drvinfo)
0370 {
0371     struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
0372     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0373     struct ieee80211_hdr *hdr;
0374     u8 *tmp_buf;
0375     u8 *praddr;
0376     u16 type, cfc;
0377     __le16 fc;
0378     bool packet_matchbssid, packet_toself, packet_beacon = false;
0379 
0380     tmp_buf = skb->data + pstats->rx_drvinfo_size + pstats->rx_bufshift;
0381     hdr = (struct ieee80211_hdr *)tmp_buf;
0382     fc = hdr->frame_control;
0383     cfc = le16_to_cpu(fc);
0384     type = WLAN_FC_GET_TYPE(fc);
0385     praddr = hdr->addr1;
0386     packet_matchbssid = ((IEEE80211_FTYPE_CTL != type) &&
0387          ether_addr_equal(mac->bssid,
0388                   (cfc & IEEE80211_FCTL_TODS) ? hdr->addr1 :
0389                   (cfc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 :
0390                   hdr->addr3) &&
0391          (!pstats->hwerror) && (!pstats->crc) && (!pstats->icv));
0392     packet_toself = packet_matchbssid &&
0393             ether_addr_equal(praddr, rtlefuse->dev_addr);
0394     if (ieee80211_is_beacon(fc))
0395         packet_beacon = true;
0396     _rtl92de_query_rxphystatus(hw, pstats, pdesc, p_drvinfo,
0397                    packet_matchbssid, packet_toself,
0398                    packet_beacon);
0399     _rtl92de_process_phyinfo(hw, tmp_buf, pstats);
0400 }
0401 
0402 bool rtl92de_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *stats,
0403         struct ieee80211_rx_status *rx_status,
0404         u8 *pdesc8, struct sk_buff *skb)
0405 {
0406     __le32 *pdesc = (__le32 *)pdesc8;
0407     struct rx_fwinfo_92d *p_drvinfo;
0408     u32 phystatus = get_rx_desc_physt(pdesc);
0409 
0410     stats->length = (u16)get_rx_desc_pkt_len(pdesc);
0411     stats->rx_drvinfo_size = (u8)get_rx_desc_drv_info_size(pdesc) *
0412                  RX_DRV_INFO_SIZE_UNIT;
0413     stats->rx_bufshift = (u8)(get_rx_desc_shift(pdesc) & 0x03);
0414     stats->icv = (u16)get_rx_desc_icv(pdesc);
0415     stats->crc = (u16)get_rx_desc_crc32(pdesc);
0416     stats->hwerror = (stats->crc | stats->icv);
0417     stats->decrypted = !get_rx_desc_swdec(pdesc);
0418     stats->rate = (u8)get_rx_desc_rxmcs(pdesc);
0419     stats->shortpreamble = (u16)get_rx_desc_splcp(pdesc);
0420     stats->isampdu = (bool)(get_rx_desc_paggr(pdesc) == 1);
0421     stats->isfirst_ampdu = (bool)((get_rx_desc_paggr(pdesc) == 1) &&
0422                       (get_rx_desc_faggr(pdesc) == 1));
0423     stats->timestamp_low = get_rx_desc_tsfl(pdesc);
0424     stats->rx_is40mhzpacket = (bool)get_rx_desc_bw(pdesc);
0425     stats->is_ht = (bool)get_rx_desc_rxht(pdesc);
0426     rx_status->freq = hw->conf.chandef.chan->center_freq;
0427     rx_status->band = hw->conf.chandef.chan->band;
0428     if (get_rx_desc_crc32(pdesc))
0429         rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
0430     if (!get_rx_desc_swdec(pdesc))
0431         rx_status->flag |= RX_FLAG_DECRYPTED;
0432     if (get_rx_desc_bw(pdesc))
0433         rx_status->bw = RATE_INFO_BW_40;
0434     if (get_rx_desc_rxht(pdesc))
0435         rx_status->encoding = RX_ENC_HT;
0436     rx_status->flag |= RX_FLAG_MACTIME_START;
0437     if (stats->decrypted)
0438         rx_status->flag |= RX_FLAG_DECRYPTED;
0439     rx_status->rate_idx = rtlwifi_rate_mapping(hw, stats->is_ht,
0440                            false, stats->rate);
0441     rx_status->mactime = get_rx_desc_tsfl(pdesc);
0442     if (phystatus) {
0443         p_drvinfo = (struct rx_fwinfo_92d *)(skb->data +
0444                              stats->rx_bufshift);
0445         _rtl92de_translate_rx_signal_stuff(hw,
0446                            skb, stats,
0447                            (struct rx_desc_92d *)pdesc,
0448                            p_drvinfo);
0449     }
0450     /*rx_status->qual = stats->signal; */
0451     rx_status->signal = stats->recvsignalpower + 10;
0452     return true;
0453 }
0454 
0455 static void _rtl92de_insert_emcontent(struct rtl_tcb_desc *ptcb_desc,
0456                       u8 *virtualaddress8)
0457 {
0458     __le32 *virtualaddress = (__le32 *)virtualaddress8;
0459 
0460     memset(virtualaddress, 0, 8);
0461 
0462     set_earlymode_pktnum(virtualaddress, ptcb_desc->empkt_num);
0463     set_earlymode_len0(virtualaddress, ptcb_desc->empkt_len[0]);
0464     set_earlymode_len1(virtualaddress, ptcb_desc->empkt_len[1]);
0465     set_earlymode_len2_1(virtualaddress, ptcb_desc->empkt_len[2] & 0xF);
0466     set_earlymode_len2_2(virtualaddress, ptcb_desc->empkt_len[2] >> 4);
0467     set_earlymode_len3(virtualaddress, ptcb_desc->empkt_len[3]);
0468     set_earlymode_len4(virtualaddress, ptcb_desc->empkt_len[4]);
0469 }
0470 
0471 void rtl92de_tx_fill_desc(struct ieee80211_hw *hw,
0472               struct ieee80211_hdr *hdr, u8 *pdesc8,
0473               u8 *pbd_desc_tx, struct ieee80211_tx_info *info,
0474               struct ieee80211_sta *sta,
0475               struct sk_buff *skb,
0476               u8 hw_queue, struct rtl_tcb_desc *ptcb_desc)
0477 {
0478     struct rtl_priv *rtlpriv = rtl_priv(hw);
0479     struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
0480     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0481     struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
0482     struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
0483     __le32 *pdesc = (__le32 *)pdesc8;
0484     u16 seq_number;
0485     __le16 fc = hdr->frame_control;
0486     unsigned int buf_len = 0;
0487     unsigned int skb_len = skb->len;
0488     u8 fw_qsel = _rtl92de_map_hwqueue_to_fwqueue(skb, hw_queue);
0489     bool firstseg = ((hdr->seq_ctrl &
0490             cpu_to_le16(IEEE80211_SCTL_FRAG)) == 0);
0491     bool lastseg = ((hdr->frame_control &
0492             cpu_to_le16(IEEE80211_FCTL_MOREFRAGS)) == 0);
0493     dma_addr_t mapping;
0494     u8 bw_40 = 0;
0495 
0496     if (mac->opmode == NL80211_IFTYPE_STATION) {
0497         bw_40 = mac->bw_40;
0498     } else if (mac->opmode == NL80211_IFTYPE_AP ||
0499         mac->opmode == NL80211_IFTYPE_ADHOC) {
0500         if (sta)
0501             bw_40 = sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40;
0502     }
0503     seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
0504     rtl_get_tcb_desc(hw, info, sta, skb, ptcb_desc);
0505     /* reserve 8 byte for AMPDU early mode */
0506     if (rtlhal->earlymode_enable) {
0507         skb_push(skb, EM_HDR_LEN);
0508         memset(skb->data, 0, EM_HDR_LEN);
0509     }
0510     buf_len = skb->len;
0511     mapping = dma_map_single(&rtlpci->pdev->dev, skb->data, skb->len,
0512                  DMA_TO_DEVICE);
0513     if (dma_mapping_error(&rtlpci->pdev->dev, mapping)) {
0514         rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0515             "DMA mapping error\n");
0516         return;
0517     }
0518     clear_pci_tx_desc_content(pdesc, sizeof(struct tx_desc_92d));
0519     if (ieee80211_is_nullfunc(fc) || ieee80211_is_ctl(fc)) {
0520         firstseg = true;
0521         lastseg = true;
0522     }
0523     if (firstseg) {
0524         if (rtlhal->earlymode_enable) {
0525             set_tx_desc_pkt_offset(pdesc, 1);
0526             set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN +
0527                        EM_HDR_LEN);
0528             if (ptcb_desc->empkt_num) {
0529                 rtl_dbg(rtlpriv, COMP_SEND, DBG_LOUD,
0530                     "Insert 8 byte.pTcb->EMPktNum:%d\n",
0531                     ptcb_desc->empkt_num);
0532                 _rtl92de_insert_emcontent(ptcb_desc,
0533                               (u8 *)(skb->data));
0534             }
0535         } else {
0536             set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
0537         }
0538         /* 5G have no CCK rate */
0539         if (rtlhal->current_bandtype == BAND_ON_5G)
0540             if (ptcb_desc->hw_rate < DESC_RATE6M)
0541                 ptcb_desc->hw_rate = DESC_RATE6M;
0542         set_tx_desc_tx_rate(pdesc, ptcb_desc->hw_rate);
0543         if (ptcb_desc->use_shortgi || ptcb_desc->use_shortpreamble)
0544             set_tx_desc_data_shortgi(pdesc, 1);
0545 
0546         if (rtlhal->macphymode == DUALMAC_DUALPHY &&
0547             ptcb_desc->hw_rate == DESC_RATEMCS7)
0548             set_tx_desc_data_shortgi(pdesc, 1);
0549 
0550         if (info->flags & IEEE80211_TX_CTL_AMPDU) {
0551             set_tx_desc_agg_enable(pdesc, 1);
0552             set_tx_desc_max_agg_num(pdesc, 0x14);
0553         }
0554         set_tx_desc_seq(pdesc, seq_number);
0555         set_tx_desc_rts_enable(pdesc,
0556                        ((ptcb_desc->rts_enable &&
0557                     !ptcb_desc->cts_enable) ? 1 : 0));
0558         set_tx_desc_hw_rts_enable(pdesc, ((ptcb_desc->rts_enable
0559                       || ptcb_desc->cts_enable) ? 1 : 0));
0560         set_tx_desc_cts2self(pdesc, ((ptcb_desc->cts_enable) ? 1 : 0));
0561         set_tx_desc_rts_stbc(pdesc, ((ptcb_desc->rts_stbc) ? 1 : 0));
0562         /* 5G have no CCK rate */
0563         if (rtlhal->current_bandtype == BAND_ON_5G)
0564             if (ptcb_desc->rts_rate < DESC_RATE6M)
0565                 ptcb_desc->rts_rate = DESC_RATE6M;
0566         set_tx_desc_rts_rate(pdesc, ptcb_desc->rts_rate);
0567         set_tx_desc_rts_bw(pdesc, 0);
0568         set_tx_desc_rts_sc(pdesc, ptcb_desc->rts_sc);
0569         set_tx_desc_rts_short(pdesc, ((ptcb_desc->rts_rate <=
0570             DESC_RATE54M) ?
0571             (ptcb_desc->rts_use_shortpreamble ? 1 : 0) :
0572             (ptcb_desc->rts_use_shortgi ? 1 : 0)));
0573         if (bw_40) {
0574             if (ptcb_desc->packet_bw) {
0575                 set_tx_desc_data_bw(pdesc, 1);
0576                 set_tx_desc_tx_sub_carrier(pdesc, 3);
0577             } else {
0578                 set_tx_desc_data_bw(pdesc, 0);
0579                 set_tx_desc_tx_sub_carrier(pdesc,
0580                             mac->cur_40_prime_sc);
0581             }
0582         } else {
0583             set_tx_desc_data_bw(pdesc, 0);
0584             set_tx_desc_tx_sub_carrier(pdesc, 0);
0585         }
0586         set_tx_desc_linip(pdesc, 0);
0587         set_tx_desc_pkt_size(pdesc, (u16)skb_len);
0588         if (sta) {
0589             u8 ampdu_density = sta->deflink.ht_cap.ampdu_density;
0590             set_tx_desc_ampdu_density(pdesc, ampdu_density);
0591         }
0592         if (info->control.hw_key) {
0593             struct ieee80211_key_conf *keyconf;
0594 
0595             keyconf = info->control.hw_key;
0596             switch (keyconf->cipher) {
0597             case WLAN_CIPHER_SUITE_WEP40:
0598             case WLAN_CIPHER_SUITE_WEP104:
0599             case WLAN_CIPHER_SUITE_TKIP:
0600                 set_tx_desc_sec_type(pdesc, 0x1);
0601                 break;
0602             case WLAN_CIPHER_SUITE_CCMP:
0603                 set_tx_desc_sec_type(pdesc, 0x3);
0604                 break;
0605             default:
0606                 set_tx_desc_sec_type(pdesc, 0x0);
0607                 break;
0608 
0609             }
0610         }
0611         set_tx_desc_pkt_id(pdesc, 0);
0612         set_tx_desc_queue_sel(pdesc, fw_qsel);
0613         set_tx_desc_data_rate_fb_limit(pdesc, 0x1F);
0614         set_tx_desc_rts_rate_fb_limit(pdesc, 0xF);
0615         set_tx_desc_disable_fb(pdesc, ptcb_desc->disable_ratefallback ?
0616                        1 : 0);
0617         set_tx_desc_use_rate(pdesc, ptcb_desc->use_driver_rate ? 1 : 0);
0618 
0619         /* Set TxRate and RTSRate in TxDesc  */
0620         /* This prevent Tx initial rate of new-coming packets */
0621         /* from being overwritten by retried  packet rate.*/
0622         if (!ptcb_desc->use_driver_rate) {
0623             set_tx_desc_rts_rate(pdesc, 0x08);
0624             /* set_tx_desc_tx_rate(pdesc, 0x0b); */
0625         }
0626         if (ieee80211_is_data_qos(fc)) {
0627             if (mac->rdg_en) {
0628                 rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0629                     "Enable RDG function\n");
0630                 set_tx_desc_rdg_enable(pdesc, 1);
0631                 set_tx_desc_htc(pdesc, 1);
0632             }
0633         }
0634     }
0635 
0636     set_tx_desc_first_seg(pdesc, (firstseg ? 1 : 0));
0637     set_tx_desc_last_seg(pdesc, (lastseg ? 1 : 0));
0638     set_tx_desc_tx_buffer_size(pdesc, (u16)buf_len);
0639     set_tx_desc_tx_buffer_address(pdesc, mapping);
0640     if (rtlpriv->dm.useramask) {
0641         set_tx_desc_rate_id(pdesc, ptcb_desc->ratr_index);
0642         set_tx_desc_macid(pdesc, ptcb_desc->mac_id);
0643     } else {
0644         set_tx_desc_rate_id(pdesc, 0xC + ptcb_desc->ratr_index);
0645         set_tx_desc_macid(pdesc, ptcb_desc->ratr_index);
0646     }
0647     if (ieee80211_is_data_qos(fc))
0648         set_tx_desc_qos(pdesc, 1);
0649 
0650     if ((!ieee80211_is_data_qos(fc)) && ppsc->fwctrl_lps) {
0651         set_tx_desc_hwseq_en(pdesc, 1);
0652         set_tx_desc_pkt_id(pdesc, 8);
0653     }
0654     set_tx_desc_more_frag(pdesc, (lastseg ? 0 : 1));
0655     rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE, "\n");
0656 }
0657 
0658 void rtl92de_tx_fill_cmddesc(struct ieee80211_hw *hw,
0659                  u8 *pdesc8, bool firstseg,
0660                  bool lastseg, struct sk_buff *skb)
0661 {
0662     struct rtl_priv *rtlpriv = rtl_priv(hw);
0663     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0664     struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
0665     struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
0666     u8 fw_queue = QSLT_BEACON;
0667 
0668     struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
0669     __le16 fc = hdr->frame_control;
0670     __le32 *pdesc = (__le32 *)pdesc8;
0671 
0672     dma_addr_t mapping = dma_map_single(&rtlpci->pdev->dev, skb->data,
0673                         skb->len, DMA_TO_DEVICE);
0674 
0675     if (dma_mapping_error(&rtlpci->pdev->dev, mapping)) {
0676         rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0677             "DMA mapping error\n");
0678         return;
0679     }
0680     clear_pci_tx_desc_content(pdesc, TX_DESC_SIZE);
0681     if (firstseg)
0682         set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
0683     /* 5G have no CCK rate
0684      * Caution: The macros below are multi-line expansions.
0685      * The braces are needed no matter what checkpatch says
0686      */
0687     if (rtlhal->current_bandtype == BAND_ON_5G) {
0688         set_tx_desc_tx_rate(pdesc, DESC_RATE6M);
0689     } else {
0690         set_tx_desc_tx_rate(pdesc, DESC_RATE1M);
0691     }
0692     set_tx_desc_seq(pdesc, 0);
0693     set_tx_desc_linip(pdesc, 0);
0694     set_tx_desc_queue_sel(pdesc, fw_queue);
0695     set_tx_desc_first_seg(pdesc, 1);
0696     set_tx_desc_last_seg(pdesc, 1);
0697     set_tx_desc_tx_buffer_size(pdesc, (u16)skb->len);
0698     set_tx_desc_tx_buffer_address(pdesc, mapping);
0699     set_tx_desc_rate_id(pdesc, 7);
0700     set_tx_desc_macid(pdesc, 0);
0701     set_tx_desc_pkt_size(pdesc, (u16)(skb->len));
0702     set_tx_desc_first_seg(pdesc, 1);
0703     set_tx_desc_last_seg(pdesc, 1);
0704     set_tx_desc_offset(pdesc, 0x20);
0705     set_tx_desc_use_rate(pdesc, 1);
0706 
0707     if (!ieee80211_is_data_qos(fc) && ppsc->fwctrl_lps) {
0708         set_tx_desc_hwseq_en(pdesc, 1);
0709         set_tx_desc_pkt_id(pdesc, 8);
0710     }
0711 
0712     RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD,
0713               "H2C Tx Cmd Content", pdesc, TX_DESC_SIZE);
0714     wmb();
0715     set_tx_desc_own(pdesc, 1);
0716 }
0717 
0718 void rtl92de_set_desc(struct ieee80211_hw *hw, u8 *pdesc8, bool istx,
0719               u8 desc_name, u8 *val)
0720 {
0721     __le32  *pdesc = (__le32 *)pdesc8;
0722 
0723     if (istx) {
0724         switch (desc_name) {
0725         case HW_DESC_OWN:
0726             wmb();
0727             set_tx_desc_own(pdesc, 1);
0728             break;
0729         case HW_DESC_TX_NEXTDESC_ADDR:
0730             set_tx_desc_next_desc_address(pdesc, *(u32 *)val);
0731             break;
0732         default:
0733             WARN_ONCE(true, "rtl8192de: ERR txdesc :%d not processed\n",
0734                   desc_name);
0735             break;
0736         }
0737     } else {
0738         switch (desc_name) {
0739         case HW_DESC_RXOWN:
0740             wmb();
0741             set_rx_desc_own(pdesc, 1);
0742             break;
0743         case HW_DESC_RXBUFF_ADDR:
0744             set_rx_desc_buff_addr(pdesc, *(u32 *)val);
0745             break;
0746         case HW_DESC_RXPKT_LEN:
0747             set_rx_desc_pkt_len(pdesc, *(u32 *)val);
0748             break;
0749         case HW_DESC_RXERO:
0750             set_rx_desc_eor(pdesc, 1);
0751             break;
0752         default:
0753             WARN_ONCE(true, "rtl8192de: ERR rxdesc :%d not processed\n",
0754                   desc_name);
0755             break;
0756         }
0757     }
0758 }
0759 
0760 u64 rtl92de_get_desc(struct ieee80211_hw *hw,
0761              u8 *p_desc8, bool istx, u8 desc_name)
0762 {
0763     __le32 *p_desc = (__le32 *)p_desc8;
0764     u32 ret = 0;
0765 
0766     if (istx) {
0767         switch (desc_name) {
0768         case HW_DESC_OWN:
0769             ret = get_tx_desc_own(p_desc);
0770             break;
0771         case HW_DESC_TXBUFF_ADDR:
0772             ret = get_tx_desc_tx_buffer_address(p_desc);
0773             break;
0774         default:
0775             WARN_ONCE(true, "rtl8192de: ERR txdesc :%d not processed\n",
0776                   desc_name);
0777             break;
0778         }
0779     } else {
0780         switch (desc_name) {
0781         case HW_DESC_OWN:
0782             ret = get_rx_desc_own(p_desc);
0783             break;
0784         case HW_DESC_RXPKT_LEN:
0785             ret = get_rx_desc_pkt_len(p_desc);
0786         break;
0787         case HW_DESC_RXBUFF_ADDR:
0788             ret = get_rx_desc_buff_addr(p_desc);
0789             break;
0790         default:
0791             WARN_ONCE(true, "rtl8192de: ERR rxdesc :%d not processed\n",
0792                   desc_name);
0793             break;
0794         }
0795     }
0796     return ret;
0797 }
0798 
0799 bool rtl92de_is_tx_desc_closed(struct ieee80211_hw *hw,
0800                    u8 hw_queue, u16 index)
0801 {
0802     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0803     struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[hw_queue];
0804     u8 *entry = (u8 *)(&ring->desc[ring->idx]);
0805     u8 own = (u8)rtl92de_get_desc(hw, entry, true, HW_DESC_OWN);
0806 
0807     /* a beacon packet will only use the first
0808      * descriptor by defaut, and the own bit may not
0809      * be cleared by the hardware
0810      */
0811     if (own)
0812         return false;
0813     return true;
0814 }
0815 
0816 void rtl92de_tx_polling(struct ieee80211_hw *hw, u8 hw_queue)
0817 {
0818     struct rtl_priv *rtlpriv = rtl_priv(hw);
0819     if (hw_queue == BEACON_QUEUE)
0820         rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG, BIT(4));
0821     else
0822         rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG,
0823                    BIT(0) << (hw_queue));
0824 }
[ 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!