Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 263cec16 authored by Madan Mohan Koyyalamudi's avatar Madan Mohan Koyyalamudi
Browse files

TDLS: Move tdls_lock to HDD Context 

Concurrent access to the data structures betweeen the TDLS
and other modules require an access to mutex lock.Hence move the
tdls_lock to the HDD context which is currently accessed only
by the tdls module.

Change-Id: Ia38d8117d9e8cd2f60bbec08e618af398e897afd
CRs-fixed: 553670
parent 3112353e

CORE/HDD/inc/wlan_hdd_main.h

+2 −0
Original line number Diff line number Diff line
@@ -1108,6 +1108,8 @@ struct hdd_context_s 
    /* TDLS peer connected count */

    tANI_U16 connected_peer_count;

    tdls_scan_context_t tdls_scan_ctxt;

   /* Lock to avoid race condition during TDLS operations*/

   struct mutex tdls_lock;

#endif



    hdd_traffic_monitor_t traffic_monitor;

CORE/HDD/src/wlan_hdd_main.c

+3 −0
Original line number Diff line number Diff line
@@ -7161,6 +7161,9 @@ int hdd_wlan_startup(struct device *dev ) 
   }



   mutex_init(&pHddCtx->sap_lock);

#ifdef FEATURE_WLAN_TDLS

   mutex_init(&pHddCtx->tdls_lock);

#endif



   pHddCtx->isLoadUnloadInProgress = FALSE;

CORE/HDD/src/wlan_hdd_tdls.c

+131 −109
Original line number Diff line number Diff line
@@ -39,7 +39,6 @@ 
#include "wlan_hdd_cfg80211.h"





static struct mutex tdls_lock;

static tANI_S32 wlan_hdd_get_tdls_discovery_peer_cnt(tdlsCtx_t *pHddTdlsCtx);

static tANI_S32 wlan_hdd_tdls_peer_reset_discovery_processed(tdlsCtx_t *pHddTdlsCtx);

static void wlan_hdd_tdls_timers_destroy(tdlsCtx_t *pHddTdlsCtx);
@@ -85,29 +84,28 @@ static v_VOID_t wlan_hdd_tdls_start_peer_discover_timer(tdlsCtx_t *pHddTdlsCtx, 
                                                        v_U32_t discoveryExpiry)

{

    hdd_station_ctx_t *pHddStaCtx;

    hdd_context_t *pHddCtx;



    if ((NULL == pHddTdlsCtx))

        return;



    if ((NULL == pHddTdlsCtx->pAdapter) )

        return;



    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return;



    if ( mutexLock )

    {

        if (mutex_lock_interruptible(&tdls_lock))

        if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

        {

           VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                     "%s: unable to lock list: %d", __func__, __LINE__);

           return;

        }

    }

    if (NULL == pHddTdlsCtx)

    {

        if ( mutexLock )

            mutex_unlock(&tdls_lock);

        return;

    }



    if (NULL == pHddTdlsCtx->pAdapter)

    {

        if ( mutexLock )

            mutex_unlock(&tdls_lock);

        return;

    }



    pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pHddTdlsCtx->pAdapter);

#ifdef FEATURE_WLAN_TDLS_INTERNAL
@@ -119,7 +117,7 @@ static v_VOID_t wlan_hdd_tdls_start_peer_discover_timer(tdlsCtx_t *pHddTdlsCtx, 
               pHddTdlsCtx->ap_rssi);



    if ( mutexLock )

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);



    return;

}
@@ -132,27 +130,28 @@ static v_VOID_t wlan_hdd_tdls_discover_peer_cb( v_PVOID_t userData ) 
    struct list_head *pos;

    hddTdlsPeer_t *curr_peer;

    hdd_station_ctx_t *pHddStaCtx;

    hdd_context_t *pHddCtx;

    tdlsCtx_t *pHddTdlsCtx = (tdlsCtx_t *)userData;

    int discover_req_sent = 0;

    v_U32_t discover_expiry = TDLS_SUB_DISCOVERY_PERIOD;

    tANI_BOOLEAN doMutexLock = eANI_BOOLEAN_TRUE;



    if (mutex_lock_interruptible(&tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list : %d", __func__, __LINE__);

    if ((NULL == pHddTdlsCtx))

        return;

    }



    if (NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

    if (NULL == pHddTdlsCtx->pAdapter)

        return;

    }



    if (NULL == pHddTdlsCtx->pAdapter)

    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return;





    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

        mutex_unlock(&tdls_lock);

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list : %d", __func__, __LINE__);

       return;

    }
@@ -228,7 +227,7 @@ static v_VOID_t wlan_hdd_tdls_discover_peer_cb( v_PVOID_t userData ) 


    wlan_hdd_tdls_peer_reset_discovery_processed(pHddTdlsCtx);



    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);



    /* Commenting out the following function as it was introducing

     * a race condition when pHddTdlsCtx is deleted. Also , this
@@ -244,7 +243,7 @@ static v_VOID_t wlan_hdd_tdls_discover_peer_cb( v_PVOID_t userData ) 
    wlan_hdd_tdls_start_peer_discover_timer(pHddTdlsCtx, doMutexLock, discover_expiry);



    if ( !doMutexLock )

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

    return;

}

#endif
@@ -255,24 +254,24 @@ static v_VOID_t wlan_hdd_tdls_update_peer_cb( v_PVOID_t userData ) 
    struct list_head *head;

    struct list_head *pos;

    hddTdlsPeer_t *curr_peer;

    tdlsCtx_t *pHddTdlsCtx;

    tdlsCtx_t *pHddTdlsCtx = (tdlsCtx_t *)userData;

    hdd_context_t *pHddCtx;



    if (mutex_lock_interruptible(&tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

       return;

    }

    pHddTdlsCtx = (tdlsCtx_t *)userData;

    if (NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

    if ((NULL == pHddTdlsCtx))

        return;

    }



    if (NULL == pHddTdlsCtx->pAdapter)

        return;



    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return;



    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

        mutex_unlock(&tdls_lock);

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

       return;

    }
@@ -401,13 +400,15 @@ static v_VOID_t wlan_hdd_tdls_update_peer_cb( v_PVOID_t userData ) 
    wlan_hdd_tdls_timer_restart(pHddTdlsCtx->pAdapter,

                                &pHddTdlsCtx->peerUpdateTimer,

                                pHddTdlsCtx->threshold_config.tx_period_t);

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

}



static v_VOID_t wlan_hdd_tdls_idle_cb( v_PVOID_t userData )

{

#ifdef CONFIG_TDLS_IMPLICIT

    hddTdlsPeer_t *curr_peer = (hddTdlsPeer_t *)userData;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx;



    if (NULL == curr_peer)

    {
@@ -415,6 +416,16 @@ static v_VOID_t wlan_hdd_tdls_idle_cb( v_PVOID_t userData ) 
               "%s: Invalid tdls idle timer expired", __func__);

      return;

    }

    pHddTdlsCtx = curr_peer->pHddTdlsCtx;



    if ((NULL == pHddTdlsCtx) || (NULL == pHddTdlsCtx->pAdapter) )

        return;



    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return;





    VOS_TRACE(VOS_MODULE_ID_HDD, TDLS_LOG_LEVEL,

              "%s: Tx/Rx Idle " MAC_ADDRESS_STR " tx_pkt: %d, rx_pkt: %d, idle_packet_n: %d\n",
@@ -423,7 +434,7 @@ static v_VOID_t wlan_hdd_tdls_idle_cb( v_PVOID_t userData ) 
              curr_peer->rx_pkt,

              curr_peer->pHddTdlsCtx->threshold_config.idle_packet_n);



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);
@@ -451,7 +462,7 @@ static v_VOID_t wlan_hdd_tdls_idle_cb( v_PVOID_t userData ) 
                                      curr_peer,

                                      eSIR_MAC_TDLS_TEARDOWN_UNSPEC_REASON);

    }

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

#endif

}
@@ -462,18 +473,22 @@ static v_VOID_t wlan_hdd_tdls_discovery_timeout_peer_cb(v_PVOID_t userData) 
    hddTdlsPeer_t *tmp;

    struct list_head *pos, *q;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx;



    if (mutex_lock_interruptible(&tdls_lock))

    {

        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                  "%s: unable to lock list", __func__);

        return ;

    }

    pHddTdlsCtx = (tdlsCtx_t *)userData;



    if ( NULL == pHddTdlsCtx )

    if ((NULL == pHddTdlsCtx) || (NULL == pHddTdlsCtx->pAdapter) )

        return;



    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return;



    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

        mutex_unlock(&tdls_lock);

        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                  "%s: unable to lock list", __func__);

        return ;

    }
@@ -494,7 +509,7 @@ static v_VOID_t wlan_hdd_tdls_discovery_timeout_peer_cb(v_PVOID_t userData) 
    pHddTdlsCtx->discovery_sent_cnt = 0;

    wlan_hdd_tdls_check_power_save_prohibited(pHddTdlsCtx->pAdapter);



    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);



    wlan_hdd_tdls_check_bmps(pHddTdlsCtx->pAdapter);
@@ -545,8 +560,6 @@ int wlan_hdd_tdls_init(hdd_adapter_t *pAdapter) 
    int i;

    v_U8_t staIdx;



    mutex_init(&tdls_lock);



    if ((FALSE == pHddCtx->cfg_ini->fEnableTDLSSupport) ||

        (FALSE == sme_IsFeatureSupportedByFW(TDLS)))

    {
@@ -665,24 +678,23 @@ void wlan_hdd_tdls_exit(hdd_adapter_t *pAdapter) 
    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx;



    if (mutex_lock_interruptible(&tdls_lock))

    pHddCtx = WLAN_HDD_GET_CTX( pAdapter );

    if (NULL == pHddCtx)

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

        return;

    }



    pHddCtx = WLAN_HDD_GET_CTX( pAdapter );

    if (NULL == pHddCtx)

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

        mutex_unlock(&tdls_lock);

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

       return;

    }



    pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    if (NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        hddLog(VOS_TRACE_LEVEL_WARN, "%s TDLS not enabled, exiting!", __func__);

        return;

    }
@@ -696,7 +708,7 @@ void wlan_hdd_tdls_exit(hdd_adapter_t *pAdapter) 


    vos_mem_free(pHddTdlsCtx);

    pHddTdlsCtx = NULL;

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

}



/* stop all monitoring timers per Adapter */
@@ -793,6 +805,9 @@ hddTdlsPeer_t *wlan_hdd_tdls_get_peer(hdd_adapter_t *pAdapter, u8 *mac) 
    hddTdlsPeer_t *peer;

    u8 key;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);



    if ((NULL == pHddCtx)) return NULL;



    /* if already there, just update */

    peer = wlan_hdd_tdls_find_peer(pAdapter, mac);
@@ -808,7 +823,7 @@ hddTdlsPeer_t *wlan_hdd_tdls_get_peer(hdd_adapter_t *pAdapter, u8 *mac) 
        return NULL;

    }



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);
@@ -820,7 +835,7 @@ hddTdlsPeer_t *wlan_hdd_tdls_get_peer(hdd_adapter_t *pAdapter, u8 *mac) 
    if (NULL == pHddTdlsCtx)

    {

        vos_mem_free(peer);

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        return NULL;

    }
@@ -842,7 +857,7 @@ hddTdlsPeer_t *wlan_hdd_tdls_get_peer(hdd_adapter_t *pAdapter, u8 *mac) 
                    peer);



    list_add_tail(&peer->node, head);

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);



    return peer;

}
@@ -1205,9 +1220,11 @@ hddTdlsPeer_t *wlan_hdd_tdls_find_peer(hdd_adapter_t *pAdapter, u8 *mac) 
    struct list_head *head;

    hddTdlsPeer_t *curr_peer;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);



    if ((NULL == pHddCtx)) return NULL;



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);
@@ -1216,7 +1233,7 @@ hddTdlsPeer_t *wlan_hdd_tdls_find_peer(hdd_adapter_t *pAdapter, u8 *mac) 
    pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    if (NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        return NULL;

    }
@@ -1229,12 +1246,12 @@ hddTdlsPeer_t *wlan_hdd_tdls_find_peer(hdd_adapter_t *pAdapter, u8 *mac) 
        if (!memcmp(mac, curr_peer->peerMac, 6)) {

            VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,

                     "findTdlsPeer: found staId %d", curr_peer->staId);

            mutex_unlock(&tdls_lock);

            mutex_unlock(&pHddCtx->tdls_lock);

            return curr_peer;

        }

    }



    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

    return NULL;

}
@@ -1369,6 +1386,12 @@ int wlan_hdd_tdls_get_all_peers(hdd_adapter_t *pAdapter, char *buf, int buflen) 
    struct list_head *pos;

    hddTdlsPeer_t *curr_peer;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);



    if ((NULL == pHddCtx)) {

        len = snprintf(buf, buflen, "NULL HddCtx\n");

        return len;

    }





    init_len = buflen;
@@ -1381,7 +1404,7 @@ int wlan_hdd_tdls_get_all_peers(hdd_adapter_t *pAdapter, char *buf, int buflen) 
    buf += len;

    buflen -= len;



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);
@@ -1389,7 +1412,7 @@ int wlan_hdd_tdls_get_all_peers(hdd_adapter_t *pAdapter, char *buf, int buflen) 
    }

    pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    if (NULL == pHddTdlsCtx) {

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        len = scnprintf(buf, buflen, "TDLS not enabled\n");

        return len;

    }
@@ -1412,28 +1435,24 @@ int wlan_hdd_tdls_get_all_peers(hdd_adapter_t *pAdapter, char *buf, int buflen) 
            buflen -= len;

        }

    }

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

    return init_len-buflen;

}



void wlan_hdd_tdls_connection_callback(hdd_adapter_t *pAdapter)

{

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX( pAdapter );

    tdlsCtx_t *pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);



    if ((NULL == pHddCtx) || (NULL == pHddTdlsCtx)) return;



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

       return;

    }



    if (NULL == pHddCtx || NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

        return;

    }



    VOS_TRACE( VOS_MODULE_ID_HDD, TDLS_LOG_LEVEL,

    "%s, update %d discover %d", __func__,

        pHddTdlsCtx->threshold_config.tx_period_t,
@@ -1454,17 +1473,20 @@ void wlan_hdd_tdls_connection_callback(hdd_adapter_t *pAdapter) 
                                   &pHddTdlsCtx->peerUpdateTimer,

                                   pHddTdlsCtx->threshold_config.tx_period_t);

    }

    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);



}



void wlan_hdd_tdls_disconnection_callback(hdd_adapter_t *pAdapter)

{

    tdlsCtx_t *pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);



    if ((NULL == pHddCtx) || (NULL == pHddTdlsCtx)) return;



    VOS_TRACE( VOS_MODULE_ID_HDD, TDLS_LOG_LEVEL,"%s", __func__);



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);
@@ -1472,7 +1494,7 @@ void wlan_hdd_tdls_disconnection_callback(hdd_adapter_t *pAdapter) 
    }

    if (NULL == pHddTdlsCtx)

    {

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        return;

    }

    pHddTdlsCtx->discovery_sent_cnt = 0;
@@ -1482,7 +1504,7 @@ void wlan_hdd_tdls_disconnection_callback(hdd_adapter_t *pAdapter) 
    wlan_hdd_tdls_peer_timers_destroy(pHddTdlsCtx);

    wlan_hdd_tdls_free_list(pHddTdlsCtx);



    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

}



void wlan_hdd_tdls_mgmt_completion_callback(hdd_adapter_t *pAdapter, tANI_U32 statusCode)
@@ -1585,23 +1607,26 @@ static hddTdlsPeer_t *wlan_hdd_tdls_find_progress_peer(hdd_adapter_t *pAdapter, 
    hddTdlsPeer_t *curr_peer;

    struct list_head *pos;

    tdlsCtx_t *pHddTdlsCtx;

    hdd_context_t *pHddCtx;



    pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    if (NULL == pHddTdlsCtx)

        return NULL;



    pHddCtx = WLAN_HDD_GET_CTX( pHddTdlsCtx->pAdapter );



    if (NULL == pHddCtx)

        return NULL;



    if (mutexLock)

    {

        if (mutex_lock_interruptible(&tdls_lock))

        if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

        {

           VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

           return NULL;

        }

    }

    pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);

    if (NULL == pHddTdlsCtx)

    {

        if (mutexLock)

            mutex_unlock(&tdls_lock);

        return NULL;

    }



    for (i = 0; i < 256; i++) {

        head = &pHddTdlsCtx->peer_list[i];
@@ -1618,7 +1643,7 @@ static hddTdlsPeer_t *wlan_hdd_tdls_find_progress_peer(hdd_adapter_t *pAdapter, 
                            "%s:" MAC_ADDRESS_STR " eTDLS_LINK_CONNECTING",

                            __func__, MAC_ADDR_ARRAY(curr_peer->peerMac));

                  if (mutexLock)

                      mutex_unlock(&tdls_lock);

                      mutex_unlock(&pHddCtx->tdls_lock);

                  return curr_peer;

                }

            }
@@ -1626,7 +1651,7 @@ static hddTdlsPeer_t *wlan_hdd_tdls_find_progress_peer(hdd_adapter_t *pAdapter, 
    }



    if (mutexLock)

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

    return NULL;

}
@@ -1689,24 +1714,21 @@ void wlan_hdd_tdls_set_mode(hdd_context_t *pHddCtx, 
    tdlsCtx_t *pHddTdlsCtx;



    VOS_TRACE( VOS_MODULE_ID_HDD, TDLS_LOG_LEVEL,"%s mode %d", __func__, (int)tdls_mode);

    if (NULL == pHddCtx)

        return;



    if (mutex_lock_interruptible(&tdls_lock))

    if (mutex_lock_interruptible(&pHddCtx->tdls_lock))

    {

       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,

                 "%s: unable to lock list", __func__);

       return;

    }



    if (NULL == pHddCtx)

    {

        mutex_unlock(&tdls_lock);

        return;

    }



    if (pHddCtx->tdls_mode == tdls_mode)

    {

        hddLog(TDLS_LOG_LEVEL, "%s already in mode %d", __func__, (int)tdls_mode);

        mutex_unlock(&tdls_lock);

        mutex_unlock(&pHddCtx->tdls_lock);

        return;

    }
@@ -1737,7 +1759,7 @@ void wlan_hdd_tdls_set_mode(hdd_context_t *pHddCtx, 
    }

    pHddCtx->tdls_mode = tdls_mode;



    mutex_unlock(&tdls_lock);

    mutex_unlock(&pHddCtx->tdls_lock);

}



static void wlan_hdd_tdls_pre_setup(struct work_struct *work)