A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-14 16:46:15 -04:00
Code Issues Projects Releases Packages Wiki Activity

qcacmn: MCL part change after serialization enhancement

Browse source 
1. Keep serialization legacy api not broken.
Serialization enhancement have much changes on internal struct
and API, need re-implement serialization legacy APIs.

2. Set all cmds on MCL platform as blocking type.
MCL dones't support cmd concurrency on multi vdevs, while WIN need
it.

Change-Id: I5d5d6e0e16becb0b0f285fd8ed20982f2819659c
CRs-Fixed: 2315407
This commit is contained in:
Jianmin Zhu 2018-08-30 13:23:30 +08:00 • committed by nshrivas
commit 035ab54cdc
4 changed files with 140 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

235
umac/cmn_services/serialization/src/wlan_serialization_legacy_api.c
View file

@ -26,6 +26,9 @@
#include "wlan_serialization_main_i.h"
#include "wlan_serialization_utils_i.h"
#include "wlan_objmgr_vdev_obj.h"
#include "wlan_serialization_internal_i.h"
#include "wlan_serialization_scan_i.h"
#include "wlan_serialization_non_scan_i.h"
extern struct serialization_legacy_callback ser_legacy_cb;
@ -36,7 +39,7 @@ static struct wlan_objmgr_pdev *wlan_serialization_get_first_pdev(
uint8_t i = 0;
if (!psoc) {
serialization_err("invalid psoc");
ser_err("invalid psoc");
return NULL;
}
for (i = 0; i < WLAN_UMAC_MAX_PDEVS; i++) {
@ -49,27 +52,27 @@ static struct wlan_objmgr_pdev *wlan_serialization_get_first_pdev(
return pdev;
}
static struct wlan_serialization_pdev_priv_obj *
static struct wlan_ser_pdev_obj *
wlan_serialization_get_pdev_priv_obj_using_psoc(struct wlan_objmgr_psoc *psoc)
{
struct wlan_objmgr_pdev *pdev = NULL;
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
if (!psoc) {
serialization_err("invalid psoc");
ser_err("invalid psoc");
return NULL;
}
pdev = wlan_serialization_get_first_pdev(psoc);
if (!pdev) {
serialization_err("invalid pdev");
ser_err("invalid pdev");
return NULL;
}
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj(pdev);
ser_pdev_obj = wlan_serialization_get_pdev_obj(pdev);
wlan_objmgr_pdev_release_ref(pdev, WLAN_SERIALIZATION_ID);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return NULL;
}
@ -80,24 +83,27 @@ uint32_t wlan_serialization_get_active_list_count(
struct wlan_objmgr_psoc *psoc,
uint8_t is_cmd_from_active_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
qdf_list_t *queue;
struct wlan_serialization_pdev_queue *pdev_queue;
uint32_t count;
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return 0;
}
wlan_serialization_acquire_lock(ser_pdev_obj);
if (is_cmd_from_active_scan_queue)
queue = &ser_pdev_obj->active_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->active_list;
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
wlan_serialization_acquire_lock(&pdev_queue->pdev_queue_lock);
queue = &pdev_queue->active_list;
count = qdf_list_size(queue);
wlan_serialization_release_lock(ser_pdev_obj);
wlan_serialization_release_lock(&pdev_queue->pdev_queue_lock);
return count;
}
@ -106,24 +112,26 @@ uint32_t wlan_serialization_get_pending_list_count(
struct wlan_objmgr_psoc *psoc,
uint8_t is_cmd_from_pending_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
qdf_list_t *queue;
uint32_t count = 0;
struct wlan_serialization_pdev_queue *pdev_queue;
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return 0;
}
wlan_serialization_acquire_lock(ser_pdev_obj);
if (is_cmd_from_pending_scan_queue)
queue = &ser_pdev_obj->pending_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->pending_list;
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
queue = &pdev_queue->pending_list;
wlan_serialization_acquire_lock(&pdev_queue->pdev_queue_lock);
count = qdf_list_size(queue);
wlan_serialization_release_lock(ser_pdev_obj);
wlan_serialization_release_lock(&pdev_queue->pdev_queue_lock);
return count;
}
@ -133,38 +141,41 @@ wlan_serialization_peek_head_active_cmd_using_psoc(
struct wlan_objmgr_psoc *psoc,
uint8_t is_cmd_from_active_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
struct wlan_serialization_command_list *cmd_list = NULL;
struct wlan_serialization_command *cmd = NULL;
qdf_list_node_t *nnode = NULL;
qdf_list_t *queue;
struct wlan_serialization_pdev_queue *pdev_queue;
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return NULL;
}
if (is_cmd_from_active_scan_queue)
queue = &ser_pdev_obj->active_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->active_list;
if (wlan_serialization_list_empty(queue, ser_pdev_obj)) {
serialization_err("Empty Queue");
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
queue = &pdev_queue->active_list;
if (wlan_serialization_list_empty(queue)) {
ser_err("Empty Queue");
goto end;
}
if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(queue,
&nnode, ser_pdev_obj)) {
serialization_err("Can't get command from queue");
&nnode)) {
ser_err("Can't get command from queue");
goto end;
}
cmd_list = qdf_container_of(nnode,
struct wlan_serialization_command_list, node);
struct wlan_serialization_command_list, pdev_node);
cmd = &cmd_list->cmd;
serialization_debug("cmd_type[%d], cmd_id[%d]",
cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
ser_debug("cmd_type[%d], cmd_id[%d]",
cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
end:
return cmd;
@ -175,36 +186,40 @@ wlan_serialization_peek_head_pending_cmd_using_psoc(
struct wlan_objmgr_psoc *psoc,
uint8_t is_cmd_from_pending_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
struct wlan_serialization_command_list *cmd_list = NULL;
struct wlan_serialization_command *cmd = NULL;
qdf_list_node_t *nnode = NULL;
qdf_list_t *queue;
struct wlan_serialization_pdev_queue *pdev_queue;
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return NULL;
}
if (is_cmd_from_pending_scan_queue)
queue = &ser_pdev_obj->pending_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->pending_list;
if (wlan_serialization_list_empty(queue, ser_pdev_obj)) {
serialization_err("Empty Queue");
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
queue = &pdev_queue->pending_list;
if (wlan_serialization_list_empty(queue)) {
ser_err("Empty Queue");
goto end;
}
if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(queue,
&nnode, ser_pdev_obj)) {
serialization_err("Can't get command from queue");
if (QDF_STATUS_SUCCESS != wlan_serialization_get_cmd_from_queue(
queue,
&nnode)) {
ser_err("Can't get command from queue");
goto end;
}
cmd_list = qdf_container_of(nnode,
struct wlan_serialization_command_list, node);
struct wlan_serialization_command_list, pdev_node);
cmd = &cmd_list->cmd;
serialization_debug("cmd_type[%d] cmd_id[%d]matched",
cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
ser_debug("cmd_type[%d] cmd_id[%d]matched",
cmd_list->cmd.cmd_type, cmd_list->cmd.cmd_id);
end:
return cmd;
@ -213,7 +228,7 @@ end:
static struct wlan_serialization_command*
wlan_serialization_get_list_next_node(qdf_list_t *queue,
struct wlan_serialization_command *cmd,
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj)
struct wlan_ser_pdev_obj *ser_pdev_obj)
{
struct wlan_serialization_command_list *cmd_list = NULL;
qdf_list_node_t *pnode = NULL, *nnode = NULL;
@ -222,19 +237,17 @@ wlan_serialization_get_list_next_node(qdf_list_t *queue,
QDF_STATUS status;
struct wlan_serialization_command *ret_cmd = NULL;
i = wlan_serialization_list_size(queue, ser_pdev_obj);
i = wlan_serialization_list_size(queue);
if (i == 0) {
serialization_err("Empty Queue");
ser_err("Empty Queue");
return NULL;
}
while (i--) {
if (!cmd_list)
status = wlan_serialization_peek_front(queue, &nnode,
ser_pdev_obj);
status = wlan_serialization_peek_front(queue, &nnode);
else
status = wlan_serialization_peek_next(queue, pnode,
&nnode,
ser_pdev_obj);
&nnode);
if ((status != QDF_STATUS_SUCCESS) || found)
break;
@ -243,26 +256,29 @@ wlan_serialization_get_list_next_node(qdf_list_t *queue,
cmd_list = qdf_container_of(
nnode,
struct wlan_serialization_command_list,
node);
if (wlan_serialization_match_cmd_id_type(nnode, cmd,
ser_pdev_obj) &&
wlan_serialization_match_cmd_vdev(nnode,
cmd->vdev)) {
pdev_node);
if (wlan_serialization_match_cmd_id_type(
nnode, cmd, WLAN_SER_PDEV_NODE) &&
wlan_serialization_match_cmd_vdev(nnode,
cmd->vdev,
WLAN_SER_PDEV_NODE)) {
found = true;
}
nnode = NULL;
}
if (nnode && found) {
cmd_list = qdf_container_of(nnode,
struct wlan_serialization_command_list, node);
cmd_list = qdf_container_of(
nnode,
struct wlan_serialization_command_list,
pdev_node);
ret_cmd = &cmd_list->cmd;
}
if (!found) {
serialization_err("Can't locate next command");
ser_err("Can't locate next command");
return NULL;
}
if (!nnode) {
serialization_debug("next node is empty, so fine");
ser_debug("next node is empty, so fine");
return NULL;
}
@ -275,25 +291,27 @@ wlan_serialization_get_active_list_next_node_using_psoc(
struct wlan_serialization_command *prev_cmd,
uint8_t is_cmd_for_active_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
qdf_list_t *queue;
struct wlan_serialization_pdev_queue *pdev_queue;
if (!prev_cmd) {
serialization_err("invalid prev_cmd");
ser_err("invalid prev_cmd");
return NULL;
}
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return NULL;
}
if (is_cmd_for_active_scan_queue)
queue = &ser_pdev_obj->active_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->active_list;
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
queue = &pdev_queue->active_list;
return wlan_serialization_get_list_next_node(queue, prev_cmd,
ser_pdev_obj);
}
@ -304,24 +322,26 @@ wlan_serialization_get_pending_list_next_node_using_psoc(
struct wlan_serialization_command *prev_cmd,
uint8_t is_cmd_for_pending_scan_queue)
{
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
qdf_list_t *queue;
struct wlan_serialization_pdev_queue *pdev_queue;
if (!prev_cmd) {
serialization_err("invalid prev_cmd");
ser_err("invalid prev_cmd");
return NULL;
}
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("invalid ser_pdev_obj");
ser_err("invalid ser_pdev_obj");
return NULL;
}
if (is_cmd_for_pending_scan_queue)
queue = &ser_pdev_obj->pending_scan_list;
pdev_queue = &ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_SCAN];
else
queue = &ser_pdev_obj->pending_list;
pdev_queue =
&ser_pdev_obj->pdev_q[SER_PDEV_QUEUE_COMP_NON_SCAN];
queue = &pdev_queue->pending_list;
return wlan_serialization_get_list_next_node(queue, prev_cmd,
ser_pdev_obj);
}
@ -332,7 +352,8 @@ void wlan_serialization_legacy_init_callback(void)
wlan_serialization_purge_cmd_list;
}
void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
void wlan_serialization_purge_cmd_list_by_vdev_id(
struct wlan_objmgr_psoc *psoc,
uint8_t vdev_id, bool purge_scan_active_queue,
bool purge_scan_pending_queue,
bool purge_nonscan_active_queue,
@ -344,10 +365,11 @@ void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, vdev_id,
WLAN_SERIALIZATION_ID);
if (!vdev) {
serialization_err("Invalid vdev");
ser_err("Invalid vdev");
return;
}
wlan_serialization_purge_cmd_list(psoc, vdev, purge_scan_active_queue,
wlan_serialization_purge_cmd_list(
psoc, vdev, purge_scan_active_queue,
purge_scan_pending_queue,
purge_nonscan_active_queue,
purge_nonscan_pending_queue,
@ -355,7 +377,8 @@ void wlan_serialization_purge_cmd_list_by_vdev_id(struct wlan_objmgr_psoc *psoc,
wlan_objmgr_vdev_release_ref(vdev, WLAN_SERIALIZATION_ID);
}
void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
void wlan_serialization_purge_cmd_list(
struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *vdev,
bool purge_scan_active_queue,
bool purge_scan_pending_queue,
@ -364,28 +387,28 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
bool purge_all_queues)
{
struct wlan_serialization_timer *ser_timer;
struct wlan_serialization_psoc_priv_obj *psoc_ser_obj;
struct wlan_serialization_pdev_priv_obj *ser_pdev_obj;
struct wlan_ser_psoc_obj *psoc_ser_obj;
struct wlan_ser_pdev_obj *ser_pdev_obj;
struct wlan_objmgr_pdev *pdev = NULL;
uint32_t i = 0;
if (!psoc) {
serialization_err("Invalid psoc");
ser_err("Invalid psoc");
return;
}
ser_pdev_obj = wlan_serialization_get_pdev_priv_obj_using_psoc(psoc);
if (!ser_pdev_obj) {
serialization_err("Invalid ser_pdev_obj");
ser_err("Invalid ser_pdev_obj");
return;
}
psoc_ser_obj = wlan_serialization_get_psoc_priv_obj(psoc);
psoc_ser_obj = wlan_serialization_get_psoc_obj(psoc);
if (!psoc_ser_obj) {
serialization_err("Invalid psoc_ser_obj");
ser_err("Invalid psoc_ser_obj");
return;
}
pdev = wlan_serialization_get_first_pdev(psoc);
if (!pdev) {
serialization_err("Invalid pdev");
ser_err("Invalid pdev");
return;
}
for (i = 0; psoc_ser_obj->max_active_cmds > i; i++) {
@ -400,7 +423,7 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
* de-activate all the timers.
*/
if (!purge_all_queues && purge_scan_active_queue &&
(ser_timer->cmd->cmd_type >= WLAN_SER_CMD_NONSCAN))
(ser_timer->cmd->cmd_type >= WLAN_SER_CMD_NONSCAN))
continue;
/*
* if request is to purge active nonscan then don't de-activate
@ -408,37 +431,49 @@ void wlan_serialization_purge_cmd_list(struct wlan_objmgr_psoc *psoc,
* de-activate all the timers.
*/
if (!purge_all_queues && purge_nonscan_active_queue &&
(ser_timer->cmd->cmd_type < WLAN_SER_CMD_NONSCAN))
(ser_timer->cmd->cmd_type < WLAN_SER_CMD_NONSCAN))
continue;
if (QDF_STATUS_SUCCESS !=
wlan_serialization_find_and_stop_timer(psoc,
wlan_serialization_find_and_stop_timer(
psoc,
ser_timer->cmd))
serialization_err("some error in stopping timer");
ser_err("some error in stopping timer");
}
if (purge_all_queues || purge_scan_active_queue) {
/* sending active queue as pending queue to leverage the API */
wlan_serialization_remove_all_cmd_from_queue(
&ser_pdev_obj->active_scan_list, ser_pdev_obj,
pdev, vdev, NULL, false);
wlan_ser_cancel_scan_cmd(ser_pdev_obj,
pdev,
vdev,
NULL,
WLAN_SER_CMD_SCAN,
true);
}
if (purge_all_queues || purge_scan_pending_queue) {
wlan_serialization_remove_all_cmd_from_queue(
&ser_pdev_obj->pending_scan_list, ser_pdev_obj,
pdev, vdev, NULL, false);
wlan_ser_cancel_scan_cmd(ser_pdev_obj,
pdev,
vdev,
NULL,
WLAN_SER_CMD_SCAN,
false);
}
if (purge_all_queues || purge_nonscan_active_queue) {
/* sending active queue as pending queue to leverage the API */
wlan_serialization_remove_all_cmd_from_queue(
&ser_pdev_obj->active_list, ser_pdev_obj,
pdev, vdev, NULL, false);
wlan_ser_cancel_non_scan_cmd(
ser_pdev_obj,
pdev, vdev,
NULL,
WLAN_SER_CMD_NONSCAN,
true);
}
if (purge_all_queues || purge_nonscan_pending_queue) {
wlan_serialization_remove_all_cmd_from_queue(
&ser_pdev_obj->pending_list, ser_pdev_obj,
pdev, vdev, NULL, false);
wlan_ser_cancel_non_scan_cmd(
ser_pdev_obj,
pdev, vdev,
NULL,
WLAN_SER_CMD_NONSCAN,
false);
}
wlan_objmgr_pdev_release_ref(pdev, WLAN_SERIALIZATION_ID);
return;
}

1
umac/nan/core/src/nan_main.c
View file

@ -226,6 +226,7 @@ QDF_STATUS nan_scheduled_msg_handler(struct scheduler_msg *msg)
cmd.is_high_priority = false;
cmd.cmd_timeout_duration = 30000 /* 30 sec for now. TBD */;
nan_debug("cmd_type: %d", cmd.cmd_type);
cmd.is_blocking = true;
status = wlan_serialization_request(&cmd);
/* following is TBD */

3
umac/tdls/core/src/wlan_tdls_cmds_process.c
View file

@ -825,6 +825,7 @@ QDF_STATUS tdls_process_add_peer(struct tdls_add_peer_request *req)
cmd.is_high_priority = false;
cmd.cmd_timeout_duration = WAIT_TIME_TDLS_ADD_STA;
cmd.vdev = vdev;
cmd.is_blocking = true;
ser_cmd_status = wlan_serialization_request(&cmd);
tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,
@ -1034,6 +1035,7 @@ QDF_STATUS tdls_process_update_peer(struct tdls_update_peer_request *req)
cmd.is_high_priority = false;
cmd.cmd_timeout_duration = WAIT_TIME_TDLS_ADD_STA;
cmd.vdev = req->vdev;
cmd.is_blocking = true;
ser_cmd_status = wlan_serialization_request(&cmd);
tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,
@ -1187,6 +1189,7 @@ QDF_STATUS tdls_process_del_peer(struct tdls_oper_request *req)
cmd.is_high_priority = false;
cmd.cmd_timeout_duration = WAIT_TIME_TDLS_DEL_STA;
cmd.vdev = vdev;
cmd.is_blocking = true;
ser_cmd_status = wlan_serialization_request(&cmd);
tdls_debug("req: 0x%pK wlan_serialization_request status:%d", req,

1
umac/tdls/core/src/wlan_tdls_mgmt.c
View file

@ -403,6 +403,7 @@ QDF_STATUS tdls_process_mgmt_req(
cmd.cmd_timeout_duration = TDLS_DEFAULT_SERIALIZE_CMD_TIMEOUT;
cmd.vdev = tdls_mgmt_req->vdev;
cmd.is_blocking = true;
ser_cmd_status = wlan_serialization_request(&cmd);
tdls_debug("wlan_serialization_request status:%d", ser_cmd_status);