1 /******************************************************************************
3 * Copyright(c) 2009-2013 Realtek Corporation.
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.
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
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
22 * Larry Finger <Larry.Finger@lwfinger.net>
24 *****************************************************************************/
33 #include "../pwrseqcmd.h"
45 static void _rtl88ee_set_bcn_ctrl_reg(struct ieee80211_hw
*hw
,
46 u8 set_bits
, u8 clear_bits
)
48 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
49 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
51 rtlpci
->reg_bcn_ctrl_val
|= set_bits
;
52 rtlpci
->reg_bcn_ctrl_val
&= ~clear_bits
;
54 rtl_write_byte(rtlpriv
, REG_BCN_CTRL
, (u8
) rtlpci
->reg_bcn_ctrl_val
);
57 static void _rtl88ee_stop_tx_beacon(struct ieee80211_hw
*hw
)
59 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
62 tmp1byte
= rtl_read_byte(rtlpriv
, REG_FWHW_TXQ_CTRL
+ 2);
63 rtl_write_byte(rtlpriv
, REG_FWHW_TXQ_CTRL
+ 2, tmp1byte
& (~BIT(6)));
64 rtl_write_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 1, 0x64);
65 tmp1byte
= rtl_read_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 2);
66 tmp1byte
&= ~(BIT(0));
67 rtl_write_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 2, tmp1byte
);
70 static void _rtl88ee_resume_tx_beacon(struct ieee80211_hw
*hw
)
72 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
75 tmp1byte
= rtl_read_byte(rtlpriv
, REG_FWHW_TXQ_CTRL
+ 2);
76 rtl_write_byte(rtlpriv
, REG_FWHW_TXQ_CTRL
+ 2, tmp1byte
| BIT(6));
77 rtl_write_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 1, 0xff);
78 tmp1byte
= rtl_read_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 2);
80 rtl_write_byte(rtlpriv
, REG_TBTT_PROHIBIT
+ 2, tmp1byte
);
83 static void _rtl88ee_enable_bcn_sub_func(struct ieee80211_hw
*hw
)
85 _rtl88ee_set_bcn_ctrl_reg(hw
, 0, BIT(1));
88 static void _rtl88ee_return_beacon_queue_skb(struct ieee80211_hw
*hw
)
90 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
91 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
92 struct rtl8192_tx_ring
*ring
= &rtlpci
->tx_ring
[BEACON_QUEUE
];
95 spin_lock_irqsave(&rtlpriv
->locks
.irq_th_lock
, flags
);
96 while (skb_queue_len(&ring
->queue
)) {
97 struct rtl_tx_desc
*entry
= &ring
->desc
[ring
->idx
];
98 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
100 pci_unmap_single(rtlpci
->pdev
,
101 rtlpriv
->cfg
->ops
->get_desc(
102 (u8
*)entry
, true, HW_DESC_TXBUFF_ADDR
),
103 skb
->len
, PCI_DMA_TODEVICE
);
105 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
107 spin_unlock_irqrestore(&rtlpriv
->locks
.irq_th_lock
, flags
);
110 static void _rtl88ee_disable_bcn_sub_func(struct ieee80211_hw
*hw
)
112 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(1), 0);
115 static void _rtl88ee_set_fw_clock_on(struct ieee80211_hw
*hw
,
116 u8 rpwm_val
, bool b_need_turn_off_ckk
)
118 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
119 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
120 bool b_support_remote_wake_up
;
121 u32 count
= 0, isr_regaddr
, content
;
122 bool schedule_timer
= b_need_turn_off_ckk
;
123 rtlpriv
->cfg
->ops
->get_hw_reg(hw
, HAL_DEF_WOWLAN
,
124 (u8
*)(&b_support_remote_wake_up
));
126 if (!rtlhal
->fw_ready
)
128 if (!rtlpriv
->psc
.fw_current_inpsmode
)
132 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
133 if (rtlhal
->fw_clk_change_in_progress
) {
134 while (rtlhal
->fw_clk_change_in_progress
) {
135 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
140 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
142 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
144 rtlhal
->fw_clk_change_in_progress
= false;
145 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
150 if (IS_IN_LOW_POWER_STATE_88E(rtlhal
->fw_ps_state
)) {
151 rtlpriv
->cfg
->ops
->get_hw_reg(hw
, HW_VAR_SET_RPWM
, &rpwm_val
);
152 if (FW_PS_IS_ACK(rpwm_val
)) {
153 isr_regaddr
= REG_HISR
;
154 content
= rtl_read_dword(rtlpriv
, isr_regaddr
);
155 while (!(content
& IMR_CPWM
) && (count
< 500)) {
158 content
= rtl_read_dword(rtlpriv
, isr_regaddr
);
161 if (content
& IMR_CPWM
) {
162 rtl_write_word(rtlpriv
, isr_regaddr
, 0x0100);
163 rtlhal
->fw_ps_state
= FW_PS_STATE_RF_ON_88E
;
164 RT_TRACE(rtlpriv
, COMP_POWER
, DBG_LOUD
,
165 "Receive CPWM INT!!! Set pHalData->FwPSState = %X\n",
166 rtlhal
->fw_ps_state
);
170 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
171 rtlhal
->fw_clk_change_in_progress
= false;
172 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
173 if (schedule_timer
) {
174 mod_timer(&rtlpriv
->works
.fw_clockoff_timer
,
175 jiffies
+ MSECS(10));
179 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
180 rtlhal
->fw_clk_change_in_progress
= false;
181 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
185 static void _rtl88ee_set_fw_clock_off(struct ieee80211_hw
*hw
,
188 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
189 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
190 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
191 struct rtl8192_tx_ring
*ring
;
192 enum rf_pwrstate rtstate
;
193 bool schedule_timer
= false;
196 if (!rtlhal
->fw_ready
)
198 if (!rtlpriv
->psc
.fw_current_inpsmode
)
200 if (!rtlhal
->allow_sw_to_change_hwclc
)
202 rtlpriv
->cfg
->ops
->get_hw_reg(hw
, HW_VAR_RF_STATE
, (u8
*)(&rtstate
));
203 if (rtstate
== ERFOFF
|| rtlpriv
->psc
.inactive_pwrstate
== ERFOFF
)
206 for (queue
= 0; queue
< RTL_PCI_MAX_TX_QUEUE_COUNT
; queue
++) {
207 ring
= &rtlpci
->tx_ring
[queue
];
208 if (skb_queue_len(&ring
->queue
)) {
209 schedule_timer
= true;
214 if (schedule_timer
) {
215 mod_timer(&rtlpriv
->works
.fw_clockoff_timer
,
216 jiffies
+ MSECS(10));
220 if (FW_PS_STATE(rtlhal
->fw_ps_state
) !=
221 FW_PS_STATE_RF_OFF_LOW_PWR_88E
) {
222 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
223 if (!rtlhal
->fw_clk_change_in_progress
) {
224 rtlhal
->fw_clk_change_in_progress
= true;
225 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
226 rtlhal
->fw_ps_state
= FW_PS_STATE(rpwm_val
);
227 rtl_write_word(rtlpriv
, REG_HISR
, 0x0100);
228 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_SET_RPWM
,
230 spin_lock_bh(&rtlpriv
->locks
.fw_ps_lock
);
231 rtlhal
->fw_clk_change_in_progress
= false;
232 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
234 spin_unlock_bh(&rtlpriv
->locks
.fw_ps_lock
);
235 mod_timer(&rtlpriv
->works
.fw_clockoff_timer
,
236 jiffies
+ MSECS(10));
241 static void _rtl88ee_set_fw_ps_rf_on(struct ieee80211_hw
*hw
)
245 rpwm_val
|= (FW_PS_STATE_RF_OFF_88E
| FW_PS_ACK
);
246 _rtl88ee_set_fw_clock_on(hw
, rpwm_val
, true);
249 static void _rtl88ee_set_fw_ps_rf_off_low_power(struct ieee80211_hw
*hw
)
252 rpwm_val
|= FW_PS_STATE_RF_OFF_LOW_PWR_88E
;
253 _rtl88ee_set_fw_clock_off(hw
, rpwm_val
);
255 void rtl88ee_fw_clk_off_timer_callback(unsigned long data
)
257 struct ieee80211_hw
*hw
= (struct ieee80211_hw
*)data
;
259 _rtl88ee_set_fw_ps_rf_off_low_power(hw
);
262 static void _rtl88ee_fwlps_leave(struct ieee80211_hw
*hw
)
264 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
265 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
266 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
267 bool fw_current_inps
= false;
268 u8 rpwm_val
= 0, fw_pwrmode
= FW_PS_ACTIVE_MODE
;
270 if (ppsc
->low_power_enable
) {
271 rpwm_val
= (FW_PS_STATE_ALL_ON_88E
|FW_PS_ACK
);/* RF on */
272 _rtl88ee_set_fw_clock_on(hw
, rpwm_val
, false);
273 rtlhal
->allow_sw_to_change_hwclc
= false;
274 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_H2C_FW_PWRMODE
,
276 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_FW_PSMODE_STATUS
,
277 (u8
*)(&fw_current_inps
));
279 rpwm_val
= FW_PS_STATE_ALL_ON_88E
; /* RF on */
280 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_SET_RPWM
, &rpwm_val
);
281 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_H2C_FW_PWRMODE
,
283 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_FW_PSMODE_STATUS
,
284 (u8
*)(&fw_current_inps
));
288 static void _rtl88ee_fwlps_enter(struct ieee80211_hw
*hw
)
290 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
291 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
292 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
293 bool fw_current_inps
= true;
296 if (ppsc
->low_power_enable
) {
297 rpwm_val
= FW_PS_STATE_RF_OFF_LOW_PWR_88E
; /* RF off */
298 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_FW_PSMODE_STATUS
,
299 (u8
*)(&fw_current_inps
));
300 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_H2C_FW_PWRMODE
,
301 &ppsc
->fwctrl_psmode
);
302 rtlhal
->allow_sw_to_change_hwclc
= true;
303 _rtl88ee_set_fw_clock_off(hw
, rpwm_val
);
305 rpwm_val
= FW_PS_STATE_RF_OFF_88E
; /* RF off */
306 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_FW_PSMODE_STATUS
,
307 (u8
*)(&fw_current_inps
));
308 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_H2C_FW_PWRMODE
,
309 &ppsc
->fwctrl_psmode
);
310 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_SET_RPWM
, &rpwm_val
);
314 void rtl88ee_get_hw_reg(struct ieee80211_hw
*hw
, u8 variable
, u8
*val
)
316 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
317 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
318 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
322 *((u32
*)(val
)) = rtlpci
->receive_config
;
324 case HW_VAR_RF_STATE
:
325 *((enum rf_pwrstate
*)(val
)) = ppsc
->rfpwr_state
;
327 case HW_VAR_FWLPS_RF_ON
:{
328 enum rf_pwrstate rfstate
;
331 rtlpriv
->cfg
->ops
->get_hw_reg(hw
,
334 if (rfstate
== ERFOFF
) {
335 *((bool *)(val
)) = true;
337 val_rcr
= rtl_read_dword(rtlpriv
, REG_RCR
);
338 val_rcr
&= 0x00070000;
340 *((bool *)(val
)) = false;
342 *((bool *)(val
)) = true;
345 case HW_VAR_FW_PSMODE_STATUS
:
346 *((bool *)(val
)) = ppsc
->fw_current_inpsmode
;
348 case HW_VAR_CORRECT_TSF
:{
350 u32
*ptsf_low
= (u32
*)&tsf
;
351 u32
*ptsf_high
= ((u32
*)&tsf
) + 1;
353 *ptsf_high
= rtl_read_dword(rtlpriv
, (REG_TSFTR
+ 4));
354 *ptsf_low
= rtl_read_dword(rtlpriv
, REG_TSFTR
);
356 *((u64
*)(val
)) = tsf
;
359 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
360 "switch case not process %x\n", variable
);
365 void rtl88ee_set_hw_reg(struct ieee80211_hw
*hw
, u8 variable
, u8
*val
)
367 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
368 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
369 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
370 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
371 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
375 case HW_VAR_ETHER_ADDR
:
376 for (idx
= 0; idx
< ETH_ALEN
; idx
++) {
377 rtl_write_byte(rtlpriv
, (REG_MACID
+ idx
),
381 case HW_VAR_BASIC_RATE
:{
382 u16 b_rate_cfg
= ((u16
*)val
)[0];
384 b_rate_cfg
= b_rate_cfg
& 0x15f;
386 rtl_write_byte(rtlpriv
, REG_RRSR
, b_rate_cfg
& 0xff);
387 rtl_write_byte(rtlpriv
, REG_RRSR
+ 1,
388 (b_rate_cfg
>> 8) & 0xff);
389 while (b_rate_cfg
> 0x1) {
390 b_rate_cfg
= (b_rate_cfg
>> 1);
393 rtl_write_byte(rtlpriv
, REG_INIRTS_RATE_SEL
,
398 for (idx
= 0; idx
< ETH_ALEN
; idx
++) {
399 rtl_write_byte(rtlpriv
, (REG_BSSID
+ idx
),
404 rtl_write_byte(rtlpriv
, REG_SIFS_CTX
+ 1, val
[0]);
405 rtl_write_byte(rtlpriv
, REG_SIFS_TRX
+ 1, val
[1]);
407 rtl_write_byte(rtlpriv
, REG_SPEC_SIFS
+ 1, val
[0]);
408 rtl_write_byte(rtlpriv
, REG_MAC_SPEC_SIFS
+ 1, val
[0]);
411 rtl_write_word(rtlpriv
, REG_RESP_SIFS_OFDM
,
414 rtl_write_word(rtlpriv
, REG_RESP_SIFS_OFDM
,
417 case HW_VAR_SLOT_TIME
:{
420 RT_TRACE(rtlpriv
, COMP_MLME
, DBG_LOUD
,
421 "HW_VAR_SLOT_TIME %x\n", val
[0]);
423 rtl_write_byte(rtlpriv
, REG_SLOT
, val
[0]);
425 for (e_aci
= 0; e_aci
< AC_MAX
; e_aci
++) {
426 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_AC_PARAM
,
431 case HW_VAR_ACK_PREAMBLE
:{
433 u8 short_preamble
= (bool)*val
;
434 reg_tmp
= rtl_read_byte(rtlpriv
, REG_TRXPTCL_CTL
+2);
435 if (short_preamble
) {
437 rtl_write_byte(rtlpriv
, REG_TRXPTCL_CTL
+
441 rtl_write_byte(rtlpriv
, REG_TRXPTCL_CTL
+
445 case HW_VAR_WPA_CONFIG
:
446 rtl_write_byte(rtlpriv
, REG_SECCFG
, *val
);
448 case HW_VAR_AMPDU_MIN_SPACE
:{
449 u8 min_spacing_to_set
;
452 min_spacing_to_set
= *val
;
453 if (min_spacing_to_set
<= 7) {
456 if (min_spacing_to_set
< sec_min_space
)
457 min_spacing_to_set
= sec_min_space
;
459 mac
->min_space_cfg
= ((mac
->min_space_cfg
&
463 *val
= min_spacing_to_set
;
465 RT_TRACE(rtlpriv
, COMP_MLME
, DBG_LOUD
,
466 "Set HW_VAR_AMPDU_MIN_SPACE: %#x\n",
469 rtl_write_byte(rtlpriv
, REG_AMPDU_MIN_SPACE
,
473 case HW_VAR_SHORTGI_DENSITY
:{
476 density_to_set
= *val
;
477 mac
->min_space_cfg
|= (density_to_set
<< 3);
479 RT_TRACE(rtlpriv
, COMP_MLME
, DBG_LOUD
,
480 "Set HW_VAR_SHORTGI_DENSITY: %#x\n",
483 rtl_write_byte(rtlpriv
, REG_AMPDU_MIN_SPACE
,
487 case HW_VAR_AMPDU_FACTOR
:{
488 u8 regtoset_normal
[4] = { 0x41, 0xa8, 0x72, 0xb9 };
490 u8
*p_regtoset
= NULL
;
493 p_regtoset
= regtoset_normal
;
496 if (factor_toset
<= 3) {
497 factor_toset
= (1 << (factor_toset
+ 2));
498 if (factor_toset
> 0xf)
501 for (index
= 0; index
< 4; index
++) {
502 if ((p_regtoset
[index
] & 0xf0) >
505 (p_regtoset
[index
] & 0x0f) |
508 if ((p_regtoset
[index
] & 0x0f) >
511 (p_regtoset
[index
] & 0xf0) |
514 rtl_write_byte(rtlpriv
,
515 (REG_AGGLEN_LMT
+ index
),
520 RT_TRACE(rtlpriv
, COMP_MLME
, DBG_LOUD
,
521 "Set HW_VAR_AMPDU_FACTOR: %#x\n",
525 case HW_VAR_AC_PARAM
:{
527 rtl88e_dm_init_edca_turbo(hw
);
529 if (rtlpci
->acm_method
!= EACMWAY2_SW
)
530 rtlpriv
->cfg
->ops
->set_hw_reg(hw
,
534 case HW_VAR_ACM_CTRL
:{
536 union aci_aifsn
*p_aci_aifsn
=
537 (union aci_aifsn
*)(&(mac
->ac
[0].aifs
));
538 u8 acm
= p_aci_aifsn
->f
.acm
;
539 u8 acm_ctrl
= rtl_read_byte(rtlpriv
, REG_ACMHWCTRL
);
541 acm_ctrl
= acm_ctrl
|
542 ((rtlpci
->acm_method
== 2) ? 0x0 : 0x1);
547 acm_ctrl
|= ACMHW_BEQEN
;
550 acm_ctrl
|= ACMHW_VIQEN
;
553 acm_ctrl
|= ACMHW_VOQEN
;
556 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
557 "HW_VAR_ACM_CTRL acm set failed: eACI is %d\n",
564 acm_ctrl
&= (~ACMHW_BEQEN
);
567 acm_ctrl
&= (~ACMHW_VIQEN
);
570 acm_ctrl
&= (~ACMHW_VOQEN
);
573 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
574 "switch case not process\n");
579 RT_TRACE(rtlpriv
, COMP_QOS
, DBG_TRACE
,
580 "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n",
582 rtl_write_byte(rtlpriv
, REG_ACMHWCTRL
, acm_ctrl
);
585 rtl_write_dword(rtlpriv
, REG_RCR
, ((u32
*)(val
))[0]);
586 rtlpci
->receive_config
= ((u32
*)(val
))[0];
588 case HW_VAR_RETRY_LIMIT
:{
589 u8 retry_limit
= *val
;
591 rtl_write_word(rtlpriv
, REG_RL
,
592 retry_limit
<< RETRY_LIMIT_SHORT_SHIFT
|
593 retry_limit
<< RETRY_LIMIT_LONG_SHIFT
);
595 case HW_VAR_DUAL_TSF_RST
:
596 rtl_write_byte(rtlpriv
, REG_DUAL_TSF_RST
, (BIT(0) | BIT(1)));
598 case HW_VAR_EFUSE_BYTES
:
599 rtlefuse
->efuse_usedbytes
= *((u16
*)val
);
601 case HW_VAR_EFUSE_USAGE
:
602 rtlefuse
->efuse_usedpercentage
= *val
;
605 rtl88e_phy_set_io_cmd(hw
, (*(enum io_type
*)val
));
607 case HW_VAR_SET_RPWM
:{
610 rpwm_val
= rtl_read_byte(rtlpriv
, REG_PCIE_HRPWM
);
613 if (rpwm_val
& BIT(7)) {
614 rtl_write_byte(rtlpriv
, REG_PCIE_HRPWM
, *val
);
616 rtl_write_byte(rtlpriv
, REG_PCIE_HRPWM
, *val
| BIT(7));
619 case HW_VAR_H2C_FW_PWRMODE
:
620 rtl88e_set_fw_pwrmode_cmd(hw
, *val
);
622 case HW_VAR_FW_PSMODE_STATUS
:
623 ppsc
->fw_current_inpsmode
= *((bool *)val
);
625 case HW_VAR_RESUME_CLK_ON
:
626 _rtl88ee_set_fw_ps_rf_on(hw
);
628 case HW_VAR_FW_LPS_ACTION
:{
629 bool enter_fwlps
= *((bool *)val
);
632 _rtl88ee_fwlps_enter(hw
);
634 _rtl88ee_fwlps_leave(hw
);
637 case HW_VAR_H2C_FW_JOINBSSRPT
:{
639 u8 tmp_regcr
, tmp_reg422
, bcnvalid_reg
;
640 u8 count
= 0, dlbcn_count
= 0;
641 bool b_recover
= false;
643 if (mstatus
== RT_MEDIA_CONNECT
) {
644 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_AID
,
647 tmp_regcr
= rtl_read_byte(rtlpriv
, REG_CR
+ 1);
648 rtl_write_byte(rtlpriv
, REG_CR
+ 1,
649 (tmp_regcr
| BIT(0)));
651 _rtl88ee_set_bcn_ctrl_reg(hw
, 0, BIT(3));
652 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(4), 0);
655 rtl_read_byte(rtlpriv
,
656 REG_FWHW_TXQ_CTRL
+ 2);
657 rtl_write_byte(rtlpriv
, REG_FWHW_TXQ_CTRL
+ 2,
658 tmp_reg422
& (~BIT(6)));
659 if (tmp_reg422
& BIT(6))
663 bcnvalid_reg
= rtl_read_byte(rtlpriv
,
665 rtl_write_byte(rtlpriv
, REG_TDECTRL
+2,
666 (bcnvalid_reg
| BIT(0)));
667 _rtl88ee_return_beacon_queue_skb(hw
);
669 rtl88e_set_fw_rsvdpagepkt(hw
, 0);
670 bcnvalid_reg
= rtl_read_byte(rtlpriv
,
673 while (!(bcnvalid_reg
& BIT(0)) && count
< 20) {
677 rtl_read_byte(rtlpriv
, REG_TDECTRL
+2);
680 } while (!(bcnvalid_reg
& BIT(0)) && dlbcn_count
< 5);
682 if (bcnvalid_reg
& BIT(0))
683 rtl_write_byte(rtlpriv
, REG_TDECTRL
+2, BIT(0));
685 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(3), 0);
686 _rtl88ee_set_bcn_ctrl_reg(hw
, 0, BIT(4));
689 rtl_write_byte(rtlpriv
,
690 REG_FWHW_TXQ_CTRL
+ 2,
694 rtl_write_byte(rtlpriv
, REG_CR
+ 1,
695 (tmp_regcr
& ~(BIT(0))));
697 rtl88e_set_fw_joinbss_report_cmd(hw
, (*(u8
*)val
));
699 case HW_VAR_H2C_FW_P2P_PS_OFFLOAD
:
700 rtl88e_set_p2p_ps_offload_cmd(hw
, *val
);
705 u2btmp
= rtl_read_word(rtlpriv
, REG_BCN_PSR_RPT
);
707 rtl_write_word(rtlpriv
, REG_BCN_PSR_RPT
, (u2btmp
|
710 case HW_VAR_CORRECT_TSF
:{
711 u8 btype_ibss
= *val
;
714 _rtl88ee_stop_tx_beacon(hw
);
716 _rtl88ee_set_bcn_ctrl_reg(hw
, 0, BIT(3));
718 rtl_write_dword(rtlpriv
, REG_TSFTR
,
719 (u32
)(mac
->tsf
& 0xffffffff));
720 rtl_write_dword(rtlpriv
, REG_TSFTR
+ 4,
721 (u32
)((mac
->tsf
>> 32) & 0xffffffff));
723 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(3), 0);
726 _rtl88ee_resume_tx_beacon(hw
);
728 case HW_VAR_KEEP_ALIVE
: {
732 array
[1] = *((u8
*)val
);
733 rtl88e_fill_h2c_cmd(hw
, H2C_88E_KEEP_ALIVE_CTRL
,
737 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
738 "switch case not process %x\n", variable
);
743 static bool _rtl88ee_llt_write(struct ieee80211_hw
*hw
, u32 address
, u32 data
)
745 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
748 u32 value
= _LLT_INIT_ADDR(address
) | _LLT_INIT_DATA(data
) |
749 _LLT_OP(_LLT_WRITE_ACCESS
);
751 rtl_write_dword(rtlpriv
, REG_LLT_INIT
, value
);
754 value
= rtl_read_dword(rtlpriv
, REG_LLT_INIT
);
755 if (_LLT_NO_ACTIVE
== _LLT_OP_VALUE(value
))
758 if (count
> POLLING_LLT_THRESHOLD
) {
759 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
760 "Failed to polling write LLT done at address %d!\n",
770 static bool _rtl88ee_llt_table_init(struct ieee80211_hw
*hw
)
772 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
779 txpktbuf_bndy
= 0xAB;
781 rtl_write_byte(rtlpriv
, REG_RQPN_NPQ
, 0x01);
782 rtl_write_dword(rtlpriv
, REG_RQPN
, 0x80730d29);
784 /*0x2600 MaxRxBuff=10k-max(TxReportSize(64*8), WOLPattern(16*24)) */
785 rtl_write_dword(rtlpriv
, REG_TRXFF_BNDY
, (0x25FF0000 | txpktbuf_bndy
));
786 rtl_write_byte(rtlpriv
, REG_TDECTRL
+ 1, txpktbuf_bndy
);
788 rtl_write_byte(rtlpriv
, REG_TXPKTBUF_BCNQ_BDNY
, txpktbuf_bndy
);
789 rtl_write_byte(rtlpriv
, REG_TXPKTBUF_MGQ_BDNY
, txpktbuf_bndy
);
791 rtl_write_byte(rtlpriv
, 0x45D, txpktbuf_bndy
);
792 rtl_write_byte(rtlpriv
, REG_PBP
, 0x11);
793 rtl_write_byte(rtlpriv
, REG_RX_DRVINFO_SZ
, 0x4);
795 for (i
= 0; i
< (txpktbuf_bndy
- 1); i
++) {
796 status
= _rtl88ee_llt_write(hw
, i
, i
+ 1);
801 status
= _rtl88ee_llt_write(hw
, (txpktbuf_bndy
- 1), 0xFF);
805 for (i
= txpktbuf_bndy
; i
< maxpage
; i
++) {
806 status
= _rtl88ee_llt_write(hw
, i
, (i
+ 1));
811 status
= _rtl88ee_llt_write(hw
, maxpage
, txpktbuf_bndy
);
818 static void _rtl88ee_gen_refresh_led_state(struct ieee80211_hw
*hw
)
820 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
821 struct rtl_pci_priv
*pcipriv
= rtl_pcipriv(hw
);
822 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
823 struct rtl_led
*pLed0
= &(pcipriv
->ledctl
.sw_led0
);
825 if (rtlpriv
->rtlhal
.up_first_time
)
828 if (ppsc
->rfoff_reason
== RF_CHANGE_BY_IPS
)
829 rtl88ee_sw_led_on(hw
, pLed0
);
830 else if (ppsc
->rfoff_reason
== RF_CHANGE_BY_INIT
)
831 rtl88ee_sw_led_on(hw
, pLed0
);
833 rtl88ee_sw_led_off(hw
, pLed0
);
836 static bool _rtl88ee_init_mac(struct ieee80211_hw
*hw
)
838 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
839 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
840 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
845 /*Disable XTAL OUTPUT for power saving. YJ,add,111206. */
846 bytetmp
= rtl_read_byte(rtlpriv
, REG_XCK_OUT_CTRL
) & (~BIT(0));
847 rtl_write_byte(rtlpriv
, REG_XCK_OUT_CTRL
, bytetmp
);
848 /*Auto Power Down to CHIP-off State*/
849 bytetmp
= rtl_read_byte(rtlpriv
, REG_APS_FSMCO
+ 1) & (~BIT(7));
850 rtl_write_byte(rtlpriv
, REG_APS_FSMCO
+ 1, bytetmp
);
852 rtl_write_byte(rtlpriv
, REG_RSV_CTRL
, 0x00);
853 /* HW Power on sequence */
854 if (!rtl_hal_pwrseqcmdparsing(rtlpriv
, PWR_CUT_ALL_MSK
,
855 PWR_FAB_ALL_MSK
, PWR_INTF_PCI_MSK
,
856 RTL8188EE_NIC_ENABLE_FLOW
)) {
857 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
858 "init MAC Fail as rtl_hal_pwrseqcmdparsing\n");
862 bytetmp
= rtl_read_byte(rtlpriv
, REG_APS_FSMCO
) | BIT(4);
863 rtl_write_byte(rtlpriv
, REG_APS_FSMCO
, bytetmp
);
865 bytetmp
= rtl_read_byte(rtlpriv
, REG_PCIE_CTRL_REG
+2);
866 rtl_write_byte(rtlpriv
, REG_PCIE_CTRL_REG
+2, bytetmp
|BIT(2));
868 bytetmp
= rtl_read_byte(rtlpriv
, REG_WATCH_DOG
+1);
869 rtl_write_byte(rtlpriv
, REG_WATCH_DOG
+1, bytetmp
|BIT(7));
871 bytetmp
= rtl_read_byte(rtlpriv
, REG_AFE_XTAL_CTRL_EXT
+1);
872 rtl_write_byte(rtlpriv
, REG_AFE_XTAL_CTRL_EXT
+1, bytetmp
|BIT(1));
874 bytetmp
= rtl_read_byte(rtlpriv
, REG_TX_RPT_CTRL
);
875 rtl_write_byte(rtlpriv
, REG_TX_RPT_CTRL
, bytetmp
|BIT(1)|BIT(0));
876 rtl_write_byte(rtlpriv
, REG_TX_RPT_CTRL
+1, 2);
877 rtl_write_word(rtlpriv
, REG_TX_RPT_TIME
, 0xcdf0);
879 /*Add for wake up online*/
880 bytetmp
= rtl_read_byte(rtlpriv
, REG_SYS_CLKR
);
882 rtl_write_byte(rtlpriv
, REG_SYS_CLKR
, bytetmp
|BIT(3));
883 bytetmp
= rtl_read_byte(rtlpriv
, REG_GPIO_MUXCFG
+1);
884 rtl_write_byte(rtlpriv
, REG_GPIO_MUXCFG
+1, (bytetmp
& (~BIT(4))));
885 rtl_write_byte(rtlpriv
, 0x367, 0x80);
887 rtl_write_word(rtlpriv
, REG_CR
, 0x2ff);
888 rtl_write_byte(rtlpriv
, REG_CR
+1, 0x06);
889 rtl_write_byte(rtlpriv
, MSR
, 0x00);
891 if (!rtlhal
->mac_func_enable
) {
892 if (_rtl88ee_llt_table_init(hw
) == false) {
893 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
894 "LLT table init fail\n");
898 rtl_write_dword(rtlpriv
, REG_HISR
, 0xffffffff);
899 rtl_write_dword(rtlpriv
, REG_HISRE
, 0xffffffff);
901 wordtmp
= rtl_read_word(rtlpriv
, REG_TRXDMA_CTRL
);
904 rtl_write_word(rtlpriv
, REG_TRXDMA_CTRL
, wordtmp
);
906 rtl_write_dword(rtlpriv
, REG_RCR
, rtlpci
->receive_config
);
907 rtl_write_word(rtlpriv
, REG_RXFLTMAP2
, 0xffff);
908 rtl_write_dword(rtlpriv
, REG_TCR
, rtlpci
->transmit_config
);
910 rtl_write_dword(rtlpriv
, REG_BCNQ_DESA
,
911 ((u64
) rtlpci
->tx_ring
[BEACON_QUEUE
].dma
) &
913 rtl_write_dword(rtlpriv
, REG_MGQ_DESA
,
914 (u64
) rtlpci
->tx_ring
[MGNT_QUEUE
].dma
&
916 rtl_write_dword(rtlpriv
, REG_VOQ_DESA
,
917 (u64
) rtlpci
->tx_ring
[VO_QUEUE
].dma
& DMA_BIT_MASK(32));
918 rtl_write_dword(rtlpriv
, REG_VIQ_DESA
,
919 (u64
) rtlpci
->tx_ring
[VI_QUEUE
].dma
& DMA_BIT_MASK(32));
920 rtl_write_dword(rtlpriv
, REG_BEQ_DESA
,
921 (u64
) rtlpci
->tx_ring
[BE_QUEUE
].dma
& DMA_BIT_MASK(32));
922 rtl_write_dword(rtlpriv
, REG_BKQ_DESA
,
923 (u64
) rtlpci
->tx_ring
[BK_QUEUE
].dma
& DMA_BIT_MASK(32));
924 rtl_write_dword(rtlpriv
, REG_HQ_DESA
,
925 (u64
) rtlpci
->tx_ring
[HIGH_QUEUE
].dma
&
927 rtl_write_dword(rtlpriv
, REG_RX_DESA
,
928 (u64
) rtlpci
->rx_ring
[RX_MPDU_QUEUE
].dma
&
931 /* if we want to support 64 bit DMA, we should set it here,
932 * but now we do not support 64 bit DMA
934 rtl_write_dword(rtlpriv
, REG_INT_MIG
, 0);
936 rtl_write_dword(rtlpriv
, REG_MCUTST_1
, 0x0);
937 rtl_write_byte(rtlpriv
, REG_PCIE_CTRL_REG
+1, 0);/*Enable RX DMA */
939 if (rtlhal
->earlymode_enable
) {/*Early mode enable*/
940 bytetmp
= rtl_read_byte(rtlpriv
, REG_EARLY_MODE_CONTROL
);
942 rtl_write_byte(rtlpriv
, REG_EARLY_MODE_CONTROL
, bytetmp
);
943 rtl_write_byte(rtlpriv
, REG_EARLY_MODE_CONTROL
+3, 0x81);
945 _rtl88ee_gen_refresh_led_state(hw
);
949 static void _rtl88ee_hw_configure(struct ieee80211_hw
*hw
)
951 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
953 u32 reg_ratr
, reg_prsr
;
955 reg_bw_opmode
= BW_OPMODE_20MHZ
;
956 reg_ratr
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
|
957 RATE_ALL_OFDM_1SS
| RATE_ALL_OFDM_2SS
;
958 reg_prsr
= RATE_ALL_CCK
| RATE_ALL_OFDM_AG
;
960 rtl_write_dword(rtlpriv
, REG_RRSR
, reg_prsr
);
961 rtl_write_byte(rtlpriv
, REG_HWSEQ_CTRL
, 0xFF);
964 static void _rtl88ee_enable_aspm_back_door(struct ieee80211_hw
*hw
)
966 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
967 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
969 u32 tmp4byte
= 0, count
= 0;
971 rtl_write_word(rtlpriv
, 0x354, 0x8104);
972 rtl_write_word(rtlpriv
, 0x358, 0x24);
974 rtl_write_word(rtlpriv
, 0x350, 0x70c);
975 rtl_write_byte(rtlpriv
, 0x352, 0x2);
976 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
978 while (tmp1byte
&& count
< 20) {
980 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
984 tmp4byte
= rtl_read_dword(rtlpriv
, 0x34c);
985 rtl_write_dword(rtlpriv
, 0x348, tmp4byte
|BIT(31));
986 rtl_write_word(rtlpriv
, 0x350, 0xf70c);
987 rtl_write_byte(rtlpriv
, 0x352, 0x1);
990 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
992 while (tmp1byte
&& count
< 20) {
994 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
998 rtl_write_word(rtlpriv
, 0x350, 0x718);
999 rtl_write_byte(rtlpriv
, 0x352, 0x2);
1000 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
1002 while (tmp1byte
&& count
< 20) {
1004 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
1008 if (ppsc
->support_backdoor
|| (0 == tmp1byte
)) {
1009 tmp4byte
= rtl_read_dword(rtlpriv
, 0x34c);
1010 rtl_write_dword(rtlpriv
, 0x348, tmp4byte
|BIT(11)|BIT(12));
1011 rtl_write_word(rtlpriv
, 0x350, 0xf718);
1012 rtl_write_byte(rtlpriv
, 0x352, 0x1);
1015 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
1017 while (tmp1byte
&& count
< 20) {
1019 tmp1byte
= rtl_read_byte(rtlpriv
, 0x352);
1024 void rtl88ee_enable_hw_security_config(struct ieee80211_hw
*hw
)
1026 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1029 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
1030 "PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n",
1031 rtlpriv
->sec
.pairwise_enc_algorithm
,
1032 rtlpriv
->sec
.group_enc_algorithm
);
1034 if (rtlpriv
->cfg
->mod_params
->sw_crypto
|| rtlpriv
->sec
.use_sw_sec
) {
1035 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
1036 "not open hw encryption\n");
1040 sec_reg_value
= SCR_TXENCENABLE
| SCR_RXDECENABLE
;
1042 if (rtlpriv
->sec
.use_defaultkey
) {
1043 sec_reg_value
|= SCR_TXUSEDK
;
1044 sec_reg_value
|= SCR_RXUSEDK
;
1047 sec_reg_value
|= (SCR_RXBCUSEDK
| SCR_TXBCUSEDK
);
1049 rtl_write_byte(rtlpriv
, REG_CR
+ 1, 0x02);
1051 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
1052 "The SECR-value %x\n", sec_reg_value
);
1054 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_WPA_CONFIG
, &sec_reg_value
);
1057 int rtl88ee_hw_init(struct ieee80211_hw
*hw
)
1059 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1060 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1061 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
1062 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1063 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
1064 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1065 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1066 bool rtstatus
= true;
1069 unsigned long flags
;
1071 rtlpriv
->rtlhal
.being_init_adapter
= true;
1072 /* As this function can take a very long time (up to 350 ms)
1073 * and can be called with irqs disabled, reenable the irqs
1074 * to let the other devices continue being serviced.
1076 * It is safe doing so since our own interrupts will only be enabled
1077 * in a subsequent step.
1079 local_save_flags(flags
);
1081 rtlhal
->fw_ready
= false;
1083 rtlpriv
->intf_ops
->disable_aspm(hw
);
1085 tmp_u1b
= rtl_read_byte(rtlpriv
, REG_SYS_CLKR
+1);
1086 u1byte
= rtl_read_byte(rtlpriv
, REG_CR
);
1087 if ((tmp_u1b
& BIT(3)) && (u1byte
!= 0 && u1byte
!= 0xEA)) {
1088 rtlhal
->mac_func_enable
= true;
1090 rtlhal
->mac_func_enable
= false;
1091 rtlhal
->fw_ps_state
= FW_PS_STATE_ALL_ON_88E
;
1094 rtstatus
= _rtl88ee_init_mac(hw
);
1095 if (rtstatus
!= true) {
1096 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
, "Init MAC failed\n");
1101 err
= rtl88e_download_fw(hw
, false);
1103 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
1104 "Failed to download FW. Init HW without FW now..\n");
1108 rtlhal
->fw_ready
= true;
1109 /*fw related variable initialize */
1110 rtlhal
->last_hmeboxnum
= 0;
1111 rtlhal
->fw_ps_state
= FW_PS_STATE_ALL_ON_88E
;
1112 rtlhal
->fw_clk_change_in_progress
= false;
1113 rtlhal
->allow_sw_to_change_hwclc
= false;
1114 ppsc
->fw_current_inpsmode
= false;
1116 rtl88e_phy_mac_config(hw
);
1117 /* because last function modify RCR, so we update
1118 * rcr var here, or TP will unstable for receive_config
1119 * is wrong, RX RCR_ACRC32 will cause TP unstabel & Rx
1120 * RCR_APP_ICV will cause mac80211 unassoc for cisco 1252
1122 rtlpci
->receive_config
&= ~(RCR_ACRC32
| RCR_AICV
);
1123 rtl_write_dword(rtlpriv
, REG_RCR
, rtlpci
->receive_config
);
1125 rtl88e_phy_bb_config(hw
);
1126 rtl_set_bbreg(hw
, RFPGA0_RFMOD
, BCCKEN
, 0x1);
1127 rtl_set_bbreg(hw
, RFPGA0_RFMOD
, BOFDMEN
, 0x1);
1129 rtlphy
->rf_mode
= RF_OP_BY_SW_3WIRE
;
1130 rtl88e_phy_rf_config(hw
);
1132 rtlphy
->rfreg_chnlval
[0] = rtl_get_rfreg(hw
, (enum radio_path
)0,
1133 RF_CHNLBW
, RFREG_OFFSET_MASK
);
1134 rtlphy
->rfreg_chnlval
[0] = rtlphy
->rfreg_chnlval
[0] & 0xfff00fff;
1136 _rtl88ee_hw_configure(hw
);
1137 rtl_cam_reset_all_entry(hw
);
1138 rtl88ee_enable_hw_security_config(hw
);
1140 rtlhal
->mac_func_enable
= true;
1141 ppsc
->rfpwr_state
= ERFON
;
1143 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_ETHER_ADDR
, mac
->mac_addr
);
1144 _rtl88ee_enable_aspm_back_door(hw
);
1145 rtlpriv
->intf_ops
->enable_aspm(hw
);
1147 if (ppsc
->rfpwr_state
== ERFON
) {
1148 if ((rtlefuse
->antenna_div_type
== CGCS_RX_HW_ANTDIV
) ||
1149 ((rtlefuse
->antenna_div_type
== CG_TRX_HW_ANTDIV
) &&
1150 (rtlhal
->oem_id
== RT_CID_819X_HP
))) {
1151 rtl88e_phy_set_rfpath_switch(hw
, true);
1152 rtlpriv
->dm
.fat_table
.rx_idle_ant
= MAIN_ANT
;
1154 rtl88e_phy_set_rfpath_switch(hw
, false);
1155 rtlpriv
->dm
.fat_table
.rx_idle_ant
= AUX_ANT
;
1157 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "rx idle ant %s\n",
1158 (rtlpriv
->dm
.fat_table
.rx_idle_ant
== MAIN_ANT
) ?
1159 ("MAIN_ANT") : ("AUX_ANT"));
1161 if (rtlphy
->iqk_initialized
) {
1162 rtl88e_phy_iq_calibrate(hw
, true);
1164 rtl88e_phy_iq_calibrate(hw
, false);
1165 rtlphy
->iqk_initialized
= true;
1168 rtl88e_dm_check_txpower_tracking(hw
);
1169 rtl88e_phy_lc_calibrate(hw
);
1172 tmp_u1b
= efuse_read_1byte(hw
, 0x1FA);
1173 if (!(tmp_u1b
& BIT(0))) {
1174 rtl_set_rfreg(hw
, RF90_PATH_A
, 0x15, 0x0F, 0x05);
1175 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "PA BIAS path A\n");
1178 if (!(tmp_u1b
& BIT(4))) {
1179 tmp_u1b
= rtl_read_byte(rtlpriv
, 0x16);
1181 rtl_write_byte(rtlpriv
, 0x16, tmp_u1b
| 0x80);
1183 rtl_write_byte(rtlpriv
, 0x16, tmp_u1b
| 0x90);
1184 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "under 1.5V\n");
1186 rtl_write_byte(rtlpriv
, REG_NAV_CTRL
+2, ((30000+127)/128));
1189 local_irq_restore(flags
);
1190 rtlpriv
->rtlhal
.being_init_adapter
= false;
1194 static enum version_8188e
_rtl88ee_read_chip_version(struct ieee80211_hw
*hw
)
1196 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1197 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1198 enum version_8188e version
= VERSION_UNKNOWN
;
1201 value32
= rtl_read_dword(rtlpriv
, REG_SYS_CFG
);
1202 if (value32
& TRP_VAUX_EN
) {
1203 version
= (enum version_8188e
) VERSION_TEST_CHIP_88E
;
1205 version
= NORMAL_CHIP
;
1206 version
= version
| ((value32
& TYPE_ID
) ? RF_TYPE_2T2R
: 0);
1207 version
= version
| ((value32
& VENDOR_ID
) ?
1208 CHIP_VENDOR_UMC
: 0);
1211 rtlphy
->rf_type
= RF_1T1R
;
1212 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1213 "Chip RF Type: %s\n", (rtlphy
->rf_type
== RF_2T2R
) ?
1214 "RF_2T2R" : "RF_1T1R");
1219 static int _rtl88ee_set_media_status(struct ieee80211_hw
*hw
,
1220 enum nl80211_iftype type
)
1222 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1223 u8 bt_msr
= rtl_read_byte(rtlpriv
, MSR
) & 0xfc;
1224 enum led_ctl_mode ledaction
= LED_CTL_NO_LINK
;
1225 u8 mode
= MSR_NOLINK
;
1228 case NL80211_IFTYPE_UNSPECIFIED
:
1230 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_TRACE
,
1231 "Set Network type to NO LINK!\n");
1233 case NL80211_IFTYPE_ADHOC
:
1234 case NL80211_IFTYPE_MESH_POINT
:
1236 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_TRACE
,
1237 "Set Network type to Ad Hoc!\n");
1239 case NL80211_IFTYPE_STATION
:
1241 ledaction
= LED_CTL_LINK
;
1242 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_TRACE
,
1243 "Set Network type to STA!\n");
1245 case NL80211_IFTYPE_AP
:
1247 ledaction
= LED_CTL_LINK
;
1248 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_TRACE
,
1249 "Set Network type to AP!\n");
1252 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
1253 "Network type %d not support!\n", type
);
1258 /* MSR_INFRA == Link in infrastructure network;
1259 * MSR_ADHOC == Link in ad hoc network;
1260 * Therefore, check link state is necessary.
1262 * MSR_AP == AP mode; link state is not cared here.
1264 if (mode
!= MSR_AP
&& rtlpriv
->mac80211
.link_state
< MAC80211_LINKED
) {
1266 ledaction
= LED_CTL_NO_LINK
;
1269 if (mode
== MSR_NOLINK
|| mode
== MSR_INFRA
) {
1270 _rtl88ee_stop_tx_beacon(hw
);
1271 _rtl88ee_enable_bcn_sub_func(hw
);
1272 } else if (mode
== MSR_ADHOC
|| mode
== MSR_AP
) {
1273 _rtl88ee_resume_tx_beacon(hw
);
1274 _rtl88ee_disable_bcn_sub_func(hw
);
1276 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
1277 "Set HW_VAR_MEDIA_STATUS: No such media status(%x).\n",
1281 rtl_write_byte(rtlpriv
, MSR
, bt_msr
| mode
);
1282 rtlpriv
->cfg
->ops
->led_control(hw
, ledaction
);
1284 rtl_write_byte(rtlpriv
, REG_BCNTCFG
+ 1, 0x00);
1286 rtl_write_byte(rtlpriv
, REG_BCNTCFG
+ 1, 0x66);
1290 void rtl88ee_set_check_bssid(struct ieee80211_hw
*hw
, bool check_bssid
)
1292 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1293 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1294 u32 reg_rcr
= rtlpci
->receive_config
;
1296 if (rtlpriv
->psc
.rfpwr_state
!= ERFON
)
1299 if (check_bssid
== true) {
1300 reg_rcr
|= (RCR_CBSSID_DATA
| RCR_CBSSID_BCN
);
1301 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_RCR
,
1303 _rtl88ee_set_bcn_ctrl_reg(hw
, 0, BIT(4));
1304 } else if (check_bssid
== false) {
1305 reg_rcr
&= (~(RCR_CBSSID_DATA
| RCR_CBSSID_BCN
));
1306 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(4), 0);
1307 rtlpriv
->cfg
->ops
->set_hw_reg(hw
,
1308 HW_VAR_RCR
, (u8
*)(®_rcr
));
1313 int rtl88ee_set_network_type(struct ieee80211_hw
*hw
,
1314 enum nl80211_iftype type
)
1316 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1318 if (_rtl88ee_set_media_status(hw
, type
))
1321 if (rtlpriv
->mac80211
.link_state
== MAC80211_LINKED
) {
1322 if (type
!= NL80211_IFTYPE_AP
&&
1323 type
!= NL80211_IFTYPE_MESH_POINT
)
1324 rtl88ee_set_check_bssid(hw
, true);
1326 rtl88ee_set_check_bssid(hw
, false);
1332 /* don't set REG_EDCA_BE_PARAM here
1333 * because mac80211 will send pkt when scan
1335 void rtl88ee_set_qos(struct ieee80211_hw
*hw
, int aci
)
1337 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1338 rtl88e_dm_init_edca_turbo(hw
);
1341 rtl_write_dword(rtlpriv
, REG_EDCA_BK_PARAM
, 0xa44f);
1346 rtl_write_dword(rtlpriv
, REG_EDCA_VI_PARAM
, 0x5e4322);
1349 rtl_write_dword(rtlpriv
, REG_EDCA_VO_PARAM
, 0x2f3222);
1352 RT_ASSERT(false, "invalid aci: %d !\n", aci
);
1357 void rtl88ee_enable_interrupt(struct ieee80211_hw
*hw
)
1359 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1360 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1362 rtl_write_dword(rtlpriv
, REG_HIMR
,
1363 rtlpci
->irq_mask
[0] & 0xFFFFFFFF);
1364 rtl_write_dword(rtlpriv
, REG_HIMRE
,
1365 rtlpci
->irq_mask
[1] & 0xFFFFFFFF);
1366 rtlpci
->irq_enabled
= true;
1367 /* there are some C2H CMDs have been sent
1368 * before system interrupt is enabled, e.g., C2H, CPWM.
1369 * So we need to clear all C2H events that FW has notified,
1370 * otherwise FW won't schedule any commands anymore.
1372 rtl_write_byte(rtlpriv
, REG_C2HEVT_CLEAR
, 0);
1373 /*enable system interrupt*/
1374 rtl_write_dword(rtlpriv
, REG_HSIMR
,
1375 rtlpci
->sys_irq_mask
& 0xFFFFFFFF);
1378 void rtl88ee_disable_interrupt(struct ieee80211_hw
*hw
)
1380 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1381 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1383 rtl_write_dword(rtlpriv
, REG_HIMR
, IMR_DISABLED
);
1384 rtl_write_dword(rtlpriv
, REG_HIMRE
, IMR_DISABLED
);
1385 rtlpci
->irq_enabled
= false;
1386 /*synchronize_irq(rtlpci->pdev->irq);*/
1389 static void _rtl88ee_poweroff_adapter(struct ieee80211_hw
*hw
)
1391 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1392 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1395 rtlhal
->mac_func_enable
= false;
1396 rtlpriv
->intf_ops
->enable_aspm(hw
);
1398 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "POWER OFF adapter\n");
1399 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_TX_RPT_CTRL
);
1400 rtl_write_byte(rtlpriv
, REG_TX_RPT_CTRL
, u1b_tmp
& (~BIT(1)));
1402 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_RXDMA_CONTROL
);
1403 while (!(u1b_tmp
& BIT(1)) && (count
++ < 100)) {
1405 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_RXDMA_CONTROL
);
1408 rtl_write_byte(rtlpriv
, REG_PCIE_CTRL_REG
+1, 0xFF);
1410 rtl_hal_pwrseqcmdparsing(rtlpriv
, PWR_CUT_ALL_MSK
, PWR_FAB_ALL_MSK
,
1412 RTL8188EE_NIC_LPS_ENTER_FLOW
);
1414 rtl_write_byte(rtlpriv
, REG_RF_CTRL
, 0x00);
1416 if ((rtl_read_byte(rtlpriv
, REG_MCUFWDL
) & BIT(7)) && rtlhal
->fw_ready
)
1417 rtl88e_firmware_selfreset(hw
);
1419 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_SYS_FUNC_EN
+1);
1420 rtl_write_byte(rtlpriv
, REG_SYS_FUNC_EN
+ 1, (u1b_tmp
& (~BIT(2))));
1421 rtl_write_byte(rtlpriv
, REG_MCUFWDL
, 0x00);
1423 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_32K_CTRL
);
1424 rtl_write_byte(rtlpriv
, REG_32K_CTRL
, (u1b_tmp
& (~BIT(0))));
1426 rtl_hal_pwrseqcmdparsing(rtlpriv
, PWR_CUT_ALL_MSK
, PWR_FAB_ALL_MSK
,
1427 PWR_INTF_PCI_MSK
, RTL8188EE_NIC_DISABLE_FLOW
);
1429 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_RSV_CTRL
+1);
1430 rtl_write_byte(rtlpriv
, REG_RSV_CTRL
+1, (u1b_tmp
& (~BIT(3))));
1431 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_RSV_CTRL
+1);
1432 rtl_write_byte(rtlpriv
, REG_RSV_CTRL
+1, (u1b_tmp
| BIT(3)));
1434 rtl_write_byte(rtlpriv
, REG_RSV_CTRL
, 0x0E);
1436 u1b_tmp
= rtl_read_byte(rtlpriv
, GPIO_IN
);
1437 rtl_write_byte(rtlpriv
, GPIO_OUT
, u1b_tmp
);
1438 rtl_write_byte(rtlpriv
, GPIO_IO_SEL
, 0x7F);
1440 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_GPIO_IO_SEL
);
1441 rtl_write_byte(rtlpriv
, REG_GPIO_IO_SEL
, (u1b_tmp
<< 4) | u1b_tmp
);
1442 u1b_tmp
= rtl_read_byte(rtlpriv
, REG_GPIO_IO_SEL
+1);
1443 rtl_write_byte(rtlpriv
, REG_GPIO_IO_SEL
+1, u1b_tmp
| 0x0F);
1445 rtl_write_dword(rtlpriv
, REG_GPIO_IO_SEL_2
+2, 0x00080808);
1448 void rtl88ee_card_disable(struct ieee80211_hw
*hw
)
1450 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1451 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
1452 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
1453 enum nl80211_iftype opmode
;
1455 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "RTL8188ee card disable\n");
1457 mac
->link_state
= MAC80211_NOLINK
;
1458 opmode
= NL80211_IFTYPE_UNSPECIFIED
;
1460 _rtl88ee_set_media_status(hw
, opmode
);
1462 if (rtlpriv
->rtlhal
.driver_is_goingto_unload
||
1463 ppsc
->rfoff_reason
> RF_CHANGE_BY_PS
)
1464 rtlpriv
->cfg
->ops
->led_control(hw
, LED_CTL_POWER_OFF
);
1466 RT_SET_PS_LEVEL(ppsc
, RT_RF_OFF_LEVL_HALT_NIC
);
1467 _rtl88ee_poweroff_adapter(hw
);
1469 /* after power off we should do iqk again */
1470 rtlpriv
->phy
.iqk_initialized
= false;
1473 void rtl88ee_interrupt_recognized(struct ieee80211_hw
*hw
,
1474 u32
*p_inta
, u32
*p_intb
)
1476 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1477 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1479 *p_inta
= rtl_read_dword(rtlpriv
, ISR
) & rtlpci
->irq_mask
[0];
1480 rtl_write_dword(rtlpriv
, ISR
, *p_inta
);
1482 *p_intb
= rtl_read_dword(rtlpriv
, REG_HISRE
) & rtlpci
->irq_mask
[1];
1483 rtl_write_dword(rtlpriv
, REG_HISRE
, *p_intb
);
1487 void rtl88ee_set_beacon_related_registers(struct ieee80211_hw
*hw
)
1489 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1490 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
1491 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1492 u16 bcn_interval
, atim_window
;
1494 bcn_interval
= mac
->beacon_interval
;
1495 atim_window
= 2; /*FIX MERGE */
1496 rtl88ee_disable_interrupt(hw
);
1497 rtl_write_word(rtlpriv
, REG_ATIMWND
, atim_window
);
1498 rtl_write_word(rtlpriv
, REG_BCN_INTERVAL
, bcn_interval
);
1499 rtl_write_word(rtlpriv
, REG_BCNTCFG
, 0x660f);
1500 rtl_write_byte(rtlpriv
, REG_RXTSF_OFFSET_CCK
, 0x18);
1501 rtl_write_byte(rtlpriv
, REG_RXTSF_OFFSET_OFDM
, 0x18);
1502 rtl_write_byte(rtlpriv
, 0x606, 0x30);
1503 rtlpci
->reg_bcn_ctrl_val
|= BIT(3);
1504 rtl_write_byte(rtlpriv
, REG_BCN_CTRL
, (u8
) rtlpci
->reg_bcn_ctrl_val
);
1505 /*rtl88ee_enable_interrupt(hw);*/
1508 void rtl88ee_set_beacon_interval(struct ieee80211_hw
*hw
)
1510 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1511 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
1512 u16 bcn_interval
= mac
->beacon_interval
;
1514 RT_TRACE(rtlpriv
, COMP_BEACON
, DBG_DMESG
,
1515 "beacon_interval:%d\n", bcn_interval
);
1516 /*rtl88ee_disable_interrupt(hw);*/
1517 rtl_write_word(rtlpriv
, REG_BCN_INTERVAL
, bcn_interval
);
1518 /*rtl88ee_enable_interrupt(hw);*/
1521 void rtl88ee_update_interrupt_mask(struct ieee80211_hw
*hw
,
1522 u32 add_msr
, u32 rm_msr
)
1524 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1525 struct rtl_pci
*rtlpci
= rtl_pcidev(rtl_pcipriv(hw
));
1527 RT_TRACE(rtlpriv
, COMP_INTR
, DBG_LOUD
,
1528 "add_msr:%x, rm_msr:%x\n", add_msr
, rm_msr
);
1531 rtlpci
->irq_mask
[0] |= add_msr
;
1533 rtlpci
->irq_mask
[0] &= (~rm_msr
);
1534 rtl88ee_disable_interrupt(hw
);
1535 rtl88ee_enable_interrupt(hw
);
1538 static u8
_rtl88e_get_chnl_group(u8 chnl
)
1552 else if (chnl
== 14)
1558 static void set_24g_base(struct txpower_info_2g
*pwrinfo24g
, u32 rfpath
)
1562 for (group
= 0 ; group
< MAX_CHNL_GROUP_24G
; group
++) {
1563 pwrinfo24g
->index_cck_base
[rfpath
][group
] = 0x2D;
1564 pwrinfo24g
->index_bw40_base
[rfpath
][group
] = 0x2D;
1566 for (txcnt
= 0; txcnt
< MAX_TX_COUNT
; txcnt
++) {
1568 pwrinfo24g
->bw20_diff
[rfpath
][0] = 0x02;
1569 pwrinfo24g
->ofdm_diff
[rfpath
][0] = 0x04;
1571 pwrinfo24g
->bw20_diff
[rfpath
][txcnt
] = 0xFE;
1572 pwrinfo24g
->bw40_diff
[rfpath
][txcnt
] = 0xFE;
1573 pwrinfo24g
->cck_diff
[rfpath
][txcnt
] = 0xFE;
1574 pwrinfo24g
->ofdm_diff
[rfpath
][txcnt
] = 0xFE;
1579 static void read_power_value_fromprom(struct ieee80211_hw
*hw
,
1580 struct txpower_info_2g
*pwrinfo24g
,
1581 struct txpower_info_5g
*pwrinfo5g
,
1582 bool autoload_fail
, u8
*hwinfo
)
1584 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1585 u32 rfpath
, eeaddr
= EEPROM_TX_PWR_INX
, group
, txcnt
= 0;
1587 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1588 "hal_ReadPowerValueFromPROM88E():PROMContent[0x%x]=0x%x\n",
1589 (eeaddr
+1), hwinfo
[eeaddr
+1]);
1590 if (0xFF == hwinfo
[eeaddr
+1]) /*YJ,add,120316*/
1591 autoload_fail
= true;
1593 if (autoload_fail
) {
1594 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1595 "auto load fail : Use Default value!\n");
1596 for (rfpath
= 0 ; rfpath
< MAX_RF_PATH
; rfpath
++) {
1597 /* 2.4G default value */
1598 set_24g_base(pwrinfo24g
, rfpath
);
1603 for (rfpath
= 0 ; rfpath
< MAX_RF_PATH
; rfpath
++) {
1604 /*2.4G default value*/
1605 for (group
= 0 ; group
< MAX_CHNL_GROUP_24G
; group
++) {
1606 pwrinfo24g
->index_cck_base
[rfpath
][group
] =
1608 if (pwrinfo24g
->index_cck_base
[rfpath
][group
] == 0xFF)
1609 pwrinfo24g
->index_cck_base
[rfpath
][group
] =
1612 for (group
= 0 ; group
< MAX_CHNL_GROUP_24G
-1; group
++) {
1613 pwrinfo24g
->index_bw40_base
[rfpath
][group
] =
1615 if (pwrinfo24g
->index_bw40_base
[rfpath
][group
] == 0xFF)
1616 pwrinfo24g
->index_bw40_base
[rfpath
][group
] =
1619 pwrinfo24g
->bw40_diff
[rfpath
][0] = 0;
1620 if (hwinfo
[eeaddr
] == 0xFF) {
1621 pwrinfo24g
->bw20_diff
[rfpath
][0] = 0x02;
1623 pwrinfo24g
->bw20_diff
[rfpath
][0] =
1624 (hwinfo
[eeaddr
]&0xf0)>>4;
1625 /*bit sign number to 8 bit sign number*/
1626 if (pwrinfo24g
->bw20_diff
[rfpath
][0] & BIT(3))
1627 pwrinfo24g
->bw20_diff
[rfpath
][0] |= 0xF0;
1630 if (hwinfo
[eeaddr
] == 0xFF) {
1631 pwrinfo24g
->ofdm_diff
[rfpath
][0] = 0x04;
1633 pwrinfo24g
->ofdm_diff
[rfpath
][0] =
1634 (hwinfo
[eeaddr
]&0x0f);
1635 /*bit sign number to 8 bit sign number*/
1636 if (pwrinfo24g
->ofdm_diff
[rfpath
][0] & BIT(3))
1637 pwrinfo24g
->ofdm_diff
[rfpath
][0] |= 0xF0;
1639 pwrinfo24g
->cck_diff
[rfpath
][0] = 0;
1641 for (txcnt
= 1; txcnt
< MAX_TX_COUNT
; txcnt
++) {
1642 if (hwinfo
[eeaddr
] == 0xFF) {
1643 pwrinfo24g
->bw40_diff
[rfpath
][txcnt
] = 0xFE;
1645 pwrinfo24g
->bw40_diff
[rfpath
][txcnt
] =
1646 (hwinfo
[eeaddr
]&0xf0)>>4;
1647 if (pwrinfo24g
->bw40_diff
[rfpath
][txcnt
] &
1649 pwrinfo24g
->bw40_diff
[rfpath
][txcnt
] |=
1653 if (hwinfo
[eeaddr
] == 0xFF) {
1654 pwrinfo24g
->bw20_diff
[rfpath
][txcnt
] =
1657 pwrinfo24g
->bw20_diff
[rfpath
][txcnt
] =
1658 (hwinfo
[eeaddr
]&0x0f);
1659 if (pwrinfo24g
->bw20_diff
[rfpath
][txcnt
] &
1661 pwrinfo24g
->bw20_diff
[rfpath
][txcnt
] |=
1666 if (hwinfo
[eeaddr
] == 0xFF) {
1667 pwrinfo24g
->ofdm_diff
[rfpath
][txcnt
] = 0xFE;
1669 pwrinfo24g
->ofdm_diff
[rfpath
][txcnt
] =
1670 (hwinfo
[eeaddr
]&0xf0)>>4;
1671 if (pwrinfo24g
->ofdm_diff
[rfpath
][txcnt
] &
1673 pwrinfo24g
->ofdm_diff
[rfpath
][txcnt
] |=
1677 if (hwinfo
[eeaddr
] == 0xFF) {
1678 pwrinfo24g
->cck_diff
[rfpath
][txcnt
] = 0xFE;
1680 pwrinfo24g
->cck_diff
[rfpath
][txcnt
] =
1681 (hwinfo
[eeaddr
]&0x0f);
1682 if (pwrinfo24g
->cck_diff
[rfpath
][txcnt
] &
1684 pwrinfo24g
->cck_diff
[rfpath
][txcnt
] |=
1690 /*5G default value*/
1691 for (group
= 0 ; group
< MAX_CHNL_GROUP_5G
; group
++) {
1692 pwrinfo5g
->index_bw40_base
[rfpath
][group
] =
1694 if (pwrinfo5g
->index_bw40_base
[rfpath
][group
] == 0xFF)
1695 pwrinfo5g
->index_bw40_base
[rfpath
][group
] =
1699 pwrinfo5g
->bw40_diff
[rfpath
][0] = 0;
1701 if (hwinfo
[eeaddr
] == 0xFF) {
1702 pwrinfo5g
->bw20_diff
[rfpath
][0] = 0;
1704 pwrinfo5g
->bw20_diff
[rfpath
][0] =
1705 (hwinfo
[eeaddr
]&0xf0)>>4;
1706 if (pwrinfo5g
->bw20_diff
[rfpath
][0] & BIT(3))
1707 pwrinfo5g
->bw20_diff
[rfpath
][0] |= 0xF0;
1710 if (hwinfo
[eeaddr
] == 0xFF) {
1711 pwrinfo5g
->ofdm_diff
[rfpath
][0] = 0x04;
1713 pwrinfo5g
->ofdm_diff
[rfpath
][0] = (hwinfo
[eeaddr
]&0x0f);
1714 if (pwrinfo5g
->ofdm_diff
[rfpath
][0] & BIT(3))
1715 pwrinfo5g
->ofdm_diff
[rfpath
][0] |= 0xF0;
1718 for (txcnt
= 1; txcnt
< MAX_TX_COUNT
; txcnt
++) {
1719 if (hwinfo
[eeaddr
] == 0xFF) {
1720 pwrinfo5g
->bw40_diff
[rfpath
][txcnt
] = 0xFE;
1722 pwrinfo5g
->bw40_diff
[rfpath
][txcnt
] =
1723 (hwinfo
[eeaddr
]&0xf0)>>4;
1724 if (pwrinfo5g
->bw40_diff
[rfpath
][txcnt
] &
1726 pwrinfo5g
->bw40_diff
[rfpath
][txcnt
] |=
1730 if (hwinfo
[eeaddr
] == 0xFF) {
1731 pwrinfo5g
->bw20_diff
[rfpath
][txcnt
] = 0xFE;
1733 pwrinfo5g
->bw20_diff
[rfpath
][txcnt
] =
1734 (hwinfo
[eeaddr
]&0x0f);
1735 if (pwrinfo5g
->bw20_diff
[rfpath
][txcnt
] &
1737 pwrinfo5g
->bw20_diff
[rfpath
][txcnt
] |=
1743 if (hwinfo
[eeaddr
] == 0xFF) {
1744 pwrinfo5g
->ofdm_diff
[rfpath
][1] = 0xFE;
1745 pwrinfo5g
->ofdm_diff
[rfpath
][2] = 0xFE;
1747 pwrinfo5g
->ofdm_diff
[rfpath
][1] =
1748 (hwinfo
[eeaddr
]&0xf0)>>4;
1749 pwrinfo5g
->ofdm_diff
[rfpath
][2] =
1750 (hwinfo
[eeaddr
]&0x0f);
1754 if (hwinfo
[eeaddr
] == 0xFF)
1755 pwrinfo5g
->ofdm_diff
[rfpath
][3] = 0xFE;
1757 pwrinfo5g
->ofdm_diff
[rfpath
][3] = (hwinfo
[eeaddr
]&0x0f);
1760 for (txcnt
= 1; txcnt
< MAX_TX_COUNT
; txcnt
++) {
1761 if (pwrinfo5g
->ofdm_diff
[rfpath
][txcnt
] == 0xFF)
1762 pwrinfo5g
->ofdm_diff
[rfpath
][txcnt
] = 0xFE;
1763 else if (pwrinfo5g
->ofdm_diff
[rfpath
][txcnt
] & BIT(3))
1764 pwrinfo5g
->ofdm_diff
[rfpath
][txcnt
] |= 0xF0;
1769 static void _rtl88ee_read_txpower_info_from_hwpg(struct ieee80211_hw
*hw
,
1773 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1774 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1775 struct txpower_info_2g pwrinfo24g
;
1776 struct txpower_info_5g pwrinfo5g
;
1780 read_power_value_fromprom(hw
, &pwrinfo24g
,
1781 &pwrinfo5g
, autoload_fail
, hwinfo
);
1783 for (rf_path
= 0; rf_path
< 2; rf_path
++) {
1784 for (i
= 0; i
< 14; i
++) {
1785 index
= _rtl88e_get_chnl_group(i
+1);
1787 rtlefuse
->txpwrlevel_cck
[rf_path
][i
] =
1788 pwrinfo24g
.index_cck_base
[rf_path
][index
];
1789 rtlefuse
->txpwrlevel_ht40_1s
[rf_path
][i
] =
1790 pwrinfo24g
.index_bw40_base
[rf_path
][index
];
1791 rtlefuse
->txpwr_ht20diff
[rf_path
][i
] =
1792 pwrinfo24g
.bw20_diff
[rf_path
][0];
1793 rtlefuse
->txpwr_legacyhtdiff
[rf_path
][i
] =
1794 pwrinfo24g
.ofdm_diff
[rf_path
][0];
1797 for (i
= 0; i
< 14; i
++) {
1798 RTPRINT(rtlpriv
, FINIT
, INIT_TXPOWER
,
1799 "RF(%d)-Ch(%d) [CCK / HT40_1S ] = [0x%x / 0x%x ]\n",
1801 rtlefuse
->txpwrlevel_cck
[rf_path
][i
],
1802 rtlefuse
->txpwrlevel_ht40_1s
[rf_path
][i
]);
1807 rtlefuse
->eeprom_thermalmeter
=
1808 hwinfo
[EEPROM_THERMAL_METER_88E
];
1810 rtlefuse
->eeprom_thermalmeter
= EEPROM_DEFAULT_THERMALMETER
;
1812 if (rtlefuse
->eeprom_thermalmeter
== 0xff || autoload_fail
) {
1813 rtlefuse
->apk_thermalmeterignore
= true;
1814 rtlefuse
->eeprom_thermalmeter
= EEPROM_DEFAULT_THERMALMETER
;
1817 rtlefuse
->thermalmeter
[0] = rtlefuse
->eeprom_thermalmeter
;
1818 RTPRINT(rtlpriv
, FINIT
, INIT_TXPOWER
,
1819 "thermalmeter = 0x%x\n", rtlefuse
->eeprom_thermalmeter
);
1821 if (!autoload_fail
) {
1822 rtlefuse
->eeprom_regulatory
=
1823 hwinfo
[EEPROM_RF_BOARD_OPTION_88E
] & 0x07;/*bit0~2*/
1824 if (hwinfo
[EEPROM_RF_BOARD_OPTION_88E
] == 0xFF)
1825 rtlefuse
->eeprom_regulatory
= 0;
1827 rtlefuse
->eeprom_regulatory
= 0;
1829 RTPRINT(rtlpriv
, FINIT
, INIT_TXPOWER
,
1830 "eeprom_regulatory = 0x%x\n", rtlefuse
->eeprom_regulatory
);
1833 static void _rtl88ee_read_adapter_info(struct ieee80211_hw
*hw
)
1835 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1836 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1837 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1838 int params
[] = {RTL8188E_EEPROM_ID
, EEPROM_VID
, EEPROM_DID
,
1839 EEPROM_SVID
, EEPROM_SMID
, EEPROM_MAC_ADDR
,
1840 EEPROM_CHANNELPLAN
, EEPROM_VERSION
, EEPROM_CUSTOMER_ID
,
1841 COUNTRY_CODE_WORLD_WIDE_13
};
1844 hwinfo
= kzalloc(HWSET_MAX_SIZE
, GFP_KERNEL
);
1848 if (rtl_get_hwinfo(hw
, rtlpriv
, HWSET_MAX_SIZE
, hwinfo
, params
))
1851 if (rtlefuse
->eeprom_oemid
== 0xFF)
1852 rtlefuse
->eeprom_oemid
= 0;
1854 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1855 "EEPROM Customer ID: 0x%2x\n", rtlefuse
->eeprom_oemid
);
1856 /* set channel plan from efuse */
1857 rtlefuse
->channel_plan
= rtlefuse
->eeprom_channelplan
;
1859 _rtl88ee_read_txpower_info_from_hwpg(hw
,
1860 rtlefuse
->autoload_failflag
,
1862 rtlefuse
->txpwr_fromeprom
= true;
1864 rtl8188ee_read_bt_coexist_info_from_hwpg(hw
,
1865 rtlefuse
->autoload_failflag
,
1869 rtlefuse
->board_type
=
1870 ((hwinfo
[EEPROM_RF_BOARD_OPTION_88E
] & 0xE0) >> 5);
1871 rtlhal
->board_type
= rtlefuse
->board_type
;
1873 rtlefuse
->wowlan_enable
=
1874 ((hwinfo
[EEPROM_RF_FEATURE_OPTION_88E
] & 0x40) >> 6);
1876 rtlefuse
->crystalcap
= hwinfo
[EEPROM_XTAL_88E
];
1877 if (hwinfo
[EEPROM_XTAL_88E
])
1878 rtlefuse
->crystalcap
= 0x20;
1879 /*antenna diversity*/
1880 rtlefuse
->antenna_div_cfg
=
1881 (hwinfo
[EEPROM_RF_BOARD_OPTION_88E
] & 0x18) >> 3;
1882 if (hwinfo
[EEPROM_RF_BOARD_OPTION_88E
] == 0xFF)
1883 rtlefuse
->antenna_div_cfg
= 0;
1884 if (rtlpriv
->btcoexist
.eeprom_bt_coexist
!= 0 &&
1885 rtlpriv
->btcoexist
.eeprom_bt_ant_num
== ANT_X1
)
1886 rtlefuse
->antenna_div_cfg
= 0;
1888 rtlefuse
->antenna_div_type
= hwinfo
[EEPROM_RF_ANTENNA_OPT_88E
];
1889 if (rtlefuse
->antenna_div_type
== 0xFF)
1890 rtlefuse
->antenna_div_type
= 0x01;
1891 if (rtlefuse
->antenna_div_type
== CG_TRX_HW_ANTDIV
||
1892 rtlefuse
->antenna_div_type
== CGCS_RX_HW_ANTDIV
)
1893 rtlefuse
->antenna_div_cfg
= 1;
1895 if (rtlhal
->oem_id
== RT_CID_DEFAULT
) {
1896 switch (rtlefuse
->eeprom_oemid
) {
1897 case EEPROM_CID_DEFAULT
:
1898 if (rtlefuse
->eeprom_did
== 0x8179) {
1899 if (rtlefuse
->eeprom_svid
== 0x1025) {
1900 rtlhal
->oem_id
= RT_CID_819X_ACER
;
1901 } else if ((rtlefuse
->eeprom_svid
== 0x10EC &&
1902 rtlefuse
->eeprom_smid
== 0x0179) ||
1903 (rtlefuse
->eeprom_svid
== 0x17AA &&
1904 rtlefuse
->eeprom_smid
== 0x0179)) {
1905 rtlhal
->oem_id
= RT_CID_819X_LENOVO
;
1906 } else if (rtlefuse
->eeprom_svid
== 0x103c &&
1907 rtlefuse
->eeprom_smid
== 0x197d) {
1908 rtlhal
->oem_id
= RT_CID_819X_HP
;
1910 rtlhal
->oem_id
= RT_CID_DEFAULT
;
1913 rtlhal
->oem_id
= RT_CID_DEFAULT
;
1916 case EEPROM_CID_TOSHIBA
:
1917 rtlhal
->oem_id
= RT_CID_TOSHIBA
;
1919 case EEPROM_CID_QMI
:
1920 rtlhal
->oem_id
= RT_CID_819X_QMI
;
1922 case EEPROM_CID_WHQL
:
1924 rtlhal
->oem_id
= RT_CID_DEFAULT
;
1933 static void _rtl88ee_hal_customized_behavior(struct ieee80211_hw
*hw
)
1935 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1936 struct rtl_pci_priv
*pcipriv
= rtl_pcipriv(hw
);
1937 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1939 pcipriv
->ledctl
.led_opendrain
= true;
1941 switch (rtlhal
->oem_id
) {
1942 case RT_CID_819X_HP
:
1943 pcipriv
->ledctl
.led_opendrain
= true;
1945 case RT_CID_819X_LENOVO
:
1946 case RT_CID_DEFAULT
:
1947 case RT_CID_TOSHIBA
:
1949 case RT_CID_819X_ACER
:
1954 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
,
1955 "RT Customized ID: 0x%02X\n", rtlhal
->oem_id
);
1958 void rtl88ee_read_eeprom_info(struct ieee80211_hw
*hw
)
1960 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1961 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1962 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1963 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1966 rtlhal
->version
= _rtl88ee_read_chip_version(hw
);
1967 if (get_rf_type(rtlphy
) == RF_1T1R
)
1968 rtlpriv
->dm
.rfpath_rxenable
[0] = true;
1970 rtlpriv
->dm
.rfpath_rxenable
[0] =
1971 rtlpriv
->dm
.rfpath_rxenable
[1] = true;
1972 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "VersionID = 0x%4x\n",
1974 tmp_u1b
= rtl_read_byte(rtlpriv
, REG_9346CR
);
1975 if (tmp_u1b
& BIT(4)) {
1976 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "Boot from EEPROM\n");
1977 rtlefuse
->epromtype
= EEPROM_93C46
;
1979 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_DMESG
, "Boot from EFUSE\n");
1980 rtlefuse
->epromtype
= EEPROM_BOOT_EFUSE
;
1982 if (tmp_u1b
& BIT(5)) {
1983 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "Autoload OK\n");
1984 rtlefuse
->autoload_failflag
= false;
1985 _rtl88ee_read_adapter_info(hw
);
1987 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
, "Autoload ERR!!\n");
1989 _rtl88ee_hal_customized_behavior(hw
);
1992 static void rtl88ee_update_hal_rate_table(struct ieee80211_hw
*hw
,
1993 struct ieee80211_sta
*sta
)
1995 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1996 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1997 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
1998 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
2001 u8 b_nmode
= mac
->ht_enable
;
2002 /*u8 mimo_ps = IEEE80211_SMPS_OFF;*/
2005 u8 curtxbw_40mhz
= mac
->bw_40
;
2006 u8 curshortgi_40mhz
= (sta
->ht_cap
.cap
& IEEE80211_HT_CAP_SGI_40
) ?
2008 u8 curshortgi_20mhz
= (sta
->ht_cap
.cap
& IEEE80211_HT_CAP_SGI_20
) ?
2010 enum wireless_mode wirelessmode
= mac
->mode
;
2013 if (rtlhal
->current_bandtype
== BAND_ON_5G
)
2014 ratr_value
= sta
->supp_rates
[1] << 4;
2016 ratr_value
= sta
->supp_rates
[0];
2017 if (mac
->opmode
== NL80211_IFTYPE_ADHOC
)
2019 ratr_value
|= (sta
->ht_cap
.mcs
.rx_mask
[1] << 20 |
2020 sta
->ht_cap
.mcs
.rx_mask
[0] << 12);
2021 switch (wirelessmode
) {
2022 case WIRELESS_MODE_B
:
2023 if (ratr_value
& 0x0000000c)
2024 ratr_value
&= 0x0000000d;
2026 ratr_value
&= 0x0000000f;
2028 case WIRELESS_MODE_G
:
2029 ratr_value
&= 0x00000FF5;
2031 case WIRELESS_MODE_N_24G
:
2032 case WIRELESS_MODE_N_5G
:
2034 if (get_rf_type(rtlphy
) == RF_1T2R
||
2035 get_rf_type(rtlphy
) == RF_1T1R
)
2036 ratr_mask
= 0x000ff005;
2038 ratr_mask
= 0x0f0ff005;
2040 ratr_value
&= ratr_mask
;
2043 if (rtlphy
->rf_type
== RF_1T2R
)
2044 ratr_value
&= 0x000ff0ff;
2046 ratr_value
&= 0x0f0ff0ff;
2051 if ((rtlpriv
->btcoexist
.bt_coexistence
) &&
2052 (rtlpriv
->btcoexist
.bt_coexist_type
== BT_CSR_BC4
) &&
2053 (rtlpriv
->btcoexist
.bt_cur_state
) &&
2054 (rtlpriv
->btcoexist
.bt_ant_isolation
) &&
2055 ((rtlpriv
->btcoexist
.bt_service
== BT_SCO
) ||
2056 (rtlpriv
->btcoexist
.bt_service
== BT_BUSY
)))
2057 ratr_value
&= 0x0fffcfc0;
2059 ratr_value
&= 0x0FFFFFFF;
2062 ((curtxbw_40mhz
&& curshortgi_40mhz
) ||
2063 (!curtxbw_40mhz
&& curshortgi_20mhz
))) {
2064 ratr_value
|= 0x10000000;
2065 tmp_ratr_value
= (ratr_value
>> 12);
2067 for (shortgi_rate
= 15; shortgi_rate
> 0; shortgi_rate
--) {
2068 if ((1 << shortgi_rate
) & tmp_ratr_value
)
2072 shortgi_rate
= (shortgi_rate
<< 12) | (shortgi_rate
<< 8) |
2073 (shortgi_rate
<< 4) | (shortgi_rate
);
2076 rtl_write_dword(rtlpriv
, REG_ARFR0
+ ratr_index
* 4, ratr_value
);
2078 RT_TRACE(rtlpriv
, COMP_RATR
, DBG_DMESG
,
2079 "%x\n", rtl_read_dword(rtlpriv
, REG_ARFR0
));
2082 static void rtl88ee_update_hal_rate_mask(struct ieee80211_hw
*hw
,
2083 struct ieee80211_sta
*sta
, u8 rssi_level
)
2085 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2086 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
2087 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
2088 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
2089 struct rtl_sta_info
*sta_entry
= NULL
;
2092 u8 curtxbw_40mhz
= (sta
->ht_cap
.cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
)
2094 u8 curshortgi_40mhz
= (sta
->ht_cap
.cap
& IEEE80211_HT_CAP_SGI_40
) ?
2096 u8 curshortgi_20mhz
= (sta
->ht_cap
.cap
& IEEE80211_HT_CAP_SGI_20
) ?
2098 enum wireless_mode wirelessmode
= 0;
2099 bool b_shortgi
= false;
2102 /*u8 mimo_ps = IEEE80211_SMPS_OFF;*/
2104 sta_entry
= (struct rtl_sta_info
*)sta
->drv_priv
;
2105 wirelessmode
= sta_entry
->wireless_mode
;
2106 if (mac
->opmode
== NL80211_IFTYPE_STATION
||
2107 mac
->opmode
== NL80211_IFTYPE_MESH_POINT
)
2108 curtxbw_40mhz
= mac
->bw_40
;
2109 else if (mac
->opmode
== NL80211_IFTYPE_AP
||
2110 mac
->opmode
== NL80211_IFTYPE_ADHOC
)
2111 macid
= sta
->aid
+ 1;
2113 if (rtlhal
->current_bandtype
== BAND_ON_5G
)
2114 ratr_bitmap
= sta
->supp_rates
[1] << 4;
2116 ratr_bitmap
= sta
->supp_rates
[0];
2117 if (mac
->opmode
== NL80211_IFTYPE_ADHOC
)
2118 ratr_bitmap
= 0xfff;
2119 ratr_bitmap
|= (sta
->ht_cap
.mcs
.rx_mask
[1] << 20 |
2120 sta
->ht_cap
.mcs
.rx_mask
[0] << 12);
2121 switch (wirelessmode
) {
2122 case WIRELESS_MODE_B
:
2123 ratr_index
= RATR_INX_WIRELESS_B
;
2124 if (ratr_bitmap
& 0x0000000c)
2125 ratr_bitmap
&= 0x0000000d;
2127 ratr_bitmap
&= 0x0000000f;
2129 case WIRELESS_MODE_G
:
2130 ratr_index
= RATR_INX_WIRELESS_GB
;
2132 if (rssi_level
== 1)
2133 ratr_bitmap
&= 0x00000f00;
2134 else if (rssi_level
== 2)
2135 ratr_bitmap
&= 0x00000ff0;
2137 ratr_bitmap
&= 0x00000ff5;
2139 case WIRELESS_MODE_N_24G
:
2140 case WIRELESS_MODE_N_5G
:
2141 ratr_index
= RATR_INX_WIRELESS_NGB
;
2142 if (rtlphy
->rf_type
== RF_1T2R
||
2143 rtlphy
->rf_type
== RF_1T1R
) {
2144 if (curtxbw_40mhz
) {
2145 if (rssi_level
== 1)
2146 ratr_bitmap
&= 0x000f0000;
2147 else if (rssi_level
== 2)
2148 ratr_bitmap
&= 0x000ff000;
2150 ratr_bitmap
&= 0x000ff015;
2152 if (rssi_level
== 1)
2153 ratr_bitmap
&= 0x000f0000;
2154 else if (rssi_level
== 2)
2155 ratr_bitmap
&= 0x000ff000;
2157 ratr_bitmap
&= 0x000ff005;
2160 if (curtxbw_40mhz
) {
2161 if (rssi_level
== 1)
2162 ratr_bitmap
&= 0x0f8f0000;
2163 else if (rssi_level
== 2)
2164 ratr_bitmap
&= 0x0f8ff000;
2166 ratr_bitmap
&= 0x0f8ff015;
2168 if (rssi_level
== 1)
2169 ratr_bitmap
&= 0x0f8f0000;
2170 else if (rssi_level
== 2)
2171 ratr_bitmap
&= 0x0f8ff000;
2173 ratr_bitmap
&= 0x0f8ff005;
2178 if ((curtxbw_40mhz
&& curshortgi_40mhz
) ||
2179 (!curtxbw_40mhz
&& curshortgi_20mhz
)) {
2183 else if (macid
== 1)
2188 ratr_index
= RATR_INX_WIRELESS_NGB
;
2190 if (rtlphy
->rf_type
== RF_1T2R
)
2191 ratr_bitmap
&= 0x000ff0ff;
2193 ratr_bitmap
&= 0x0f0ff0ff;
2196 sta_entry
->ratr_index
= ratr_index
;
2198 RT_TRACE(rtlpriv
, COMP_RATR
, DBG_DMESG
,
2199 "ratr_bitmap :%x\n", ratr_bitmap
);
2200 *(u32
*)&rate_mask
= (ratr_bitmap
& 0x0fffffff) |
2202 rate_mask
[4] = macid
| (b_shortgi
? 0x20 : 0x00) | 0x80;
2203 RT_TRACE(rtlpriv
, COMP_RATR
, DBG_DMESG
,
2204 "Rate_index:%x, ratr_val:%x, %x:%x:%x:%x:%x\n",
2205 ratr_index
, ratr_bitmap
,
2206 rate_mask
[0], rate_mask
[1],
2207 rate_mask
[2], rate_mask
[3],
2209 rtl88e_fill_h2c_cmd(hw
, H2C_88E_RA_MASK
, 5, rate_mask
);
2210 _rtl88ee_set_bcn_ctrl_reg(hw
, BIT(3), 0);
2213 void rtl88ee_update_hal_rate_tbl(struct ieee80211_hw
*hw
,
2214 struct ieee80211_sta
*sta
, u8 rssi_level
)
2216 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2218 if (rtlpriv
->dm
.useramask
)
2219 rtl88ee_update_hal_rate_mask(hw
, sta
, rssi_level
);
2221 rtl88ee_update_hal_rate_table(hw
, sta
);
2224 void rtl88ee_update_channel_access_setting(struct ieee80211_hw
*hw
)
2226 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2227 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
2230 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_SLOT_TIME
, &mac
->slot_time
);
2231 if (!mac
->ht_enable
)
2232 sifs_timer
= 0x0a0a;
2234 sifs_timer
= 0x0e0e;
2235 rtlpriv
->cfg
->ops
->set_hw_reg(hw
, HW_VAR_SIFS
, (u8
*)&sifs_timer
);
2238 bool rtl88ee_gpio_radio_on_off_checking(struct ieee80211_hw
*hw
, u8
*valid
)
2240 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2241 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
2242 enum rf_pwrstate e_rfpowerstate_toset
, cur_rfstate
;
2244 bool b_actuallyset
= false;
2246 if (rtlpriv
->rtlhal
.being_init_adapter
)
2249 if (ppsc
->swrf_processing
)
2252 spin_lock(&rtlpriv
->locks
.rf_ps_lock
);
2253 if (ppsc
->rfchange_inprogress
) {
2254 spin_unlock(&rtlpriv
->locks
.rf_ps_lock
);
2257 ppsc
->rfchange_inprogress
= true;
2258 spin_unlock(&rtlpriv
->locks
.rf_ps_lock
);
2261 cur_rfstate
= ppsc
->rfpwr_state
;
2263 u4tmp
= rtl_read_dword(rtlpriv
, REG_GPIO_OUTPUT
);
2264 e_rfpowerstate_toset
= (u4tmp
& BIT(31)) ? ERFON
: ERFOFF
;
2266 if (ppsc
->hwradiooff
&& (e_rfpowerstate_toset
== ERFON
)) {
2267 RT_TRACE(rtlpriv
, COMP_RF
, DBG_DMESG
,
2268 "GPIOChangeRF - HW Radio ON, RF ON\n");
2270 e_rfpowerstate_toset
= ERFON
;
2271 ppsc
->hwradiooff
= false;
2272 b_actuallyset
= true;
2273 } else if ((!ppsc
->hwradiooff
) &&
2274 (e_rfpowerstate_toset
== ERFOFF
)) {
2275 RT_TRACE(rtlpriv
, COMP_RF
, DBG_DMESG
,
2276 "GPIOChangeRF - HW Radio OFF, RF OFF\n");
2278 e_rfpowerstate_toset
= ERFOFF
;
2279 ppsc
->hwradiooff
= true;
2280 b_actuallyset
= true;
2283 if (b_actuallyset
) {
2284 spin_lock(&rtlpriv
->locks
.rf_ps_lock
);
2285 ppsc
->rfchange_inprogress
= false;
2286 spin_unlock(&rtlpriv
->locks
.rf_ps_lock
);
2288 if (ppsc
->reg_rfps_level
& RT_RF_OFF_LEVL_HALT_NIC
)
2289 RT_SET_PS_LEVEL(ppsc
, RT_RF_OFF_LEVL_HALT_NIC
);
2291 spin_lock(&rtlpriv
->locks
.rf_ps_lock
);
2292 ppsc
->rfchange_inprogress
= false;
2293 spin_unlock(&rtlpriv
->locks
.rf_ps_lock
);
2297 return !ppsc
->hwradiooff
;
2301 void rtl88ee_set_key(struct ieee80211_hw
*hw
, u32 key_index
,
2302 u8
*p_macaddr
, bool is_group
, u8 enc_algo
,
2303 bool is_wepkey
, bool clear_all
)
2305 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2306 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
2307 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
2308 u8
*macaddr
= p_macaddr
;
2310 bool is_pairwise
= false;
2311 static u8 cam_const_addr
[4][6] = {
2312 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
2313 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
2314 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
2315 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}
2317 static u8 cam_const_broad
[] = {
2318 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2324 u8 clear_number
= 5;
2326 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
, "clear_all\n");
2328 for (idx
= 0; idx
< clear_number
; idx
++) {
2329 rtl_cam_mark_invalid(hw
, cam_offset
+ idx
);
2330 rtl_cam_empty_entry(hw
, cam_offset
+ idx
);
2333 memset(rtlpriv
->sec
.key_buf
[idx
], 0,
2335 rtlpriv
->sec
.key_len
[idx
] = 0;
2341 case WEP40_ENCRYPTION
:
2342 enc_algo
= CAM_WEP40
;
2344 case WEP104_ENCRYPTION
:
2345 enc_algo
= CAM_WEP104
;
2347 case TKIP_ENCRYPTION
:
2348 enc_algo
= CAM_TKIP
;
2350 case AESCCMP_ENCRYPTION
:
2354 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
2355 "switch case not process\n");
2356 enc_algo
= CAM_TKIP
;
2360 if (is_wepkey
|| rtlpriv
->sec
.use_defaultkey
) {
2361 macaddr
= cam_const_addr
[key_index
];
2362 entry_id
= key_index
;
2365 macaddr
= cam_const_broad
;
2366 entry_id
= key_index
;
2368 if (mac
->opmode
== NL80211_IFTYPE_AP
||
2369 mac
->opmode
== NL80211_IFTYPE_MESH_POINT
) {
2371 rtl_cam_get_free_entry(hw
, p_macaddr
);
2372 if (entry_id
>= TOTAL_CAM_ENTRY
) {
2373 RT_TRACE(rtlpriv
, COMP_SEC
,
2375 "Can not find free hw security cam entry\n");
2379 entry_id
= CAM_PAIRWISE_KEY_POSITION
;
2381 key_index
= PAIRWISE_KEYIDX
;
2386 if (rtlpriv
->sec
.key_len
[key_index
] == 0) {
2387 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
2388 "delete one entry, entry_id is %d\n",
2390 if (mac
->opmode
== NL80211_IFTYPE_AP
||
2391 mac
->opmode
== NL80211_IFTYPE_MESH_POINT
)
2392 rtl_cam_del_entry(hw
, p_macaddr
);
2393 rtl_cam_delete_one_entry(hw
, p_macaddr
, entry_id
);
2395 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
2398 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
2399 "set Pairwise key\n");
2401 rtl_cam_add_one_entry(hw
, macaddr
, key_index
,
2403 CAM_CONFIG_NO_USEDK
,
2404 rtlpriv
->sec
.key_buf
[key_index
]);
2406 RT_TRACE(rtlpriv
, COMP_SEC
, DBG_DMESG
,
2409 if (mac
->opmode
== NL80211_IFTYPE_ADHOC
) {
2410 rtl_cam_add_one_entry(hw
,
2413 CAM_PAIRWISE_KEY_POSITION
,
2415 CAM_CONFIG_NO_USEDK
,
2416 rtlpriv
->sec
.key_buf
2420 rtl_cam_add_one_entry(hw
, macaddr
, key_index
,
2422 CAM_CONFIG_NO_USEDK
,
2423 rtlpriv
->sec
.key_buf
[entry_id
]);
2430 static void rtl8188ee_bt_var_init(struct ieee80211_hw
*hw
)
2432 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2434 rtlpriv
->btcoexist
.bt_coexistence
=
2435 rtlpriv
->btcoexist
.eeprom_bt_coexist
;
2436 rtlpriv
->btcoexist
.bt_ant_num
= rtlpriv
->btcoexist
.eeprom_bt_ant_num
;
2437 rtlpriv
->btcoexist
.bt_coexist_type
= rtlpriv
->btcoexist
.eeprom_bt_type
;
2439 if (rtlpriv
->btcoexist
.reg_bt_iso
== 2)
2440 rtlpriv
->btcoexist
.bt_ant_isolation
=
2441 rtlpriv
->btcoexist
.eeprom_bt_ant_isol
;
2443 rtlpriv
->btcoexist
.bt_ant_isolation
=
2444 rtlpriv
->btcoexist
.reg_bt_iso
;
2446 rtlpriv
->btcoexist
.bt_radio_shared_type
=
2447 rtlpriv
->btcoexist
.eeprom_bt_radio_shared
;
2449 if (rtlpriv
->btcoexist
.bt_coexistence
) {
2450 if (rtlpriv
->btcoexist
.reg_bt_sco
== 1)
2451 rtlpriv
->btcoexist
.bt_service
= BT_OTHER_ACTION
;
2452 else if (rtlpriv
->btcoexist
.reg_bt_sco
== 2)
2453 rtlpriv
->btcoexist
.bt_service
= BT_SCO
;
2454 else if (rtlpriv
->btcoexist
.reg_bt_sco
== 4)
2455 rtlpriv
->btcoexist
.bt_service
= BT_BUSY
;
2456 else if (rtlpriv
->btcoexist
.reg_bt_sco
== 5)
2457 rtlpriv
->btcoexist
.bt_service
= BT_OTHERBUSY
;
2459 rtlpriv
->btcoexist
.bt_service
= BT_IDLE
;
2461 rtlpriv
->btcoexist
.bt_edca_ul
= 0;
2462 rtlpriv
->btcoexist
.bt_edca_dl
= 0;
2463 rtlpriv
->btcoexist
.bt_rssi_state
= 0xff;
2467 void rtl8188ee_read_bt_coexist_info_from_hwpg(struct ieee80211_hw
*hw
,
2468 bool auto_load_fail
, u8
*hwinfo
)
2470 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2473 if (!auto_load_fail
) {
2474 rtlpriv
->btcoexist
.eeprom_bt_coexist
=
2475 ((hwinfo
[EEPROM_RF_FEATURE_OPTION_88E
] & 0xe0) >> 5);
2476 if (hwinfo
[EEPROM_RF_FEATURE_OPTION_88E
] == 0xFF)
2477 rtlpriv
->btcoexist
.eeprom_bt_coexist
= 0;
2478 value
= hwinfo
[EEPROM_RF_BT_SETTING_88E
];
2479 rtlpriv
->btcoexist
.eeprom_bt_type
= ((value
& 0xe) >> 1);
2480 rtlpriv
->btcoexist
.eeprom_bt_ant_num
= (value
& 0x1);
2481 rtlpriv
->btcoexist
.eeprom_bt_ant_isol
= ((value
& 0x10) >> 4);
2482 rtlpriv
->btcoexist
.eeprom_bt_radio_shared
=
2483 ((value
& 0x20) >> 5);
2485 rtlpriv
->btcoexist
.eeprom_bt_coexist
= 0;
2486 rtlpriv
->btcoexist
.eeprom_bt_type
= BT_2WIRE
;
2487 rtlpriv
->btcoexist
.eeprom_bt_ant_num
= ANT_X2
;
2488 rtlpriv
->btcoexist
.eeprom_bt_ant_isol
= 0;
2489 rtlpriv
->btcoexist
.eeprom_bt_radio_shared
= BT_RADIO_SHARED
;
2492 rtl8188ee_bt_var_init(hw
);
2495 void rtl8188ee_bt_reg_init(struct ieee80211_hw
*hw
)
2497 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2499 /* 0:Low, 1:High, 2:From Efuse. */
2500 rtlpriv
->btcoexist
.reg_bt_iso
= 2;
2501 /* 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter. */
2502 rtlpriv
->btcoexist
.reg_bt_sco
= 3;
2503 /* 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */
2504 rtlpriv
->btcoexist
.reg_bt_sco
= 0;
2507 void rtl8188ee_bt_hw_init(struct ieee80211_hw
*hw
)
2509 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
2510 struct rtl_phy
*rtlphy
= &rtlpriv
->phy
;
2513 if (rtlpriv
->btcoexist
.bt_coexistence
&&
2514 ((rtlpriv
->btcoexist
.bt_coexist_type
== BT_CSR_BC4
) ||
2515 rtlpriv
->btcoexist
.bt_coexist_type
== BT_CSR_BC8
)) {
2516 if (rtlpriv
->btcoexist
.bt_ant_isolation
)
2517 rtl_write_byte(rtlpriv
, REG_GPIO_MUXCFG
, 0xa0);
2519 u1_tmp
= rtl_read_byte(rtlpriv
, 0x4fd) &
2520 BIT_OFFSET_LEN_MASK_32(0, 1);
2522 ((rtlpriv
->btcoexist
.bt_ant_isolation
== 1) ?
2523 0 : BIT_OFFSET_LEN_MASK_32(1, 1)) |
2524 ((rtlpriv
->btcoexist
.bt_service
== BT_SCO
) ?
2525 0 : BIT_OFFSET_LEN_MASK_32(2, 1));
2526 rtl_write_byte(rtlpriv
, 0x4fd, u1_tmp
);
2528 rtl_write_dword(rtlpriv
, REG_BT_COEX_TABLE
+4, 0xaaaa9aaa);
2529 rtl_write_dword(rtlpriv
, REG_BT_COEX_TABLE
+8, 0xffbd0040);
2530 rtl_write_dword(rtlpriv
, REG_BT_COEX_TABLE
+0xc, 0x40000010);
2532 /* Config to 1T1R. */
2533 if (rtlphy
->rf_type
== RF_1T1R
) {
2534 u1_tmp
= rtl_read_byte(rtlpriv
, ROFDM0_TRXPATHENABLE
);
2535 u1_tmp
&= ~(BIT_OFFSET_LEN_MASK_32(1, 1));
2536 rtl_write_byte(rtlpriv
, ROFDM0_TRXPATHENABLE
, u1_tmp
);
2538 u1_tmp
= rtl_read_byte(rtlpriv
, ROFDM1_TRXPATHENABLE
);
2539 u1_tmp
&= ~(BIT_OFFSET_LEN_MASK_32(1, 1));
2540 rtl_write_byte(rtlpriv
, ROFDM1_TRXPATHENABLE
, u1_tmp
);
2545 void rtl88ee_suspend(struct ieee80211_hw
*hw
)
2549 void rtl88ee_resume(struct ieee80211_hw
*hw
)