/* Copyright(c) 2019-2020 Realtek Corporation
*/
#include <linux/ip.h>
+#include <linux/sort.h>
#include <linux/udp.h>
#include "cam.h"
return NULL;
}
-bool rtw89_ra_report_to_bitrate(struct rtw89_dev *rtwdev, u8 rpt_rate, u16 *bitrate)
+bool rtw89_legacy_rate_to_bitrate(struct rtw89_dev *rtwdev, u8 legacy_rate, u16 *bitrate)
{
- struct ieee80211_rate rate;
+ const struct ieee80211_rate *rate;
- if (unlikely(rpt_rate >= ARRAY_SIZE(rtw89_bitrates))) {
- rtw89_debug(rtwdev, RTW89_DBG_UNEXP, "invalid rpt rate %d\n", rpt_rate);
+ if (unlikely(legacy_rate >= ARRAY_SIZE(rtw89_bitrates))) {
+ rtw89_debug(rtwdev, RTW89_DBG_UNEXP,
+ "invalid legacy rate %d\n", legacy_rate);
return false;
}
- rate = rtw89_bitrates[rpt_rate];
- *bitrate = rate.bitrate;
+ rate = &rtw89_bitrates[legacy_rate];
+ *bitrate = rate->bitrate;
return true;
}
WRITE_ONCE(rtwvif_link->sync_bcn_tsf, le64_to_cpu(mgmt->u.beacon.timestamp));
}
+static u32 rtw89_bcn_calc_min_tbtt(struct rtw89_dev *rtwdev, u32 tbtt1, u32 tbtt2)
+{
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ u32 close_bcn_intvl_th = bcn_track->close_bcn_intvl_th;
+ u32 tbtt_diff_th = bcn_track->tbtt_diff_th;
+
+ if (tbtt2 > tbtt1)
+ swap(tbtt1, tbtt2);
+
+ if (tbtt1 - tbtt2 > tbtt_diff_th)
+ return tbtt1;
+ else if (tbtt2 > close_bcn_intvl_th)
+ return tbtt2;
+ else if (tbtt1 > close_bcn_intvl_th)
+ return tbtt1;
+ else
+ return tbtt2;
+}
+
+static void rtw89_bcn_cfg_tbtt_offset(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link)
+{
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ enum rtw89_core_chip_id chip_id = rtwdev->chip->chip_id;
+ u32 offset = bcn_track->tbtt_offset;
+
+ if (chip_id == RTL8852A || rtw89_is_rtl885xb(rtwdev)) {
+ const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def;
+ const struct rtw89_port_reg *p = mac->port_base;
+ u32 bcnspc, val;
+
+ bcnspc = rtw89_read32_port_mask(rtwdev, rtwvif_link,
+ p->bcn_space, B_AX_BCN_SPACE_MASK);
+ val = bcnspc - (offset / 1024);
+ val = u32_encode_bits(val, B_AX_TBTT_SHIFT_OFST_MAG) |
+ B_AX_TBTT_SHIFT_OFST_SIGN;
+
+ rtw89_write16_port_mask(rtwdev, rtwvif_link, p->tbtt_shift,
+ B_AX_TBTT_SHIFT_OFST_MASK, val);
+
+ return;
+ }
+
+ rtw89_fw_h2c_tbtt_tuning(rtwdev, rtwvif_link, offset);
+}
+
+static void rtw89_bcn_update_tbtt_offset(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link)
+{
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ u32 *tbtt_us = bcn_stat->tbtt_us;
+ u32 offset = tbtt_us[0];
+ u8 i;
+
+ for (i = 1; i < RTW89_BCN_TRACK_STAT_NR; i++)
+ offset = rtw89_bcn_calc_min_tbtt(rtwdev, tbtt_us[i], offset);
+
+ if (bcn_track->tbtt_offset == offset)
+ return;
+
+ bcn_track->tbtt_offset = offset;
+ rtw89_bcn_cfg_tbtt_offset(rtwdev, rtwvif_link);
+}
+
+static int cmp_u16(const void *a, const void *b)
+{
+ return *(const u16 *)a - *(const u16 *)b;
+}
+
+static u16 _rtw89_bcn_calc_drift(u16 tbtt, u16 offset, u16 beacon_int)
+{
+ if (tbtt < offset)
+ return beacon_int - offset + tbtt;
+
+ return tbtt - offset;
+}
+
+static void rtw89_bcn_calc_drift(struct rtw89_dev *rtwdev)
+{
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ u16 offset_tu = bcn_track->tbtt_offset / 1024;
+ u16 *tbtt_tu = bcn_stat->tbtt_tu;
+ u16 *drift = bcn_stat->drift;
+ u8 i;
+
+ bcn_stat->tbtt_tu_min = U16_MAX;
+ bcn_stat->tbtt_tu_max = 0;
+ for (i = 0; i < RTW89_BCN_TRACK_STAT_NR; i++) {
+ drift[i] = _rtw89_bcn_calc_drift(tbtt_tu[i], offset_tu,
+ bcn_track->beacon_int);
+
+ bcn_stat->tbtt_tu_min = min(bcn_stat->tbtt_tu_min, tbtt_tu[i]);
+ bcn_stat->tbtt_tu_max = max(bcn_stat->tbtt_tu_max, tbtt_tu[i]);
+ }
+
+ sort(drift, RTW89_BCN_TRACK_STAT_NR, sizeof(*drift), cmp_u16, NULL);
+}
+
+static void rtw89_bcn_calc_distribution(struct rtw89_dev *rtwdev)
+{
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_dist *bcn_dist = &bcn_stat->bcn_dist;
+ u16 lower_bound, upper_bound, outlier_count = 0;
+ u16 *drift = bcn_stat->drift;
+ u16 *bins = bcn_dist->bins;
+ u16 q1, q3, iqr, tmp;
+ u8 i;
+
+ BUILD_BUG_ON(RTW89_BCN_TRACK_STAT_NR % 4 != 0);
+
+ memset(bcn_dist, 0, sizeof(*bcn_dist));
+
+ bcn_dist->min = drift[0];
+ bcn_dist->max = drift[RTW89_BCN_TRACK_STAT_NR - 1];
+
+ tmp = RTW89_BCN_TRACK_STAT_NR / 4;
+ q1 = ((drift[tmp] + drift[tmp - 1]) * RTW89_BCN_TRACK_SCALE_FACTOR) / 2;
+
+ tmp = (RTW89_BCN_TRACK_STAT_NR * 3) / 4;
+ q3 = ((drift[tmp] + drift[tmp - 1]) * RTW89_BCN_TRACK_SCALE_FACTOR) / 2;
+
+ iqr = q3 - q1;
+ tmp = (3 * iqr) / 2;
+
+ if (bcn_dist->min <= 5)
+ lower_bound = bcn_dist->min;
+ else if (q1 > tmp)
+ lower_bound = (q1 - tmp) / RTW89_BCN_TRACK_SCALE_FACTOR;
+ else
+ lower_bound = 0;
+
+ upper_bound = (q3 + tmp) / RTW89_BCN_TRACK_SCALE_FACTOR;
+
+ for (i = 0; i < RTW89_BCN_TRACK_STAT_NR; i++) {
+ u16 tbtt = bcn_stat->tbtt_tu[i];
+ u16 min = bcn_stat->tbtt_tu_min;
+ u8 bin_idx;
+
+ /* histogram */
+ bin_idx = min((tbtt - min) / RTW89_BCN_TRACK_BIN_WIDTH,
+ RTW89_BCN_TRACK_MAX_BIN_NUM - 1);
+ bins[bin_idx]++;
+
+ /* boxplot outlier */
+ if (drift[i] < lower_bound || drift[i] > upper_bound)
+ outlier_count++;
+ }
+
+ bcn_dist->outlier_count = outlier_count;
+ bcn_dist->lower_bound = lower_bound;
+ bcn_dist->upper_bound = upper_bound;
+}
+
+static u8 rtw89_bcn_get_coverage(struct rtw89_dev *rtwdev, u16 threshold)
+{
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ int l = 0, r = RTW89_BCN_TRACK_STAT_NR - 1, m;
+ u16 *drift = bcn_stat->drift;
+ int index = -1;
+ u8 count = 0;
+
+ while (l <= r) {
+ m = l + (r - l) / 2;
+
+ if (drift[m] <= threshold) {
+ index = m;
+ l = m + 1;
+ } else {
+ r = m - 1;
+ }
+ }
+
+ count = (index == -1) ? 0 : (index + 1);
+
+ return (count * PERCENT) / RTW89_BCN_TRACK_STAT_NR;
+}
+
+static u16 rtw89_bcn_get_histogram_bound(struct rtw89_dev *rtwdev, u8 target)
+{
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_dist *bcn_dist = &bcn_stat->bcn_dist;
+ u16 tbtt_tu_max = bcn_stat->tbtt_tu_max;
+ u16 upper, lower = bcn_stat->tbtt_tu_min;
+ u8 i, count = 0;
+
+ for (i = 0; i < RTW89_BCN_TRACK_MAX_BIN_NUM; i++) {
+ upper = lower + RTW89_BCN_TRACK_BIN_WIDTH - 1;
+ if (i == RTW89_BCN_TRACK_MAX_BIN_NUM - 1)
+ upper = max(upper, tbtt_tu_max);
+
+ count += bcn_dist->bins[i];
+ if (count > target)
+ break;
+
+ lower = upper + 1;
+ }
+
+ return upper;
+}
+
+static u16 rtw89_bcn_get_rx_time(struct rtw89_dev *rtwdev,
+ const struct rtw89_chan *chan)
+{
+#define RTW89_SYMBOL_TIME_2GHZ 192
+#define RTW89_SYMBOL_TIME_5GHZ 20
+#define RTW89_SYMBOL_TIME_6GHZ 20
+ struct rtw89_pkt_stat *pkt_stat = &rtwdev->phystat.cur_pkt_stat;
+ u16 bitrate, val;
+
+ if (!rtw89_legacy_rate_to_bitrate(rtwdev, pkt_stat->beacon_rate, &bitrate))
+ return 0;
+
+ val = (pkt_stat->beacon_len * 8 * RTW89_BCN_TRACK_SCALE_FACTOR) / bitrate;
+
+ switch (chan->band_type) {
+ default:
+ case RTW89_BAND_2G:
+ val += RTW89_SYMBOL_TIME_2GHZ;
+ break;
+ case RTW89_BAND_5G:
+ val += RTW89_SYMBOL_TIME_5GHZ;
+ break;
+ case RTW89_BAND_6G:
+ val += RTW89_SYMBOL_TIME_6GHZ;
+ break;
+ }
+
+ /* convert to millisecond */
+ return DIV_ROUND_UP(val, 1000);
+}
+
+static void rtw89_bcn_calc_timeout(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link)
+{
+#define RTW89_BCN_TRACK_EXTEND_TIMEOUT 5
+#define RTW89_BCN_TRACK_COVERAGE_TH 0 /* unit: TU */
+#define RTW89_BCN_TRACK_STRONG_RSSI 80
+ const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, rtwvif_link->chanctx_idx);
+ struct rtw89_pkt_stat *pkt_stat = &rtwdev->phystat.cur_pkt_stat;
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ struct rtw89_beacon_dist *bcn_dist = &bcn_stat->bcn_dist;
+ u16 outlier_high_bcn_th = bcn_track->outlier_high_bcn_th;
+ u16 outlier_low_bcn_th = bcn_track->outlier_low_bcn_th;
+ u8 rssi = ewma_rssi_read(&rtwdev->phystat.bcn_rssi);
+ u16 target_bcn_th = bcn_track->target_bcn_th;
+ u16 low_bcn_th = bcn_track->low_bcn_th;
+ u16 med_bcn_th = bcn_track->med_bcn_th;
+ u16 beacon_int = bcn_track->beacon_int;
+ u16 bcn_timeout;
+
+ if (pkt_stat->beacon_nr < low_bcn_th) {
+ bcn_timeout = (RTW89_BCN_TRACK_TARGET_BCN * beacon_int) / PERCENT;
+ goto out;
+ }
+
+ if (bcn_dist->outlier_count >= outlier_high_bcn_th) {
+ bcn_timeout = bcn_dist->max;
+ goto out;
+ }
+
+ if (pkt_stat->beacon_nr < med_bcn_th) {
+ if (bcn_dist->outlier_count > outlier_low_bcn_th)
+ bcn_timeout = (bcn_dist->max + bcn_dist->upper_bound) / 2;
+ else
+ bcn_timeout = bcn_dist->upper_bound +
+ RTW89_BCN_TRACK_EXTEND_TIMEOUT;
+
+ goto out;
+ }
+
+ if (rssi >= RTW89_BCN_TRACK_STRONG_RSSI) {
+ if (rtw89_bcn_get_coverage(rtwdev, RTW89_BCN_TRACK_COVERAGE_TH) >= 90) {
+ /* ideal case */
+ bcn_timeout = 0;
+ } else {
+ u16 offset_tu = bcn_track->tbtt_offset / 1024;
+ u16 upper_bound;
+
+ upper_bound =
+ rtw89_bcn_get_histogram_bound(rtwdev, target_bcn_th);
+ bcn_timeout =
+ _rtw89_bcn_calc_drift(upper_bound, offset_tu, beacon_int);
+ }
+
+ goto out;
+ }
+
+ bcn_timeout = bcn_stat->drift[target_bcn_th];
+
+out:
+ bcn_track->bcn_timeout = bcn_timeout + rtw89_bcn_get_rx_time(rtwdev, chan);
+}
+
+static void rtw89_bcn_update_timeout(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link)
+{
+ rtw89_bcn_calc_drift(rtwdev);
+ rtw89_bcn_calc_distribution(rtwdev);
+ rtw89_bcn_calc_timeout(rtwdev, rtwvif_link);
+}
+
+static void rtw89_core_bcn_track(struct rtw89_dev *rtwdev)
+{
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ struct rtw89_vif_link *rtwvif_link;
+ struct rtw89_vif *rtwvif;
+ unsigned int link_id;
+
+ if (!RTW89_CHK_FW_FEATURE(BEACON_TRACKING, &rtwdev->fw))
+ return;
+
+ if (!rtwdev->lps_enabled)
+ return;
+
+ if (!bcn_track->is_data_ready)
+ return;
+
+ rtw89_for_each_rtwvif(rtwdev, rtwvif) {
+ rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) {
+ if (!(rtwvif_link->wifi_role == RTW89_WIFI_ROLE_STATION ||
+ rtwvif_link->wifi_role == RTW89_WIFI_ROLE_P2P_CLIENT))
+ continue;
+
+ rtw89_bcn_update_tbtt_offset(rtwdev, rtwvif_link);
+ rtw89_bcn_update_timeout(rtwdev, rtwvif_link);
+ }
+ }
+}
+
+static bool rtw89_core_bcn_track_can_lps(struct rtw89_dev *rtwdev)
+{
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+
+ if (!RTW89_CHK_FW_FEATURE(BEACON_TRACKING, &rtwdev->fw))
+ return true;
+
+ return bcn_track->is_data_ready;
+}
+
+static void rtw89_core_bcn_track_assoc(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link)
+{
+#define RTW89_BCN_TRACK_MED_BCN 70
+#define RTW89_BCN_TRACK_LOW_BCN 30
+#define RTW89_BCN_TRACK_OUTLIER_HIGH_BCN 30
+#define RTW89_BCN_TRACK_OUTLIER_LOW_BCN 20
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ u32 period = jiffies_to_msecs(RTW89_TRACK_WORK_PERIOD);
+ struct ieee80211_bss_conf *bss_conf;
+ u32 beacons_in_period;
+ u32 bcn_intvl_us;
+ u16 beacon_int;
+ u8 dtim;
+
+ rcu_read_lock();
+ bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true);
+ beacon_int = bss_conf->beacon_int;
+ dtim = bss_conf->dtim_period;
+ rcu_read_unlock();
+
+ beacons_in_period = period / beacon_int / dtim;
+ bcn_intvl_us = ieee80211_tu_to_usec(beacon_int);
+
+ bcn_track->low_bcn_th =
+ (beacons_in_period * RTW89_BCN_TRACK_LOW_BCN) / PERCENT;
+ bcn_track->med_bcn_th =
+ (beacons_in_period * RTW89_BCN_TRACK_MED_BCN) / PERCENT;
+ bcn_track->outlier_low_bcn_th =
+ (RTW89_BCN_TRACK_STAT_NR * RTW89_BCN_TRACK_OUTLIER_LOW_BCN) / PERCENT;
+ bcn_track->outlier_high_bcn_th =
+ (RTW89_BCN_TRACK_STAT_NR * RTW89_BCN_TRACK_OUTLIER_HIGH_BCN) / PERCENT;
+ bcn_track->target_bcn_th =
+ (RTW89_BCN_TRACK_STAT_NR * RTW89_BCN_TRACK_TARGET_BCN) / PERCENT;
+
+ bcn_track->close_bcn_intvl_th = ieee80211_tu_to_usec(beacon_int - 3);
+ bcn_track->tbtt_diff_th = (bcn_intvl_us * 85) / PERCENT;
+ bcn_track->beacon_int = beacon_int;
+ bcn_track->dtim = dtim;
+}
+
+static void rtw89_core_bcn_track_reset(struct rtw89_dev *rtwdev)
+{
+ memset(&rtwdev->phystat.bcn_stat, 0, sizeof(rtwdev->phystat.bcn_stat));
+ memset(&rtwdev->bcn_track, 0, sizeof(rtwdev->bcn_track));
+}
+
+static void rtw89_vif_rx_bcn_stat(struct rtw89_dev *rtwdev,
+ struct ieee80211_bss_conf *bss_conf,
+ struct sk_buff *skb)
+{
+#define RTW89_APPEND_TSF_2GHZ 384
+#define RTW89_APPEND_TSF_5GHZ 52
+#define RTW89_APPEND_TSF_6GHZ 52
+ struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
+ struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
+ struct rtw89_beacon_stat *bcn_stat = &rtwdev->phystat.bcn_stat;
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ u32 bcn_intvl_us = ieee80211_tu_to_usec(bss_conf->beacon_int);
+ u64 tsf = le64_to_cpu(mgmt->u.beacon.timestamp);
+ u8 wp, num = bcn_stat->num;
+ u16 append;
+
+ if (!RTW89_CHK_FW_FEATURE(BEACON_TRACKING, &rtwdev->fw))
+ return;
+
+ switch (rx_status->band) {
+ default:
+ case NL80211_BAND_2GHZ:
+ append = RTW89_APPEND_TSF_2GHZ;
+ break;
+ case NL80211_BAND_5GHZ:
+ append = RTW89_APPEND_TSF_5GHZ;
+ break;
+ case NL80211_BAND_6GHZ:
+ append = RTW89_APPEND_TSF_6GHZ;
+ break;
+ }
+
+ wp = bcn_stat->wp;
+ div_u64_rem(tsf - append, bcn_intvl_us, &bcn_stat->tbtt_us[wp]);
+ bcn_stat->tbtt_tu[wp] = bcn_stat->tbtt_us[wp] / 1024;
+ bcn_stat->wp = (wp + 1) % RTW89_BCN_TRACK_STAT_NR;
+ bcn_stat->num = umin(num + 1, RTW89_BCN_TRACK_STAT_NR);
+ bcn_track->is_data_ready = bcn_stat->num == RTW89_BCN_TRACK_STAT_NR;
+}
+
static void rtw89_vif_rx_stats_iter(void *data, u8 *mac,
struct ieee80211_vif *vif)
{
rtw89_vif_sync_bcn_tsf(rtwvif_link, hdr, skb->len);
rtw89_fw_h2c_rssi_offload(rtwdev, phy_ppdu);
}
- pkt_stat->beacon_nr++;
if (phy_ppdu) {
ewma_rssi_add(&rtwdev->phystat.bcn_rssi, phy_ppdu->rssi_avg);
rtwvif_link->bcn_bw_idx = phy_ppdu->bw_idx;
}
+ pkt_stat->beacon_nr++;
pkt_stat->beacon_rate = desc_info->data_rate;
+ pkt_stat->beacon_len = skb->len;
+
+ rtw89_vif_rx_bcn_stat(rtwdev, bss_conf, skb);
}
if (!ether_addr_equal(bss_conf->addr, hdr->addr1))
vif->type == NL80211_IFTYPE_P2P_CLIENT))
continue;
+ if (!rtw89_core_bcn_track_can_lps(rtwdev))
+ continue;
+
rtw89_enter_lps(rtwdev, rtwvif, true);
}
}
rtw89_btc_ntfy_wl_sta(rtwdev);
}
rtw89_mac_bf_monitor_track(rtwdev);
+ rtw89_core_bcn_track(rtwdev);
rtw89_phy_stat_track(rtwdev);
rtw89_phy_env_monitor_track(rtwdev);
rtw89_phy_dig(rtwdev);
rtw89_assoc_link_clr(rtwsta_link);
- if (vif->type == NL80211_IFTYPE_STATION)
+ if (vif->type == NL80211_IFTYPE_STATION) {
rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, false);
+ rtw89_core_bcn_track_reset(rtwdev);
+ }
if (rtwvif_link->wifi_role == RTW89_WIFI_ROLE_P2P_CLIENT)
rtw89_p2p_noa_once_deinit(rtwvif_link);
BTC_ROLE_MSTS_STA_CONN_END);
rtw89_core_get_no_ul_ofdma_htc(rtwdev, &rtwsta_link->htc_template, chan);
rtw89_phy_ul_tb_assoc(rtwdev, rtwvif_link);
+ rtw89_core_bcn_track_assoc(rtwdev, rtwvif_link);
ret = rtw89_fw_h2c_general_pkt(rtwdev, rtwvif_link, rtwsta_link->mac_id);
if (ret) {
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 90, 0, CRASH_TRIGGER_TYPE_0),
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 91, 0, SCAN_OFFLOAD),
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 110, 0, BEACON_FILTER),
+ __CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 122, 0, BEACON_TRACKING),
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 127, 0, SCAN_OFFLOAD_EXTRA_OP),
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 127, 0, LPS_DACK_BY_C2H_REG),
__CFG_FW_FEAT(RTL8852BT, ge, 0, 29, 127, 0, CRASH_TRIGGER_TYPE_1),
__CFG_FW_FEAT(RTL8852C, ge, 0, 27, 56, 10, BEACON_FILTER),
__CFG_FW_FEAT(RTL8852C, ge, 0, 27, 80, 0, WOW_REASON_V1),
__CFG_FW_FEAT(RTL8852C, ge, 0, 27, 128, 0, BEACON_LOSS_COUNT_V1),
+ __CFG_FW_FEAT(RTL8852C, ge, 0, 27, 129, 1, BEACON_TRACKING),
__CFG_FW_FEAT(RTL8922A, ge, 0, 34, 30, 0, CRASH_TRIGGER_TYPE_0),
__CFG_FW_FEAT(RTL8922A, ge, 0, 34, 11, 0, MACID_PAUSE_SLEEP),
__CFG_FW_FEAT(RTL8922A, ge, 0, 34, 35, 0, SCAN_OFFLOAD),
__CFG_FW_FEAT(RTL8922A, ge, 0, 35, 71, 0, BEACON_LOSS_COUNT_V1),
__CFG_FW_FEAT(RTL8922A, ge, 0, 35, 76, 0, LPS_DACK_BY_C2H_REG),
__CFG_FW_FEAT(RTL8922A, ge, 0, 35, 79, 0, CRASH_TRIGGER_TYPE_1),
+ __CFG_FW_FEAT(RTL8922A, ge, 0, 35, 80, 0, BEACON_TRACKING),
};
static void rtw89_fw_iterate_feature_cfg(struct rtw89_fw_info *fw,
}
EXPORT_SYMBOL(rtw89_fw_h2c_update_beacon_be);
+int rtw89_fw_h2c_tbtt_tuning(struct rtw89_dev *rtwdev,
+ struct rtw89_vif_link *rtwvif_link, u32 offset)
+{
+ struct rtw89_h2c_tbtt_tuning *h2c;
+ u32 len = sizeof(*h2c);
+ struct sk_buff *skb;
+ int ret;
+
+ skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
+ if (!skb) {
+ rtw89_err(rtwdev, "failed to alloc skb for h2c tbtt tuning\n");
+ return -ENOMEM;
+ }
+ skb_put(skb, len);
+ h2c = (struct rtw89_h2c_tbtt_tuning *)skb->data;
+
+ h2c->w0 = le32_encode_bits(rtwvif_link->phy_idx, RTW89_H2C_TBTT_TUNING_W0_BAND) |
+ le32_encode_bits(rtwvif_link->port, RTW89_H2C_TBTT_TUNING_W0_PORT);
+ h2c->w1 = le32_encode_bits(offset, RTW89_H2C_TBTT_TUNING_W1_SHIFT);
+
+ rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
+ H2C_CAT_MAC, H2C_CL_MAC_PS,
+ H2C_FUNC_TBTT_TUNING, 0, 0,
+ len);
+
+ ret = rtw89_h2c_tx(rtwdev, skb, false);
+ if (ret) {
+ rtw89_err(rtwdev, "failed to send h2c\n");
+ goto fail;
+ }
+
+ return 0;
+fail:
+ dev_kfree_skb_any(skb);
+
+ return ret;
+}
+
+int rtw89_fw_h2c_pwr_lvl(struct rtw89_dev *rtwdev, struct rtw89_vif_link *rtwvif_link)
+{
+#define RTW89_BCN_TO_VAL_MIN 4
+#define RTW89_BCN_TO_VAL_MAX 64
+#define RTW89_DTIM_TO_VAL_MIN 7
+#define RTW89_DTIM_TO_VAL_MAX 15
+ struct rtw89_beacon_track_info *bcn_track = &rtwdev->bcn_track;
+ struct rtw89_h2c_pwr_lvl *h2c;
+ u32 len = sizeof(*h2c);
+ struct sk_buff *skb;
+ u8 bcn_to_val;
+ int ret;
+
+ skb = rtw89_fw_h2c_alloc_skb_with_hdr(rtwdev, len);
+ if (!skb) {
+ rtw89_err(rtwdev, "failed to alloc skb for h2c pwr lvl\n");
+ return -ENOMEM;
+ }
+ skb_put(skb, len);
+ h2c = (struct rtw89_h2c_pwr_lvl *)skb->data;
+
+ bcn_to_val = clamp_t(u8, bcn_track->bcn_timeout,
+ RTW89_BCN_TO_VAL_MIN, RTW89_BCN_TO_VAL_MAX);
+
+ h2c->w0 = le32_encode_bits(rtwvif_link->mac_id, RTW89_H2C_PWR_LVL_W0_MACID) |
+ le32_encode_bits(bcn_to_val, RTW89_H2C_PWR_LVL_W0_BCN_TO_VAL) |
+ le32_encode_bits(0, RTW89_H2C_PWR_LVL_W0_PS_LVL) |
+ le32_encode_bits(0, RTW89_H2C_PWR_LVL_W0_TRX_LVL) |
+ le32_encode_bits(RTW89_DTIM_TO_VAL_MIN,
+ RTW89_H2C_PWR_LVL_W0_DTIM_TO_VAL);
+
+ rtw89_h2c_pkt_set_hdr(rtwdev, skb, FWCMD_TYPE_H2C,
+ H2C_CAT_MAC, H2C_CL_MAC_PS,
+ H2C_FUNC_PS_POWER_LEVEL, 0, 0,
+ len);
+
+ ret = rtw89_h2c_tx(rtwdev, skb, false);
+ if (ret) {
+ rtw89_err(rtwdev, "failed to send h2c\n");
+ goto fail;
+ }
+
+ return 0;
+fail:
+ dev_kfree_skb_any(skb);
+
+ return ret;
+}
+
int rtw89_fw_h2c_role_maintain(struct rtw89_dev *rtwdev,
struct rtw89_vif_link *rtwvif_link,
struct rtw89_sta_link *rtwsta_link,
projects / thirdparty / kernel / stable.git / commitdiff
