1 /******************************************************************************
3 * Copyright(c) 2009-2014 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 *****************************************************************************/
40 #include "../pwrseqcmd.h"
45 static void _rtl92ee_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 _rtl92ee_stop_tx_beacon(struct ieee80211_hw *hw)
59 struct rtl_priv *rtlpriv = rtl_priv(hw);
62 tmp = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
63 rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp & (~BIT(6)));
64 rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0x64);
65 tmp = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2);
67 rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp);
70 static void _rtl92ee_resume_tx_beacon(struct ieee80211_hw *hw)
72 struct rtl_priv *rtlpriv = rtl_priv(hw);
75 tmp = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
76 rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp | BIT(6));
77 rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff);
78 tmp = rtl_read_byte(rtlpriv, REG_TBTT_PROHIBIT + 2);
80 rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp);
83 static void _rtl92ee_enable_bcn_sub_func(struct ieee80211_hw *hw)
85 _rtl92ee_set_bcn_ctrl_reg(hw, 0, BIT(1));
88 static void _rtl92ee_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_buffer_desc *entry =
98 &ring->buffer_desc[ring->idx];
99 struct sk_buff *skb = __skb_dequeue(&ring->queue);
101 pci_unmap_single(rtlpci->pdev,
102 rtlpriv->cfg->ops->get_desc(
103 (u8 *)entry, true, HW_DESC_TXBUFF_ADDR),
104 skb->len, PCI_DMA_TODEVICE);
106 ring->idx = (ring->idx + 1) % ring->entries;
108 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
111 static void _rtl92ee_disable_bcn_sub_func(struct ieee80211_hw *hw)
113 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(1), 0);
116 static void _rtl92ee_set_fw_clock_on(struct ieee80211_hw *hw,
117 u8 rpwm_val, bool b_need_turn_off_ckk)
119 struct rtl_priv *rtlpriv = rtl_priv(hw);
120 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
121 bool b_support_remote_wake_up;
122 u32 count = 0, isr_regaddr, content;
123 bool b_schedule_timer = b_need_turn_off_ckk;
125 rtlpriv->cfg->ops->get_hw_reg(hw, HAL_DEF_WOWLAN,
126 (u8 *)(&b_support_remote_wake_up));
128 if (!rtlhal->fw_ready)
130 if (!rtlpriv->psc.fw_current_inpsmode)
134 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
135 if (rtlhal->fw_clk_change_in_progress) {
136 while (rtlhal->fw_clk_change_in_progress) {
137 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
142 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
144 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
146 rtlhal->fw_clk_change_in_progress = false;
147 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
152 if (IS_IN_LOW_POWER_STATE_92E(rtlhal->fw_ps_state)) {
153 rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_SET_RPWM,
155 if (FW_PS_IS_ACK(rpwm_val)) {
156 isr_regaddr = REG_HISR;
157 content = rtl_read_dword(rtlpriv, isr_regaddr);
158 while (!(content & IMR_CPWM) && (count < 500)) {
161 content = rtl_read_dword(rtlpriv, isr_regaddr);
164 if (content & IMR_CPWM) {
165 rtl_write_word(rtlpriv, isr_regaddr, 0x0100);
166 rtlhal->fw_ps_state = FW_PS_STATE_RF_ON_92E;
167 RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
168 "Receive CPWM INT!!! PSState = %X\n",
169 rtlhal->fw_ps_state);
173 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
174 rtlhal->fw_clk_change_in_progress = false;
175 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
176 if (b_schedule_timer) {
177 mod_timer(&rtlpriv->works.fw_clockoff_timer,
178 jiffies + MSECS(10));
181 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
182 rtlhal->fw_clk_change_in_progress = false;
183 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
187 static void _rtl92ee_set_fw_clock_off(struct ieee80211_hw *hw, u8 rpwm_val)
189 struct rtl_priv *rtlpriv = rtl_priv(hw);
190 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
191 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
192 struct rtl8192_tx_ring *ring;
193 enum rf_pwrstate rtstate;
194 bool b_schedule_timer = false;
197 if (!rtlhal->fw_ready)
199 if (!rtlpriv->psc.fw_current_inpsmode)
201 if (!rtlhal->allow_sw_to_change_hwclc)
204 rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RF_STATE, (u8 *)(&rtstate));
205 if (rtstate == ERFOFF || rtlpriv->psc.inactive_pwrstate == ERFOFF)
208 for (queue = 0; queue < RTL_PCI_MAX_TX_QUEUE_COUNT; queue++) {
209 ring = &rtlpci->tx_ring[queue];
210 if (skb_queue_len(&ring->queue)) {
211 b_schedule_timer = true;
216 if (b_schedule_timer) {
217 mod_timer(&rtlpriv->works.fw_clockoff_timer,
218 jiffies + MSECS(10));
222 if (FW_PS_STATE(rtlhal->fw_ps_state) != FW_PS_STATE_RF_OFF_LOW_PWR) {
223 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
224 if (!rtlhal->fw_clk_change_in_progress) {
225 rtlhal->fw_clk_change_in_progress = true;
226 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
227 rtlhal->fw_ps_state = FW_PS_STATE(rpwm_val);
228 rtl_write_word(rtlpriv, REG_HISR, 0x0100);
229 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SET_RPWM,
231 spin_lock_bh(&rtlpriv->locks.fw_ps_lock);
232 rtlhal->fw_clk_change_in_progress = false;
233 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
235 spin_unlock_bh(&rtlpriv->locks.fw_ps_lock);
236 mod_timer(&rtlpriv->works.fw_clockoff_timer,
237 jiffies + MSECS(10));
242 static void _rtl92ee_set_fw_ps_rf_on(struct ieee80211_hw *hw)
246 rpwm_val |= (FW_PS_STATE_RF_OFF_92E | FW_PS_ACK);
247 _rtl92ee_set_fw_clock_on(hw, rpwm_val, true);
250 static void _rtl92ee_set_fw_ps_rf_off_low_power(struct ieee80211_hw *hw)
254 rpwm_val |= FW_PS_STATE_RF_OFF_LOW_PWR;
255 _rtl92ee_set_fw_clock_off(hw, rpwm_val);
258 void rtl92ee_fw_clk_off_timer_callback(unsigned long data)
260 struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
262 _rtl92ee_set_fw_ps_rf_off_low_power(hw);
265 static void _rtl92ee_fwlps_leave(struct ieee80211_hw *hw)
267 struct rtl_priv *rtlpriv = rtl_priv(hw);
268 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
269 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
270 bool fw_current_inps = false;
271 u8 rpwm_val = 0, fw_pwrmode = FW_PS_ACTIVE_MODE;
273 if (ppsc->low_power_enable) {
274 rpwm_val = (FW_PS_STATE_ALL_ON_92E | FW_PS_ACK);/* RF on */
275 _rtl92ee_set_fw_clock_on(hw, rpwm_val, false);
276 rtlhal->allow_sw_to_change_hwclc = false;
277 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
278 (u8 *)(&fw_pwrmode));
279 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
280 (u8 *)(&fw_current_inps));
282 rpwm_val = FW_PS_STATE_ALL_ON_92E; /* RF on */
283 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SET_RPWM,
285 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
286 (u8 *)(&fw_pwrmode));
287 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
288 (u8 *)(&fw_current_inps));
292 static void _rtl92ee_fwlps_enter(struct ieee80211_hw *hw)
294 struct rtl_priv *rtlpriv = rtl_priv(hw);
295 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
296 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
297 bool fw_current_inps = true;
300 if (ppsc->low_power_enable) {
301 rpwm_val = FW_PS_STATE_RF_OFF_LOW_PWR; /* RF off */
302 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
303 (u8 *)(&fw_current_inps));
304 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
305 (u8 *)(&ppsc->fwctrl_psmode));
306 rtlhal->allow_sw_to_change_hwclc = true;
307 _rtl92ee_set_fw_clock_off(hw, rpwm_val);
309 rpwm_val = FW_PS_STATE_RF_OFF_92E; /* RF off */
310 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_PSMODE_STATUS,
311 (u8 *)(&fw_current_inps));
312 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_PWRMODE,
313 (u8 *)(&ppsc->fwctrl_psmode));
314 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SET_RPWM,
319 void rtl92ee_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
321 struct rtl_priv *rtlpriv = rtl_priv(hw);
322 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
323 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
327 *((u32 *)(val)) = rtlpci->receive_config;
329 case HW_VAR_RF_STATE:
330 *((enum rf_pwrstate *)(val)) = ppsc->rfpwr_state;
332 case HW_VAR_FWLPS_RF_ON:{
333 enum rf_pwrstate rfstate;
336 rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_RF_STATE,
338 if (rfstate == ERFOFF) {
339 *((bool *)(val)) = true;
341 val_rcr = rtl_read_dword(rtlpriv, REG_RCR);
342 val_rcr &= 0x00070000;
344 *((bool *)(val)) = false;
346 *((bool *)(val)) = true;
350 case HW_VAR_FW_PSMODE_STATUS:
351 *((bool *)(val)) = ppsc->fw_current_inpsmode;
353 case HW_VAR_CORRECT_TSF:{
355 u32 *ptsf_low = (u32 *)&tsf;
356 u32 *ptsf_high = ((u32 *)&tsf) + 1;
358 *ptsf_high = rtl_read_dword(rtlpriv, (REG_TSFTR + 4));
359 *ptsf_low = rtl_read_dword(rtlpriv, REG_TSFTR);
361 *((u64 *)(val)) = tsf;
365 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
366 "switch case not process %x\n", variable);
371 static void _rtl92ee_download_rsvd_page(struct ieee80211_hw *hw)
373 struct rtl_priv *rtlpriv = rtl_priv(hw);
374 u8 tmp_regcr, tmp_reg422;
375 u8 bcnvalid_reg, txbc_reg;
376 u8 count = 0, dlbcn_count = 0;
377 bool b_recover = false;
379 /*Set REG_CR bit 8. DMA beacon by SW.*/
380 tmp_regcr = rtl_read_byte(rtlpriv, REG_CR + 1);
381 rtl_write_byte(rtlpriv, REG_CR + 1, tmp_regcr | BIT(0));
383 /* Disable Hw protection for a time which revserd for Hw sending beacon.
384 * Fix download reserved page packet fail
385 * that access collision with the protection time.
386 * 2010.05.11. Added by tynli.
388 _rtl92ee_set_bcn_ctrl_reg(hw, 0, BIT(3));
389 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(4), 0);
391 /* Set FWHW_TXQ_CTRL 0x422[6]=0 to
392 * tell Hw the packet is not a real beacon frame.
394 tmp_reg422 = rtl_read_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2);
395 rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp_reg422 & (~BIT(6)));
397 if (tmp_reg422 & BIT(6))
401 /* Clear beacon valid check bit */
402 bcnvalid_reg = rtl_read_byte(rtlpriv, REG_DWBCN0_CTRL + 2);
403 rtl_write_byte(rtlpriv, REG_DWBCN0_CTRL + 2,
404 bcnvalid_reg | BIT(0));
406 /* Return Beacon TCB */
407 _rtl92ee_return_beacon_queue_skb(hw);
409 /* download rsvd page */
410 rtl92ee_set_fw_rsvdpagepkt(hw, false);
412 txbc_reg = rtl_read_byte(rtlpriv, REG_MGQ_TXBD_NUM + 3);
414 while ((txbc_reg & BIT(4)) && count < 20) {
417 txbc_reg = rtl_read_byte(rtlpriv, REG_MGQ_TXBD_NUM + 3);
419 rtl_write_byte(rtlpriv, REG_MGQ_TXBD_NUM + 3,
422 /* check rsvd page download OK. */
423 bcnvalid_reg = rtl_read_byte(rtlpriv, REG_DWBCN0_CTRL + 2);
425 while (!(bcnvalid_reg & BIT(0)) && count < 20) {
428 bcnvalid_reg = rtl_read_byte(rtlpriv,
429 REG_DWBCN0_CTRL + 2);
432 if (bcnvalid_reg & BIT(0))
433 rtl_write_byte(rtlpriv, REG_DWBCN0_CTRL + 2, BIT(0));
436 } while (!(bcnvalid_reg & BIT(0)) && dlbcn_count < 5);
438 if (!(bcnvalid_reg & BIT(0)))
439 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
440 "Download RSVD page failed!\n");
443 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(3), 0);
444 _rtl92ee_set_bcn_ctrl_reg(hw, 0, BIT(4));
447 rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 2, tmp_reg422);
449 tmp_regcr = rtl_read_byte(rtlpriv, REG_CR + 1);
450 rtl_write_byte(rtlpriv, REG_CR + 1, tmp_regcr & (~BIT(0)));
453 void rtl92ee_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
455 struct rtl_priv *rtlpriv = rtl_priv(hw);
456 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
457 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
458 struct rtl_efuse *efuse = rtl_efuse(rtl_priv(hw));
459 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
463 case HW_VAR_ETHER_ADDR:
464 for (idx = 0; idx < ETH_ALEN; idx++)
465 rtl_write_byte(rtlpriv, (REG_MACID + idx), val[idx]);
467 case HW_VAR_BASIC_RATE:{
468 u16 b_rate_cfg = ((u16 *)val)[0];
470 b_rate_cfg = b_rate_cfg & 0x15f;
472 b_rate_cfg = (b_rate_cfg | 0xd) & (~BIT(1));
473 rtl_write_byte(rtlpriv, REG_RRSR, b_rate_cfg & 0xff);
474 rtl_write_byte(rtlpriv, REG_RRSR + 1, (b_rate_cfg >> 8) & 0xff);
477 for (idx = 0; idx < ETH_ALEN; idx++)
478 rtl_write_byte(rtlpriv, (REG_BSSID + idx), val[idx]);
481 rtl_write_byte(rtlpriv, REG_SIFS_CTX + 1, val[0]);
482 rtl_write_byte(rtlpriv, REG_SIFS_TRX + 1, val[1]);
484 rtl_write_byte(rtlpriv, REG_SPEC_SIFS + 1, val[0]);
485 rtl_write_byte(rtlpriv, REG_MAC_SPEC_SIFS + 1, val[0]);
488 rtl_write_word(rtlpriv, REG_RESP_SIFS_OFDM, 0x0e0e);
490 rtl_write_word(rtlpriv, REG_RESP_SIFS_OFDM,
493 case HW_VAR_SLOT_TIME:{
496 RT_TRACE(rtlpriv, COMP_MLME, DBG_TRACE,
497 "HW_VAR_SLOT_TIME %x\n", val[0]);
499 rtl_write_byte(rtlpriv, REG_SLOT, val[0]);
501 for (e_aci = 0; e_aci < AC_MAX; e_aci++) {
502 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AC_PARAM,
506 case HW_VAR_ACK_PREAMBLE:{
508 u8 short_preamble = (bool)(*(u8 *)val);
510 reg_tmp = (rtlpriv->mac80211.cur_40_prime_sc) << 5;
513 rtl_write_byte(rtlpriv, REG_RRSR + 2, reg_tmp);
514 rtlpriv->mac80211.short_preamble = short_preamble;
517 case HW_VAR_WPA_CONFIG:
518 rtl_write_byte(rtlpriv, REG_SECCFG, *((u8 *)val));
520 case HW_VAR_AMPDU_FACTOR:{
521 u8 regtoset_normal[4] = { 0x41, 0xa8, 0x72, 0xb9 };
526 reg = regtoset_normal;
530 fac = (1 << (fac + 2));
533 for (i = 0; i < 4; i++) {
534 if ((reg[i] & 0xf0) > (fac << 4))
535 reg[i] = (reg[i] & 0x0f) |
537 if ((reg[i] & 0x0f) > fac)
538 reg[i] = (reg[i] & 0xf0) | fac;
539 rtl_write_byte(rtlpriv,
540 (REG_AGGLEN_LMT + i),
543 RT_TRACE(rtlpriv, COMP_MLME, DBG_LOUD,
544 "Set HW_VAR_AMPDU_FACTOR:%#x\n", fac);
548 case HW_VAR_AC_PARAM:{
549 u8 e_aci = *((u8 *)val);
551 if (rtlpci->acm_method != EACMWAY2_SW)
552 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ACM_CTRL,
556 case HW_VAR_ACM_CTRL:{
557 u8 e_aci = *((u8 *)val);
558 union aci_aifsn *aifs = (union aci_aifsn *)(&mac->ac[0].aifs);
560 u8 acm = aifs->f.acm;
561 u8 acm_ctrl = rtl_read_byte(rtlpriv, REG_ACMHWCTRL);
563 acm_ctrl = acm_ctrl | ((rtlpci->acm_method == 2) ? 0x0 : 0x1);
568 acm_ctrl |= ACMHW_BEQEN;
571 acm_ctrl |= ACMHW_VIQEN;
574 acm_ctrl |= ACMHW_VOQEN;
577 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
578 "HW_VAR_ACM_CTRL acm set failed: eACI is %d\n",
585 acm_ctrl &= (~ACMHW_BEQEN);
588 acm_ctrl &= (~ACMHW_VIQEN);
591 acm_ctrl &= (~ACMHW_BEQEN);
594 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
595 "switch case not process\n");
600 RT_TRACE(rtlpriv, COMP_QOS, DBG_TRACE,
601 "SetHwReg8190pci(): [HW_VAR_ACM_CTRL] Write 0x%X\n",
603 rtl_write_byte(rtlpriv, REG_ACMHWCTRL, acm_ctrl);
607 rtl_write_dword(rtlpriv, REG_RCR, ((u32 *)(val))[0]);
608 rtlpci->receive_config = ((u32 *)(val))[0];
611 case HW_VAR_RETRY_LIMIT:{
612 u8 retry_limit = ((u8 *)(val))[0];
614 rtl_write_word(rtlpriv, REG_RETRY_LIMIT,
615 retry_limit << RETRY_LIMIT_SHORT_SHIFT |
616 retry_limit << RETRY_LIMIT_LONG_SHIFT);
619 case HW_VAR_DUAL_TSF_RST:
620 rtl_write_byte(rtlpriv, REG_DUAL_TSF_RST, (BIT(0) | BIT(1)));
622 case HW_VAR_EFUSE_BYTES:
623 efuse->efuse_usedbytes = *((u16 *)val);
625 case HW_VAR_EFUSE_USAGE:
626 efuse->efuse_usedpercentage = *((u8 *)val);
629 rtl92ee_phy_set_io_cmd(hw, (*(enum io_type *)val));
631 case HW_VAR_SET_RPWM:{
634 rpwm_val = rtl_read_byte(rtlpriv, REG_PCIE_HRPWM);
637 if (rpwm_val & BIT(7)) {
638 rtl_write_byte(rtlpriv, REG_PCIE_HRPWM, (*(u8 *)val));
640 rtl_write_byte(rtlpriv, REG_PCIE_HRPWM,
641 ((*(u8 *)val) | BIT(7)));
645 case HW_VAR_H2C_FW_PWRMODE:
646 rtl92ee_set_fw_pwrmode_cmd(hw, (*(u8 *)val));
648 case HW_VAR_FW_PSMODE_STATUS:
649 ppsc->fw_current_inpsmode = *((bool *)val);
651 case HW_VAR_RESUME_CLK_ON:
652 _rtl92ee_set_fw_ps_rf_on(hw);
654 case HW_VAR_FW_LPS_ACTION:{
655 bool b_enter_fwlps = *((bool *)val);
658 _rtl92ee_fwlps_enter(hw);
660 _rtl92ee_fwlps_leave(hw);
663 case HW_VAR_H2C_FW_JOINBSSRPT:{
664 u8 mstatus = (*(u8 *)val);
666 if (mstatus == RT_MEDIA_CONNECT) {
667 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AID, NULL);
668 _rtl92ee_download_rsvd_page(hw);
670 rtl92ee_set_fw_media_status_rpt_cmd(hw, mstatus);
673 case HW_VAR_H2C_FW_P2P_PS_OFFLOAD:
674 rtl92ee_set_p2p_ps_offload_cmd(hw, (*(u8 *)val));
679 u2btmp = rtl_read_word(rtlpriv, REG_BCN_PSR_RPT);
681 rtl_write_word(rtlpriv, REG_BCN_PSR_RPT,
682 (u2btmp | mac->assoc_id));
685 case HW_VAR_CORRECT_TSF:{
686 u8 btype_ibss = ((u8 *)(val))[0];
689 _rtl92ee_stop_tx_beacon(hw);
691 _rtl92ee_set_bcn_ctrl_reg(hw, 0, BIT(3));
693 rtl_write_dword(rtlpriv, REG_TSFTR,
694 (u32)(mac->tsf & 0xffffffff));
695 rtl_write_dword(rtlpriv, REG_TSFTR + 4,
696 (u32)((mac->tsf >> 32) & 0xffffffff));
698 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(3), 0);
701 _rtl92ee_resume_tx_beacon(hw);
704 case HW_VAR_KEEP_ALIVE: {
708 array[1] = *((u8 *)val);
709 rtl92ee_fill_h2c_cmd(hw, H2C_92E_KEEP_ALIVE_CTRL, 2, array);
713 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
714 "switch case not process %x\n", variable);
719 static bool _rtl92ee_llt_table_init(struct ieee80211_hw *hw)
721 struct rtl_priv *rtlpriv = rtl_priv(hw);
723 u8 u8tmp, testcnt = 0;
725 txpktbuf_bndy = 0xFA;
727 rtl_write_dword(rtlpriv, REG_RQPN, 0x80E90808);
729 rtl_write_byte(rtlpriv, REG_TRXFF_BNDY, txpktbuf_bndy);
730 rtl_write_word(rtlpriv, REG_TRXFF_BNDY + 2, 0x3d00 - 1);
732 rtl_write_byte(rtlpriv, REG_DWBCN0_CTRL + 1, txpktbuf_bndy);
733 rtl_write_byte(rtlpriv, REG_DWBCN1_CTRL + 1, txpktbuf_bndy);
735 rtl_write_byte(rtlpriv, REG_BCNQ_BDNY, txpktbuf_bndy);
736 rtl_write_byte(rtlpriv, REG_BCNQ1_BDNY, txpktbuf_bndy);
738 rtl_write_byte(rtlpriv, REG_MGQ_BDNY, txpktbuf_bndy);
739 rtl_write_byte(rtlpriv, 0x45D, txpktbuf_bndy);
741 rtl_write_byte(rtlpriv, REG_PBP, 0x31);
742 rtl_write_byte(rtlpriv, REG_RX_DRVINFO_SZ, 0x4);
744 u8tmp = rtl_read_byte(rtlpriv, REG_AUTO_LLT + 2);
745 rtl_write_byte(rtlpriv, REG_AUTO_LLT + 2, u8tmp | BIT(0));
747 while (u8tmp & BIT(0)) {
748 u8tmp = rtl_read_byte(rtlpriv, REG_AUTO_LLT + 2);
758 static void _rtl92ee_gen_refresh_led_state(struct ieee80211_hw *hw)
760 struct rtl_priv *rtlpriv = rtl_priv(hw);
761 struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
762 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
763 struct rtl_led *pled0 = &pcipriv->ledctl.sw_led0;
765 if (rtlpriv->rtlhal.up_first_time)
768 if (ppsc->rfoff_reason == RF_CHANGE_BY_IPS)
769 rtl92ee_sw_led_on(hw, pled0);
770 else if (ppsc->rfoff_reason == RF_CHANGE_BY_INIT)
771 rtl92ee_sw_led_on(hw, pled0);
773 rtl92ee_sw_led_off(hw, pled0);
776 static bool _rtl92ee_init_mac(struct ieee80211_hw *hw)
778 struct rtl_priv *rtlpriv = rtl_priv(hw);
779 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
780 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
786 rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x0);
788 dwordtmp = rtl_read_dword(rtlpriv, REG_SYS_CFG1);
789 if (dwordtmp & BIT(24)) {
790 rtl_write_byte(rtlpriv, 0x7c, 0xc3);
792 bytetmp = rtl_read_byte(rtlpriv, 0x16);
793 rtl_write_byte(rtlpriv, 0x16, bytetmp | BIT(4) | BIT(6));
794 rtl_write_byte(rtlpriv, 0x7c, 0x83);
796 /* 1. 40Mhz crystal source*/
797 bytetmp = rtl_read_byte(rtlpriv, REG_AFE_CTRL2);
799 rtl_write_byte(rtlpriv, REG_AFE_CTRL2, bytetmp);
801 dwordtmp = rtl_read_dword(rtlpriv, REG_AFE_CTRL4);
802 dwordtmp &= 0xfffffc7f;
803 rtl_write_dword(rtlpriv, REG_AFE_CTRL4, dwordtmp);
805 /* 2. 92E AFE parameter
806 * MP chip then check version
808 bytetmp = rtl_read_byte(rtlpriv, REG_AFE_CTRL2);
810 rtl_write_byte(rtlpriv, REG_AFE_CTRL2, bytetmp);
812 dwordtmp = rtl_read_dword(rtlpriv, REG_AFE_CTRL4);
813 dwordtmp &= 0xffdfffff;
814 rtl_write_dword(rtlpriv, REG_AFE_CTRL4, dwordtmp);
816 /* HW Power on sequence */
817 if (!rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
819 RTL8192E_NIC_ENABLE_FLOW)) {
820 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
821 "init MAC Fail as rtl_hal_pwrseqcmdparsing\n");
825 /* Release MAC IO register reset */
826 bytetmp = rtl_read_byte(rtlpriv, REG_CR);
828 rtl_write_byte(rtlpriv, REG_CR, bytetmp);
831 rtl_write_byte(rtlpriv, REG_HWSEQ_CTRL, bytetmp);
834 /* Add for wakeup online */
835 bytetmp = rtl_read_byte(rtlpriv, REG_SYS_CLKR);
836 rtl_write_byte(rtlpriv, REG_SYS_CLKR, bytetmp | BIT(3));
837 bytetmp = rtl_read_byte(rtlpriv, REG_GPIO_MUXCFG + 1);
838 rtl_write_byte(rtlpriv, REG_GPIO_MUXCFG + 1, bytetmp & (~BIT(4)));
839 /* Release MAC IO register reset */
840 rtl_write_word(rtlpriv, REG_CR, 0x2ff);
842 if (!rtlhal->mac_func_enable) {
843 if (_rtl92ee_llt_table_init(hw) == false) {
844 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
845 "LLT table init fail\n");
850 rtl_write_dword(rtlpriv, REG_HISR, 0xffffffff);
851 rtl_write_dword(rtlpriv, REG_HISRE, 0xffffffff);
853 wordtmp = rtl_read_word(rtlpriv, REG_TRXDMA_CTRL);
856 rtl_write_word(rtlpriv, REG_TRXDMA_CTRL, wordtmp);
857 /* Reported Tx status from HW for rate adaptive.*/
858 rtl_write_byte(rtlpriv, REG_FWHW_TXQ_CTRL + 1, 0x1F);
860 /* Set RCR register */
861 rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config);
862 rtl_write_word(rtlpriv, REG_RXFLTMAP2, 0xffff);
864 /* Set TCR register */
865 rtl_write_dword(rtlpriv, REG_TCR, rtlpci->transmit_config);
867 /* Set TX/RX descriptor physical address(from OS API). */
868 rtl_write_dword(rtlpriv, REG_BCNQ_DESA,
869 ((u64)rtlpci->tx_ring[BEACON_QUEUE].buffer_desc_dma) &
871 rtl_write_dword(rtlpriv, REG_MGQ_DESA,
872 (u64)rtlpci->tx_ring[MGNT_QUEUE].buffer_desc_dma &
874 rtl_write_dword(rtlpriv, REG_VOQ_DESA,
875 (u64)rtlpci->tx_ring[VO_QUEUE].buffer_desc_dma &
877 rtl_write_dword(rtlpriv, REG_VIQ_DESA,
878 (u64)rtlpci->tx_ring[VI_QUEUE].buffer_desc_dma &
881 rtl_write_dword(rtlpriv, REG_BEQ_DESA,
882 (u64)rtlpci->tx_ring[BE_QUEUE].buffer_desc_dma &
885 dwordtmp = rtl_read_dword(rtlpriv, REG_BEQ_DESA);
887 rtl_write_dword(rtlpriv, REG_BKQ_DESA,
888 (u64)rtlpci->tx_ring[BK_QUEUE].buffer_desc_dma &
890 rtl_write_dword(rtlpriv, REG_HQ0_DESA,
891 (u64)rtlpci->tx_ring[HIGH_QUEUE].buffer_desc_dma &
894 rtl_write_dword(rtlpriv, REG_RX_DESA,
895 (u64)rtlpci->rx_ring[RX_MPDU_QUEUE].dma &
898 /* if we want to support 64 bit DMA, we should set it here,
899 * but now we do not support 64 bit DMA
902 rtl_write_dword(rtlpriv, REG_TSFTIMER_HCI, 0x3fffffff);
904 bytetmp = rtl_read_byte(rtlpriv, REG_PCIE_CTRL_REG + 3);
905 rtl_write_byte(rtlpriv, REG_PCIE_CTRL_REG + 3, bytetmp | 0xF7);
907 rtl_write_dword(rtlpriv, REG_INT_MIG, 0);
909 rtl_write_dword(rtlpriv, REG_MCUTST_1, 0x0);
911 rtl_write_word(rtlpriv, REG_MGQ_TXBD_NUM,
912 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
913 rtl_write_word(rtlpriv, REG_VOQ_TXBD_NUM,
914 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
915 rtl_write_word(rtlpriv, REG_VIQ_TXBD_NUM,
916 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
917 rtl_write_word(rtlpriv, REG_BEQ_TXBD_NUM,
918 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
919 rtl_write_word(rtlpriv, REG_VOQ_TXBD_NUM,
920 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
921 rtl_write_word(rtlpriv, REG_BKQ_TXBD_NUM,
922 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
923 rtl_write_word(rtlpriv, REG_HI0Q_TXBD_NUM,
924 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
925 rtl_write_word(rtlpriv, REG_HI1Q_TXBD_NUM,
926 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
927 rtl_write_word(rtlpriv, REG_HI2Q_TXBD_NUM,
928 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
929 rtl_write_word(rtlpriv, REG_HI3Q_TXBD_NUM,
930 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
931 rtl_write_word(rtlpriv, REG_HI4Q_TXBD_NUM,
932 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
933 rtl_write_word(rtlpriv, REG_HI5Q_TXBD_NUM,
934 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
935 rtl_write_word(rtlpriv, REG_HI6Q_TXBD_NUM,
936 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
937 rtl_write_word(rtlpriv, REG_HI7Q_TXBD_NUM,
938 TX_DESC_NUM_92E | ((RTL8192EE_SEG_NUM << 12) & 0x3000));
940 #if (DMA_IS_64BIT == 1)
941 rtl_write_word(rtlpriv, REG_RX_RXBD_NUM,
943 ((RTL8192EE_SEG_NUM << 13) & 0x6000) | 0x8000);
945 rtl_write_word(rtlpriv, REG_RX_RXBD_NUM,
947 ((RTL8192EE_SEG_NUM << 13) & 0x6000) | 0x0000);
950 rtl_write_dword(rtlpriv, REG_TSFTIMER_HCI, 0XFFFFFFFF);
952 _rtl92ee_gen_refresh_led_state(hw);
956 static void _rtl92ee_hw_configure(struct ieee80211_hw *hw)
958 struct rtl_priv *rtlpriv = rtl_priv(hw);
959 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
962 reg_rrsr = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
963 /* Init value for RRSR. */
964 rtl_write_dword(rtlpriv, REG_RRSR, reg_rrsr);
966 /* ARFB table 9 for 11ac 5G 2SS */
967 rtl_write_dword(rtlpriv, REG_ARFR0, 0x00000010);
968 rtl_write_dword(rtlpriv, REG_ARFR0 + 4, 0x3e0ff000);
970 /* ARFB table 10 for 11ac 5G 1SS */
971 rtl_write_dword(rtlpriv, REG_ARFR1, 0x00000010);
972 rtl_write_dword(rtlpriv, REG_ARFR1 + 4, 0x000ff000);
975 rtl_write_byte(rtlpriv, REG_SLOT, 0x09);
977 /* CF-End setting. */
978 rtl_write_word(rtlpriv, REG_FWHW_TXQ_CTRL, 0x1F80);
980 /* Set retry limit */
981 rtl_write_word(rtlpriv, REG_RETRY_LIMIT, 0x0707);
984 rtl_write_dword(rtlpriv, REG_BAR_MODE_CTRL, 0x0201ffff);
986 /* Set Data / Response auto rate fallack retry count */
987 rtl_write_dword(rtlpriv, REG_DARFRC, 0x01000000);
988 rtl_write_dword(rtlpriv, REG_DARFRC + 4, 0x07060504);
989 rtl_write_dword(rtlpriv, REG_RARFRC, 0x01000000);
990 rtl_write_dword(rtlpriv, REG_RARFRC + 4, 0x07060504);
992 /* Beacon related, for rate adaptive */
993 rtl_write_byte(rtlpriv, REG_ATIMWND, 0x2);
994 rtl_write_byte(rtlpriv, REG_BCN_MAX_ERR, 0xff);
996 rtlpci->reg_bcn_ctrl_val = 0x1d;
997 rtl_write_byte(rtlpriv, REG_BCN_CTRL, rtlpci->reg_bcn_ctrl_val);
999 /* Marked out by Bruce, 2010-09-09.
1000 * This register is configured for the 2nd Beacon (multiple BSSID).
1001 * We shall disable this register if we only support 1 BSSID.
1002 * vivi guess 92d also need this, also 92d now doesnot set this reg
1004 rtl_write_byte(rtlpriv, REG_BCN_CTRL_1, 0);
1006 /* TBTT prohibit hold time. Suggested by designer TimChen. */
1007 rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 1, 0xff); /* 8 ms */
1009 rtl_write_byte(rtlpriv, REG_PIFS, 0);
1010 rtl_write_byte(rtlpriv, REG_AGGR_BREAK_TIME, 0x16);
1012 rtl_write_word(rtlpriv, REG_NAV_PROT_LEN, 0x0040);
1013 rtl_write_word(rtlpriv, REG_PROT_MODE_CTRL, 0x08ff);
1015 /* For Rx TP. Suggested by SD1 Richard. Added by tynli. 2010.04.12.*/
1016 rtl_write_dword(rtlpriv, REG_FAST_EDCA_CTRL, 0x03086666);
1018 /* ACKTO for IOT issue. */
1019 rtl_write_byte(rtlpriv, REG_ACKTO, 0x40);
1021 /* Set Spec SIFS (used in NAV) */
1022 rtl_write_word(rtlpriv, REG_SPEC_SIFS, 0x100a);
1023 rtl_write_word(rtlpriv, REG_MAC_SPEC_SIFS, 0x100a);
1025 /* Set SIFS for CCK */
1026 rtl_write_word(rtlpriv, REG_SIFS_CTX, 0x100a);
1028 /* Set SIFS for OFDM */
1029 rtl_write_word(rtlpriv, REG_SIFS_TRX, 0x100a);
1031 /* Note Data sheet don't define */
1032 rtl_write_word(rtlpriv, 0x4C7, 0x80);
1034 rtl_write_byte(rtlpriv, REG_RX_PKT_LIMIT, 0x20);
1036 rtl_write_word(rtlpriv, REG_MAX_AGGR_NUM, 0x1717);
1038 /* Set Multicast Address. 2009.01.07. by tynli. */
1039 rtl_write_dword(rtlpriv, REG_MAR, 0xffffffff);
1040 rtl_write_dword(rtlpriv, REG_MAR + 4, 0xffffffff);
1043 static void _rtl92ee_enable_aspm_back_door(struct ieee80211_hw *hw)
1045 struct rtl_priv *rtlpriv = rtl_priv(hw);
1046 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
1047 u32 tmp32 = 0, count = 0;
1050 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0x78);
1051 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x2);
1052 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1054 while (tmp8 && count < 20) {
1056 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1061 tmp32 = rtl_read_dword(rtlpriv, REG_BACKDOOR_DBI_RDATA);
1062 if ((tmp32 & 0xff00) != 0x2000) {
1063 tmp32 &= 0xffff00ff;
1064 rtl_write_dword(rtlpriv, REG_BACKDOOR_DBI_WDATA,
1066 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0xf078);
1067 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x1);
1069 tmp8 = rtl_read_byte(rtlpriv,
1070 REG_BACKDOOR_DBI_DATA + 2);
1072 while (tmp8 && count < 20) {
1074 tmp8 = rtl_read_byte(rtlpriv,
1075 REG_BACKDOOR_DBI_DATA + 2);
1081 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0x70c);
1082 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x2);
1083 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1085 while (tmp8 && count < 20) {
1087 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1091 tmp32 = rtl_read_dword(rtlpriv, REG_BACKDOOR_DBI_RDATA);
1092 rtl_write_dword(rtlpriv, REG_BACKDOOR_DBI_WDATA,
1094 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0xf70c);
1095 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x1);
1098 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1100 while (tmp8 && count < 20) {
1102 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1106 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0x718);
1107 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x2);
1108 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1110 while (tmp8 && count < 20) {
1112 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1115 if (ppsc->support_backdoor || (0 == tmp8)) {
1116 tmp32 = rtl_read_dword(rtlpriv, REG_BACKDOOR_DBI_RDATA);
1117 rtl_write_dword(rtlpriv, REG_BACKDOOR_DBI_WDATA,
1118 tmp32 | BIT(11) | BIT(12));
1119 rtl_write_word(rtlpriv, REG_BACKDOOR_DBI_DATA, 0xf718);
1120 rtl_write_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2, 0x1);
1122 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1124 while (tmp8 && count < 20) {
1126 tmp8 = rtl_read_byte(rtlpriv, REG_BACKDOOR_DBI_DATA + 2);
1131 void rtl92ee_enable_hw_security_config(struct ieee80211_hw *hw)
1133 struct rtl_priv *rtlpriv = rtl_priv(hw);
1137 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
1138 "PairwiseEncAlgorithm = %d GroupEncAlgorithm = %d\n",
1139 rtlpriv->sec.pairwise_enc_algorithm,
1140 rtlpriv->sec.group_enc_algorithm);
1142 if (rtlpriv->cfg->mod_params->sw_crypto || rtlpriv->sec.use_sw_sec) {
1143 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
1144 "not open hw encryption\n");
1148 sec_reg_value = SCR_TXENCENABLE | SCR_RXDECENABLE;
1150 if (rtlpriv->sec.use_defaultkey) {
1151 sec_reg_value |= SCR_TXUSEDK;
1152 sec_reg_value |= SCR_RXUSEDK;
1155 sec_reg_value |= (SCR_RXBCUSEDK | SCR_TXBCUSEDK);
1157 tmp = rtl_read_byte(rtlpriv, REG_CR + 1);
1158 rtl_write_byte(rtlpriv, REG_CR + 1, tmp | BIT(1));
1160 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
1161 "The SECR-value %x\n", sec_reg_value);
1163 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_WPA_CONFIG, &sec_reg_value);
1166 int rtl92ee_hw_init(struct ieee80211_hw *hw)
1168 struct rtl_priv *rtlpriv = rtl_priv(hw);
1169 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1170 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1171 struct rtl_phy *rtlphy = &rtlpriv->phy;
1172 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
1173 bool rtstatus = true;
1178 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, " Rtl8192EE hw init\n");
1179 rtlpriv->rtlhal.being_init_adapter = true;
1180 rtlpriv->intf_ops->disable_aspm(hw);
1182 tmp_u1b = rtl_read_byte(rtlpriv, REG_SYS_CLKR+1);
1183 u1byte = rtl_read_byte(rtlpriv, REG_CR);
1184 if ((tmp_u1b & BIT(3)) && (u1byte != 0 && u1byte != 0xEA)) {
1185 rtlhal->mac_func_enable = true;
1187 rtlhal->mac_func_enable = false;
1188 rtlhal->fw_ps_state = FW_PS_STATE_ALL_ON_92E;
1191 rtstatus = _rtl92ee_init_mac(hw);
1193 rtl_write_byte(rtlpriv, 0x577, 0x03);
1195 /*for Crystal 40 Mhz setting */
1196 rtl_write_byte(rtlpriv, REG_AFE_CTRL4, 0x2A);
1197 rtl_write_byte(rtlpriv, REG_AFE_CTRL4 + 1, 0x00);
1198 rtl_write_byte(rtlpriv, REG_AFE_CTRL2, 0x83);
1200 /*Forced the antenna b to wifi */
1201 if (rtlpriv->btcoexist.btc_info.btcoexist == 1) {
1202 rtl_write_byte(rtlpriv, 0x64, 0);
1203 rtl_write_byte(rtlpriv, 0x65, 1);
1206 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Init MAC failed\n");
1211 rtl_write_word(rtlpriv, REG_PCIE_CTRL_REG, 0x8000);
1212 err = rtl92ee_download_fw(hw, false);
1214 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1215 "Failed to download FW. Init HW without FW now..\n");
1217 rtlhal->fw_ready = false;
1220 rtlhal->fw_ready = true;
1221 /*fw related variable initialize */
1222 ppsc->fw_current_inpsmode = false;
1223 rtlhal->fw_ps_state = FW_PS_STATE_ALL_ON_92E;
1224 rtlhal->fw_clk_change_in_progress = false;
1225 rtlhal->allow_sw_to_change_hwclc = false;
1226 rtlhal->last_hmeboxnum = 0;
1228 rtl92ee_phy_mac_config(hw);
1230 rtl92ee_phy_bb_config(hw);
1232 rtl92ee_phy_rf_config(hw);
1234 rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, RF90_PATH_A,
1235 RF_CHNLBW, RFREG_OFFSET_MASK);
1236 rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, RF90_PATH_B,
1237 RF_CHNLBW, RFREG_OFFSET_MASK);
1238 rtlphy->backup_rf_0x1a = (u32)rtl_get_rfreg(hw, RF90_PATH_A, RF_RX_G1,
1240 rtlphy->rfreg_chnlval[0] = (rtlphy->rfreg_chnlval[0] & 0xfffff3ff) |
1243 rtl_set_rfreg(hw, RF90_PATH_A, RF_CHNLBW, RFREG_OFFSET_MASK,
1244 rtlphy->rfreg_chnlval[0]);
1245 rtl_set_rfreg(hw, RF90_PATH_B, RF_CHNLBW, RFREG_OFFSET_MASK,
1246 rtlphy->rfreg_chnlval[0]);
1248 /*---- Set CCK and OFDM Block "ON"----*/
1249 rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1);
1250 rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1);
1253 * otherwise the rx sensitivity will be very pool. Maddest
1255 rtl_set_rfreg(hw, RF90_PATH_A, 0xB1, RFREG_OFFSET_MASK, 0x54418);
1257 /*Set Hardware(MAC default setting.)*/
1258 _rtl92ee_hw_configure(hw);
1260 rtlhal->mac_func_enable = true;
1262 rtl_cam_reset_all_entry(hw);
1263 rtl92ee_enable_hw_security_config(hw);
1265 ppsc->rfpwr_state = ERFON;
1267 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ETHER_ADDR, mac->mac_addr);
1268 _rtl92ee_enable_aspm_back_door(hw);
1269 rtlpriv->intf_ops->enable_aspm(hw);
1271 rtl92ee_bt_hw_init(hw);
1273 rtlpriv->rtlhal.being_init_adapter = false;
1275 if (ppsc->rfpwr_state == ERFON) {
1276 if (rtlphy->iqk_initialized) {
1277 rtl92ee_phy_iq_calibrate(hw, true);
1279 rtl92ee_phy_iq_calibrate(hw, false);
1280 rtlphy->iqk_initialized = true;
1284 rtlphy->rfpath_rx_enable[0] = true;
1285 if (rtlphy->rf_type == RF_2T2R)
1286 rtlphy->rfpath_rx_enable[1] = true;
1288 efuse_one_byte_read(hw, 0x1FA, &tmp_u1b);
1289 if (!(tmp_u1b & BIT(0))) {
1290 rtl_set_rfreg(hw, RF90_PATH_A, 0x15, 0x0F, 0x05);
1291 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "PA BIAS path A\n");
1294 if ((!(tmp_u1b & BIT(1))) && (rtlphy->rf_type == RF_2T2R)) {
1295 rtl_set_rfreg(hw, RF90_PATH_B, 0x15, 0x0F, 0x05);
1296 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "PA BIAS path B\n");
1299 rtl_write_byte(rtlpriv, REG_NAV_UPPER, ((30000 + 127) / 128));
1301 /*Fixed LDPC rx hang issue. */
1302 tmp_u4b = rtl_read_dword(rtlpriv, REG_SYS_SWR_CTRL1);
1303 rtl_write_byte(rtlpriv, REG_SYS_SWR_CTRL2, 0x75);
1304 tmp_u4b = (tmp_u4b & 0xfff00fff) | (0x7E << 12);
1305 rtl_write_dword(rtlpriv, REG_SYS_SWR_CTRL1, tmp_u4b);
1307 rtl92ee_dm_init(hw);
1309 rtl_write_dword(rtlpriv, 0x4fc, 0);
1311 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1312 "end of Rtl8192EE hw init %x\n", err);
1316 static enum version_8192e _rtl92ee_read_chip_version(struct ieee80211_hw *hw)
1318 struct rtl_priv *rtlpriv = rtl_priv(hw);
1319 struct rtl_phy *rtlphy = &rtlpriv->phy;
1320 enum version_8192e version = VERSION_UNKNOWN;
1323 rtlphy->rf_type = RF_2T2R;
1325 value32 = rtl_read_dword(rtlpriv, REG_SYS_CFG1);
1326 if (value32 & TRP_VAUX_EN)
1327 version = (enum version_8192e)VERSION_TEST_CHIP_2T2R_8192E;
1329 version = (enum version_8192e)VERSION_NORMAL_CHIP_2T2R_8192E;
1331 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1332 "Chip RF Type: %s\n", (rtlphy->rf_type == RF_2T2R) ?
1333 "RF_2T2R" : "RF_1T1R");
1338 static int _rtl92ee_set_media_status(struct ieee80211_hw *hw,
1339 enum nl80211_iftype type)
1341 struct rtl_priv *rtlpriv = rtl_priv(hw);
1342 u8 bt_msr = rtl_read_byte(rtlpriv, MSR) & 0xfc;
1343 enum led_ctl_mode ledaction = LED_CTL_NO_LINK;
1344 u8 mode = MSR_NOLINK;
1347 case NL80211_IFTYPE_UNSPECIFIED:
1349 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
1350 "Set Network type to NO LINK!\n");
1352 case NL80211_IFTYPE_ADHOC:
1353 case NL80211_IFTYPE_MESH_POINT:
1355 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
1356 "Set Network type to Ad Hoc!\n");
1358 case NL80211_IFTYPE_STATION:
1360 ledaction = LED_CTL_LINK;
1361 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
1362 "Set Network type to STA!\n");
1364 case NL80211_IFTYPE_AP:
1366 ledaction = LED_CTL_LINK;
1367 RT_TRACE(rtlpriv, COMP_INIT, DBG_TRACE,
1368 "Set Network type to AP!\n");
1371 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1372 "Network type %d not support!\n", type);
1376 /* MSR_INFRA == Link in infrastructure network;
1377 * MSR_ADHOC == Link in ad hoc network;
1378 * Therefore, check link state is necessary.
1380 * MSR_AP == AP mode; link state is not cared here.
1382 if (mode != MSR_AP && rtlpriv->mac80211.link_state < MAC80211_LINKED) {
1384 ledaction = LED_CTL_NO_LINK;
1387 if (mode == MSR_NOLINK || mode == MSR_INFRA) {
1388 _rtl92ee_stop_tx_beacon(hw);
1389 _rtl92ee_enable_bcn_sub_func(hw);
1390 } else if (mode == MSR_ADHOC || mode == MSR_AP) {
1391 _rtl92ee_resume_tx_beacon(hw);
1392 _rtl92ee_disable_bcn_sub_func(hw);
1394 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
1395 "Set HW_VAR_MEDIA_STATUS: No such media status(%x).\n",
1399 rtl_write_byte(rtlpriv, (MSR), bt_msr | mode);
1400 rtlpriv->cfg->ops->led_control(hw, ledaction);
1402 rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x00);
1404 rtl_write_byte(rtlpriv, REG_BCNTCFG + 1, 0x66);
1408 void rtl92ee_set_check_bssid(struct ieee80211_hw *hw, bool check_bssid)
1410 struct rtl_priv *rtlpriv = rtl_priv(hw);
1411 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1412 u32 reg_rcr = rtlpci->receive_config;
1414 if (rtlpriv->psc.rfpwr_state != ERFON)
1418 reg_rcr |= (RCR_CBSSID_DATA | RCR_CBSSID_BCN);
1419 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_RCR,
1421 _rtl92ee_set_bcn_ctrl_reg(hw, 0, BIT(4));
1423 reg_rcr &= (~(RCR_CBSSID_DATA | RCR_CBSSID_BCN));
1424 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(4), 0);
1425 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_RCR,
1430 int rtl92ee_set_network_type(struct ieee80211_hw *hw, enum nl80211_iftype type)
1432 struct rtl_priv *rtlpriv = rtl_priv(hw);
1434 if (_rtl92ee_set_media_status(hw, type))
1437 if (rtlpriv->mac80211.link_state == MAC80211_LINKED) {
1438 if (type != NL80211_IFTYPE_AP &&
1439 type != NL80211_IFTYPE_MESH_POINT)
1440 rtl92ee_set_check_bssid(hw, true);
1442 rtl92ee_set_check_bssid(hw, false);
1448 /* don't set REG_EDCA_BE_PARAM here because mac80211 will send pkt when scan */
1449 void rtl92ee_set_qos(struct ieee80211_hw *hw, int aci)
1451 struct rtl_priv *rtlpriv = rtl_priv(hw);
1453 rtl92ee_dm_init_edca_turbo(hw);
1456 rtl_write_dword(rtlpriv, REG_EDCA_BK_PARAM, 0xa44f);
1459 /* rtl_write_dword(rtlpriv, REG_EDCA_BE_PARAM, u4b_ac_param); */
1462 rtl_write_dword(rtlpriv, REG_EDCA_VI_PARAM, 0x5e4322);
1465 rtl_write_dword(rtlpriv, REG_EDCA_VO_PARAM, 0x2f3222);
1468 RT_ASSERT(false, "invalid aci: %d !\n", aci);
1473 static void rtl92ee_clear_interrupt(struct ieee80211_hw *hw)
1475 struct rtl_priv *rtlpriv = rtl_priv(hw);
1478 tmp = rtl_read_dword(rtlpriv, REG_HISR);
1479 rtl_write_dword(rtlpriv, REG_HISR, tmp);
1481 tmp = rtl_read_dword(rtlpriv, REG_HISRE);
1482 rtl_write_dword(rtlpriv, REG_HISRE, tmp);
1484 tmp = rtl_read_dword(rtlpriv, REG_HSISR);
1485 rtl_write_dword(rtlpriv, REG_HSISR, tmp);
1488 void rtl92ee_enable_interrupt(struct ieee80211_hw *hw)
1490 struct rtl_priv *rtlpriv = rtl_priv(hw);
1491 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1493 rtl92ee_clear_interrupt(hw);/*clear it here first*/
1495 rtl_write_dword(rtlpriv, REG_HIMR, rtlpci->irq_mask[0] & 0xFFFFFFFF);
1496 rtl_write_dword(rtlpriv, REG_HIMRE, rtlpci->irq_mask[1] & 0xFFFFFFFF);
1497 rtlpci->irq_enabled = true;
1500 void rtl92ee_disable_interrupt(struct ieee80211_hw *hw)
1502 struct rtl_priv *rtlpriv = rtl_priv(hw);
1503 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1505 rtl_write_dword(rtlpriv, REG_HIMR, IMR_DISABLED);
1506 rtl_write_dword(rtlpriv, REG_HIMRE, IMR_DISABLED);
1507 rtlpci->irq_enabled = false;
1508 /*synchronize_irq(rtlpci->pdev->irq);*/
1511 static void _rtl92ee_poweroff_adapter(struct ieee80211_hw *hw)
1513 struct rtl_priv *rtlpriv = rtl_priv(hw);
1514 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
1517 rtlhal->mac_func_enable = false;
1519 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "POWER OFF adapter\n");
1521 /* Run LPS WL RFOFF flow */
1522 rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
1523 PWR_INTF_PCI_MSK, RTL8192E_NIC_LPS_ENTER_FLOW);
1525 rtl_write_byte(rtlpriv, REG_RF_CTRL, 0x00);
1527 /* ==== Reset digital sequence ====== */
1528 if ((rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) && rtlhal->fw_ready)
1529 rtl92ee_firmware_selfreset(hw);
1532 u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
1533 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, (u1b_tmp & (~BIT(2))));
1535 /* reset MCU ready status */
1536 rtl_write_byte(rtlpriv, REG_MCUFWDL, 0x00);
1538 /* HW card disable configuration. */
1539 rtl_hal_pwrseqcmdparsing(rtlpriv, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK,
1540 PWR_INTF_PCI_MSK, RTL8192E_NIC_DISABLE_FLOW);
1542 /* Reset MCU IO Wrapper */
1543 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
1544 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp & (~BIT(0))));
1545 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
1546 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp | BIT(0)));
1548 /* lock ISO/CLK/Power control register */
1549 rtl_write_byte(rtlpriv, REG_RSV_CTRL, 0x0E);
1552 void rtl92ee_card_disable(struct ieee80211_hw *hw)
1554 struct rtl_priv *rtlpriv = rtl_priv(hw);
1555 struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
1556 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1557 enum nl80211_iftype opmode;
1559 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "RTL8192ee card disable\n");
1561 RT_SET_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC);
1563 mac->link_state = MAC80211_NOLINK;
1564 opmode = NL80211_IFTYPE_UNSPECIFIED;
1566 _rtl92ee_set_media_status(hw, opmode);
1568 if (rtlpriv->rtlhal.driver_is_goingto_unload ||
1569 ppsc->rfoff_reason > RF_CHANGE_BY_PS)
1570 rtlpriv->cfg->ops->led_control(hw, LED_CTL_POWER_OFF);
1572 _rtl92ee_poweroff_adapter(hw);
1574 /* after power off we should do iqk again */
1575 rtlpriv->phy.iqk_initialized = false;
1578 void rtl92ee_interrupt_recognized(struct ieee80211_hw *hw,
1579 u32 *p_inta, u32 *p_intb)
1581 struct rtl_priv *rtlpriv = rtl_priv(hw);
1582 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1584 *p_inta = rtl_read_dword(rtlpriv, ISR) & rtlpci->irq_mask[0];
1585 rtl_write_dword(rtlpriv, ISR, *p_inta);
1587 *p_intb = rtl_read_dword(rtlpriv, REG_HISRE) & rtlpci->irq_mask[1];
1588 rtl_write_dword(rtlpriv, REG_HISRE, *p_intb);
1591 void rtl92ee_set_beacon_related_registers(struct ieee80211_hw *hw)
1593 struct rtl_priv *rtlpriv = rtl_priv(hw);
1594 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1595 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1596 u16 bcn_interval, atim_window;
1598 bcn_interval = mac->beacon_interval;
1599 atim_window = 2; /*FIX MERGE */
1600 rtl92ee_disable_interrupt(hw);
1601 rtl_write_word(rtlpriv, REG_ATIMWND, atim_window);
1602 rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval);
1603 rtl_write_word(rtlpriv, REG_BCNTCFG, 0x660f);
1604 rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_CCK, 0x18);
1605 rtl_write_byte(rtlpriv, REG_RXTSF_OFFSET_OFDM, 0x18);
1606 rtl_write_byte(rtlpriv, 0x606, 0x30);
1607 rtlpci->reg_bcn_ctrl_val |= BIT(3);
1608 rtl_write_byte(rtlpriv, REG_BCN_CTRL, (u8)rtlpci->reg_bcn_ctrl_val);
1611 void rtl92ee_set_beacon_interval(struct ieee80211_hw *hw)
1613 struct rtl_priv *rtlpriv = rtl_priv(hw);
1614 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
1615 u16 bcn_interval = mac->beacon_interval;
1617 RT_TRACE(rtlpriv, COMP_BEACON, DBG_DMESG,
1618 "beacon_interval:%d\n", bcn_interval);
1619 rtl_write_word(rtlpriv, REG_BCN_INTERVAL, bcn_interval);
1622 void rtl92ee_update_interrupt_mask(struct ieee80211_hw *hw,
1623 u32 add_msr, u32 rm_msr)
1625 struct rtl_priv *rtlpriv = rtl_priv(hw);
1626 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
1628 RT_TRACE(rtlpriv, COMP_INTR, DBG_LOUD,
1629 "add_msr:%x, rm_msr:%x\n", add_msr, rm_msr);
1632 rtlpci->irq_mask[0] |= add_msr;
1634 rtlpci->irq_mask[0] &= (~rm_msr);
1635 rtl92ee_disable_interrupt(hw);
1636 rtl92ee_enable_interrupt(hw);
1639 static u8 _rtl92ee_get_chnl_group(u8 chnl)
1644 if (1 <= chnl && chnl <= 2)
1646 else if (3 <= chnl && chnl <= 5)
1648 else if (6 <= chnl && chnl <= 8)
1650 else if (9 <= chnl && chnl <= 11)
1652 else if (12 <= chnl && chnl <= 14)
1655 if (36 <= chnl && chnl <= 42)
1657 else if (44 <= chnl && chnl <= 48)
1659 else if (50 <= chnl && chnl <= 58)
1661 else if (60 <= chnl && chnl <= 64)
1663 else if (100 <= chnl && chnl <= 106)
1665 else if (108 <= chnl && chnl <= 114)
1667 else if (116 <= chnl && chnl <= 122)
1669 else if (124 <= chnl && chnl <= 130)
1671 else if (132 <= chnl && chnl <= 138)
1673 else if (140 <= chnl && chnl <= 144)
1675 else if (149 <= chnl && chnl <= 155)
1677 else if (157 <= chnl && chnl <= 161)
1679 else if (165 <= chnl && chnl <= 171)
1681 else if (173 <= chnl && chnl <= 177)
1687 static void _rtl8192ee_read_power_value_fromprom(struct ieee80211_hw *hw,
1688 struct txpower_info_2g *pwr2g,
1689 struct txpower_info_5g *pwr5g,
1690 bool autoload_fail, u8 *hwinfo)
1692 struct rtl_priv *rtlpriv = rtl_priv(hw);
1693 u32 rf, addr = EEPROM_TX_PWR_INX, group, i = 0;
1695 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1696 "hal_ReadPowerValueFromPROM92E(): PROMContent[0x%x]=0x%x\n",
1697 (addr + 1), hwinfo[addr + 1]);
1698 if (0xFF == hwinfo[addr+1]) /*YJ,add,120316*/
1699 autoload_fail = true;
1701 if (autoload_fail) {
1702 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
1703 "auto load fail : Use Default value!\n");
1704 for (rf = 0 ; rf < MAX_RF_PATH ; rf++) {
1705 /* 2.4G default value */
1706 for (group = 0 ; group < MAX_CHNL_GROUP_24G; group++) {
1707 pwr2g->index_cck_base[rf][group] = 0x2D;
1708 pwr2g->index_bw40_base[rf][group] = 0x2D;
1710 for (i = 0; i < MAX_TX_COUNT; i++) {
1712 pwr2g->bw20_diff[rf][0] = 0x02;
1713 pwr2g->ofdm_diff[rf][0] = 0x04;
1715 pwr2g->bw20_diff[rf][i] = 0xFE;
1716 pwr2g->bw40_diff[rf][i] = 0xFE;
1717 pwr2g->cck_diff[rf][i] = 0xFE;
1718 pwr2g->ofdm_diff[rf][i] = 0xFE;
1722 /*5G default value*/
1723 for (group = 0 ; group < MAX_CHNL_GROUP_5G; group++)
1724 pwr5g->index_bw40_base[rf][group] = 0x2A;
1726 for (i = 0; i < MAX_TX_COUNT; i++) {
1728 pwr5g->ofdm_diff[rf][0] = 0x04;
1729 pwr5g->bw20_diff[rf][0] = 0x00;
1730 pwr5g->bw80_diff[rf][0] = 0xFE;
1731 pwr5g->bw160_diff[rf][0] = 0xFE;
1733 pwr5g->ofdm_diff[rf][0] = 0xFE;
1734 pwr5g->bw20_diff[rf][0] = 0xFE;
1735 pwr5g->bw40_diff[rf][0] = 0xFE;
1736 pwr5g->bw80_diff[rf][0] = 0xFE;
1737 pwr5g->bw160_diff[rf][0] = 0xFE;
1744 rtl_priv(hw)->efuse.txpwr_fromeprom = true;
1746 for (rf = 0 ; rf < MAX_RF_PATH ; rf++) {
1747 /*2.4G default value*/
1748 for (group = 0 ; group < MAX_CHNL_GROUP_24G; group++) {
1749 pwr2g->index_cck_base[rf][group] = hwinfo[addr++];
1750 if (pwr2g->index_cck_base[rf][group] == 0xFF)
1751 pwr2g->index_cck_base[rf][group] = 0x2D;
1753 for (group = 0 ; group < MAX_CHNL_GROUP_24G - 1; group++) {
1754 pwr2g->index_bw40_base[rf][group] = hwinfo[addr++];
1755 if (pwr2g->index_bw40_base[rf][group] == 0xFF)
1756 pwr2g->index_bw40_base[rf][group] = 0x2D;
1758 for (i = 0; i < MAX_TX_COUNT; i++) {
1760 pwr2g->bw40_diff[rf][i] = 0;
1761 if (hwinfo[addr] == 0xFF) {
1762 pwr2g->bw20_diff[rf][i] = 0x02;
1764 pwr2g->bw20_diff[rf][i] = (hwinfo[addr]
1766 if (pwr2g->bw20_diff[rf][i] & BIT(3))
1767 pwr2g->bw20_diff[rf][i] |= 0xF0;
1770 if (hwinfo[addr] == 0xFF) {
1771 pwr2g->ofdm_diff[rf][i] = 0x04;
1773 pwr2g->ofdm_diff[rf][i] = (hwinfo[addr]
1775 if (pwr2g->ofdm_diff[rf][i] & BIT(3))
1776 pwr2g->ofdm_diff[rf][i] |= 0xF0;
1778 pwr2g->cck_diff[rf][i] = 0;
1781 if (hwinfo[addr] == 0xFF) {
1782 pwr2g->bw40_diff[rf][i] = 0xFE;
1784 pwr2g->bw40_diff[rf][i] = (hwinfo[addr]
1786 if (pwr2g->bw40_diff[rf][i] & BIT(3))
1787 pwr2g->bw40_diff[rf][i] |= 0xF0;
1790 if (hwinfo[addr] == 0xFF) {
1791 pwr2g->bw20_diff[rf][i] = 0xFE;
1793 pwr2g->bw20_diff[rf][i] = (hwinfo[addr]
1795 if (pwr2g->bw20_diff[rf][i] & BIT(3))
1796 pwr2g->bw20_diff[rf][i] |= 0xF0;
1800 if (hwinfo[addr] == 0xFF) {
1801 pwr2g->ofdm_diff[rf][i] = 0xFE;
1803 pwr2g->ofdm_diff[rf][i] = (hwinfo[addr]
1805 if (pwr2g->ofdm_diff[rf][i] & BIT(3))
1806 pwr2g->ofdm_diff[rf][i] |= 0xF0;
1809 if (hwinfo[addr] == 0xFF) {
1810 pwr2g->cck_diff[rf][i] = 0xFE;
1812 pwr2g->cck_diff[rf][i] = (hwinfo[addr]
1814 if (pwr2g->cck_diff[rf][i] & BIT(3))
1815 pwr2g->cck_diff[rf][i] |= 0xF0;
1821 /*5G default value*/
1822 for (group = 0 ; group < MAX_CHNL_GROUP_5G; group++) {
1823 pwr5g->index_bw40_base[rf][group] = hwinfo[addr++];
1824 if (pwr5g->index_bw40_base[rf][group] == 0xFF)
1825 pwr5g->index_bw40_base[rf][group] = 0xFE;
1828 for (i = 0; i < MAX_TX_COUNT; i++) {
1830 pwr5g->bw40_diff[rf][i] = 0;
1832 if (hwinfo[addr] == 0xFF) {
1833 pwr5g->bw20_diff[rf][i] = 0;
1835 pwr5g->bw20_diff[rf][0] = (hwinfo[addr]
1837 if (pwr5g->bw20_diff[rf][i] & BIT(3))
1838 pwr5g->bw20_diff[rf][i] |= 0xF0;
1841 if (hwinfo[addr] == 0xFF) {
1842 pwr5g->ofdm_diff[rf][i] = 0x04;
1844 pwr5g->ofdm_diff[rf][0] = (hwinfo[addr]
1846 if (pwr5g->ofdm_diff[rf][i] & BIT(3))
1847 pwr5g->ofdm_diff[rf][i] |= 0xF0;
1851 if (hwinfo[addr] == 0xFF) {
1852 pwr5g->bw40_diff[rf][i] = 0xFE;
1854 pwr5g->bw40_diff[rf][i] = (hwinfo[addr]
1856 if (pwr5g->bw40_diff[rf][i] & BIT(3))
1857 pwr5g->bw40_diff[rf][i] |= 0xF0;
1860 if (hwinfo[addr] == 0xFF) {
1861 pwr5g->bw20_diff[rf][i] = 0xFE;
1863 pwr5g->bw20_diff[rf][i] = (hwinfo[addr]
1865 if (pwr5g->bw20_diff[rf][i] & BIT(3))
1866 pwr5g->bw20_diff[rf][i] |= 0xF0;
1872 if (hwinfo[addr] == 0xFF) {
1873 pwr5g->ofdm_diff[rf][1] = 0xFE;
1874 pwr5g->ofdm_diff[rf][2] = 0xFE;
1876 pwr5g->ofdm_diff[rf][1] = (hwinfo[addr] & 0xf0) >> 4;
1877 pwr5g->ofdm_diff[rf][2] = (hwinfo[addr] & 0x0f);
1881 if (hwinfo[addr] == 0xFF)
1882 pwr5g->ofdm_diff[rf][3] = 0xFE;
1884 pwr5g->ofdm_diff[rf][3] = (hwinfo[addr] & 0x0f);
1887 for (i = 1; i < MAX_TX_COUNT; i++) {
1888 if (pwr5g->ofdm_diff[rf][i] == 0xFF)
1889 pwr5g->ofdm_diff[rf][i] = 0xFE;
1890 else if (pwr5g->ofdm_diff[rf][i] & BIT(3))
1891 pwr5g->ofdm_diff[rf][i] |= 0xF0;
1894 for (i = 0; i < MAX_TX_COUNT; i++) {
1895 if (hwinfo[addr] == 0xFF) {
1896 pwr5g->bw80_diff[rf][i] = 0xFE;
1898 pwr5g->bw80_diff[rf][i] = (hwinfo[addr] & 0xf0)
1900 if (pwr5g->bw80_diff[rf][i] & BIT(3))
1901 pwr5g->bw80_diff[rf][i] |= 0xF0;
1904 if (hwinfo[addr] == 0xFF) {
1905 pwr5g->bw160_diff[rf][i] = 0xFE;
1907 pwr5g->bw160_diff[rf][i] =
1908 (hwinfo[addr] & 0x0f);
1909 if (pwr5g->bw160_diff[rf][i] & BIT(3))
1910 pwr5g->bw160_diff[rf][i] |= 0xF0;
1917 static void _rtl92ee_read_txpower_info_from_hwpg(struct ieee80211_hw *hw,
1918 bool autoload_fail, u8 *hwinfo)
1920 struct rtl_priv *rtlpriv = rtl_priv(hw);
1921 struct rtl_efuse *efu = rtl_efuse(rtl_priv(hw));
1922 struct txpower_info_2g pwr2g;
1923 struct txpower_info_5g pwr5g;
1924 u8 channel5g[CHANNEL_MAX_NUMBER_5G] = {
1925 36, 38, 40, 42, 44, 46, 48, 50, 52, 54,
1926 56, 58, 60, 62, 64, 100, 102, 104, 106,
1927 108, 110, 112, 114, 116, 118, 120, 122,
1928 124, 126, 128, 130, 132, 134, 136, 138,
1929 140, 142, 144, 149, 151, 153, 155, 157,
1930 159, 161, 163, 165, 167, 168, 169, 171,
1933 u8 channel5g_80m[CHANNEL_MAX_NUMBER_5G_80M] = {
1934 42, 58, 106, 122, 138, 155, 171
1939 _rtl8192ee_read_power_value_fromprom(hw, &pwr2g, &pwr5g,
1940 autoload_fail, hwinfo);
1942 for (rf = 0; rf < MAX_RF_PATH; rf++) {
1943 for (i = 0; i < 14; i++) {
1944 idx = _rtl92ee_get_chnl_group(i + 1);
1946 if (i == CHANNEL_MAX_NUMBER_2G - 1) {
1947 efu->txpwrlevel_cck[rf][i] =
1948 pwr2g.index_cck_base[rf][5];
1949 efu->txpwrlevel_ht40_1s[rf][i] =
1950 pwr2g.index_bw40_base[rf][idx];
1952 efu->txpwrlevel_cck[rf][i] =
1953 pwr2g.index_cck_base[rf][idx];
1954 efu->txpwrlevel_ht40_1s[rf][i] =
1955 pwr2g.index_bw40_base[rf][idx];
1958 for (i = 0; i < CHANNEL_MAX_NUMBER_5G; i++) {
1959 idx = _rtl92ee_get_chnl_group(channel5g[i]);
1960 efu->txpwr_5g_bw40base[rf][i] =
1961 pwr5g.index_bw40_base[rf][idx];
1963 for (i = 0; i < CHANNEL_MAX_NUMBER_5G_80M; i++) {
1966 idx = _rtl92ee_get_chnl_group(channel5g_80m[i]);
1967 upper = pwr5g.index_bw40_base[rf][idx];
1968 lower = pwr5g.index_bw40_base[rf][idx + 1];
1970 efu->txpwr_5g_bw80base[rf][i] = (upper + lower) / 2;
1972 for (i = 0; i < MAX_TX_COUNT; i++) {
1973 efu->txpwr_cckdiff[rf][i] = pwr2g.cck_diff[rf][i];
1974 efu->txpwr_legacyhtdiff[rf][i] = pwr2g.ofdm_diff[rf][i];
1975 efu->txpwr_ht20diff[rf][i] = pwr2g.bw20_diff[rf][i];
1976 efu->txpwr_ht40diff[rf][i] = pwr2g.bw40_diff[rf][i];
1978 efu->txpwr_5g_ofdmdiff[rf][i] = pwr5g.ofdm_diff[rf][i];
1979 efu->txpwr_5g_bw20diff[rf][i] = pwr5g.bw20_diff[rf][i];
1980 efu->txpwr_5g_bw40diff[rf][i] = pwr5g.bw40_diff[rf][i];
1981 efu->txpwr_5g_bw80diff[rf][i] = pwr5g.bw80_diff[rf][i];
1986 efu->eeprom_thermalmeter = hwinfo[EEPROM_THERMAL_METER_92E];
1988 efu->eeprom_thermalmeter = EEPROM_DEFAULT_THERMALMETER;
1990 if (efu->eeprom_thermalmeter == 0xff || autoload_fail) {
1991 efu->apk_thermalmeterignore = true;
1992 efu->eeprom_thermalmeter = EEPROM_DEFAULT_THERMALMETER;
1995 efu->thermalmeter[0] = efu->eeprom_thermalmeter;
1996 RTPRINT(rtlpriv, FINIT, INIT_TXPOWER,
1997 "thermalmeter = 0x%x\n", efu->eeprom_thermalmeter);
1999 if (!autoload_fail) {
2000 efu->eeprom_regulatory = hwinfo[EEPROM_RF_BOARD_OPTION_92E]
2002 if (hwinfo[EEPROM_RF_BOARD_OPTION_92E] == 0xFF)
2003 efu->eeprom_regulatory = 0;
2005 efu->eeprom_regulatory = 0;
2007 RTPRINT(rtlpriv, FINIT, INIT_TXPOWER,
2008 "eeprom_regulatory = 0x%x\n", efu->eeprom_regulatory);
2011 static void _rtl92ee_read_adapter_info(struct ieee80211_hw *hw)
2013 struct rtl_priv *rtlpriv = rtl_priv(hw);
2014 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
2015 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
2017 u8 hwinfo[HWSET_MAX_SIZE];
2020 if (rtlefuse->epromtype == EEPROM_BOOT_EFUSE) {
2021 rtl_efuse_shadow_map_update(hw);
2023 memcpy(hwinfo, &rtlefuse->efuse_map[EFUSE_INIT_MAP][0],
2025 } else if (rtlefuse->epromtype == EEPROM_93C46) {
2026 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
2027 "RTL819X Not boot from eeprom, check it !!");
2030 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
2031 "boot from neither eeprom nor efuse, check it !!");
2035 RT_PRINT_DATA(rtlpriv, COMP_INIT, DBG_DMESG, "MAP\n",
2036 hwinfo, HWSET_MAX_SIZE);
2038 eeprom_id = *((u16 *)&hwinfo[0]);
2039 if (eeprom_id != RTL8192E_EEPROM_ID) {
2040 RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
2041 "EEPROM ID(%#x) is invalid!!\n", eeprom_id);
2042 rtlefuse->autoload_failflag = true;
2044 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
2045 rtlefuse->autoload_failflag = false;
2048 if (rtlefuse->autoload_failflag)
2050 /*VID DID SVID SDID*/
2051 rtlefuse->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID];
2052 rtlefuse->eeprom_did = *(u16 *)&hwinfo[EEPROM_DID];
2053 rtlefuse->eeprom_svid = *(u16 *)&hwinfo[EEPROM_SVID];
2054 rtlefuse->eeprom_smid = *(u16 *)&hwinfo[EEPROM_SMID];
2055 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "EEPROMId = 0x%4x\n", eeprom_id);
2056 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
2057 "EEPROM VID = 0x%4x\n", rtlefuse->eeprom_vid);
2058 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
2059 "EEPROM DID = 0x%4x\n", rtlefuse->eeprom_did);
2060 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
2061 "EEPROM SVID = 0x%4x\n", rtlefuse->eeprom_svid);
2062 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
2063 "EEPROM SMID = 0x%4x\n", rtlefuse->eeprom_smid);
2065 rtlefuse->eeprom_oemid = *(u8 *)&hwinfo[EEPROM_CUSTOMER_ID];
2066 if (rtlefuse->eeprom_oemid == 0xFF)
2067 rtlefuse->eeprom_oemid = 0;
2069 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
2070 "EEPROM Customer ID: 0x%2x\n", rtlefuse->eeprom_oemid);
2072 rtlefuse->eeprom_version = *(u8 *)&hwinfo[EEPROM_VERSION];
2074 for (i = 0; i < 6; i += 2) {
2075 usvalue = *(u16 *)&hwinfo[EEPROM_MAC_ADDR + i];
2076 *((u16 *)(&rtlefuse->dev_addr[i])) = usvalue;
2079 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2080 "dev_addr: %pM\n", rtlefuse->dev_addr);
2082 rtlefuse->eeprom_channelplan = *(u8 *)&hwinfo[EEPROM_CHANNELPLAN];
2083 /* set channel paln to world wide 13 */
2084 rtlefuse->channel_plan = COUNTRY_CODE_WORLD_WIDE_13;
2086 _rtl92ee_read_txpower_info_from_hwpg(hw, rtlefuse->autoload_failflag,
2089 rtl92ee_read_bt_coexist_info_from_hwpg(hw, rtlefuse->autoload_failflag,
2093 rtlefuse->board_type = (((*(u8 *)&hwinfo[EEPROM_RF_BOARD_OPTION_92E])
2095 if ((*(u8 *)&hwinfo[EEPROM_RF_BOARD_OPTION_92E]) == 0xFF)
2096 rtlefuse->board_type = 0;
2098 rtlhal->board_type = rtlefuse->board_type;
2100 rtlefuse->crystalcap = hwinfo[EEPROM_XTAL_92E];
2101 if (hwinfo[EEPROM_XTAL_92E] == 0xFF)
2102 rtlefuse->crystalcap = 0x20;
2104 /*antenna diversity*/
2105 rtlefuse->antenna_div_type = NO_ANTDIV;
2106 rtlefuse->antenna_div_cfg = 0;
2108 if (rtlhal->oem_id == RT_CID_DEFAULT) {
2109 switch (rtlefuse->eeprom_oemid) {
2110 case EEPROM_CID_DEFAULT:
2111 if (rtlefuse->eeprom_did == 0x818B) {
2112 if ((rtlefuse->eeprom_svid == 0x10EC) &&
2113 (rtlefuse->eeprom_smid == 0x001B))
2114 rtlhal->oem_id = RT_CID_819X_LENOVO;
2116 rtlhal->oem_id = RT_CID_DEFAULT;
2120 rtlhal->oem_id = RT_CID_DEFAULT;
2126 static void _rtl92ee_hal_customized_behavior(struct ieee80211_hw *hw)
2128 struct rtl_priv *rtlpriv = rtl_priv(hw);
2129 struct rtl_pci_priv *pcipriv = rtl_pcipriv(hw);
2130 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
2132 pcipriv->ledctl.led_opendrain = true;
2134 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
2135 "RT Customized ID: 0x%02X\n", rtlhal->oem_id);
2138 void rtl92ee_read_eeprom_info(struct ieee80211_hw *hw)
2140 struct rtl_priv *rtlpriv = rtl_priv(hw);
2141 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
2142 struct rtl_phy *rtlphy = &rtlpriv->phy;
2143 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
2146 rtlhal->version = _rtl92ee_read_chip_version(hw);
2147 if (get_rf_type(rtlphy) == RF_1T1R) {
2148 rtlpriv->dm.rfpath_rxenable[0] = true;
2150 rtlpriv->dm.rfpath_rxenable[0] = true;
2151 rtlpriv->dm.rfpath_rxenable[1] = true;
2153 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "VersionID = 0x%4x\n",
2155 tmp_u1b = rtl_read_byte(rtlpriv, REG_9346CR);
2156 if (tmp_u1b & BIT(4)) {
2157 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EEPROM\n");
2158 rtlefuse->epromtype = EEPROM_93C46;
2160 RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, "Boot from EFUSE\n");
2161 rtlefuse->epromtype = EEPROM_BOOT_EFUSE;
2163 if (tmp_u1b & BIT(5)) {
2164 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
2165 rtlefuse->autoload_failflag = false;
2166 _rtl92ee_read_adapter_info(hw);
2168 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG, "Autoload ERR!!\n");
2170 _rtl92ee_hal_customized_behavior(hw);
2172 rtlphy->rfpath_rx_enable[0] = true;
2173 if (rtlphy->rf_type == RF_2T2R)
2174 rtlphy->rfpath_rx_enable[1] = true;
2177 static u8 _rtl92ee_mrate_idx_to_arfr_id(struct ieee80211_hw *hw, u8 rate_index)
2181 switch (rate_index) {
2182 case RATR_INX_WIRELESS_NGB:
2185 case RATR_INX_WIRELESS_N:
2186 case RATR_INX_WIRELESS_NG:
2189 case RATR_INX_WIRELESS_NB:
2192 case RATR_INX_WIRELESS_GB:
2195 case RATR_INX_WIRELESS_G:
2198 case RATR_INX_WIRELESS_B:
2208 static void rtl92ee_update_hal_rate_mask(struct ieee80211_hw *hw,
2209 struct ieee80211_sta *sta,
2212 struct rtl_priv *rtlpriv = rtl_priv(hw);
2213 struct rtl_phy *rtlphy = &rtlpriv->phy;
2214 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
2215 struct rtl_sta_info *sta_entry = NULL;
2218 u8 curtxbw_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)
2220 u8 b_curshortgi_40mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40) ?
2222 u8 b_curshortgi_20mhz = (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ?
2224 enum wireless_mode wirelessmode = 0;
2225 bool b_shortgi = false;
2226 u8 rate_mask[7] = {0};
2228 /*u8 mimo_ps = IEEE80211_SMPS_OFF;*/
2229 sta_entry = (struct rtl_sta_info *)sta->drv_priv;
2230 wirelessmode = sta_entry->wireless_mode;
2231 if (mac->opmode == NL80211_IFTYPE_STATION ||
2232 mac->opmode == NL80211_IFTYPE_MESH_POINT)
2233 curtxbw_40mhz = mac->bw_40;
2234 else if (mac->opmode == NL80211_IFTYPE_AP ||
2235 mac->opmode == NL80211_IFTYPE_ADHOC)
2236 macid = sta->aid + 1;
2238 ratr_bitmap = sta->supp_rates[0];
2239 if (mac->opmode == NL80211_IFTYPE_ADHOC)
2240 ratr_bitmap = 0xfff;
2242 ratr_bitmap |= (sta->ht_cap.mcs.rx_mask[1] << 20 |
2243 sta->ht_cap.mcs.rx_mask[0] << 12);
2245 switch (wirelessmode) {
2246 case WIRELESS_MODE_B:
2247 ratr_index = RATR_INX_WIRELESS_B;
2248 if (ratr_bitmap & 0x0000000c)
2249 ratr_bitmap &= 0x0000000d;
2251 ratr_bitmap &= 0x0000000f;
2253 case WIRELESS_MODE_G:
2254 ratr_index = RATR_INX_WIRELESS_GB;
2256 if (rssi_level == 1)
2257 ratr_bitmap &= 0x00000f00;
2258 else if (rssi_level == 2)
2259 ratr_bitmap &= 0x00000ff0;
2261 ratr_bitmap &= 0x00000ff5;
2263 case WIRELESS_MODE_N_24G:
2265 ratr_index = RATR_INX_WIRELESS_NGB;
2267 ratr_index = RATR_INX_WIRELESS_NB;
2269 if (rtlphy->rf_type == RF_1T1R) {
2270 if (curtxbw_40mhz) {
2271 if (rssi_level == 1)
2272 ratr_bitmap &= 0x000f0000;
2273 else if (rssi_level == 2)
2274 ratr_bitmap &= 0x000ff000;
2276 ratr_bitmap &= 0x000ff015;
2278 if (rssi_level == 1)
2279 ratr_bitmap &= 0x000f0000;
2280 else if (rssi_level == 2)
2281 ratr_bitmap &= 0x000ff000;
2283 ratr_bitmap &= 0x000ff005;
2286 if (curtxbw_40mhz) {
2287 if (rssi_level == 1)
2288 ratr_bitmap &= 0x0f8f0000;
2289 else if (rssi_level == 2)
2290 ratr_bitmap &= 0x0ffff000;
2292 ratr_bitmap &= 0x0ffff015;
2294 if (rssi_level == 1)
2295 ratr_bitmap &= 0x0f8f0000;
2296 else if (rssi_level == 2)
2297 ratr_bitmap &= 0x0ffff000;
2299 ratr_bitmap &= 0x0ffff005;
2303 if ((curtxbw_40mhz && b_curshortgi_40mhz) ||
2304 (!curtxbw_40mhz && b_curshortgi_20mhz)) {
2307 else if (macid == 1)
2312 ratr_index = RATR_INX_WIRELESS_NGB;
2314 if (rtlphy->rf_type == RF_1T1R)
2315 ratr_bitmap &= 0x000ff0ff;
2317 ratr_bitmap &= 0x0f8ff0ff;
2320 ratr_index = _rtl92ee_mrate_idx_to_arfr_id(hw, ratr_index);
2321 sta_entry->ratr_index = ratr_index;
2323 RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
2324 "ratr_bitmap :%x\n", ratr_bitmap);
2325 *(u32 *)&rate_mask = (ratr_bitmap & 0x0fffffff) |
2327 rate_mask[0] = macid;
2328 rate_mask[1] = ratr_index | (b_shortgi ? 0x80 : 0x00);
2329 rate_mask[2] = curtxbw_40mhz;
2330 rate_mask[3] = (u8)(ratr_bitmap & 0x000000ff);
2331 rate_mask[4] = (u8)((ratr_bitmap & 0x0000ff00) >> 8);
2332 rate_mask[5] = (u8)((ratr_bitmap & 0x00ff0000) >> 16);
2333 rate_mask[6] = (u8)((ratr_bitmap & 0xff000000) >> 24);
2334 RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
2335 "Rate_index:%x, ratr_val:%x, %x:%x:%x:%x:%x:%x:%x\n",
2336 ratr_index, ratr_bitmap, rate_mask[0], rate_mask[1],
2337 rate_mask[2], rate_mask[3], rate_mask[4],
2338 rate_mask[5], rate_mask[6]);
2339 rtl92ee_fill_h2c_cmd(hw, H2C_92E_RA_MASK, 7, rate_mask);
2340 _rtl92ee_set_bcn_ctrl_reg(hw, BIT(3), 0);
2343 void rtl92ee_update_hal_rate_tbl(struct ieee80211_hw *hw,
2344 struct ieee80211_sta *sta, u8 rssi_level)
2346 struct rtl_priv *rtlpriv = rtl_priv(hw);
2348 if (rtlpriv->dm.useramask)
2349 rtl92ee_update_hal_rate_mask(hw, sta, rssi_level);
2352 void rtl92ee_update_channel_access_setting(struct ieee80211_hw *hw)
2354 struct rtl_priv *rtlpriv = rtl_priv(hw);
2355 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
2358 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SLOT_TIME,
2359 (u8 *)&mac->slot_time);
2360 if (!mac->ht_enable)
2361 sifs_timer = 0x0a0a;
2363 sifs_timer = 0x0e0e;
2364 rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SIFS, (u8 *)&sifs_timer);
2367 bool rtl92ee_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
2373 void rtl92ee_set_key(struct ieee80211_hw *hw, u32 key_index,
2374 u8 *p_macaddr, bool is_group, u8 enc_algo,
2375 bool is_wepkey, bool clear_all)
2377 struct rtl_priv *rtlpriv = rtl_priv(hw);
2378 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
2379 struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
2380 u8 *macaddr = p_macaddr;
2382 bool is_pairwise = false;
2384 static u8 cam_const_addr[4][6] = {
2385 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
2386 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
2387 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
2388 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}
2390 static u8 cam_const_broad[] = {
2391 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
2397 u8 clear_number = 5;
2399 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "clear_all\n");
2401 for (idx = 0; idx < clear_number; idx++) {
2402 rtl_cam_mark_invalid(hw, cam_offset + idx);
2403 rtl_cam_empty_entry(hw, cam_offset + idx);
2406 memset(rtlpriv->sec.key_buf[idx], 0,
2408 rtlpriv->sec.key_len[idx] = 0;
2414 case WEP40_ENCRYPTION:
2415 enc_algo = CAM_WEP40;
2417 case WEP104_ENCRYPTION:
2418 enc_algo = CAM_WEP104;
2420 case TKIP_ENCRYPTION:
2421 enc_algo = CAM_TKIP;
2423 case AESCCMP_ENCRYPTION:
2427 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
2428 "switch case not process\n");
2429 enc_algo = CAM_TKIP;
2433 if (is_wepkey || rtlpriv->sec.use_defaultkey) {
2434 macaddr = cam_const_addr[key_index];
2435 entry_id = key_index;
2438 macaddr = cam_const_broad;
2439 entry_id = key_index;
2441 if (mac->opmode == NL80211_IFTYPE_AP ||
2442 mac->opmode == NL80211_IFTYPE_MESH_POINT) {
2443 entry_id = rtl_cam_get_free_entry(hw,
2445 if (entry_id >= TOTAL_CAM_ENTRY) {
2446 RT_TRACE(rtlpriv, COMP_SEC,
2448 "Can not find free hw security cam entry\n");
2452 entry_id = CAM_PAIRWISE_KEY_POSITION;
2455 key_index = PAIRWISE_KEYIDX;
2460 if (rtlpriv->sec.key_len[key_index] == 0) {
2461 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
2462 "delete one entry, entry_id is %d\n",
2464 if (mac->opmode == NL80211_IFTYPE_AP ||
2465 mac->opmode == NL80211_IFTYPE_MESH_POINT)
2466 rtl_cam_del_entry(hw, p_macaddr);
2467 rtl_cam_delete_one_entry(hw, p_macaddr, entry_id);
2469 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
2472 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
2473 "set Pairwiase key\n");
2475 rtl_cam_add_one_entry(hw, macaddr, key_index,
2477 CAM_CONFIG_NO_USEDK,
2478 rtlpriv->sec.key_buf[key_index]);
2480 RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
2483 if (mac->opmode == NL80211_IFTYPE_ADHOC) {
2484 rtl_cam_add_one_entry(hw,
2487 CAM_PAIRWISE_KEY_POSITION,
2488 enc_algo, CAM_CONFIG_NO_USEDK,
2489 rtlpriv->sec.key_buf[entry_id]);
2492 rtl_cam_add_one_entry(hw, macaddr, key_index,
2494 CAM_CONFIG_NO_USEDK,
2495 rtlpriv->sec.key_buf[entry_id]);
2501 void rtl92ee_read_bt_coexist_info_from_hwpg(struct ieee80211_hw *hw,
2502 bool auto_load_fail, u8 *hwinfo)
2504 struct rtl_priv *rtlpriv = rtl_priv(hw);
2507 if (!auto_load_fail) {
2508 value = hwinfo[EEPROM_RF_BOARD_OPTION_92E];
2509 if (((value & 0xe0) >> 5) == 0x1)
2510 rtlpriv->btcoexist.btc_info.btcoexist = 1;
2512 rtlpriv->btcoexist.btc_info.btcoexist = 0;
2514 rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8192E;
2515 rtlpriv->btcoexist.btc_info.ant_num = ANT_TOTAL_X2;
2517 rtlpriv->btcoexist.btc_info.btcoexist = 1;
2518 rtlpriv->btcoexist.btc_info.bt_type = BT_RTL8192E;
2519 rtlpriv->btcoexist.btc_info.ant_num = ANT_TOTAL_X1;
2523 void rtl92ee_bt_reg_init(struct ieee80211_hw *hw)
2525 struct rtl_priv *rtlpriv = rtl_priv(hw);
2527 /* 0:Low, 1:High, 2:From Efuse. */
2528 rtlpriv->btcoexist.reg_bt_iso = 2;
2529 /* 0:Idle, 1:None-SCO, 2:SCO, 3:From Counter. */
2530 rtlpriv->btcoexist.reg_bt_sco = 3;
2531 /* 0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */
2532 rtlpriv->btcoexist.reg_bt_sco = 0;
2535 void rtl92ee_bt_hw_init(struct ieee80211_hw *hw)
2537 struct rtl_priv *rtlpriv = rtl_priv(hw);
2539 if (rtlpriv->cfg->ops->get_btc_status())
2540 rtlpriv->btcoexist.btc_ops->btc_init_hw_config(rtlpriv);
2543 void rtl92ee_suspend(struct ieee80211_hw *hw)
2547 void rtl92ee_resume(struct ieee80211_hw *hw)
2551 /* Turn on AAP (RCR:bit 0) for promicuous mode. */
2552 void rtl92ee_allow_all_destaddr(struct ieee80211_hw *hw,
2553 bool allow_all_da, bool write_into_reg)
2555 struct rtl_priv *rtlpriv = rtl_priv(hw);
2556 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
2558 if (allow_all_da) /* Set BIT0 */
2559 rtlpci->receive_config |= RCR_AAP;
2560 else /* Clear BIT0 */
2561 rtlpci->receive_config &= ~RCR_AAP;
2564 rtl_write_dword(rtlpriv, REG_RCR, rtlpci->receive_config);
2566 RT_TRACE(rtlpriv, COMP_TURBO | COMP_INIT, DBG_LOUD,
2567 "receive_config=0x%08X, write_into_reg=%d\n",
2568 rtlpci->receive_config, write_into_reg);