github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-06-01 02:53:36 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

rtw-next patches for v6.11

Browse Source 
Some fixes and refactors of rtlwifi, rtw88 and rtw89. Only one major change
 listed below:
 
 rtlwifi:
  - add new chip support of RTL8192DU
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCgAdFiEEuyEnvMdOsBl1WjpdjlvZYmhshd8FAmZecvoACgkQjlvZYmhs
 hd9zfQ//ZdUjUqjIYZX7fWtWy5WLYbDXus/ky8e4jdR7vR2LQg7OJca658n9LjwG
 L7Nwsh3quLXOLvNVZREsbJhXswNmk62TvtTxH9nT8jNioNCnqUQg0dDH5dCwmZZz
 uAD+ypwdA5oON6knyE90Rp1Tx+SJkgi029VarUbajUJ9Awi8wd2tsv/jtPxM6ZQF
 BtX0JdQpVrYP/lsZeFhs/jsFhKr1rIBn/1xPW/exq0yNAi2xkEJlrRqgA/YLdwkJ
 yEC9lIq9wwGFs7Qhm6/twIj6PC387AIHx4ccdvlIy07H6ZAgsQdCqQsudcdqBxeQ
 MllJ3g9c43mDiVbmzZYjLwqPosvnNnOXie7B6uzWwyzbJx1b65Wz4w7w7WdNo6bp
 foh7bYjhtmwdydBF53UDv6kuepY7JR3spSuoN4xA32fMdSO3GPLb18m+GsOK//IN
 a0XjUTH6i12HSiZgPeR9okbOoEvpT56EL5Z1FjzLPQX8+GLZAr/UCybOo0sRNcEy
 dZ5kXiAfXKaBJRoO0uFJ0iCgbhcYH44WMI0ubw+B3m5SaNQMdLYNxXLyv/b6lNnj
 EyJHjZcwQWu2KHDLmF0c+mcchCuff+rg6r5OvWpnuM8YzoEJu0RithugQ6oWYZ9r
 blIo9MNkDhkrTbvZW5NoeqMaFxs1VJoA/UUrHEdjkqbLo0fXUdg=
 =tWr4
 -----END PGP SIGNATURE-----

Merge tag 'rtw-next-2024-06-04' of https://github.com/pkshih/rtw

rtw-next patches for v6.11

Some fixes and refactors of rtlwifi, rtw88 and rtw89. Only one major change
listed below:

rtlwifi:
 - add new chip support of RTL8192DU
This commit is contained in:
Kalle Valo 2024-06-05 21:23:16 +03:00
commit f29dcae96e
52 changed files with 7870 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
drivers/net/wireless/realtek/rtlwifi/Kconfig
View File

@ -119,6 +119,18 @@ config RTL8192CU
If you choose to build it as a module, it will be called rtl8192cu
config RTL8192DU
tristate "Realtek RTL8192DU USB Wireless Network Adapter"
depends on USB
select RTLWIFI
select RTLWIFI_USB
select RTL8192D_COMMON
help
This is the driver for Realtek RTL8192DU 802.11n USB
wireless network adapters.
If you choose to build it as a module, it will be called rtl8192du
config RTLWIFI
tristate
select FW_LOADER

1
drivers/net/wireless/realtek/rtlwifi/Makefile
View File

@ -25,6 +25,7 @@ obj-$(CONFIG_RTL8192CU) += rtl8192cu/
obj-$(CONFIG_RTL8192SE) += rtl8192se/
obj-$(CONFIG_RTL8192D_COMMON) += rtl8192d/
obj-$(CONFIG_RTL8192DE) += rtl8192de/
obj-$(CONFIG_RTL8192DU) += rtl8192du/
obj-$(CONFIG_RTL8723AE) += rtl8723ae/
obj-$(CONFIG_RTL8723BE) += rtl8723be/
obj-$(CONFIG_RTL8188EE) += rtl8188ee/

2
drivers/net/wireless/realtek/rtlwifi/base.c
View File

@ -2272,7 +2272,7 @@ static void rtl_c2h_content_parsing(struct ieee80211_hw *hw,
struct sk_buff *skb)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal_ops *hal_ops = rtlpriv->cfg->ops;
const struct rtl_hal_ops *hal_ops = rtlpriv->cfg->ops;
const struct rtl_btc_ops *btc_ops = rtlpriv->btcoexist.btc_ops;
u8 cmd_id, cmd_len;
u8 *cmd_buf = NULL;

3
drivers/net/wireless/realtek/rtlwifi/rtl8192cu/sw.c
View File

@ -53,8 +53,6 @@ static int rtl92cu_init_sw_vars(struct ieee80211_hw *hw)
} else {
fw_name = "rtlwifi/rtl8192cufw_TMSC.bin";
}
/* provide name of alternative file */
rtlpriv->cfg->alt_fw_name = "rtlwifi/rtl8192cufw.bin";
pr_info("Loading firmware %s\n", fw_name);
rtlpriv->max_fw_size = 0x4000;
err = request_firmware_nowait(THIS_MODULE, 1,
@ -160,6 +158,7 @@ static struct rtl_hal_usbint_cfg rtl92cu_interface_cfg = {
static struct rtl_hal_cfg rtl92cu_hal_cfg = {
.name = "rtl92c_usb",
.alt_fw_name = "rtlwifi/rtl8192cufw.bin",
.ops = &rtl8192cu_hal_ops,
.mod_params = &rtl92cu_mod_params,
.usb_interface_cfg = &rtl92cu_interface_cfg,

94
drivers/net/wireless/realtek/rtlwifi/rtl8192d/hw_common.c
View File

@ -14,7 +14,7 @@
#include "hw_common.h"
#include "phy_common.h"
void rtl92de_stop_tx_beacon(struct ieee80211_hw *hw)
void rtl92d_stop_tx_beacon(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
u8 tmp1byte;
@ -27,9 +27,9 @@ void rtl92de_stop_tx_beacon(struct ieee80211_hw *hw)
tmp1byte &= ~(BIT(0));
rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte);
}
EXPORT_SYMBOL_GPL(rtl92de_stop_tx_beacon);
EXPORT_SYMBOL_GPL(rtl92d_stop_tx_beacon);
void rtl92de_resume_tx_beacon(struct ieee80211_hw *hw)
void rtl92d_resume_tx_beacon(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
u8 tmp1byte;
@ -42,7 +42,7 @@ void rtl92de_resume_tx_beacon(struct ieee80211_hw *hw)
tmp1byte |= BIT(0);
rtl_write_byte(rtlpriv, REG_TBTT_PROHIBIT + 2, tmp1byte);
}
EXPORT_SYMBOL_GPL(rtl92de_resume_tx_beacon);
EXPORT_SYMBOL_GPL(rtl92d_resume_tx_beacon);
void rtl92d_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
{
@ -285,7 +285,7 @@ void rtl92d_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
}
EXPORT_SYMBOL_GPL(rtl92d_set_hw_reg);
bool rtl92de_llt_write(struct ieee80211_hw *hw, u32 address, u32 data)
bool rtl92d_llt_write(struct ieee80211_hw *hw, u32 address, u32 data)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
bool status = true;
@ -307,9 +307,9 @@ bool rtl92de_llt_write(struct ieee80211_hw *hw, u32 address, u32 data)
} while (++count);
return status;
}
EXPORT_SYMBOL_GPL(rtl92de_llt_write);
EXPORT_SYMBOL_GPL(rtl92d_llt_write);
void rtl92de_enable_hw_security_config(struct ieee80211_hw *hw)
void rtl92d_enable_hw_security_config(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
u8 sec_reg_value;
@ -334,16 +334,16 @@ void rtl92de_enable_hw_security_config(struct ieee80211_hw *hw)
"The SECR-value %x\n", sec_reg_value);
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_WPA_CONFIG, &sec_reg_value);
}
EXPORT_SYMBOL_GPL(rtl92de_enable_hw_security_config);
EXPORT_SYMBOL_GPL(rtl92d_enable_hw_security_config);
/* don't set REG_EDCA_BE_PARAM here because
* mac80211 will send pkt when scan
*/
void rtl92de_set_qos(struct ieee80211_hw *hw, int aci)
void rtl92d_set_qos(struct ieee80211_hw *hw, int aci)
{
rtl92d_dm_init_edca_turbo(hw);
}
EXPORT_SYMBOL_GPL(rtl92de_set_qos);
EXPORT_SYMBOL_GPL(rtl92d_set_qos);
static enum version_8192d _rtl92d_read_chip_version(struct ieee80211_hw *hw)
{
@ -362,8 +362,8 @@ static enum version_8192d _rtl92d_read_chip_version(struct ieee80211_hw *hw)
return version;
}
static void _rtl92de_readpowervalue_fromprom(struct txpower_info *pwrinfo,
u8 *efuse, bool autoloadfail)
static void _rtl92d_readpowervalue_fromprom(struct txpower_info *pwrinfo,
u8 *efuse, bool autoloadfail)
{
u32 rfpath, eeaddr, group, offset, offset1, offset2;
u8 i, val8;
@ -500,8 +500,8 @@ static void _rtl92de_readpowervalue_fromprom(struct txpower_info *pwrinfo,
}
}
static void _rtl92de_read_txpower_info(struct ieee80211_hw *hw,
bool autoload_fail, u8 *hwinfo)
static void _rtl92d_read_txpower_info(struct ieee80211_hw *hw,
bool autoload_fail, u8 *hwinfo)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
@ -509,7 +509,7 @@ static void _rtl92de_read_txpower_info(struct ieee80211_hw *hw,
u8 tempval[2], i, pwr, diff;
u32 ch, rfpath, group;
_rtl92de_readpowervalue_fromprom(&pwrinfo, hwinfo, autoload_fail);
_rtl92d_readpowervalue_fromprom(&pwrinfo, hwinfo, autoload_fail);
if (!autoload_fail) {
/* bit0~2 */
rtlefuse->eeprom_regulatory = (hwinfo[EEPROM_RF_OPT1] & 0x7);
@ -613,8 +613,8 @@ static void _rtl92de_read_txpower_info(struct ieee80211_hw *hw,
}
}
static void _rtl92de_read_macphymode_from_prom(struct ieee80211_hw *hw,
u8 *content)
static void _rtl92d_read_macphymode_from_prom(struct ieee80211_hw *hw,
u8 *content)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
@ -636,15 +636,15 @@ static void _rtl92de_read_macphymode_from_prom(struct ieee80211_hw *hw,
}
}
static void _rtl92de_read_macphymode_and_bandtype(struct ieee80211_hw *hw,
u8 *content)
static void _rtl92d_read_macphymode_and_bandtype(struct ieee80211_hw *hw,
u8 *content)
{
_rtl92de_read_macphymode_from_prom(hw, content);
_rtl92d_read_macphymode_from_prom(hw, content);
rtl92d_phy_config_macphymode(hw);
rtl92d_phy_config_macphymode_info(hw);
}
static void _rtl92de_efuse_update_chip_version(struct ieee80211_hw *hw)
static void _rtl92d_efuse_update_chip_version(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
enum version_8192d chipver = rtlpriv->rtlhal.version;
@ -676,7 +676,7 @@ static void _rtl92de_efuse_update_chip_version(struct ieee80211_hw *hw)
rtlpriv->rtlhal.version = chipver;
}
static void _rtl92de_read_adapter_info(struct ieee80211_hw *hw)
static void _rtl92d_read_adapter_info(struct ieee80211_hw *hw)
{
static const int params_pci[] = {
RTL8190_EEPROM_ID, EEPROM_VID, EEPROM_DID,
@ -706,8 +706,8 @@ static void _rtl92de_read_adapter_info(struct ieee80211_hw *hw)
if (rtl_get_hwinfo(hw, rtlpriv, HWSET_MAX_SIZE, hwinfo, params))
goto exit;
_rtl92de_efuse_update_chip_version(hw);
_rtl92de_read_macphymode_and_bandtype(hw, hwinfo);
_rtl92d_efuse_update_chip_version(hw);
_rtl92d_read_macphymode_and_bandtype(hw, hwinfo);
/* Read Permanent MAC address for 2nd interface */
if (rtlhal->interfaceindex != 0)
@ -717,7 +717,7 @@ static void _rtl92de_read_adapter_info(struct ieee80211_hw *hw)
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ETHER_ADDR,
rtlefuse->dev_addr);
rtl_dbg(rtlpriv, COMP_INIT, DBG_DMESG, "%pM\n", rtlefuse->dev_addr);
_rtl92de_read_txpower_info(hw, rtlefuse->autoload_failflag, hwinfo);
_rtl92d_read_txpower_info(hw, rtlefuse->autoload_failflag, hwinfo);
/* Read Channel Plan */
switch (rtlhal->bandset) {
@ -739,7 +739,7 @@ static void _rtl92de_read_adapter_info(struct ieee80211_hw *hw)
kfree(hwinfo);
}
void rtl92de_read_eeprom_info(struct ieee80211_hw *hw)
void rtl92d_read_eeprom_info(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
@ -760,15 +760,15 @@ void rtl92de_read_eeprom_info(struct ieee80211_hw *hw)
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "Autoload OK\n");
rtlefuse->autoload_failflag = false;
_rtl92de_read_adapter_info(hw);
_rtl92d_read_adapter_info(hw);
} else {
pr_err("Autoload ERR!!\n");
}
}
EXPORT_SYMBOL_GPL(rtl92de_read_eeprom_info);
EXPORT_SYMBOL_GPL(rtl92d_read_eeprom_info);
static void rtl92de_update_hal_rate_table(struct ieee80211_hw *hw,
struct ieee80211_sta *sta)
static void rtl92d_update_hal_rate_table(struct ieee80211_hw *hw,
struct ieee80211_sta *sta)
{
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
@ -851,9 +851,9 @@ static void rtl92de_update_hal_rate_table(struct ieee80211_hw *hw,
rtl_read_dword(rtlpriv, REG_ARFR0));
}
static void rtl92de_update_hal_rate_mask(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw)
static void rtl92d_update_hal_rate_mask(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw)
{
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
@ -1009,20 +1009,20 @@ static void rtl92de_update_hal_rate_mask(struct ieee80211_hw *hw,
sta_entry->ratr_index = ratr_index;
}
void rtl92de_update_hal_rate_tbl(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw)
void rtl92d_update_hal_rate_tbl(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
if (rtlpriv->dm.useramask)
rtl92de_update_hal_rate_mask(hw, sta, rssi_level, update_bw);
rtl92d_update_hal_rate_mask(hw, sta, rssi_level, update_bw);
else
rtl92de_update_hal_rate_table(hw, sta);
rtl92d_update_hal_rate_table(hw, sta);
}
EXPORT_SYMBOL_GPL(rtl92de_update_hal_rate_tbl);
EXPORT_SYMBOL_GPL(rtl92d_update_hal_rate_tbl);
void rtl92de_update_channel_access_setting(struct ieee80211_hw *hw)
void rtl92d_update_channel_access_setting(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
@ -1036,9 +1036,9 @@ void rtl92de_update_channel_access_setting(struct ieee80211_hw *hw)
sifs_timer = 0x1010;
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SIFS, (u8 *)&sifs_timer);
}
EXPORT_SYMBOL_GPL(rtl92de_update_channel_access_setting);
EXPORT_SYMBOL_GPL(rtl92d_update_channel_access_setting);
bool rtl92de_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
bool rtl92d_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
@ -1093,11 +1093,11 @@ bool rtl92de_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid)
*valid = 1;
return !ppsc->hwradiooff;
}
EXPORT_SYMBOL_GPL(rtl92de_gpio_radio_on_off_checking);
EXPORT_SYMBOL_GPL(rtl92d_gpio_radio_on_off_checking);
void rtl92de_set_key(struct ieee80211_hw *hw, u32 key_index,
u8 *p_macaddr, bool is_group, u8 enc_algo,
bool is_wepkey, bool clear_all)
void rtl92d_set_key(struct ieee80211_hw *hw, u32 key_index,
u8 *p_macaddr, bool is_group, u8 enc_algo,
bool is_wepkey, bool clear_all)
{
static const u8 cam_const_addr[4][6] = {
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
@ -1222,4 +1222,4 @@ void rtl92de_set_key(struct ieee80211_hw *hw, u32 key_index,
}
}
}
EXPORT_SYMBOL_GPL(rtl92de_set_key);
EXPORT_SYMBOL_GPL(rtl92d_set_key);

28
drivers/net/wireless/realtek/rtlwifi/rtl8192d/hw_common.h
View File

@ -4,21 +4,21 @@
#ifndef __RTL92D_HW_COMMON_H__
#define __RTL92D_HW_COMMON_H__
void rtl92de_stop_tx_beacon(struct ieee80211_hw *hw);
void rtl92de_resume_tx_beacon(struct ieee80211_hw *hw);
void rtl92d_stop_tx_beacon(struct ieee80211_hw *hw);
void rtl92d_resume_tx_beacon(struct ieee80211_hw *hw);
void rtl92d_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val);
void rtl92d_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val);
bool rtl92de_llt_write(struct ieee80211_hw *hw, u32 address, u32 data);
void rtl92de_enable_hw_security_config(struct ieee80211_hw *hw);
void rtl92de_set_qos(struct ieee80211_hw *hw, int aci);
void rtl92de_read_eeprom_info(struct ieee80211_hw *hw);
void rtl92de_update_hal_rate_tbl(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw);
void rtl92de_update_channel_access_setting(struct ieee80211_hw *hw);
bool rtl92de_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid);
void rtl92de_set_key(struct ieee80211_hw *hw, u32 key_index,
u8 *p_macaddr, bool is_group, u8 enc_algo,
bool is_wepkey, bool clear_all);
bool rtl92d_llt_write(struct ieee80211_hw *hw, u32 address, u32 data);
void rtl92d_enable_hw_security_config(struct ieee80211_hw *hw);
void rtl92d_set_qos(struct ieee80211_hw *hw, int aci);
void rtl92d_read_eeprom_info(struct ieee80211_hw *hw);
void rtl92d_update_hal_rate_tbl(struct ieee80211_hw *hw,
struct ieee80211_sta *sta,
u8 rssi_level, bool update_bw);
void rtl92d_update_channel_access_setting(struct ieee80211_hw *hw);
bool rtl92d_gpio_radio_on_off_checking(struct ieee80211_hw *hw, u8 *valid);
void rtl92d_set_key(struct ieee80211_hw *hw, u32 key_index,
u8 *p_macaddr, bool is_group, u8 enc_algo,
bool is_wepkey, bool clear_all);
#endif

92
drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.c
View File

@ -7,8 +7,8 @@
#include "def.h"
#include "trx_common.h"
static long _rtl92de_translate_todbm(struct ieee80211_hw *hw,
u8 signal_strength_index)
static long _rtl92d_translate_todbm(struct ieee80211_hw *hw,
u8 signal_strength_index)
{
long signal_power;
@ -17,13 +17,13 @@ static long _rtl92de_translate_todbm(struct ieee80211_hw *hw,
return signal_power;
}
static void _rtl92de_query_rxphystatus(struct ieee80211_hw *hw,
struct rtl_stats *pstats,
__le32 *pdesc,
struct rx_fwinfo_92d *p_drvinfo,
bool packet_match_bssid,
bool packet_toself,
bool packet_beacon)
static void _rtl92d_query_rxphystatus(struct ieee80211_hw *hw,
struct rtl_stats *pstats,
__le32 *pdesc,
struct rx_fwinfo_92d *p_drvinfo,
bool packet_match_bssid,
bool packet_toself,
bool packet_beacon)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_phy *rtlphy = &rtlpriv->phy;
@ -203,8 +203,8 @@ static void rtl92d_loop_over_paths(struct ieee80211_hw *hw,
}
}
static void _rtl92de_process_ui_rssi(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
static void _rtl92d_process_ui_rssi(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rt_smooth_data *ui_rssi;
@ -226,15 +226,15 @@ static void _rtl92de_process_ui_rssi(struct ieee80211_hw *hw,
if (ui_rssi->index >= PHY_RSSI_SLID_WIN_MAX)
ui_rssi->index = 0;
tmpval = ui_rssi->total_val / ui_rssi->total_num;
rtlpriv->stats.signal_strength = _rtl92de_translate_todbm(hw, (u8)tmpval);
rtlpriv->stats.signal_strength = _rtl92d_translate_todbm(hw, (u8)tmpval);
pstats->rssi = rtlpriv->stats.signal_strength;
if (!pstats->is_cck && pstats->packet_toself)
rtl92d_loop_over_paths(hw, pstats);
}
static void _rtl92de_update_rxsignalstatistics(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
static void _rtl92d_update_rxsignalstatistics(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
int weighting = 0;
@ -249,8 +249,8 @@ static void _rtl92de_update_rxsignalstatistics(struct ieee80211_hw *hw,
5 + pstats->recvsignalpower + weighting) / 6;
}
static void _rtl92de_process_pwdb(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
static void _rtl92d_process_pwdb(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
@ -276,7 +276,7 @@ static void _rtl92de_process_pwdb(struct ieee80211_hw *hw,
(pstats->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
}
rtlpriv->dm.undec_sm_pwdb = undec_sm_pwdb;
_rtl92de_update_rxsignalstatistics(hw, pstats);
_rtl92d_update_rxsignalstatistics(hw, pstats);
}
}
@ -301,8 +301,8 @@ static void rtl92d_loop_over_streams(struct ieee80211_hw *hw,
}
}
static void _rtl92de_process_ui_link_quality(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
static void _rtl92d_process_ui_link_quality(struct ieee80211_hw *hw,
struct rtl_stats *pstats)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rt_smooth_data *ui_link_quality;
@ -330,24 +330,24 @@ static void _rtl92de_process_ui_link_quality(struct ieee80211_hw *hw,
rtl92d_loop_over_streams(hw, pstats);
}
static void _rtl92de_process_phyinfo(struct ieee80211_hw *hw,
u8 *buffer,
struct rtl_stats *pcurrent_stats)
static void _rtl92d_process_phyinfo(struct ieee80211_hw *hw,
u8 *buffer,
struct rtl_stats *pcurrent_stats)
{
if (!pcurrent_stats->packet_matchbssid &&
!pcurrent_stats->packet_beacon)
return;
_rtl92de_process_ui_rssi(hw, pcurrent_stats);
_rtl92de_process_pwdb(hw, pcurrent_stats);
_rtl92de_process_ui_link_quality(hw, pcurrent_stats);
_rtl92d_process_ui_rssi(hw, pcurrent_stats);
_rtl92d_process_pwdb(hw, pcurrent_stats);
_rtl92d_process_ui_link_quality(hw, pcurrent_stats);
}
static void _rtl92de_translate_rx_signal_stuff(struct ieee80211_hw *hw,
struct sk_buff *skb,
struct rtl_stats *pstats,
__le32 *pdesc,
struct rx_fwinfo_92d *p_drvinfo)
static void _rtl92d_translate_rx_signal_stuff(struct ieee80211_hw *hw,
struct sk_buff *skb,
struct rtl_stats *pstats,
__le32 *pdesc,
struct rx_fwinfo_92d *p_drvinfo)
{
struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
@ -375,15 +375,15 @@ static void _rtl92de_translate_rx_signal_stuff(struct ieee80211_hw *hw,
packet_toself = packet_matchbssid &&
ether_addr_equal(praddr, rtlefuse->dev_addr);
packet_beacon = ieee80211_is_beacon(fc);
_rtl92de_query_rxphystatus(hw, pstats, pdesc, p_drvinfo,
packet_matchbssid, packet_toself,
packet_beacon);
_rtl92de_process_phyinfo(hw, tmp_buf, pstats);
_rtl92d_query_rxphystatus(hw, pstats, pdesc, p_drvinfo,
packet_matchbssid, packet_toself,
packet_beacon);
_rtl92d_process_phyinfo(hw, tmp_buf, pstats);
}
bool rtl92de_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *stats,
struct ieee80211_rx_status *rx_status,
u8 *pdesc8, struct sk_buff *skb)
bool rtl92d_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *stats,
struct ieee80211_rx_status *rx_status,
u8 *pdesc8, struct sk_buff *skb)
{
__le32 *pdesc = (__le32 *)pdesc8;
struct rx_fwinfo_92d *p_drvinfo;
@ -423,17 +423,17 @@ bool rtl92de_rx_query_desc(struct ieee80211_hw *hw, struct rtl_stats *stats,
if (phystatus) {
p_drvinfo = (struct rx_fwinfo_92d *)(skb->data +
stats->rx_bufshift);
_rtl92de_translate_rx_signal_stuff(hw, skb, stats, pdesc,
p_drvinfo);
_rtl92d_translate_rx_signal_stuff(hw, skb, stats, pdesc,
p_drvinfo);
}
/*rx_status->qual = stats->signal; */
rx_status->signal = stats->recvsignalpower + 10;
return true;
}
EXPORT_SYMBOL_GPL(rtl92de_rx_query_desc);
EXPORT_SYMBOL_GPL(rtl92d_rx_query_desc);
void rtl92de_set_desc(struct ieee80211_hw *hw, u8 *pdesc8, bool istx,
u8 desc_name, u8 *val)
void rtl92d_set_desc(struct ieee80211_hw *hw, u8 *pdesc8, bool istx,
u8 desc_name, u8 *val)
{
__le32 *pdesc = (__le32 *)pdesc8;
@ -473,10 +473,10 @@ void rtl92de_set_desc(struct ieee80211_hw *hw, u8 *pdesc8, bool istx,
}
}
}
EXPORT_SYMBOL_GPL(rtl92de_set_desc);
EXPORT_SYMBOL_GPL(rtl92d_set_desc);
u64 rtl92de_get_desc(struct ieee80211_hw *hw,
u8 *p_desc8, bool istx, u8 desc_name)
u64 rtl92d_get_desc(struct ieee80211_hw *hw,
u8 *p_desc8, bool istx, u8 desc_name)
{
__le32 *p_desc = (__le32 *)p_desc8;
u32 ret = 0;
@ -513,4 +513,4 @@ u64 rtl92de_get_desc(struct ieee80211_hw *hw,
}
return ret;
}
EXPORT_SYMBOL_GPL(rtl92de_get_desc);
EXPORT_SYMBOL_GPL(rtl92d_get_desc);

16
drivers/net/wireless/realtek/rtlwifi/rtl8192d/trx_common.h
View File

@ -393,13 +393,13 @@ struct rx_fwinfo_92d {
#endif
} __packed;
bool rtl92de_rx_query_desc(struct ieee80211_hw *hw,
struct rtl_stats *stats,
struct ieee80211_rx_status *rx_status,
u8 *pdesc, struct sk_buff *skb);
void rtl92de_set_desc(struct ieee80211_hw *hw, u8 *pdesc, bool istx,
u8 desc_name, u8 *val);
u64 rtl92de_get_desc(struct ieee80211_hw *hw,
u8 *p_desc, bool istx, u8 desc_name);
bool rtl92d_rx_query_desc(struct ieee80211_hw *hw,
struct rtl_stats *stats,
struct ieee80211_rx_status *rx_status,
u8 *pdesc, struct sk_buff *skb);
void rtl92d_set_desc(struct ieee80211_hw *hw, u8 *pdesc, bool istx,
u8 desc_name, u8 *val);
u64 rtl92d_get_desc(struct ieee80211_hw *hw,
u8 *p_desc, bool istx, u8 desc_name);
#endif

18
drivers/net/wireless/realtek/rtlwifi/rtl8192de/hw.c
View File

@ -181,7 +181,7 @@ void rtl92de_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
u8 btype_ibss = val[0];
if (btype_ibss)
rtl92de_stop_tx_beacon(hw);
rtl92d_stop_tx_beacon(hw);
_rtl92de_set_bcn_ctrl_reg(hw, 0, BIT(3));
rtl_write_dword(rtlpriv, REG_TSFTR,
(u32) (mac->tsf & 0xffffffff));
@ -189,7 +189,7 @@ void rtl92de_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
(u32) ((mac->tsf >> 32) & 0xffffffff));
_rtl92de_set_bcn_ctrl_reg(hw, BIT(3), 0);
if (btype_ibss)
rtl92de_resume_tx_beacon(hw);
rtl92d_resume_tx_beacon(hw);
break;
}
@ -295,13 +295,13 @@ static bool _rtl92de_llt_table_init(struct ieee80211_hw *hw)
/* 18. LLT_table_init(Adapter); */
for (i = 0; i < (txpktbuf_bndy - 1); i++) {
status = rtl92de_llt_write(hw, i, i + 1);
status = rtl92d_llt_write(hw, i, i + 1);
if (!status)
return status;
}
/* end of list */
status = rtl92de_llt_write(hw, (txpktbuf_bndy - 1), 0xFF);
status = rtl92d_llt_write(hw, (txpktbuf_bndy - 1), 0xFF);
if (!status)
return status;
@ -310,13 +310,13 @@ static bool _rtl92de_llt_table_init(struct ieee80211_hw *hw)
/* config this MAC as two MAC transfer. */
/* Otherwise used as local loopback buffer. */
for (i = txpktbuf_bndy; i < maxpage; i++) {
status = rtl92de_llt_write(hw, i, (i + 1));
status = rtl92d_llt_write(hw, i, (i + 1));
if (!status)
return status;
}
/* Let last entry point to the start entry of ring buffer */
status = rtl92de_llt_write(hw, maxpage, txpktbuf_bndy);
status = rtl92d_llt_write(hw, maxpage, txpktbuf_bndy);
if (!status)
return status;
@ -688,7 +688,7 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
/* reset hw sec */
rtl_cam_reset_all_entry(hw);
rtl92de_enable_hw_security_config(hw);
rtl92d_enable_hw_security_config(hw);
/* Read EEPROM TX power index and PHY_REG_PG.txt to capture correct */
/* TX power index for different rate set. */
@ -742,11 +742,11 @@ static int _rtl92de_set_media_status(struct ieee80211_hw *hw,
if (type == NL80211_IFTYPE_UNSPECIFIED ||
type == NL80211_IFTYPE_STATION) {
rtl92de_stop_tx_beacon(hw);
rtl92d_stop_tx_beacon(hw);
_rtl92de_enable_bcn_sub_func(hw);
} else if (type == NL80211_IFTYPE_ADHOC ||
type == NL80211_IFTYPE_AP) {
rtl92de_resume_tx_beacon(hw);
rtl92d_resume_tx_beacon(hw);
_rtl92de_disable_bcn_sub_func(hw);
} else {
rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING,

20
drivers/net/wireless/realtek/rtlwifi/rtl8192de/sw.c
View File

@ -187,7 +187,7 @@ static void rtl92d_deinit_sw_vars(struct ieee80211_hw *hw)
static struct rtl_hal_ops rtl8192de_hal_ops = {
.init_sw_vars = rtl92d_init_sw_vars,
.deinit_sw_vars = rtl92d_deinit_sw_vars,
.read_eeprom_info = rtl92de_read_eeprom_info,
.read_eeprom_info = rtl92d_read_eeprom_info,
.interrupt_recognized = rtl92de_interrupt_recognized,
.hw_init = rtl92de_hw_init,
.hw_disable = rtl92de_card_disable,
@ -197,30 +197,30 @@ static struct rtl_hal_ops rtl8192de_hal_ops = {
.disable_interrupt = rtl92de_disable_interrupt,
.set_network_type = rtl92de_set_network_type,
.set_chk_bssid = rtl92de_set_check_bssid,
.set_qos = rtl92de_set_qos,
.set_qos = rtl92d_set_qos,
.set_bcn_reg = rtl92de_set_beacon_related_registers,
.set_bcn_intv = rtl92de_set_beacon_interval,
.update_interrupt_mask = rtl92de_update_interrupt_mask,
.get_hw_reg = rtl92de_get_hw_reg,
.set_hw_reg = rtl92de_set_hw_reg,
.update_rate_tbl = rtl92de_update_hal_rate_tbl,
.update_rate_tbl = rtl92d_update_hal_rate_tbl,
.fill_tx_desc = rtl92de_tx_fill_desc,
.fill_tx_cmddesc = rtl92de_tx_fill_cmddesc,
.query_rx_desc = rtl92de_rx_query_desc,
.set_channel_access = rtl92de_update_channel_access_setting,
.radio_onoff_checking = rtl92de_gpio_radio_on_off_checking,
.query_rx_desc = rtl92d_rx_query_desc,
.set_channel_access = rtl92d_update_channel_access_setting,
.radio_onoff_checking = rtl92d_gpio_radio_on_off_checking,
.set_bw_mode = rtl92d_phy_set_bw_mode,
.switch_channel = rtl92d_phy_sw_chnl,
.dm_watchdog = rtl92de_dm_watchdog,
.scan_operation_backup = rtl_phy_scan_operation_backup,
.set_rf_power_state = rtl92d_phy_set_rf_power_state,
.led_control = rtl92de_led_control,
.set_desc = rtl92de_set_desc,
.get_desc = rtl92de_get_desc,
.set_desc = rtl92d_set_desc,
.get_desc = rtl92d_get_desc,
.is_tx_desc_closed = rtl92de_is_tx_desc_closed,
.tx_polling = rtl92de_tx_polling,
.enable_hw_sec = rtl92de_enable_hw_security_config,
.set_key = rtl92de_set_key,
.enable_hw_sec = rtl92d_enable_hw_security_config,
.set_key = rtl92d_set_key,
.get_bbreg = rtl92d_phy_query_bb_reg,
.set_bbreg = rtl92d_phy_set_bb_reg,
.get_rfreg = rtl92d_phy_query_rf_reg,

2
drivers/net/wireless/realtek/rtlwifi/rtl8192de/trx.c
View File

@ -292,7 +292,7 @@ bool rtl92de_is_tx_desc_closed(struct ieee80211_hw *hw,
struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
struct rtl8192_tx_ring *ring = &rtlpci->tx_ring[hw_queue];
u8 *entry = (u8 *)(&ring->desc[ring->idx]);
u8 own = (u8)rtl92de_get_desc(hw, entry, true, HW_DESC_OWN);
u8 own = (u8)rtl92d_get_desc(hw, entry, true, HW_DESC_OWN);
/* a beacon packet will only use the first
* descriptor by defaut, and the own bit may not

13
drivers/net/wireless/realtek/rtlwifi/rtl8192du/Makefile Normal file
View File

@ -0,0 +1,13 @@
# SPDX-License-Identifier: GPL-2.0
rtl8192du-objs := \
dm.o \
fw.o \
hw.o \
led.o \
phy.o \
rf.o \
sw.o \
table.o \
trx.o
obj-$(CONFIG_RTL8192DU) += rtl8192du.o

120
drivers/net/wireless/realtek/rtlwifi/rtl8192du/dm.c Normal file
View File

@ -0,0 +1,120 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "../core.h"
#include "../rtl8192d/reg.h"
#include "../rtl8192d/def.h"
#include "../rtl8192d/dm_common.h"
#include "../rtl8192d/fw_common.h"
#include "dm.h"
static void rtl92du_dm_init_1r_cca(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct ps_t *dm_pstable = &rtlpriv->dm_pstable;
dm_pstable->pre_ccastate = CCA_MAX;
dm_pstable->cur_ccasate = CCA_MAX;
}
static void rtl92du_dm_1r_cca(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct ps_t *dm_pstable = &rtlpriv->dm_pstable;
struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
int pwdb = rtlpriv->dm_digtable.min_undec_pwdb_for_dm;
if (rtlhal->macphymode != SINGLEMAC_SINGLEPHY ||
rtlhal->current_bandtype != BAND_ON_5G)
return;
if (pwdb != 0) {
if (dm_pstable->pre_ccastate == CCA_2R ||
dm_pstable->pre_ccastate == CCA_MAX)
dm_pstable->cur_ccasate = (pwdb >= 35) ? CCA_1R : CCA_2R;
else
dm_pstable->cur_ccasate = (pwdb <= 30) ? CCA_2R : CCA_1R;
} else {
dm_pstable->cur_ccasate = CCA_MAX;
}
if (dm_pstable->pre_ccastate == dm_pstable->cur_ccasate)
return;
rtl_dbg(rtlpriv, COMP_BB_POWERSAVING, DBG_TRACE,
"Old CCA state: %d new CCA state: %d\n",
dm_pstable->pre_ccastate, dm_pstable->cur_ccasate);
if (dm_pstable->cur_ccasate == CCA_1R) {
if (rtlpriv->phy.rf_type == RF_2T2R)
rtl_set_bbreg(hw, ROFDM0_TRXPATHENABLE, MASKBYTE0, 0x13);
else /* Is this branch reachable? */
rtl_set_bbreg(hw, ROFDM0_TRXPATHENABLE, MASKBYTE0, 0x23);
} else { /* CCA_2R or CCA_MAX */
rtl_set_bbreg(hw, ROFDM0_TRXPATHENABLE, MASKBYTE0, 0x33);
}
}
static void rtl92du_dm_pwdb_monitor(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
const u32 max_macid = 32;
u32 temp;
/* AP & ADHOC & MESH will return tmp */
if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION)
return;
/* Indicate Rx signal strength to FW. */
if (rtlpriv->dm.useramask) {
temp = rtlpriv->dm.undec_sm_pwdb << 16;
temp |= max_macid << 8;
rtl92d_fill_h2c_cmd(hw, H2C_RSSI_REPORT, 3, (u8 *)(&temp));
} else {
rtl_write_byte(rtlpriv, 0x4fe, (u8)rtlpriv->dm.undec_sm_pwdb);
}
}
void rtl92du_dm_init(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
rtlpriv->dm.dm_type = DM_TYPE_BYDRIVER;
rtl_dm_diginit(hw, 0x20);
rtlpriv->dm_digtable.rx_gain_max = DM_DIG_FA_UPPER;
rtlpriv->dm_digtable.rx_gain_min = DM_DIG_FA_LOWER;
rtl92d_dm_init_edca_turbo(hw);
rtl92du_dm_init_1r_cca(hw);
rtl92d_dm_init_rate_adaptive_mask(hw);
rtl92d_dm_initialize_txpower_tracking(hw);
}
void rtl92du_dm_watchdog(struct ieee80211_hw *hw)
{
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
bool fw_current_inpsmode = false;
bool fwps_awake = true;
/* 1. RF is OFF. (No need to do DM.)
* 2. Fw is under power saving mode for FwLPS.
* (Prevent from SW/FW I/O racing.)
* 3. IPS workitem is scheduled. (Prevent from IPS sequence
* to be swapped with DM.
* 4. RFChangeInProgress is TRUE.
* (Prevent from broken by IPS/HW/SW Rf off.)
*/
if (ppsc->rfpwr_state != ERFON || fw_current_inpsmode ||
!fwps_awake || ppsc->rfchange_inprogress)
return;
rtl92du_dm_pwdb_monitor(hw);
rtl92d_dm_false_alarm_counter_statistics(hw);
rtl92d_dm_find_minimum_rssi(hw);
rtl92d_dm_dig(hw);
rtl92d_dm_check_txpower_tracking_thermal_meter(hw);
rtl92d_dm_check_edca_turbo(hw);
rtl92du_dm_1r_cca(hw);
}

10
drivers/net/wireless/realtek/rtlwifi/rtl8192du/dm.h Normal file
View File

@ -0,0 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_DM_H__
#define __RTL92DU_DM_H__
void rtl92du_dm_init(struct ieee80211_hw *hw);
void rtl92du_dm_watchdog(struct ieee80211_hw *hw);
#endif

63
drivers/net/wireless/realtek/rtlwifi/rtl8192du/fw.c Normal file
View File

@ -0,0 +1,63 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "../rtl8192d/reg.h"
#include "../rtl8192d/def.h"
#include "../rtl8192d/fw_common.h"
#include "fw.h"
int rtl92du_download_fw(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
enum version_8192d version = rtlhal->version;
u8 *pfwheader;
u8 *pfwdata;
u32 fwsize;
int err;
if (rtlpriv->max_fw_size == 0 || !rtlhal->pfirmware)
return 1;
fwsize = rtlhal->fwsize;
pfwheader = rtlhal->pfirmware;
pfwdata = rtlhal->pfirmware;
rtlhal->fw_version = (u16)GET_FIRMWARE_HDR_VERSION(pfwheader);
rtlhal->fw_subversion = (u16)GET_FIRMWARE_HDR_SUB_VER(pfwheader);
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD,
"FirmwareVersion(%d), FirmwareSubVersion(%d), Signature(%#x)\n",
rtlhal->fw_version, rtlhal->fw_subversion,
GET_FIRMWARE_HDR_SIGNATURE(pfwheader));
if (IS_FW_HEADER_EXIST(pfwheader)) {
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD,
"Shift 32 bytes for FW header!!\n");
pfwdata = pfwdata + 32;
fwsize = fwsize - 32;
}
if (rtl92d_is_fw_downloaded(rtlpriv))
goto exit;
/* If 8051 is running in RAM code, driver should
* inform Fw to reset by itself, or it will cause
* download Fw fail.
*/
if (rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) {
rtl92d_firmware_selfreset(hw);
rtl_write_byte(rtlpriv, REG_MCUFWDL, 0x00);
}
rtl92d_enable_fw_download(hw, true);
rtl92d_write_fw(hw, version, pfwdata, fwsize);
rtl92d_enable_fw_download(hw, false);
err = rtl92d_fw_free_to_go(hw);
if (err)
pr_err("fw is not ready to run!\n");
exit:
err = rtl92d_fw_init(hw);
return err;
}

9
drivers/net/wireless/realtek/rtlwifi/rtl8192du/fw.h Normal file
View File

@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_FW_H__
#define __RTL92DU_FW_H__
int rtl92du_download_fw(struct ieee80211_hw *hw);
#endif

1212
drivers/net/wireless/realtek/rtlwifi/rtl8192du/hw.c Normal file
View File

File diff suppressed because it is too large Load Diff

22
drivers/net/wireless/realtek/rtlwifi/rtl8192du/hw.h Normal file
View File

@ -0,0 +1,22 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_HW_H__
#define __RTL92DU_HW_H__
void rtl92du_get_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val);
void rtl92du_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val);
void rtl92du_read_chip_version(struct ieee80211_hw *hw);
int rtl92du_hw_init(struct ieee80211_hw *hw);
void rtl92du_card_disable(struct ieee80211_hw *hw);
void rtl92du_enable_interrupt(struct ieee80211_hw *hw);
void rtl92du_disable_interrupt(struct ieee80211_hw *hw);
int rtl92du_set_network_type(struct ieee80211_hw *hw, enum nl80211_iftype type);
void rtl92du_set_check_bssid(struct ieee80211_hw *hw, bool check_bssid);
void rtl92du_set_beacon_related_registers(struct ieee80211_hw *hw);
void rtl92du_set_beacon_interval(struct ieee80211_hw *hw);
void rtl92du_update_interrupt_mask(struct ieee80211_hw *hw,
u32 add_msr, u32 rm_msr);
void rtl92du_linked_set_reg(struct ieee80211_hw *hw);
#endif

10
drivers/net/wireless/realtek/rtlwifi/rtl8192du/led.c Normal file
View File

@ -0,0 +1,10 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "led.h"
void rtl92du_led_control(struct ieee80211_hw *hw, enum led_ctl_mode ledaction)
{
/* The hardware has control. */
}

9
drivers/net/wireless/realtek/rtlwifi/rtl8192du/led.h Normal file
View File

@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_LED_H__
#define __RTL92DU_LED_H__
void rtl92du_led_control(struct ieee80211_hw *hw, enum led_ctl_mode ledaction);
#endif

3123
drivers/net/wireless/realtek/rtlwifi/rtl8192du/phy.c Normal file
View File

File diff suppressed because it is too large Load Diff

32
drivers/net/wireless/realtek/rtlwifi/rtl8192du/phy.h Normal file
View File

@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_PHY_H__
#define __RTL92DU_PHY_H__
u32 rtl92du_phy_query_bb_reg(struct ieee80211_hw *hw,
u32 regaddr, u32 bitmask);
void rtl92du_phy_set_bb_reg(struct ieee80211_hw *hw,
u32 regaddr, u32 bitmask, u32 data);
bool rtl92du_phy_mac_config(struct ieee80211_hw *hw);
bool rtl92du_phy_bb_config(struct ieee80211_hw *hw);
bool rtl92du_phy_rf_config(struct ieee80211_hw *hw);
void rtl92du_phy_set_bw_mode(struct ieee80211_hw *hw,
enum nl80211_channel_type ch_type);
u8 rtl92du_phy_sw_chnl(struct ieee80211_hw *hw);
bool rtl92du_phy_config_rf_with_headerfile(struct ieee80211_hw *hw,
enum rf_content content,
enum radio_path rfpath);
bool rtl92du_phy_set_rf_power_state(struct ieee80211_hw *hw,
enum rf_pwrstate rfpwr_state);
void rtl92du_phy_set_poweron(struct ieee80211_hw *hw);
bool rtl92du_phy_check_poweroff(struct ieee80211_hw *hw);
void rtl92du_phy_lc_calibrate(struct ieee80211_hw *hw, bool is2t);
void rtl92du_update_bbrf_configuration(struct ieee80211_hw *hw);
void rtl92du_phy_ap_calibrate(struct ieee80211_hw *hw, s8 delta);
void rtl92du_phy_iq_calibrate(struct ieee80211_hw *hw);
void rtl92du_phy_reload_iqk_setting(struct ieee80211_hw *hw, u8 channel);
void rtl92du_phy_init_pa_bias(struct ieee80211_hw *hw);
#endif

240
drivers/net/wireless/realtek/rtlwifi/rtl8192du/rf.c Normal file
View File

@ -0,0 +1,240 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "../rtl8192d/reg.h"
#include "../rtl8192d/phy_common.h"
#include "phy.h"
#include "rf.h"
bool rtl92du_phy_enable_anotherphy(struct ieee80211_hw *hw, bool bmac0)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = &rtlpriv->rtlhal;
u8 mac_on_bit = bmac0 ? MAC1_ON : MAC0_ON;
u8 mac_reg = bmac0 ? REG_MAC1 : REG_MAC0;
bool bresult = true; /* true: need to enable BB/RF power */
u32 maskforphyset = 0;
u16 val16;
u8 u1btmp;
rtlhal->during_mac0init_radiob = false;
rtlhal->during_mac1init_radioa = false;
rtl_dbg(rtlpriv, COMP_RF, DBG_LOUD, "===>\n");
/* MAC0 Need PHY1 load radio_b.txt . Driver use DBI to write. */
u1btmp = rtl_read_byte(rtlpriv, mac_reg);
if (!(u1btmp & mac_on_bit)) {
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "enable BB & RF\n");
/* Enable BB and RF power */
maskforphyset = bmac0 ? MAC0_ACCESS_PHY1 : MAC1_ACCESS_PHY0;
val16 = rtl_read_word(rtlpriv, REG_SYS_FUNC_EN | maskforphyset);
val16 &= 0xfffc;
rtl_write_word(rtlpriv, REG_SYS_FUNC_EN | maskforphyset, val16);
val16 = rtl_read_word(rtlpriv, REG_SYS_FUNC_EN | maskforphyset);
val16 |= BIT(13) | BIT(0) | BIT(1);
rtl_write_word(rtlpriv, REG_SYS_FUNC_EN | maskforphyset, val16);
} else {
/* We think if MAC1 is ON,then radio_a.txt
* and radio_b.txt has been load.
*/
bresult = false;
}
rtl_dbg(rtlpriv, COMP_RF, DBG_LOUD, "<===\n");
return bresult;
}
void rtl92du_phy_powerdown_anotherphy(struct ieee80211_hw *hw, bool bmac0)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = &rtlpriv->rtlhal;
u8 mac_on_bit = bmac0 ? MAC1_ON : MAC0_ON;
u8 mac_reg = bmac0 ? REG_MAC1 : REG_MAC0;
u32 maskforphyset = 0;
u8 u1btmp;
rtlhal->during_mac0init_radiob = false;
rtlhal->during_mac1init_radioa = false;
rtl_dbg(rtlpriv, COMP_RF, DBG_LOUD, "====>\n");
/* check MAC0 enable or not again now, if
* enabled, not power down radio A.
*/
u1btmp = rtl_read_byte(rtlpriv, mac_reg);
if (!(u1btmp & mac_on_bit)) {
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, "power down\n");
/* power down RF radio A according to YuNan's advice. */
maskforphyset = bmac0 ? MAC0_ACCESS_PHY1 : MAC1_ACCESS_PHY0;
rtl_write_dword(rtlpriv, RFPGA0_XA_LSSIPARAMETER | maskforphyset,
0x00000000);
}
rtl_dbg(rtlpriv, COMP_RF, DBG_LOUD, "<====\n");
}
bool rtl92du_phy_rf6052_config(struct ieee80211_hw *hw)
{
bool mac1_initradioa_first = false, mac0_initradiob_first = false;
bool need_pwrdown_radioa = false, need_pwrdown_radiob = false;
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = &rtlpriv->rtlhal;
struct rtl_phy *rtlphy = &rtlpriv->phy;
struct bb_reg_def *pphyreg;
bool true_bpath = false;
bool rtstatus = true;
u32 u4_regvalue = 0;
u8 rfpath;
if (rtlphy->rf_type == RF_1T1R)
rtlphy->num_total_rfpath = 1;
else
rtlphy->num_total_rfpath = 2;
/* Single phy mode: use radio_a radio_b config path_A path_B
* separately by MAC0, and MAC1 needn't configure RF;
* Dual PHY mode: MAC0 use radio_a config 1st phy path_A,
* MAC1 use radio_b config 2nd PHY path_A.
* DMDP, MAC0 on G band, MAC1 on A band.
*/
if (rtlhal->macphymode == DUALMAC_DUALPHY) {
if (rtlhal->current_bandtype == BAND_ON_2_4G &&
rtlhal->interfaceindex == 0) {
/* MAC0 needs PHY1 load radio_b.txt. */
if (rtl92du_phy_enable_anotherphy(hw, true)) {
rtlphy->num_total_rfpath = 2;
mac0_initradiob_first = true;
} else {
/* We think if MAC1 is ON,then radio_a.txt and
* radio_b.txt has been load.
*/
return rtstatus;
}
} else if (rtlhal->current_bandtype == BAND_ON_5G &&
rtlhal->interfaceindex == 1) {
/* MAC1 needs PHY0 load radio_a.txt. */
if (rtl92du_phy_enable_anotherphy(hw, false)) {
rtlphy->num_total_rfpath = 2;
mac1_initradioa_first = true;
} else {
/* We think if MAC0 is ON, then radio_a.txt and
* radio_b.txt has been load.
*/
return rtstatus;
}
} else if (rtlhal->interfaceindex == 1) {
/* MAC0 enabled, only init radia B. */
true_bpath = true;
}
}
for (rfpath = 0; rfpath < rtlphy->num_total_rfpath; rfpath++) {
/* Mac1 use PHY0 write */
if (mac1_initradioa_first) {
if (rfpath == RF90_PATH_A) {
rtlhal->during_mac1init_radioa = true;
need_pwrdown_radioa = true;
} else if (rfpath == RF90_PATH_B) {
rtlhal->during_mac1init_radioa = false;
mac1_initradioa_first = false;
rfpath = RF90_PATH_A;
true_bpath = true;
rtlphy->num_total_rfpath = 1;
}
} else if (mac0_initradiob_first) {
/* Mac0 use PHY1 write */
if (rfpath == RF90_PATH_A)
rtlhal->during_mac0init_radiob = false;
if (rfpath == RF90_PATH_B) {
rtlhal->during_mac0init_radiob = true;
mac0_initradiob_first = false;
need_pwrdown_radiob = true;
rfpath = RF90_PATH_A;
true_bpath = true;
rtlphy->num_total_rfpath = 1;
}
}
pphyreg = &rtlphy->phyreg_def[rfpath];
switch (rfpath) {
case RF90_PATH_A:
case RF90_PATH_C:
u4_regvalue = rtl_get_bbreg(hw, pphyreg->rfintfs,
BRFSI_RFENV);
break;
case RF90_PATH_B:
case RF90_PATH_D:
u4_regvalue = rtl_get_bbreg(hw, pphyreg->rfintfs,
BRFSI_RFENV << 16);
break;
}
rtl_set_bbreg(hw, pphyreg->rfintfe, BRFSI_RFENV << 16, 0x1);
udelay(1);
rtl_set_bbreg(hw, pphyreg->rfintfo, BRFSI_RFENV, 0x1);
udelay(1);
/* Set bit number of Address and Data for RF register */
rtl_set_bbreg(hw, pphyreg->rfhssi_para2,
B3WIREADDRESSLENGTH, 0x0);
udelay(1);
rtl_set_bbreg(hw, pphyreg->rfhssi_para2, B3WIREDATALENGTH, 0x0);
udelay(1);
switch (rfpath) {
case RF90_PATH_A:
if (true_bpath)
rtstatus = rtl92du_phy_config_rf_with_headerfile(
hw, radiob_txt,
(enum radio_path)rfpath);
else
rtstatus = rtl92du_phy_config_rf_with_headerfile(
hw, radioa_txt,
(enum radio_path)rfpath);
break;
case RF90_PATH_B:
rtstatus =
rtl92du_phy_config_rf_with_headerfile(hw, radiob_txt,
(enum radio_path)rfpath);
break;
case RF90_PATH_C:
break;
case RF90_PATH_D:
break;
}
switch (rfpath) {
case RF90_PATH_A:
case RF90_PATH_C:
rtl_set_bbreg(hw, pphyreg->rfintfs, BRFSI_RFENV,
u4_regvalue);
break;
case RF90_PATH_B:
case RF90_PATH_D:
rtl_set_bbreg(hw, pphyreg->rfintfs, BRFSI_RFENV << 16,
u4_regvalue);
break;
}
if (!rtstatus) {
rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE,
"Radio[%d] Fail!!\n", rfpath);
return rtstatus;
}
}
/* check MAC0 enable or not again, if enabled,
* not power down radio A.
* check MAC1 enable or not again, if enabled,
* not power down radio B.
*/
if (need_pwrdown_radioa)
rtl92du_phy_powerdown_anotherphy(hw, false);
else if (need_pwrdown_radiob)
rtl92du_phy_powerdown_anotherphy(hw, true);
rtl_dbg(rtlpriv, COMP_INIT, DBG_TRACE, "<---\n");
return rtstatus;
}

11
drivers/net/wireless/realtek/rtlwifi/rtl8192du/rf.h Normal file
View File

@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_RF_H__
#define __RTL92DU_RF_H__
bool rtl92du_phy_rf6052_config(struct ieee80211_hw *hw);
bool rtl92du_phy_enable_anotherphy(struct ieee80211_hw *hw, bool bmac0);
void rtl92du_phy_powerdown_anotherphy(struct ieee80211_hw *hw, bool bmac0);
#endif

395
drivers/net/wireless/realtek/rtlwifi/rtl8192du/sw.c Normal file
View File

@ -0,0 +1,395 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "../core.h"
#include "../usb.h"
#include "../base.h"
#include "../rtl8192d/reg.h"
#include "../rtl8192d/def.h"
#include "../rtl8192d/fw_common.h"
#include "../rtl8192d/hw_common.h"
#include "../rtl8192d/phy_common.h"
#include "../rtl8192d/trx_common.h"
#include "phy.h"
#include "dm.h"
#include "hw.h"
#include "trx.h"
#include "led.h"
#include <linux/module.h>
static struct usb_interface *rtl92du_get_other_intf(struct ieee80211_hw *hw)
{
struct usb_interface *intf;
struct usb_device *udev;
u8 other_interfaceindex;
/* See SET_IEEE80211_DEV(hw, &intf->dev); in usb.c */
intf = container_of_const(wiphy_dev(hw->wiphy), struct usb_interface, dev);
if (intf->altsetting[0].desc.bInterfaceNumber == 0)
other_interfaceindex = 1;
else
other_interfaceindex = 0;
udev = interface_to_usbdev(intf);
return usb_ifnum_to_if(udev, other_interfaceindex);
}
static int rtl92du_init_shared_data(struct ieee80211_hw *hw)
{
struct usb_interface *other_intf = rtl92du_get_other_intf(hw);
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_priv *other_rtlpriv = NULL;
struct ieee80211_hw *other_hw = NULL;
if (other_intf)
other_hw = usb_get_intfdata(other_intf);
if (other_hw) {
/* The other interface was already probed. */
other_rtlpriv = rtl_priv(other_hw);
rtlpriv->curveindex_2g = other_rtlpriv->curveindex_2g;
rtlpriv->curveindex_5g = other_rtlpriv->curveindex_5g;
rtlpriv->mutex_for_power_on_off = other_rtlpriv->mutex_for_power_on_off;
rtlpriv->mutex_for_hw_init = other_rtlpriv->mutex_for_hw_init;
if (!rtlpriv->curveindex_2g || !rtlpriv->curveindex_5g ||
!rtlpriv->mutex_for_power_on_off || !rtlpriv->mutex_for_hw_init)
return -ENOMEM;
return 0;
}
/* The other interface doesn't exist or was not probed yet. */
rtlpriv->curveindex_2g = kcalloc(TARGET_CHNL_NUM_2G,
sizeof(*rtlpriv->curveindex_2g),
GFP_KERNEL);
rtlpriv->curveindex_5g = kcalloc(TARGET_CHNL_NUM_5G,
sizeof(*rtlpriv->curveindex_5g),
GFP_KERNEL);
rtlpriv->mutex_for_power_on_off =
kzalloc(sizeof(*rtlpriv->mutex_for_power_on_off), GFP_KERNEL);
rtlpriv->mutex_for_hw_init =
kzalloc(sizeof(*rtlpriv->mutex_for_hw_init), GFP_KERNEL);
if (!rtlpriv->curveindex_2g || !rtlpriv->curveindex_5g ||
!rtlpriv->mutex_for_power_on_off || !rtlpriv->mutex_for_hw_init) {
kfree(rtlpriv->curveindex_2g);
kfree(rtlpriv->curveindex_5g);
kfree(rtlpriv->mutex_for_power_on_off);
kfree(rtlpriv->mutex_for_hw_init);
rtlpriv->curveindex_2g = NULL;
rtlpriv->curveindex_5g = NULL;
rtlpriv->mutex_for_power_on_off = NULL;
rtlpriv->mutex_for_hw_init = NULL;
return -ENOMEM;
}
mutex_init(rtlpriv->mutex_for_power_on_off);
mutex_init(rtlpriv->mutex_for_hw_init);
return 0;
}
static void rtl92du_deinit_shared_data(struct ieee80211_hw *hw)
{
struct usb_interface *other_intf = rtl92du_get_other_intf(hw);
struct rtl_priv *rtlpriv = rtl_priv(hw);
if (!other_intf || !usb_get_intfdata(other_intf)) {
/* The other interface doesn't exist or was already disconnected. */
kfree(rtlpriv->curveindex_2g);
kfree(rtlpriv->curveindex_5g);
if (rtlpriv->mutex_for_power_on_off)
mutex_destroy(rtlpriv->mutex_for_power_on_off);
if (rtlpriv->mutex_for_hw_init)
mutex_destroy(rtlpriv->mutex_for_hw_init);
kfree(rtlpriv->mutex_for_power_on_off);
kfree(rtlpriv->mutex_for_hw_init);
}
}
static int rtl92du_init_sw_vars(struct ieee80211_hw *hw)
{
const char *fw_name = "rtlwifi/rtl8192dufw.bin";
struct rtl_priv *rtlpriv = rtl_priv(hw);
int err;
err = rtl92du_init_shared_data(hw);
if (err)
return err;
rtlpriv->dm.dm_initialgain_enable = true;
rtlpriv->dm.dm_flag = 0;
rtlpriv->dm.disable_framebursting = false;
rtlpriv->dm.thermalvalue = 0;
rtlpriv->dm.useramask = true;
/* dual mac */
if (rtlpriv->rtlhal.current_bandtype == BAND_ON_5G)
rtlpriv->phy.current_channel = 36;
else
rtlpriv->phy.current_channel = 1;
if (rtlpriv->rtlhal.macphymode != SINGLEMAC_SINGLEPHY)
rtlpriv->rtlhal.disable_amsdu_8k = true;
/* for LPS & IPS */
rtlpriv->psc.inactiveps = rtlpriv->cfg->mod_params->inactiveps;
rtlpriv->psc.swctrl_lps = rtlpriv->cfg->mod_params->swctrl_lps;
rtlpriv->psc.fwctrl_lps = rtlpriv->cfg->mod_params->fwctrl_lps;
/* for early mode */
rtlpriv->rtlhal.earlymode_enable = false;
/* for firmware buf */
rtlpriv->rtlhal.pfirmware = kmalloc(0x8000, GFP_KERNEL);
if (!rtlpriv->rtlhal.pfirmware)
return -ENOMEM;
rtlpriv->max_fw_size = 0x8000;
pr_info("Driver for Realtek RTL8192DU WLAN interface\n");
pr_info("Loading firmware file %s\n", fw_name);
/* request fw */
err = request_firmware_nowait(THIS_MODULE, 1, fw_name,
rtlpriv->io.dev, GFP_KERNEL, hw,
rtl_fw_cb);
if (err) {
pr_err("Failed to request firmware!\n");
kfree(rtlpriv->rtlhal.pfirmware);
rtlpriv->rtlhal.pfirmware = NULL;
return err;
}
return 0;
}
static void rtl92du_deinit_sw_vars(struct ieee80211_hw *hw)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
kfree(rtlpriv->rtlhal.pfirmware);
rtlpriv->rtlhal.pfirmware = NULL;
rtl92du_deinit_shared_data(hw);
}
static const struct rtl_hal_ops rtl8192du_hal_ops = {
.init_sw_vars = rtl92du_init_sw_vars,
.deinit_sw_vars = rtl92du_deinit_sw_vars,
.read_chip_version = rtl92du_read_chip_version,
.read_eeprom_info = rtl92d_read_eeprom_info,
.hw_init = rtl92du_hw_init,
.hw_disable = rtl92du_card_disable,
.enable_interrupt = rtl92du_enable_interrupt,
.disable_interrupt = rtl92du_disable_interrupt,
.set_network_type = rtl92du_set_network_type,
.set_chk_bssid = rtl92du_set_check_bssid,
.set_qos = rtl92d_set_qos,
.set_bcn_reg = rtl92du_set_beacon_related_registers,
.set_bcn_intv = rtl92du_set_beacon_interval,
.update_interrupt_mask = rtl92du_update_interrupt_mask,
.get_hw_reg = rtl92du_get_hw_reg,
.set_hw_reg = rtl92du_set_hw_reg,
.update_rate_tbl = rtl92d_update_hal_rate_tbl,
.fill_tx_desc = rtl92du_tx_fill_desc,
.query_rx_desc = rtl92d_rx_query_desc,
.set_channel_access = rtl92d_update_channel_access_setting,
.radio_onoff_checking = rtl92d_gpio_radio_on_off_checking,
.set_bw_mode = rtl92du_phy_set_bw_mode,
.switch_channel = rtl92du_phy_sw_chnl,
.dm_watchdog = rtl92du_dm_watchdog,
.scan_operation_backup = rtl_phy_scan_operation_backup,
.set_rf_power_state = rtl92du_phy_set_rf_power_state,
.led_control = rtl92du_led_control,
.set_desc = rtl92d_set_desc,
.get_desc = rtl92d_get_desc,
.enable_hw_sec = rtl92d_enable_hw_security_config,
.set_key = rtl92d_set_key,
.get_bbreg = rtl92du_phy_query_bb_reg,
.set_bbreg = rtl92du_phy_set_bb_reg,
.get_rfreg = rtl92d_phy_query_rf_reg,
.set_rfreg = rtl92d_phy_set_rf_reg,
.linked_set_reg = rtl92du_linked_set_reg,
.fill_h2c_cmd = rtl92d_fill_h2c_cmd,
.get_btc_status = rtl_btc_status_false,
.phy_iq_calibrate = rtl92du_phy_iq_calibrate,
.phy_lc_calibrate = rtl92du_phy_lc_calibrate,
};
static struct rtl_mod_params rtl92du_mod_params = {
.sw_crypto = false,
.inactiveps = false,
.swctrl_lps = false,
.debug_level = 0,
.debug_mask = 0,
};
static const struct rtl_hal_usbint_cfg rtl92du_interface_cfg = {
/* rx */
.rx_urb_num = 8,
.rx_max_size = 15360,
.usb_rx_hdl = NULL,
.usb_rx_segregate_hdl = NULL,
/* tx */
.usb_tx_cleanup = rtl92du_tx_cleanup,
.usb_tx_post_hdl = rtl92du_tx_post_hdl,
.usb_tx_aggregate_hdl = rtl92du_tx_aggregate_hdl,
.usb_endpoint_mapping = rtl92du_endpoint_mapping,
.usb_mq_to_hwq = rtl92du_mq_to_hwq,
};
static const struct rtl_hal_cfg rtl92du_hal_cfg = {
.name = "rtl8192du",
.ops = &rtl8192du_hal_ops,
.mod_params = &rtl92du_mod_params,
.usb_interface_cfg = &rtl92du_interface_cfg,
.maps[SYS_ISO_CTRL] = REG_SYS_ISO_CTRL,
.maps[SYS_FUNC_EN] = REG_SYS_FUNC_EN,
.maps[SYS_CLK] = REG_SYS_CLKR,
.maps[MAC_RCR_AM] = RCR_AM,
.maps[MAC_RCR_AB] = RCR_AB,
.maps[MAC_RCR_ACRC32] = RCR_ACRC32,
.maps[MAC_RCR_ACF] = RCR_ACF,
.maps[MAC_RCR_AAP] = RCR_AAP,
.maps[EFUSE_TEST] = REG_EFUSE_TEST,
.maps[EFUSE_ACCESS] = REG_EFUSE_ACCESS,
.maps[EFUSE_CTRL] = REG_EFUSE_CTRL,
.maps[EFUSE_CLK] = 0, /* just for 92se */
.maps[EFUSE_CLK_CTRL] = REG_EFUSE_CTRL,
.maps[EFUSE_PWC_EV12V] = PWC_EV12V,
.maps[EFUSE_FEN_ELDR] = FEN_ELDR,
.maps[EFUSE_LOADER_CLK_EN] = 0,
.maps[EFUSE_ANA8M] = 0, /* just for 92se */
.maps[EFUSE_HWSET_MAX_SIZE] = HWSET_MAX_SIZE,
.maps[EFUSE_MAX_SECTION_MAP] = EFUSE_MAX_SECTION,
.maps[EFUSE_REAL_CONTENT_SIZE] = EFUSE_REAL_CONTENT_LEN,
.maps[RWCAM] = REG_CAMCMD,
.maps[WCAMI] = REG_CAMWRITE,
.maps[RCAMO] = REG_CAMREAD,
.maps[CAMDBG] = REG_CAMDBG,
.maps[SECR] = REG_SECCFG,
.maps[SEC_CAM_NONE] = CAM_NONE,
.maps[SEC_CAM_WEP40] = CAM_WEP40,
.maps[SEC_CAM_TKIP] = CAM_TKIP,
.maps[SEC_CAM_AES] = CAM_AES,
.maps[SEC_CAM_WEP104] = CAM_WEP104,
.maps[RTL_IMR_BCNDMAINT6] = IMR_BCNDMAINT6,
.maps[RTL_IMR_BCNDMAINT5] = IMR_BCNDMAINT5,
.maps[RTL_IMR_BCNDMAINT4] = IMR_BCNDMAINT4,
.maps[RTL_IMR_BCNDMAINT3] = IMR_BCNDMAINT3,
.maps[RTL_IMR_BCNDMAINT2] = IMR_BCNDMAINT2,
.maps[RTL_IMR_BCNDMAINT1] = IMR_BCNDMAINT1,
.maps[RTL_IMR_BCNDOK8] = IMR_BCNDOK8,
.maps[RTL_IMR_BCNDOK7] = IMR_BCNDOK7,
.maps[RTL_IMR_BCNDOK6] = IMR_BCNDOK6,
.maps[RTL_IMR_BCNDOK5] = IMR_BCNDOK5,
.maps[RTL_IMR_BCNDOK4] = IMR_BCNDOK4,
.maps[RTL_IMR_BCNDOK3] = IMR_BCNDOK3,
.maps[RTL_IMR_BCNDOK2] = IMR_BCNDOK2,
.maps[RTL_IMR_BCNDOK1] = IMR_BCNDOK1,
.maps[RTL_IMR_TIMEOUT2] = IMR_TIMEOUT2,
.maps[RTL_IMR_TIMEOUT1] = IMR_TIMEOUT1,
.maps[RTL_IMR_TXFOVW] = IMR_TXFOVW,
.maps[RTL_IMR_PSTIMEOUT] = IMR_PSTIMEOUT,
.maps[RTL_IMR_BCNINT] = IMR_BCNINT,
.maps[RTL_IMR_RXFOVW] = IMR_RXFOVW,
.maps[RTL_IMR_RDU] = IMR_RDU,
.maps[RTL_IMR_ATIMEND] = IMR_ATIMEND,
.maps[RTL_IMR_BDOK] = IMR_BDOK,
.maps[RTL_IMR_MGNTDOK] = IMR_MGNTDOK,
.maps[RTL_IMR_TBDER] = IMR_TBDER,
.maps[RTL_IMR_HIGHDOK] = IMR_HIGHDOK,
.maps[RTL_IMR_TBDOK] = IMR_TBDOK,
.maps[RTL_IMR_BKDOK] = IMR_BKDOK,
.maps[RTL_IMR_BEDOK] = IMR_BEDOK,
.maps[RTL_IMR_VIDOK] = IMR_VIDOK,
.maps[RTL_IMR_VODOK] = IMR_VODOK,
.maps[RTL_IMR_ROK] = IMR_ROK,
.maps[RTL_IBSS_INT_MASKS] = (IMR_BCNINT | IMR_TBDOK | IMR_TBDER),
.maps[RTL_RC_CCK_RATE1M] = DESC_RATE1M,
.maps[RTL_RC_CCK_RATE2M] = DESC_RATE2M,
.maps[RTL_RC_CCK_RATE5_5M] = DESC_RATE5_5M,
.maps[RTL_RC_CCK_RATE11M] = DESC_RATE11M,
.maps[RTL_RC_OFDM_RATE6M] = DESC_RATE6M,
.maps[RTL_RC_OFDM_RATE9M] = DESC_RATE9M,
.maps[RTL_RC_OFDM_RATE12M] = DESC_RATE12M,
.maps[RTL_RC_OFDM_RATE18M] = DESC_RATE18M,
.maps[RTL_RC_OFDM_RATE24M] = DESC_RATE24M,
.maps[RTL_RC_OFDM_RATE36M] = DESC_RATE36M,
.maps[RTL_RC_OFDM_RATE48M] = DESC_RATE48M,
.maps[RTL_RC_OFDM_RATE54M] = DESC_RATE54M,
.maps[RTL_RC_HT_RATEMCS7] = DESC_RATEMCS7,
.maps[RTL_RC_HT_RATEMCS15] = DESC_RATEMCS15,
};
module_param_named(swenc, rtl92du_mod_params.sw_crypto, bool, 0444);
module_param_named(debug_level, rtl92du_mod_params.debug_level, int, 0644);
module_param_named(ips, rtl92du_mod_params.inactiveps, bool, 0444);
module_param_named(swlps, rtl92du_mod_params.swctrl_lps, bool, 0444);
module_param_named(debug_mask, rtl92du_mod_params.debug_mask, ullong, 0644);
MODULE_PARM_DESC(swenc, "Set to 1 for software crypto (default 0)\n");
MODULE_PARM_DESC(ips, "Set to 0 to not use link power save (default 0)\n");
MODULE_PARM_DESC(swlps, "Set to 1 to use SW control power save (default 0)\n");
MODULE_PARM_DESC(debug_level, "Set debug level (0-5) (default 0)");
MODULE_PARM_DESC(debug_mask, "Set debug mask (default 0)");
#define USB_VENDOR_ID_REALTEK 0x0bda
static const struct usb_device_id rtl8192d_usb_ids[] = {
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x8193, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x8194, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x8111, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x0193, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0x8171, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(USB_VENDOR_ID_REALTEK, 0xe194, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x2019, 0xab2c, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x2019, 0xab2d, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x2019, 0x4903, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x2019, 0x4904, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x07b8, 0x8193, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x20f4, 0x664b, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x04dd, 0x954f, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x04dd, 0x96a6, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x050d, 0x110a, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x050d, 0x1105, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x050d, 0x120a, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x1668, 0x8102, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x0930, 0x0a0a, rtl92du_hal_cfg)},
{RTL_USB_DEVICE(0x2001, 0x330c, rtl92du_hal_cfg)},
{}
};
MODULE_DEVICE_TABLE(usb, rtl8192d_usb_ids);
static int rtl8192du_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
return rtl_usb_probe(intf, id, &rtl92du_hal_cfg);
}
static struct usb_driver rtl8192du_driver = {
.name = "rtl8192du",
.probe = rtl8192du_probe,
.disconnect = rtl_usb_disconnect,
.id_table = rtl8192d_usb_ids,
.disable_hub_initiated_lpm = 1,
};
module_usb_driver(rtl8192du_driver);
MODULE_AUTHOR("Bitterblue Smith <rtl8821cerfe2@gmail.com>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Realtek 8192DU 802.11n Dual Mac USB wireless");
MODULE_FIRMWARE("rtlwifi/rtl8192dufw.bin");

1675
drivers/net/wireless/realtek/rtlwifi/rtl8192du/table.c Normal file
View File

File diff suppressed because it is too large Load Diff

29
drivers/net/wireless/realtek/rtlwifi/rtl8192du/table.h Normal file
View File

@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_TABLE_H__
#define __RTL92DU_TABLE_H__
#define PHY_REG_2T_ARRAYLENGTH 372
#define PHY_REG_ARRAY_PG_LENGTH 624
#define RADIOA_2T_ARRAYLENGTH 378
#define RADIOB_2T_ARRAYLENGTH 384
#define RADIOA_2T_INT_PA_ARRAYLENGTH 378
#define RADIOB_2T_INT_PA_ARRAYLENGTH 384
#define MAC_2T_ARRAYLENGTH 192
#define AGCTAB_ARRAYLENGTH 386
#define AGCTAB_5G_ARRAYLENGTH 194
#define AGCTAB_2G_ARRAYLENGTH 194
extern const u32 rtl8192du_phy_reg_2tarray[PHY_REG_2T_ARRAYLENGTH];
extern const u32 rtl8192du_phy_reg_array_pg[PHY_REG_ARRAY_PG_LENGTH];
extern const u32 rtl8192du_radioa_2tarray[RADIOA_2T_ARRAYLENGTH];
extern const u32 rtl8192du_radiob_2tarray[RADIOB_2T_ARRAYLENGTH];
extern const u32 rtl8192du_radioa_2t_int_paarray[RADIOA_2T_INT_PA_ARRAYLENGTH];
extern const u32 rtl8192du_radiob_2t_int_paarray[RADIOB_2T_INT_PA_ARRAYLENGTH];
extern const u32 rtl8192du_mac_2tarray[MAC_2T_ARRAYLENGTH];
extern const u32 rtl8192du_agctab_array[AGCTAB_ARRAYLENGTH];
extern const u32 rtl8192du_agctab_5garray[AGCTAB_5G_ARRAYLENGTH];
extern const u32 rtl8192du_agctab_2garray[AGCTAB_2G_ARRAYLENGTH];
#endif

372
drivers/net/wireless/realtek/rtlwifi/rtl8192du/trx.c Normal file
View File

@ -0,0 +1,372 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2024 Realtek Corporation.*/
#include "../wifi.h"
#include "../base.h"
#include "../usb.h"
#include "../rtl8192d/reg.h"
#include "../rtl8192d/def.h"
#include "../rtl8192d/trx_common.h"
#include "trx.h"
void rtl92du_tx_cleanup(struct ieee80211_hw *hw, struct sk_buff *skb)
{
}
int rtl92du_tx_post_hdl(struct ieee80211_hw *hw, struct urb *urb,
struct sk_buff *skb)
{
return 0;
}
struct sk_buff *rtl92du_tx_aggregate_hdl(struct ieee80211_hw *hw,
struct sk_buff_head *list)
{
return skb_dequeue(list);
}
static enum rtl_desc_qsel _rtl92du_hwq_to_descq(u16 queue_index)
{
switch (queue_index) {
case RTL_TXQ_BCN:
return QSLT_BEACON;
case RTL_TXQ_MGT:
return QSLT_MGNT;
case RTL_TXQ_VO:
return QSLT_VO;
case RTL_TXQ_VI:
return QSLT_VI;
case RTL_TXQ_BK:
return QSLT_BK;
default:
case RTL_TXQ_BE:
return QSLT_BE;
}
}
/* For HW recovery information */
static void _rtl92du_tx_desc_checksum(__le32 *txdesc)
{
__le16 *ptr = (__le16 *)txdesc;
u16 checksum = 0;
u32 index;
/* Clear first */
set_tx_desc_tx_desc_checksum(txdesc, 0);
for (index = 0; index < 16; index++)
checksum = checksum ^ le16_to_cpu(*(ptr + index));
set_tx_desc_tx_desc_checksum(txdesc, checksum);
}
void rtl92du_tx_fill_desc(struct ieee80211_hw *hw,
struct ieee80211_hdr *hdr, u8 *pdesc_tx,
u8 *pbd_desc_tx, struct ieee80211_tx_info *info,
struct ieee80211_sta *sta,
struct sk_buff *skb,
u8 queue_index,
struct rtl_tcb_desc *tcb_desc)
{
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_ps_ctl *ppsc = rtl_psc(rtlpriv);
struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
struct rtl_mac *mac = rtl_mac(rtlpriv);
struct rtl_sta_info *sta_entry;
__le16 fc = hdr->frame_control;
u8 agg_state = RTL_AGG_STOP;
u16 pktlen = skb->len;
u32 rts_en, hw_rts_en;
u8 ampdu_density = 0;
u16 seq_number;
__le32 *txdesc;
u8 rate_flag;
u8 tid;
rtl_get_tcb_desc(hw, info, sta, skb, tcb_desc);
txdesc = (__le32 *)skb_push(skb, RTL_TX_HEADER_SIZE);
memset(txdesc, 0, RTL_TX_HEADER_SIZE);
set_tx_desc_pkt_size(txdesc, pktlen);
set_tx_desc_linip(txdesc, 0);
set_tx_desc_pkt_offset(txdesc, RTL_DUMMY_OFFSET);
set_tx_desc_offset(txdesc, RTL_TX_HEADER_SIZE);
/* 5G have no CCK rate */
if (rtlhal->current_bandtype == BAND_ON_5G)
if (tcb_desc->hw_rate < DESC_RATE6M)
tcb_desc->hw_rate = DESC_RATE6M;
set_tx_desc_tx_rate(txdesc, tcb_desc->hw_rate);
if (tcb_desc->use_shortgi || tcb_desc->use_shortpreamble)
set_tx_desc_data_shortgi(txdesc, 1);
if (rtlhal->macphymode == DUALMAC_DUALPHY &&
tcb_desc->hw_rate == DESC_RATEMCS7)
set_tx_desc_data_shortgi(txdesc, 1);
if (sta) {
sta_entry = (struct rtl_sta_info *)sta->drv_priv;
tid = ieee80211_get_tid(hdr);
agg_state = sta_entry->tids[tid].agg.agg_state;
ampdu_density = sta->deflink.ht_cap.ampdu_density;
}
if (agg_state == RTL_AGG_OPERATIONAL &&
info->flags & IEEE80211_TX_CTL_AMPDU) {
set_tx_desc_agg_enable(txdesc, 1);
set_tx_desc_max_agg_num(txdesc, 0x14);
set_tx_desc_ampdu_density(txdesc, ampdu_density);
tcb_desc->rts_enable = 1;
tcb_desc->rts_rate = DESC_RATE24M;
} else {
set_tx_desc_agg_break(txdesc, 1);
}
seq_number = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
set_tx_desc_seq(txdesc, seq_number);
rts_en = tcb_desc->rts_enable && !tcb_desc->cts_enable;
hw_rts_en = tcb_desc->rts_enable || tcb_desc->cts_enable;
set_tx_desc_rts_enable(txdesc, rts_en);
set_tx_desc_hw_rts_enable(txdesc, hw_rts_en);
set_tx_desc_cts2self(txdesc, tcb_desc->cts_enable);
set_tx_desc_rts_stbc(txdesc, tcb_desc->rts_stbc);
/* 5G have no CCK rate */
if (rtlhal->current_bandtype == BAND_ON_5G)
if (tcb_desc->rts_rate < DESC_RATE6M)
tcb_desc->rts_rate = DESC_RATE6M;
set_tx_desc_rts_rate(txdesc, tcb_desc->rts_rate);
set_tx_desc_rts_bw(txdesc, 0);
set_tx_desc_rts_sc(txdesc, tcb_desc->rts_sc);
set_tx_desc_rts_short(txdesc, tcb_desc->rts_use_shortpreamble);
rate_flag = info->control.rates[0].flags;
if (mac->bw_40) {
if (rate_flag & IEEE80211_TX_RC_DUP_DATA) {
set_tx_desc_data_bw(txdesc, 1);
set_tx_desc_tx_sub_carrier(txdesc, 3);
} else if (rate_flag & IEEE80211_TX_RC_40_MHZ_WIDTH) {
set_tx_desc_data_bw(txdesc, 1);
set_tx_desc_tx_sub_carrier(txdesc, mac->cur_40_prime_sc);
} else {
set_tx_desc_data_bw(txdesc, 0);
set_tx_desc_tx_sub_carrier(txdesc, 0);
}
} else {
set_tx_desc_data_bw(txdesc, 0);
set_tx_desc_tx_sub_carrier(txdesc, 0);
}
if (info->control.hw_key) {
struct ieee80211_key_conf *keyconf = info->control.hw_key;
switch (keyconf->cipher) {
case WLAN_CIPHER_SUITE_WEP40:
case WLAN_CIPHER_SUITE_WEP104:
case WLAN_CIPHER_SUITE_TKIP:
set_tx_desc_sec_type(txdesc, 0x1);
break;
case WLAN_CIPHER_SUITE_CCMP:
set_tx_desc_sec_type(txdesc, 0x3);
break;
default:
set_tx_desc_sec_type(txdesc, 0x0);
break;
}
}
set_tx_desc_pkt_id(txdesc, 0);
set_tx_desc_queue_sel(txdesc, _rtl92du_hwq_to_descq(queue_index));
set_tx_desc_data_rate_fb_limit(txdesc, 0x1F);
set_tx_desc_rts_rate_fb_limit(txdesc, 0xF);
set_tx_desc_disable_fb(txdesc, 0);
set_tx_desc_use_rate(txdesc, tcb_desc->use_driver_rate);
if (ieee80211_is_data_qos(fc)) {
if (mac->rdg_en) {
rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE,
"Enable RDG function\n");
set_tx_desc_rdg_enable(txdesc, 1);
set_tx_desc_htc(txdesc, 1);
}
set_tx_desc_qos(txdesc, 1);
}
if (rtlpriv->dm.useramask) {
set_tx_desc_rate_id(txdesc, tcb_desc->ratr_index);
set_tx_desc_macid(txdesc, tcb_desc->mac_id);
} else {
set_tx_desc_rate_id(txdesc, 0xC + tcb_desc->ratr_index);
set_tx_desc_macid(txdesc, tcb_desc->ratr_index);
}
if (!ieee80211_is_data_qos(fc) && ppsc->leisure_ps &&
ppsc->fwctrl_lps) {
set_tx_desc_hwseq_en(txdesc, 1);
set_tx_desc_pkt_id(txdesc, 8);
}
if (ieee80211_has_morefrags(fc))
set_tx_desc_more_frag(txdesc, 1);
if (is_multicast_ether_addr(ieee80211_get_DA(hdr)) ||
is_broadcast_ether_addr(ieee80211_get_DA(hdr)))
set_tx_desc_bmc(txdesc, 1);
set_tx_desc_own(txdesc, 1);
set_tx_desc_last_seg(txdesc, 1);
set_tx_desc_first_seg(txdesc, 1);
_rtl92du_tx_desc_checksum(txdesc);
rtl_dbg(rtlpriv, COMP_SEND, DBG_TRACE, "==>\n");
}
static void _rtl92du_config_out_ep(struct ieee80211_hw *hw, u8 num_out_pipe)
{
struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
struct rtl_priv *rtlpriv = rtl_priv(hw);
struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
u16 ep_cfg;
rtlusb->out_queue_sel = 0;
rtlusb->out_ep_nums = 0;
if (rtlhal->interfaceindex == 0)
ep_cfg = rtl_read_word(rtlpriv, REG_USB_Queue_Select_MAC0);
else
ep_cfg = rtl_read_word(rtlpriv, REG_USB_Queue_Select_MAC1);
if (ep_cfg & 0x00f) {
rtlusb->out_queue_sel |= TX_SELE_HQ;
rtlusb->out_ep_nums++;
}
if (ep_cfg & 0x0f0) {
rtlusb->out_queue_sel |= TX_SELE_NQ;
rtlusb->out_ep_nums++;
}
if (ep_cfg & 0xf00) {
rtlusb->out_queue_sel |= TX_SELE_LQ;
rtlusb->out_ep_nums++;
}
switch (num_out_pipe) {
case 3:
rtlusb->out_queue_sel = TX_SELE_HQ | TX_SELE_NQ | TX_SELE_LQ;
rtlusb->out_ep_nums = 3;
break;
case 2:
rtlusb->out_queue_sel = TX_SELE_HQ | TX_SELE_NQ;
rtlusb->out_ep_nums = 2;
break;
case 1:
rtlusb->out_queue_sel = TX_SELE_HQ;
rtlusb->out_ep_nums = 1;
break;
default:
break;
}
}
static void _rtl92du_one_out_ep_mapping(struct rtl_usb *rtlusb,
struct rtl_ep_map *ep_map)
{
ep_map->ep_mapping[RTL_TXQ_BE] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_BK] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_VI] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_VO] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_MGT] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_BCN] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_HI] = rtlusb->out_eps[0];
}
static void _rtl92du_two_out_ep_mapping(struct rtl_usb *rtlusb,
struct rtl_ep_map *ep_map)
{
ep_map->ep_mapping[RTL_TXQ_BE] = rtlusb->out_eps[1];
ep_map->ep_mapping[RTL_TXQ_BK] = rtlusb->out_eps[1];
ep_map->ep_mapping[RTL_TXQ_VI] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_VO] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_MGT] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_BCN] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_HI] = rtlusb->out_eps[0];
}
static void _rtl92du_three_out_ep_mapping(struct rtl_usb *rtlusb,
struct rtl_ep_map *ep_map)
{
ep_map->ep_mapping[RTL_TXQ_BE] = rtlusb->out_eps[2];
ep_map->ep_mapping[RTL_TXQ_BK] = rtlusb->out_eps[2];
ep_map->ep_mapping[RTL_TXQ_VI] = rtlusb->out_eps[1];
ep_map->ep_mapping[RTL_TXQ_VO] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_MGT] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_BCN] = rtlusb->out_eps[0];
ep_map->ep_mapping[RTL_TXQ_HI] = rtlusb->out_eps[0];
}
static int _rtl92du_out_ep_mapping(struct ieee80211_hw *hw)
{
struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
struct rtl_ep_map *ep_map = &rtlusb->ep_map;
switch (rtlusb->out_ep_nums) {
case 1:
_rtl92du_one_out_ep_mapping(rtlusb, ep_map);
break;
case 2:
_rtl92du_two_out_ep_mapping(rtlusb, ep_map);
break;
case 3:
_rtl92du_three_out_ep_mapping(rtlusb, ep_map);
break;
default:
return -EINVAL;
}
return 0;
}
int rtl92du_endpoint_mapping(struct ieee80211_hw *hw)
{
struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
_rtl92du_config_out_ep(hw, rtlusb->out_ep_nums);
/* Normal chip with one IN and one OUT doesn't have interrupt IN EP. */
if (rtlusb->out_ep_nums == 1 && rtlusb->in_ep_nums != 1)
return -EINVAL;
return _rtl92du_out_ep_mapping(hw);
}
u16 rtl92du_mq_to_hwq(__le16 fc, u16 mac80211_queue_index)
{
u16 hw_queue_index;
if (unlikely(ieee80211_is_beacon(fc))) {
hw_queue_index = RTL_TXQ_BCN;
goto out;
}
if (ieee80211_is_mgmt(fc)) {
hw_queue_index = RTL_TXQ_MGT;
goto out;
}
switch (mac80211_queue_index) {
case 0:
hw_queue_index = RTL_TXQ_VO;
break;
case 1:
hw_queue_index = RTL_TXQ_VI;
break;
case 2:
hw_queue_index = RTL_TXQ_BE;
break;
case 3:
hw_queue_index = RTL_TXQ_BK;
break;
default:
hw_queue_index = RTL_TXQ_BE;
WARN_ONCE(true, "rtl8192du: QSLT_BE queue, skb_queue:%d\n",
mac80211_queue_index);
break;
}
out:
return hw_queue_index;
}

60
drivers/net/wireless/realtek/rtlwifi/rtl8192du/trx.h Normal file
View File

@ -0,0 +1,60 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2024 Realtek Corporation.*/
#ifndef __RTL92DU_TRX_H__
#define __RTL92DU_TRX_H__
#define TX_SELE_HQ BIT(0) /* High Queue */
#define TX_SELE_LQ BIT(1) /* Low Queue */
#define TX_SELE_NQ BIT(2) /* Normal Queue */
#define TX_TOTAL_PAGE_NUMBER_92DU 0xF8
#define TEST_PAGE_NUM_PUBQ_92DU 0x89
#define TX_TOTAL_PAGE_NUMBER_92D_DUAL_MAC 0x7A
#define NORMAL_PAGE_NUM_PUBQ_92D_DUAL_MAC 0x5A
#define NORMAL_PAGE_NUM_HPQ_92D_DUAL_MAC 0x10
#define NORMAL_PAGE_NUM_LPQ_92D_DUAL_MAC 0x10
#define NORMAL_PAGE_NUM_NORMALQ_92D_DUAL_MAC 0
#define WMM_NORMAL_TX_TOTAL_PAGE_NUMBER 0xF5
#define WMM_NORMAL_PAGE_NUM_PUBQ_92D 0x65
#define WMM_NORMAL_PAGE_NUM_HPQ_92D 0x30
#define WMM_NORMAL_PAGE_NUM_LPQ_92D 0x30
#define WMM_NORMAL_PAGE_NUM_NPQ_92D 0x30
#define WMM_NORMAL_PAGE_NUM_PUBQ_92D_DUAL_MAC 0x32
#define WMM_NORMAL_PAGE_NUM_HPQ_92D_DUAL_MAC 0x18
#define WMM_NORMAL_PAGE_NUM_LPQ_92D_DUAL_MAC 0x18
#define WMM_NORMAL_PAGE_NUM_NPQ_92D_DUAL_MAC 0x18
static inline void set_tx_desc_bmc(__le32 *__txdesc, u32 __value)
{
le32p_replace_bits(__txdesc, __value, BIT(24));
}
static inline void set_tx_desc_agg_break(__le32 *__txdesc, u32 __value)
{
le32p_replace_bits((__txdesc + 1), __value, BIT(6));
}
static inline void set_tx_desc_tx_desc_checksum(__le32 *__txdesc, u32 __value)
{
le32p_replace_bits((__txdesc + 7), __value, GENMASK(15, 0));
}
void rtl92du_tx_fill_desc(struct ieee80211_hw *hw,
struct ieee80211_hdr *hdr, u8 *pdesc,
u8 *pbd_desc_tx, struct ieee80211_tx_info *info,
struct ieee80211_sta *sta,
struct sk_buff *skb, u8 hw_queue,
struct rtl_tcb_desc *ptcb_desc);
int rtl92du_endpoint_mapping(struct ieee80211_hw *hw);
u16 rtl92du_mq_to_hwq(__le16 fc, u16 mac80211_queue_index);
struct sk_buff *rtl92du_tx_aggregate_hdl(struct ieee80211_hw *hw,
struct sk_buff_head *list);
void rtl92du_tx_cleanup(struct ieee80211_hw *hw, struct sk_buff *skb);
int rtl92du_tx_post_hdl(struct ieee80211_hw *hw, struct urb *urb,
struct sk_buff *skb);
#endif

36
drivers/net/wireless/realtek/rtlwifi/usb.c
View File

@ -23,6 +23,8 @@ MODULE_DESCRIPTION("USB basic driver for rtlwifi");
#define MAX_USBCTRL_VENDORREQ_TIMES 10
static void _rtl_usb_cleanup_tx(struct ieee80211_hw *hw);
static void _usbctrl_vendorreq_sync(struct usb_device *udev, u8 reqtype,
u16 value, void *pdata, u16 len)
{
@ -285,9 +287,23 @@ static int _rtl_usb_init(struct ieee80211_hw *hw)
}
/* usb endpoint mapping */
err = rtlpriv->cfg->usb_interface_cfg->usb_endpoint_mapping(hw);
rtlusb->usb_mq_to_hwq = rtlpriv->cfg->usb_interface_cfg->usb_mq_to_hwq;
_rtl_usb_init_tx(hw);
_rtl_usb_init_rx(hw);
if (err)
return err;
rtlusb->usb_mq_to_hwq = rtlpriv->cfg->usb_interface_cfg->usb_mq_to_hwq;
err = _rtl_usb_init_tx(hw);
if (err)
return err;
err = _rtl_usb_init_rx(hw);
if (err)
goto err_out;
return 0;
err_out:
_rtl_usb_cleanup_tx(hw);
return err;
}
@ -691,17 +707,13 @@ static int rtl_usb_start(struct ieee80211_hw *hw)
}
/*======================= tx =========================================*/
static void rtl_usb_cleanup(struct ieee80211_hw *hw)
static void _rtl_usb_cleanup_tx(struct ieee80211_hw *hw)
{
u32 i;
struct sk_buff *_skb;
struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
struct ieee80211_tx_info *txinfo;
/* clean up rx stuff. */
_rtl_usb_cleanup_rx(hw);
/* clean up tx stuff */
for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {
while ((_skb = skb_dequeue(&rtlusb->tx_skb_queue[i]))) {
rtlusb->usb_tx_cleanup(hw, _skb);
@ -715,6 +727,12 @@ static void rtl_usb_cleanup(struct ieee80211_hw *hw)
usb_kill_anchored_urbs(&rtlusb->tx_submitted);
}
static void rtl_usb_cleanup(struct ieee80211_hw *hw)
{
_rtl_usb_cleanup_rx(hw);
_rtl_usb_cleanup_tx(hw);
}
/* We may add some struct into struct rtl_usb later. Do deinit here. */
static void rtl_usb_deinit(struct ieee80211_hw *hw)
{
@ -937,7 +955,7 @@ static const struct rtl_intf_ops rtl_usb_ops = {
int rtl_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id,
struct rtl_hal_cfg *rtl_hal_cfg)
const struct rtl_hal_cfg *rtl_hal_cfg)
{
int err;
struct ieee80211_hw *hw = NULL;

2
drivers/net/wireless/realtek/rtlwifi/usb.h
View File

@ -136,7 +136,7 @@ struct rtl_usb_priv {
int rtl_usb_probe(struct usb_interface *intf,
const struct usb_device_id *id,
struct rtl_hal_cfg *rtl92cu_hal_cfg);
const struct rtl_hal_cfg *rtl92cu_hal_cfg);
void rtl_usb_disconnect(struct usb_interface *intf);
int rtl_usb_suspend(struct usb_interface *pusb_intf, pm_message_t message);
int rtl_usb_resume(struct usb_interface *pusb_intf);

12
drivers/net/wireless/realtek/rtlwifi/wifi.h
View File

@ -2356,9 +2356,9 @@ struct rtl_hal_cfg {
bool write_readback;
char *name;
char *alt_fw_name;
struct rtl_hal_ops *ops;
const struct rtl_hal_ops *ops;
struct rtl_mod_params *mod_params;
struct rtl_hal_usbint_cfg *usb_interface_cfg;
const struct rtl_hal_usbint_cfg *usb_interface_cfg;
enum rtl_spec_ver spec_ver;
/*this map used for some registers or vars
@ -2707,7 +2707,7 @@ struct rtl_priv {
/* hal_cfg : for diff cards
* intf_ops : for diff interrface usb/pcie
*/
struct rtl_hal_cfg *cfg;
const struct rtl_hal_cfg *cfg;
const struct rtl_intf_ops *intf_ops;
/* this var will be set by set_bit,
@ -2746,6 +2746,12 @@ struct rtl_priv {
*/
bool use_new_trx_flow;
/* For dual MAC RTL8192DU, things shared by the 2 USB interfaces */
u32 *curveindex_2g;
u32 *curveindex_5g;
struct mutex *mutex_for_power_on_off; /* for power on/off */
struct mutex *mutex_for_hw_init; /* for hardware init */
#ifdef CONFIG_PM
struct wiphy_wowlan_support wowlan;
#endif

17
drivers/net/wireless/realtek/rtw88/pci.c
View File

@ -1682,12 +1682,16 @@ static int rtw_pci_napi_poll(struct napi_struct *napi, int budget)
return work_done;
}
static void rtw_pci_napi_init(struct rtw_dev *rtwdev)
static int rtw_pci_napi_init(struct rtw_dev *rtwdev)
{
struct rtw_pci *rtwpci = (struct rtw_pci *)rtwdev->priv;
init_dummy_netdev(&rtwpci->netdev);
netif_napi_add(&rtwpci->netdev, &rtwpci->napi, rtw_pci_napi_poll);
rtwpci->netdev = alloc_netdev_dummy(0);
if (!rtwpci->netdev)
return -ENOMEM;
netif_napi_add(rtwpci->netdev, &rtwpci->napi, rtw_pci_napi_poll);
return 0;
}
static void rtw_pci_napi_deinit(struct rtw_dev *rtwdev)
@ -1696,6 +1700,7 @@ static void rtw_pci_napi_deinit(struct rtw_dev *rtwdev)
rtw_pci_napi_stop(rtwdev);
netif_napi_del(&rtwpci->napi);
free_netdev(rtwpci->netdev);
}
int rtw_pci_probe(struct pci_dev *pdev,
@ -1745,7 +1750,11 @@ int rtw_pci_probe(struct pci_dev *pdev,
goto err_pci_declaim;
}
rtw_pci_napi_init(rtwdev);
ret = rtw_pci_napi_init(rtwdev);
if (ret) {
rtw_err(rtwdev, "failed to setup NAPI\n");
goto err_pci_declaim;
}
ret = rtw_chip_info_setup(rtwdev);
if (ret) {

2
drivers/net/wireless/realtek/rtw88/pci.h
View File

@ -215,7 +215,7 @@ struct rtw_pci {
bool running;
/* napi structure */
struct net_device netdev;
struct net_device *netdev;
struct napi_struct napi;
u16 rx_tag;

14
drivers/net/wireless/realtek/rtw88/usb.c
View File

@ -273,6 +273,8 @@ static void rtw_usb_write_port_tx_complete(struct urb *urb)
info = IEEE80211_SKB_CB(skb);
tx_data = rtw_usb_get_tx_data(skb);
skb_pull(skb, rtwdev->chip->tx_pkt_desc_sz);
/* enqueue to wait for tx report */
if (info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS) {
rtw_tx_report_enqueue(rtwdev, skb, tx_data->sn);
@ -433,23 +435,21 @@ static int rtw_usb_write_data(struct rtw_dev *rtwdev,
{
const struct rtw_chip_info *chip = rtwdev->chip;
struct sk_buff *skb;
unsigned int desclen, headsize, size;
unsigned int size;
u8 qsel;
int ret = 0;
size = pkt_info->tx_pkt_size;
qsel = pkt_info->qsel;
desclen = chip->tx_pkt_desc_sz;
headsize = pkt_info->offset ? pkt_info->offset : desclen;
skb = dev_alloc_skb(headsize + size);
skb = dev_alloc_skb(chip->tx_pkt_desc_sz + size);
if (unlikely(!skb))
return -ENOMEM;
skb_reserve(skb, headsize);
skb_reserve(skb, chip->tx_pkt_desc_sz);
skb_put_data(skb, buf, size);
skb_push(skb, headsize);
memset(skb->data, 0, headsize);
skb_push(skb, chip->tx_pkt_desc_sz);
memset(skb->data, 0, chip->tx_pkt_desc_sz);
rtw_tx_fill_tx_desc(pkt_info, skb);
rtw_tx_fill_txdesc_checksum(rtwdev, pkt_info, skb->data);

79
drivers/net/wireless/realtek/rtw89/cam.c
View File

@ -211,6 +211,46 @@ static int rtw89_cam_get_addr_cam_key_idx(struct rtw89_addr_cam_entry *addr_cam,
return 0;
}
static int rtw89_cam_detach_sec_cam(struct rtw89_dev *rtwdev,
struct ieee80211_vif *vif,
struct ieee80211_sta *sta,
const struct rtw89_sec_cam_entry *sec_cam,
bool inform_fw)
{
struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
struct rtw89_vif *rtwvif;
struct rtw89_addr_cam_entry *addr_cam;
unsigned int i;
int ret = 0;
if (!vif) {
rtw89_err(rtwdev, "No iface for deleting sec cam\n");
return -EINVAL;
}
rtwvif = (struct rtw89_vif *)vif->drv_priv;
addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
for_each_set_bit(i, addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM) {
if (addr_cam->sec_ent[i] != sec_cam->sec_cam_idx)
continue;
clear_bit(i, addr_cam->sec_cam_map);
}
if (inform_fw) {
ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif, rtwsta);
if (ret)
rtw89_err(rtwdev,
"failed to update dctl cam del key: %d\n", ret);
ret = rtw89_fw_h2c_cam(rtwdev, rtwvif, rtwsta, NULL);
if (ret)
rtw89_err(rtwdev, "failed to update cam del key: %d\n", ret);
}
return ret;
}
static int rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
struct ieee80211_vif *vif,
struct ieee80211_sta *sta,
@ -242,10 +282,8 @@ static int rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
return ret;
}
key->hw_key_idx = key_idx;
addr_cam->sec_ent_keyid[key_idx] = key->keyidx;
addr_cam->sec_ent[key_idx] = sec_cam->sec_cam_idx;
addr_cam->sec_entries[key_idx] = sec_cam;
set_bit(key_idx, addr_cam->sec_cam_map);
ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif, rtwsta);
if (ret) {
@ -258,7 +296,6 @@ static int rtw89_cam_attach_sec_cam(struct rtw89_dev *rtwdev,
rtw89_err(rtwdev, "failed to update addr cam sec entry: %d\n",
ret);
clear_bit(key_idx, addr_cam->sec_cam_map);
addr_cam->sec_entries[key_idx] = NULL;
return ret;
}
@ -295,6 +332,9 @@ static int rtw89_cam_sec_key_install(struct rtw89_dev *rtwdev,
goto err_release_cam;
}
key->hw_key_idx = sec_cam_idx;
cam_info->sec_entries[sec_cam_idx] = sec_cam;
sec_cam->sec_cam_idx = sec_cam_idx;
sec_cam->type = hw_key_type;
sec_cam->len = RTW89_SEC_CAM_LEN;
@ -316,6 +356,7 @@ static int rtw89_cam_sec_key_install(struct rtw89_dev *rtwdev,
return 0;
err_release_cam:
cam_info->sec_entries[sec_cam_idx] = NULL;
kfree(sec_cam);
clear_bit(sec_cam_idx, cam_info->sec_cam_map);
if (ext_key)
@ -386,42 +427,22 @@ int rtw89_cam_sec_key_del(struct rtw89_dev *rtwdev,
struct ieee80211_key_conf *key,
bool inform_fw)
{
struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
struct rtw89_vif *rtwvif;
struct rtw89_addr_cam_entry *addr_cam;
struct rtw89_sec_cam_entry *sec_cam;
u8 key_idx = key->hw_key_idx;
const struct rtw89_sec_cam_entry *sec_cam;
u8 sec_cam_idx;
int ret = 0;
int ret;
if (!vif) {
rtw89_err(rtwdev, "No iface for deleting sec cam\n");
return -EINVAL;
}
rtwvif = (struct rtw89_vif *)vif->drv_priv;
addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
sec_cam = addr_cam->sec_entries[key_idx];
sec_cam_idx = key->hw_key_idx;
sec_cam = cam_info->sec_entries[sec_cam_idx];
if (!sec_cam)
return -EINVAL;
/* detach sec cam from addr cam */
clear_bit(key_idx, addr_cam->sec_cam_map);
addr_cam->sec_entries[key_idx] = NULL;
if (inform_fw) {
ret = rtw89_chip_h2c_dctl_sec_cam(rtwdev, rtwvif, rtwsta);
if (ret)
rtw89_err(rtwdev, "failed to update dctl cam del key: %d\n", ret);
ret = rtw89_fw_h2c_cam(rtwdev, rtwvif, rtwsta, NULL);
if (ret)
rtw89_err(rtwdev, "failed to update cam del key: %d\n", ret);
}
ret = rtw89_cam_detach_sec_cam(rtwdev, vif, sta, sec_cam, inform_fw);
/* clear valid bit in addr cam will disable sec cam,
* so we don't need to send H2C command again
*/
sec_cam_idx = sec_cam->sec_cam_idx;
cam_info->sec_entries[sec_cam_idx] = NULL;
clear_bit(sec_cam_idx, cam_info->sec_cam_map);
if (sec_cam->ext_key)
clear_bit(sec_cam_idx + 1, cam_info->sec_cam_map);

5
drivers/net/wireless/realtek/rtw89/chan.c
View File

@ -2322,7 +2322,6 @@ static void rtw89_swap_sub_entity(struct rtw89_dev *rtwdev,
enum rtw89_sub_entity_idx idx2)
{
struct rtw89_hal *hal = &rtwdev->hal;
struct rtw89_sub_entity tmp;
struct rtw89_vif *rtwvif;
u8 cur;
@ -2332,9 +2331,7 @@ static void rtw89_swap_sub_entity(struct rtw89_dev *rtwdev,
hal->sub[idx1].cfg->idx = idx2;
hal->sub[idx2].cfg->idx = idx1;
tmp = hal->sub[idx1];
hal->sub[idx1] = hal->sub[idx2];
hal->sub[idx2] = tmp;
swap(hal->sub[idx1], hal->sub[idx2]);
rtw89_for_each_rtwvif(rtwdev, rtwvif) {
if (!rtwvif->chanctx_assigned)

107
drivers/net/wireless/realtek/rtw89/core.c
View File

@ -499,31 +499,21 @@ static void
rtw89_core_tx_update_sec_key(struct rtw89_dev *rtwdev,
struct rtw89_core_tx_request *tx_req)
{
struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
const struct rtw89_chip_info *chip = rtwdev->chip;
struct ieee80211_vif *vif = tx_req->vif;
struct ieee80211_sta *sta = tx_req->sta;
const struct rtw89_sec_cam_entry *sec_cam;
struct ieee80211_tx_info *info;
struct ieee80211_key_conf *key;
struct rtw89_vif *rtwvif;
struct rtw89_sta *rtwsta = sta_to_rtwsta_safe(sta);
struct rtw89_addr_cam_entry *addr_cam;
struct rtw89_sec_cam_entry *sec_cam;
struct rtw89_tx_desc_info *desc_info = &tx_req->desc_info;
struct sk_buff *skb = tx_req->skb;
u8 sec_type = RTW89_SEC_KEY_TYPE_NONE;
u8 sec_cam_idx;
u64 pn64;
if (!vif) {
rtw89_warn(rtwdev, "cannot set sec key without vif\n");
return;
}
rtwvif = (struct rtw89_vif *)vif->drv_priv;
addr_cam = rtw89_get_addr_cam_of(rtwvif, rtwsta);
info = IEEE80211_SKB_CB(skb);
key = info->control.hw_key;
sec_cam = addr_cam->sec_entries[key->hw_key_idx];
sec_cam_idx = key->hw_key_idx;
sec_cam = cam_info->sec_entries[sec_cam_idx];
if (!sec_cam) {
rtw89_warn(rtwdev, "sec cam entry is empty\n");
return;
@ -823,6 +813,8 @@ rtw89_core_tx_update_data_info(struct rtw89_dev *rtwdev,
desc_info->mac_id = rtw89_core_tx_get_mac_id(rtwdev, tx_req);
desc_info->port = desc_info->hiq ? rtwvif->port : 0;
desc_info->er_cap = rtwsta ? rtwsta->er_cap : false;
desc_info->stbc = rtwsta ? rtwsta->ra.stbc_cap : false;
desc_info->ldpc = rtwsta ? rtwsta->ra.ldpc_cap : false;
/* enable wd_info for AMPDU */
desc_info->en_wd_info = true;
@ -1137,6 +1129,8 @@ static __le32 rtw89_build_txwd_info0(struct rtw89_tx_desc_info *desc_info)
{
u32 dword = FIELD_PREP(RTW89_TXWD_INFO0_USE_RATE, desc_info->use_rate) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_RATE, desc_info->data_rate) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_STBC, desc_info->stbc) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_LDPC, desc_info->ldpc) |
FIELD_PREP(RTW89_TXWD_INFO0_DISDATAFB, desc_info->dis_data_fb) |
FIELD_PREP(RTW89_TXWD_INFO0_MULTIPORT_ID, desc_info->port);
@ -1145,7 +1139,9 @@ static __le32 rtw89_build_txwd_info0(struct rtw89_tx_desc_info *desc_info)
static __le32 rtw89_build_txwd_info0_v1(struct rtw89_tx_desc_info *desc_info)
{
u32 dword = FIELD_PREP(RTW89_TXWD_INFO0_DISDATAFB, desc_info->dis_data_fb) |
u32 dword = FIELD_PREP(RTW89_TXWD_INFO0_DATA_STBC, desc_info->stbc) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_LDPC, desc_info->ldpc) |
FIELD_PREP(RTW89_TXWD_INFO0_DISDATAFB, desc_info->dis_data_fb) |
FIELD_PREP(RTW89_TXWD_INFO0_MULTIPORT_ID, desc_info->port) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_ER, desc_info->er_cap) |
FIELD_PREP(RTW89_TXWD_INFO0_DATA_BW_ER, 0);
@ -1311,7 +1307,9 @@ static __le32 rtw89_build_txwd_body7_v2(struct rtw89_tx_desc_info *desc_info)
static __le32 rtw89_build_txwd_info0_v2(struct rtw89_tx_desc_info *desc_info)
{
u32 dword = FIELD_PREP(BE_TXD_INFO0_DISDATAFB, desc_info->dis_data_fb) |
u32 dword = FIELD_PREP(BE_TXD_INFO0_DATA_STBC, desc_info->stbc) |
FIELD_PREP(BE_TXD_INFO0_DATA_LDPC, desc_info->ldpc) |
FIELD_PREP(BE_TXD_INFO0_DISDATAFB, desc_info->dis_data_fb) |
FIELD_PREP(BE_TXD_INFO0_MULTIPORT_ID, desc_info->port);
return cpu_to_le32(dword);
@ -1559,6 +1557,12 @@ static void rtw89_core_parse_phy_status_ie01(struct rtw89_dev *rtwdev,
u32 t;
phy_ppdu->chan_idx = le32_get_bits(ie->w0, RTW89_PHY_STS_IE01_W0_CH_IDX);
if (rtwdev->hw->conf.flags & IEEE80211_CONF_MONITOR) {
phy_ppdu->ldpc = le32_get_bits(ie->w2, RTW89_PHY_STS_IE01_W2_LDPC);
phy_ppdu->stbc = le32_get_bits(ie->w2, RTW89_PHY_STS_IE01_W2_STBC);
}
if (phy_ppdu->rate < RTW89_HW_RATE_OFDM6)
return;
@ -1984,6 +1988,23 @@ static void rtw89_core_hw_to_sband_rate(struct ieee80211_rx_status *rx_status)
rx_status->rate_idx -= 4;
}
static
void rtw89_core_update_rx_status_by_ppdu(struct rtw89_dev *rtwdev,
struct ieee80211_rx_status *rx_status,
struct rtw89_rx_phy_ppdu *phy_ppdu)
{
if (!(rtwdev->hw->conf.flags & IEEE80211_CONF_MONITOR))
return;
if (!phy_ppdu)
return;
if (phy_ppdu->ldpc)
rx_status->enc_flags |= RX_ENC_FLAG_LDPC;
if (phy_ppdu->stbc)
rx_status->enc_flags |= u8_encode_bits(1, RX_ENC_FLAG_STBC_MASK);
}
static const u8 rx_status_bw_to_radiotap_eht_usig[] = {
[RATE_INFO_BW_20] = IEEE80211_RADIOTAP_EHT_USIG_COMMON_BW_20MHZ,
[RATE_INFO_BW_5] = U8_MAX,
@ -2027,10 +2048,14 @@ static void rtw89_core_update_radiotap_eht(struct rtw89_dev *rtwdev,
eht->user_info[0] =
cpu_to_le32(IEEE80211_RADIOTAP_EHT_USER_INFO_MCS_KNOWN |
IEEE80211_RADIOTAP_EHT_USER_INFO_NSS_KNOWN_O);
IEEE80211_RADIOTAP_EHT_USER_INFO_NSS_KNOWN_O |
IEEE80211_RADIOTAP_EHT_USER_INFO_CODING_KNOWN);
eht->user_info[0] |=
le32_encode_bits(rx_status->rate_idx, IEEE80211_RADIOTAP_EHT_USER_INFO_MCS) |
le32_encode_bits(rx_status->nss, IEEE80211_RADIOTAP_EHT_USER_INFO_NSS_O);
if (rx_status->enc_flags & RX_ENC_FLAG_LDPC)
eht->user_info[0] |=
cpu_to_le32(IEEE80211_RADIOTAP_EHT_USER_INFO_CODING);
/* U-SIG */
tlv = (void *)tlv + sizeof(*tlv) + ALIGN(eht_len, 4);
@ -2056,6 +2081,8 @@ static void rtw89_core_update_radiotap(struct rtw89_dev *rtwdev,
{
static const struct ieee80211_radiotap_he known_he = {
.data1 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA1_DATA_MCS_KNOWN |
IEEE80211_RADIOTAP_HE_DATA1_CODING_KNOWN |
IEEE80211_RADIOTAP_HE_DATA1_STBC_KNOWN |
IEEE80211_RADIOTAP_HE_DATA1_BW_RU_ALLOC_KNOWN),
.data2 = cpu_to_le16(IEEE80211_RADIOTAP_HE_DATA2_GI_KNOWN),
};
@ -2087,6 +2114,7 @@ static void rtw89_core_rx_to_mac80211(struct rtw89_dev *rtwdev,
rtw89_core_hw_to_sband_rate(rx_status);
rtw89_core_rx_stats(rtwdev, phy_ppdu, desc_info, skb_ppdu);
rtw89_core_update_rx_status_by_ppdu(rtwdev, rx_status, phy_ppdu);
rtw89_core_update_radiotap(rtwdev, skb_ppdu, rx_status);
/* In low power mode, it does RX in thread context. */
local_bh_disable();
@ -2492,11 +2520,15 @@ void rtw89_core_napi_stop(struct rtw89_dev *rtwdev)
}
EXPORT_SYMBOL(rtw89_core_napi_stop);
void rtw89_core_napi_init(struct rtw89_dev *rtwdev)
int rtw89_core_napi_init(struct rtw89_dev *rtwdev)
{
init_dummy_netdev(&rtwdev->netdev);
netif_napi_add(&rtwdev->netdev, &rtwdev->napi,
rtwdev->netdev = alloc_netdev_dummy(0);
if (!rtwdev->netdev)
return -ENOMEM;
netif_napi_add(rtwdev->netdev, &rtwdev->napi,
rtwdev->hci.ops->napi_poll);
return 0;
}
EXPORT_SYMBOL(rtw89_core_napi_init);
@ -2504,6 +2536,7 @@ void rtw89_core_napi_deinit(struct rtw89_dev *rtwdev)
{
rtw89_core_napi_stop(rtwdev);
netif_napi_del(&rtwdev->napi);
free_netdev(rtwdev->netdev);
}
EXPORT_SYMBOL(rtw89_core_napi_deinit);
@ -3348,14 +3381,13 @@ int rtw89_core_sta_add(struct rtw89_dev *rtwdev,
BTC_ROLE_MSTS_STA_CONN_START);
rtw89_chip_rfk_channel(rtwdev);
} else if (vif->type == NL80211_IFTYPE_AP || sta->tdls) {
rtwsta->mac_id = rtw89_core_acquire_bit_map(rtwdev->mac_id_map,
RTW89_MAX_MAC_ID_NUM);
rtwsta->mac_id = rtw89_acquire_mac_id(rtwdev);
if (rtwsta->mac_id == RTW89_MAX_MAC_ID_NUM)
return -ENOSPC;
ret = rtw89_mac_set_macid_pause(rtwdev, rtwsta->mac_id, false);
if (ret) {
rtw89_core_release_bit_map(rtwdev->mac_id_map, rtwsta->mac_id);
rtw89_release_mac_id(rtwdev, rtwsta->mac_id);
rtw89_warn(rtwdev, "failed to send h2c macid pause\n");
return ret;
}
@ -3363,7 +3395,7 @@ int rtw89_core_sta_add(struct rtw89_dev *rtwdev,
ret = rtw89_fw_h2c_role_maintain(rtwdev, rtwvif, rtwsta,
RTW89_ROLE_CREATE);
if (ret) {
rtw89_core_release_bit_map(rtwdev->mac_id_map, rtwsta->mac_id);
rtw89_release_mac_id(rtwdev, rtwsta->mac_id);
rtw89_warn(rtwdev, "failed to send h2c role info\n");
return ret;
}
@ -3536,7 +3568,7 @@ int rtw89_core_sta_remove(struct rtw89_dev *rtwdev,
rtw89_btc_ntfy_role_info(rtwdev, rtwvif, rtwsta,
BTC_ROLE_MSTS_STA_DIS_CONN);
} else if (vif->type == NL80211_IFTYPE_AP || sta->tdls) {
rtw89_core_release_bit_map(rtwdev->mac_id_map, rtwsta->mac_id);
rtw89_release_mac_id(rtwdev, rtwsta->mac_id);
ret = rtw89_fw_h2c_role_maintain(rtwdev, rtwvif, rtwsta,
RTW89_ROLE_REMOVE);
@ -4186,6 +4218,25 @@ void rtw89_core_stop(struct rtw89_dev *rtwdev)
rtw89_hci_reset(rtwdev);
}
u8 rtw89_acquire_mac_id(struct rtw89_dev *rtwdev)
{
const struct rtw89_chip_info *chip = rtwdev->chip;
u8 mac_id_num = chip->support_macid_num;
u8 mac_id;
mac_id = find_first_zero_bit(rtwdev->mac_id_map, mac_id_num);
if (mac_id == mac_id_num)
return RTW89_MAX_MAC_ID_NUM;
set_bit(mac_id, rtwdev->mac_id_map);
return mac_id;
}
void rtw89_release_mac_id(struct rtw89_dev *rtwdev, u8 mac_id)
{
clear_bit(mac_id, rtwdev->mac_id_map);
}
int rtw89_core_init(struct rtw89_dev *rtwdev)
{
struct rtw89_btc *btc = &rtwdev->btc;
@ -4475,6 +4526,10 @@ static int rtw89_core_register_hw(struct rtw89_dev *rtwdev)
hw->max_tx_aggregation_subframes = RTW89_MAX_TX_AGG_NUM;
hw->uapsd_max_sp_len = IEEE80211_WMM_IE_STA_QOSINFO_SP_ALL;
hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC |
IEEE80211_RADIOTAP_MCS_HAVE_STBC;
hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC;
ieee80211_hw_set(hw, SIGNAL_DBM);
ieee80211_hw_set(hw, HAS_RATE_CONTROL);
ieee80211_hw_set(hw, MFP_CAPABLE);

20
drivers/net/wireless/realtek/rtw89/core.h
View File

@ -793,6 +793,8 @@ struct rtw89_rx_phy_ppdu {
u8 evm_max;
u8 evm_min;
} ofdm;
bool ldpc;
bool stbc;
bool to_self;
bool valid;
};
@ -884,6 +886,13 @@ enum rtw89_ps_mode {
#define RTW89_BYR_BW_NUM (RTW89_CHANNEL_WIDTH_320 + 1)
#define RTW89_PPE_BW_NUM (RTW89_CHANNEL_WIDTH_320 + 1)
enum rtw89_pe_duration {
RTW89_PE_DURATION_0 = 0,
RTW89_PE_DURATION_8 = 1,
RTW89_PE_DURATION_16 = 2,
RTW89_PE_DURATION_16_20 = 3,
};
enum rtw89_ru_bandwidth {
RTW89_RU26 = 0,
RTW89_RU52 = 1,
@ -1129,6 +1138,8 @@ struct rtw89_tx_desc_info {
bool hiq;
u8 port;
bool er_cap;
bool stbc;
bool ldpc;
};
struct rtw89_core_tx_request {
@ -3249,7 +3260,6 @@ struct rtw89_addr_cam_entry {
DECLARE_BITMAP(sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM);
u8 sec_ent_keyid[RTW89_SEC_CAM_IN_ADDR_CAM];
u8 sec_ent[RTW89_SEC_CAM_IN_ADDR_CAM];
struct rtw89_sec_cam_entry *sec_entries[RTW89_SEC_CAM_IN_ADDR_CAM];
};
struct rtw89_bssid_cam_entry {
@ -4144,6 +4154,7 @@ struct rtw89_chip_info {
u8 wde_qempty_acq_grpnum;
u8 wde_qempty_mgq_grpsel;
u32 rf_base_addr[2];
u8 support_macid_num;
u8 support_chanctx_num;
u8 support_bands;
u16 support_bandwidths;
@ -4436,6 +4447,7 @@ struct rtw89_cam_info {
DECLARE_BITMAP(sec_cam_map, RTW89_MAX_SEC_CAM_NUM);
DECLARE_BITMAP(ba_cam_map, RTW89_MAX_BA_CAM_NUM);
struct rtw89_ba_cam_entry ba_cam_entry[RTW89_MAX_BA_CAM_NUM];
const struct rtw89_sec_cam_entry *sec_entries[RTW89_MAX_SEC_CAM_NUM];
};
enum rtw89_sar_sources {
@ -5469,7 +5481,7 @@ struct rtw89_dev {
struct rtw89_wow_param wow;
/* napi structure */
struct net_device netdev;
struct net_device *netdev;
struct napi_struct napi;
int napi_budget_countdown;
@ -6441,7 +6453,7 @@ void rtw89_core_query_rxdesc_v2(struct rtw89_dev *rtwdev,
u8 *data, u32 data_offset);
void rtw89_core_napi_start(struct rtw89_dev *rtwdev);
void rtw89_core_napi_stop(struct rtw89_dev *rtwdev);
void rtw89_core_napi_init(struct rtw89_dev *rtwdev);
int rtw89_core_napi_init(struct rtw89_dev *rtwdev);
void rtw89_core_napi_deinit(struct rtw89_dev *rtwdev);
int rtw89_core_sta_add(struct rtw89_dev *rtwdev,
struct ieee80211_vif *vif,
@ -6470,6 +6482,8 @@ struct rtw89_dev *rtw89_alloc_ieee80211_hw(struct device *device,
u32 bus_data_size,
const struct rtw89_chip_info *chip);
void rtw89_free_ieee80211_hw(struct rtw89_dev *rtwdev);
u8 rtw89_acquire_mac_id(struct rtw89_dev *rtwdev);
void rtw89_release_mac_id(struct rtw89_dev *rtwdev, u8 mac_id);
void rtw89_core_set_chip_txpwr(struct rtw89_dev *rtwdev);
void rtw89_get_default_chandef(struct cfg80211_chan_def *chandef);
void rtw89_get_channel_params(const struct cfg80211_chan_def *chandef,

16
drivers/net/wireless/realtek/rtw89/debug.c
View File

@ -3645,17 +3645,21 @@ static int rtw89_debug_priv_phy_info_get(struct seq_file *m, void *v)
}
static void rtw89_dump_addr_cam(struct seq_file *m,
struct rtw89_dev *rtwdev,
struct rtw89_addr_cam_entry *addr_cam)
{
struct rtw89_sec_cam_entry *sec_entry;
struct rtw89_cam_info *cam_info = &rtwdev->cam_info;
const struct rtw89_sec_cam_entry *sec_entry;
u8 sec_cam_idx;
int i;
seq_printf(m, "\taddr_cam_idx=%u\n", addr_cam->addr_cam_idx);
seq_printf(m, "\t-> bssid_cam_idx=%u\n", addr_cam->bssid_cam_idx);
seq_printf(m, "\tsec_cam_bitmap=%*ph\n", (int)sizeof(addr_cam->sec_cam_map),
addr_cam->sec_cam_map);
for (i = 0; i < RTW89_SEC_CAM_IN_ADDR_CAM; i++) {
sec_entry = addr_cam->sec_entries[i];
for_each_set_bit(i, addr_cam->sec_cam_map, RTW89_SEC_CAM_IN_ADDR_CAM) {
sec_cam_idx = addr_cam->sec_ent[i];
sec_entry = cam_info->sec_entries[sec_cam_idx];
if (!sec_entry)
continue;
seq_printf(m, "\tsec[%d]: sec_cam_idx %u", i, sec_entry->sec_cam_idx);
@ -3694,12 +3698,13 @@ static
void rtw89_vif_ids_get_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
{
struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
struct rtw89_dev *rtwdev = rtwvif->rtwdev;
struct seq_file *m = (struct seq_file *)data;
struct rtw89_bssid_cam_entry *bssid_cam = &rtwvif->bssid_cam;
seq_printf(m, "VIF [%d] %pM\n", rtwvif->mac_id, rtwvif->mac_addr);
seq_printf(m, "\tbssid_cam_idx=%u\n", bssid_cam->bssid_cam_idx);
rtw89_dump_addr_cam(m, &rtwvif->addr_cam);
rtw89_dump_addr_cam(m, rtwdev, &rtwvif->addr_cam);
rtw89_dump_pkt_offload(m, &rtwvif->general_pkt_list, "\tpkt_ofld[GENERAL]: ");
}
@ -3726,11 +3731,12 @@ static void rtw89_dump_ba_cam(struct seq_file *m, struct rtw89_sta *rtwsta)
static void rtw89_sta_ids_get_iter(void *data, struct ieee80211_sta *sta)
{
struct rtw89_sta *rtwsta = (struct rtw89_sta *)sta->drv_priv;
struct rtw89_dev *rtwdev = rtwsta->rtwdev;
struct seq_file *m = (struct seq_file *)data;
seq_printf(m, "STA [%d] %pM %s\n", rtwsta->mac_id, sta->addr,
sta->tdls ? "(TDLS)" : "");
rtw89_dump_addr_cam(m, &rtwsta->addr_cam);
rtw89_dump_addr_cam(m, rtwdev, &rtwsta->addr_cam);
rtw89_dump_ba_cam(m, rtwsta);
}

31
drivers/net/wireless/realtek/rtw89/fw.c
View File

@ -2752,11 +2752,11 @@ static void __get_sta_he_pkt_padding(struct rtw89_dev *rtwdev,
ppe8 = (ppe >> sh) & IEEE80211_PPE_THRES_NSS_MASK;
if (ppe16 != 7 && ppe8 == 7)
pads[i] = 2;
pads[i] = RTW89_PE_DURATION_16;
else if (ppe8 != 7)
pads[i] = 1;
pads[i] = RTW89_PE_DURATION_8;
else
pads[i] = 0;
pads[i] = RTW89_PE_DURATION_0;
}
}
@ -2889,11 +2889,11 @@ static void __get_sta_eht_pkt_padding(struct rtw89_dev *rtwdev,
ppe8 = (ppe >> sh) & IEEE80211_PPE_THRES_NSS_MASK;
if (ppe16 != 7 && ppe8 == 7)
pads[i] = 2;
pads[i] = RTW89_PE_DURATION_16_20;
else if (ppe8 != 7)
pads[i] = 1;
pads[i] = RTW89_PE_DURATION_8;
else
pads[i] = 0;
pads[i] = RTW89_PE_DURATION_0;
}
}
@ -4850,6 +4850,7 @@ int rtw89_fw_h2c_scan_offload_be(struct rtw89_dev *rtwdev,
{
struct rtw89_hw_scan_info *scan_info = &rtwdev->scan_info;
struct rtw89_wait_info *wait = &rtwdev->mac.fw_ofld_wait;
struct cfg80211_scan_request *req = rtwvif->scan_req;
struct rtw89_h2c_scanofld_be_macc_role *macc_role;
struct rtw89_chan *op = &scan_info->op_chan;
struct rtw89_h2c_scanofld_be_opch *opch;
@ -4923,6 +4924,15 @@ int rtw89_fw_h2c_scan_offload_be(struct rtw89_dev *rtwdev,
RTW89_H2C_SCANOFLD_BE_W6_CHAN_PROHIB_LOW);
h2c->w7 = le32_encode_bits(option->prohib_chan >> 32,
RTW89_H2C_SCANOFLD_BE_W7_CHAN_PROHIB_HIGH);
if (req->no_cck) {
h2c->w0 |= le32_encode_bits(true, RTW89_H2C_SCANOFLD_BE_W0_PROBE_WITH_RATE);
h2c->w8 = le32_encode_bits(RTW89_HW_RATE_OFDM6,
RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_2GHZ) |
le32_encode_bits(RTW89_HW_RATE_OFDM6,
RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_5GHZ) |
le32_encode_bits(RTW89_HW_RATE_OFDM6,
RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_6GHZ);
}
ptr += sizeof(*h2c);
for (i = 0; i < option->num_macc_role; i++) {
@ -6245,7 +6255,14 @@ void rtw89_hw_scan_abort(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif)
ret = rtw89_hw_scan_offload(rtwdev, vif, false);
if (ret)
rtw89_hw_scan_complete(rtwdev, vif, true);
rtw89_warn(rtwdev, "rtw89_hw_scan_offload failed ret %d\n", ret);
/* Indicate ieee80211_scan_completed() before returning, which is safe
* because scan abort command always waits for completion of
* RTW89_SCAN_END_SCAN_NOTIFY, so that ieee80211_stop() can flush scan
* work properly.
*/
rtw89_hw_scan_complete(rtwdev, vif, true);
}
static bool rtw89_is_any_vif_connected_or_connecting(struct rtw89_dev *rtwdev)

4
drivers/net/wireless/realtek/rtw89/fw.h
View File

@ -2722,6 +2722,7 @@ struct rtw89_h2c_scanofld_be {
#define RTW89_H2C_SCANOFLD_BE_W0_MACID GENMASK(23, 8)
#define RTW89_H2C_SCANOFLD_BE_W0_PORT GENMASK(26, 24)
#define RTW89_H2C_SCANOFLD_BE_W0_BAND GENMASK(28, 27)
#define RTW89_H2C_SCANOFLD_BE_W0_PROBE_WITH_RATE BIT(29)
#define RTW89_H2C_SCANOFLD_BE_W1_NUM_MACC_ROLE GENMASK(7, 0)
#define RTW89_H2C_SCANOFLD_BE_W1_NUM_OP GENMASK(15, 8)
#define RTW89_H2C_SCANOFLD_BE_W1_NORM_PD GENMASK(31, 16)
@ -2738,6 +2739,9 @@ struct rtw89_h2c_scanofld_be {
#define RTW89_H2C_SCANOFLD_BE_W5_MLO_MODE GENMASK(31, 0)
#define RTW89_H2C_SCANOFLD_BE_W6_CHAN_PROHIB_LOW GENMASK(31, 0)
#define RTW89_H2C_SCANOFLD_BE_W7_CHAN_PROHIB_HIGH GENMASK(31, 0)
#define RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_2GHZ GENMASK(7, 0)
#define RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_5GHZ GENMASK(15, 8)
#define RTW89_H2C_SCANOFLD_BE_W8_PROBE_RATE_6GHZ GENMASK(23, 16)
static inline void RTW89_SET_FWCMD_P2P_MACID(void *cmd, u32 val)
{

12
drivers/net/wireless/realtek/rtw89/mac.c
View File

@ -4664,8 +4664,7 @@ int rtw89_mac_add_vif(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
{
int ret;
rtwvif->mac_id = rtw89_core_acquire_bit_map(rtwdev->mac_id_map,
RTW89_MAX_MAC_ID_NUM);
rtwvif->mac_id = rtw89_acquire_mac_id(rtwdev);
if (rtwvif->mac_id == RTW89_MAX_MAC_ID_NUM)
return -ENOSPC;
@ -4676,7 +4675,7 @@ int rtw89_mac_add_vif(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
return 0;
release_mac_id:
rtw89_core_release_bit_map(rtwdev->mac_id_map, rtwvif->mac_id);
rtw89_release_mac_id(rtwdev, rtwvif->mac_id);
return ret;
}
@ -4686,7 +4685,7 @@ int rtw89_mac_remove_vif(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
int ret;
ret = rtw89_mac_vif_deinit(rtwdev, rtwvif);
rtw89_core_release_bit_map(rtwdev->mac_id_map, rtwvif->mac_id);
rtw89_release_mac_id(rtwdev, rtwvif->mac_id);
return ret;
}
@ -4757,6 +4756,9 @@ rtw89_mac_c2h_scanofld_rsp(struct rtw89_dev *rtwdev, struct sk_buff *skb,
}
return;
case RTW89_SCAN_END_SCAN_NOTIFY:
if (rtwdev->scan_info.abort)
return;
if (rtwvif && rtwvif->scan_req &&
last_chan < rtwvif->scan_req->n_channels) {
ret = rtw89_hw_scan_offload(rtwdev, vif, true);
@ -4765,7 +4767,7 @@ rtw89_mac_c2h_scanofld_rsp(struct rtw89_dev *rtwdev, struct sk_buff *skb,
rtw89_warn(rtwdev, "HW scan failed: %d\n", ret);
}
} else {
rtw89_hw_scan_complete(rtwdev, vif, rtwdev->scan_info.abort);
rtw89_hw_scan_complete(rtwdev, vif, false);
}
break;
case RTW89_SCAN_ENTER_OP_NOTIFY:

42
drivers/net/wireless/realtek/rtw89/mac80211.c
View File

@ -397,15 +397,14 @@ static void rtw89_conf_tx(struct rtw89_dev *rtwdev,
}
static void rtw89_station_mode_sta_assoc(struct rtw89_dev *rtwdev,
struct ieee80211_vif *vif,
struct ieee80211_bss_conf *conf)
struct ieee80211_vif *vif)
{
struct ieee80211_sta *sta;
if (vif->type != NL80211_IFTYPE_STATION)
return;
sta = ieee80211_find_sta(vif, conf->bssid);
sta = ieee80211_find_sta(vif, vif->cfg.ap_addr);
if (!sta) {
rtw89_err(rtwdev, "can't find sta to set sta_assoc state\n");
return;
@ -416,10 +415,8 @@ static void rtw89_station_mode_sta_assoc(struct rtw89_dev *rtwdev,
rtw89_core_sta_assoc(rtwdev, vif, sta);
}
static void rtw89_ops_bss_info_changed(struct ieee80211_hw *hw,
struct ieee80211_vif *vif,
struct ieee80211_bss_conf *conf,
u64 changed)
static void rtw89_ops_vif_cfg_changed(struct ieee80211_hw *hw,
struct ieee80211_vif *vif, u64 changed)
{
struct rtw89_dev *rtwdev = hw->priv;
struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
@ -429,7 +426,7 @@ static void rtw89_ops_bss_info_changed(struct ieee80211_hw *hw,
if (changed & BSS_CHANGED_ASSOC) {
if (vif->cfg.assoc) {
rtw89_station_mode_sta_assoc(rtwdev, vif, conf);
rtw89_station_mode_sta_assoc(rtwdev, vif);
rtw89_phy_set_bss_color(rtwdev, vif);
rtw89_chip_cfg_txpwr_ul_tb_offset(rtwdev, vif);
rtw89_mac_port_update(rtwdev, rtwvif);
@ -445,6 +442,26 @@ static void rtw89_ops_bss_info_changed(struct ieee80211_hw *hw,
}
}
if (changed & BSS_CHANGED_PS)
rtw89_recalc_lps(rtwdev);
if (changed & BSS_CHANGED_ARP_FILTER)
rtwvif->ip_addr = vif->cfg.arp_addr_list[0];
mutex_unlock(&rtwdev->mutex);
}
static void rtw89_ops_link_info_changed(struct ieee80211_hw *hw,
struct ieee80211_vif *vif,
struct ieee80211_bss_conf *conf,
u64 changed)
{
struct rtw89_dev *rtwdev = hw->priv;
struct rtw89_vif *rtwvif = (struct rtw89_vif *)vif->drv_priv;
mutex_lock(&rtwdev->mutex);
rtw89_leave_ps_mode(rtwdev);
if (changed & BSS_CHANGED_BSSID) {
ether_addr_copy(rtwvif->bssid, conf->bssid);
rtw89_cam_bssid_changed(rtwdev, rtwvif);
@ -470,12 +487,6 @@ static void rtw89_ops_bss_info_changed(struct ieee80211_hw *hw,
if (changed & BSS_CHANGED_CQM)
rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, vif, true);
if (changed & BSS_CHANGED_PS)
rtw89_recalc_lps(rtwdev);
if (changed & BSS_CHANGED_ARP_FILTER)
rtwvif->ip_addr = vif->cfg.arp_addr_list[0];
mutex_unlock(&rtwdev->mutex);
}
@ -1143,7 +1154,8 @@ const struct ieee80211_ops rtw89_ops = {
.change_interface = rtw89_ops_change_interface,
.remove_interface = rtw89_ops_remove_interface,
.configure_filter = rtw89_ops_configure_filter,
.bss_info_changed = rtw89_ops_bss_info_changed,
.vif_cfg_changed = rtw89_ops_vif_cfg_changed,
.link_info_changed = rtw89_ops_link_info_changed,
.start_ap = rtw89_ops_start_ap,
.stop_ap = rtw89_ops_stop_ap,
.set_tim = rtw89_ops_set_tim,

29
drivers/net/wireless/realtek/rtw89/pci.c
View File

@ -2330,21 +2330,20 @@ static void rtw89_pci_disable_eq(struct rtw89_dev *rtwdev)
u32 backup_aspm;
u32 phy_offset;
u16 oobs_val;
u16 val16;
int ret;
if (rtwdev->chip->chip_id != RTL8852C)
return;
backup_aspm = rtw89_read32(rtwdev, R_AX_PCIE_MIX_CFG_V1);
rtw89_write32_clr(rtwdev, R_AX_PCIE_MIX_CFG_V1, B_AX_ASPM_CTRL_MASK);
g1_oobs = rtw89_read16_mask(rtwdev, R_RAC_DIRECT_OFFSET_G1 +
RAC_ANA09 * RAC_MULT, BAC_OOBS_SEL);
g2_oobs = rtw89_read16_mask(rtwdev, R_RAC_DIRECT_OFFSET_G2 +
RAC_ANA09 * RAC_MULT, BAC_OOBS_SEL);
if (g1_oobs && g2_oobs)
goto out;
return;
backup_aspm = rtw89_read32(rtwdev, R_AX_PCIE_MIX_CFG_V1);
rtw89_write32_clr(rtwdev, R_AX_PCIE_MIX_CFG_V1, B_AX_ASPM_CTRL_MASK);
ret = rtw89_pci_get_phy_offset_by_link_speed(rtwdev, &phy_offset);
if (ret)
@ -2354,15 +2353,16 @@ static void rtw89_pci_disable_eq(struct rtw89_dev *rtwdev)
rtw89_write16(rtwdev, phy_offset + RAC_ANA10 * RAC_MULT, ADDR_SEL_PINOUT_DIS_VAL);
rtw89_write16_set(rtwdev, phy_offset + RAC_ANA19 * RAC_MULT, B_PCIE_BIT_RD_SEL);
val16 = rtw89_read16_mask(rtwdev, phy_offset + RAC_ANA1F * RAC_MULT,
OOBS_LEVEL_MASK);
oobs_val = u16_encode_bits(val16, OOBS_SEN_MASK);
oobs_val = rtw89_read16_mask(rtwdev, phy_offset + RAC_ANA1F * RAC_MULT,
OOBS_LEVEL_MASK);
rtw89_write16(rtwdev, R_RAC_DIRECT_OFFSET_G1 + RAC_ANA03 * RAC_MULT, oobs_val);
rtw89_write16_mask(rtwdev, R_RAC_DIRECT_OFFSET_G1 + RAC_ANA03 * RAC_MULT,
OOBS_SEN_MASK, oobs_val);
rtw89_write16_set(rtwdev, R_RAC_DIRECT_OFFSET_G1 + RAC_ANA09 * RAC_MULT,
BAC_OOBS_SEL);
rtw89_write16(rtwdev, R_RAC_DIRECT_OFFSET_G2 + RAC_ANA03 * RAC_MULT, oobs_val);
rtw89_write16_mask(rtwdev, R_RAC_DIRECT_OFFSET_G2 + RAC_ANA03 * RAC_MULT,
OOBS_SEN_MASK, oobs_val);
rtw89_write16_set(rtwdev, R_RAC_DIRECT_OFFSET_G2 + RAC_ANA09 * RAC_MULT,
BAC_OOBS_SEL);
@ -2783,7 +2783,6 @@ static int rtw89_pci_ops_mac_pre_init_ax(struct rtw89_dev *rtwdev)
const struct rtw89_pci_info *info = rtwdev->pci_info;
int ret;
rtw89_pci_disable_eq(rtwdev);
rtw89_pci_ber(rtwdev);
rtw89_pci_rxdma_prefth(rtwdev);
rtw89_pci_l1off_pwroff(rtwdev);
@ -4155,6 +4154,7 @@ static int __maybe_unused rtw89_pci_resume(struct device *dev)
B_AX_SEL_REQ_ENTR_L1);
}
rtw89_pci_l2_hci_ldo(rtwdev);
rtw89_pci_disable_eq(rtwdev);
rtw89_pci_filter_out(rtwdev);
rtw89_pci_link_cfg(rtwdev);
rtw89_pci_l1ss_cfg(rtwdev);
@ -4289,11 +4289,16 @@ int rtw89_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
goto err_clear_resource;
}
rtw89_pci_disable_eq(rtwdev);
rtw89_pci_filter_out(rtwdev);
rtw89_pci_link_cfg(rtwdev);
rtw89_pci_l1ss_cfg(rtwdev);
rtw89_core_napi_init(rtwdev);
ret = rtw89_core_napi_init(rtwdev);
if (ret) {
rtw89_err(rtwdev, "failed to init napi\n");
goto err_clear_resource;
}
ret = rtw89_pci_request_irq(rtwdev, pdev);
if (ret) {

1
drivers/net/wireless/realtek/rtw89/rtw8851b.c
View File

@ -2447,6 +2447,7 @@ const struct rtw89_chip_info rtw8851b_chip_info = {
.dig_table = NULL,
.dig_regs = &rtw8851b_dig_regs,
.tssi_dbw_table = NULL,
.support_macid_num = RTW89_MAX_MAC_ID_NUM,
.support_chanctx_num = 0,
.support_rnr = false,
.support_bands = BIT(NL80211_BAND_2GHZ) |

1
drivers/net/wireless/realtek/rtw89/rtw8852a.c
View File

@ -2162,6 +2162,7 @@ const struct rtw89_chip_info rtw8852a_chip_info = {
.dig_table = &rtw89_8852a_phy_dig_table,
.dig_regs = &rtw8852a_dig_regs,
.tssi_dbw_table = NULL,
.support_macid_num = RTW89_MAX_MAC_ID_NUM,
.support_chanctx_num = 1,
.support_rnr = false,
.support_bands = BIT(NL80211_BAND_2GHZ) |

7
drivers/net/wireless/realtek/rtw89/rtw8852b.c
View File

@ -403,6 +403,8 @@ static int rtw8852b_pwr_on_func(struct rtw89_dev *rtwdev)
u32 val32;
u32 ret;
rtw8852b_pwr_sps_ana(rtwdev);
rtw89_write32_clr(rtwdev, R_AX_SYS_PW_CTRL, B_AX_AFSM_WLSUS_EN |
B_AX_AFSM_PCIE_SUS_EN);
rtw89_write32_set(rtwdev, R_AX_SYS_PW_CTRL, B_AX_DIS_WLBT_PDNSUSEN_SOPC);
@ -530,9 +532,7 @@ static int rtw8852b_pwr_off_func(struct rtw89_dev *rtwdev)
u32 val32;
u32 ret;
/* Only do once during probe stage after reading efuse */
if (!test_bit(RTW89_FLAG_PROBE_DONE, rtwdev->flags))
rtw8852b_pwr_sps_ana(rtwdev);
rtw8852b_pwr_sps_ana(rtwdev);
ret = rtw89_mac_write_xtal_si(rtwdev, XTAL_SI_ANAPAR_WL, XTAL_SI_RFC2RF,
XTAL_SI_RFC2RF);
@ -2610,6 +2610,7 @@ const struct rtw89_chip_info rtw8852b_chip_info = {
.dig_table = NULL,
.dig_regs = &rtw8852b_dig_regs,
.tssi_dbw_table = NULL,
.support_macid_num = RTW89_MAX_MAC_ID_NUM,
.support_chanctx_num = 0,
.support_rnr = false,
.support_bands = BIT(NL80211_BAND_2GHZ) |

1
drivers/net/wireless/realtek/rtw89/rtw8852c.c
View File

@ -2941,6 +2941,7 @@ const struct rtw89_chip_info rtw8852c_chip_info = {
.dig_table = NULL,
.dig_regs = &rtw8852c_dig_regs,
.tssi_dbw_table = &rtw89_8852c_tssi_dbw_table,
.support_macid_num = RTW89_MAX_MAC_ID_NUM,
.support_chanctx_num = 2,
.support_rnr = false,
.support_bands = BIT(NL80211_BAND_2GHZ) |

1
drivers/net/wireless/realtek/rtw89/rtw8922a.c
View File

@ -2544,6 +2544,7 @@ const struct rtw89_chip_info rtw8922a_chip_info = {
.dig_table = NULL,
.dig_regs = &rtw8922a_dig_regs,
.tssi_dbw_table = NULL,
.support_macid_num = 32,
.support_chanctx_num = 2,
.support_rnr = true,
.support_bands = BIT(NL80211_BAND_2GHZ) |

8
drivers/net/wireless/realtek/rtw89/ser.c
View File

@ -308,9 +308,13 @@ static void ser_reset_vif(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif)
static void ser_sta_deinit_cam_iter(void *data, struct ieee80211_sta *sta)
{
struct rtw89_vif *rtwvif = (struct rtw89_vif *)data;
struct rtw89_dev *rtwdev = rtwvif->rtwdev;
struct rtw89_vif *target_rtwvif = (struct rtw89_vif *)data;
struct rtw89_sta *rtwsta = (struct rtw89_sta *)sta->drv_priv;
struct rtw89_vif *rtwvif = rtwsta->rtwvif;
struct rtw89_dev *rtwdev = rtwvif->rtwdev;
if (rtwvif != target_rtwvif)
return;
if (rtwvif->net_type == RTW89_NET_TYPE_AP_MODE || sta->tdls)
rtw89_cam_deinit_addr_cam(rtwdev, &rtwsta->addr_cam);

4
drivers/net/wireless/realtek/rtw89/txrx.h
View File

@ -113,6 +113,8 @@ static inline u8 rtw89_get_data_nss(struct rtw89_dev *rtwdev, u16 hw_rate)
#define RTW89_TXWD_INFO0_GI_LTF GENMASK(27, 25)
#define RTW89_TXWD_INFO0_DATA_RATE GENMASK(24, 16)
#define RTW89_TXWD_INFO0_DATA_ER BIT(15)
#define RTW89_TXWD_INFO0_DATA_STBC BIT(12)
#define RTW89_TXWD_INFO0_DATA_LDPC BIT(11)
#define RTW89_TXWD_INFO0_DISDATAFB BIT(10)
#define RTW89_TXWD_INFO0_DATA_BW_ER BIT(8)
#define RTW89_TXWD_INFO0_MULTIPORT_ID GENMASK(6, 4)
@ -556,6 +558,8 @@ struct rtw89_phy_sts_ie0 {
#define RTW89_PHY_STS_IE01_W2_AVG_SNR GENMASK(5, 0)
#define RTW89_PHY_STS_IE01_W2_EVM_MAX GENMASK(15, 8)
#define RTW89_PHY_STS_IE01_W2_EVM_MIN GENMASK(23, 16)
#define RTW89_PHY_STS_IE01_W2_LDPC BIT(28)
#define RTW89_PHY_STS_IE01_W2_STBC BIT(30)
enum rtw89_tx_channel {
RTW89_TXCH_ACH0 = 0,