1 /******************************************************************************
3 * Copyright(c) 2009-2012 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 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
21 * Contact Information:
22 * wlanfae <wlanfae@realtek.com>
23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
24 * Hsinchu 300, Taiwan.
26 * Larry Finger <Larry.Finger@lwfinger.net>
28 *****************************************************************************/
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
44 static u32
_rtl92s_phy_calculate_bit_shift(u32 bitmask
)
48 for (i
= 0; i
<= 31; i
++) {
49 if (((bitmask
>> i
) & 0x1) == 1)
56 u32
rtl92s_phy_query_bb_reg(struct ieee80211_hw
*hw
, u32 regaddr
, u32 bitmask
)
58 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
59 u32 returnvalue
= 0, originalvalue
, bitshift
;
61 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
, "regaddr(%#x), bitmask(%#x)\n",
64 originalvalue
= rtl_read_dword(rtlpriv
, regaddr
);
65 bitshift
= _rtl92s_phy_calculate_bit_shift(bitmask
);
66 returnvalue
= (originalvalue
& bitmask
) >> bitshift
;
68 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
, "BBR MASK=0x%x Addr[0x%x]=0x%x\n",
69 bitmask
, regaddr
, originalvalue
);
75 void rtl92s_phy_set_bb_reg(struct ieee80211_hw
*hw
, u32 regaddr
, u32 bitmask
,
78 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
79 u32 originalvalue
, bitshift
;
81 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
82 "regaddr(%#x), bitmask(%#x), data(%#x)\n",
83 regaddr
, bitmask
, data
);
85 if (bitmask
!= MASKDWORD
) {
86 originalvalue
= rtl_read_dword(rtlpriv
, regaddr
);
87 bitshift
= _rtl92s_phy_calculate_bit_shift(bitmask
);
88 data
= ((originalvalue
& (~bitmask
)) | (data
<< bitshift
));
91 rtl_write_dword(rtlpriv
, regaddr
, data
);
93 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
94 "regaddr(%#x), bitmask(%#x), data(%#x)\n",
95 regaddr
, bitmask
, data
);
99 static u32
_rtl92s_phy_rf_serial_read(struct ieee80211_hw
*hw
,
100 enum radio_path rfpath
, u32 offset
)
103 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
104 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
105 struct bb_reg_def
*pphyreg
= &rtlphy
->phyreg_def
[rfpath
];
107 u32 tmplong
, tmplong2
;
114 tmplong
= rtl_get_bbreg(hw
, RFPGA0_XA_HSSIPARAMETER2
, MASKDWORD
);
116 if (rfpath
== RF90_PATH_A
)
119 tmplong2
= rtl_get_bbreg(hw
, pphyreg
->rfhssi_para2
, MASKDWORD
);
121 tmplong2
= (tmplong2
& (~BLSSI_READADDRESS
)) | (newoffset
<< 23) |
124 rtl_set_bbreg(hw
, RFPGA0_XA_HSSIPARAMETER2
, MASKDWORD
,
125 tmplong
& (~BLSSI_READEDGE
));
129 rtl_set_bbreg(hw
, pphyreg
->rfhssi_para2
, MASKDWORD
, tmplong2
);
132 rtl_set_bbreg(hw
, RFPGA0_XA_HSSIPARAMETER2
, MASKDWORD
, tmplong
|
136 if (rfpath
== RF90_PATH_A
)
137 rfpi_enable
= (u8
)rtl_get_bbreg(hw
, RFPGA0_XA_HSSIPARAMETER1
,
139 else if (rfpath
== RF90_PATH_B
)
140 rfpi_enable
= (u8
)rtl_get_bbreg(hw
, RFPGA0_XB_HSSIPARAMETER1
,
144 retvalue
= rtl_get_bbreg(hw
, pphyreg
->rflssi_readbackpi
,
145 BLSSI_READBACK_DATA
);
147 retvalue
= rtl_get_bbreg(hw
, pphyreg
->rflssi_readback
,
148 BLSSI_READBACK_DATA
);
150 retvalue
= rtl_get_bbreg(hw
, pphyreg
->rflssi_readback
,
151 BLSSI_READBACK_DATA
);
153 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
, "RFR-%d Addr[0x%x]=0x%x\n",
154 rfpath
, pphyreg
->rflssi_readback
, retvalue
);
160 static void _rtl92s_phy_rf_serial_write(struct ieee80211_hw
*hw
,
161 enum radio_path rfpath
, u32 offset
,
164 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
165 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
166 struct bb_reg_def
*pphyreg
= &rtlphy
->phyreg_def
[rfpath
];
167 u32 data_and_addr
= 0;
173 data_and_addr
= ((newoffset
<< 20) | (data
& 0x000fffff)) & 0x0fffffff;
174 rtl_set_bbreg(hw
, pphyreg
->rf3wire_offset
, MASKDWORD
, data_and_addr
);
176 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
, "RFW-%d Addr[0x%x]=0x%x\n",
177 rfpath
, pphyreg
->rf3wire_offset
, data_and_addr
);
181 u32
rtl92s_phy_query_rf_reg(struct ieee80211_hw
*hw
, enum radio_path rfpath
,
182 u32 regaddr
, u32 bitmask
)
184 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
185 u32 original_value
, readback_value
, bitshift
;
187 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
188 "regaddr(%#x), rfpath(%#x), bitmask(%#x)\n",
189 regaddr
, rfpath
, bitmask
);
191 spin_lock(&rtlpriv
->locks
.rf_lock
);
193 original_value
= _rtl92s_phy_rf_serial_read(hw
, rfpath
, regaddr
);
195 bitshift
= _rtl92s_phy_calculate_bit_shift(bitmask
);
196 readback_value
= (original_value
& bitmask
) >> bitshift
;
198 spin_unlock(&rtlpriv
->locks
.rf_lock
);
200 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
201 "regaddr(%#x), rfpath(%#x), bitmask(%#x), original_value(%#x)\n",
202 regaddr
, rfpath
, bitmask
, original_value
);
204 return readback_value
;
207 void rtl92s_phy_set_rf_reg(struct ieee80211_hw
*hw
, enum radio_path rfpath
,
208 u32 regaddr
, u32 bitmask
, u32 data
)
210 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
211 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
212 u32 original_value
, bitshift
;
214 if (!((rtlphy
->rf_pathmap
>> rfpath
) & 0x1))
217 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
218 "regaddr(%#x), bitmask(%#x), data(%#x), rfpath(%#x)\n",
219 regaddr
, bitmask
, data
, rfpath
);
221 spin_lock(&rtlpriv
->locks
.rf_lock
);
223 if (bitmask
!= RFREG_OFFSET_MASK
) {
224 original_value
= _rtl92s_phy_rf_serial_read(hw
, rfpath
,
226 bitshift
= _rtl92s_phy_calculate_bit_shift(bitmask
);
227 data
= ((original_value
& (~bitmask
)) | (data
<< bitshift
));
230 _rtl92s_phy_rf_serial_write(hw
, rfpath
, regaddr
, data
);
232 spin_unlock(&rtlpriv
->locks
.rf_lock
);
234 RT_TRACE(rtlpriv
, COMP_RF
, DBG_TRACE
,
235 "regaddr(%#x), bitmask(%#x), data(%#x), rfpath(%#x)\n",
236 regaddr
, bitmask
, data
, rfpath
);
240 void rtl92s_phy_scan_operation_backup(struct ieee80211_hw
*hw
,
243 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
244 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
246 if (!is_hal_stop(rtlhal
)) {
248 case SCAN_OPT_BACKUP
:
249 rtl92s_phy_set_fw_cmd(hw
, FW_CMD_PAUSE_DM_BY_SCAN
);
251 case SCAN_OPT_RESTORE
:
252 rtl92s_phy_set_fw_cmd(hw
, FW_CMD_RESUME_DM_BY_SCAN
);
255 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
256 "Unknown operation\n");
262 void rtl92s_phy_set_bw_mode(struct ieee80211_hw
*hw
,
263 enum nl80211_channel_type ch_type
)
265 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
266 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
267 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
268 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
271 RT_TRACE(rtlpriv
, COMP_SCAN
, DBG_TRACE
, "Switch to %s bandwidth\n",
272 rtlphy
->current_chan_bw
== HT_CHANNEL_WIDTH_20
?
275 if (rtlphy
->set_bwmode_inprogress
)
277 if (is_hal_stop(rtlhal
))
280 rtlphy
->set_bwmode_inprogress
= true;
282 reg_bw_opmode
= rtl_read_byte(rtlpriv
, BW_OPMODE
);
284 rtl_read_byte(rtlpriv
, RRSR
+ 2);
286 switch (rtlphy
->current_chan_bw
) {
287 case HT_CHANNEL_WIDTH_20
:
288 reg_bw_opmode
|= BW_OPMODE_20MHZ
;
289 rtl_write_byte(rtlpriv
, BW_OPMODE
, reg_bw_opmode
);
291 case HT_CHANNEL_WIDTH_20_40
:
292 reg_bw_opmode
&= ~BW_OPMODE_20MHZ
;
293 rtl_write_byte(rtlpriv
, BW_OPMODE
, reg_bw_opmode
);
296 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
297 "unknown bandwidth: %#X\n", rtlphy
->current_chan_bw
);
301 switch (rtlphy
->current_chan_bw
) {
302 case HT_CHANNEL_WIDTH_20
:
303 rtl_set_bbreg(hw
, RFPGA0_RFMOD
, BRFMOD
, 0x0);
304 rtl_set_bbreg(hw
, RFPGA1_RFMOD
, BRFMOD
, 0x0);
306 if (rtlhal
->version
>= VERSION_8192S_BCUT
)
307 rtl_write_byte(rtlpriv
, RFPGA0_ANALOGPARAMETER2
, 0x58);
309 case HT_CHANNEL_WIDTH_20_40
:
310 rtl_set_bbreg(hw
, RFPGA0_RFMOD
, BRFMOD
, 0x1);
311 rtl_set_bbreg(hw
, RFPGA1_RFMOD
, BRFMOD
, 0x1);
313 rtl_set_bbreg(hw
, RCCK0_SYSTEM
, BCCK_SIDEBAND
,
314 (mac
->cur_40_prime_sc
>> 1));
315 rtl_set_bbreg(hw
, ROFDM1_LSTF
, 0xC00, mac
->cur_40_prime_sc
);
317 if (rtlhal
->version
>= VERSION_8192S_BCUT
)
318 rtl_write_byte(rtlpriv
, RFPGA0_ANALOGPARAMETER2
, 0x18);
321 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
322 "unknown bandwidth: %#X\n", rtlphy
->current_chan_bw
);
326 rtl92s_phy_rf6052_set_bandwidth(hw
, rtlphy
->current_chan_bw
);
327 rtlphy
->set_bwmode_inprogress
= false;
328 RT_TRACE(rtlpriv
, COMP_SCAN
, DBG_TRACE
, "<==\n");
331 static bool _rtl92s_phy_set_sw_chnl_cmdarray(struct swchnlcmd
*cmdtable
,
332 u32 cmdtableidx
, u32 cmdtablesz
, enum swchnlcmd_id cmdid
,
333 u32 para1
, u32 para2
, u32 msdelay
)
335 struct swchnlcmd
*pcmd
;
337 if (cmdtable
== NULL
) {
338 RT_ASSERT(false, "cmdtable cannot be NULL\n");
342 if (cmdtableidx
>= cmdtablesz
)
345 pcmd
= cmdtable
+ cmdtableidx
;
349 pcmd
->msdelay
= msdelay
;
354 static bool _rtl92s_phy_sw_chnl_step_by_step(struct ieee80211_hw
*hw
,
355 u8 channel
, u8
*stage
, u8
*step
, u32
*delay
)
357 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
358 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
359 struct swchnlcmd precommoncmd
[MAX_PRECMD_CNT
];
361 struct swchnlcmd postcommoncmd
[MAX_POSTCMD_CNT
];
362 u32 postcommoncmdcnt
;
363 struct swchnlcmd rfdependcmd
[MAX_RFDEPENDCMD_CNT
];
365 struct swchnlcmd
*currentcmd
= NULL
;
367 u8 num_total_rfpath
= rtlphy
->num_total_rfpath
;
370 _rtl92s_phy_set_sw_chnl_cmdarray(precommoncmd
, precommoncmdcnt
++,
371 MAX_PRECMD_CNT
, CMDID_SET_TXPOWEROWER_LEVEL
, 0, 0, 0);
372 _rtl92s_phy_set_sw_chnl_cmdarray(precommoncmd
, precommoncmdcnt
++,
373 MAX_PRECMD_CNT
, CMDID_END
, 0, 0, 0);
375 postcommoncmdcnt
= 0;
377 _rtl92s_phy_set_sw_chnl_cmdarray(postcommoncmd
, postcommoncmdcnt
++,
378 MAX_POSTCMD_CNT
, CMDID_END
, 0, 0, 0);
382 RT_ASSERT((channel
>= 1 && channel
<= 14),
383 "invalid channel for Zebra: %d\n", channel
);
385 _rtl92s_phy_set_sw_chnl_cmdarray(rfdependcmd
, rfdependcmdcnt
++,
386 MAX_RFDEPENDCMD_CNT
, CMDID_RF_WRITEREG
,
387 RF_CHNLBW
, channel
, 10);
389 _rtl92s_phy_set_sw_chnl_cmdarray(rfdependcmd
, rfdependcmdcnt
++,
390 MAX_RFDEPENDCMD_CNT
, CMDID_END
, 0, 0, 0);
395 currentcmd
= &precommoncmd
[*step
];
398 currentcmd
= &rfdependcmd
[*step
];
401 currentcmd
= &postcommoncmd
[*step
];
405 if (currentcmd
->cmdid
== CMDID_END
) {
415 switch (currentcmd
->cmdid
) {
416 case CMDID_SET_TXPOWEROWER_LEVEL
:
417 rtl92s_phy_set_txpower(hw
, channel
);
419 case CMDID_WRITEPORT_ULONG
:
420 rtl_write_dword(rtlpriv
, currentcmd
->para1
,
423 case CMDID_WRITEPORT_USHORT
:
424 rtl_write_word(rtlpriv
, currentcmd
->para1
,
425 (u16
)currentcmd
->para2
);
427 case CMDID_WRITEPORT_UCHAR
:
428 rtl_write_byte(rtlpriv
, currentcmd
->para1
,
429 (u8
)currentcmd
->para2
);
431 case CMDID_RF_WRITEREG
:
432 for (rfpath
= 0; rfpath
< num_total_rfpath
; rfpath
++) {
433 rtlphy
->rfreg_chnlval
[rfpath
] =
434 ((rtlphy
->rfreg_chnlval
[rfpath
] &
435 0xfffffc00) | currentcmd
->para2
);
436 rtl_set_rfreg(hw
, (enum radio_path
)rfpath
,
439 rtlphy
->rfreg_chnlval
[rfpath
]);
443 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
444 "switch case not processed\n");
451 (*delay
) = currentcmd
->msdelay
;
456 u8
rtl92s_phy_sw_chnl(struct ieee80211_hw
*hw
)
458 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
459 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
460 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
464 RT_TRACE(rtlpriv
, COMP_SCAN
, DBG_TRACE
, "switch to channel%d\n",
465 rtlphy
->current_channel
);
467 if (rtlphy
->sw_chnl_inprogress
)
470 if (rtlphy
->set_bwmode_inprogress
)
473 if (is_hal_stop(rtlhal
))
476 rtlphy
->sw_chnl_inprogress
= true;
477 rtlphy
->sw_chnl_stage
= 0;
478 rtlphy
->sw_chnl_step
= 0;
481 if (!rtlphy
->sw_chnl_inprogress
)
484 ret
= _rtl92s_phy_sw_chnl_step_by_step(hw
,
485 rtlphy
->current_channel
,
486 &rtlphy
->sw_chnl_stage
,
487 &rtlphy
->sw_chnl_step
, &delay
);
494 rtlphy
->sw_chnl_inprogress
= false;
499 rtlphy
->sw_chnl_inprogress
= false;
501 RT_TRACE(rtlpriv
, COMP_SCAN
, DBG_TRACE
, "<==\n");
506 static void _rtl92se_phy_set_rf_sleep(struct ieee80211_hw
*hw
)
508 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
511 u1btmp
= rtl_read_byte(rtlpriv
, LDOV12D_CTRL
);
514 rtl_write_byte(rtlpriv
, LDOV12D_CTRL
, u1btmp
);
515 rtl_write_byte(rtlpriv
, SPS1_CTRL
, 0x0);
516 rtl_write_byte(rtlpriv
, TXPAUSE
, 0xFF);
517 rtl_write_word(rtlpriv
, CMDR
, 0x57FC);
520 rtl_write_word(rtlpriv
, CMDR
, 0x77FC);
521 rtl_write_byte(rtlpriv
, PHY_CCA
, 0x0);
524 rtl_write_word(rtlpriv
, CMDR
, 0x37FC);
527 rtl_write_word(rtlpriv
, CMDR
, 0x77FC);
530 rtl_write_word(rtlpriv
, CMDR
, 0x57FC);
532 /* we should chnge GPIO to input mode
533 * this will drop away current about 25mA*/
534 rtl8192se_gpiobit3_cfg_inputmode(hw
);
537 bool rtl92s_phy_set_rf_power_state(struct ieee80211_hw
*hw
,
538 enum rf_pwrstate rfpwr_state
)
540 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
541 struct rtl_pci_priv
*pcipriv
= rtl_pcipriv(hw
);
542 struct rtl_mac
*mac
= rtl_mac(rtl_priv(hw
));
543 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
546 struct rtl8192_tx_ring
*ring
= NULL
;
548 if (rfpwr_state
== ppsc
->rfpwr_state
)
551 switch (rfpwr_state
) {
553 if ((ppsc
->rfpwr_state
== ERFOFF
) &&
554 RT_IN_PS_LEVEL(ppsc
, RT_RF_OFF_LEVL_HALT_NIC
)) {
557 u32 InitializeCount
= 0;
560 RT_TRACE(rtlpriv
, COMP_RF
, DBG_DMESG
,
561 "IPS Set eRf nic enable\n");
562 rtstatus
= rtl_ps_enable_nic(hw
);
563 } while ((rtstatus
!= true) &&
564 (InitializeCount
< 10));
566 RT_CLEAR_PS_LEVEL(ppsc
,
567 RT_RF_OFF_LEVL_HALT_NIC
);
569 RT_TRACE(rtlpriv
, COMP_POWER
, DBG_DMESG
,
570 "awake, sleeped:%d ms state_inap:%x\n",
571 jiffies_to_msecs(jiffies
-
574 rtlpriv
->psc
.state_inap
);
575 ppsc
->last_awake_jiffies
= jiffies
;
576 rtl_write_word(rtlpriv
, CMDR
, 0x37FC);
577 rtl_write_byte(rtlpriv
, TXPAUSE
, 0x00);
578 rtl_write_byte(rtlpriv
, PHY_CCA
, 0x3);
581 if (mac
->link_state
== MAC80211_LINKED
)
582 rtlpriv
->cfg
->ops
->led_control(hw
,
585 rtlpriv
->cfg
->ops
->led_control(hw
,
590 if (ppsc
->reg_rfps_level
& RT_RF_OFF_LEVL_HALT_NIC
) {
591 RT_TRACE(rtlpriv
, COMP_RF
, DBG_DMESG
,
592 "IPS Set eRf nic disable\n");
593 rtl_ps_disable_nic(hw
);
594 RT_SET_PS_LEVEL(ppsc
, RT_RF_OFF_LEVL_HALT_NIC
);
596 if (ppsc
->rfoff_reason
== RF_CHANGE_BY_IPS
)
597 rtlpriv
->cfg
->ops
->led_control(hw
,
600 rtlpriv
->cfg
->ops
->led_control(hw
,
606 if (ppsc
->rfpwr_state
== ERFOFF
)
609 for (queue_id
= 0, i
= 0;
610 queue_id
< RTL_PCI_MAX_TX_QUEUE_COUNT
;) {
611 ring
= &pcipriv
->dev
.tx_ring
[queue_id
];
612 if (skb_queue_len(&ring
->queue
) == 0 ||
613 queue_id
== BEACON_QUEUE
) {
617 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
618 "eRf Off/Sleep: %d times TcbBusyQueue[%d] = %d before doze!\n",
620 skb_queue_len(&ring
->queue
));
626 if (i
>= MAX_DOZE_WAITING_TIMES_9x
) {
627 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_WARNING
,
628 "ERFOFF: %d times TcbBusyQueue[%d] = %d !\n",
629 MAX_DOZE_WAITING_TIMES_9x
,
631 skb_queue_len(&ring
->queue
));
636 RT_TRACE(rtlpriv
, COMP_POWER
, DBG_DMESG
,
637 "Set ERFSLEEP awaked:%d ms\n",
638 jiffies_to_msecs(jiffies
-
639 ppsc
->last_awake_jiffies
));
641 RT_TRACE(rtlpriv
, COMP_POWER
, DBG_DMESG
,
642 "sleep awaked:%d ms state_inap:%x\n",
643 jiffies_to_msecs(jiffies
-
644 ppsc
->last_awake_jiffies
),
645 rtlpriv
->psc
.state_inap
);
646 ppsc
->last_sleep_jiffies
= jiffies
;
647 _rtl92se_phy_set_rf_sleep(hw
);
650 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
,
651 "switch case not processed\n");
657 ppsc
->rfpwr_state
= rfpwr_state
;
662 static bool _rtl92s_phy_config_rfpa_bias_current(struct ieee80211_hw
*hw
,
663 enum radio_path rfpath
)
665 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
666 bool rtstatus
= true;
669 /* If inferiority IC, we have to increase the PA bias current */
670 if (rtlhal
->ic_class
!= IC_INFERIORITY_A
) {
671 tmpval
= rtl92s_phy_query_rf_reg(hw
, rfpath
, RF_IPA
, 0xf);
672 rtl92s_phy_set_rf_reg(hw
, rfpath
, RF_IPA
, 0xf, tmpval
+ 1);
678 static void _rtl92s_store_pwrindex_diffrate_offset(struct ieee80211_hw
*hw
,
679 u32 reg_addr
, u32 bitmask
, u32 data
)
681 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
682 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
684 if (reg_addr
== RTXAGC_RATE18_06
)
685 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][0] =
687 if (reg_addr
== RTXAGC_RATE54_24
)
688 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][1] =
690 if (reg_addr
== RTXAGC_CCK_MCS32
)
691 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][6] =
693 if (reg_addr
== RTXAGC_MCS03_MCS00
)
694 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][2] =
696 if (reg_addr
== RTXAGC_MCS07_MCS04
)
697 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][3] =
699 if (reg_addr
== RTXAGC_MCS11_MCS08
)
700 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][4] =
702 if (reg_addr
== RTXAGC_MCS15_MCS12
) {
703 rtlphy
->mcs_txpwrlevel_origoffset
[rtlphy
->pwrgroup_cnt
][5] =
705 rtlphy
->pwrgroup_cnt
++;
709 static void _rtl92s_phy_init_register_definition(struct ieee80211_hw
*hw
)
711 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
712 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
714 /*RF Interface Sowrtware Control */
715 rtlphy
->phyreg_def
[RF90_PATH_A
].rfintfs
= RFPGA0_XAB_RFINTERFACESW
;
716 rtlphy
->phyreg_def
[RF90_PATH_B
].rfintfs
= RFPGA0_XAB_RFINTERFACESW
;
717 rtlphy
->phyreg_def
[RF90_PATH_C
].rfintfs
= RFPGA0_XCD_RFINTERFACESW
;
718 rtlphy
->phyreg_def
[RF90_PATH_D
].rfintfs
= RFPGA0_XCD_RFINTERFACESW
;
720 /* RF Interface Readback Value */
721 rtlphy
->phyreg_def
[RF90_PATH_A
].rfintfi
= RFPGA0_XAB_RFINTERFACERB
;
722 rtlphy
->phyreg_def
[RF90_PATH_B
].rfintfi
= RFPGA0_XAB_RFINTERFACERB
;
723 rtlphy
->phyreg_def
[RF90_PATH_C
].rfintfi
= RFPGA0_XCD_RFINTERFACERB
;
724 rtlphy
->phyreg_def
[RF90_PATH_D
].rfintfi
= RFPGA0_XCD_RFINTERFACERB
;
726 /* RF Interface Output (and Enable) */
727 rtlphy
->phyreg_def
[RF90_PATH_A
].rfintfo
= RFPGA0_XA_RFINTERFACEOE
;
728 rtlphy
->phyreg_def
[RF90_PATH_B
].rfintfo
= RFPGA0_XB_RFINTERFACEOE
;
729 rtlphy
->phyreg_def
[RF90_PATH_C
].rfintfo
= RFPGA0_XC_RFINTERFACEOE
;
730 rtlphy
->phyreg_def
[RF90_PATH_D
].rfintfo
= RFPGA0_XD_RFINTERFACEOE
;
732 /* RF Interface (Output and) Enable */
733 rtlphy
->phyreg_def
[RF90_PATH_A
].rfintfe
= RFPGA0_XA_RFINTERFACEOE
;
734 rtlphy
->phyreg_def
[RF90_PATH_B
].rfintfe
= RFPGA0_XB_RFINTERFACEOE
;
735 rtlphy
->phyreg_def
[RF90_PATH_C
].rfintfe
= RFPGA0_XC_RFINTERFACEOE
;
736 rtlphy
->phyreg_def
[RF90_PATH_D
].rfintfe
= RFPGA0_XD_RFINTERFACEOE
;
738 /* Addr of LSSI. Wirte RF register by driver */
739 rtlphy
->phyreg_def
[RF90_PATH_A
].rf3wire_offset
=
740 RFPGA0_XA_LSSIPARAMETER
;
741 rtlphy
->phyreg_def
[RF90_PATH_B
].rf3wire_offset
=
742 RFPGA0_XB_LSSIPARAMETER
;
743 rtlphy
->phyreg_def
[RF90_PATH_C
].rf3wire_offset
=
744 RFPGA0_XC_LSSIPARAMETER
;
745 rtlphy
->phyreg_def
[RF90_PATH_D
].rf3wire_offset
=
746 RFPGA0_XD_LSSIPARAMETER
;
749 rtlphy
->phyreg_def
[RF90_PATH_A
].rflssi_select
= RFPGA0_XAB_RFPARAMETER
;
750 rtlphy
->phyreg_def
[RF90_PATH_B
].rflssi_select
= RFPGA0_XAB_RFPARAMETER
;
751 rtlphy
->phyreg_def
[RF90_PATH_C
].rflssi_select
= RFPGA0_XCD_RFPARAMETER
;
752 rtlphy
->phyreg_def
[RF90_PATH_D
].rflssi_select
= RFPGA0_XCD_RFPARAMETER
;
754 /* Tx AGC Gain Stage (same for all path. Should we remove this?) */
755 rtlphy
->phyreg_def
[RF90_PATH_A
].rftxgain_stage
= RFPGA0_TXGAINSTAGE
;
756 rtlphy
->phyreg_def
[RF90_PATH_B
].rftxgain_stage
= RFPGA0_TXGAINSTAGE
;
757 rtlphy
->phyreg_def
[RF90_PATH_C
].rftxgain_stage
= RFPGA0_TXGAINSTAGE
;
758 rtlphy
->phyreg_def
[RF90_PATH_D
].rftxgain_stage
= RFPGA0_TXGAINSTAGE
;
760 /* Tranceiver A~D HSSI Parameter-1 */
761 rtlphy
->phyreg_def
[RF90_PATH_A
].rfhssi_para1
= RFPGA0_XA_HSSIPARAMETER1
;
762 rtlphy
->phyreg_def
[RF90_PATH_B
].rfhssi_para1
= RFPGA0_XB_HSSIPARAMETER1
;
763 rtlphy
->phyreg_def
[RF90_PATH_C
].rfhssi_para1
= RFPGA0_XC_HSSIPARAMETER1
;
764 rtlphy
->phyreg_def
[RF90_PATH_D
].rfhssi_para1
= RFPGA0_XD_HSSIPARAMETER1
;
766 /* Tranceiver A~D HSSI Parameter-2 */
767 rtlphy
->phyreg_def
[RF90_PATH_A
].rfhssi_para2
= RFPGA0_XA_HSSIPARAMETER2
;
768 rtlphy
->phyreg_def
[RF90_PATH_B
].rfhssi_para2
= RFPGA0_XB_HSSIPARAMETER2
;
769 rtlphy
->phyreg_def
[RF90_PATH_C
].rfhssi_para2
= RFPGA0_XC_HSSIPARAMETER2
;
770 rtlphy
->phyreg_def
[RF90_PATH_D
].rfhssi_para2
= RFPGA0_XD_HSSIPARAMETER2
;
772 /* RF switch Control */
773 rtlphy
->phyreg_def
[RF90_PATH_A
].rfswitch_control
=
774 RFPGA0_XAB_SWITCHCONTROL
;
775 rtlphy
->phyreg_def
[RF90_PATH_B
].rfswitch_control
=
776 RFPGA0_XAB_SWITCHCONTROL
;
777 rtlphy
->phyreg_def
[RF90_PATH_C
].rfswitch_control
=
778 RFPGA0_XCD_SWITCHCONTROL
;
779 rtlphy
->phyreg_def
[RF90_PATH_D
].rfswitch_control
=
780 RFPGA0_XCD_SWITCHCONTROL
;
783 rtlphy
->phyreg_def
[RF90_PATH_A
].rfagc_control1
= ROFDM0_XAAGCCORE1
;
784 rtlphy
->phyreg_def
[RF90_PATH_B
].rfagc_control1
= ROFDM0_XBAGCCORE1
;
785 rtlphy
->phyreg_def
[RF90_PATH_C
].rfagc_control1
= ROFDM0_XCAGCCORE1
;
786 rtlphy
->phyreg_def
[RF90_PATH_D
].rfagc_control1
= ROFDM0_XDAGCCORE1
;
789 rtlphy
->phyreg_def
[RF90_PATH_A
].rfagc_control2
= ROFDM0_XAAGCCORE2
;
790 rtlphy
->phyreg_def
[RF90_PATH_B
].rfagc_control2
= ROFDM0_XBAGCCORE2
;
791 rtlphy
->phyreg_def
[RF90_PATH_C
].rfagc_control2
= ROFDM0_XCAGCCORE2
;
792 rtlphy
->phyreg_def
[RF90_PATH_D
].rfagc_control2
= ROFDM0_XDAGCCORE2
;
794 /* RX AFE control 1 */
795 rtlphy
->phyreg_def
[RF90_PATH_A
].rfrxiq_imbalance
=
796 ROFDM0_XARXIQIMBALANCE
;
797 rtlphy
->phyreg_def
[RF90_PATH_B
].rfrxiq_imbalance
=
798 ROFDM0_XBRXIQIMBALANCE
;
799 rtlphy
->phyreg_def
[RF90_PATH_C
].rfrxiq_imbalance
=
800 ROFDM0_XCRXIQIMBALANCE
;
801 rtlphy
->phyreg_def
[RF90_PATH_D
].rfrxiq_imbalance
=
802 ROFDM0_XDRXIQIMBALANCE
;
804 /* RX AFE control 1 */
805 rtlphy
->phyreg_def
[RF90_PATH_A
].rfrx_afe
= ROFDM0_XARXAFE
;
806 rtlphy
->phyreg_def
[RF90_PATH_B
].rfrx_afe
= ROFDM0_XBRXAFE
;
807 rtlphy
->phyreg_def
[RF90_PATH_C
].rfrx_afe
= ROFDM0_XCRXAFE
;
808 rtlphy
->phyreg_def
[RF90_PATH_D
].rfrx_afe
= ROFDM0_XDRXAFE
;
810 /* Tx AFE control 1 */
811 rtlphy
->phyreg_def
[RF90_PATH_A
].rftxiq_imbalance
=
812 ROFDM0_XATXIQIMBALANCE
;
813 rtlphy
->phyreg_def
[RF90_PATH_B
].rftxiq_imbalance
=
814 ROFDM0_XBTXIQIMBALANCE
;
815 rtlphy
->phyreg_def
[RF90_PATH_C
].rftxiq_imbalance
=
816 ROFDM0_XCTXIQIMBALANCE
;
817 rtlphy
->phyreg_def
[RF90_PATH_D
].rftxiq_imbalance
=
818 ROFDM0_XDTXIQIMBALANCE
;
820 /* Tx AFE control 2 */
821 rtlphy
->phyreg_def
[RF90_PATH_A
].rftx_afe
= ROFDM0_XATXAFE
;
822 rtlphy
->phyreg_def
[RF90_PATH_B
].rftx_afe
= ROFDM0_XBTXAFE
;
823 rtlphy
->phyreg_def
[RF90_PATH_C
].rftx_afe
= ROFDM0_XCTXAFE
;
824 rtlphy
->phyreg_def
[RF90_PATH_D
].rftx_afe
= ROFDM0_XDTXAFE
;
826 /* Tranceiver LSSI Readback */
827 rtlphy
->phyreg_def
[RF90_PATH_A
].rflssi_readback
=
828 RFPGA0_XA_LSSIREADBACK
;
829 rtlphy
->phyreg_def
[RF90_PATH_B
].rflssi_readback
=
830 RFPGA0_XB_LSSIREADBACK
;
831 rtlphy
->phyreg_def
[RF90_PATH_C
].rflssi_readback
=
832 RFPGA0_XC_LSSIREADBACK
;
833 rtlphy
->phyreg_def
[RF90_PATH_D
].rflssi_readback
=
834 RFPGA0_XD_LSSIREADBACK
;
836 /* Tranceiver LSSI Readback PI mode */
837 rtlphy
->phyreg_def
[RF90_PATH_A
].rflssi_readbackpi
=
838 TRANSCEIVERA_HSPI_READBACK
;
839 rtlphy
->phyreg_def
[RF90_PATH_B
].rflssi_readbackpi
=
840 TRANSCEIVERB_HSPI_READBACK
;
844 static bool _rtl92s_phy_config_bb(struct ieee80211_hw
*hw
, u8 configtype
)
849 u16 phy_reg_len
, agc_len
;
851 agc_len
= AGCTAB_ARRAYLENGTH
;
852 agc_table
= rtl8192seagctab_array
;
853 /* Default RF_type: 2T2R */
854 phy_reg_len
= PHY_REG_2T2RARRAYLENGTH
;
855 phy_reg_table
= rtl8192sephy_reg_2t2rarray
;
857 if (configtype
== BASEBAND_CONFIG_PHY_REG
) {
858 for (i
= 0; i
< phy_reg_len
; i
= i
+ 2) {
859 if (phy_reg_table
[i
] == 0xfe)
861 else if (phy_reg_table
[i
] == 0xfd)
863 else if (phy_reg_table
[i
] == 0xfc)
865 else if (phy_reg_table
[i
] == 0xfb)
867 else if (phy_reg_table
[i
] == 0xfa)
869 else if (phy_reg_table
[i
] == 0xf9)
872 /* Add delay for ECS T20 & LG malow platform, */
875 rtl92s_phy_set_bb_reg(hw
, phy_reg_table
[i
], MASKDWORD
,
876 phy_reg_table
[i
+ 1]);
878 } else if (configtype
== BASEBAND_CONFIG_AGC_TAB
) {
879 for (i
= 0; i
< agc_len
; i
= i
+ 2) {
880 rtl92s_phy_set_bb_reg(hw
, agc_table
[i
], MASKDWORD
,
883 /* Add delay for ECS T20 & LG malow platform */
891 static bool _rtl92s_phy_set_bb_to_diff_rf(struct ieee80211_hw
*hw
,
894 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
895 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
896 u32
*phy_regarray2xtxr_table
;
897 u16 phy_regarray2xtxr_len
;
900 if (rtlphy
->rf_type
== RF_1T1R
) {
901 phy_regarray2xtxr_table
= rtl8192sephy_changeto_1t1rarray
;
902 phy_regarray2xtxr_len
= PHY_CHANGETO_1T1RARRAYLENGTH
;
903 } else if (rtlphy
->rf_type
== RF_1T2R
) {
904 phy_regarray2xtxr_table
= rtl8192sephy_changeto_1t2rarray
;
905 phy_regarray2xtxr_len
= PHY_CHANGETO_1T2RARRAYLENGTH
;
910 if (configtype
== BASEBAND_CONFIG_PHY_REG
) {
911 for (i
= 0; i
< phy_regarray2xtxr_len
; i
= i
+ 3) {
912 if (phy_regarray2xtxr_table
[i
] == 0xfe)
914 else if (phy_regarray2xtxr_table
[i
] == 0xfd)
916 else if (phy_regarray2xtxr_table
[i
] == 0xfc)
918 else if (phy_regarray2xtxr_table
[i
] == 0xfb)
920 else if (phy_regarray2xtxr_table
[i
] == 0xfa)
922 else if (phy_regarray2xtxr_table
[i
] == 0xf9)
925 rtl92s_phy_set_bb_reg(hw
, phy_regarray2xtxr_table
[i
],
926 phy_regarray2xtxr_table
[i
+ 1],
927 phy_regarray2xtxr_table
[i
+ 2]);
934 static bool _rtl92s_phy_config_bb_with_pg(struct ieee80211_hw
*hw
,
941 phy_pg_len
= PHY_REG_ARRAY_PGLENGTH
;
942 phy_table_pg
= rtl8192sephy_reg_array_pg
;
944 if (configtype
== BASEBAND_CONFIG_PHY_REG
) {
945 for (i
= 0; i
< phy_pg_len
; i
= i
+ 3) {
946 if (phy_table_pg
[i
] == 0xfe)
948 else if (phy_table_pg
[i
] == 0xfd)
950 else if (phy_table_pg
[i
] == 0xfc)
952 else if (phy_table_pg
[i
] == 0xfb)
954 else if (phy_table_pg
[i
] == 0xfa)
956 else if (phy_table_pg
[i
] == 0xf9)
959 _rtl92s_store_pwrindex_diffrate_offset(hw
,
962 phy_table_pg
[i
+ 2]);
963 rtl92s_phy_set_bb_reg(hw
, phy_table_pg
[i
],
965 phy_table_pg
[i
+ 2]);
972 static bool _rtl92s_phy_bb_config_parafile(struct ieee80211_hw
*hw
)
974 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
975 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
976 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
977 bool rtstatus
= true;
979 /* 1. Read PHY_REG.TXT BB INIT!! */
980 /* We will separate as 1T1R/1T2R/1T2R_GREEN/2T2R */
981 if (rtlphy
->rf_type
== RF_1T2R
|| rtlphy
->rf_type
== RF_2T2R
||
982 rtlphy
->rf_type
== RF_1T1R
|| rtlphy
->rf_type
== RF_2T2R_GREEN
) {
983 rtstatus
= _rtl92s_phy_config_bb(hw
, BASEBAND_CONFIG_PHY_REG
);
985 if (rtlphy
->rf_type
!= RF_2T2R
&&
986 rtlphy
->rf_type
!= RF_2T2R_GREEN
)
987 /* so we should reconfig BB reg with the right
989 rtstatus
= _rtl92s_phy_set_bb_to_diff_rf(hw
,
990 BASEBAND_CONFIG_PHY_REG
);
995 if (rtstatus
!= true) {
996 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_EMERG
,
997 "Write BB Reg Fail!!\n");
998 goto phy_BB8190_Config_ParaFile_Fail
;
1001 /* 2. If EEPROM or EFUSE autoload OK, We must config by
1003 if (rtlefuse
->autoload_failflag
== false) {
1004 rtlphy
->pwrgroup_cnt
= 0;
1006 rtstatus
= _rtl92s_phy_config_bb_with_pg(hw
,
1007 BASEBAND_CONFIG_PHY_REG
);
1009 if (rtstatus
!= true) {
1010 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_EMERG
,
1011 "_rtl92s_phy_bb_config_parafile(): BB_PG Reg Fail!!\n");
1012 goto phy_BB8190_Config_ParaFile_Fail
;
1015 /* 3. BB AGC table Initialization */
1016 rtstatus
= _rtl92s_phy_config_bb(hw
, BASEBAND_CONFIG_AGC_TAB
);
1018 if (rtstatus
!= true) {
1019 pr_err("%s(): AGC Table Fail\n", __func__
);
1020 goto phy_BB8190_Config_ParaFile_Fail
;
1023 /* Check if the CCK HighPower is turned ON. */
1024 /* This is used to calculate PWDB. */
1025 rtlphy
->cck_high_power
= (bool)(rtl92s_phy_query_bb_reg(hw
,
1026 RFPGA0_XA_HSSIPARAMETER2
, 0x200));
1028 phy_BB8190_Config_ParaFile_Fail
:
1032 u8
rtl92s_phy_config_rf(struct ieee80211_hw
*hw
, enum radio_path rfpath
)
1034 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1035 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1037 bool rtstatus
= true;
1040 u16 radio_a_tblen
, radio_b_tblen
;
1042 radio_a_tblen
= RADIOA_1T_ARRAYLENGTH
;
1043 radio_a_table
= rtl8192seradioa_1t_array
;
1045 /* Using Green mode array table for RF_2T2R_GREEN */
1046 if (rtlphy
->rf_type
== RF_2T2R_GREEN
) {
1047 radio_b_table
= rtl8192seradiob_gm_array
;
1048 radio_b_tblen
= RADIOB_GM_ARRAYLENGTH
;
1050 radio_b_table
= rtl8192seradiob_array
;
1051 radio_b_tblen
= RADIOB_ARRAYLENGTH
;
1054 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
, "Radio No %x\n", rfpath
);
1059 for (i
= 0; i
< radio_a_tblen
; i
= i
+ 2) {
1060 if (radio_a_table
[i
] == 0xfe)
1061 /* Delay specific ms. Only RF configuration
1062 * requires delay. */
1064 else if (radio_a_table
[i
] == 0xfd)
1066 else if (radio_a_table
[i
] == 0xfc)
1068 else if (radio_a_table
[i
] == 0xfb)
1070 else if (radio_a_table
[i
] == 0xfa)
1072 else if (radio_a_table
[i
] == 0xf9)
1075 rtl92s_phy_set_rf_reg(hw
, rfpath
,
1078 radio_a_table
[i
+ 1]);
1080 /* Add delay for ECS T20 & LG malow platform */
1084 /* PA Bias current for inferiority IC */
1085 _rtl92s_phy_config_rfpa_bias_current(hw
, rfpath
);
1088 for (i
= 0; i
< radio_b_tblen
; i
= i
+ 2) {
1089 if (radio_b_table
[i
] == 0xfe)
1090 /* Delay specific ms. Only RF configuration
1093 else if (radio_b_table
[i
] == 0xfd)
1095 else if (radio_b_table
[i
] == 0xfc)
1097 else if (radio_b_table
[i
] == 0xfb)
1099 else if (radio_b_table
[i
] == 0xfa)
1101 else if (radio_b_table
[i
] == 0xf9)
1104 rtl92s_phy_set_rf_reg(hw
, rfpath
,
1107 radio_b_table
[i
+ 1]);
1109 /* Add delay for ECS T20 & LG malow platform */
1127 bool rtl92s_phy_mac_config(struct ieee80211_hw
*hw
)
1129 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1134 arraylength
= MAC_2T_ARRAYLENGTH
;
1135 ptraArray
= rtl8192semac_2t_array
;
1137 for (i
= 0; i
< arraylength
; i
= i
+ 2)
1138 rtl_write_byte(rtlpriv
, ptraArray
[i
], (u8
)ptraArray
[i
+ 1]);
1144 bool rtl92s_phy_bb_config(struct ieee80211_hw
*hw
)
1146 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1147 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1148 bool rtstatus
= true;
1149 u8 pathmap
, index
, rf_num
= 0;
1152 _rtl92s_phy_init_register_definition(hw
);
1154 /* Config BB and AGC */
1155 rtstatus
= _rtl92s_phy_bb_config_parafile(hw
);
1158 /* Check BB/RF confiuration setting. */
1159 /* We only need to configure RF which is turned on. */
1160 path1
= (u8
)(rtl92s_phy_query_bb_reg(hw
, RFPGA0_TXINFO
, 0xf));
1162 path2
= (u8
)(rtl92s_phy_query_bb_reg(hw
, ROFDM0_TRXPATHENABLE
, 0xf));
1163 pathmap
= path1
| path2
;
1165 rtlphy
->rf_pathmap
= pathmap
;
1166 for (index
= 0; index
< 4; index
++) {
1167 if ((pathmap
>> index
) & 0x1)
1171 if ((rtlphy
->rf_type
== RF_1T1R
&& rf_num
!= 1) ||
1172 (rtlphy
->rf_type
== RF_1T2R
&& rf_num
!= 2) ||
1173 (rtlphy
->rf_type
== RF_2T2R
&& rf_num
!= 2) ||
1174 (rtlphy
->rf_type
== RF_2T2R_GREEN
&& rf_num
!= 2)) {
1175 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_EMERG
,
1176 "RF_Type(%x) does not match RF_Num(%x)!!\n",
1177 rtlphy
->rf_type
, rf_num
);
1178 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_EMERG
,
1179 "path1 0x%x, path2 0x%x, pathmap 0x%x\n",
1180 path1
, path2
, pathmap
);
1186 bool rtl92s_phy_rf_config(struct ieee80211_hw
*hw
)
1188 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1189 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1191 /* Initialize general global value */
1192 if (rtlphy
->rf_type
== RF_1T1R
)
1193 rtlphy
->num_total_rfpath
= 1;
1195 rtlphy
->num_total_rfpath
= 2;
1197 /* Config BB and RF */
1198 return rtl92s_phy_rf6052_config(hw
);
1201 void rtl92s_phy_get_hw_reg_originalvalue(struct ieee80211_hw
*hw
)
1203 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1204 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1206 /* read rx initial gain */
1207 rtlphy
->default_initialgain
[0] = rtl_get_bbreg(hw
,
1208 ROFDM0_XAAGCCORE1
, MASKBYTE0
);
1209 rtlphy
->default_initialgain
[1] = rtl_get_bbreg(hw
,
1210 ROFDM0_XBAGCCORE1
, MASKBYTE0
);
1211 rtlphy
->default_initialgain
[2] = rtl_get_bbreg(hw
,
1212 ROFDM0_XCAGCCORE1
, MASKBYTE0
);
1213 rtlphy
->default_initialgain
[3] = rtl_get_bbreg(hw
,
1214 ROFDM0_XDAGCCORE1
, MASKBYTE0
);
1215 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1216 "Default initial gain (c50=0x%x, c58=0x%x, c60=0x%x, c68=0x%x)\n",
1217 rtlphy
->default_initialgain
[0],
1218 rtlphy
->default_initialgain
[1],
1219 rtlphy
->default_initialgain
[2],
1220 rtlphy
->default_initialgain
[3]);
1222 /* read framesync */
1223 rtlphy
->framesync
= rtl_get_bbreg(hw
, ROFDM0_RXDETECTOR3
, MASKBYTE0
);
1224 rtlphy
->framesync_c34
= rtl_get_bbreg(hw
, ROFDM0_RXDETECTOR2
,
1226 RT_TRACE(rtlpriv
, COMP_INIT
, DBG_LOUD
,
1227 "Default framesync (0x%x) = 0x%x\n",
1228 ROFDM0_RXDETECTOR3
, rtlphy
->framesync
);
1232 static void _rtl92s_phy_get_txpower_index(struct ieee80211_hw
*hw
, u8 channel
,
1233 u8
*cckpowerlevel
, u8
*ofdmpowerLevel
)
1235 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1236 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1237 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1238 u8 index
= (channel
- 1);
1242 cckpowerlevel
[0] = rtlefuse
->txpwrlevel_cck
[0][index
];
1244 cckpowerlevel
[1] = rtlefuse
->txpwrlevel_cck
[1][index
];
1246 /* 2. OFDM for 1T or 2T */
1247 if (rtlphy
->rf_type
== RF_1T2R
|| rtlphy
->rf_type
== RF_1T1R
) {
1248 /* Read HT 40 OFDM TX power */
1249 ofdmpowerLevel
[0] = rtlefuse
->txpwrlevel_ht40_1s
[0][index
];
1250 ofdmpowerLevel
[1] = rtlefuse
->txpwrlevel_ht40_1s
[1][index
];
1251 } else if (rtlphy
->rf_type
== RF_2T2R
) {
1252 /* Read HT 40 OFDM TX power */
1253 ofdmpowerLevel
[0] = rtlefuse
->txpwrlevel_ht40_2s
[0][index
];
1254 ofdmpowerLevel
[1] = rtlefuse
->txpwrlevel_ht40_2s
[1][index
];
1258 static void _rtl92s_phy_ccxpower_indexcheck(struct ieee80211_hw
*hw
,
1259 u8 channel
, u8
*cckpowerlevel
, u8
*ofdmpowerlevel
)
1261 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1262 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1264 rtlphy
->cur_cck_txpwridx
= cckpowerlevel
[0];
1265 rtlphy
->cur_ofdm24g_txpwridx
= ofdmpowerlevel
[0];
1268 void rtl92s_phy_set_txpower(struct ieee80211_hw
*hw
, u8 channel
)
1270 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1271 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1272 /* [0]:RF-A, [1]:RF-B */
1273 u8 cckpowerlevel
[2], ofdmpowerLevel
[2];
1275 if (rtlefuse
->txpwr_fromeprom
== false)
1278 /* Mainly we use RF-A Tx Power to write the Tx Power registers,
1279 * but the RF-B Tx Power must be calculated by the antenna diff.
1280 * So we have to rewrite Antenna gain offset register here.
1281 * Please refer to BB register 0x80c
1283 * 2. For OFDM 1T or 2T */
1284 _rtl92s_phy_get_txpower_index(hw
, channel
, &cckpowerlevel
[0],
1285 &ofdmpowerLevel
[0]);
1287 RT_TRACE(rtlpriv
, COMP_POWER
, DBG_LOUD
,
1288 "Channel-%d, cckPowerLevel (A / B) = 0x%x / 0x%x, ofdmPowerLevel (A / B) = 0x%x / 0x%x\n",
1289 channel
, cckpowerlevel
[0], cckpowerlevel
[1],
1290 ofdmpowerLevel
[0], ofdmpowerLevel
[1]);
1292 _rtl92s_phy_ccxpower_indexcheck(hw
, channel
, &cckpowerlevel
[0],
1293 &ofdmpowerLevel
[0]);
1295 rtl92s_phy_rf6052_set_ccktxpower(hw
, cckpowerlevel
[0]);
1296 rtl92s_phy_rf6052_set_ofdmtxpower(hw
, &ofdmpowerLevel
[0], channel
);
1300 void rtl92s_phy_chk_fwcmd_iodone(struct ieee80211_hw
*hw
)
1302 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1303 u16 pollingcnt
= 10000;
1306 /* Make sure that CMD IO has be accepted by FW. */
1310 tmpvalue
= rtl_read_dword(rtlpriv
, WFM5
);
1313 } while (--pollingcnt
);
1315 if (pollingcnt
== 0)
1316 RT_TRACE(rtlpriv
, COMP_ERR
, DBG_EMERG
, "Set FW Cmd fail!!\n");
1320 static void _rtl92s_phy_set_fwcmd_io(struct ieee80211_hw
*hw
)
1322 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1323 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1324 struct rtl_phy
*rtlphy
= &(rtlpriv
->phy
);
1325 u32 input
, current_aid
= 0;
1327 if (is_hal_stop(rtlhal
))
1330 /* We re-map RA related CMD IO to combinational ones */
1331 /* if FW version is v.52 or later. */
1332 switch (rtlhal
->current_fwcmd_io
) {
1333 case FW_CMD_RA_REFRESH_N
:
1334 rtlhal
->current_fwcmd_io
= FW_CMD_RA_REFRESH_N_COMB
;
1336 case FW_CMD_RA_REFRESH_BG
:
1337 rtlhal
->current_fwcmd_io
= FW_CMD_RA_REFRESH_BG_COMB
;
1343 switch (rtlhal
->current_fwcmd_io
) {
1344 case FW_CMD_RA_RESET
:
1345 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_RA_RESET\n");
1346 rtl_write_dword(rtlpriv
, WFM5
, FW_RA_RESET
);
1347 rtl92s_phy_chk_fwcmd_iodone(hw
);
1349 case FW_CMD_RA_ACTIVE
:
1350 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_RA_ACTIVE\n");
1351 rtl_write_dword(rtlpriv
, WFM5
, FW_RA_ACTIVE
);
1352 rtl92s_phy_chk_fwcmd_iodone(hw
);
1354 case FW_CMD_RA_REFRESH_N
:
1355 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_RA_REFRESH_N\n");
1356 input
= FW_RA_REFRESH
;
1357 rtl_write_dword(rtlpriv
, WFM5
, input
);
1358 rtl92s_phy_chk_fwcmd_iodone(hw
);
1359 rtl_write_dword(rtlpriv
, WFM5
, FW_RA_ENABLE_RSSI_MASK
);
1360 rtl92s_phy_chk_fwcmd_iodone(hw
);
1362 case FW_CMD_RA_REFRESH_BG
:
1363 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
,
1364 "FW_CMD_RA_REFRESH_BG\n");
1365 rtl_write_dword(rtlpriv
, WFM5
, FW_RA_REFRESH
);
1366 rtl92s_phy_chk_fwcmd_iodone(hw
);
1367 rtl_write_dword(rtlpriv
, WFM5
, FW_RA_DISABLE_RSSI_MASK
);
1368 rtl92s_phy_chk_fwcmd_iodone(hw
);
1370 case FW_CMD_RA_REFRESH_N_COMB
:
1371 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
,
1372 "FW_CMD_RA_REFRESH_N_COMB\n");
1373 input
= FW_RA_IOT_N_COMB
;
1374 rtl_write_dword(rtlpriv
, WFM5
, input
);
1375 rtl92s_phy_chk_fwcmd_iodone(hw
);
1377 case FW_CMD_RA_REFRESH_BG_COMB
:
1378 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
,
1379 "FW_CMD_RA_REFRESH_BG_COMB\n");
1380 input
= FW_RA_IOT_BG_COMB
;
1381 rtl_write_dword(rtlpriv
, WFM5
, input
);
1382 rtl92s_phy_chk_fwcmd_iodone(hw
);
1384 case FW_CMD_IQK_ENABLE
:
1385 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_IQK_ENABLE\n");
1386 rtl_write_dword(rtlpriv
, WFM5
, FW_IQK_ENABLE
);
1387 rtl92s_phy_chk_fwcmd_iodone(hw
);
1389 case FW_CMD_PAUSE_DM_BY_SCAN
:
1390 /* Lower initial gain */
1391 rtl_set_bbreg(hw
, ROFDM0_XAAGCCORE1
, MASKBYTE0
, 0x17);
1392 rtl_set_bbreg(hw
, ROFDM0_XBAGCCORE1
, MASKBYTE0
, 0x17);
1394 rtl_set_bbreg(hw
, RCCK0_CCA
, MASKBYTE2
, 0x40);
1396 case FW_CMD_RESUME_DM_BY_SCAN
:
1398 rtl_set_bbreg(hw
, RCCK0_CCA
, MASKBYTE2
, 0xcd);
1399 rtl92s_phy_set_txpower(hw
, rtlphy
->current_channel
);
1401 case FW_CMD_HIGH_PWR_DISABLE
:
1402 if (rtlpriv
->dm
.dm_flag
& HAL_DM_HIPWR_DISABLE
)
1405 /* Lower initial gain */
1406 rtl_set_bbreg(hw
, ROFDM0_XAAGCCORE1
, MASKBYTE0
, 0x17);
1407 rtl_set_bbreg(hw
, ROFDM0_XBAGCCORE1
, MASKBYTE0
, 0x17);
1409 rtl_set_bbreg(hw
, RCCK0_CCA
, MASKBYTE2
, 0x40);
1411 case FW_CMD_HIGH_PWR_ENABLE
:
1412 if ((rtlpriv
->dm
.dm_flag
& HAL_DM_HIPWR_DISABLE
) ||
1413 rtlpriv
->dm
.dynamic_txpower_enable
)
1417 rtl_set_bbreg(hw
, RCCK0_CCA
, MASKBYTE2
, 0xcd);
1419 case FW_CMD_LPS_ENTER
:
1420 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_LPS_ENTER\n");
1421 current_aid
= rtlpriv
->mac80211
.assoc_id
;
1422 rtl_write_dword(rtlpriv
, WFM5
, (FW_LPS_ENTER
|
1423 ((current_aid
| 0xc000) << 8)));
1424 rtl92s_phy_chk_fwcmd_iodone(hw
);
1425 /* FW set TXOP disable here, so disable EDCA
1426 * turbo mode until driver leave LPS */
1428 case FW_CMD_LPS_LEAVE
:
1429 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_LPS_LEAVE\n");
1430 rtl_write_dword(rtlpriv
, WFM5
, FW_LPS_LEAVE
);
1431 rtl92s_phy_chk_fwcmd_iodone(hw
);
1433 case FW_CMD_ADD_A2_ENTRY
:
1434 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_DMESG
, "FW_CMD_ADD_A2_ENTRY\n");
1435 rtl_write_dword(rtlpriv
, WFM5
, FW_ADD_A2_ENTRY
);
1436 rtl92s_phy_chk_fwcmd_iodone(hw
);
1438 case FW_CMD_CTRL_DM_BY_DRIVER
:
1439 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1440 "FW_CMD_CTRL_DM_BY_DRIVER\n");
1441 rtl_write_dword(rtlpriv
, WFM5
, FW_CTRL_DM_BY_DRIVER
);
1442 rtl92s_phy_chk_fwcmd_iodone(hw
);
1449 rtl92s_phy_chk_fwcmd_iodone(hw
);
1451 /* Clear FW CMD operation flag. */
1452 rtlhal
->set_fwcmd_inprogress
= false;
1455 bool rtl92s_phy_set_fw_cmd(struct ieee80211_hw
*hw
, enum fwcmd_iotype fw_cmdio
)
1457 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1458 struct rtl_hal
*rtlhal
= rtl_hal(rtl_priv(hw
));
1459 struct rtl_efuse
*rtlefuse
= rtl_efuse(rtl_priv(hw
));
1460 u32 fw_param
= FW_CMD_IO_PARA_QUERY(rtlpriv
);
1461 u16 fw_cmdmap
= FW_CMD_IO_QUERY(rtlpriv
);
1462 bool bPostProcessing
= false;
1464 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1465 "Set FW Cmd(%#x), set_fwcmd_inprogress(%d)\n",
1466 fw_cmdio
, rtlhal
->set_fwcmd_inprogress
);
1469 /* We re-map to combined FW CMD ones if firmware version */
1470 /* is v.53 or later. */
1472 case FW_CMD_RA_REFRESH_N
:
1473 fw_cmdio
= FW_CMD_RA_REFRESH_N_COMB
;
1475 case FW_CMD_RA_REFRESH_BG
:
1476 fw_cmdio
= FW_CMD_RA_REFRESH_BG_COMB
;
1482 /* If firmware version is v.62 or later,
1483 * use FW_CMD_IO_SET for FW_CMD_CTRL_DM_BY_DRIVER */
1484 if (hal_get_firmwareversion(rtlpriv
) >= 0x3E) {
1485 if (fw_cmdio
== FW_CMD_CTRL_DM_BY_DRIVER
)
1486 fw_cmdio
= FW_CMD_CTRL_DM_BY_DRIVER_NEW
;
1490 /* We shall revise all FW Cmd IO into Reg0x364
1491 * DM map table in the future. */
1493 case FW_CMD_RA_INIT
:
1494 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
, "RA init!!\n");
1495 fw_cmdmap
|= FW_RA_INIT_CTL
;
1496 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1497 /* Clear control flag to sync with FW. */
1498 FW_CMD_IO_CLR(rtlpriv
, FW_RA_INIT_CTL
);
1500 case FW_CMD_DIG_DISABLE
:
1501 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1502 "Set DIG disable!!\n");
1503 fw_cmdmap
&= ~FW_DIG_ENABLE_CTL
;
1504 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1506 case FW_CMD_DIG_ENABLE
:
1507 case FW_CMD_DIG_RESUME
:
1508 if (!(rtlpriv
->dm
.dm_flag
& HAL_DM_DIG_DISABLE
)) {
1509 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1510 "Set DIG enable or resume!!\n");
1511 fw_cmdmap
|= (FW_DIG_ENABLE_CTL
| FW_SS_CTL
);
1512 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1515 case FW_CMD_DIG_HALT
:
1516 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1517 "Set DIG halt!!\n");
1518 fw_cmdmap
&= ~(FW_DIG_ENABLE_CTL
| FW_SS_CTL
);
1519 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1521 case FW_CMD_TXPWR_TRACK_THERMAL
: {
1523 fw_cmdmap
|= FW_PWR_TRK_CTL
;
1525 /* Clear FW parameter in terms of thermal parts. */
1526 fw_param
&= FW_PWR_TRK_PARAM_CLR
;
1528 thermalval
= rtlpriv
->dm
.thermalvalue
;
1529 fw_param
|= ((thermalval
<< 24) |
1530 (rtlefuse
->thermalmeter
[0] << 16));
1532 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1533 "Set TxPwr tracking!! FwCmdMap(%#x), FwParam(%#x)\n",
1534 fw_cmdmap
, fw_param
);
1536 FW_CMD_PARA_SET(rtlpriv
, fw_param
);
1537 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1539 /* Clear control flag to sync with FW. */
1540 FW_CMD_IO_CLR(rtlpriv
, FW_PWR_TRK_CTL
);
1543 /* The following FW CMDs are only compatible to
1545 case FW_CMD_RA_REFRESH_N_COMB
:
1546 fw_cmdmap
|= FW_RA_N_CTL
;
1548 /* Clear RA BG mode control. */
1549 fw_cmdmap
&= ~(FW_RA_BG_CTL
| FW_RA_INIT_CTL
);
1551 /* Clear FW parameter in terms of RA parts. */
1552 fw_param
&= FW_RA_PARAM_CLR
;
1554 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1555 "[FW CMD] [New Version] Set RA/IOT Comb in n mode!! FwCmdMap(%#x), FwParam(%#x)\n",
1556 fw_cmdmap
, fw_param
);
1558 FW_CMD_PARA_SET(rtlpriv
, fw_param
);
1559 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1561 /* Clear control flag to sync with FW. */
1562 FW_CMD_IO_CLR(rtlpriv
, FW_RA_N_CTL
);
1564 case FW_CMD_RA_REFRESH_BG_COMB
:
1565 fw_cmdmap
|= FW_RA_BG_CTL
;
1567 /* Clear RA n-mode control. */
1568 fw_cmdmap
&= ~(FW_RA_N_CTL
| FW_RA_INIT_CTL
);
1569 /* Clear FW parameter in terms of RA parts. */
1570 fw_param
&= FW_RA_PARAM_CLR
;
1572 FW_CMD_PARA_SET(rtlpriv
, fw_param
);
1573 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1575 /* Clear control flag to sync with FW. */
1576 FW_CMD_IO_CLR(rtlpriv
, FW_RA_BG_CTL
);
1578 case FW_CMD_IQK_ENABLE
:
1579 fw_cmdmap
|= FW_IQK_CTL
;
1580 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1581 /* Clear control flag to sync with FW. */
1582 FW_CMD_IO_CLR(rtlpriv
, FW_IQK_CTL
);
1584 /* The following FW CMD is compatible to v.62 or later. */
1585 case FW_CMD_CTRL_DM_BY_DRIVER_NEW
:
1586 fw_cmdmap
|= FW_DRIVER_CTRL_DM_CTL
;
1587 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1589 /* The followed FW Cmds needs post-processing later. */
1590 case FW_CMD_RESUME_DM_BY_SCAN
:
1591 fw_cmdmap
|= (FW_DIG_ENABLE_CTL
|
1592 FW_HIGH_PWR_ENABLE_CTL
|
1595 if (rtlpriv
->dm
.dm_flag
& HAL_DM_DIG_DISABLE
||
1596 !digtable
.dig_enable_flag
)
1597 fw_cmdmap
&= ~FW_DIG_ENABLE_CTL
;
1599 if ((rtlpriv
->dm
.dm_flag
& HAL_DM_HIPWR_DISABLE
) ||
1600 rtlpriv
->dm
.dynamic_txpower_enable
)
1601 fw_cmdmap
&= ~FW_HIGH_PWR_ENABLE_CTL
;
1603 if ((digtable
.dig_ext_port_stage
==
1604 DIG_EXT_PORT_STAGE_0
) ||
1605 (digtable
.dig_ext_port_stage
==
1606 DIG_EXT_PORT_STAGE_1
))
1607 fw_cmdmap
&= ~FW_DIG_ENABLE_CTL
;
1609 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1610 bPostProcessing
= true;
1612 case FW_CMD_PAUSE_DM_BY_SCAN
:
1613 fw_cmdmap
&= ~(FW_DIG_ENABLE_CTL
|
1614 FW_HIGH_PWR_ENABLE_CTL
|
1616 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1617 bPostProcessing
= true;
1619 case FW_CMD_HIGH_PWR_DISABLE
:
1620 fw_cmdmap
&= ~FW_HIGH_PWR_ENABLE_CTL
;
1621 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1622 bPostProcessing
= true;
1624 case FW_CMD_HIGH_PWR_ENABLE
:
1625 if (!(rtlpriv
->dm
.dm_flag
& HAL_DM_HIPWR_DISABLE
) &&
1626 (rtlpriv
->dm
.dynamic_txpower_enable
!= true)) {
1627 fw_cmdmap
|= (FW_HIGH_PWR_ENABLE_CTL
|
1629 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1630 bPostProcessing
= true;
1633 case FW_CMD_DIG_MODE_FA
:
1634 fw_cmdmap
|= FW_FA_CTL
;
1635 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1637 case FW_CMD_DIG_MODE_SS
:
1638 fw_cmdmap
&= ~FW_FA_CTL
;
1639 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1641 case FW_CMD_PAPE_CONTROL
:
1642 RT_TRACE(rtlpriv
, COMP_CMD
, DBG_LOUD
,
1643 "[FW CMD] Set PAPE Control\n");
1644 fw_cmdmap
&= ~FW_PAPE_CTL_BY_SW_HW
;
1646 FW_CMD_IO_SET(rtlpriv
, fw_cmdmap
);
1649 /* Pass to original FW CMD processing callback
1651 bPostProcessing
= true;
1656 /* We shall post processing these FW CMD if
1657 * variable bPostProcessing is set. */
1658 if (bPostProcessing
&& !rtlhal
->set_fwcmd_inprogress
) {
1659 rtlhal
->set_fwcmd_inprogress
= true;
1660 /* Update current FW Cmd for callback use. */
1661 rtlhal
->current_fwcmd_io
= fw_cmdio
;
1666 _rtl92s_phy_set_fwcmd_io(hw
);
1670 static void _rtl92s_phy_check_ephy_switchready(struct ieee80211_hw
*hw
)
1672 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1676 regu1
= rtl_read_byte(rtlpriv
, 0x554);
1677 while ((regu1
& BIT(5)) && (delay
> 0)) {
1678 regu1
= rtl_read_byte(rtlpriv
, 0x554);
1680 /* We delay only 50us to prevent
1681 * being scheduled out. */
1686 void rtl92s_phy_switch_ephy_parameter(struct ieee80211_hw
*hw
)
1688 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1689 struct rtl_ps_ctl
*ppsc
= rtl_psc(rtl_priv(hw
));
1691 /* The way to be capable to switch clock request
1692 * when the PG setting does not support clock request.
1693 * This is the backdoor solution to switch clock
1694 * request before ASPM or D3. */
1695 rtl_write_dword(rtlpriv
, 0x540, 0x73c11);
1696 rtl_write_dword(rtlpriv
, 0x548, 0x2407c);
1698 /* Switch EPHY parameter!!!! */
1699 rtl_write_word(rtlpriv
, 0x550, 0x1000);
1700 rtl_write_byte(rtlpriv
, 0x554, 0x20);
1701 _rtl92s_phy_check_ephy_switchready(hw
);
1703 rtl_write_word(rtlpriv
, 0x550, 0xa0eb);
1704 rtl_write_byte(rtlpriv
, 0x554, 0x3e);
1705 _rtl92s_phy_check_ephy_switchready(hw
);
1707 rtl_write_word(rtlpriv
, 0x550, 0xff80);
1708 rtl_write_byte(rtlpriv
, 0x554, 0x39);
1709 _rtl92s_phy_check_ephy_switchready(hw
);
1711 /* Delay L1 enter time */
1712 if (ppsc
->support_aspm
&& !ppsc
->support_backdoor
)
1713 rtl_write_byte(rtlpriv
, 0x560, 0x40);
1715 rtl_write_byte(rtlpriv
, 0x560, 0x00);
1719 void rtl92s_phy_set_beacon_hwreg(struct ieee80211_hw
*hw
, u16 BeaconInterval
)
1721 struct rtl_priv
*rtlpriv
= rtl_priv(hw
);
1722 rtl_write_dword(rtlpriv
, WFM5
, 0xF1000000 | (BeaconInterval
<< 8));