Ksawlii/kernel_samsung_a53x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kernel_samsung_a53x/drivers/net/wireless/scsc/ba.c
Gabriel2392 7ed7ee9edf Import A536BXXU9EXDC
2024-06-15 16:02:09 -03:00

685 lines
24 KiB
C
Executable file
Raw Blame History

/****************************************************************************
*
* Copyright (c) 2012 - 2019 Samsung Electronics Co., Ltd. All rights reserved
*
****************************************************************************/
#include "debug.h"
#include "dev.h"
#include "ba.h"
#include "mgt.h"
#include "sap.h"
/* Timeout (in milliseconds) for frames in MPDU reorder buffer
*
* When a frame is out of order, the frame is stored in Reorder buffer.
* Frames can be released from the buffer, if subsequent frames arrive such that
* frames can be ordered or when this timeout occurs
*/
static uint ba_mpdu_reorder_age_timeout = 100; /* 100 milliseconds */
module_param(ba_mpdu_reorder_age_timeout, uint, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(ba_mpdu_reorder_age_timeout, "Timeout (in ms) before a BA frame in Reorder buffer is passed to upper layers");
static bool ba_out_of_range_delba_enable = 1;
module_param(ba_out_of_range_delba_enable, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(ba_out_of_range_delba_enable, "Option to trigger DELBA on out of range frame (1: enable (default), 0: disable)");
#define ADVANCE_EXPECTED_SN(__ba_session_rx) \
{ \
__ba_session_rx->expected_sn++; \
__ba_session_rx->expected_sn &= 0xFFF; \
}
#define FREE_BUFFER_SLOT(__ba_session_rx, __index) \
{ \
__ba_session_rx->occupied_slots--; \
__ba_session_rx->buffer[__index].active = false; \
}
void slsi_rx_ba_init(struct slsi_dev *sdev)
{
slsi_spinlock_create(&sdev->rx_ba_buffer_pool_lock);
}
static struct slsi_ba_session_rx *slsi_rx_ba_alloc_buffer(struct net_device *dev)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct slsi_dev *sdev = ndev_vif->sdev;
struct slsi_ba_session_rx *buffer = NULL;
int i;
SLSI_NET_DBG3(dev, SLSI_RX_BA, "RX BA buffer pool status: %d,%d,%d,%d,%d,%d,%d,%d\n",
sdev->rx_ba_buffer_pool[0].used, sdev->rx_ba_buffer_pool[1].used, sdev->rx_ba_buffer_pool[2].used,
sdev->rx_ba_buffer_pool[3].used, sdev->rx_ba_buffer_pool[4].used, sdev->rx_ba_buffer_pool[5].used,
sdev->rx_ba_buffer_pool[6].used, sdev->rx_ba_buffer_pool[7].used);
slsi_spinlock_lock(&sdev->rx_ba_buffer_pool_lock);
for (i = 0; i < SLSI_MAX_RX_BA_SESSIONS; i++) {
if (!sdev->rx_ba_buffer_pool[i].used) {
sdev->rx_ba_buffer_pool[i].used = true;
buffer = &sdev->rx_ba_buffer_pool[i];
break;
}
}
slsi_spinlock_unlock(&sdev->rx_ba_buffer_pool_lock);
if (!buffer)
SLSI_NET_ERR(dev, "No free RX BA buffer\n");
return buffer;
}
static void slsi_rx_ba_free_buffer(struct net_device *dev, struct slsi_peer *peer, int tid)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct slsi_dev *sdev = ndev_vif->sdev;
slsi_spinlock_lock(&sdev->rx_ba_buffer_pool_lock);
if (peer && peer->ba_session_rx[tid]) {
peer->ba_session_rx[tid]->used = false;
peer->ba_session_rx[tid] = NULL;
}
slsi_spinlock_unlock(&sdev->rx_ba_buffer_pool_lock);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "RX BA buffer pool status: %d,%d,%d,%d,%d,%d,%d,%d\n",
sdev->rx_ba_buffer_pool[0].used, sdev->rx_ba_buffer_pool[1].used, sdev->rx_ba_buffer_pool[2].used,
sdev->rx_ba_buffer_pool[3].used, sdev->rx_ba_buffer_pool[4].used, sdev->rx_ba_buffer_pool[5].used,
sdev->rx_ba_buffer_pool[6].used, sdev->rx_ba_buffer_pool[7].used);
}
/* This code - slsi_ba_process_complete()
* must be called with the ba_lock spinlock held.
*/
void slsi_ba_process_complete(struct net_device *dev, bool ctx_napi)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct sk_buff *skb;
while ((skb = skb_dequeue(&ndev_vif->ba_complete)) != NULL) {
local_bh_disable();
slsi_spinlock_unlock(&ndev_vif->ba_lock);
slsi_rx_data_deliver_skb(ndev_vif->sdev, dev, skb, ctx_napi);
slsi_spinlock_lock(&ndev_vif->ba_lock);
local_bh_enable();
}
}
static void slsi_ba_signal_process_complete(struct net_device *dev)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
atomic_set(&ndev_vif->ba_flush, 1);
#ifndef CONFIG_SCSC_WLAN_RX_NAPI
slsi_skb_schedule_work(&ndev_vif->rx_data);
#endif
}
static void ba_add_frame_to_ba_complete(struct net_device *dev, struct slsi_ba_session_rx *ba_session_rx, struct slsi_ba_frame_desc *frame_desc)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
if (slsi_ba_replay_check_pn(dev, ba_session_rx, frame_desc)) {
SLSI_NET_DBG4(dev, SLSI_RX_BA, "drop: tid=%d sn=%d received PN %pm\n",
frame_desc->tid,
frame_desc->sn,
frame_desc->pn);
#ifdef CONFIG_SCSC_SMAPPER
hip4_smapper_free_mapped_skb(frame_desc->signal);
#endif
kfree_skb(frame_desc->signal);
return;
}
skb_queue_tail(&ndev_vif->ba_complete, frame_desc->signal);
}
static void ba_update_expected_sn(struct net_device *dev,
struct slsi_ba_session_rx *ba_session_rx, u16 sn)
{
u32 i, j;
u16 gap;
gap = (sn - ba_session_rx->expected_sn) & 0xFFF;
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Proccess the frames up to new expected_sn = %d gap = %d\n", sn, gap);
for (j = 0; j < gap && j < ba_session_rx->buffer_size; j++) {
i = SN_TO_INDEX(ba_session_rx, ba_session_rx->expected_sn);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Proccess the slot index = %d\n", i);
if (ba_session_rx->buffer[i].active) {
ba_add_frame_to_ba_complete(dev, ba_session_rx, &ba_session_rx->buffer[i]);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Proccess the frame at index = %d expected_sn = %d\n", i, ba_session_rx->expected_sn);
FREE_BUFFER_SLOT(ba_session_rx, i);
} else {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Empty slot at index = %d\n", i);
}
ADVANCE_EXPECTED_SN(ba_session_rx);
}
ba_session_rx->expected_sn = sn;
}
static void ba_complete_ready_sequence(struct net_device *dev,
struct slsi_ba_session_rx *ba_session_rx)
{
int i;
i = SN_TO_INDEX(ba_session_rx, ba_session_rx->expected_sn);
while (ba_session_rx->buffer[i].active) {
ba_add_frame_to_ba_complete(dev, ba_session_rx, &ba_session_rx->buffer[i]);
SLSI_NET_DBG4(dev, SLSI_RX_BA, "Completed stored frame (expected_sn=%d) at i = %d\n",
ba_session_rx->expected_sn, i);
FREE_BUFFER_SLOT(ba_session_rx, i);
ADVANCE_EXPECTED_SN(ba_session_rx);
i = SN_TO_INDEX(ba_session_rx, ba_session_rx->expected_sn);
}
}
static void ba_scroll_window(struct net_device *dev,
struct slsi_ba_session_rx *ba_session_rx, u16 sn)
{
if (((sn - ba_session_rx->expected_sn) & 0xFFF) <= BA_WINDOW_BOUNDARY) {
ba_update_expected_sn(dev, ba_session_rx, sn);
ba_complete_ready_sequence(dev, ba_session_rx);
}
}
static void ba_delete_ba_on_old_frame(struct net_device *dev, struct slsi_peer *peer,
struct slsi_ba_session_rx *ba_session_rx, u16 sn)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
struct sap_drv_ma_to_mlme_delba_req *delba_req;
struct sk_buff *skb = NULL;
SLSI_NET_DBG4(dev, SLSI_RX_BA, "sn=%d\n", sn);
/* construct a message for MLME */
skb = alloc_skb(sizeof(struct sap_drv_ma_to_mlme_delba_req), GFP_ATOMIC);
if (WARN_ON(!skb))
return;
ba_session_rx->closing = true;
slsi_skb_cb_init(skb)->sig_length = sizeof(struct sap_drv_ma_to_mlme_delba_req);
slsi_skb_cb_get(skb)->data_length = sizeof(struct sap_drv_ma_to_mlme_delba_req);
delba_req = (struct sap_drv_ma_to_mlme_delba_req *)skb_put(skb, sizeof(struct sap_drv_ma_to_mlme_delba_req));
delba_req->header.id = cpu_to_le16(SAP_DRV_MA_TO_MLME_DELBA_REQ);
delba_req->header.receiver_pid = 0;
delba_req->header.sender_pid = 0;
delba_req->header.fw_reference = 0;
delba_req->vif = ndev_vif->ifnum;
memcpy(delba_req->peer_qsta_address, peer->address, ETH_ALEN);
delba_req->sequence_number = sn;
delba_req->user_priority = ba_session_rx->tid;
delba_req->reason = FAPI_REASONCODE_OUT_OF_RANGE_SEQUENCE_NUMBER;
delba_req->direction = FAPI_DIRECTION_RECEIVE;
/* queue the message for MLME SAP */
slsi_rx_enqueue_netdev_mlme(ndev_vif->sdev, skb, fapi_get_vif(skb));
}
static int ba_consume_frame_or_get_buffer_index(struct net_device *dev, struct slsi_peer *peer,
struct slsi_ba_session_rx *ba_session_rx, u16 sn, struct slsi_ba_frame_desc *frame_desc, bool *stop_timer)
{
int i;
u16 sn_temp;
#ifdef CONFIG_SCSC_WLAN_STA_ENHANCED_ARP_DETECT
struct netdev_vif *ndev_vif = netdev_priv(dev);
#endif
*stop_timer = false;
if (((sn - ba_session_rx->expected_sn) & 0xFFF) <= BA_WINDOW_BOUNDARY) {
/* Once we are in BA window, set the flag for BA trigger */
if (!ba_session_rx->trigger_ba_after_ssn)
ba_session_rx->trigger_ba_after_ssn = true;
sn_temp = ba_session_rx->expected_sn + ba_session_rx->buffer_size;
SLSI_NET_DBG4(dev, SLSI_RX_BA, "New frame: sn=%d\n", sn);
if (!(((sn - sn_temp) & 0xFFF) > BA_WINDOW_BOUNDARY)) {
u16 new_expected_sn;
SLSI_NET_DBG2(dev, SLSI_RX_BA, "Frame is out of window\n");
sn_temp = (sn - ba_session_rx->buffer_size) & 0xFFF;
if (ba_session_rx->timer_on)
*stop_timer = true;
new_expected_sn = (sn_temp + 1) & 0xFFF;
ba_update_expected_sn(dev, ba_session_rx, new_expected_sn);
}
i = -1;
if (sn == ba_session_rx->expected_sn) {
SLSI_NET_DBG4(dev, SLSI_RX_BA, "sn = ba_session_rx->expected_sn = %d\n", sn);
if (ba_session_rx->timer_on)
*stop_timer = true;
ADVANCE_EXPECTED_SN(ba_session_rx);
ba_add_frame_to_ba_complete(dev, ba_session_rx, frame_desc);
} else {
i = SN_TO_INDEX(ba_session_rx, sn);
SLSI_NET_DBG4(dev, SLSI_RX_BA, "sn (%d) != ba_session_rx->expected_sn(%d), i = %d\n", sn, ba_session_rx->expected_sn, i);
if (ba_session_rx->buffer[i].active) {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "free frame at i = %d\n", i);
i = -1;
#ifdef CONFIG_SCSC_SMAPPER
hip4_smapper_free_mapped_skb(frame_desc->signal);
#endif
kfree_skb(frame_desc->signal);
}
}
if (!IS_SN_LESS(sn, ba_session_rx->highest_received_sn))
ba_session_rx->highest_received_sn = sn;
} else {
i = -1;
if (!ba_session_rx->trigger_ba_after_ssn) {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "frame before ssn, pass it up: sn=%d\n", sn);
ba_add_frame_to_ba_complete(dev, ba_session_rx, frame_desc);
} else {
frame_desc->flag_old_sn = true;
if (slsi_is_tdls_peer(dev, peer)) {
/* Don't drop old frames in TDLS AMPDU-reordering for interoperability with third party devices.
* When the TDLS link is established the peer sends few packets with AP's sequence number.
* BA reorder logic updates the expected sequence number. After that peer sends packets with
* starting sequence number negotiated in BA (0). But those frames are getting dropped here.
* Because of this TCP traffic does not work and TDLS link is getting disconnected.
*/
SLSI_NET_DBG1(dev, SLSI_RX_BA, "tdls: forward old frame: sn=%d, expected_sn=%d\n", sn, ba_session_rx->expected_sn);
frame_desc->flag_old_tdls = true;
ba_add_frame_to_ba_complete(dev, ba_session_rx, frame_desc);
} else {
/* this frame is deemed as old. But it may so happen that the reorder process did not wait long
* enough for this frame and moved to new window. So check here that the current frame still lies in
* originators transmit window by comparing it with highest sequence number received from originator.
*
* If it lies in the window pass the frame to next process else pass the frame and initiate DELBA procedure.
*/
if (IS_SN_LESS(ba_session_rx->highest_received_sn, ((sn + ba_session_rx->buffer_size) & 0xFFF))) {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "old frame, but still in window: sn=%d, highest_received_sn=%d\n", sn, ba_session_rx->highest_received_sn);
ba_add_frame_to_ba_complete(dev, ba_session_rx, frame_desc);
} else {
SLSI_NET_WARN(dev, "old frame, drop: sn=%d, expected_sn=%d\n", sn, ba_session_rx->expected_sn);
#ifdef CONFIG_SCSC_WLAN_STA_ENHANCED_ARP_DETECT
if (ndev_vif->enhanced_arp_detect_enabled)
slsi_fill_enhanced_arp_out_of_order_drop_counter(ndev_vif, frame_desc->signal);
#endif
#ifdef CONFIG_SCSC_SMAPPER
hip4_smapper_free_mapped_skb(frame_desc->signal);
#endif
kfree_skb(frame_desc->signal);
if (ba_out_of_range_delba_enable) {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "as a countermeasure to re-sync, delete BA: sn=%d, expected_sn=%d\n", sn, ba_session_rx->expected_sn);
if (!ba_session_rx->closing)
ba_delete_ba_on_old_frame(dev, peer, ba_session_rx, sn);
}
}
}
}
}
return i;
}
#if KERNEL_VERSION(4, 15, 0) <= LINUX_VERSION_CODE
static void slsi_ba_aging_timeout_handler(struct timer_list *t)
#else
static void slsi_ba_aging_timeout_handler(unsigned long data)
#endif
{
#if KERNEL_VERSION(4, 15, 0) <= LINUX_VERSION_CODE
struct slsi_ba_session_rx *ba_session_rx = from_timer(ba_session_rx, t, ba_age_timer);
#else
struct slsi_ba_session_rx *ba_session_rx = (struct slsi_ba_session_rx *)data;
#endif
u8 i, j;
u8 gap = 1;
u16 temp_sn;
struct net_device *dev = ba_session_rx->dev;
struct netdev_vif *ndev_vif = netdev_priv(dev);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "\n");
slsi_spinlock_lock(&ndev_vif->ba_lock);
ba_session_rx->timer_on = false;
if (ba_session_rx->active && ba_session_rx->occupied_slots) {
/* expected sequence has not arrived so start searching from next
* sequence number until a frame is available and determine the gap.
* Release all the frames upto next hole from the reorder buffer.
*/
temp_sn = (ba_session_rx->expected_sn + 1) & 0xFFF;
for (i = 0; i < MAX_BA_BUFFER_SIZE; i++) {
ba_session_rx->ba_window[i].sent = false;
ba_session_rx->ba_window[i].sn = 0;
}
for (j = 0; j < ba_session_rx->buffer_size; j++) {
i = SN_TO_INDEX(ba_session_rx, temp_sn);
if (ba_session_rx->buffer[i].active) {
while (gap--)
ADVANCE_EXPECTED_SN(ba_session_rx);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Completed stored frame (expected_sn=%d) at i = %d\n", ba_session_rx->expected_sn, i);
ba_add_frame_to_ba_complete(dev, ba_session_rx, &ba_session_rx->buffer[i]);
FREE_BUFFER_SLOT(ba_session_rx, i);
ADVANCE_EXPECTED_SN(ba_session_rx);
ba_complete_ready_sequence(dev, ba_session_rx);
ba_session_rx->ba_timeouts++;
break;
}
/* advance temp sequence number and frame gap */
temp_sn = (temp_sn + 1) & 0xFFF;
gap++;
}
/* Check for next hole in the buffer, if hole exists create the timer for next missing frame */
/* do not rearm the timer if BA session is going down */
if (ba_session_rx->active && ba_session_rx->occupied_slots) {
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Timer start\n");
mod_timer(&ba_session_rx->ba_age_timer, jiffies + msecs_to_jiffies(ba_mpdu_reorder_age_timeout));
ba_session_rx->timer_on = true;
}
/* Process the data now marked as completed */
#ifdef CONFIG_SCSC_WLAN_RX_NAPI
slsi_ba_process_complete(dev, false);
#else
slsi_ba_signal_process_complete(dev);
#endif
}
slsi_spinlock_unlock(&ndev_vif->ba_lock);
}
int slsi_ba_process_frame(struct net_device *dev, struct slsi_peer *peer,
struct sk_buff *skb, u16 sequence_number, u16 tid)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
int i;
struct slsi_ba_session_rx *ba_session_rx = peer->ba_session_rx[tid];
struct slsi_ba_frame_desc frame_desc;
bool stop_timer = false;
SLSI_NET_DBG4(dev, SLSI_RX_BA, "Got frame(sn=%d)\n", sequence_number);
if (WARN_ON(tid > FAPI_PRIORITY_QOS_UP7)) {
SLSI_NET_ERR(dev, "tid=%d\n", tid);
return -EINVAL;
}
if (!ba_session_rx)
return -EINVAL;
slsi_spinlock_lock(&ndev_vif->ba_lock);
if (!ba_session_rx->active) {
SLSI_NET_ERR(dev, "No BA session exists\n");
slsi_spinlock_unlock(&ndev_vif->ba_lock);
return -EINVAL;
}
frame_desc.signal = skb;
frame_desc.tid = tid;
frame_desc.sn = sequence_number;
frame_desc.active = true;
slsi_ba_replay_get_pn(dev, peer, skb, &frame_desc);
i = ba_consume_frame_or_get_buffer_index(dev, peer, ba_session_rx, sequence_number, &frame_desc, &stop_timer);
if (i >= 0) {
SLSI_NET_DBG4(dev, SLSI_RX_BA, "Store frame(sn=%d) at i = %d\n", sequence_number, i);
if (ba_session_rx->buffer[i].active) {
SLSI_NET_WARN(dev, "drop duplicate frame (sn=%d) at i = %d\n", sequence_number, i);
#ifdef CONFIG_SCSC_SMAPPER
hip4_smapper_free_mapped_skb(frame_desc.signal);
#endif
kfree_skb(frame_desc.signal);
slsi_spinlock_unlock(&ndev_vif->ba_lock);
return 0;
}
ba_session_rx->buffer[i] = frame_desc;
ba_session_rx->occupied_slots++;
} else {
SLSI_NET_DBG4(dev, SLSI_RX_BA, "Frame consumed - sn = %d\n", sequence_number);
}
ba_complete_ready_sequence(dev, ba_session_rx);
/* Timer decision:
*
* If the timer is not running (timer_on=false)
* Start the timer if there are holes (occupied_slots!=0)
*
* If the timer is running (timer_on=true)
* Stop the timer if
* There are no holes (occupied_slots=0)
* Restart the timer if
* stop_timer=true and there are holes (occupied_slots!=0)
* Leave the timer running (do nothing) if
* stop_timer=false and there are holes (occupied_slots!=0)
*/
if (!ba_session_rx->timer_on) {
if (ba_session_rx->occupied_slots) {
stop_timer = false;
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Timer start\n");
mod_timer(&ba_session_rx->ba_age_timer, jiffies + msecs_to_jiffies(ba_mpdu_reorder_age_timeout));
ba_session_rx->timer_on = true;
}
} else if (!ba_session_rx->occupied_slots) {
stop_timer = true;
} else if (stop_timer) {
stop_timer = false;
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Timer restart\n");
mod_timer(&ba_session_rx->ba_age_timer, jiffies + msecs_to_jiffies(ba_mpdu_reorder_age_timeout));
ba_session_rx->timer_on = true;
}
if (stop_timer) {
ba_session_rx->timer_on = false;
slsi_spinlock_unlock(&ndev_vif->ba_lock);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Timer stop\n");
del_timer_sync(&ba_session_rx->ba_age_timer);
} else {
slsi_spinlock_unlock(&ndev_vif->ba_lock);
}
slsi_ba_signal_process_complete(dev);
return 0;
}
bool slsi_ba_check(struct slsi_peer *peer, u16 tid)
{
if (tid > FAPI_PRIORITY_QOS_UP7)
return false;
if (!peer->ba_session_rx[tid])
return false;
return peer->ba_session_rx[tid]->active;
}
static void __slsi_rx_ba_stop(struct net_device *dev, struct slsi_ba_session_rx *ba_session_rx)
{
u8 i, j;
SLSI_NET_DBG1(dev, SLSI_RX_BA, "Stopping BA session: tid = %d\n", ba_session_rx->tid);
if (WARN_ON(!ba_session_rx->active)) {
SLSI_NET_ERR(dev, "No BA session exists\n");
return;
}
for (i = SN_TO_INDEX(ba_session_rx, ba_session_rx->expected_sn), j = 0;
j < ba_session_rx->buffer_size; i++, j++) {
i %= ba_session_rx->buffer_size;
if (ba_session_rx->buffer[i].active) {
ba_add_frame_to_ba_complete(dev, ba_session_rx, &ba_session_rx->buffer[i]);
SLSI_NET_DBG3(dev, SLSI_RX_BA, "Completed stored frame at i = %d\n", i);
FREE_BUFFER_SLOT(ba_session_rx, i);
}
}
#ifdef CONFIG_SCSC_WLAN_RX_NAPI
slsi_ba_process_complete(dev, false);
#else
slsi_ba_signal_process_complete(dev);
#endif
ba_session_rx->active = false;
}
static void slsi_rx_ba_stop_lock_held(struct net_device *dev, struct slsi_ba_session_rx *ba_session_rx)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
__slsi_rx_ba_stop(dev, ba_session_rx);
ba_session_rx->timer_on = false;
slsi_spinlock_unlock(&ndev_vif->ba_lock);
del_timer_sync(&ba_session_rx->ba_age_timer);
slsi_spinlock_lock(&ndev_vif->ba_lock);
}
static void slsi_rx_ba_stop_lock_unheld(struct net_device *dev, struct slsi_ba_session_rx *ba_session_rx)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
slsi_spinlock_lock(&ndev_vif->ba_lock);
__slsi_rx_ba_stop(dev, ba_session_rx);
ba_session_rx->timer_on = false;
slsi_spinlock_unlock(&ndev_vif->ba_lock);
del_timer_sync(&ba_session_rx->ba_age_timer);
}
void slsi_rx_ba_stop_all(struct net_device *dev, struct slsi_peer *peer)
{
int i;
for (i = 0; i < NUM_BA_SESSIONS_PER_PEER; i++)
if (peer->ba_session_rx[i] && peer->ba_session_rx[i]->active) {
slsi_rx_ba_stop_lock_unheld(dev, peer->ba_session_rx[i]);
slsi_rx_ba_free_buffer(dev, peer, i);
}
}
static int slsi_rx_ba_start(struct net_device *dev,
struct slsi_peer *peer,
struct slsi_ba_session_rx *ba_session_rx,
u16 tid, u16 buffer_size, u16 start_sn)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
SLSI_NET_DBG1(dev, SLSI_RX_BA, "Request to start a new BA session tid=%d buffer_size=%d start_sn=%d\n",
tid, buffer_size, start_sn);
if (WARN_ON((!buffer_size) || (buffer_size > SLSI_BA_BUFFER_SIZE_MAX))) {
SLSI_NET_ERR(dev, "Invalid window size: buffer_size=%d\n", buffer_size);
return -EINVAL;
}
slsi_spinlock_lock(&ndev_vif->ba_lock);
if (ba_session_rx->active) {
SLSI_NET_DBG1(dev, SLSI_RX_BA, "BA session already exists\n");
if ((ba_session_rx->buffer_size == buffer_size) &&
(ba_session_rx->expected_sn == start_sn)) {
SLSI_NET_DBG1(dev, SLSI_RX_BA,
"BA session tid=%d already exists. The parameters match so keep the existing session\n",
tid);
slsi_spinlock_unlock(&ndev_vif->ba_lock);
return 0;
}
SLSI_NET_DBG1(dev, SLSI_RX_BA, "Parameters don't match so stop the existing BA session: tid=%d\n", tid);
slsi_rx_ba_stop_lock_held(dev, ba_session_rx);
}
ba_session_rx->dev = dev;
ba_session_rx->peer = peer;
ba_session_rx->buffer_size = buffer_size;
ba_session_rx->start_sn = start_sn;
ba_session_rx->expected_sn = start_sn;
ba_session_rx->highest_received_sn = 0;
ba_session_rx->closing = false;
ba_session_rx->trigger_ba_after_ssn = false;
ba_session_rx->tid = tid;
ba_session_rx->timer_on = false;
#if KERNEL_VERSION(4, 15, 0) <= LINUX_VERSION_CODE
timer_setup(&ba_session_rx->ba_age_timer, slsi_ba_aging_timeout_handler, 0);
#else
ba_session_rx->ba_age_timer.function = slsi_ba_aging_timeout_handler;
ba_session_rx->ba_age_timer.data = (unsigned long)ba_session_rx;
init_timer(&ba_session_rx->ba_age_timer);
#endif
ba_session_rx->ba_timeouts = 0;
ba_session_rx->ba_drops_old = 0;
ba_session_rx->ba_drops_replay = 0;
ba_session_rx->active = true;
SLSI_NET_DBG1(dev, SLSI_RX_BA, "Started a new BA session tid=%d buffer_size=%d start_sn=%d\n",
tid, buffer_size, start_sn);
slsi_spinlock_unlock(&ndev_vif->ba_lock);
slsi_ba_signal_process_complete(dev);
return 0;
}
void slsi_ba_update_window(struct net_device *dev,
struct slsi_ba_session_rx *ba_session_rx, u16 sequence_number)
{
struct netdev_vif *ndev_vif = netdev_priv(dev);
slsi_spinlock_lock(&ndev_vif->ba_lock);
if (WARN_ON(!ba_session_rx->active)) {
SLSI_NET_ERR(dev, "No BA session exists\n");
slsi_spinlock_unlock(&ndev_vif->ba_lock);
return;
}
ba_scroll_window(dev, ba_session_rx, sequence_number);
#ifdef CONFIG_SCSC_WLAN_RX_NAPI
slsi_ba_process_complete(dev, false);
#else
slsi_ba_signal_process_complete(dev);
#endif
slsi_spinlock_unlock(&ndev_vif->ba_lock);
}
void slsi_handle_blockack(struct net_device *dev, struct slsi_peer *peer,
u16 reason_code, u16 user_priority, u16 buffer_size, u16 sequence_number)
{
struct slsi_ba_session_rx *ba_session_rx;
if (WARN_ON(user_priority > FAPI_PRIORITY_QOS_UP7)) {
SLSI_NET_ERR(dev, "Invalid user_priority=%d\n", user_priority);
return;
}
SLSI_NET_DBG1(dev, SLSI_MLME, "reason_code:%d, user_priority:%d, buffer_size:%d, sequence_num:%d)\n",
reason_code,
user_priority,
buffer_size,
sequence_number);
ba_session_rx = peer->ba_session_rx[user_priority];
switch (reason_code) {
case FAPI_REASONCODE_START:
if (!peer->ba_session_rx[user_priority])
peer->ba_session_rx[user_priority] = slsi_rx_ba_alloc_buffer(dev);
if (peer->ba_session_rx[user_priority])
if (slsi_rx_ba_start(dev, peer, peer->ba_session_rx[user_priority], user_priority, buffer_size, sequence_number) != 0)
slsi_rx_ba_free_buffer(dev, peer, user_priority);
break;
case FAPI_REASONCODE_END:
if (ba_session_rx) {
slsi_rx_ba_stop_lock_unheld(dev, ba_session_rx);
slsi_rx_ba_free_buffer(dev, peer, user_priority);
}
break;
case FAPI_REASONCODE_UNSPECIFIED_REASON:
if (ba_session_rx)
slsi_ba_update_window(dev, ba_session_rx, sequence_number);
break;
default:
SLSI_NET_ERR(dev, "Invalid value: reason_code=%d\n", reason_code);
break;
}
}
Reference in a new issue View git blame Copy permalink