ble_mesh: stack: Rename mesh adv queue and relay queue

components/bt/esp_ble_mesh/mesh_core/adv.c

@@ -27,25 +27,19 @@
 #include "mesh_bearer_adapt.h"
 
 /* Convert from ms to 0.625ms units */
-#define ADV_SCAN_UNIT(_ms) ((_ms) * 8 / 5)
+#define ADV_SCAN_UNIT(_ms)  ((_ms) * 8 / 5)
 /* Convert from 0.625ms units to interval(ms) */
-#define ADV_SCAN_INT(val) ((val) * 5 / 8)
+#define ADV_SCAN_INT(val)   ((val) * 5 / 8)
 
 /* Window and Interval are equal for continuous scanning */
-#define MESH_SCAN_INTERVAL 0x20
-#define MESH_SCAN_WINDOW   0x20
+#define MESH_SCAN_INTERVAL  0x20
+#define MESH_SCAN_WINDOW    0x20
 
 /* Pre-5.0 controllers enforce a minimum interval of 100ms
  * whereas 5.0+ controllers can go down to 20ms.
  */
-#define ADV_INT_DEFAULT_MS 100
-#define ADV_INT_FAST_MS    20
-
-#if defined(CONFIG_BT_HOST_CRYPTO)
-#define ADV_STACK_SIZE 1024
-#else
-#define ADV_STACK_SIZE 768
-#endif
+#define ADV_INT_DEFAULT_MS  100
+#define ADV_INT_FAST_MS     20
 
 static const bt_mesh_addr_t *dev_addr;
 
@@ -62,19 +56,19 @@ NET_BUF_POOL_DEFINE(adv_buf_pool, CONFIG_BLE_MESH_ADV_BUF_COUNT,
 static struct bt_mesh_adv adv_pool[CONFIG_BLE_MESH_ADV_BUF_COUNT];
 
 struct bt_mesh_queue {
-    QueueHandle_t queue;
+    QueueHandle_t handle;
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC
     StaticQueue_t *buffer;
     u8_t *storage;
 #endif
 };
 
-static struct bt_mesh_queue xBleMeshQueue;
-/* We reserve one queue for bt_mesh_adv_update() */
+static struct bt_mesh_queue adv_queue;
+/* We reserve one queue item for bt_mesh_adv_update() */
 #if CONFIG_BLE_MESH_SUPPORT_BLE_ADV
-#define BLE_MESH_QUEUE_SIZE     (CONFIG_BLE_MESH_ADV_BUF_COUNT + CONFIG_BLE_MESH_BLE_ADV_BUF_COUNT + 1)
+#define BLE_MESH_ADV_QUEUE_SIZE     (CONFIG_BLE_MESH_ADV_BUF_COUNT + CONFIG_BLE_MESH_BLE_ADV_BUF_COUNT + 1)
 #else
-#define BLE_MESH_QUEUE_SIZE     (CONFIG_BLE_MESH_ADV_BUF_COUNT + 1)
+#define BLE_MESH_ADV_QUEUE_SIZE     (CONFIG_BLE_MESH_ADV_BUF_COUNT + 1)
 #endif
 
 #if defined(CONFIG_BLE_MESH_RELAY_ADV_BUF)
@@ -83,11 +77,11 @@ NET_BUF_POOL_DEFINE(relay_adv_buf_pool, CONFIG_BLE_MESH_RELAY_ADV_BUF_COUNT,
 
 static struct bt_mesh_adv relay_adv_pool[CONFIG_BLE_MESH_RELAY_ADV_BUF_COUNT];
 
-static struct bt_mesh_queue xBleMeshRelayQueue;
+static struct bt_mesh_queue relay_queue;
 #define BLE_MESH_RELAY_QUEUE_SIZE   CONFIG_BLE_MESH_RELAY_ADV_BUF_COUNT
 
-static QueueSetHandle_t xBleMeshQueueSet;
-#define BLE_MESH_QUEUE_SET_SIZE     (BLE_MESH_QUEUE_SIZE + BLE_MESH_RELAY_QUEUE_SIZE)
+static QueueSetHandle_t mesh_queue_set;
+#define BLE_MESH_QUEUE_SET_SIZE     (BLE_MESH_ADV_QUEUE_SIZE + BLE_MESH_RELAY_QUEUE_SIZE)
 
 #define BLE_MESH_RELAY_TIME_INTERVAL     K_SECONDS(6)
 #define BLE_MESH_MAX_TIME_INTERVAL       0xFFFFFFFF
@@ -260,28 +254,28 @@ static void adv_thread(void *p)
 #if !defined(CONFIG_BLE_MESH_RELAY_ADV_BUF)
 #if (CONFIG_BLE_MESH_NODE && CONFIG_BLE_MESH_PB_GATT) || \
     CONFIG_BLE_MESH_GATT_PROXY_SERVER
-        xQueueReceive(xBleMeshQueue.queue, &msg, K_NO_WAIT);
+        xQueueReceive(adv_queue.handle, &msg, K_NO_WAIT);
         while (!(*buf)) {
             s32_t timeout;
             BT_DBG("Mesh Proxy Advertising start");
             timeout = bt_mesh_proxy_adv_start();
             BT_DBG("Mesh Proxy Advertising up to %d ms", timeout);
-            xQueueReceive(xBleMeshQueue.queue, &msg, timeout);
+            xQueueReceive(adv_queue.handle, &msg, timeout);
             BT_DBG("Mesh Proxy Advertising stop");
             bt_mesh_proxy_adv_stop();
         }
 #else
-        xQueueReceive(xBleMeshQueue.queue, &msg, portMAX_DELAY);
+        xQueueReceive(adv_queue.handle, &msg, portMAX_DELAY);
 #endif /* (CONFIG_BLE_MESH_NODE && CONFIG_BLE_MESH_PB_GATT) || CONFIG_BLE_MESH_GATT_PROXY_SERVER */
 #else /* !defined(CONFIG_BLE_MESH_RELAY_ADV_BUF) */
 #if (CONFIG_BLE_MESH_NODE && CONFIG_BLE_MESH_PB_GATT) || \
     CONFIG_BLE_MESH_GATT_PROXY_SERVER
-        handle = xQueueSelectFromSet(xBleMeshQueueSet, K_NO_WAIT);
+        handle = xQueueSelectFromSet(mesh_queue_set, K_NO_WAIT);
         if (handle) {
-            if (uxQueueMessagesWaiting(xBleMeshQueue.queue)) {
-                xQueueReceive(xBleMeshQueue.queue, &msg, K_NO_WAIT);
-            } else if (uxQueueMessagesWaiting(xBleMeshRelayQueue.queue)) {
-                xQueueReceive(xBleMeshRelayQueue.queue, &msg, K_NO_WAIT);
+            if (uxQueueMessagesWaiting(adv_queue.handle)) {
+                xQueueReceive(adv_queue.handle, &msg, K_NO_WAIT);
+            } else if (uxQueueMessagesWaiting(relay_queue.handle)) {
+                xQueueReceive(relay_queue.handle, &msg, K_NO_WAIT);
             }
         } else {
             while (!(*buf)) {
@@ -289,25 +283,25 @@ static void adv_thread(void *p)
                 BT_DBG("Mesh Proxy Advertising start");
                 timeout = bt_mesh_proxy_adv_start();
                 BT_DBG("Mesh Proxy Advertising up to %d ms", timeout);
-                handle = xQueueSelectFromSet(xBleMeshQueueSet, timeout);
+                handle = xQueueSelectFromSet(mesh_queue_set, timeout);
                 BT_DBG("Mesh Proxy Advertising stop");
                 bt_mesh_proxy_adv_stop();
                 if (handle) {
-                    if (uxQueueMessagesWaiting(xBleMeshQueue.queue)) {
-                        xQueueReceive(xBleMeshQueue.queue, &msg, K_NO_WAIT);
-                    } else if (uxQueueMessagesWaiting(xBleMeshRelayQueue.queue)) {
-                        xQueueReceive(xBleMeshRelayQueue.queue, &msg, K_NO_WAIT);
+                    if (uxQueueMessagesWaiting(adv_queue.handle)) {
+                        xQueueReceive(adv_queue.handle, &msg, K_NO_WAIT);
+                    } else if (uxQueueMessagesWaiting(relay_queue.handle)) {
+                        xQueueReceive(relay_queue.handle, &msg, K_NO_WAIT);
                     }
                 }
             }
         }
 #else
-        handle = xQueueSelectFromSet(xBleMeshQueueSet, portMAX_DELAY);
+        handle = xQueueSelectFromSet(mesh_queue_set, portMAX_DELAY);
         if (handle) {
-            if (uxQueueMessagesWaiting(xBleMeshQueue.queue)) {
-                xQueueReceive(xBleMeshQueue.queue, &msg, K_NO_WAIT);
-            } else if (uxQueueMessagesWaiting(xBleMeshRelayQueue.queue)) {
-                xQueueReceive(xBleMeshRelayQueue.queue, &msg, K_NO_WAIT);
+            if (uxQueueMessagesWaiting(adv_queue.handle)) {
+                xQueueReceive(adv_queue.handle, &msg, K_NO_WAIT);
+            } else if (uxQueueMessagesWaiting(relay_queue.handle)) {
+                xQueueReceive(relay_queue.handle, &msg, K_NO_WAIT);
             }
         }
 #endif /* (CONFIG_BLE_MESH_NODE && CONFIG_BLE_MESH_PB_GATT) || CONFIG_BLE_MESH_GATT_PROXY_SERVER */
@@ -448,18 +442,18 @@ static void bt_mesh_task_post(bt_mesh_msg_t *msg, uint32_t timeout, bool front)
 {
     BT_DBG("%s", __func__);
 
-    if (xBleMeshQueue.queue == NULL) {
+    if (adv_queue.handle == NULL) {
         BT_ERR("%s, Invalid queue", __func__);
         return;
     }
 
     if (front) {
-        if (xQueueSendToFront(xBleMeshQueue.queue, msg, timeout) != pdTRUE) {
+        if (xQueueSendToFront(adv_queue.handle, msg, timeout) != pdTRUE) {
             BT_ERR("%s, Failed to send item to queue front", __func__);
             bt_mesh_unref_buf(msg);
         }
     } else {
-        if (xQueueSend(xBleMeshQueue.queue, msg, timeout) != pdTRUE) {
+        if (xQueueSend(adv_queue.handle, msg, timeout) != pdTRUE) {
             BT_ERR("%s, Failed to send item to queue back", __func__);
             bt_mesh_unref_buf(msg);
         }
@@ -532,12 +526,12 @@ static void ble_mesh_relay_task_post(bt_mesh_msg_t *msg, uint32_t timeout)
 
     BT_DBG("%s", __func__);
 
-    if (xBleMeshRelayQueue.queue == NULL) {
+    if (relay_queue.handle == NULL) {
         BT_ERR("%s, Invalid relay queue", __func__);
         return;
     }
 
-    if (xQueueSend(xBleMeshRelayQueue.queue, msg, timeout) == pdTRUE) {
+    if (xQueueSend(relay_queue.handle, msg, timeout) == pdTRUE) {
         return;
     }
 
@@ -545,11 +539,11 @@ static void ble_mesh_relay_task_post(bt_mesh_msg_t *msg, uint32_t timeout)
      * If failed to send packet to the relay queue(queue is full), we will
      * remove the oldest packet in the queue and put the new one into it.
      */
-    handle = xQueueSelectFromSet(xBleMeshQueueSet, K_NO_WAIT);
-    if (handle && uxQueueMessagesWaiting(xBleMeshRelayQueue.queue)) {
+    handle = xQueueSelectFromSet(mesh_queue_set, K_NO_WAIT);
+    if (handle && uxQueueMessagesWaiting(relay_queue.handle)) {
         BT_INFO("%s, Full queue, remove the oldest relay packet", __func__);
         /* Remove the oldest relay packet from queue */
-        if (xQueueReceive(xBleMeshRelayQueue.queue, &old_msg, K_NO_WAIT) != pdTRUE) {
+        if (xQueueReceive(relay_queue.handle, &old_msg, K_NO_WAIT) != pdTRUE) {
             BT_ERR("%s, Failed to remove item from queue", __func__);
             bt_mesh_unref_buf(msg);
             return;
@@ -557,7 +551,7 @@ static void ble_mesh_relay_task_post(bt_mesh_msg_t *msg, uint32_t timeout)
         /* Unref buf used for the oldest relay packet */
         bt_mesh_unref_buf(&old_msg);
         /* Send the latest relay packet to queue */
-        if (xQueueSend(xBleMeshRelayQueue.queue, msg, K_NO_WAIT) != pdTRUE) {
+        if (xQueueSend(relay_queue.handle, msg, K_NO_WAIT) != pdTRUE) {
             BT_ERR("%s, Failed to send item to relay queue", __func__);
             bt_mesh_unref_buf(msg);
             return;
@@ -586,13 +580,13 @@ void bt_mesh_relay_adv_send(struct net_buf *buf, const struct bt_mesh_send_cb *c
     msg.src = src;
     msg.dst = dst;
     msg.timestamp = k_uptime_get_32();
-    /* Use K_NO_WAIT here, if xBleMeshRelayQueue is full return immediately */
+    /* Use K_NO_WAIT here, if relay_queue is full return immediately */
     ble_mesh_relay_task_post(&msg, K_NO_WAIT);
 }
 
 u16_t bt_mesh_get_stored_relay_count(void)
 {
-    return (u16_t)uxQueueMessagesWaiting(xBleMeshRelayQueue.queue);
+    return (u16_t)uxQueueMessagesWaiting(relay_queue.handle);
 }
 #endif /* #if defined(CONFIG_BLE_MESH_RELAY_ADV_BUF) */
 
@@ -798,50 +792,50 @@ static void bt_mesh_scan_cb(const bt_mesh_addr_t *addr, s8_t rssi,
 void bt_mesh_adv_init(void)
 {
 #if !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC
-    xBleMeshQueue.queue = xQueueCreate(BLE_MESH_QUEUE_SIZE, sizeof(bt_mesh_msg_t));
-    __ASSERT(xBleMeshQueue.queue, "Failed to create queue");
+    adv_queue.handle = xQueueCreate(BLE_MESH_ADV_QUEUE_SIZE, sizeof(bt_mesh_msg_t));
+    __ASSERT(adv_queue.handle, "Failed to create queue");
 #else /* !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC */
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_EXTERNAL
-    xBleMeshQueue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    adv_queue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #elif CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_IRAM_8BIT
-    xBleMeshQueue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    adv_queue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #endif
-    __ASSERT(xBleMeshQueue.buffer, "Failed to create queue buffer");
+    __ASSERT(adv_queue.buffer, "Failed to create queue buffer");
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_EXTERNAL
-    xBleMeshQueue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    adv_queue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_ADV_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #elif CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_IRAM_8BIT
-    xBleMeshQueue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    adv_queue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_ADV_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #endif
-    __ASSERT(xBleMeshQueue.storage, "Failed to create queue storage");
-    xBleMeshQueue.queue = xQueueCreateStatic(BLE_MESH_QUEUE_SIZE, sizeof(bt_mesh_msg_t), (uint8_t*)xBleMeshQueue.storage, xBleMeshQueue.buffer);
-    __ASSERT(xBleMeshQueue.queue, "Failed to create static queue");
+    __ASSERT(adv_queue.storage, "Failed to create queue storage");
+    adv_queue.handle = xQueueCreateStatic(BLE_MESH_ADV_QUEUE_SIZE, sizeof(bt_mesh_msg_t), (uint8_t*)adv_queue.storage, adv_queue.buffer);
+    __ASSERT(adv_queue.handle, "Failed to create static queue");
 #endif /* !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC */
 
 #if defined(CONFIG_BLE_MESH_RELAY_ADV_BUF)
 #if !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC
-    xBleMeshRelayQueue.queue = xQueueCreate(BLE_MESH_RELAY_QUEUE_SIZE, sizeof(bt_mesh_msg_t));
-    __ASSERT(xBleMeshRelayQueue.queue, "Failed to create relay queue");
+    relay_queue.handle = xQueueCreate(BLE_MESH_RELAY_QUEUE_SIZE, sizeof(bt_mesh_msg_t));
+    __ASSERT(relay_queue.handle, "Failed to create relay queue");
 #else /* !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC */
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_EXTERNAL
-    xBleMeshRelayQueue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    relay_queue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #elif CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_IRAM_8BIT
-    xBleMeshRelayQueue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    relay_queue.buffer = heap_caps_calloc_prefer(1, sizeof(StaticQueue_t), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #endif
-    __ASSERT(xBleMeshRelayQueue.buffer, "Failed to create relay queue buffer");
+    __ASSERT(relay_queue.buffer, "Failed to create relay queue buffer");
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_EXTERNAL
-    xBleMeshRelayQueue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_RELAY_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    relay_queue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_RELAY_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #elif CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_IRAM_8BIT
-    xBleMeshRelayQueue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_RELAY_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
+    relay_queue.storage = heap_caps_calloc_prefer(1, (BLE_MESH_RELAY_QUEUE_SIZE * sizeof(bt_mesh_msg_t)), 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 #endif
-    __ASSERT(xBleMeshRelayQueue.storage, "Failed to create relay queue storage");
-    xBleMeshRelayQueue.queue = xQueueCreateStatic(BLE_MESH_RELAY_QUEUE_SIZE, sizeof(bt_mesh_msg_t), (uint8_t*)xBleMeshRelayQueue.storage, xBleMeshRelayQueue.buffer);
-    __ASSERT(xBleMeshRelayQueue.queue, "Failed to create static relay queue");
+    __ASSERT(relay_queue.storage, "Failed to create relay queue storage");
+    relay_queue.handle = xQueueCreateStatic(BLE_MESH_RELAY_QUEUE_SIZE, sizeof(bt_mesh_msg_t), (uint8_t*)relay_queue.storage, relay_queue.buffer);
+    __ASSERT(relay_queue.handle, "Failed to create static relay queue");
 #endif /* !CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC */
 
-    xBleMeshQueueSet = xQueueCreateSet(BLE_MESH_QUEUE_SET_SIZE);
-    __ASSERT(xBleMeshQueueSet, "Failed to create queue set");
-    xQueueAddToSet(xBleMeshQueue.queue, xBleMeshQueueSet);
-    xQueueAddToSet(xBleMeshRelayQueue.queue, xBleMeshQueueSet);
+    mesh_queue_set = xQueueCreateSet(BLE_MESH_QUEUE_SET_SIZE);
+    __ASSERT(mesh_queue_set, "Failed to create queue set");
+    xQueueAddToSet(adv_queue.handle, mesh_queue_set);
+    xQueueAddToSet(relay_queue.handle, mesh_queue_set);
 #endif /* defined(CONFIG_BLE_MESH_RELAY_ADV_BUF) */
 
 #if (CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC_EXTERNAL && \
@@ -863,7 +857,7 @@ void bt_mesh_adv_init(void)
 
 void bt_mesh_adv_deinit(void)
 {
-    if (xBleMeshQueue.queue == NULL) {
+    if (adv_queue.handle == NULL) {
         return;
     }
 
@@ -879,32 +873,32 @@ void bt_mesh_adv_deinit(void)
 #endif
 
 #if defined(CONFIG_BLE_MESH_RELAY_ADV_BUF)
-    xQueueRemoveFromSet(xBleMeshQueue.queue, xBleMeshQueueSet);
-    xQueueRemoveFromSet(xBleMeshRelayQueue.queue, xBleMeshQueueSet);
+    xQueueRemoveFromSet(adv_queue.handle, mesh_queue_set);
+    xQueueRemoveFromSet(relay_queue.handle, mesh_queue_set);
 
-    vQueueDelete(xBleMeshRelayQueue.queue);
-    xBleMeshRelayQueue.queue = NULL;
+    vQueueDelete(relay_queue.handle);
+    relay_queue.handle = NULL;
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC
-    heap_caps_free(xBleMeshRelayQueue.buffer);
-    xBleMeshRelayQueue.buffer = NULL;
-    heap_caps_free(xBleMeshRelayQueue.storage);
-    xBleMeshRelayQueue.storage = NULL;
+    heap_caps_free(relay_queue.buffer);
+    relay_queue.buffer = NULL;
+    heap_caps_free(relay_queue.storage);
+    relay_queue.storage = NULL;
 #endif
 
     bt_mesh_unref_buf_from_pool(&relay_adv_buf_pool);
     memset(relay_adv_pool, 0, sizeof(relay_adv_pool));
 
-    vQueueDelete(xBleMeshQueueSet);
-    xBleMeshQueueSet = NULL;
+    vQueueDelete(mesh_queue_set);
+    mesh_queue_set = NULL;
 #endif /* defined(CONFIG_BLE_MESH_RELAY_ADV_BUF) */
 
-    vQueueDelete(xBleMeshQueue.queue);
-    xBleMeshQueue.queue = NULL;
+    vQueueDelete(adv_queue.handle);
+    adv_queue.handle = NULL;
 #if CONFIG_BLE_MESH_FREERTOS_STATIC_ALLOC
-    heap_caps_free(xBleMeshQueue.buffer);
-    xBleMeshQueue.buffer = NULL;
-    heap_caps_free(xBleMeshQueue.storage);
-    xBleMeshQueue.storage = NULL;
+    heap_caps_free(adv_queue.buffer);
+    adv_queue.buffer = NULL;
+    heap_caps_free(adv_queue.storage);
+    adv_queue.storage = NULL;
 #endif
 
     bt_mesh_unref_buf_from_pool(&adv_buf_pool);