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 <wlanfae@realtek.com>
23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
24 * Hsinchu 300, Taiwan.
25 *
26 * Larry Finger <Larry.Finger@lwfinger.net>
27 *
28 *****************************************************************************/
29
30#include "wifi.h"
31#include "rc.h"
32#include "base.h"
33#include "efuse.h"
34#include "cam.h"
35#include "ps.h"
36#include "regd.h"
37
38#include <linux/ip.h>
39#include <linux/module.h>
40
41/*
42 *NOTICE!!!: This file will be very big, we should
43 *keep it clear under following roles:
44 *
45 *This file include following parts, so, if you add new
46 *functions into this file, please check which part it
47 *should includes. or check if you should add new part
48 *for this file:
49 *
50 *1) mac80211 init functions
51 *2) tx information functions
52 *3) functions called by core.c
53 *4) wq & timer callback functions
54 *5) frame process functions
55 *6) IOT functions
56 *7) sysfs functions
57 *8) ...
58 */
59
60/*********************************************************
61 *
62 * mac80211 init functions
63 *
64 *********************************************************/
65static struct ieee80211_channel rtl_channeltable_2g[] = {
66	{.center_freq = 2412, .hw_value = 1,},
67	{.center_freq = 2417, .hw_value = 2,},
68	{.center_freq = 2422, .hw_value = 3,},
69	{.center_freq = 2427, .hw_value = 4,},
70	{.center_freq = 2432, .hw_value = 5,},
71	{.center_freq = 2437, .hw_value = 6,},
72	{.center_freq = 2442, .hw_value = 7,},
73	{.center_freq = 2447, .hw_value = 8,},
74	{.center_freq = 2452, .hw_value = 9,},
75	{.center_freq = 2457, .hw_value = 10,},
76	{.center_freq = 2462, .hw_value = 11,},
77	{.center_freq = 2467, .hw_value = 12,},
78	{.center_freq = 2472, .hw_value = 13,},
79	{.center_freq = 2484, .hw_value = 14,},
80};
81
82static struct ieee80211_channel rtl_channeltable_5g[] = {
83	{.center_freq = 5180, .hw_value = 36,},
84	{.center_freq = 5200, .hw_value = 40,},
85	{.center_freq = 5220, .hw_value = 44,},
86	{.center_freq = 5240, .hw_value = 48,},
87	{.center_freq = 5260, .hw_value = 52,},
88	{.center_freq = 5280, .hw_value = 56,},
89	{.center_freq = 5300, .hw_value = 60,},
90	{.center_freq = 5320, .hw_value = 64,},
91	{.center_freq = 5500, .hw_value = 100,},
92	{.center_freq = 5520, .hw_value = 104,},
93	{.center_freq = 5540, .hw_value = 108,},
94	{.center_freq = 5560, .hw_value = 112,},
95	{.center_freq = 5580, .hw_value = 116,},
96	{.center_freq = 5600, .hw_value = 120,},
97	{.center_freq = 5620, .hw_value = 124,},
98	{.center_freq = 5640, .hw_value = 128,},
99	{.center_freq = 5660, .hw_value = 132,},
100	{.center_freq = 5680, .hw_value = 136,},
101	{.center_freq = 5700, .hw_value = 140,},
102	{.center_freq = 5745, .hw_value = 149,},
103	{.center_freq = 5765, .hw_value = 153,},
104	{.center_freq = 5785, .hw_value = 157,},
105	{.center_freq = 5805, .hw_value = 161,},
106	{.center_freq = 5825, .hw_value = 165,},
107};
108
109static struct ieee80211_rate rtl_ratetable_2g[] = {
110	{.bitrate = 10, .hw_value = 0x00,},
111	{.bitrate = 20, .hw_value = 0x01,},
112	{.bitrate = 55, .hw_value = 0x02,},
113	{.bitrate = 110, .hw_value = 0x03,},
114	{.bitrate = 60, .hw_value = 0x04,},
115	{.bitrate = 90, .hw_value = 0x05,},
116	{.bitrate = 120, .hw_value = 0x06,},
117	{.bitrate = 180, .hw_value = 0x07,},
118	{.bitrate = 240, .hw_value = 0x08,},
119	{.bitrate = 360, .hw_value = 0x09,},
120	{.bitrate = 480, .hw_value = 0x0a,},
121	{.bitrate = 540, .hw_value = 0x0b,},
122};
123
124static struct ieee80211_rate rtl_ratetable_5g[] = {
125	{.bitrate = 60, .hw_value = 0x04,},
126	{.bitrate = 90, .hw_value = 0x05,},
127	{.bitrate = 120, .hw_value = 0x06,},
128	{.bitrate = 180, .hw_value = 0x07,},
129	{.bitrate = 240, .hw_value = 0x08,},
130	{.bitrate = 360, .hw_value = 0x09,},
131	{.bitrate = 480, .hw_value = 0x0a,},
132	{.bitrate = 540, .hw_value = 0x0b,},
133};
134
135static const struct ieee80211_supported_band rtl_band_2ghz = {
136	.band = IEEE80211_BAND_2GHZ,
137
138	.channels = rtl_channeltable_2g,
139	.n_channels = ARRAY_SIZE(rtl_channeltable_2g),
140
141	.bitrates = rtl_ratetable_2g,
142	.n_bitrates = ARRAY_SIZE(rtl_ratetable_2g),
143
144	.ht_cap = {0},
145};
146
147static struct ieee80211_supported_band rtl_band_5ghz = {
148	.band = IEEE80211_BAND_5GHZ,
149
150	.channels = rtl_channeltable_5g,
151	.n_channels = ARRAY_SIZE(rtl_channeltable_5g),
152
153	.bitrates = rtl_ratetable_5g,
154	.n_bitrates = ARRAY_SIZE(rtl_ratetable_5g),
155
156	.ht_cap = {0},
157};
158
159static const u8 tid_to_ac[] = {
160	2, /* IEEE80211_AC_BE */
161	3, /* IEEE80211_AC_BK */
162	3, /* IEEE80211_AC_BK */
163	2, /* IEEE80211_AC_BE */
164	1, /* IEEE80211_AC_VI */
165	1, /* IEEE80211_AC_VI */
166	0, /* IEEE80211_AC_VO */
167	0, /* IEEE80211_AC_VO */
168};
169
170u8 rtl_tid_to_ac(struct ieee80211_hw *hw, u8 tid)
171{
172	return tid_to_ac[tid];
173}
174
175static void _rtl_init_hw_ht_capab(struct ieee80211_hw *hw,
176				  struct ieee80211_sta_ht_cap *ht_cap)
177{
178	struct rtl_priv *rtlpriv = rtl_priv(hw);
179	struct rtl_phy *rtlphy = &(rtlpriv->phy);
180
181	ht_cap->ht_supported = true;
182	ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
183	    IEEE80211_HT_CAP_SGI_40 |
184	    IEEE80211_HT_CAP_SGI_20 |
185	    IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU;
186
187	if (rtlpriv->rtlhal.disable_amsdu_8k)
188		ht_cap->cap &= ~IEEE80211_HT_CAP_MAX_AMSDU;
189
190	/*
191	 *Maximum length of AMPDU that the STA can receive.
192	 *Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets)
193	 */
194	ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
195
196	/*Minimum MPDU start spacing , */
197	ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
198
199	ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
200
201	/*
202	 *hw->wiphy->bands[IEEE80211_BAND_2GHZ]
203	 *base on ant_num
204	 *rx_mask: RX mask
205	 *if rx_ant =1 rx_mask[0]=0xff;==>MCS0-MCS7
206	 *if rx_ant =2 rx_mask[1]=0xff;==>MCS8-MCS15
207	 *if rx_ant >=3 rx_mask[2]=0xff;
208	 *if BW_40 rx_mask[4]=0x01;
209	 *highest supported RX rate
210	 */
211	if (get_rf_type(rtlphy) == RF_1T2R || get_rf_type(rtlphy) == RF_2T2R) {
212
213		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "1T2R or 2T2R\n");
214
215		ht_cap->mcs.rx_mask[0] = 0xFF;
216		ht_cap->mcs.rx_mask[1] = 0xFF;
217		ht_cap->mcs.rx_mask[4] = 0x01;
218
219		ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS15);
220	} else if (get_rf_type(rtlphy) == RF_1T1R) {
221
222		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "1T1R\n");
223
224		ht_cap->mcs.rx_mask[0] = 0xFF;
225		ht_cap->mcs.rx_mask[1] = 0x00;
226		ht_cap->mcs.rx_mask[4] = 0x01;
227
228		ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7);
229	}
230}
231
232static void _rtl_init_mac80211(struct ieee80211_hw *hw)
233{
234	struct rtl_priv *rtlpriv = rtl_priv(hw);
235	struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
236	struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw));
237	struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
238	struct ieee80211_supported_band *sband;
239
240
241	if (rtlhal->macphymode == SINGLEMAC_SINGLEPHY && rtlhal->bandset ==
242	    BAND_ON_BOTH) {
243		/* 1: 2.4 G bands */
244		/* <1> use  mac->bands as mem for hw->wiphy->bands */
245		sband = &(rtlmac->bands[IEEE80211_BAND_2GHZ]);
246
247		/* <2> set hw->wiphy->bands[IEEE80211_BAND_2GHZ]
248		 * to default value(1T1R) */
249		memcpy(&(rtlmac->bands[IEEE80211_BAND_2GHZ]), &rtl_band_2ghz,
250				sizeof(struct ieee80211_supported_band));
251
252		/* <3> init ht cap base on ant_num */
253		_rtl_init_hw_ht_capab(hw, &sband->ht_cap);
254
255		/* <4> set mac->sband to wiphy->sband */
256		hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
257
258		/* 2: 5 G bands */
259		/* <1> use  mac->bands as mem for hw->wiphy->bands */
260		sband = &(rtlmac->bands[IEEE80211_BAND_5GHZ]);
261
262		/* <2> set hw->wiphy->bands[IEEE80211_BAND_5GHZ]
263		 * to default value(1T1R) */
264		memcpy(&(rtlmac->bands[IEEE80211_BAND_5GHZ]), &rtl_band_5ghz,
265				sizeof(struct ieee80211_supported_band));
266
267		/* <3> init ht cap base on ant_num */
268		_rtl_init_hw_ht_capab(hw, &sband->ht_cap);
269
270		/* <4> set mac->sband to wiphy->sband */
271		hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
272	} else {
273		if (rtlhal->current_bandtype == BAND_ON_2_4G) {
274			/* <1> use  mac->bands as mem for hw->wiphy->bands */
275			sband = &(rtlmac->bands[IEEE80211_BAND_2GHZ]);
276
277			/* <2> set hw->wiphy->bands[IEEE80211_BAND_2GHZ]
278			 * to default value(1T1R) */
279			memcpy(&(rtlmac->bands[IEEE80211_BAND_2GHZ]),
280				 &rtl_band_2ghz,
281				 sizeof(struct ieee80211_supported_band));
282
283			/* <3> init ht cap base on ant_num */
284			_rtl_init_hw_ht_capab(hw, &sband->ht_cap);
285
286			/* <4> set mac->sband to wiphy->sband */
287			hw->wiphy->bands[IEEE80211_BAND_2GHZ] = sband;
288		} else if (rtlhal->current_bandtype == BAND_ON_5G) {
289			/* <1> use  mac->bands as mem for hw->wiphy->bands */
290			sband = &(rtlmac->bands[IEEE80211_BAND_5GHZ]);
291
292			/* <2> set hw->wiphy->bands[IEEE80211_BAND_5GHZ]
293			 * to default value(1T1R) */
294			memcpy(&(rtlmac->bands[IEEE80211_BAND_5GHZ]),
295				 &rtl_band_5ghz,
296				 sizeof(struct ieee80211_supported_band));
297
298			/* <3> init ht cap base on ant_num */
299			_rtl_init_hw_ht_capab(hw, &sband->ht_cap);
300
301			/* <4> set mac->sband to wiphy->sband */
302			hw->wiphy->bands[IEEE80211_BAND_5GHZ] = sband;
303		} else {
304			RT_TRACE(rtlpriv, COMP_INIT, DBG_EMERG, "Err BAND %d\n",
305				 rtlhal->current_bandtype);
306		}
307	}
308	/* <5> set hw caps */
309	hw->flags = IEEE80211_HW_SIGNAL_DBM |
310	    IEEE80211_HW_RX_INCLUDES_FCS |
311	    IEEE80211_HW_AMPDU_AGGREGATION |
312	    IEEE80211_HW_CONNECTION_MONITOR |
313	    /* IEEE80211_HW_SUPPORTS_CQM_RSSI | */
314	    IEEE80211_HW_REPORTS_TX_ACK_STATUS | 0;
315
316	/* swlps or hwlps has been set in diff chip in init_sw_vars */
317	if (rtlpriv->psc.swctrl_lps)
318		hw->flags |= IEEE80211_HW_SUPPORTS_PS |
319			IEEE80211_HW_PS_NULLFUNC_STACK |
320			/* IEEE80211_HW_SUPPORTS_DYNAMIC_PS | */
321			0;
322
323	hw->wiphy->interface_modes =
324	    BIT(NL80211_IFTYPE_AP) |
325	    BIT(NL80211_IFTYPE_STATION) |
326	    BIT(NL80211_IFTYPE_ADHOC);
327
328	hw->wiphy->rts_threshold = 2347;
329
330	hw->queues = AC_MAX;
331	hw->extra_tx_headroom = RTL_TX_HEADER_SIZE;
332
333	/* TODO: Correct this value for our hw */
334	/* TODO: define these hard code value */
335	hw->channel_change_time = 100;
336	hw->max_listen_interval = 10;
337	hw->max_rate_tries = 4;
338	/* hw->max_rates = 1; */
339	hw->sta_data_size = sizeof(struct rtl_sta_info);
340
341	/* <6> mac address */
342	if (is_valid_ether_addr(rtlefuse->dev_addr)) {
343		SET_IEEE80211_PERM_ADDR(hw, rtlefuse->dev_addr);
344	} else {
345		u8 rtlmac1[] = { 0x00, 0xe0, 0x4c, 0x81, 0x92, 0x00 };
346		get_random_bytes((rtlmac1 + (ETH_ALEN - 1)), 1);
347		SET_IEEE80211_PERM_ADDR(hw, rtlmac1);
348	}
349
350}
351
352static void _rtl_init_deferred_work(struct ieee80211_hw *hw)
353{
354	struct rtl_priv *rtlpriv = rtl_priv(hw);
355
356	/* <1> timer */
357	init_timer(&rtlpriv->works.watchdog_timer);
358	setup_timer(&rtlpriv->works.watchdog_timer,
359		    rtl_watch_dog_timer_callback, (unsigned long)hw);
360
361	/* <2> work queue */
362	rtlpriv->works.hw = hw;
363	rtlpriv->works.rtl_wq = alloc_workqueue(rtlpriv->cfg->name, 0, 0);
364	INIT_DELAYED_WORK(&rtlpriv->works.watchdog_wq,
365			  (void *)rtl_watchdog_wq_callback);
366	INIT_DELAYED_WORK(&rtlpriv->works.ips_nic_off_wq,
367			  (void *)rtl_ips_nic_off_wq_callback);
368	INIT_DELAYED_WORK(&rtlpriv->works.ps_work,
369			  (void *)rtl_swlps_wq_callback);
370	INIT_DELAYED_WORK(&rtlpriv->works.ps_rfon_wq,
371			  (void *)rtl_swlps_rfon_wq_callback);
372
373}
374
375void rtl_deinit_deferred_work(struct ieee80211_hw *hw)
376{
377	struct rtl_priv *rtlpriv = rtl_priv(hw);
378
379	del_timer_sync(&rtlpriv->works.watchdog_timer);
380
381	cancel_delayed_work(&rtlpriv->works.watchdog_wq);
382	cancel_delayed_work(&rtlpriv->works.ips_nic_off_wq);
383	cancel_delayed_work(&rtlpriv->works.ps_work);
384	cancel_delayed_work(&rtlpriv->works.ps_rfon_wq);
385}
386
387void rtl_init_rfkill(struct ieee80211_hw *hw)
388{
389	struct rtl_priv *rtlpriv = rtl_priv(hw);
390
391	bool radio_state;
392	bool blocked;
393	u8 valid = 0;
394
395	/*set init state to on */
396	rtlpriv->rfkill.rfkill_state = true;
397	wiphy_rfkill_set_hw_state(hw->wiphy, 0);
398
399	radio_state = rtlpriv->cfg->ops->radio_onoff_checking(hw, &valid);
400
401	if (valid) {
402		pr_info("wireless switch is %s\n",
403			rtlpriv->rfkill.rfkill_state ? "on" : "off");
404
405		rtlpriv->rfkill.rfkill_state = radio_state;
406
407		blocked = (rtlpriv->rfkill.rfkill_state == 1) ? 0 : 1;
408		wiphy_rfkill_set_hw_state(hw->wiphy, blocked);
409	}
410
411	wiphy_rfkill_start_polling(hw->wiphy);
412}
413EXPORT_SYMBOL(rtl_init_rfkill);
414
415void rtl_deinit_rfkill(struct ieee80211_hw *hw)
416{
417	wiphy_rfkill_stop_polling(hw->wiphy);
418}
419
420int rtl_init_core(struct ieee80211_hw *hw)
421{
422	struct rtl_priv *rtlpriv = rtl_priv(hw);
423	struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw));
424
425	/* <1> init mac80211 */
426	_rtl_init_mac80211(hw);
427	rtlmac->hw = hw;
428
429	/* <2> rate control register */
430	hw->rate_control_algorithm = "rtl_rc";
431
432	/*
433	 * <3> init CRDA must come after init
434	 * mac80211 hw  in _rtl_init_mac80211.
435	 */
436	if (rtl_regd_init(hw, rtl_reg_notifier)) {
437		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "REGD init failed\n");
438		return 1;
439	} else {
440		/* CRDA regd hint must after init CRDA */
441		if (regulatory_hint(hw->wiphy, rtlpriv->regd.alpha2)) {
442			RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
443				 "regulatory_hint fail\n");
444		}
445	}
446
447	/* <4> locks */
448	mutex_init(&rtlpriv->locks.conf_mutex);
449	mutex_init(&rtlpriv->locks.ps_mutex);
450	spin_lock_init(&rtlpriv->locks.ips_lock);
451	spin_lock_init(&rtlpriv->locks.irq_th_lock);
452	spin_lock_init(&rtlpriv->locks.h2c_lock);
453	spin_lock_init(&rtlpriv->locks.rf_ps_lock);
454	spin_lock_init(&rtlpriv->locks.rf_lock);
455	spin_lock_init(&rtlpriv->locks.waitq_lock);
456	spin_lock_init(&rtlpriv->locks.cck_and_rw_pagea_lock);
457
458	rtlmac->link_state = MAC80211_NOLINK;
459
460	/* <5> init deferred work */
461	_rtl_init_deferred_work(hw);
462
463	return 0;
464}
465
466void rtl_deinit_core(struct ieee80211_hw *hw)
467{
468}
469
470void rtl_init_rx_config(struct ieee80211_hw *hw)
471{
472	struct rtl_priv *rtlpriv = rtl_priv(hw);
473	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
474
475	rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RCR, (u8 *) (&mac->rx_conf));
476}
477
478/*********************************************************
479 *
480 * tx information functions
481 *
482 *********************************************************/
483static void _rtl_qurey_shortpreamble_mode(struct ieee80211_hw *hw,
484					  struct rtl_tcb_desc *tcb_desc,
485					  struct ieee80211_tx_info *info)
486{
487	struct rtl_priv *rtlpriv = rtl_priv(hw);
488	u8 rate_flag = info->control.rates[0].flags;
489
490	tcb_desc->use_shortpreamble = false;
491
492	/* 1M can only use Long Preamble. 11B spec */
493	if (tcb_desc->hw_rate == rtlpriv->cfg->maps[RTL_RC_CCK_RATE1M])
494		return;
495	else if (rate_flag & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
496		tcb_desc->use_shortpreamble = true;
497
498	return;
499}
500
501static void _rtl_query_shortgi(struct ieee80211_hw *hw,
502			       struct ieee80211_sta *sta,
503			       struct rtl_tcb_desc *tcb_desc,
504			       struct ieee80211_tx_info *info)
505{
506	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
507	u8 rate_flag = info->control.rates[0].flags;
508	u8 sgi_40 = 0, sgi_20 = 0, bw_40 = 0;
509	tcb_desc->use_shortgi = false;
510
511	if (sta == NULL)
512		return;
513
514	sgi_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40;
515	sgi_20 = sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20;
516
517	if (!(sta->ht_cap.ht_supported))
518		return;
519
520	if (!sgi_40 && !sgi_20)
521		return;
522
523	if (mac->opmode == NL80211_IFTYPE_STATION)
524		bw_40 = mac->bw_40;
525	else if (mac->opmode == NL80211_IFTYPE_AP ||
526		mac->opmode == NL80211_IFTYPE_ADHOC)
527		bw_40 = sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40;
528
529	if (bw_40 && sgi_40)
530		tcb_desc->use_shortgi = true;
531	else if ((bw_40 == false) && sgi_20)
532		tcb_desc->use_shortgi = true;
533
534	if (!(rate_flag & IEEE80211_TX_RC_SHORT_GI))
535		tcb_desc->use_shortgi = false;
536}
537
538static void _rtl_query_protection_mode(struct ieee80211_hw *hw,
539				       struct rtl_tcb_desc *tcb_desc,
540				       struct ieee80211_tx_info *info)
541{
542	struct rtl_priv *rtlpriv = rtl_priv(hw);
543	u8 rate_flag = info->control.rates[0].flags;
544
545	/* Common Settings */
546	tcb_desc->rts_stbc = false;
547	tcb_desc->cts_enable = false;
548	tcb_desc->rts_sc = 0;
549	tcb_desc->rts_bw = false;
550	tcb_desc->rts_use_shortpreamble = false;
551	tcb_desc->rts_use_shortgi = false;
552
553	if (rate_flag & IEEE80211_TX_RC_USE_CTS_PROTECT) {
554		/* Use CTS-to-SELF in protection mode. */
555		tcb_desc->rts_enable = true;
556		tcb_desc->cts_enable = true;
557		tcb_desc->rts_rate = rtlpriv->cfg->maps[RTL_RC_OFDM_RATE24M];
558	} else if (rate_flag & IEEE80211_TX_RC_USE_RTS_CTS) {
559		/* Use RTS-CTS in protection mode. */
560		tcb_desc->rts_enable = true;
561		tcb_desc->rts_rate = rtlpriv->cfg->maps[RTL_RC_OFDM_RATE24M];
562	}
563}
564
565static void _rtl_txrate_selectmode(struct ieee80211_hw *hw,
566				   struct ieee80211_sta *sta,
567				   struct rtl_tcb_desc *tcb_desc)
568{
569	struct rtl_priv *rtlpriv = rtl_priv(hw);
570	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
571	struct rtl_sta_info *sta_entry = NULL;
572	u8 ratr_index = 7;
573
574	if (sta) {
575		sta_entry = (struct rtl_sta_info *) sta->drv_priv;
576		ratr_index = sta_entry->ratr_index;
577	}
578	if (!tcb_desc->disable_ratefallback || !tcb_desc->use_driver_rate) {
579		if (mac->opmode == NL80211_IFTYPE_STATION) {
580			tcb_desc->ratr_index = 0;
581		} else if (mac->opmode == NL80211_IFTYPE_ADHOC) {
582			if (tcb_desc->multicast || tcb_desc->broadcast) {
583				tcb_desc->hw_rate =
584				    rtlpriv->cfg->maps[RTL_RC_CCK_RATE2M];
585				tcb_desc->use_driver_rate = 1;
586			} else {
587				/* TODO */
588			}
589			tcb_desc->ratr_index = ratr_index;
590		} else if (mac->opmode == NL80211_IFTYPE_AP) {
591			tcb_desc->ratr_index = ratr_index;
592		}
593	}
594
595	if (rtlpriv->dm.useramask) {
596		/* TODO we will differentiate adhoc and station futrue  */
597		if (mac->opmode == NL80211_IFTYPE_STATION) {
598			tcb_desc->mac_id = 0;
599
600			if (mac->mode == WIRELESS_MODE_N_24G)
601				tcb_desc->ratr_index = RATR_INX_WIRELESS_NGB;
602			else if (mac->mode == WIRELESS_MODE_N_5G)
603				tcb_desc->ratr_index = RATR_INX_WIRELESS_NG;
604			else if (mac->mode & WIRELESS_MODE_G)
605				tcb_desc->ratr_index = RATR_INX_WIRELESS_GB;
606			else if (mac->mode & WIRELESS_MODE_B)
607				tcb_desc->ratr_index = RATR_INX_WIRELESS_B;
608			else if (mac->mode & WIRELESS_MODE_A)
609				tcb_desc->ratr_index = RATR_INX_WIRELESS_G;
610		} else if (mac->opmode == NL80211_IFTYPE_AP ||
611			mac->opmode == NL80211_IFTYPE_ADHOC) {
612			if (NULL != sta) {
613				if (sta->aid > 0)
614					tcb_desc->mac_id = sta->aid + 1;
615				else
616					tcb_desc->mac_id = 1;
617			} else {
618				tcb_desc->mac_id = 0;
619			}
620		}
621	}
622
623}
624
625static void _rtl_query_bandwidth_mode(struct ieee80211_hw *hw,
626				      struct ieee80211_sta *sta,
627				      struct rtl_tcb_desc *tcb_desc)
628{
629	struct rtl_priv *rtlpriv = rtl_priv(hw);
630	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
631
632	tcb_desc->packet_bw = false;
633	if (!sta)
634		return;
635	if (mac->opmode == NL80211_IFTYPE_AP ||
636	    mac->opmode == NL80211_IFTYPE_ADHOC) {
637		if (!(sta->ht_cap.ht_supported) ||
638		    !(sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40))
639			return;
640	} else if (mac->opmode == NL80211_IFTYPE_STATION) {
641		if (!mac->bw_40 || !(sta->ht_cap.ht_supported))
642			return;
643	}
644	if (tcb_desc->multicast || tcb_desc->broadcast)
645		return;
646
647	/*use legency rate, shall use 20MHz */
648	if (tcb_desc->hw_rate <= rtlpriv->cfg->maps[RTL_RC_OFDM_RATE54M])
649		return;
650
651	tcb_desc->packet_bw = true;
652}
653
654static u8 _rtl_get_highest_n_rate(struct ieee80211_hw *hw)
655{
656	struct rtl_priv *rtlpriv = rtl_priv(hw);
657	struct rtl_phy *rtlphy = &(rtlpriv->phy);
658	u8 hw_rate;
659
660	if (get_rf_type(rtlphy) == RF_2T2R)
661		hw_rate = rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS15];
662	else
663		hw_rate = rtlpriv->cfg->maps[RTL_RC_HT_RATEMCS7];
664
665	return hw_rate;
666}
667
668/* mac80211's rate_idx is like this:
669 *
670 * 2.4G band:rx_status->band == IEEE80211_BAND_2GHZ
671 *
672 * B/G rate:
673 * (rx_status->flag & RX_FLAG_HT) = 0,
674 * DESC92_RATE1M-->DESC92_RATE54M ==> idx is 0-->11,
675 *
676 * N rate:
677 * (rx_status->flag & RX_FLAG_HT) = 1,
678 * DESC92_RATEMCS0-->DESC92_RATEMCS15 ==> idx is 0-->15
679 *
680 * 5G band:rx_status->band == IEEE80211_BAND_5GHZ
681 * A rate:
682 * (rx_status->flag & RX_FLAG_HT) = 0,
683 * DESC92_RATE6M-->DESC92_RATE54M ==> idx is 0-->7,
684 *
685 * N rate:
686 * (rx_status->flag & RX_FLAG_HT) = 1,
687 * DESC92_RATEMCS0-->DESC92_RATEMCS15 ==> idx is 0-->15
688 */
689int rtlwifi_rate_mapping(struct ieee80211_hw *hw,
690			 bool isht, u8 desc_rate, bool first_ampdu)
691{
692	int rate_idx;
693
694	if (false == isht) {
695		if (IEEE80211_BAND_2GHZ == hw->conf.channel->band) {
696			switch (desc_rate) {
697			case DESC92_RATE1M:
698				rate_idx = 0;
699				break;
700			case DESC92_RATE2M:
701				rate_idx = 1;
702				break;
703			case DESC92_RATE5_5M:
704				rate_idx = 2;
705				break;
706			case DESC92_RATE11M:
707				rate_idx = 3;
708				break;
709			case DESC92_RATE6M:
710				rate_idx = 4;
711				break;
712			case DESC92_RATE9M:
713				rate_idx = 5;
714				break;
715			case DESC92_RATE12M:
716				rate_idx = 6;
717				break;
718			case DESC92_RATE18M:
719				rate_idx = 7;
720				break;
721			case DESC92_RATE24M:
722				rate_idx = 8;
723				break;
724			case DESC92_RATE36M:
725				rate_idx = 9;
726				break;
727			case DESC92_RATE48M:
728				rate_idx = 10;
729				break;
730			case DESC92_RATE54M:
731				rate_idx = 11;
732				break;
733			default:
734				rate_idx = 0;
735				break;
736			}
737		} else {
738			switch (desc_rate) {
739			case DESC92_RATE6M:
740				rate_idx = 0;
741				break;
742			case DESC92_RATE9M:
743				rate_idx = 1;
744				break;
745			case DESC92_RATE12M:
746				rate_idx = 2;
747				break;
748			case DESC92_RATE18M:
749				rate_idx = 3;
750				break;
751			case DESC92_RATE24M:
752				rate_idx = 4;
753				break;
754			case DESC92_RATE36M:
755				rate_idx = 5;
756				break;
757			case DESC92_RATE48M:
758				rate_idx = 6;
759				break;
760			case DESC92_RATE54M:
761				rate_idx = 7;
762				break;
763			default:
764				rate_idx = 0;
765				break;
766			}
767		}
768
769	} else {
770
771		switch (desc_rate) {
772		case DESC92_RATEMCS0:
773			rate_idx = 0;
774			break;
775		case DESC92_RATEMCS1:
776			rate_idx = 1;
777			break;
778		case DESC92_RATEMCS2:
779			rate_idx = 2;
780			break;
781		case DESC92_RATEMCS3:
782			rate_idx = 3;
783			break;
784		case DESC92_RATEMCS4:
785			rate_idx = 4;
786			break;
787		case DESC92_RATEMCS5:
788			rate_idx = 5;
789			break;
790		case DESC92_RATEMCS6:
791			rate_idx = 6;
792			break;
793		case DESC92_RATEMCS7:
794			rate_idx = 7;
795			break;
796		case DESC92_RATEMCS8:
797			rate_idx = 8;
798			break;
799		case DESC92_RATEMCS9:
800			rate_idx = 9;
801			break;
802		case DESC92_RATEMCS10:
803			rate_idx = 10;
804			break;
805		case DESC92_RATEMCS11:
806			rate_idx = 11;
807			break;
808		case DESC92_RATEMCS12:
809			rate_idx = 12;
810			break;
811		case DESC92_RATEMCS13:
812			rate_idx = 13;
813			break;
814		case DESC92_RATEMCS14:
815			rate_idx = 14;
816			break;
817		case DESC92_RATEMCS15:
818			rate_idx = 15;
819			break;
820		default:
821			rate_idx = 0;
822			break;
823		}
824	}
825	return rate_idx;
826}
827EXPORT_SYMBOL(rtlwifi_rate_mapping);
828
829void rtl_get_tcb_desc(struct ieee80211_hw *hw,
830		      struct ieee80211_tx_info *info,
831		      struct ieee80211_sta *sta,
832		      struct sk_buff *skb, struct rtl_tcb_desc *tcb_desc)
833{
834	struct rtl_priv *rtlpriv = rtl_priv(hw);
835	struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw));
836	struct ieee80211_hdr *hdr = rtl_get_hdr(skb);
837	struct ieee80211_rate *txrate;
838	__le16 fc = hdr->frame_control;
839
840	txrate = ieee80211_get_tx_rate(hw, info);
841	if (txrate)
842		tcb_desc->hw_rate = txrate->hw_value;
843	else
844		tcb_desc->hw_rate = 0;
845
846	if (ieee80211_is_data(fc)) {
847		/*
848		 *we set data rate INX 0
849		 *in rtl_rc.c   if skb is special data or
850		 *mgt which need low data rate.
851		 */
852
853		/*
854		 *So tcb_desc->hw_rate is just used for
855		 *special data and mgt frames
856		 */
857		if (info->control.rates[0].idx == 0 ||
858				ieee80211_is_nullfunc(fc)) {
859			tcb_desc->use_driver_rate = true;
860			tcb_desc->ratr_index = RATR_INX_WIRELESS_MC;
861
862			tcb_desc->disable_ratefallback = 1;
863		} else {
864			/*
865			 *because hw will nerver use hw_rate
866			 *when tcb_desc->use_driver_rate = false
867			 *so we never set highest N rate here,
868			 *and N rate will all be controlled by FW
869			 *when tcb_desc->use_driver_rate = false
870			 */
871			if (sta && (sta->ht_cap.ht_supported)) {
872				tcb_desc->hw_rate = _rtl_get_highest_n_rate(hw);
873			} else {
874				if (rtlmac->mode == WIRELESS_MODE_B) {
875					tcb_desc->hw_rate =
876					   rtlpriv->cfg->maps[RTL_RC_CCK_RATE11M];
877				} else {
878					tcb_desc->hw_rate =
879					   rtlpriv->cfg->maps[RTL_RC_OFDM_RATE54M];
880				}
881			}
882		}
883
884		if (is_multicast_ether_addr(ieee80211_get_DA(hdr)))
885			tcb_desc->multicast = 1;
886		else if (is_broadcast_ether_addr(ieee80211_get_DA(hdr)))
887			tcb_desc->broadcast = 1;
888
889		_rtl_txrate_selectmode(hw, sta, tcb_desc);
890		_rtl_query_bandwidth_mode(hw, sta, tcb_desc);
891		_rtl_qurey_shortpreamble_mode(hw, tcb_desc, info);
892		_rtl_query_shortgi(hw, sta, tcb_desc, info);
893		_rtl_query_protection_mode(hw, tcb_desc, info);
894	} else {
895		tcb_desc->use_driver_rate = true;
896		tcb_desc->ratr_index = RATR_INX_WIRELESS_MC;
897		tcb_desc->disable_ratefallback = 1;
898		tcb_desc->mac_id = 0;
899		tcb_desc->packet_bw = false;
900	}
901}
902EXPORT_SYMBOL(rtl_get_tcb_desc);
903
904bool rtl_action_proc(struct ieee80211_hw *hw, struct sk_buff *skb, u8 is_tx)
905{
906	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
907	struct ieee80211_hdr *hdr = rtl_get_hdr(skb);
908	struct rtl_priv *rtlpriv = rtl_priv(hw);
909	__le16 fc = hdr->frame_control;
910	u8 *act = (u8 *) (((u8 *) skb->data + MAC80211_3ADDR_LEN));
911	u8 category;
912
913	if (!ieee80211_is_action(fc))
914		return true;
915
916	category = *act;
917	act++;
918	switch (category) {
919	case ACT_CAT_BA:
920		switch (*act) {
921		case ACT_ADDBAREQ:
922			if (mac->act_scanning)
923				return false;
924
925			RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
926				 "%s ACT_ADDBAREQ From :%pM\n",
927				 is_tx ? "Tx" : "Rx", hdr->addr2);
928			break;
929		case ACT_ADDBARSP:
930			RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
931				 "%s ACT_ADDBARSP From :%pM\n",
932				 is_tx ? "Tx" : "Rx", hdr->addr2);
933			break;
934		case ACT_DELBA:
935			RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
936				 "ACT_ADDBADEL From :%pM\n", hdr->addr2);
937			break;
938		}
939		break;
940	default:
941		break;
942	}
943
944	return true;
945}
946
947/*should call before software enc*/
948u8 rtl_is_special_data(struct ieee80211_hw *hw, struct sk_buff *skb, u8 is_tx)
949{
950	struct rtl_priv *rtlpriv = rtl_priv(hw);
951	struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
952	__le16 fc = rtl_get_fc(skb);
953	u16 ether_type;
954	u8 mac_hdr_len = ieee80211_get_hdrlen_from_skb(skb);
955	const struct iphdr *ip;
956
957	if (!ieee80211_is_data(fc))
958		return false;
959
960
961	ip = (struct iphdr *)((u8 *) skb->data + mac_hdr_len +
962			      SNAP_SIZE + PROTOC_TYPE_SIZE);
963	ether_type = *(u16 *) ((u8 *) skb->data + mac_hdr_len + SNAP_SIZE);
964	/*	ether_type = ntohs(ether_type); */
965
966	if (ETH_P_IP == ether_type) {
967		if (IPPROTO_UDP == ip->protocol) {
968			struct udphdr *udp = (struct udphdr *)((u8 *) ip +
969							       (ip->ihl << 2));
970			if (((((u8 *) udp)[1] == 68) &&
971			     (((u8 *) udp)[3] == 67)) ||
972			    ((((u8 *) udp)[1] == 67) &&
973			     (((u8 *) udp)[3] == 68))) {
974				/*
975				 * 68 : UDP BOOTP client
976				 * 67 : UDP BOOTP server
977				 */
978				RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV),
979					 DBG_DMESG, "dhcp %s !!\n",
980					 is_tx ? "Tx" : "Rx");
981
982				if (is_tx) {
983					rtl_lps_leave(hw);
984					ppsc->last_delaylps_stamp_jiffies =
985					    jiffies;
986				}
987
988				return true;
989			}
990		}
991	} else if (ETH_P_ARP == ether_type) {
992		if (is_tx) {
993			rtl_lps_leave(hw);
994			ppsc->last_delaylps_stamp_jiffies = jiffies;
995		}
996
997		return true;
998	} else if (ETH_P_PAE == ether_type) {
999		RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
1000			 "802.1X %s EAPOL pkt!!\n", is_tx ? "Tx" : "Rx");
1001
1002		if (is_tx) {
1003			rtl_lps_leave(hw);
1004			ppsc->last_delaylps_stamp_jiffies = jiffies;
1005		}
1006
1007		return true;
1008	} else if (ETH_P_IPV6 == ether_type) {
1009		/* IPv6 */
1010		return true;
1011	}
1012
1013	return false;
1014}
1015
1016/*********************************************************
1017 *
1018 * functions called by core.c
1019 *
1020 *********************************************************/
1021int rtl_tx_agg_start(struct ieee80211_hw *hw,
1022		struct ieee80211_sta *sta, u16 tid, u16 *ssn)
1023{
1024	struct rtl_priv *rtlpriv = rtl_priv(hw);
1025	struct rtl_tid_data *tid_data;
1026	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1027	struct rtl_sta_info *sta_entry = NULL;
1028
1029	if (sta == NULL)
1030		return -EINVAL;
1031
1032	if (unlikely(tid >= MAX_TID_COUNT))
1033		return -EINVAL;
1034
1035	sta_entry = (struct rtl_sta_info *)sta->drv_priv;
1036	if (!sta_entry)
1037		return -ENXIO;
1038	tid_data = &sta_entry->tids[tid];
1039
1040	RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "on ra = %pM tid = %d seq:%d\n",
1041		 sta->addr, tid, tid_data->seq_number);
1042
1043	*ssn = tid_data->seq_number;
1044	tid_data->agg.agg_state = RTL_AGG_START;
1045
1046	ieee80211_start_tx_ba_cb_irqsafe(mac->vif, sta->addr, tid);
1047
1048	return 0;
1049}
1050
1051int rtl_tx_agg_stop(struct ieee80211_hw *hw,
1052		struct ieee80211_sta *sta, u16 tid)
1053{
1054	struct rtl_priv *rtlpriv = rtl_priv(hw);
1055	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1056	struct rtl_sta_info *sta_entry = NULL;
1057
1058	if (sta == NULL)
1059		return -EINVAL;
1060
1061	if (!sta->addr) {
1062		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "ra = NULL\n");
1063		return -EINVAL;
1064	}
1065
1066	RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "on ra = %pM tid = %d\n",
1067		 sta->addr, tid);
1068
1069	if (unlikely(tid >= MAX_TID_COUNT))
1070		return -EINVAL;
1071
1072	sta_entry = (struct rtl_sta_info *)sta->drv_priv;
1073	sta_entry->tids[tid].agg.agg_state = RTL_AGG_STOP;
1074
1075	ieee80211_stop_tx_ba_cb_irqsafe(mac->vif, sta->addr, tid);
1076
1077	return 0;
1078}
1079
1080int rtl_tx_agg_oper(struct ieee80211_hw *hw,
1081		struct ieee80211_sta *sta, u16 tid)
1082{
1083	struct rtl_priv *rtlpriv = rtl_priv(hw);
1084	struct rtl_sta_info *sta_entry = NULL;
1085
1086	if (sta == NULL)
1087		return -EINVAL;
1088
1089	if (!sta->addr) {
1090		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "ra = NULL\n");
1091		return -EINVAL;
1092	}
1093
1094	RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, "on ra = %pM tid = %d\n",
1095		 sta->addr, tid);
1096
1097	if (unlikely(tid >= MAX_TID_COUNT))
1098		return -EINVAL;
1099
1100	sta_entry = (struct rtl_sta_info *)sta->drv_priv;
1101	sta_entry->tids[tid].agg.agg_state = RTL_AGG_OPERATIONAL;
1102
1103	return 0;
1104}
1105
1106/*********************************************************
1107 *
1108 * wq & timer callback functions
1109 *
1110 *********************************************************/
1111void rtl_watchdog_wq_callback(void *data)
1112{
1113	struct rtl_works *rtlworks = container_of_dwork_rtl(data,
1114							    struct rtl_works,
1115							    watchdog_wq);
1116	struct ieee80211_hw *hw = rtlworks->hw;
1117	struct rtl_priv *rtlpriv = rtl_priv(hw);
1118	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1119	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1120	bool busytraffic = false;
1121	bool higher_busytraffic = false;
1122	bool higher_busyrxtraffic = false;
1123	u8 idx, tid;
1124	u32 rx_cnt_inp4eriod = 0;
1125	u32 tx_cnt_inp4eriod = 0;
1126	u32 aver_rx_cnt_inperiod = 0;
1127	u32 aver_tx_cnt_inperiod = 0;
1128	u32 aver_tidtx_inperiod[MAX_TID_COUNT] = {0};
1129	u32 tidtx_inp4eriod[MAX_TID_COUNT] = {0};
1130	bool enter_ps = false;
1131
1132	if (is_hal_stop(rtlhal))
1133		return;
1134
1135	/* <1> Determine if action frame is allowed */
1136	if (mac->link_state > MAC80211_NOLINK) {
1137		if (mac->cnt_after_linked < 20)
1138			mac->cnt_after_linked++;
1139	} else {
1140		mac->cnt_after_linked = 0;
1141	}
1142
1143	/*
1144	 *<2> to check if traffic busy, if
1145	 * busytraffic we don't change channel
1146	 */
1147	if (mac->link_state >= MAC80211_LINKED) {
1148
1149		/* (1) get aver_rx_cnt_inperiod & aver_tx_cnt_inperiod */
1150		for (idx = 0; idx <= 2; idx++) {
1151			rtlpriv->link_info.num_rx_in4period[idx] =
1152			    rtlpriv->link_info.num_rx_in4period[idx + 1];
1153			rtlpriv->link_info.num_tx_in4period[idx] =
1154			    rtlpriv->link_info.num_tx_in4period[idx + 1];
1155		}
1156		rtlpriv->link_info.num_rx_in4period[3] =
1157		    rtlpriv->link_info.num_rx_inperiod;
1158		rtlpriv->link_info.num_tx_in4period[3] =
1159		    rtlpriv->link_info.num_tx_inperiod;
1160		for (idx = 0; idx <= 3; idx++) {
1161			rx_cnt_inp4eriod +=
1162			    rtlpriv->link_info.num_rx_in4period[idx];
1163			tx_cnt_inp4eriod +=
1164			    rtlpriv->link_info.num_tx_in4period[idx];
1165		}
1166		aver_rx_cnt_inperiod = rx_cnt_inp4eriod / 4;
1167		aver_tx_cnt_inperiod = tx_cnt_inp4eriod / 4;
1168
1169		/* (2) check traffic busy */
1170		if (aver_rx_cnt_inperiod > 100 || aver_tx_cnt_inperiod > 100)
1171			busytraffic = true;
1172
1173		/* Higher Tx/Rx data. */
1174		if (aver_rx_cnt_inperiod > 4000 ||
1175		    aver_tx_cnt_inperiod > 4000) {
1176			higher_busytraffic = true;
1177
1178			/* Extremely high Rx data. */
1179			if (aver_rx_cnt_inperiod > 5000)
1180				higher_busyrxtraffic = true;
1181		}
1182
1183		/* check every tid's tx traffic */
1184		for (tid = 0; tid <= 7; tid++) {
1185			for (idx = 0; idx <= 2; idx++)
1186				rtlpriv->link_info.tidtx_in4period[tid][idx] =
1187				  rtlpriv->link_info.tidtx_in4period[tid]
1188				  [idx + 1];
1189			rtlpriv->link_info.tidtx_in4period[tid][3] =
1190				rtlpriv->link_info.tidtx_inperiod[tid];
1191
1192			for (idx = 0; idx <= 3; idx++)
1193				tidtx_inp4eriod[tid] +=
1194				  rtlpriv->link_info.tidtx_in4period[tid][idx];
1195			aver_tidtx_inperiod[tid] = tidtx_inp4eriod[tid] / 4;
1196			if (aver_tidtx_inperiod[tid] > 5000)
1197				rtlpriv->link_info.higher_busytxtraffic[tid] =
1198						   true;
1199			else
1200				rtlpriv->link_info.higher_busytxtraffic[tid] =
1201						   false;
1202		}
1203
1204		if (((rtlpriv->link_info.num_rx_inperiod +
1205		      rtlpriv->link_info.num_tx_inperiod) > 8) ||
1206		    (rtlpriv->link_info.num_rx_inperiod > 2))
1207			enter_ps = false;
1208		else
1209			enter_ps = true;
1210
1211		/* LeisurePS only work in infra mode. */
1212		if (enter_ps)
1213			rtl_lps_enter(hw);
1214		else
1215			rtl_lps_leave(hw);
1216	}
1217
1218	rtlpriv->link_info.num_rx_inperiod = 0;
1219	rtlpriv->link_info.num_tx_inperiod = 0;
1220	for (tid = 0; tid <= 7; tid++)
1221		rtlpriv->link_info.tidtx_inperiod[tid] = 0;
1222
1223	rtlpriv->link_info.busytraffic = busytraffic;
1224	rtlpriv->link_info.higher_busytraffic = higher_busytraffic;
1225	rtlpriv->link_info.higher_busyrxtraffic = higher_busyrxtraffic;
1226
1227	/* <3> DM */
1228	rtlpriv->cfg->ops->dm_watchdog(hw);
1229}
1230
1231void rtl_watch_dog_timer_callback(unsigned long data)
1232{
1233	struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
1234	struct rtl_priv *rtlpriv = rtl_priv(hw);
1235
1236	queue_delayed_work(rtlpriv->works.rtl_wq,
1237			   &rtlpriv->works.watchdog_wq, 0);
1238
1239	mod_timer(&rtlpriv->works.watchdog_timer,
1240		  jiffies + MSECS(RTL_WATCH_DOG_TIME));
1241}
1242
1243/*********************************************************
1244 *
1245 * frame process functions
1246 *
1247 *********************************************************/
1248u8 *rtl_find_ie(u8 *data, unsigned int len, u8 ie)
1249{
1250	struct ieee80211_mgmt *mgmt = (void *)data;
1251	u8 *pos, *end;
1252
1253	pos = (u8 *)mgmt->u.beacon.variable;
1254	end = data + len;
1255	while (pos < end) {
1256		if (pos + 2 + pos[1] > end)
1257			return NULL;
1258
1259		if (pos[0] == ie)
1260			return pos;
1261
1262		pos += 2 + pos[1];
1263	}
1264	return NULL;
1265}
1266
1267/* when we use 2 rx ants we send IEEE80211_SMPS_OFF */
1268/* when we use 1 rx ant we send IEEE80211_SMPS_STATIC */
1269static struct sk_buff *rtl_make_smps_action(struct ieee80211_hw *hw,
1270		enum ieee80211_smps_mode smps, u8 *da, u8 *bssid)
1271{
1272	struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
1273	struct sk_buff *skb;
1274	struct ieee80211_mgmt *action_frame;
1275
1276	/* 27 = header + category + action + smps mode */
1277	skb = dev_alloc_skb(27 + hw->extra_tx_headroom);
1278	if (!skb)
1279		return NULL;
1280
1281	skb_reserve(skb, hw->extra_tx_headroom);
1282	action_frame = (void *)skb_put(skb, 27);
1283	memset(action_frame, 0, 27);
1284	memcpy(action_frame->da, da, ETH_ALEN);
1285	memcpy(action_frame->sa, rtlefuse->dev_addr, ETH_ALEN);
1286	memcpy(action_frame->bssid, bssid, ETH_ALEN);
1287	action_frame->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1288						  IEEE80211_STYPE_ACTION);
1289	action_frame->u.action.category = WLAN_CATEGORY_HT;
1290	action_frame->u.action.u.ht_smps.action = WLAN_HT_ACTION_SMPS;
1291	switch (smps) {
1292	case IEEE80211_SMPS_AUTOMATIC:/* 0 */
1293	case IEEE80211_SMPS_NUM_MODES:/* 4 */
1294		WARN_ON(1);
1295	case IEEE80211_SMPS_OFF:/* 1 */ /*MIMO_PS_NOLIMIT*/
1296		action_frame->u.action.u.ht_smps.smps_control =
1297				WLAN_HT_SMPS_CONTROL_DISABLED;/* 0 */
1298		break;
1299	case IEEE80211_SMPS_STATIC:/* 2 */ /*MIMO_PS_STATIC*/
1300		action_frame->u.action.u.ht_smps.smps_control =
1301				WLAN_HT_SMPS_CONTROL_STATIC;/* 1 */
1302		break;
1303	case IEEE80211_SMPS_DYNAMIC:/* 3 */ /*MIMO_PS_DYNAMIC*/
1304		action_frame->u.action.u.ht_smps.smps_control =
1305				WLAN_HT_SMPS_CONTROL_DYNAMIC;/* 3 */
1306		break;
1307	}
1308
1309	return skb;
1310}
1311
1312int rtl_send_smps_action(struct ieee80211_hw *hw,
1313		struct ieee80211_sta *sta, u8 *da, u8 *bssid,
1314		enum ieee80211_smps_mode smps)
1315{
1316	struct rtl_priv *rtlpriv = rtl_priv(hw);
1317	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1318	struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
1319	struct sk_buff *skb = rtl_make_smps_action(hw, smps, da, bssid);
1320	struct rtl_tcb_desc tcb_desc;
1321	memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc));
1322
1323	if (rtlpriv->mac80211.act_scanning)
1324		goto err_free;
1325
1326	if (!sta)
1327		goto err_free;
1328
1329	if (unlikely(is_hal_stop(rtlhal) || ppsc->rfpwr_state != ERFON))
1330		goto err_free;
1331
1332	if (!test_bit(RTL_STATUS_INTERFACE_START, &rtlpriv->status))
1333		goto err_free;
1334
1335	/* this is a type = mgmt * stype = action frame */
1336	if (skb) {
1337		struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1338		struct rtl_sta_info *sta_entry =
1339			(struct rtl_sta_info *) sta->drv_priv;
1340		sta_entry->mimo_ps = smps;
1341		rtlpriv->cfg->ops->update_rate_tbl(hw, sta, 0);
1342
1343		info->control.rates[0].idx = 0;
1344		info->control.sta = sta;
1345		info->band = hw->conf.channel->band;
1346		rtlpriv->intf_ops->adapter_tx(hw, skb, &tcb_desc);
1347	}
1348err_free:
1349	return 0;
1350}
1351
1352/*********************************************************
1353 *
1354 * IOT functions
1355 *
1356 *********************************************************/
1357static bool rtl_chk_vendor_ouisub(struct ieee80211_hw *hw,
1358		struct octet_string vendor_ie)
1359{
1360	struct rtl_priv *rtlpriv = rtl_priv(hw);
1361	bool matched = false;
1362	static u8 athcap_1[] = { 0x00, 0x03, 0x7F };
1363	static u8 athcap_2[] = { 0x00, 0x13, 0x74 };
1364	static u8 broadcap_1[] = { 0x00, 0x10, 0x18 };
1365	static u8 broadcap_2[] = { 0x00, 0x0a, 0xf7 };
1366	static u8 broadcap_3[] = { 0x00, 0x05, 0xb5 };
1367	static u8 racap[] = { 0x00, 0x0c, 0x43 };
1368	static u8 ciscocap[] = { 0x00, 0x40, 0x96 };
1369	static u8 marvcap[] = { 0x00, 0x50, 0x43 };
1370
1371	if (memcmp(vendor_ie.octet, athcap_1, 3) == 0 ||
1372		memcmp(vendor_ie.octet, athcap_2, 3) == 0) {
1373		rtlpriv->mac80211.vendor = PEER_ATH;
1374		matched = true;
1375	} else if (memcmp(vendor_ie.octet, broadcap_1, 3) == 0 ||
1376		memcmp(vendor_ie.octet, broadcap_2, 3) == 0 ||
1377		memcmp(vendor_ie.octet, broadcap_3, 3) == 0) {
1378		rtlpriv->mac80211.vendor = PEER_BROAD;
1379		matched = true;
1380	} else if (memcmp(vendor_ie.octet, racap, 3) == 0) {
1381		rtlpriv->mac80211.vendor = PEER_RAL;
1382		matched = true;
1383	} else if (memcmp(vendor_ie.octet, ciscocap, 3) == 0) {
1384		rtlpriv->mac80211.vendor = PEER_CISCO;
1385		matched = true;
1386	} else if (memcmp(vendor_ie.octet, marvcap, 3) == 0) {
1387		rtlpriv->mac80211.vendor = PEER_MARV;
1388		matched = true;
1389	}
1390
1391	return matched;
1392}
1393
1394static bool rtl_find_221_ie(struct ieee80211_hw *hw, u8 *data,
1395		unsigned int len)
1396{
1397	struct ieee80211_mgmt *mgmt = (void *)data;
1398	struct octet_string vendor_ie;
1399	u8 *pos, *end;
1400
1401	pos = (u8 *)mgmt->u.beacon.variable;
1402	end = data + len;
1403	while (pos < end) {
1404		if (pos[0] == 221) {
1405			vendor_ie.length = pos[1];
1406			vendor_ie.octet = &pos[2];
1407			if (rtl_chk_vendor_ouisub(hw, vendor_ie))
1408				return true;
1409		}
1410
1411		if (pos + 2 + pos[1] > end)
1412			return false;
1413
1414		pos += 2 + pos[1];
1415	}
1416	return false;
1417}
1418
1419void rtl_recognize_peer(struct ieee80211_hw *hw, u8 *data, unsigned int len)
1420{
1421	struct rtl_priv *rtlpriv = rtl_priv(hw);
1422	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1423	struct ieee80211_hdr *hdr = (void *)data;
1424	u32 vendor = PEER_UNKNOWN;
1425
1426	static u8 ap3_1[3] = { 0x00, 0x14, 0xbf };
1427	static u8 ap3_2[3] = { 0x00, 0x1a, 0x70 };
1428	static u8 ap3_3[3] = { 0x00, 0x1d, 0x7e };
1429	static u8 ap4_1[3] = { 0x00, 0x90, 0xcc };
1430	static u8 ap4_2[3] = { 0x00, 0x0e, 0x2e };
1431	static u8 ap4_3[3] = { 0x00, 0x18, 0x02 };
1432	static u8 ap4_4[3] = { 0x00, 0x17, 0x3f };
1433	static u8 ap4_5[3] = { 0x00, 0x1c, 0xdf };
1434	static u8 ap5_1[3] = { 0x00, 0x1c, 0xf0 };
1435	static u8 ap5_2[3] = { 0x00, 0x21, 0x91 };
1436	static u8 ap5_3[3] = { 0x00, 0x24, 0x01 };
1437	static u8 ap5_4[3] = { 0x00, 0x15, 0xe9 };
1438	static u8 ap5_5[3] = { 0x00, 0x17, 0x9A };
1439	static u8 ap5_6[3] = { 0x00, 0x18, 0xE7 };
1440	static u8 ap6_1[3] = { 0x00, 0x17, 0x94 };
1441	static u8 ap7_1[3] = { 0x00, 0x14, 0xa4 };
1442
1443	if (mac->opmode != NL80211_IFTYPE_STATION)
1444		return;
1445
1446	if (mac->link_state == MAC80211_NOLINK) {
1447		mac->vendor = PEER_UNKNOWN;
1448		return;
1449	}
1450
1451	if (mac->cnt_after_linked > 2)
1452		return;
1453
1454	/* check if this really is a beacon */
1455	if (!ieee80211_is_beacon(hdr->frame_control))
1456		return;
1457
1458	/* min. beacon length + FCS_LEN */
1459	if (len <= 40 + FCS_LEN)
1460		return;
1461
1462	/* and only beacons from the associated BSSID, please */
1463	if (compare_ether_addr(hdr->addr3, rtlpriv->mac80211.bssid))
1464		return;
1465
1466	if (rtl_find_221_ie(hw, data, len))
1467		vendor = mac->vendor;
1468
1469	if ((memcmp(mac->bssid, ap5_1, 3) == 0) ||
1470		(memcmp(mac->bssid, ap5_2, 3) == 0) ||
1471		(memcmp(mac->bssid, ap5_3, 3) == 0) ||
1472		(memcmp(mac->bssid, ap5_4, 3) == 0) ||
1473		(memcmp(mac->bssid, ap5_5, 3) == 0) ||
1474		(memcmp(mac->bssid, ap5_6, 3) == 0) ||
1475		vendor == PEER_ATH) {
1476		vendor = PEER_ATH;
1477		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>ath find\n");
1478	} else if ((memcmp(mac->bssid, ap4_4, 3) == 0) ||
1479		(memcmp(mac->bssid, ap4_5, 3) == 0) ||
1480		(memcmp(mac->bssid, ap4_1, 3) == 0) ||
1481		(memcmp(mac->bssid, ap4_2, 3) == 0) ||
1482		(memcmp(mac->bssid, ap4_3, 3) == 0) ||
1483		vendor == PEER_RAL) {
1484		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>ral find\n");
1485		vendor = PEER_RAL;
1486	} else if (memcmp(mac->bssid, ap6_1, 3) == 0 ||
1487		vendor == PEER_CISCO) {
1488		vendor = PEER_CISCO;
1489		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>cisco find\n");
1490	} else if ((memcmp(mac->bssid, ap3_1, 3) == 0) ||
1491		(memcmp(mac->bssid, ap3_2, 3) == 0) ||
1492		(memcmp(mac->bssid, ap3_3, 3) == 0) ||
1493		vendor == PEER_BROAD) {
1494		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>broad find\n");
1495		vendor = PEER_BROAD;
1496	} else if (memcmp(mac->bssid, ap7_1, 3) == 0 ||
1497		vendor == PEER_MARV) {
1498		vendor = PEER_MARV;
1499		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD, "=>marv find\n");
1500	}
1501
1502	mac->vendor = vendor;
1503}
1504
1505/*********************************************************
1506 *
1507 * sysfs functions
1508 *
1509 *********************************************************/
1510static ssize_t rtl_show_debug_level(struct device *d,
1511				    struct device_attribute *attr, char *buf)
1512{
1513	struct ieee80211_hw *hw = dev_get_drvdata(d);
1514	struct rtl_priv *rtlpriv = rtl_priv(hw);
1515
1516	return sprintf(buf, "0x%08X\n", rtlpriv->dbg.global_debuglevel);
1517}
1518
1519static ssize_t rtl_store_debug_level(struct device *d,
1520				     struct device_attribute *attr,
1521				     const char *buf, size_t count)
1522{
1523	struct ieee80211_hw *hw = dev_get_drvdata(d);
1524	struct rtl_priv *rtlpriv = rtl_priv(hw);
1525	unsigned long val;
1526	int ret;
1527
1528	ret = strict_strtoul(buf, 0, &val);
1529	if (ret) {
1530		printk(KERN_DEBUG "%s is not in hex or decimal form.\n", buf);
1531	} else {
1532		rtlpriv->dbg.global_debuglevel = val;
1533		printk(KERN_DEBUG "debuglevel:%x\n",
1534		       rtlpriv->dbg.global_debuglevel);
1535	}
1536
1537	return strnlen(buf, count);
1538}
1539
1540static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
1541		   rtl_show_debug_level, rtl_store_debug_level);
1542
1543static struct attribute *rtl_sysfs_entries[] = {
1544
1545	&dev_attr_debug_level.attr,
1546
1547	NULL
1548};
1549
1550/*
1551 * "name" is folder name witch will be
1552 * put in device directory like :
1553 * sys/devices/pci0000:00/0000:00:1c.4/
1554 * 0000:06:00.0/rtl_sysfs
1555 */
1556struct attribute_group rtl_attribute_group = {
1557	.name = "rtlsysfs",
1558	.attrs = rtl_sysfs_entries,
1559};
1560
1561MODULE_AUTHOR("lizhaoming	<chaoming_li@realsil.com.cn>");
1562MODULE_AUTHOR("Realtek WlanFAE	<wlanfae@realtek.com>");
1563MODULE_AUTHOR("Larry Finger	<Larry.FInger@lwfinger.net>");
1564MODULE_LICENSE("GPL");
1565MODULE_DESCRIPTION("Realtek 802.11n PCI wireless core");
1566
1567static int __init rtl_core_module_init(void)
1568{
1569	if (rtl_rate_control_register())
1570		pr_err("Unable to register rtl_rc, use default RC !!\n");
1571
1572	return 0;
1573}
1574
1575static void __exit rtl_core_module_exit(void)
1576{
1577	/*RC*/
1578	rtl_rate_control_unregister();
1579}
1580
1581module_init(rtl_core_module_init);
1582module_exit(rtl_core_module_exit);
1583