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 _rtl8723e_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) || ieee80211_is_ctl(fc))
0021         return QSLT_MGNT;
0022 
0023     return skb->priority;
0024 }
0025 
0026 static void _rtl8723e_query_rxphystatus(struct ieee80211_hw *hw,
0027                     struct rtl_stats *pstatus, u8 *pdesc,
0028                     struct rx_fwinfo_8723e *p_drvinfo,
0029                     bool bpacket_match_bssid,
0030                     bool bpacket_toself, bool packet_beacon)
0031 {
0032     struct rtl_priv *rtlpriv = rtl_priv(hw);
0033     struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
0034     struct phy_sts_cck_8723e_t *cck_buf;
0035     s8 rx_pwr_all = 0, rx_pwr[4];
0036     u8 rf_rx_num = 0, evm, pwdb_all;
0037     u8 i, max_spatial_stream;
0038     u32 rssi, total_rssi = 0;
0039     bool is_cck = pstatus->is_cck;
0040 
0041     /* Record it for next packet processing */
0042     pstatus->packet_matchbssid = bpacket_match_bssid;
0043     pstatus->packet_toself = bpacket_toself;
0044     pstatus->packet_beacon = packet_beacon;
0045     pstatus->rx_mimo_signalquality[0] = -1;
0046     pstatus->rx_mimo_signalquality[1] = -1;
0047 
0048     if (is_cck) {
0049         u8 report, cck_highpwr;
0050 
0051         /* CCK Driver info Structure is not the same as OFDM packet. */
0052         cck_buf = (struct phy_sts_cck_8723e_t *)p_drvinfo;
0053 
0054         /* (1)Hardware does not provide RSSI for CCK */
0055         /* (2)PWDB, Average PWDB calculated by
0056          * hardware (for rate adaptive)
0057          */
0058         if (ppsc->rfpwr_state == ERFON)
0059             cck_highpwr = (u8)rtl_get_bbreg(hw,
0060                     RFPGA0_XA_HSSIPARAMETER2,
0061                     BIT(9));
0062         else
0063             cck_highpwr = false;
0064 
0065         if (!cck_highpwr) {
0066             u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
0067             report = cck_buf->cck_agc_rpt & 0xc0;
0068             report = report >> 6;
0069             switch (report) {
0070             case 0x3:
0071                 rx_pwr_all = -46 - (cck_agc_rpt & 0x3e);
0072                 break;
0073             case 0x2:
0074                 rx_pwr_all = -26 - (cck_agc_rpt & 0x3e);
0075                 break;
0076             case 0x1:
0077                 rx_pwr_all = -12 - (cck_agc_rpt & 0x3e);
0078                 break;
0079             case 0x0:
0080                 rx_pwr_all = 16 - (cck_agc_rpt & 0x3e);
0081                 break;
0082             }
0083         } else {
0084             u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
0085             report = p_drvinfo->cfosho[0] & 0x60;
0086             report = report >> 5;
0087             switch (report) {
0088             case 0x3:
0089                 rx_pwr_all = -46 - ((cck_agc_rpt & 0x1f) << 1);
0090                 break;
0091             case 0x2:
0092                 rx_pwr_all = -26 - ((cck_agc_rpt & 0x1f) << 1);
0093                 break;
0094             case 0x1:
0095                 rx_pwr_all = -12 - ((cck_agc_rpt & 0x1f) << 1);
0096                 break;
0097             case 0x0:
0098                 rx_pwr_all = 16 - ((cck_agc_rpt & 0x1f) << 1);
0099                 break;
0100             }
0101         }
0102 
0103         pwdb_all = rtl_query_rxpwrpercentage(rx_pwr_all);
0104         /* CCK gain is smaller than OFDM/MCS gain,  */
0105         /* so we add gain diff by experiences,
0106          * the val is 6
0107          */
0108         pwdb_all += 6;
0109         if (pwdb_all > 100)
0110             pwdb_all = 100;
0111         /* modify the offset to make the same
0112          * gain index with OFDM.
0113          */
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 
0123         pstatus->rx_pwdb_all = pwdb_all;
0124         pstatus->recvsignalpower = rx_pwr_all;
0125 
0126         /* (3) Get Signal Quality (EVM) */
0127         if (bpacket_match_bssid) {
0128             u8 sq;
0129 
0130             if (pstatus->rx_pwdb_all > 40)
0131                 sq = 100;
0132             else {
0133                 sq = cck_buf->sq_rpt;
0134                 if (sq > 64)
0135                     sq = 0;
0136                 else if (sq < 20)
0137                     sq = 100;
0138                 else
0139                     sq = ((64 - sq) * 100) / 44;
0140             }
0141 
0142             pstatus->signalquality = sq;
0143             pstatus->rx_mimo_signalquality[0] = sq;
0144             pstatus->rx_mimo_signalquality[1] = -1;
0145         }
0146     } else {
0147         rtlpriv->dm.rfpath_rxenable[0] =
0148             rtlpriv->dm.rfpath_rxenable[1] = true;
0149 
0150         /* (1)Get RSSI for HT rate */
0151         for (i = RF90_PATH_A; i < RF6052_MAX_PATH; i++) {
0152 
0153             /* we will judge RF RX path now. */
0154             if (rtlpriv->dm.rfpath_rxenable[i])
0155                 rf_rx_num++;
0156 
0157             rx_pwr[i] = ((p_drvinfo->gain_trsw[i] &
0158                       0x3f) * 2) - 110;
0159 
0160             /* Translate DBM to percentage. */
0161             rssi = rtl_query_rxpwrpercentage(rx_pwr[i]);
0162             total_rssi += rssi;
0163 
0164             /* Get Rx snr value in DB */
0165             rtlpriv->stats.rx_snr_db[i] =
0166                 (long)(p_drvinfo->rxsnr[i] / 2);
0167 
0168             /* Record Signal Strength for next packet */
0169             if (bpacket_match_bssid)
0170                 pstatus->rx_mimo_signalstrength[i] = (u8)rssi;
0171         }
0172 
0173         /* (2)PWDB, Average PWDB calculated by
0174          * hardware (for rate adaptive)
0175          */
0176         rx_pwr_all = ((p_drvinfo->pwdb_all >> 1) & 0x7f) - 110;
0177 
0178         pwdb_all = rtl_query_rxpwrpercentage(rx_pwr_all);
0179         pstatus->rx_pwdb_all = pwdb_all;
0180         pstatus->rxpower = rx_pwr_all;
0181         pstatus->recvsignalpower = rx_pwr_all;
0182 
0183         /* (3)EVM of HT rate */
0184         if (pstatus->is_ht && pstatus->rate >= DESC92C_RATEMCS8 &&
0185             pstatus->rate <= DESC92C_RATEMCS15)
0186             max_spatial_stream = 2;
0187         else
0188             max_spatial_stream = 1;
0189 
0190         for (i = 0; i < max_spatial_stream; i++) {
0191             evm = rtl_evm_db_to_percentage(p_drvinfo->rxevm[i]);
0192 
0193             if (bpacket_match_bssid) {
0194                 /* Fill value in RFD, Get the first
0195                  * spatial stream only
0196                  */
0197                 if (i == 0)
0198                     pstatus->signalquality =
0199                         (u8)(evm & 0xff);
0200                 pstatus->rx_mimo_signalquality[i] =
0201                     (u8)(evm & 0xff);
0202             }
0203         }
0204     }
0205 
0206     /* UI BSS List signal strength(in percentage),
0207      * make it good looking, from 0~100.
0208      */
0209     if (is_cck)
0210         pstatus->signalstrength = (u8)(rtl_signal_scale_mapping(hw,
0211             pwdb_all));
0212     else if (rf_rx_num != 0)
0213         pstatus->signalstrength = (u8)(rtl_signal_scale_mapping(hw,
0214             total_rssi /= rf_rx_num));
0215 }
0216 
0217 static void translate_rx_signal_stuff(struct ieee80211_hw *hw,
0218                       struct sk_buff *skb,
0219                       struct rtl_stats *pstatus, u8 *pdesc,
0220                       struct rx_fwinfo_8723e *p_drvinfo)
0221 {
0222     struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
0223     struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
0224     struct ieee80211_hdr *hdr;
0225     u8 *tmp_buf;
0226     u8 *praddr;
0227     /*u8 *psaddr;*/
0228     u16 fc, type;
0229     bool packet_matchbssid, packet_toself, packet_beacon;
0230 
0231     tmp_buf = skb->data + pstatus->rx_drvinfo_size + pstatus->rx_bufshift;
0232 
0233     hdr = (struct ieee80211_hdr *)tmp_buf;
0234     fc = le16_to_cpu(hdr->frame_control);
0235     type = WLAN_FC_GET_TYPE(hdr->frame_control);
0236     praddr = hdr->addr1;
0237 
0238     packet_matchbssid = ((IEEE80211_FTYPE_CTL != type) &&
0239         (ether_addr_equal(mac->bssid, (fc & IEEE80211_FCTL_TODS) ?
0240          hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS) ?
0241          hdr->addr2 : hdr->addr3)) &&
0242          (!pstatus->hwerror) &&
0243          (!pstatus->crc) && (!pstatus->icv));
0244 
0245     packet_toself = packet_matchbssid &&
0246         (ether_addr_equal(praddr, rtlefuse->dev_addr));
0247 
0248     if (ieee80211_is_beacon(hdr->frame_control))
0249         packet_beacon = true;
0250     else
0251         packet_beacon = false;
0252 
0253     _rtl8723e_query_rxphystatus(hw, pstatus, pdesc, p_drvinfo,
0254                     packet_matchbssid, packet_toself,
0255                     packet_beacon);
0256 
0257     rtl_process_phyinfo(hw, tmp_buf, pstatus);
0258 }
0259 
0260 bool rtl8723e_rx_query_desc(struct ieee80211_hw *hw,
0261                 struct rtl_stats *status,
0262                 struct ieee80211_rx_status *rx_status,
0263                 u8 *pdesc8, struct sk_buff *skb)
0264 {
0265     struct rx_fwinfo_8723e *p_drvinfo;
0266     struct ieee80211_hdr *hdr;
0267     __le32 *pdesc = (__le32 *)pdesc8;
0268     u32 phystatus = get_rx_desc_physt(pdesc);
0269 
0270     status->length = (u16)get_rx_desc_pkt_len(pdesc);
0271     status->rx_drvinfo_size = (u8)get_rx_desc_drv_info_size(pdesc) *
0272         RX_DRV_INFO_SIZE_UNIT;
0273     status->rx_bufshift = (u8)(get_rx_desc_shift(pdesc) & 0x03);
0274     status->icv = (u16)get_rx_desc_icv(pdesc);
0275     status->crc = (u16)get_rx_desc_crc32(pdesc);
0276     status->hwerror = (status->crc | status->icv);
0277     status->decrypted = !get_rx_desc_swdec(pdesc);
0278     status->rate = (u8)get_rx_desc_rxmcs(pdesc);
0279     status->shortpreamble = (u16)get_rx_desc_splcp(pdesc);
0280     status->isampdu = (bool)(get_rx_desc_paggr(pdesc) == 1);
0281     status->isfirst_ampdu = (bool)((get_rx_desc_paggr(pdesc) == 1) &&
0282                        (get_rx_desc_faggr(pdesc) == 1));
0283     status->timestamp_low = get_rx_desc_tsfl(pdesc);
0284     status->rx_is40mhzpacket = (bool)get_rx_desc_bw(pdesc);
0285     status->is_ht = (bool)get_rx_desc_rxht(pdesc);
0286 
0287     status->is_cck = RX_HAL_IS_CCK_RATE(status->rate);
0288 
0289     rx_status->freq = hw->conf.chandef.chan->center_freq;
0290     rx_status->band = hw->conf.chandef.chan->band;
0291 
0292     hdr = (struct ieee80211_hdr *)(skb->data + status->rx_drvinfo_size
0293             + status->rx_bufshift);
0294 
0295     if (status->crc)
0296         rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
0297 
0298     if (status->rx_is40mhzpacket)
0299         rx_status->bw = RATE_INFO_BW_40;
0300 
0301     if (status->is_ht)
0302         rx_status->encoding = RX_ENC_HT;
0303 
0304     rx_status->flag |= RX_FLAG_MACTIME_START;
0305 
0306     /* hw will set status->decrypted true, if it finds the
0307      * frame is open data frame or mgmt frame.
0308      * So hw will not decryption robust managment frame
0309      * for IEEE80211w but still set status->decrypted
0310      * true, so here we should set it back to undecrypted
0311      * for IEEE80211w frame, and mac80211 sw will help
0312      * to decrypt it
0313      */
0314     if (status->decrypted) {
0315         if ((!_ieee80211_is_robust_mgmt_frame(hdr)) &&
0316             (ieee80211_has_protected(hdr->frame_control)))
0317             rx_status->flag |= RX_FLAG_DECRYPTED;
0318         else
0319             rx_status->flag &= ~RX_FLAG_DECRYPTED;
0320     }
0321 
0322     /* rate_idx: index of data rate into band's
0323      * supported rates or MCS index if HT rates
0324      * are use (RX_FLAG_HT)
0325      * Notice: this is diff with windows define
0326      */
0327     rx_status->rate_idx = rtlwifi_rate_mapping(hw, status->is_ht,
0328                            false, status->rate);
0329 
0330     rx_status->mactime = status->timestamp_low;
0331     if (phystatus == true) {
0332         p_drvinfo = (struct rx_fwinfo_8723e *)(skb->data +
0333                              status->rx_bufshift);
0334 
0335         translate_rx_signal_stuff(hw, skb, status, pdesc8, p_drvinfo);
0336     }
0337     rx_status->signal = status->recvsignalpower + 10;
0338     return true;
0339 }
0340 
0341 void rtl8723e_tx_fill_desc(struct ieee80211_hw *hw,
0342                struct ieee80211_hdr *hdr, u8 *pdesc_tx,
0343                u8 *txbd, struct ieee80211_tx_info *info,
0344                struct ieee80211_sta *sta,
0345                struct sk_buff *skb,
0346                u8 hw_queue, struct rtl_tcb_desc *ptcb_desc)
0347 {
0348     struct rtl_priv *rtlpriv = rtl_priv(hw);
0349     struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
0350     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0351     struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
0352     bool b_defaultadapter = true;
0353     /* bool b_trigger_ac = false; */
0354     u8 *pdesc8 = (u8 *)pdesc_tx;
0355     __le32 *pdesc = (__le32 *)pdesc8;
0356     u16 seq_number;
0357     __le16 fc = hdr->frame_control;
0358     u8 fw_qsel = _rtl8723e_map_hwqueue_to_fwqueue(skb, hw_queue);
0359     bool firstseg = ((hdr->seq_ctrl &
0360               cpu_to_le16(IEEE80211_SCTL_FRAG)) == 0);
0361 
0362     bool lastseg = ((hdr->frame_control &
0363              cpu_to_le16(IEEE80211_FCTL_MOREFRAGS)) == 0);
0364 
0365     dma_addr_t mapping = dma_map_single(&rtlpci->pdev->dev, skb->data,
0366                         skb->len, DMA_TO_DEVICE);
0367     u8 bw_40 = 0;
0368 
0369     if (dma_mapping_error(&rtlpci->pdev->dev, mapping)) {
0370         rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0371             "DMA mapping error\n");
0372         return;
0373     }
0374     if (mac->opmode == NL80211_IFTYPE_STATION) {
0375         bw_40 = mac->bw_40;
0376     } else if (mac->opmode == NL80211_IFTYPE_AP ||
0377         mac->opmode == NL80211_IFTYPE_ADHOC) {
0378         if (sta)
0379             bw_40 = sta->deflink.ht_cap.cap &
0380                 IEEE80211_HT_CAP_SUP_WIDTH_20_40;
0381     }
0382 
0383     seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
0384 
0385     rtl_get_tcb_desc(hw, info, sta, skb, ptcb_desc);
0386 
0387     clear_pci_tx_desc_content(pdesc, sizeof(struct tx_desc_8723e));
0388 
0389     if (ieee80211_is_nullfunc(fc) || ieee80211_is_ctl(fc)) {
0390         firstseg = true;
0391         lastseg = true;
0392     }
0393 
0394     if (firstseg) {
0395         set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
0396 
0397         set_tx_desc_tx_rate(pdesc, ptcb_desc->hw_rate);
0398 
0399         if (ptcb_desc->use_shortgi || ptcb_desc->use_shortpreamble)
0400             set_tx_desc_data_shortgi(pdesc, 1);
0401 
0402         if (info->flags & IEEE80211_TX_CTL_AMPDU) {
0403             set_tx_desc_agg_break(pdesc, 1);
0404             set_tx_desc_max_agg_num(pdesc, 0x14);
0405         }
0406         set_tx_desc_seq(pdesc, seq_number);
0407 
0408         set_tx_desc_rts_enable(pdesc,
0409                        ((ptcb_desc->rts_enable &&
0410                     !ptcb_desc->cts_enable) ? 1 : 0));
0411         set_tx_desc_hw_rts_enable(pdesc,
0412                       ((ptcb_desc->rts_enable ||
0413                       ptcb_desc->cts_enable) ? 1 : 0));
0414         set_tx_desc_cts2self(pdesc,
0415                      ((ptcb_desc->cts_enable) ? 1 : 0));
0416         set_tx_desc_rts_stbc(pdesc,
0417                      ((ptcb_desc->rts_stbc) ? 1 : 0));
0418 
0419         set_tx_desc_rts_rate(pdesc, ptcb_desc->rts_rate);
0420         set_tx_desc_rts_bw(pdesc, 0);
0421         set_tx_desc_rts_sc(pdesc, ptcb_desc->rts_sc);
0422         set_tx_desc_rts_short(pdesc,
0423                 ((ptcb_desc->rts_rate <= DESC92C_RATE54M) ?
0424                 (ptcb_desc->rts_use_shortpreamble ? 1 : 0)
0425                 : (ptcb_desc->rts_use_shortgi ? 1 : 0)));
0426 
0427         if (bw_40) {
0428             if (ptcb_desc->packet_bw == HT_CHANNEL_WIDTH_20_40) {
0429                 set_tx_desc_data_bw(pdesc, 1);
0430                 set_tx_desc_tx_sub_carrier(pdesc, 3);
0431             } else {
0432                 set_tx_desc_data_bw(pdesc, 0);
0433                 set_tx_desc_tx_sub_carrier(pdesc,
0434                     mac->cur_40_prime_sc);
0435             }
0436         } else {
0437             set_tx_desc_data_bw(pdesc, 0);
0438             set_tx_desc_tx_sub_carrier(pdesc, 0);
0439         }
0440 
0441         set_tx_desc_linip(pdesc, 0);
0442         set_tx_desc_pkt_size(pdesc, (u16)skb->len);
0443 
0444         if (sta) {
0445             u8 ampdu_density = sta->deflink.ht_cap.ampdu_density;
0446             set_tx_desc_ampdu_density(pdesc, ampdu_density);
0447         }
0448 
0449         if (info->control.hw_key) {
0450             struct ieee80211_key_conf *keyconf =
0451                 info->control.hw_key;
0452 
0453             switch (keyconf->cipher) {
0454             case WLAN_CIPHER_SUITE_WEP40:
0455             case WLAN_CIPHER_SUITE_WEP104:
0456             case WLAN_CIPHER_SUITE_TKIP:
0457                 set_tx_desc_sec_type(pdesc, 0x1);
0458                 break;
0459             case WLAN_CIPHER_SUITE_CCMP:
0460                 set_tx_desc_sec_type(pdesc, 0x3);
0461                 break;
0462             default:
0463                 set_tx_desc_sec_type(pdesc, 0x0);
0464                 break;
0465 
0466             }
0467         }
0468 
0469         set_tx_desc_pkt_id(pdesc, 0);
0470         set_tx_desc_queue_sel(pdesc, fw_qsel);
0471 
0472         set_tx_desc_data_rate_fb_limit(pdesc, 0x1F);
0473         set_tx_desc_rts_rate_fb_limit(pdesc, 0xF);
0474         set_tx_desc_disable_fb(pdesc, 0);
0475         set_tx_desc_use_rate(pdesc, ptcb_desc->use_driver_rate ? 1 : 0);
0476 
0477         if (ieee80211_is_data_qos(fc)) {
0478             if (mac->rdg_en) {
0479                 rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0480                     "Enable RDG function.\n");
0481                 set_tx_desc_rdg_enable(pdesc, 1);
0482                 set_tx_desc_htc(pdesc, 1);
0483             }
0484         }
0485     }
0486 
0487     set_tx_desc_first_seg(pdesc, (firstseg ? 1 : 0));
0488     set_tx_desc_last_seg(pdesc, (lastseg ? 1 : 0));
0489 
0490     set_tx_desc_tx_buffer_size(pdesc, (u16)skb->len);
0491 
0492     set_tx_desc_tx_buffer_address(pdesc, mapping);
0493 
0494     if (rtlpriv->dm.useramask) {
0495         set_tx_desc_rate_id(pdesc, ptcb_desc->ratr_index);
0496         set_tx_desc_macid(pdesc, ptcb_desc->mac_id);
0497     } else {
0498         set_tx_desc_rate_id(pdesc, 0xC + ptcb_desc->ratr_index);
0499         set_tx_desc_macid(pdesc, ptcb_desc->ratr_index);
0500     }
0501 
0502     if ((!ieee80211_is_data_qos(fc)) && ppsc->fwctrl_lps) {
0503         set_tx_desc_hwseq_en_8723(pdesc, 1);
0504         /* set_tx_desc_hwseq_en(pdesc, 1); */
0505         /* set_tx_desc_pkt_id(pdesc, 8); */
0506 
0507         if (!b_defaultadapter)
0508             set_tx_desc_hwseq_sel_8723(pdesc, 1);
0509     /* set_tx_desc_qos(pdesc, 1); */
0510     }
0511 
0512     set_tx_desc_more_frag(pdesc, (lastseg ? 0 : 1));
0513 
0514     if (is_multicast_ether_addr(ieee80211_get_DA(hdr)) ||
0515         is_broadcast_ether_addr(ieee80211_get_DA(hdr))) {
0516         set_tx_desc_bmc(pdesc, 1);
0517     }
0518 
0519     rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE, "\n");
0520 }
0521 
0522 void rtl8723e_tx_fill_cmddesc(struct ieee80211_hw *hw,
0523                   u8 *pdesc8, bool firstseg,
0524                   bool lastseg, struct sk_buff *skb)
0525 {
0526     struct rtl_priv *rtlpriv = rtl_priv(hw);
0527     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0528     u8 fw_queue = QSLT_BEACON;
0529     __le32 *pdesc = (__le32 *)pdesc8;
0530 
0531     struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
0532     __le16 fc = hdr->frame_control;
0533 
0534     dma_addr_t mapping = dma_map_single(&rtlpci->pdev->dev, skb->data,
0535                         skb->len, DMA_TO_DEVICE);
0536 
0537     if (dma_mapping_error(&rtlpci->pdev->dev, mapping)) {
0538         rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
0539             "DMA mapping error\n");
0540         return;
0541     }
0542     clear_pci_tx_desc_content(pdesc, TX_DESC_SIZE);
0543 
0544     if (firstseg)
0545         set_tx_desc_offset(pdesc, USB_HWDESC_HEADER_LEN);
0546 
0547     set_tx_desc_tx_rate(pdesc, DESC92C_RATE1M);
0548 
0549     set_tx_desc_seq(pdesc, 0);
0550 
0551     set_tx_desc_linip(pdesc, 0);
0552 
0553     set_tx_desc_queue_sel(pdesc, fw_queue);
0554 
0555     set_tx_desc_first_seg(pdesc, 1);
0556     set_tx_desc_last_seg(pdesc, 1);
0557 
0558     set_tx_desc_tx_buffer_size(pdesc, (u16)(skb->len));
0559 
0560     set_tx_desc_tx_buffer_address(pdesc, mapping);
0561 
0562     set_tx_desc_rate_id(pdesc, 7);
0563     set_tx_desc_macid(pdesc, 0);
0564 
0565     set_tx_desc_own(pdesc, 1);
0566 
0567     set_tx_desc_pkt_size(pdesc, (u16)(skb->len));
0568 
0569     set_tx_desc_first_seg(pdesc, 1);
0570     set_tx_desc_last_seg(pdesc, 1);
0571 
0572     set_tx_desc_offset(pdesc, 0x20);
0573 
0574     set_tx_desc_use_rate(pdesc, 1);
0575 
0576     if (!ieee80211_is_data_qos(fc)) {
0577         set_tx_desc_hwseq_en_8723(pdesc, 1);
0578         /* set_tx_desc_hwseq_en(pdesc, 1); */
0579         /* set_tx_desc_pkt_id(pdesc, 8); */
0580     }
0581 
0582     RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD,
0583               "H2C Tx Cmd Content\n",
0584               pdesc, TX_DESC_SIZE);
0585 }
0586 
0587 void rtl8723e_set_desc(struct ieee80211_hw *hw, u8 *pdesc8,
0588                bool istx, u8 desc_name, u8 *val)
0589 {
0590     __le32 *pdesc = (__le32 *)pdesc8;
0591 
0592     if (istx) {
0593         switch (desc_name) {
0594         case HW_DESC_OWN:
0595             set_tx_desc_own(pdesc, 1);
0596             break;
0597         case HW_DESC_TX_NEXTDESC_ADDR:
0598             set_tx_desc_next_desc_address(pdesc, *(u32 *)val);
0599             break;
0600         default:
0601             WARN_ONCE(true, "rtl8723ae: ERR txdesc :%d not processed\n",
0602                   desc_name);
0603             break;
0604         }
0605     } else {
0606         switch (desc_name) {
0607         case HW_DESC_RXOWN:
0608             set_rx_desc_own(pdesc, 1);
0609             break;
0610         case HW_DESC_RXBUFF_ADDR:
0611             set_rx_desc_buff_addr(pdesc, *(u32 *)val);
0612             break;
0613         case HW_DESC_RXPKT_LEN:
0614             set_rx_desc_pkt_len(pdesc, *(u32 *)val);
0615             break;
0616         case HW_DESC_RXERO:
0617             set_rx_desc_eor(pdesc, 1);
0618             break;
0619         default:
0620             WARN_ONCE(true, "rtl8723ae: ERR rxdesc :%d not processed\n",
0621                   desc_name);
0622             break;
0623         }
0624     }
0625 }
0626 
0627 u64 rtl8723e_get_desc(struct ieee80211_hw *hw,
0628               u8 *pdesc8, bool istx, u8 desc_name)
0629 {
0630     u32 ret = 0;
0631     __le32 *pdesc = (__le32 *)pdesc8;
0632 
0633     if (istx) {
0634         switch (desc_name) {
0635         case HW_DESC_OWN:
0636             ret = get_tx_desc_own(pdesc);
0637             break;
0638         case HW_DESC_TXBUFF_ADDR:
0639             ret = get_tx_desc_tx_buffer_address(pdesc);
0640             break;
0641         default:
0642             WARN_ONCE(true, "rtl8723ae: ERR txdesc :%d not processed\n",
0643                   desc_name);
0644             break;
0645         }
0646     } else {
0647         switch (desc_name) {
0648         case HW_DESC_OWN:
0649             ret = get_rx_desc_own(pdesc);
0650             break;
0651         case HW_DESC_RXPKT_LEN:
0652             ret = get_rx_desc_pkt_len(pdesc);
0653             break;
0654         case HW_DESC_RXBUFF_ADDR:
0655             ret = get_rx_desc_buff_addr(pdesc);
0656             break;
0657         default:
0658             WARN_ONCE(true, "rtl8723ae: ERR rxdesc :%d not processed\n",
0659                   desc_name);
0660             break;
0661         }
0662     }
0663     return ret;
0664 }
0665 
0666 bool rtl8723e_is_tx_desc_closed(struct ieee80211_hw *hw,
0667                 u8 hw_queue, u16 index)
0668 {
0669     struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
0670     struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[hw_queue];
0671     u8 *entry = (u8 *)(&ring->desc[ring->idx]);
0672     u8 own = (u8)rtl8723e_get_desc(hw, entry, true, HW_DESC_OWN);
0673 
0674     /**
0675      *beacon packet will only use the first
0676      *descriptor defautly,and the own may not
0677      *be cleared by the hardware
0678      */
0679     if (own)
0680         return false;
0681     return true;
0682 }
0683 
0684 void rtl8723e_tx_polling(struct ieee80211_hw *hw, u8 hw_queue)
0685 {
0686     struct rtl_priv *rtlpriv = rtl_priv(hw);
0687     if (hw_queue == BEACON_QUEUE) {
0688         rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG, BIT(4));
0689     } else {
0690         rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG,
0691                    BIT(0) << (hw_queue));
0692     }
0693 }
[ 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!