Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
trx.c
Go to the documentation of this file.
1 /******************************************************************************
2  *
3  * Copyright(c) 2009-2012 Realtek Corporation.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of version 2 of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called LICENSE.
20  *
21  * Contact Information:
22  * wlanfae <[email protected]>
23  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
24  * Hsinchu 300, Taiwan.
25  *
26  * Larry Finger <[email protected]>
27  *
28  *****************************************************************************/
29 
30 #include "../wifi.h"
31 #include "../pci.h"
32 #include "../base.h"
33 #include "reg.h"
34 #include "def.h"
35 #include "phy.h"
36 #include "trx.h"
37 #include "led.h"
38 
39 static u8 _rtl92de_map_hwqueue_to_fwqueue(struct sk_buff *skb, u8 hw_queue)
40 {
41  __le16 fc = rtl_get_fc(skb);
42 
43  if (unlikely(ieee80211_is_beacon(fc)))
44  return QSLT_BEACON;
45  if (ieee80211_is_mgmt(fc))
46  return QSLT_MGNT;
47 
48  return skb->priority;
49 }
50 
51 static u8 _rtl92d_query_rxpwrpercentage(char antpower)
52 {
53  if ((antpower <= -100) || (antpower >= 20))
54  return 0;
55  else if (antpower >= 0)
56  return 100;
57  else
58  return 100 + antpower;
59 }
60 
61 static u8 _rtl92d_evm_db_to_percentage(char value)
62 {
63  char ret_val = value;
64 
65  if (ret_val >= 0)
66  ret_val = 0;
67  if (ret_val <= -33)
68  ret_val = -33;
69  ret_val = 0 - ret_val;
70  ret_val *= 3;
71  if (ret_val == 99)
72  ret_val = 100;
73  return ret_val;
74 }
75 
76 static long _rtl92de_translate_todbm(struct ieee80211_hw *hw,
77  u8 signal_strength_index)
78 {
79  long signal_power;
80 
81  signal_power = (long)((signal_strength_index + 1) >> 1);
82  signal_power -= 95;
83  return signal_power;
84 }
85 
86 static long _rtl92de_signal_scale_mapping(struct ieee80211_hw *hw, long currsig)
87 {
88  long retsig;
89 
90  if (currsig >= 61 && currsig <= 100)
91  retsig = 90 + ((currsig - 60) / 4);
92  else if (currsig >= 41 && currsig <= 60)
93  retsig = 78 + ((currsig - 40) / 2);
94  else if (currsig >= 31 && currsig <= 40)
95  retsig = 66 + (currsig - 30);
96  else if (currsig >= 21 && currsig <= 30)
97  retsig = 54 + (currsig - 20);
98  else if (currsig >= 5 && currsig <= 20)
99  retsig = 42 + (((currsig - 5) * 2) / 3);
100  else if (currsig == 4)
101  retsig = 36;
102  else if (currsig == 3)
103  retsig = 27;
104  else if (currsig == 2)
105  retsig = 18;
106  else if (currsig == 1)
107  retsig = 9;
108  else
109  retsig = currsig;
110  return retsig;
111 }
112 
113 static void _rtl92de_query_rxphystatus(struct ieee80211_hw *hw,
114  struct rtl_stats *pstats,
115  struct rx_desc_92d *pdesc,
116  struct rx_fwinfo_92d *p_drvinfo,
117  bool packet_match_bssid,
118  bool packet_toself,
119  bool packet_beacon)
120 {
121  struct rtl_priv *rtlpriv = rtl_priv(hw);
122  struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
123  struct phy_sts_cck_8192d *cck_buf;
124  s8 rx_pwr_all, rx_pwr[4];
125  u8 rf_rx_num = 0, evm, pwdb_all;
126  u8 i, max_spatial_stream;
127  u32 rssi, total_rssi = 0;
128  bool is_cck_rate;
129 
130  is_cck_rate = RX_HAL_IS_CCK_RATE(pdesc);
131  pstats->packet_matchbssid = packet_match_bssid;
132  pstats->packet_toself = packet_toself;
133  pstats->packet_beacon = packet_beacon;
134  pstats->is_cck = is_cck_rate;
135  pstats->rx_mimo_signalquality[0] = -1;
136  pstats->rx_mimo_signalquality[1] = -1;
137 
138  if (is_cck_rate) {
139  u8 report, cck_highpwr;
140  cck_buf = (struct phy_sts_cck_8192d *)p_drvinfo;
141  if (ppsc->rfpwr_state == ERFON)
142  cck_highpwr = (u8) rtl_get_bbreg(hw,
143  RFPGA0_XA_HSSIPARAMETER2,
144  BIT(9));
145  else
146  cck_highpwr = false;
147  if (!cck_highpwr) {
148  u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
149  report = cck_buf->cck_agc_rpt & 0xc0;
150  report = report >> 6;
151  switch (report) {
152  case 0x3:
153  rx_pwr_all = -46 - (cck_agc_rpt & 0x3e);
154  break;
155  case 0x2:
156  rx_pwr_all = -26 - (cck_agc_rpt & 0x3e);
157  break;
158  case 0x1:
159  rx_pwr_all = -12 - (cck_agc_rpt & 0x3e);
160  break;
161  case 0x0:
162  rx_pwr_all = 16 - (cck_agc_rpt & 0x3e);
163  break;
164  }
165  } else {
166  u8 cck_agc_rpt = cck_buf->cck_agc_rpt;
167  report = p_drvinfo->cfosho[0] & 0x60;
168  report = report >> 5;
169  switch (report) {
170  case 0x3:
171  rx_pwr_all = -46 - ((cck_agc_rpt & 0x1f) << 1);
172  break;
173  case 0x2:
174  rx_pwr_all = -26 - ((cck_agc_rpt & 0x1f) << 1);
175  break;
176  case 0x1:
177  rx_pwr_all = -12 - ((cck_agc_rpt & 0x1f) << 1);
178  break;
179  case 0x0:
180  rx_pwr_all = 16 - ((cck_agc_rpt & 0x1f) << 1);
181  break;
182  }
183  }
184  pwdb_all = _rtl92d_query_rxpwrpercentage(rx_pwr_all);
185  /* CCK gain is smaller than OFDM/MCS gain, */
186  /* so we add gain diff by experiences, the val is 6 */
187  pwdb_all += 6;
188  if (pwdb_all > 100)
189  pwdb_all = 100;
190  /* modify the offset to make the same gain index with OFDM. */
191  if (pwdb_all > 34 && pwdb_all <= 42)
192  pwdb_all -= 2;
193  else if (pwdb_all > 26 && pwdb_all <= 34)
194  pwdb_all -= 6;
195  else if (pwdb_all > 14 && pwdb_all <= 26)
196  pwdb_all -= 8;
197  else if (pwdb_all > 4 && pwdb_all <= 14)
198  pwdb_all -= 4;
199  pstats->rx_pwdb_all = pwdb_all;
200  pstats->recvsignalpower = rx_pwr_all;
201  if (packet_match_bssid) {
202  u8 sq;
203  if (pstats->rx_pwdb_all > 40) {
204  sq = 100;
205  } else {
206  sq = cck_buf->sq_rpt;
207  if (sq > 64)
208  sq = 0;
209  else if (sq < 20)
210  sq = 100;
211  else
212  sq = ((64 - sq) * 100) / 44;
213  }
214  pstats->signalquality = sq;
215  pstats->rx_mimo_signalquality[0] = sq;
216  pstats->rx_mimo_signalquality[1] = -1;
217  }
218  } else {
219  rtlpriv->dm.rfpath_rxenable[0] = true;
220  rtlpriv->dm.rfpath_rxenable[1] = true;
221  for (i = RF90_PATH_A; i < RF6052_MAX_PATH; i++) {
222  if (rtlpriv->dm.rfpath_rxenable[i])
223  rf_rx_num++;
224  rx_pwr[i] = ((p_drvinfo->gain_trsw[i] & 0x3f) * 2)
225  - 110;
226  rssi = _rtl92d_query_rxpwrpercentage(rx_pwr[i]);
227  total_rssi += rssi;
228  rtlpriv->stats.rx_snr_db[i] =
229  (long)(p_drvinfo->rxsnr[i] / 2);
230  if (packet_match_bssid)
231  pstats->rx_mimo_signalstrength[i] = (u8) rssi;
232  }
233  rx_pwr_all = ((p_drvinfo->pwdb_all >> 1) & 0x7f) - 106;
234  pwdb_all = _rtl92d_query_rxpwrpercentage(rx_pwr_all);
235  pstats->rx_pwdb_all = pwdb_all;
236  pstats->rxpower = rx_pwr_all;
237  pstats->recvsignalpower = rx_pwr_all;
238  if (pdesc->rxht && pdesc->rxmcs >= DESC92_RATEMCS8 &&
239  pdesc->rxmcs <= DESC92_RATEMCS15)
240  max_spatial_stream = 2;
241  else
242  max_spatial_stream = 1;
243  for (i = 0; i < max_spatial_stream; i++) {
244  evm = _rtl92d_evm_db_to_percentage(p_drvinfo->rxevm[i]);
245  if (packet_match_bssid) {
246  if (i == 0)
247  pstats->signalquality =
248  (u8)(evm & 0xff);
249  pstats->rx_mimo_signalquality[i] =
250  (u8)(evm & 0xff);
251  }
252  }
253  }
254  if (is_cck_rate)
255  pstats->signalstrength = (u8)(_rtl92de_signal_scale_mapping(hw,
256  pwdb_all));
257  else if (rf_rx_num != 0)
258  pstats->signalstrength = (u8)(_rtl92de_signal_scale_mapping(hw,
259  total_rssi /= rf_rx_num));
260 }
261 
262 static void rtl92d_loop_over_paths(struct ieee80211_hw *hw,
263  struct rtl_stats *pstats)
264 {
265  struct rtl_priv *rtlpriv = rtl_priv(hw);
266  struct rtl_phy *rtlphy = &(rtlpriv->phy);
267  u8 rfpath;
268 
269  for (rfpath = RF90_PATH_A; rfpath < rtlphy->num_total_rfpath;
270  rfpath++) {
271  if (rtlpriv->stats.rx_rssi_percentage[rfpath] == 0) {
272  rtlpriv->stats.rx_rssi_percentage[rfpath] =
273  pstats->rx_mimo_signalstrength[rfpath];
274 
275  }
276  if (pstats->rx_mimo_signalstrength[rfpath] >
277  rtlpriv->stats.rx_rssi_percentage[rfpath]) {
278  rtlpriv->stats.rx_rssi_percentage[rfpath] =
279  ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
280  (RX_SMOOTH_FACTOR - 1)) +
281  (pstats->rx_mimo_signalstrength[rfpath])) /
282  (RX_SMOOTH_FACTOR);
283  rtlpriv->stats.rx_rssi_percentage[rfpath] =
284  rtlpriv->stats.rx_rssi_percentage[rfpath] + 1;
285  } else {
286  rtlpriv->stats.rx_rssi_percentage[rfpath] =
287  ((rtlpriv->stats.rx_rssi_percentage[rfpath] *
288  (RX_SMOOTH_FACTOR - 1)) +
289  (pstats->rx_mimo_signalstrength[rfpath])) /
290  (RX_SMOOTH_FACTOR);
291  }
292  }
293 }
294 
295 static void _rtl92de_process_ui_rssi(struct ieee80211_hw *hw,
296  struct rtl_stats *pstats)
297 {
298  struct rtl_priv *rtlpriv = rtl_priv(hw);
299  u32 last_rssi, tmpval;
300 
301  if (pstats->packet_toself || pstats->packet_beacon) {
302  rtlpriv->stats.rssi_calculate_cnt++;
303  if (rtlpriv->stats.ui_rssi.total_num++ >=
304  PHY_RSSI_SLID_WIN_MAX) {
305  rtlpriv->stats.ui_rssi.total_num =
306  PHY_RSSI_SLID_WIN_MAX;
307  last_rssi = rtlpriv->stats.ui_rssi.elements[
308  rtlpriv->stats.ui_rssi.index];
309  rtlpriv->stats.ui_rssi.total_val -= last_rssi;
310  }
311  rtlpriv->stats.ui_rssi.total_val += pstats->signalstrength;
312  rtlpriv->stats.ui_rssi.elements
313  [rtlpriv->stats.ui_rssi.index++] =
314  pstats->signalstrength;
315  if (rtlpriv->stats.ui_rssi.index >= PHY_RSSI_SLID_WIN_MAX)
316  rtlpriv->stats.ui_rssi.index = 0;
317  tmpval = rtlpriv->stats.ui_rssi.total_val /
318  rtlpriv->stats.ui_rssi.total_num;
319  rtlpriv->stats.signal_strength = _rtl92de_translate_todbm(hw,
320  (u8) tmpval);
321  pstats->rssi = rtlpriv->stats.signal_strength;
322  }
323  if (!pstats->is_cck && pstats->packet_toself)
324  rtl92d_loop_over_paths(hw, pstats);
325 }
326 
327 static void _rtl92de_update_rxsignalstatistics(struct ieee80211_hw *hw,
328  struct rtl_stats *pstats)
329 {
330  struct rtl_priv *rtlpriv = rtl_priv(hw);
331  int weighting = 0;
332 
333  if (rtlpriv->stats.recv_signal_power == 0)
334  rtlpriv->stats.recv_signal_power = pstats->recvsignalpower;
335  if (pstats->recvsignalpower > rtlpriv->stats.recv_signal_power)
336  weighting = 5;
337  else if (pstats->recvsignalpower < rtlpriv->stats.recv_signal_power)
338  weighting = (-5);
339  rtlpriv->stats.recv_signal_power = (rtlpriv->stats.recv_signal_power *
340  5 + pstats->recvsignalpower + weighting) / 6;
341 }
342 
343 static void _rtl92de_process_pwdb(struct ieee80211_hw *hw,
344  struct rtl_stats *pstats)
345 {
346  struct rtl_priv *rtlpriv = rtl_priv(hw);
347  struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
348  long undecorated_smoothed_pwdb;
349 
350  if (mac->opmode == NL80211_IFTYPE_ADHOC ||
351  mac->opmode == NL80211_IFTYPE_AP)
352  return;
353  else
354  undecorated_smoothed_pwdb =
355  rtlpriv->dm.undecorated_smoothed_pwdb;
356 
357  if (pstats->packet_toself || pstats->packet_beacon) {
358  if (undecorated_smoothed_pwdb < 0)
359  undecorated_smoothed_pwdb = pstats->rx_pwdb_all;
360  if (pstats->rx_pwdb_all > (u32) undecorated_smoothed_pwdb) {
361  undecorated_smoothed_pwdb =
362  (((undecorated_smoothed_pwdb) *
363  (RX_SMOOTH_FACTOR - 1)) +
364  (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
365  undecorated_smoothed_pwdb =
366  undecorated_smoothed_pwdb + 1;
367  } else {
368  undecorated_smoothed_pwdb =
369  (((undecorated_smoothed_pwdb) *
370  (RX_SMOOTH_FACTOR - 1)) +
371  (pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
372  }
373  rtlpriv->dm.undecorated_smoothed_pwdb =
374  undecorated_smoothed_pwdb;
375  _rtl92de_update_rxsignalstatistics(hw, pstats);
376  }
377 }
378 
379 static void rtl92d_loop_over_streams(struct ieee80211_hw *hw,
380  struct rtl_stats *pstats)
381 {
382  struct rtl_priv *rtlpriv = rtl_priv(hw);
383  int stream;
384 
385  for (stream = 0; stream < 2; stream++) {
386  if (pstats->rx_mimo_signalquality[stream] != -1) {
387  if (rtlpriv->stats.rx_evm_percentage[stream] == 0) {
388  rtlpriv->stats.rx_evm_percentage[stream] =
389  pstats->rx_mimo_signalquality[stream];
390  }
391  rtlpriv->stats.rx_evm_percentage[stream] =
392  ((rtlpriv->stats.rx_evm_percentage[stream]
393  * (RX_SMOOTH_FACTOR - 1)) +
394  (pstats->rx_mimo_signalquality[stream] * 1)) /
395  (RX_SMOOTH_FACTOR);
396  }
397  }
398 }
399 
400 static void _rtl92de_process_ui_link_quality(struct ieee80211_hw *hw,
401  struct rtl_stats *pstats)
402 {
403  struct rtl_priv *rtlpriv = rtl_priv(hw);
404  u32 last_evm, tmpval;
405 
406  if (pstats->signalquality == 0)
407  return;
408  if (pstats->packet_toself || pstats->packet_beacon) {
409  if (rtlpriv->stats.ui_link_quality.total_num++ >=
410  PHY_LINKQUALITY_SLID_WIN_MAX) {
411  rtlpriv->stats.ui_link_quality.total_num =
412  PHY_LINKQUALITY_SLID_WIN_MAX;
413  last_evm = rtlpriv->stats.ui_link_quality.elements[
414  rtlpriv->stats.ui_link_quality.index];
415  rtlpriv->stats.ui_link_quality.total_val -= last_evm;
416  }
417  rtlpriv->stats.ui_link_quality.total_val +=
418  pstats->signalquality;
419  rtlpriv->stats.ui_link_quality.elements[
420  rtlpriv->stats.ui_link_quality.index++] =
421  pstats->signalquality;
422  if (rtlpriv->stats.ui_link_quality.index >=
423  PHY_LINKQUALITY_SLID_WIN_MAX)
424  rtlpriv->stats.ui_link_quality.index = 0;
425  tmpval = rtlpriv->stats.ui_link_quality.total_val /
426  rtlpriv->stats.ui_link_quality.total_num;
427  rtlpriv->stats.signal_quality = tmpval;
428  rtlpriv->stats.last_sigstrength_inpercent = tmpval;
429  rtl92d_loop_over_streams(hw, pstats);
430  }
431 }
432 
433 static void _rtl92de_process_phyinfo(struct ieee80211_hw *hw,
434  u8 *buffer,
435  struct rtl_stats *pcurrent_stats)
436 {
437 
438  if (!pcurrent_stats->packet_matchbssid &&
439  !pcurrent_stats->packet_beacon)
440  return;
441 
442  _rtl92de_process_ui_rssi(hw, pcurrent_stats);
443  _rtl92de_process_pwdb(hw, pcurrent_stats);
444  _rtl92de_process_ui_link_quality(hw, pcurrent_stats);
445 }
446 
447 static void _rtl92de_translate_rx_signal_stuff(struct ieee80211_hw *hw,
448  struct sk_buff *skb,
449  struct rtl_stats *pstats,
450  struct rx_desc_92d *pdesc,
451  struct rx_fwinfo_92d *p_drvinfo)
452 {
453  struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
454  struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
455  struct ieee80211_hdr *hdr;
456  u8 *tmp_buf;
457  u8 *praddr;
458  u16 type, cfc;
459  __le16 fc;
460  bool packet_matchbssid, packet_toself, packet_beacon;
461 
462  tmp_buf = skb->data + pstats->rx_drvinfo_size + pstats->rx_bufshift;
463  hdr = (struct ieee80211_hdr *)tmp_buf;
464  fc = hdr->frame_control;
465  cfc = le16_to_cpu(fc);
466  type = WLAN_FC_GET_TYPE(fc);
467  praddr = hdr->addr1;
468  packet_matchbssid = ((IEEE80211_FTYPE_CTL != type) &&
469  ether_addr_equal(mac->bssid,
470  (cfc & IEEE80211_FCTL_TODS) ? hdr->addr1 :
471  (cfc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 :
472  hdr->addr3) &&
473  (!pstats->hwerror) && (!pstats->crc) && (!pstats->icv));
474  packet_toself = packet_matchbssid &&
475  ether_addr_equal(praddr, rtlefuse->dev_addr);
476  if (ieee80211_is_beacon(fc))
477  packet_beacon = true;
478  _rtl92de_query_rxphystatus(hw, pstats, pdesc, p_drvinfo,
479  packet_matchbssid, packet_toself,
480  packet_beacon);
481  _rtl92de_process_phyinfo(hw, tmp_buf, pstats);
482 }
483 
484 bool rtl92de_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *stats,
485  struct ieee80211_rx_status *rx_status,
486  u8 *p_desc, struct sk_buff *skb)
487 {
488  struct rx_fwinfo_92d *p_drvinfo;
489  struct rx_desc_92d *pdesc = (struct rx_desc_92d *)p_desc;
490  u32 phystatus = GET_RX_DESC_PHYST(pdesc);
491 
492  stats->length = (u16) GET_RX_DESC_PKT_LEN(pdesc);
493  stats->rx_drvinfo_size = (u8) GET_RX_DESC_DRV_INFO_SIZE(pdesc) *
494  RX_DRV_INFO_SIZE_UNIT;
495  stats->rx_bufshift = (u8) (GET_RX_DESC_SHIFT(pdesc) & 0x03);
496  stats->icv = (u16) GET_RX_DESC_ICV(pdesc);
497  stats->crc = (u16) GET_RX_DESC_CRC32(pdesc);
498  stats->hwerror = (stats->crc | stats->icv);
499  stats->decrypted = !GET_RX_DESC_SWDEC(pdesc);
500  stats->rate = (u8) GET_RX_DESC_RXMCS(pdesc);
501  stats->shortpreamble = (u16) GET_RX_DESC_SPLCP(pdesc);
502  stats->isampdu = (bool) (GET_RX_DESC_PAGGR(pdesc) == 1);
503  stats->isfirst_ampdu = (bool) ((GET_RX_DESC_PAGGR(pdesc) == 1)
504  && (GET_RX_DESC_FAGGR(pdesc) == 1));
505  stats->timestamp_low = GET_RX_DESC_TSFL(pdesc);
506  stats->rx_is40Mhzpacket = (bool) GET_RX_DESC_BW(pdesc);
507  rx_status->freq = hw->conf.channel->center_freq;
508  rx_status->band = hw->conf.channel->band;
509  if (GET_RX_DESC_CRC32(pdesc))
510  rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
511  if (!GET_RX_DESC_SWDEC(pdesc))
512  rx_status->flag |= RX_FLAG_DECRYPTED;
513  if (GET_RX_DESC_BW(pdesc))
514  rx_status->flag |= RX_FLAG_40MHZ;
515  if (GET_RX_DESC_RXHT(pdesc))
516  rx_status->flag |= RX_FLAG_HT;
517  rx_status->flag |= RX_FLAG_MACTIME_MPDU;
518  if (stats->decrypted)
519  rx_status->flag |= RX_FLAG_DECRYPTED;
520  rx_status->rate_idx = rtlwifi_rate_mapping(hw,
521  (bool)GET_RX_DESC_RXHT(pdesc),
522  (u8)GET_RX_DESC_RXMCS(pdesc),
523  (bool)GET_RX_DESC_PAGGR(pdesc));
524  rx_status->mactime = GET_RX_DESC_TSFL(pdesc);
525  if (phystatus) {
526  p_drvinfo = (struct rx_fwinfo_92d *)(skb->data +
527  stats->rx_bufshift);
528  _rtl92de_translate_rx_signal_stuff(hw,
529  skb, stats, pdesc,
530  p_drvinfo);
531  }
532  /*rx_status->qual = stats->signal; */
533  rx_status->signal = stats->rssi + 10;
534  /*rx_status->noise = -stats->noise; */
535  return true;
536 }
537 
538 static void _rtl92de_insert_emcontent(struct rtl_tcb_desc *ptcb_desc,
539  u8 *virtualaddress)
540 {
541  memset(virtualaddress, 0, 8);
542 
543  SET_EARLYMODE_PKTNUM(virtualaddress, ptcb_desc->empkt_num);
544  SET_EARLYMODE_LEN0(virtualaddress, ptcb_desc->empkt_len[0]);
545  SET_EARLYMODE_LEN1(virtualaddress, ptcb_desc->empkt_len[1]);
546  SET_EARLYMODE_LEN2_1(virtualaddress, ptcb_desc->empkt_len[2] & 0xF);
547  SET_EARLYMODE_LEN2_2(virtualaddress, ptcb_desc->empkt_len[2] >> 4);
548  SET_EARLYMODE_LEN3(virtualaddress, ptcb_desc->empkt_len[3]);
549  SET_EARLYMODE_LEN4(virtualaddress, ptcb_desc->empkt_len[4]);
550 }
551 
552 void rtl92de_tx_fill_desc(struct ieee80211_hw *hw,
553  struct ieee80211_hdr *hdr, u8 *pdesc_tx,
554  struct ieee80211_tx_info *info,
555  struct ieee80211_sta *sta,
556  struct sk_buff *skb,
557  u8 hw_queue, struct rtl_tcb_desc *ptcb_desc)
558 {
559  struct rtl_priv *rtlpriv = rtl_priv(hw);
560  struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
561  struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
562  struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
563  struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
564  u8 *pdesc = pdesc_tx;
565  u16 seq_number;
566  __le16 fc = hdr->frame_control;
567  unsigned int buf_len = 0;
568  unsigned int skb_len = skb->len;
569  u8 fw_qsel = _rtl92de_map_hwqueue_to_fwqueue(skb, hw_queue);
570  bool firstseg = ((hdr->seq_ctrl &
571  cpu_to_le16(IEEE80211_SCTL_FRAG)) == 0);
572  bool lastseg = ((hdr->frame_control &
573  cpu_to_le16(IEEE80211_FCTL_MOREFRAGS)) == 0);
574  dma_addr_t mapping;
575  u8 bw_40 = 0;
576 
577  if (mac->opmode == NL80211_IFTYPE_STATION) {
578  bw_40 = mac->bw_40;
579  } else if (mac->opmode == NL80211_IFTYPE_AP ||
580  mac->opmode == NL80211_IFTYPE_ADHOC) {
581  if (sta)
582  bw_40 = sta->ht_cap.cap &
583  IEEE80211_HT_CAP_SUP_WIDTH_20_40;
584  }
585  seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
586  rtl_get_tcb_desc(hw, info, sta, skb, ptcb_desc);
587  /* reserve 8 byte for AMPDU early mode */
588  if (rtlhal->earlymode_enable) {
589  skb_push(skb, EM_HDR_LEN);
590  memset(skb->data, 0, EM_HDR_LEN);
591  }
592  buf_len = skb->len;
593  mapping = pci_map_single(rtlpci->pdev, skb->data, skb->len,
594  PCI_DMA_TODEVICE);
595  CLEAR_PCI_TX_DESC_CONTENT(pdesc, sizeof(struct tx_desc_92d));
596  if (ieee80211_is_nullfunc(fc) || ieee80211_is_ctl(fc)) {
597  firstseg = true;
598  lastseg = true;
599  }
600  if (firstseg) {
601  if (rtlhal->earlymode_enable) {
602  SET_TX_DESC_PKT_OFFSET(pdesc, 1);
603  SET_TX_DESC_OFFSET(pdesc, USB_HWDESC_HEADER_LEN +
604  EM_HDR_LEN);
605  if (ptcb_desc->empkt_num) {
606  RT_TRACE(rtlpriv, COMP_SEND, DBG_LOUD,
607  "Insert 8 byte.pTcb->EMPktNum:%d\n",
608  ptcb_desc->empkt_num);
609  _rtl92de_insert_emcontent(ptcb_desc,
610  (u8 *)(skb->data));
611  }
612  } else {
613  SET_TX_DESC_OFFSET(pdesc, USB_HWDESC_HEADER_LEN);
614  }
615  /* 5G have no CCK rate */
616  if (rtlhal->current_bandtype == BAND_ON_5G)
617  if (ptcb_desc->hw_rate < DESC92_RATE6M)
618  ptcb_desc->hw_rate = DESC92_RATE6M;
619  SET_TX_DESC_TX_RATE(pdesc, ptcb_desc->hw_rate);
620  if (ptcb_desc->use_shortgi || ptcb_desc->use_shortpreamble)
621  SET_TX_DESC_DATA_SHORTGI(pdesc, 1);
622 
623  if (rtlhal->macphymode == DUALMAC_DUALPHY &&
624  ptcb_desc->hw_rate == DESC92_RATEMCS7)
625  SET_TX_DESC_DATA_SHORTGI(pdesc, 1);
626 
627  if (info->flags & IEEE80211_TX_CTL_AMPDU) {
628  SET_TX_DESC_AGG_ENABLE(pdesc, 1);
629  SET_TX_DESC_MAX_AGG_NUM(pdesc, 0x14);
630  }
631  SET_TX_DESC_SEQ(pdesc, seq_number);
632  SET_TX_DESC_RTS_ENABLE(pdesc, ((ptcb_desc->rts_enable &&
633  !ptcb_desc->cts_enable) ? 1 : 0));
634  SET_TX_DESC_HW_RTS_ENABLE(pdesc, ((ptcb_desc->rts_enable
635  || ptcb_desc->cts_enable) ? 1 : 0));
636  SET_TX_DESC_CTS2SELF(pdesc, ((ptcb_desc->cts_enable) ? 1 : 0));
637  SET_TX_DESC_RTS_STBC(pdesc, ((ptcb_desc->rts_stbc) ? 1 : 0));
638  /* 5G have no CCK rate */
639  if (rtlhal->current_bandtype == BAND_ON_5G)
640  if (ptcb_desc->rts_rate < DESC92_RATE6M)
641  ptcb_desc->rts_rate = DESC92_RATE6M;
642  SET_TX_DESC_RTS_RATE(pdesc, ptcb_desc->rts_rate);
643  SET_TX_DESC_RTS_BW(pdesc, 0);
644  SET_TX_DESC_RTS_SC(pdesc, ptcb_desc->rts_sc);
645  SET_TX_DESC_RTS_SHORT(pdesc, ((ptcb_desc->rts_rate <=
646  DESC92_RATE54M) ?
647  (ptcb_desc->rts_use_shortpreamble ? 1 : 0) :
648  (ptcb_desc->rts_use_shortgi ? 1 : 0)));
649  if (bw_40) {
650  if (ptcb_desc->packet_bw) {
651  SET_TX_DESC_DATA_BW(pdesc, 1);
652  SET_TX_DESC_TX_SUB_CARRIER(pdesc, 3);
653  } else {
654  SET_TX_DESC_DATA_BW(pdesc, 0);
655  SET_TX_DESC_TX_SUB_CARRIER(pdesc,
656  mac->cur_40_prime_sc);
657  }
658  } else {
659  SET_TX_DESC_DATA_BW(pdesc, 0);
660  SET_TX_DESC_TX_SUB_CARRIER(pdesc, 0);
661  }
662  SET_TX_DESC_LINIP(pdesc, 0);
663  SET_TX_DESC_PKT_SIZE(pdesc, (u16) skb_len);
664  if (sta) {
665  u8 ampdu_density = sta->ht_cap.ampdu_density;
666  SET_TX_DESC_AMPDU_DENSITY(pdesc, ampdu_density);
667  }
668  if (info->control.hw_key) {
669  struct ieee80211_key_conf *keyconf;
670 
671  keyconf = info->control.hw_key;
672  switch (keyconf->cipher) {
673  case WLAN_CIPHER_SUITE_WEP40:
674  case WLAN_CIPHER_SUITE_WEP104:
675  case WLAN_CIPHER_SUITE_TKIP:
676  SET_TX_DESC_SEC_TYPE(pdesc, 0x1);
677  break;
678  case WLAN_CIPHER_SUITE_CCMP:
679  SET_TX_DESC_SEC_TYPE(pdesc, 0x3);
680  break;
681  default:
682  SET_TX_DESC_SEC_TYPE(pdesc, 0x0);
683  break;
684 
685  }
686  }
687  SET_TX_DESC_PKT_ID(pdesc, 0);
688  SET_TX_DESC_QUEUE_SEL(pdesc, fw_qsel);
689  SET_TX_DESC_DATA_RATE_FB_LIMIT(pdesc, 0x1F);
690  SET_TX_DESC_RTS_RATE_FB_LIMIT(pdesc, 0xF);
691  SET_TX_DESC_DISABLE_FB(pdesc, ptcb_desc->disable_ratefallback ?
692  1 : 0);
693  SET_TX_DESC_USE_RATE(pdesc, ptcb_desc->use_driver_rate ? 1 : 0);
694 
695  /* Set TxRate and RTSRate in TxDesc */
696  /* This prevent Tx initial rate of new-coming packets */
697  /* from being overwritten by retried packet rate.*/
698  if (!ptcb_desc->use_driver_rate) {
699  SET_TX_DESC_RTS_RATE(pdesc, 0x08);
700  /* SET_TX_DESC_TX_RATE(pdesc, 0x0b); */
701  }
702  if (ieee80211_is_data_qos(fc)) {
703  if (mac->rdg_en) {
704  RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE,
705  "Enable RDG function\n");
706  SET_TX_DESC_RDG_ENABLE(pdesc, 1);
707  SET_TX_DESC_HTC(pdesc, 1);
708  }
709  }
710  }
711 
712  SET_TX_DESC_FIRST_SEG(pdesc, (firstseg ? 1 : 0));
713  SET_TX_DESC_LAST_SEG(pdesc, (lastseg ? 1 : 0));
714  SET_TX_DESC_TX_BUFFER_SIZE(pdesc, (u16) buf_len);
715  SET_TX_DESC_TX_BUFFER_ADDRESS(pdesc, mapping);
716  if (rtlpriv->dm.useramask) {
717  SET_TX_DESC_RATE_ID(pdesc, ptcb_desc->ratr_index);
718  SET_TX_DESC_MACID(pdesc, ptcb_desc->mac_id);
719  } else {
720  SET_TX_DESC_RATE_ID(pdesc, 0xC + ptcb_desc->ratr_index);
721  SET_TX_DESC_MACID(pdesc, ptcb_desc->ratr_index);
722  }
723  if (ieee80211_is_data_qos(fc))
724  SET_TX_DESC_QOS(pdesc, 1);
725 
726  if ((!ieee80211_is_data_qos(fc)) && ppsc->fwctrl_lps) {
727  SET_TX_DESC_HWSEQ_EN(pdesc, 1);
728  SET_TX_DESC_PKT_ID(pdesc, 8);
729  }
730  SET_TX_DESC_MORE_FRAG(pdesc, (lastseg ? 0 : 1));
731  RT_TRACE(rtlpriv, COMP_SEND, DBG_TRACE, "\n");
732 }
733 
734 void rtl92de_tx_fill_cmddesc(struct ieee80211_hw *hw,
735  u8 *pdesc, bool firstseg,
736  bool lastseg, struct sk_buff *skb)
737 {
738  struct rtl_priv *rtlpriv = rtl_priv(hw);
739  struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
740  struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
741  struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
742  u8 fw_queue = QSLT_BEACON;
743  dma_addr_t mapping = pci_map_single(rtlpci->pdev,
744  skb->data, skb->len, PCI_DMA_TODEVICE);
745  struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
746  __le16 fc = hdr->frame_control;
747 
748  CLEAR_PCI_TX_DESC_CONTENT(pdesc, TX_DESC_SIZE);
749  if (firstseg)
750  SET_TX_DESC_OFFSET(pdesc, USB_HWDESC_HEADER_LEN);
751  /* 5G have no CCK rate
752  * Caution: The macros below are multi-line expansions.
753  * The braces are needed no matter what checkpatch says
754  */
755  if (rtlhal->current_bandtype == BAND_ON_5G) {
756  SET_TX_DESC_TX_RATE(pdesc, DESC92_RATE6M);
757  } else {
758  SET_TX_DESC_TX_RATE(pdesc, DESC92_RATE1M);
759  }
760  SET_TX_DESC_SEQ(pdesc, 0);
761  SET_TX_DESC_LINIP(pdesc, 0);
762  SET_TX_DESC_QUEUE_SEL(pdesc, fw_queue);
763  SET_TX_DESC_FIRST_SEG(pdesc, 1);
764  SET_TX_DESC_LAST_SEG(pdesc, 1);
765  SET_TX_DESC_TX_BUFFER_SIZE(pdesc, (u16)skb->len);
766  SET_TX_DESC_TX_BUFFER_ADDRESS(pdesc, mapping);
767  SET_TX_DESC_RATE_ID(pdesc, 7);
768  SET_TX_DESC_MACID(pdesc, 0);
769  SET_TX_DESC_PKT_SIZE(pdesc, (u16) (skb->len));
770  SET_TX_DESC_FIRST_SEG(pdesc, 1);
771  SET_TX_DESC_LAST_SEG(pdesc, 1);
772  SET_TX_DESC_OFFSET(pdesc, 0x20);
773  SET_TX_DESC_USE_RATE(pdesc, 1);
774 
775  if (!ieee80211_is_data_qos(fc) && ppsc->fwctrl_lps) {
776  SET_TX_DESC_HWSEQ_EN(pdesc, 1);
777  SET_TX_DESC_PKT_ID(pdesc, 8);
778  }
779 
780  RT_PRINT_DATA(rtlpriv, COMP_CMD, DBG_LOUD,
781  "H2C Tx Cmd Content", pdesc, TX_DESC_SIZE);
782  wmb();
783  SET_TX_DESC_OWN(pdesc, 1);
784 }
785 
786 void rtl92de_set_desc(u8 *pdesc, bool istx, u8 desc_name, u8 *val)
787 {
788  if (istx) {
789  switch (desc_name) {
790  case HW_DESC_OWN:
791  wmb();
792  SET_TX_DESC_OWN(pdesc, 1);
793  break;
794  case HW_DESC_TX_NEXTDESC_ADDR:
795  SET_TX_DESC_NEXT_DESC_ADDRESS(pdesc, *(u32 *) val);
796  break;
797  default:
798  RT_ASSERT(false, "ERR txdesc :%d not process\n",
799  desc_name);
800  break;
801  }
802  } else {
803  switch (desc_name) {
804  case HW_DESC_RXOWN:
805  wmb();
806  SET_RX_DESC_OWN(pdesc, 1);
807  break;
808  case HW_DESC_RXBUFF_ADDR:
809  SET_RX_DESC_BUFF_ADDR(pdesc, *(u32 *) val);
810  break;
811  case HW_DESC_RXPKT_LEN:
812  SET_RX_DESC_PKT_LEN(pdesc, *(u32 *) val);
813  break;
814  case HW_DESC_RXERO:
815  SET_RX_DESC_EOR(pdesc, 1);
816  break;
817  default:
818  RT_ASSERT(false, "ERR rxdesc :%d not process\n",
819  desc_name);
820  break;
821  }
822  }
823 }
824 
825 u32 rtl92de_get_desc(u8 *p_desc, bool istx, u8 desc_name)
826 {
827  u32 ret = 0;
828 
829  if (istx) {
830  switch (desc_name) {
831  case HW_DESC_OWN:
832  ret = GET_TX_DESC_OWN(p_desc);
833  break;
834  case HW_DESC_TXBUFF_ADDR:
835  ret = GET_TX_DESC_TX_BUFFER_ADDRESS(p_desc);
836  break;
837  default:
838  RT_ASSERT(false, "ERR txdesc :%d not process\n",
839  desc_name);
840  break;
841  }
842  } else {
843  struct rx_desc_92c *pdesc = (struct rx_desc_92c *)p_desc;
844  switch (desc_name) {
845  case HW_DESC_OWN:
846  ret = GET_RX_DESC_OWN(pdesc);
847  break;
848  case HW_DESC_RXPKT_LEN:
849  ret = GET_RX_DESC_PKT_LEN(pdesc);
850  break;
851  default:
852  RT_ASSERT(false, "ERR rxdesc :%d not process\n",
853  desc_name);
854  break;
855  }
856  }
857  return ret;
858 }
859 
860 void rtl92de_tx_polling(struct ieee80211_hw *hw, u8 hw_queue)
861 {
862  struct rtl_priv *rtlpriv = rtl_priv(hw);
863  if (hw_queue == BEACON_QUEUE)
864  rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG, BIT(4));
865  else
866  rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG,
867  BIT(0) << (hw_queue));
868 }
Generated on Thu Jan 10 2013 14:13:07 for Linux Kernel by   doxygen 1.8.2