samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Rename broadcast T2LM data structure

Browse Source 
- Replace T2LM array in wlan_t2lm_context structure with established_t2lm
  and upcoming_t2lm structures
- Mapping switch time is different for each AP vdevs. Hence, store the
  value in vdev_mlme_proto_ap structure.
- Fix a few issues seen in mapping switch time expiry and expected duration
  expiry.

Change-Id: Id69badc3f4bf5e5e741691348488369008ffc4e9
CRs-Fixed: 3369279
This commit is contained in:
Shashikala Prabhu
2023-01-04 10:02:44 +05:30
committed by Madan Koyyalamudi
parent 2d884cc639
commit 88785d0116
6 changed files with 276 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
target_if/mlo_mgr/src/target_if_mlo_mgr.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
* Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -433,7 +433,7 @@ target_if_mlo_send_tid_to_link_mapping(struct wlan_objmgr_vdev *vdev,
params.t2lm_info[params.num_dir].default_link_mapping);
for (tid = 0; tid < T2LM_MAX_NUM_TIDS; tid++) {
t2lm_debug("tid:%d hw_link_map:%x ieee_lin_map:%x", tid,
t2lm_debug("tid:%d hw_link_map:%x ieee_link_map:%x", tid,
params.t2lm_info[params.num_dir].t2lm_provisioned_links[tid],
t2lm->ieee_link_map_tid[tid]);
}

5
umac/mlme/include/wlan_vdev_mlme.h
View File

@@ -1,6 +1,6 @@
/*
* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
* Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -86,9 +86,10 @@ struct vdev_mlme_proto_generic {
/**
* struct vdev_mlme_proto_ap - ap specific mlme protocol
* @.
* @mapping_switch_time: Mapping switch time of T2LM
*/
struct vdev_mlme_proto_ap {
uint16_t mapping_switch_time;
};
/**

2
umac/mlo_mgr/inc/wlan_mlo_mgr_public_structs.h
View File

@@ -839,7 +839,7 @@ enum wlan_t2lm_status {
struct mlo_vdev_host_tid_to_link_map_resp {
uint8_t vdev_id;
enum wlan_t2lm_status status;
uint8_t mapping_switch_tsf;
uint32_t mapping_switch_tsf;
};
/**

52
umac/mlo_mgr/inc/wlan_mlo_t2lm.h
View File

@@ -34,6 +34,16 @@ struct wlan_mlo_dev_context;
#define MAX_T2LM_HANDLERS 50
#define T2LM_EXPECTED_DURATION_MAX_VALUE 0xFFFFFF
/* Mapping switch time represented as bits 10 to 25 of the TSF value */
#define WLAN_T2LM_MAPPING_SWITCH_TSF_BITS 0x3FFFC00
/* There is a delay involved to receive and process the beacon/probe response
* T2LM IE from AP. To match mapping switch timer expiry in both AP and STA,
* advance timer expiry in STA by 100ms (= 98 * 1024 / 1000 = 100).
*/
#define WLAN_T2LM_MAPPING_SWITCH_TIME_DELAY 98
/**
* enum wlan_t2lm_direction - Indicates the direction for which TID-to-link
* mapping is available.
@@ -228,14 +238,14 @@ struct wlan_mlo_t2lm_ie {
* @t2lm_timer: T2LM timer
* @timer_interval: T2LM Timer value
* @timer_started: T2LM timer started or not
* @t2lm_ie_index: T2LM IE index value
* @timer_out_time: T2LM timer target out time
* @t2lm_dev_lock: lock to access struct
*/
struct wlan_t2lm_timer {
qdf_timer_t t2lm_timer;
uint32_t timer_interval;
uint32_t timer_out_time;
bool timer_started;
uint8_t t2lm_ie_index;
#ifdef WLAN_MLO_USE_SPINLOCK
qdf_spinlock_t t2lm_dev_lock;
#else
@@ -259,8 +269,14 @@ typedef QDF_STATUS (*wlan_mlo_t2lm_link_update_handler)(
/**
* struct wlan_t2lm_context - T2LM IE information
*
* @num_of_t2lm_ie: Number of T2LM IE
* @t2lm_ie: T2LM IE information
* @established_t2lm: Indicates the already established broadcast T2LM IE
* advertised by the AP in beacon/probe response frames.
* In this T2LM IE, expected duration flag is set to 1 and
* mapping switch time present flag is set to 0 when the
* mapping is non-default.
* @upcoming_t2lm: Indicates the new broadcast T2LM IE advertised by the AP in
* beacon/probe response frames. STA needs to use this mapping
* when expected duration in the established T2LM is expires.
* @t2lm_timer: T2LM timer information
* @t2lm_dev_lock: t2lm dev context lock
* @tsf: time sync func value received via beacon
@@ -268,8 +284,8 @@ typedef QDF_STATUS (*wlan_mlo_t2lm_link_update_handler)(
* @is_valid_handler: T2LM handler is valid or not
*/
struct wlan_t2lm_context {
uint8_t num_of_t2lm_ie;
struct wlan_mlo_t2lm_ie t2lm_ie[WLAN_MAX_T2LM_IE];
struct wlan_mlo_t2lm_ie established_t2lm;
struct wlan_mlo_t2lm_ie upcoming_t2lm;
struct wlan_t2lm_timer t2lm_timer;
#ifdef WLAN_MLO_USE_SPINLOCK
qdf_spinlock_t t2lm_dev_lock;
@@ -431,11 +447,13 @@ QDF_STATUS wlan_mlo_parse_t2lm_ie(
* wlan_mlo_add_t2lm_ie() - API to add TID-to-link mapping IE
* @frm: Pointer to buffer
* @t2lm: Pointer to t2lm mapping structure
* @vdev: Pointer to vdev structure
*
* Return: Updated frame pointer
*/
uint8_t *wlan_mlo_add_t2lm_ie(uint8_t *frm,
struct wlan_t2lm_onging_negotiation_info *t2lm);
struct wlan_t2lm_onging_negotiation_info *t2lm,
struct wlan_objmgr_vdev *vdev);
/**
* wlan_mlo_vdev_tid_to_link_map_event() - API to process the revceived T2LM
@@ -500,10 +518,12 @@ QDF_STATUS wlan_mlo_parse_t2lm_info(uint8_t *ie,
* wlan_mlo_add_t2lm_info_ie() - Add T2LM IE for UL/DL/Bidirection
* @frm: Pointer to buffer
* @t2lm: Pointer to t2lm mapping structure
* @vdev: Pointer to vdev structure
*
* Return: Updated frame pointer
*/
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm);
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm,
struct wlan_objmgr_vdev *vdev);
/**
* wlan_mlo_t2lm_timer_init() - API to initialize t2lm timer
@@ -527,13 +547,12 @@ wlan_mlo_t2lm_timer_deinit(struct wlan_objmgr_vdev *vdev);
* wlan_mlo_t2lm_timer_start() - API to start T2LM timer
* @vdev: Pointer to vdev
* @interval: T2LM timer interval
* @t2lm_ie_index: T2LM IE index
*
* Return: qdf status
*/
QDF_STATUS
wlan_mlo_t2lm_timer_start(struct wlan_objmgr_vdev *vdev,
uint32_t interval, uint8_t t2lm_ie_index);
uint32_t interval);
/**
* wlan_mlo_t2lm_timer_stop() - API to stop TID-to-link mapping timer
@@ -556,12 +575,11 @@ wlan_mlo_t2lm_timer_expiry_handler(void *vdev);
/**
* wlan_handle_t2lm_timer() - API to handle TID-to-link mapping timer
* @vdev: Pointer to vdev
* @ie_idx: ie index value
*
* Return: qdf status
*/
QDF_STATUS
wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev, uint8_t ie_idx);
wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev);
/**
* wlan_process_bcn_prbrsp_t2lm_ie() - API to process the received T2LM IE from
@@ -585,7 +603,8 @@ static inline QDF_STATUS wlan_mlo_parse_t2lm_ie(
static inline
int8_t *wlan_mlo_add_t2lm_ie(uint8_t *frm,
struct wlan_t2lm_onging_negotiation_info *t2lm)
struct wlan_t2lm_onging_negotiation_info *t2lm,
struct wlan_objmgr_vdev *vdev)
{
return frm;
}
@@ -622,7 +641,8 @@ QDF_STATUS wlan_mlo_parse_t2lm_info(uint8_t *ie,
}
static inline
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm,
struct wlan_objmgr_vdev *vdev)
{
return frm;
}
@@ -641,7 +661,7 @@ wlan_mlo_t2lm_timer_deinit(struct wlan_objmgr_vdev *vdev)
static inline QDF_STATUS
wlan_mlo_t2lm_timer_start(struct wlan_objmgr_vdev *vdev,
uint32_t interval, uint8_t t2lm_ie_index)
uint32_t interval)
{
return QDF_STATUS_E_NOSUPPORT;
}
@@ -657,7 +677,7 @@ wlan_mlo_t2lm_timer_expiry_handler(void *vdev)
{}
static inline QDF_STATUS
wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev, uint8_t ie_idx)
wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev)
{
return QDF_STATUS_E_NOSUPPORT;
}

3
umac/mlo_mgr/src/wlan_mlo_mgr_main.c
View File

@@ -505,11 +505,10 @@ static inline void mlo_t2lm_ctx_init(struct wlan_mlo_dev_context *ml_dev,
{
struct wlan_t2lm_info *t2lm;
t2lm = &ml_dev->t2lm_ctx.t2lm_ie[0].t2lm;
t2lm = &ml_dev->t2lm_ctx.established_t2lm.t2lm;
qdf_mem_zero(&ml_dev->t2lm_ctx, sizeof(struct wlan_t2lm_context));
ml_dev->t2lm_ctx.num_of_t2lm_ie = 1;
t2lm->direction = WLAN_T2LM_BIDI_DIRECTION;
t2lm->default_link_mapping = 1;

414
umac/mlo_mgr/src/wlan_mlo_t2lm.c
View File

@@ -116,7 +116,7 @@ QDF_STATUS wlan_mlo_parse_t2lm_info(uint8_t *ie,
t2lm->ieee_link_map_tid[tid_num] =
qdf_le16_to_cpu(*(uint16_t *)link_mapping_of_tids);
t2lm_debug("link mapping of TID%d is %x", tid_num,
t2lm_rl_debug("link mapping of TID%d is %x", tid_num,
t2lm->ieee_link_map_tid[tid_num]);
link_mapping_of_tids += sizeof(uint16_t);
@@ -128,18 +128,17 @@ QDF_STATUS wlan_mlo_parse_t2lm_info(uint8_t *ie,
QDF_STATUS wlan_mlo_parse_bcn_prbresp_t2lm_ie(
struct wlan_t2lm_context *t2lm_ctx, uint8_t *ie)
{
struct wlan_t2lm_info t2lm = {0};
struct extn_ie_header *ext_ie_hdr;
QDF_STATUS retval;
int i = 0;
for (i = 0; i < t2lm_ctx->num_of_t2lm_ie; i++) {
qdf_mem_zero(&t2lm_ctx->t2lm_ie[i].t2lm,
sizeof(struct wlan_t2lm_info));
t2lm_ctx->t2lm_ie[i].t2lm.direction =
WLAN_T2LM_INVALID_DIRECTION;
}
qdf_mem_zero(&t2lm_ctx->established_t2lm,
sizeof(struct wlan_mlo_t2lm_ie));
qdf_mem_zero(&t2lm_ctx->upcoming_t2lm, sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->num_of_t2lm_ie = 0;
t2lm_ctx->established_t2lm.t2lm.direction = WLAN_T2LM_INVALID_DIRECTION;
t2lm_ctx->upcoming_t2lm.t2lm.direction = WLAN_T2LM_INVALID_DIRECTION;
for (i = 0; i < WLAN_MAX_T2LM_IE; i++) {
if (!ie) {
@@ -149,20 +148,28 @@ QDF_STATUS wlan_mlo_parse_bcn_prbresp_t2lm_ie(
ext_ie_hdr = (struct extn_ie_header *)ie;
if (ext_ie_hdr->ie_id == WLAN_ELEMID_EXTN_ELEM &&
ext_ie_hdr->ie_extn_id == WLAN_EXTN_ELEMID_T2LM) {
retval = wlan_mlo_parse_t2lm_info(
ie, &t2lm_ctx->t2lm_ie[i].t2lm);
if (!(ext_ie_hdr->ie_id == WLAN_ELEMID_EXTN_ELEM &&
ext_ie_hdr->ie_extn_id == WLAN_EXTN_ELEMID_T2LM))
continue;
t2lm.direction = WLAN_T2LM_INVALID_DIRECTION;
retval = wlan_mlo_parse_t2lm_info(ie, &t2lm);
if (retval) {
t2lm_err("Failed to parse the T2LM IE");
return retval;
}
t2lm_ctx->num_of_t2lm_ie++;
if (!t2lm.mapping_switch_time_present &&
t2lm.expected_duration_present) {
qdf_mem_copy(&t2lm_ctx->established_t2lm.t2lm, &t2lm,
sizeof(struct wlan_t2lm_info));
} else if (t2lm.mapping_switch_time_present) {
qdf_mem_copy(&t2lm_ctx->upcoming_t2lm.t2lm, &t2lm,
sizeof(struct wlan_t2lm_info));
}
ie += ext_ie_hdr->ie_len + sizeof(struct ie_header);
}
}
return QDF_STATUS_SUCCESS;
}
@@ -223,14 +230,8 @@ QDF_STATUS wlan_mlo_parse_t2lm_ie(
return QDF_STATUS_SUCCESS;
}
/**
* wlan_mlo_add_t2lm_info_ie() - Add T2LM IE for UL/DL/Bidirection
* @frm: Pointer to buffer
* @t2lm: Pointer to t2lm mapping structure
*
* Return: Updated frame pointer
*/
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm,
struct wlan_objmgr_vdev *vdev)
{
struct wlan_ie_tid_to_link_mapping *t2lm_ie;
uint16_t t2lm_control = 0;
@@ -239,6 +240,7 @@ uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
uint8_t tid_num;
uint8_t num_tids = 0;
uint8_t link_mapping_presence_indicator = 0;
struct vdev_mlme_obj *vdev_mlme;
t2lm_ie = (struct wlan_ie_tid_to_link_mapping *)frm;
t2lm_ie->elem_id = WLAN_ELEMID_EXTN_ELEM;
@@ -298,8 +300,13 @@ uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
t2lm_ie->elem_len += sizeof(uint16_t);
}
if (t2lm->mapping_switch_time_present) {
*frm = htole16(t2lm->mapping_switch_time);
vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
if (vdev_mlme && t2lm->mapping_switch_time_present) {
/* Mapping switch time is different for each vdevs. Hence,
* populate the mapping switch time from vdev_mlme_obj.
*/
*(uint16_t *)frm =
htole16(vdev_mlme->proto.ap.mapping_switch_time);
frm += sizeof(uint16_t);
t2lm_ie->elem_len += sizeof(uint16_t);
}
@@ -308,7 +315,7 @@ uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
qdf_mem_copy(frm, &t2lm->expected_duration,
WLAN_T2LM_EXPECTED_DURATION_SIZE *
sizeof(uint8_t));
frm += WLAN_T2LM_EXPECTED_DURATION_SIZE;
frm += WLAN_T2LM_EXPECTED_DURATION_SIZE * sizeof(uint8_t);
t2lm_ie->elem_len +=
WLAN_T2LM_EXPECTED_DURATION_SIZE * sizeof(uint8_t);
}
@@ -340,7 +347,8 @@ uint8_t *wlan_mlo_add_t2lm_info_ie(uint8_t *frm, struct wlan_t2lm_info *t2lm)
}
uint8_t *wlan_mlo_add_t2lm_ie(uint8_t *frm,
struct wlan_t2lm_onging_negotiation_info *t2lm)
struct wlan_t2lm_onging_negotiation_info *t2lm,
struct wlan_objmgr_vdev *vdev)
{
uint8_t dir;
@@ -371,7 +379,8 @@ uint8_t *wlan_mlo_add_t2lm_ie(uint8_t *frm,
if (t2lm->t2lm_info[dir].direction !=
WLAN_T2LM_INVALID_DIRECTION)
frm = wlan_mlo_add_t2lm_info_ie(frm,
&t2lm->t2lm_info[dir]);
&t2lm->t2lm_info[dir],
vdev);
}
return frm;
@@ -514,7 +523,7 @@ static uint8_t *wlan_mlo_add_t2lm_request_action_frame(
t2lm_info("T2LM request frame: category:%d action:%d dialog_token:%d",
args->category, args->action, args->arg1);
return wlan_mlo_add_t2lm_ie(frm, (void *)buf);
return wlan_mlo_add_t2lm_ie(frm, (void *)buf, NULL);
}
static uint8_t *wlan_mlo_add_t2lm_response_action_frame(
@@ -533,7 +542,7 @@ static uint8_t *wlan_mlo_add_t2lm_response_action_frame(
args->category, args->action, args->arg1, args->arg2);
if (args->arg2 == WLAN_T2LM_RESP_TYPE_PREFERRED_TID_TO_LINK_MAPPING)
frm = wlan_mlo_add_t2lm_ie(frm, (void *)buf);
frm = wlan_mlo_add_t2lm_ie(frm, (void *)buf, NULL);
return frm;
}
@@ -574,26 +583,28 @@ static void wlan_mlo_t2lm_handle_mapping_switch_time_expiry(
struct wlan_t2lm_context *t2lm_ctx,
struct wlan_objmgr_vdev *vdev)
{
uint8_t vdev_id = wlan_vdev_get_id(vdev);
int i = 0;
struct wlan_t2lm_info *t2lm;
for (i = 0; i < t2lm_ctx->num_of_t2lm_ie; i++) {
if (!t2lm_ctx->t2lm_ie[i].t2lm.mapping_switch_time_present)
continue;
t2lm_debug("Mapping switch time expired for vdev_id:%d ",
wlan_vdev_get_id(vdev));
/* Mapping switch time will always present at index 1. Hence,
* skip the index 0.
*/
if (i == 0)
continue;
qdf_mem_copy(&t2lm_ctx->t2lm_ie[0], &t2lm_ctx->t2lm_ie[1],
qdf_mem_copy(&t2lm_ctx->established_t2lm, &t2lm_ctx->upcoming_t2lm,
sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->t2lm_ie[0].t2lm.mapping_switch_time_present = false;
t2lm_ctx->t2lm_ie[0].t2lm.mapping_switch_time = 0;
t2lm_debug("vdev_id:%d mark the advertised T2LM as established",
vdev_id);
}
t2lm_ctx->established_t2lm.t2lm.mapping_switch_time_present = false;
t2lm_ctx->established_t2lm.t2lm.mapping_switch_time = 0;
t2lm = &t2lm_ctx->established_t2lm.t2lm;
t2lm_debug("Established mapping: disabled_link_bitmap:%x dir:%d default_map:%d MSTP:%d EDP:%d MST:%d ED:%d ieee_link_map:%x hw_link_map:%x",
t2lm_ctx->established_t2lm.disabled_link_bitmap,
t2lm->direction, t2lm->default_link_mapping,
t2lm->mapping_switch_time_present,
t2lm->expected_duration_present,
t2lm->mapping_switch_time, t2lm->expected_duration,
t2lm->ieee_link_map_tid[0], t2lm->hw_link_map_tid[0]);
qdf_mem_zero(&t2lm_ctx->upcoming_t2lm, sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->upcoming_t2lm.t2lm.direction = WLAN_T2LM_INVALID_DIRECTION;
/* Notify the registered caller about the link update*/
wlan_mlo_dev_t2lm_notify_link_update(vdev->mlo_dev_ctx);
@@ -611,40 +622,31 @@ static void wlan_mlo_t2lm_handle_expected_duration_expiry(
struct wlan_t2lm_context *t2lm_ctx,
struct wlan_objmgr_vdev *vdev)
{
uint8_t vdev_id = wlan_vdev_get_id(vdev);
int i = 0;
t2lm_debug("Expected duration expired for vdev_id:%d ",
wlan_vdev_get_id(vdev));
for (i = 0; i < t2lm_ctx->num_of_t2lm_ie; i++) {
if (!t2lm_ctx->t2lm_ie[i].t2lm.expected_duration_present)
continue;
/* If two T2LM IEs are present, and expected duration of first
* T2LM IE is expired, copy the T2LM IE from index 1 to index 0.
* Mark mapping switch time present as false and clear the
* mapping switch time value.
* If one T2LM IE is present, and the expected duration is
* expired, configure the T2LM IE with the default values.
if (t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time_present) {
/* Copy the new non-default ongoing mapping to established
* mapping if expected duration expires for the established
* mapping.
*/
if (!i && t2lm_ctx->num_of_t2lm_ie == WLAN_MAX_T2LM_IE) {
qdf_mem_copy(&t2lm_ctx->t2lm_ie[0],
&t2lm_ctx->t2lm_ie[1],
sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->t2lm_ie[0].t2lm.mapping_switch_time_present =
false;
t2lm_ctx->t2lm_ie[0].t2lm.mapping_switch_time = 0;
t2lm_debug("vdev_id:%d mark the advertised T2LM as established",
vdev_id);
} else {
qdf_mem_zero(&t2lm_ctx->t2lm_ie[i],
sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->t2lm_ie[i].t2lm.direction =
WLAN_T2LM_BIDI_DIRECTION;
t2lm_ctx->t2lm_ie[i].t2lm.default_link_mapping = 1;
t2lm_debug("vdev_id:%d Expected duration is expired",
vdev_id);
}
wlan_mlo_t2lm_handle_mapping_switch_time_expiry(t2lm_ctx,
vdev);
return;
}
/* Use the default mapping when expected duration expires for the
* established mapping and no new non-default T2LM announcement is
* ongoing.
*/
qdf_mem_zero(&t2lm_ctx->established_t2lm,
sizeof(struct wlan_mlo_t2lm_ie));
t2lm_ctx->established_t2lm.t2lm.direction = WLAN_T2LM_BIDI_DIRECTION;
t2lm_ctx->established_t2lm.t2lm.default_link_mapping = 1;
t2lm_ctx->established_t2lm.disabled_link_bitmap = 0;
t2lm_debug("Set established mapping to default mapping");
/* Notify the registered caller about the link update*/
wlan_mlo_dev_t2lm_notify_link_update(vdev->mlo_dev_ctx);
}
@@ -655,7 +657,7 @@ QDF_STATUS wlan_mlo_vdev_tid_to_link_map_event(
{
struct wlan_objmgr_vdev *vdev;
struct wlan_t2lm_context *t2lm_ctx;
int i = 0;
struct vdev_mlme_obj *vdev_mlme;
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, event->vdev_id,
WLAN_MLO_MGR_ID);
@@ -669,23 +671,35 @@ QDF_STATUS wlan_mlo_vdev_tid_to_link_map_event(
return QDF_STATUS_E_NULL_VALUE;
}
vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
if (!vdev_mlme) {
t2lm_err("null vdev_mlme");
return QDF_STATUS_E_FAILURE;
}
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
t2lm_debug("status:%d", event->status);
t2lm_debug("psoc_id:%d vdev_id:%d status:%d",
wlan_psoc_get_id(psoc), event->vdev_id, event->status);
t2lm_dev_lock_acquire(t2lm_ctx);
switch (event->status) {
case WLAN_MAP_SWITCH_TIMER_TSF:
for (i = 0; i < t2lm_ctx->num_of_t2lm_ie; i++) {
if (!t2lm_ctx->t2lm_ie[i].t2lm.mapping_switch_time_present)
continue;
t2lm_ctx->t2lm_ie[i].t2lm.mapping_switch_time =
event->mapping_switch_tsf;
/* Mapping switch time is different for each AP vdev of a given
* MLD as these vdevs can have separate beacon TDF value.
*/
if (t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time_present)
vdev_mlme->proto.ap.mapping_switch_time =
(event->mapping_switch_tsf &
WLAN_T2LM_MAPPING_SWITCH_TSF_BITS) >> 10;
t2lm_debug("vdev_id:%d updated mapping switch time:%d",
event->vdev_id, event->mapping_switch_tsf);
}
event->vdev_id,
vdev_mlme->proto.ap.mapping_switch_time);
break;
case WLAN_MAP_SWITCH_TIMER_EXPIRED:
vdev_mlme->proto.ap.mapping_switch_time = 0;
wlan_mlo_t2lm_handle_mapping_switch_time_expiry(t2lm_ctx, vdev);
break;
case WLAN_EXPECTED_DUR_EXPIRED:
@@ -695,6 +709,7 @@ QDF_STATUS wlan_mlo_vdev_tid_to_link_map_event(
t2lm_err("Invalid status");
}
t2lm_dev_lock_release(t2lm_ctx);
mlo_release_vdev_ref(vdev);
return QDF_STATUS_SUCCESS;
@@ -759,28 +774,33 @@ void wlan_mlo_t2lm_timer_expiry_handler(void *vdev)
struct wlan_t2lm_timer *t2lm_timer;
struct wlan_t2lm_context *t2lm_ctx;
uint8_t t2lm_ie_idx;
if (!vdev_ctx || !vdev_ctx->mlo_dev_ctx)
return;
t2lm_ctx = &vdev_ctx->mlo_dev_ctx->t2lm_ctx;
t2lm_timer = &vdev_ctx->mlo_dev_ctx->t2lm_ctx.t2lm_timer;
t2lm_ie_idx = t2lm_timer->t2lm_ie_index;
if (t2lm_ie_idx >= WLAN_MAX_T2LM_IE)
return;
wlan_mlo_t2lm_timer_stop(vdev_ctx);
if (t2lm_ctx->t2lm_ie[t2lm_ie_idx].t2lm.mapping_switch_time_present) {
wlan_send_tid_to_link_mapping(
vdev, &t2lm_ctx->t2lm_ie[t2lm_ie_idx].t2lm);
wlan_mlo_t2lm_handle_mapping_switch_time_expiry(t2lm_ctx, vdev);
wlan_handle_t2lm_timer(vdev_ctx, t2lm_timer->t2lm_ie_index);
} else if (!t2lm_ie_idx) {
/* Since qdf_mutex_acquire cannot be called from interrupt context,
* change needed to create a workqueue and offload the timer expiry
* handling to workqueue.
*/
if (t2lm_ctx->established_t2lm.t2lm.expected_duration_present) {
wlan_mlo_t2lm_handle_expected_duration_expiry(t2lm_ctx, vdev);
wlan_handle_t2lm_timer(vdev_ctx, t2lm_timer->t2lm_ie_index);
wlan_send_tid_to_link_mapping(
vdev, &t2lm_ctx->established_t2lm.t2lm);
wlan_handle_t2lm_timer(vdev_ctx);
} else if (t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time_present) {
wlan_mlo_t2lm_handle_mapping_switch_time_expiry(t2lm_ctx, vdev);
wlan_send_tid_to_link_mapping(
vdev, &t2lm_ctx->established_t2lm.t2lm);
wlan_handle_t2lm_timer(vdev_ctx);
}
}
QDF_STATUS
@@ -805,31 +825,24 @@ wlan_mlo_t2lm_timer_init(struct wlan_objmgr_vdev *vdev)
t2lm_timer->timer_started = false;
t2lm_timer->timer_interval = 0;
t2lm_timer->t2lm_ie_index = 0;
t2lm_timer->timer_out_time = 0;
t2lm_dev_lock_release(&vdev->mlo_dev_ctx->t2lm_ctx);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS
wlan_mlo_t2lm_timer_start(struct wlan_objmgr_vdev *vdev,
uint32_t interval, uint8_t t2lm_ie_index)
uint32_t interval)
{
struct wlan_t2lm_timer *t2lm_timer;
struct wlan_t2lm_context *t2lm_ctx;
struct vdev_mlme_obj *vdev_mlme;
uint32_t target_out_time;
if (!vdev || !vdev->mlo_dev_ctx)
return QDF_STATUS_E_NULL_VALUE;
if (interval == 0) {
if (!interval) {
t2lm_debug("Timer interval is 0");
return QDF_STATUS_E_NULL_VALUE;
}
vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
if (!vdev_mlme)
return QDF_STATUS_E_FAILURE;
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
t2lm_timer = &vdev->mlo_dev_ctx->t2lm_ctx.t2lm_timer;
if (!t2lm_timer) {
@@ -837,19 +850,29 @@ wlan_mlo_t2lm_timer_start(struct wlan_objmgr_vdev *vdev,
return QDF_STATUS_E_NULL_VALUE;
}
t2lm_debug("t2lm timer started with interval %d", interval);
t2lm_dev_lock_acquire(&vdev->mlo_dev_ctx->t2lm_ctx);
if (t2lm_ctx->t2lm_ie[t2lm_ie_index].t2lm.mapping_switch_time_present)
t2lm_timer->timer_interval =
t2lm_ctx->t2lm_ie[t2lm_ie_index].t2lm.mapping_switch_time;
else
t2lm_timer->timer_interval = interval *
vdev_mlme->proto.generic.beacon_interval * 1000;
interval = (interval * 1024) / 1000;
target_out_time = qdf_system_ticks_to_msecs(qdf_system_ticks());
target_out_time += interval;
t2lm_debug("earlier timer @%u ms out, new @%u ms out",
t2lm_timer->timer_out_time, target_out_time);
t2lm_timer->t2lm_ie_index = t2lm_ie_index;
/* sometimes the host process the beacon maybe delay, it may help for
* update the new expected time.
*/
if (t2lm_timer->timer_out_time &&
(target_out_time > t2lm_timer->timer_out_time ||
(t2lm_timer->timer_out_time - target_out_time) <
WLAN_T2LM_MAPPING_SWITCH_TIME_DELAY))
return QDF_STATUS_E_NULL_VALUE;
if (t2lm_timer->timer_started)
qdf_timer_stop(&t2lm_timer->t2lm_timer);
t2lm_debug("t2lm timer started with interval %d ms", interval);
t2lm_timer->timer_interval = interval;
t2lm_timer->timer_started = true;
t2lm_timer->timer_out_time = target_out_time;
qdf_timer_start(&t2lm_timer->t2lm_timer, t2lm_timer->timer_interval);
t2lm_dev_lock_release(&vdev->mlo_dev_ctx->t2lm_ctx);
return QDF_STATUS_SUCCESS;
}
@@ -873,51 +896,40 @@ wlan_mlo_t2lm_timer_stop(struct wlan_objmgr_vdev *vdev)
qdf_timer_stop(&t2lm_timer->t2lm_timer);
t2lm_timer->timer_started = false;
t2lm_timer->timer_interval = 0;
t2lm_timer->timer_out_time = 0;
}
t2lm_dev_lock_release(&vdev->mlo_dev_ctx->t2lm_ctx);
return QDF_STATUS_SUCCESS;
}
QDF_STATUS wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev, uint8_t ie_idx)
QDF_STATUS wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev)
{
struct wlan_t2lm_context *t2lm_ctx;
struct vdev_mlme_obj *vdev_mlme;
QDF_STATUS status = QDF_STATUS_SUCCESS;
if (!vdev || !vdev->mlo_dev_ctx)
return QDF_STATUS_E_NULL_VALUE;
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
if (!t2lm_ctx->num_of_t2lm_ie) {
t2lm_err("No T2LM IE present");
return QDF_STATUS_SUCCESS;
}
if (ie_idx >= WLAN_MAX_T2LM_IE) {
t2lm_err("Invalid T2LM IE index");
vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
if (!vdev_mlme)
return QDF_STATUS_E_FAILURE;
if (t2lm_ctx->established_t2lm.t2lm.expected_duration_present) {
if (t2lm_ctx->established_t2lm.t2lm.expected_duration ==
T2LM_EXPECTED_DURATION_MAX_VALUE) {
return status;
}
if (!t2lm_ctx->t2lm_ie[ie_idx].t2lm.mapping_switch_time_present &&
!t2lm_ctx->t2lm_ie[ie_idx].t2lm.expected_duration_present) {
/* non-default to default mapping case */
wlan_send_tid_to_link_mapping(vdev,
&t2lm_ctx->t2lm_ie[ie_idx].t2lm);
} else if (t2lm_ctx->t2lm_ie[ie_idx].t2lm.mapping_switch_time_present) {
/* Default to non-default mapping case */
status = wlan_mlo_t2lm_timer_start(
vdev,
t2lm_ctx->t2lm_ie[ie_idx].t2lm.mapping_switch_time,
ie_idx);
} else if (t2lm_ctx->t2lm_ie[ie_idx].t2lm.expected_duration_present) {
wlan_send_tid_to_link_mapping(
vdev, &t2lm_ctx->t2lm_ie[ie_idx].t2lm);
if (t2lm_ctx->t2lm_ie[ie_idx].t2lm.expected_duration !=
T2LM_EXPECTED_DURATION_MAX_VALUE)
t2lm_ctx->established_t2lm.t2lm.expected_duration);
} else if (t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time_present) {
status = wlan_mlo_t2lm_timer_start(
vdev,
t2lm_ctx->t2lm_ie[ie_idx].t2lm.expected_duration,
ie_idx);
t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time);
}
return status;
@@ -932,52 +944,69 @@ QDF_STATUS wlan_handle_t2lm_timer(struct wlan_objmgr_vdev *vdev, uint8_t ie_idx)
*
* Return: None
*/
static void wlan_update_mapping_switch_time_expected_dur(
struct wlan_objmgr_vdev *vdev, struct wlan_t2lm_info *rx_t2lm,
uint64_t tsf)
static QDF_STATUS wlan_update_mapping_switch_time_expected_dur(
struct wlan_objmgr_vdev *vdev,
struct wlan_t2lm_context *rx_t2lm, uint64_t tsf)
{
struct wlan_t2lm_context *t2lm_ctx;
uint16_t tsf_bit25_16, ms_time;
bool match_found = false;
int j;
uint16_t tsf_bit25_10, ms_time;
tsf_bit25_16 = (tsf & 0x3FF0000) >> 16;
tsf_bit25_10 = (tsf & WLAN_T2LM_MAPPING_SWITCH_TSF_BITS) >> 10;
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
for (j = 0; j < t2lm_ctx->num_of_t2lm_ie; j++) {
/* Match not found */
if (qdf_mem_cmp(rx_t2lm->ieee_link_map_tid,
t2lm_ctx->t2lm_ie[j].t2lm.ieee_link_map_tid,
sizeof(uint16_t) * T2LM_MAX_NUM_TIDS))
continue;
t2lm_dev_lock_acquire(t2lm_ctx);
if (t2lm_ctx->t2lm_ie[j].t2lm.mapping_switch_time_present) {
ms_time = rx_t2lm->mapping_switch_time;
if (t2lm_ctx->established_t2lm.t2lm.expected_duration_present &&
rx_t2lm->established_t2lm.t2lm.expected_duration_present) {
/* Established T2LM is already saved in the T2LM context.
* T2LM IE in the beacon/probe response frame has the updated
* expected duration.
*/
if (!qdf_mem_cmp(t2lm_ctx->established_t2lm.t2lm.ieee_link_map_tid,
rx_t2lm->established_t2lm.t2lm.ieee_link_map_tid,
sizeof(uint16_t) * T2LM_MAX_NUM_TIDS)) {
t2lm_ctx->established_t2lm.t2lm.expected_duration =
rx_t2lm->established_t2lm.t2lm.expected_duration;
}
} else if (rx_t2lm->established_t2lm.t2lm.expected_duration_present &&
!rx_t2lm->established_t2lm.t2lm.mapping_switch_time_present) {
/* Mapping switch time is already expired when STA receives the
* T2LM IE from beacon/probe response frame.
*/
qdf_mem_copy(&t2lm_ctx->established_t2lm.t2lm,
&rx_t2lm->established_t2lm.t2lm,
sizeof(struct wlan_t2lm_info));
wlan_send_tid_to_link_mapping(
vdev, &t2lm_ctx->established_t2lm.t2lm);
}
if (ms_time > tsf_bit25_16) {
t2lm_ctx->t2lm_ie[j].t2lm.mapping_switch_time =
((ms_time - tsf_bit25_16) * 1024) / 1000;
if (rx_t2lm->upcoming_t2lm.t2lm.mapping_switch_time_present) {
if (!qdf_mem_cmp(t2lm_ctx->established_t2lm.t2lm.ieee_link_map_tid,
rx_t2lm->upcoming_t2lm.t2lm.ieee_link_map_tid,
sizeof(uint16_t) * T2LM_MAX_NUM_TIDS)) {
t2lm_debug("Ongoing mapping is already established");
t2lm_dev_lock_release(t2lm_ctx);
return QDF_STATUS_E_ALREADY;
}
qdf_mem_copy(&t2lm_ctx->upcoming_t2lm.t2lm,
&rx_t2lm->upcoming_t2lm.t2lm,
sizeof(struct wlan_t2lm_info));
ms_time = t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time;
/* Per test, -300ms is fine */
if (ms_time > tsf_bit25_10) {
t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time =
(ms_time - tsf_bit25_10 - (3 * WLAN_T2LM_MAPPING_SWITCH_TIME_DELAY));
} else {
t2lm_ctx->t2lm_ie[j].t2lm.mapping_switch_time =
((0xFFFF - (tsf_bit25_16 - ms_time)) * 1024) / 1000;
t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time =
0xFFFF - (tsf_bit25_10 - ms_time) - (3 * WLAN_T2LM_MAPPING_SWITCH_TIME_DELAY);
}
}
if (t2lm_ctx->t2lm_ie[j].t2lm.expected_duration_present) {
t2lm_ctx->t2lm_ie[j].t2lm.expected_duration =
rx_t2lm->expected_duration;
}
t2lm_dev_lock_release(t2lm_ctx);
match_found = true;
break;
}
if (!match_found &&
t2lm_ctx->num_of_t2lm_ie < WLAN_MAX_T2LM_IE) {
qdf_mem_copy(&t2lm_ctx->t2lm_ie[t2lm_ctx->num_of_t2lm_ie].t2lm,
rx_t2lm, sizeof(struct wlan_t2lm_info));
t2lm_ctx->num_of_t2lm_ie++;
}
return QDF_STATUS_SUCCESS;
}
QDF_STATUS wlan_process_bcn_prbrsp_t2lm_ie(
@@ -985,26 +1014,25 @@ QDF_STATUS wlan_process_bcn_prbrsp_t2lm_ie(
struct wlan_t2lm_context *rx_t2lm_ie, uint64_t tsf)
{
struct wlan_t2lm_context *t2lm_ctx;
int i;
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
for (i = 0; i < rx_t2lm_ie->num_of_t2lm_ie; i++) {
wlan_update_mapping_switch_time_expected_dur(
vdev, &rx_t2lm_ie->t2lm_ie[i].t2lm, tsf);
}
QDF_STATUS status;
/* Do not parse the T2LM IE if STA is not in connected state */
if (!wlan_cm_is_vdev_connected(vdev))
return QDF_STATUS_SUCCESS;
/* Do not start the timer if STA is not in connected state */
for (i = 0; i < t2lm_ctx->num_of_t2lm_ie; i++) {
if (t2lm_ctx->t2lm_ie[i].t2lm.mapping_switch_time_present ||
t2lm_ctx->t2lm_ie[i].t2lm.expected_duration_present) {
wlan_handle_t2lm_timer(vdev, i);
break;
}
t2lm_ctx = &vdev->mlo_dev_ctx->t2lm_ctx;
status = wlan_update_mapping_switch_time_expected_dur(
vdev, rx_t2lm_ie, tsf);
if (QDF_IS_STATUS_ERROR(status))
return status;
t2lm_dev_lock_acquire(t2lm_ctx);
if (t2lm_ctx->established_t2lm.t2lm.expected_duration_present ||
t2lm_ctx->upcoming_t2lm.t2lm.mapping_switch_time_present) {
wlan_handle_t2lm_timer(vdev);
}
t2lm_dev_lock_release(t2lm_ctx);
return QDF_STATUS_SUCCESS;
}
@@ -1056,10 +1084,11 @@ QDF_STATUS wlan_mlo_dev_t2lm_notify_link_update(
continue;
handler = t2lm_ctx->link_update_handler[i];
if (!(handler && t2lm_ctx->num_of_t2lm_ie))
if (!handler)
continue;
handler(mldev, &t2lm_ctx->t2lm_ie[0].t2lm.ieee_link_map_tid[0]);
handler(mldev,
&t2lm_ctx->established_t2lm.t2lm.ieee_link_map_tid[0]);
}
return QDF_STATUS_SUCCESS;
}
@@ -1081,7 +1110,6 @@ wlan_mlo_t2lm_timer_deinit(struct wlan_objmgr_vdev *vdev)
t2lm_dev_lock_acquire(&vdev->mlo_dev_ctx->t2lm_ctx);
t2lm_timer->timer_started = false;
t2lm_timer->timer_interval = 0;
t2lm_timer->t2lm_ie_index = 0;
t2lm_dev_lock_release(&vdev->mlo_dev_ctx->t2lm_ctx);
qdf_timer_free(&t2lm_timer->t2lm_timer);
t2lm_dev_lock_destroy(&vdev->mlo_dev_ctx->t2lm_ctx);