ble_mesh: Spit mesh_util.h into different header files

Split mesh_util.h into mesh_byteorder.h, mesh_compiler.h,
mesh_ffs.h and mesh_util.h based on the classification of
Zephyr, which will make further porting more clear.

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_common_api.c

@@ -17,8 +17,6 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_local_data_operation_api.c

@@ -14,8 +14,6 @@
 
 #include <stdint.h>
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_low_power_api.c

@@ -14,8 +14,6 @@
 
 #include <stdint.h>
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_networking_api.c

@@ -15,8 +15,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_provisioning_api.c

@@ -15,8 +15,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/api/core/esp_ble_mesh_proxy_api.c

@@ -15,8 +15,6 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "btc/btc_manage.h"
-
 #include "esp_err.h"
 
 #include "btc_ble_mesh_prov.h"

components/bt/esp_ble_mesh/btc/btc_ble_mesh_config_model.c

@@ -15,11 +15,9 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_config_model.h"
 #include "foundation.h"
-#include "mesh_common.h"
 #include "cfg_cli.h"
-
-#include "btc_ble_mesh_config_model.h"
 #include "esp_ble_mesh_config_model_api.h"
 
 #define CID_NVAL 0xffff

components/bt/esp_ble_mesh/btc/btc_ble_mesh_generic_model.c

@@ -15,10 +15,8 @@
 #include <string.h>
 #include <errno.h>
 
-#include "mesh_common.h"
-#include "generic_client.h"
-
 #include "btc_ble_mesh_generic_model.h"
+#include "generic_client.h"
 #include "esp_ble_mesh_generic_model_api.h"
 
 /* Generic Client Models related functions */

components/bt/esp_ble_mesh/btc/btc_ble_mesh_health_model.c

@@ -15,13 +15,11 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_health_model.h"
 #include "foundation.h"
-#include "mesh_common.h"
 #include "health_srv.h"
 #include "health_cli.h"
-
-#include "btc_ble_mesh_health_model.h"
-#include "esp_ble_mesh_defs.h"
+#include "esp_ble_mesh_health_model_api.h"
 
 extern s32_t health_msg_timeout;
 

components/bt/esp_ble_mesh/btc/btc_ble_mesh_lighting_model.c

@@ -15,10 +15,8 @@
 #include <string.h>
 #include <errno.h>
 
-#include "mesh_common.h"
-#include "lighting_client.h"
-
 #include "btc_ble_mesh_lighting_model.h"
+#include "lighting_client.h"
 #include "esp_ble_mesh_lighting_model_api.h"
 
 /* Lighting Client Models related functions */

components/bt/esp_ble_mesh/btc/btc_ble_mesh_prov.c

@@ -15,6 +15,14 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_prov.h"
+#include "btc_ble_mesh_config_model.h"
+#include "btc_ble_mesh_health_model.h"
+#include "btc_ble_mesh_generic_model.h"
+#include "btc_ble_mesh_time_scene_model.h"
+#include "btc_ble_mesh_sensor_model.h"
+#include "btc_ble_mesh_lighting_model.h"
+
 #include "adv.h"
 #include "mesh_kernel.h"
 #include "mesh_proxy.h"
@@ -37,15 +45,6 @@
 #include "client_common.h"
 #include "state_binding.h"
 
-#include "btc_ble_mesh_prov.h"
-#include "btc_ble_mesh_config_model.h"
-#include "btc_ble_mesh_health_model.h"
-#include "btc_ble_mesh_generic_model.h"
-#include "btc_ble_mesh_time_scene_model.h"
-#include "btc_ble_mesh_sensor_model.h"
-#include "btc_ble_mesh_lighting_model.h"
-
-#include "esp_ble_mesh_defs.h"
 #include "esp_ble_mesh_common_api.h"
 #include "esp_ble_mesh_provisioning_api.h"
 #include "esp_ble_mesh_networking_api.h"

components/bt/esp_ble_mesh/btc/btc_ble_mesh_sensor_model.c

@@ -15,10 +15,8 @@
 #include <string.h>
 #include <errno.h>
 
-#include "mesh_common.h"
-#include "sensor_client.h"
-
 #include "btc_ble_mesh_sensor_model.h"
+#include "sensor_client.h"
 #include "esp_ble_mesh_sensor_model_api.h"
 
 /* Sensor Client Models related functions */

components/bt/esp_ble_mesh/btc/btc_ble_mesh_time_scene_model.c

@@ -15,10 +15,8 @@
 #include <string.h>
 #include <errno.h>
 
-#include "mesh_common.h"
-#include "time_scene_client.h"
-
 #include "btc_ble_mesh_time_scene_model.h"
+#include "time_scene_client.h"
 #include "esp_ble_mesh_time_scene_model_api.h"
 
 /* Time and Scenes Client Models related functions */

components/bt/esp_ble_mesh/btc/include/btc_ble_mesh_prov.h

@@ -16,6 +16,7 @@
 #define _BTC_BLE_MESH_PROV_H_
 
 #include "btc/btc_manage.h"
+#include "mesh_byteorder.h"
 #include "mesh_main.h"
 #include "provisioner_prov.h"
 #include "esp_ble_mesh_defs.h"

components/bt/esp_ble_mesh/mesh_common/include/mesh_buf.h

@@ -12,6 +12,7 @@
 #define _BLE_MESH_BUF_H_
 
 #include "mesh_slist.h"
+#include "mesh_compiler.h"
 
 #ifdef __cplusplus
 extern "C" {

components/bt/esp_ble_mesh/mesh_common/include/mesh_byteorder.h

@@ -0,0 +1,599 @@
+/*
+ * Copyright (c) 2015-2016, Intel Corporation.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _BLE_MESH_BYTEORDER_H_
+#define _BLE_MESH_BYTEORDER_H_
+
+#include "mesh_types.h"
+#include "mesh_trace.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Internal helpers only used by the sys_* APIs further below */
+#ifndef __bswap_16
+#define __bswap_16(x) ((u16_t) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
+#endif
+
+#ifndef __bswap_24
+#define __bswap_24(x) ((u32_t) ((((x) >> 16) & 0xff) | \
+                                (((x)) & 0xff00) | \
+                                (((x) & 0xff) << 16)))
+#endif
+
+#ifndef __bswap_32
+#define __bswap_32(x) ((u32_t) ((((x) >> 24) & 0xff) | \
+                                (((x) >> 8) & 0xff00) | \
+                                (((x) & 0xff00) << 8) | \
+                                (((x) & 0xff) << 24)))
+#endif
+
+#ifndef __bswap_48
+#define __bswap_48(x) ((u64_t) ((((x) >> 40) & 0xff) | \
+                                (((x) >> 24) & 0xff00) | \
+                                (((x) >> 8) & 0xff0000) | \
+                                (((x) & 0xff0000) << 8) | \
+                                (((x) & 0xff00) << 24) | \
+                                (((x) & 0xff) << 40)))
+#endif
+
+#ifndef __bswap_64
+#define __bswap_64(x) ((u64_t) ((((x) >> 56) & 0xff) | \
+                                (((x) >> 40) & 0xff00) | \
+                                (((x) >> 24) & 0xff0000) | \
+                                (((x) >> 8) & 0xff000000) | \
+                                (((x) & 0xff000000) << 8) | \
+                                (((x) & 0xff0000) << 24) | \
+                                (((x) & 0xff00) << 40) | \
+                                (((x) & 0xff) << 56)))
+#endif
+
+/** @def sys_le16_to_cpu
+ *  @brief Convert 16-bit integer from little-endian to host endianness.
+ *
+ *  @param val 16-bit integer in little-endian format.
+ *
+ *  @return 16-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_le16
+ *  @brief Convert 16-bit integer from host endianness to little-endian.
+ *
+ *  @param val 16-bit integer in host endianness.
+ *
+ *  @return 16-bit integer in little-endian format.
+ */
+
+/** @def sys_le24_to_cpu
+ *  @brief Convert 24-bit integer from little-endian to host endianness.
+ *
+ *  @param val 24-bit integer in little-endian format.
+ *
+ *  @return 24-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_le24
+ *  @brief Convert 24-bit integer from host endianness to little-endian.
+ *
+ *  @param val 24-bit integer in host endianness.
+ *
+ *  @return 24-bit integer in little-endian format.
+ */
+
+/** @def sys_le32_to_cpu
+ *  @brief Convert 32-bit integer from little-endian to host endianness.
+ *
+ *  @param val 32-bit integer in little-endian format.
+ *
+ *  @return 32-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_le32
+ *  @brief Convert 32-bit integer from host endianness to little-endian.
+ *
+ *  @param val 32-bit integer in host endianness.
+ *
+ *  @return 32-bit integer in little-endian format.
+ */
+
+/** @def sys_le48_to_cpu
+ *  @brief Convert 48-bit integer from little-endian to host endianness.
+ *
+ *  @param val 48-bit integer in little-endian format.
+ *
+ *  @return 48-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_le48
+ *  @brief Convert 48-bit integer from host endianness to little-endian.
+ *
+ *  @param val 48-bit integer in host endianness.
+ *
+ *  @return 48-bit integer in little-endian format.
+ */
+
+/** @def sys_be16_to_cpu
+ *  @brief Convert 16-bit integer from big-endian to host endianness.
+ *
+ *  @param val 16-bit integer in big-endian format.
+ *
+ *  @return 16-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_be16
+ *  @brief Convert 16-bit integer from host endianness to big-endian.
+ *
+ *  @param val 16-bit integer in host endianness.
+ *
+ *  @return 16-bit integer in big-endian format.
+ */
+
+/** @def sys_be24_to_cpu
+ *  @brief Convert 24-bit integer from big-endian to host endianness.
+ *
+ *  @param val 24-bit integer in big-endian format.
+ *
+ *  @return 24-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_be24
+ *  @brief Convert 24-bit integer from host endianness to big-endian.
+ *
+ *  @param val 24-bit integer in host endianness.
+ *
+ *  @return 24-bit integer in big-endian format.
+ */
+
+/** @def sys_be32_to_cpu
+ *  @brief Convert 32-bit integer from big-endian to host endianness.
+ *
+ *  @param val 32-bit integer in big-endian format.
+ *
+ *  @return 32-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_be32
+ *  @brief Convert 32-bit integer from host endianness to big-endian.
+ *
+ *  @param val 32-bit integer in host endianness.
+ *
+ *  @return 32-bit integer in big-endian format.
+ */
+
+/** @def sys_be48_to_cpu
+ *  @brief Convert 48-bit integer from big-endian to host endianness.
+ *
+ *  @param val 48-bit integer in big-endian format.
+ *
+ *  @return 48-bit integer in host endianness.
+ */
+
+/** @def sys_cpu_to_be48
+ *  @brief Convert 48-bit integer from host endianness to big-endian.
+ *
+ *  @param val 48-bit integer in host endianness.
+ *
+ *  @return 48-bit integer in big-endian format.
+ */
+
+#ifndef sys_le16_to_cpu
+#define sys_le16_to_cpu(val) (val)
+#endif
+#ifndef sys_cpu_to_le16
+#define sys_cpu_to_le16(val) (val)
+#endif
+#ifndef sys_le24_to_cpu
+#define sys_le24_to_cpu(val) (val)
+#endif
+#ifndef sys_cpu_to_le24
+#define sys_cpu_to_le24(val) (val)
+#endif
+#ifndef sys_le32_to_cpu
+#define sys_le32_to_cpu(val) (val)
+#endif
+#ifndef sys_cpu_to_le32
+#define sys_cpu_to_le32(val) (val)
+#endif
+#ifndef sys_le48_to_cpu
+#define sys_le48_to_cpu(val) (val)
+#endif
+#ifndef sys_cpu_to_le48
+#define sys_cpu_to_le48(val) (val)
+#endif
+#ifndef sys_le64_to_cpu
+#define sys_le64_to_cpu(val) (val)
+#endif
+#ifndef sys_cpu_to_le64
+#define sys_cpu_to_le64(val) (val)
+#endif
+#ifndef sys_be16_to_cpu
+#define sys_be16_to_cpu(val) __bswap_16(val)
+#endif
+#ifndef sys_cpu_to_be16
+#define sys_cpu_to_be16(val) __bswap_16(val)
+#endif
+#ifndef sys_be24_to_cpu
+#define sys_be24_to_cpu(val) __bswap_24(val)
+#endif
+#ifndef sys_cpu_to_be24
+#define sys_cpu_to_be24(val) __bswap_24(val)
+#endif
+#ifndef sys_be32_to_cpu
+#define sys_be32_to_cpu(val) __bswap_32(val)
+#endif
+#ifndef sys_cpu_to_be32
+#define sys_cpu_to_be32(val) __bswap_32(val)
+#endif
+#ifndef sys_be48_to_cpu
+#define sys_be48_to_cpu(val) __bswap_48(val)
+#endif
+#ifndef sys_cpu_to_be48
+#define sys_cpu_to_be48(val) __bswap_48(val)
+#endif
+#ifndef sys_be64_to_cpu
+#define sys_be64_to_cpu(val) __bswap_64(val)
+#endif
+#ifndef sys_cpu_to_be64
+#define sys_cpu_to_be64(val) __bswap_64(val)
+#endif
+
+/**
+ *  @brief Put a 16-bit integer as big-endian to arbitrary location.
+ *
+ *  Put a 16-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in big-endian format.
+ *
+ *  @param val 16-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_be16(u16_t val, u8_t dst[2])
+{
+    dst[0] = val >> 8;
+    dst[1] = val;
+}
+
+/**
+ *  @brief Put a 24-bit integer as big-endian to arbitrary location.
+ *
+ *  Put a 24-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in big-endian format.
+ *
+ *  @param val 24-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_be24(u32_t val, u8_t dst[3])
+{
+    dst[0] = val >> 16;
+    sys_put_be16(val, &dst[1]);
+}
+
+/**
+ *  @brief Put a 32-bit integer as big-endian to arbitrary location.
+ *
+ *  Put a 32-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in big-endian format.
+ *
+ *  @param val 32-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_be32(u32_t val, u8_t dst[4])
+{
+    sys_put_be16(val >> 16, dst);
+    sys_put_be16(val, &dst[2]);
+}
+
+/**
+ *  @brief Put a 48-bit integer as big-endian to arbitrary location.
+ *
+ *  Put a 48-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in big-endian format.
+ *
+ *  @param val 48-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_be48(u64_t val, u8_t dst[6])
+{
+    sys_put_be16(val >> 32, dst);
+    sys_put_be32(val, &dst[2]);
+}
+
+/**
+ *  @brief Put a 64-bit integer as big-endian to arbitrary location.
+ *
+ *  Put a 64-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in big-endian format.
+ *
+ *  @param val 64-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_be64(u64_t val, u8_t dst[8])
+{
+    sys_put_be32(val >> 32, dst);
+    sys_put_be32(val, &dst[4]);
+}
+
+/**
+ *  @brief Put a 16-bit integer as little-endian to arbitrary location.
+ *
+ *  Put a 16-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in little-endian format.
+ *
+ *  @param val 16-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_le16(u16_t val, u8_t dst[2])
+{
+    dst[0] = val;
+    dst[1] = val >> 8;
+}
+
+/**
+ *  @brief Put a 24-bit integer as little-endian to arbitrary location.
+ *
+ *  Put a 24-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in littel-endian format.
+ *
+ *  @param val 24-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_le24(u32_t val, u8_t dst[3])
+{
+    sys_put_le16(val, dst);
+    dst[2] = val >> 16;
+}
+
+/**
+ *  @brief Put a 32-bit integer as little-endian to arbitrary location.
+ *
+ *  Put a 32-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in little-endian format.
+ *
+ *  @param val 32-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_le32(u32_t val, u8_t dst[4])
+{
+    sys_put_le16(val, dst);
+    sys_put_le16(val >> 16, &dst[2]);
+}
+
+/**
+ *  @brief Put a 48-bit integer as little-endian to arbitrary location.
+ *
+ *  Put a 48-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in little-endian format.
+ *
+ *  @param val 48-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_le48(u64_t val, u8_t dst[6])
+{
+    sys_put_le32(val, dst);
+    sys_put_le16(val >> 32, &dst[4]);
+}
+
+/**
+ *  @brief Put a 64-bit integer as little-endian to arbitrary location.
+ *
+ *  Put a 64-bit integer, originally in host endianness, to a
+ *  potentially unaligned memory location in little-endian format.
+ *
+ *  @param val 64-bit integer in host endianness.
+ *  @param dst Destination memory address to store the result.
+ */
+static inline void sys_put_le64(u64_t val, u8_t dst[8])
+{
+    sys_put_le32(val, dst);
+    sys_put_le32(val >> 32, &dst[4]);
+}
+
+/**
+ *  @brief Get a 16-bit integer stored in big-endian format.
+ *
+ *  Get a 16-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 16-bit integer to get.
+ *
+ *  @return 16-bit integer in host endianness.
+ */
+static inline u16_t sys_get_be16(const u8_t src[2])
+{
+    return ((u16_t)src[0] << 8) | src[1];
+}
+
+/**
+ *  @brief Get a 24-bit integer stored in big-endian format.
+ *
+ *  Get a 24-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 24-bit integer to get.
+ *
+ *  @return 24-bit integer in host endianness.
+ */
+static inline u32_t sys_get_be24(const u8_t src[3])
+{
+    return ((u32_t)src[0] << 16) | sys_get_be16(&src[1]);
+}
+
+/**
+ *  @brief Get a 32-bit integer stored in big-endian format.
+ *
+ *  Get a 32-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 32-bit integer to get.
+ *
+ *  @return 32-bit integer in host endianness.
+ */
+static inline u32_t sys_get_be32(const u8_t src[4])
+{
+    return ((u32_t)sys_get_be16(&src[0]) << 16) | sys_get_be16(&src[2]);
+}
+
+/**
+ *  @brief Get a 48-bit integer stored in big-endian format.
+ *
+ *  Get a 48-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 48-bit integer to get.
+ *
+ *  @return 48-bit integer in host endianness.
+ */
+static inline u64_t sys_get_be48(const u8_t src[6])
+{
+    return ((u64_t)sys_get_be32(&src[0]) << 32) | sys_get_be16(&src[4]);
+}
+
+/**
+ *  @brief Get a 64-bit integer stored in big-endian format.
+ *
+ *  Get a 64-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 64-bit integer to get.
+ *
+ *  @return 64-bit integer in host endianness.
+ */
+static inline u64_t sys_get_be64(const u8_t src[8])
+{
+    return ((u64_t)sys_get_be32(&src[0]) << 32) | sys_get_be32(&src[4]);
+}
+
+/**
+ *  @brief Get a 16-bit integer stored in little-endian format.
+ *
+ *  Get a 16-bit integer, stored in little-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the little-endian 16-bit integer to get.
+ *
+ *  @return 16-bit integer in host endianness.
+ */
+static inline u16_t sys_get_le16(const u8_t src[2])
+{
+    return ((u16_t)src[1] << 8) | src[0];
+}
+
+/**
+ *  @brief Get a 24-bit integer stored in big-endian format.
+ *
+ *  Get a 24-bit integer, stored in big-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the big-endian 24-bit integer to get.
+ *
+ *  @return 24-bit integer in host endianness.
+ */
+static inline u32_t sys_get_le24(const u8_t src[3])
+{
+    return ((u32_t)src[2] << 16) | sys_get_le16(&src[0]);
+}
+
+/**
+ *  @brief Get a 32-bit integer stored in little-endian format.
+ *
+ *  Get a 32-bit integer, stored in little-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the little-endian 32-bit integer to get.
+ *
+ *  @return 32-bit integer in host endianness.
+ */
+static inline u32_t sys_get_le32(const u8_t src[4])
+{
+    return ((u32_t)sys_get_le16(&src[2]) << 16) | sys_get_le16(&src[0]);
+}
+
+/**
+ *  @brief Get a 48-bit integer stored in little-endian format.
+ *
+ *  Get a 48-bit integer, stored in little-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the little-endian 48-bit integer to get.
+ *
+ *  @return 48-bit integer in host endianness.
+ */
+static inline u64_t sys_get_le48(const u8_t src[6])
+{
+    return ((u64_t)sys_get_le32(&src[2]) << 32) | sys_get_le16(&src[0]);
+}
+
+/**
+ *  @brief Get a 64-bit integer stored in little-endian format.
+ *
+ *  Get a 64-bit integer, stored in little-endian format in a potentially
+ *  unaligned memory location, and convert it to the host endianness.
+ *
+ *  @param src Location of the little-endian 64-bit integer to get.
+ *
+ *  @return 64-bit integer in host endianness.
+ */
+static inline u64_t sys_get_le64(const u8_t src[8])
+{
+    return ((u64_t)sys_get_le32(&src[4]) << 32) | sys_get_le32(&src[0]);
+}
+
+/**
+ * @brief Swap one buffer content into another
+ *
+ * Copy the content of src buffer into dst buffer in reversed order,
+ * i.e.: src[n] will be put in dst[end-n]
+ * Where n is an index and 'end' the last index in both arrays.
+ * The 2 memory pointers must be pointing to different areas, and have
+ * a minimum size of given length.
+ *
+ * @param dst A valid pointer on a memory area where to copy the data in
+ * @param src A valid pointer on a memory area where to copy the data from
+ * @param length Size of both dst and src memory areas
+ */
+static inline void sys_memcpy_swap(void *dst, const void *src, size_t length)
+{
+    u8_t *pdst = (u8_t *)dst;
+    const u8_t *psrc = (const u8_t *)src;
+
+    __ASSERT(((psrc < pdst && (psrc + length) <= pdst) ||
+            (psrc > pdst && (pdst + length) <= psrc)),
+            "Source and destination buffers must not overlap");
+
+    psrc += length - 1;
+
+    for (; length > 0; length--) {
+        *pdst++ = *psrc--;
+    }
+}
+
+/**
+ * @brief Swap buffer content
+ *
+ * In-place memory swap, where final content will be reversed.
+ * I.e.: buf[n] will be put in buf[end-n]
+ * Where n is an index and 'end' the last index of buf.
+ *
+ * @param buf A valid pointer on a memory area to swap
+ * @param length Size of buf memory area
+ */
+static inline void sys_mem_swap(void *buf, size_t length)
+{
+    size_t i;
+
+    for (i = 0; i < (length / 2); i++) {
+        u8_t tmp = ((u8_t *)buf)[i];
+
+        ((u8_t *)buf)[i] = ((u8_t *)buf)[length - 1 - i];
+        ((u8_t *)buf)[length - 1 - i] = tmp;
+    }
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BLE_MESH_BYTEORDER_H_ */

components/bt/esp_ble_mesh/mesh_common/include/mesh_common.h

@@ -24,6 +24,9 @@
 
 #include "esp_heap_caps.h"
 
+#include "mesh_byteorder.h"
+#include "mesh_ffs.h"
+#include "mesh_trace.h"
 #include "mesh_mutex.h"
 #include "mesh_access.h"
 

components/bt/esp_ble_mesh/mesh_common/include/mesh_compiler.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2010-2014,2017 Wind River Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _BLE_MESH_COMPILER_H_
+#define _BLE_MESH_COMPILER_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ___in_section(a, b, c)
+
+#define __in_section(a, b, c) ___in_section(a, b, c)
+
+#define __in_section_unique(seg) ___in_section(seg, __FILE__, __COUNTER__)
+
+#ifndef __packed
+#define __packed        __attribute__((__packed__))
+#endif
+
+#ifndef __aligned
+#define __aligned(x)    __attribute__((__aligned__(x)))
+#endif
+
+#ifndef __used
+#define __used          __attribute__((__used__))
+#endif
+
+#ifndef ARG_UNUSED
+#define ARG_UNUSED(x)   (void)(x)
+#endif
+
+#ifndef popcount
+#define popcount(x)     __builtin_popcount(x)
+#endif
+
+#ifndef ALWAYS_INLINE
+#define ALWAYS_INLINE inline __attribute__((always_inline))
+#endif
+
+
+/*
+ * This is meant to be used in conjunction with __in_section() and similar
+ * where scattered structure instances are concatened together by the linker
+ * and walked by the code at run time just like a contiguous array of such
+ * structures.
+ *
+ * Assemblers and linkers may insert alignment padding by default whose
+ * size is larger than the natural alignment for those structures when
+ * gathering various section segments together, messing up the array walk.
+ * To prevent this, we need to provide an explicit alignment not to rely
+ * on the default that might just work by luck.
+ *
+ * Alignment statements in  linker scripts are not sufficient as
+ * the assembler may add padding by itself to each segment when switching
+ * between sections within the same file even if it merges many such segments
+ * into a single section in the end.
+ */
+#ifndef Z_DECL_ALIGN
+#define Z_DECL_ALIGN(type) __aligned(__alignof(type)) type
+#endif
+
+/*
+ * Convenience helper combining __in_section() and Z_DECL_ALIGN().
+ * The section name is the struct type prepended with an underscore.
+ * The subsection is "static" and the subsubsection is the variable name.
+ */
+#ifndef Z_STRUCT_SECTION_ITERABLE
+#define Z_STRUCT_SECTION_ITERABLE(struct_type, name) \
+        Z_DECL_ALIGN(struct struct_type) name
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BLE_MESH_COMPILER_H_ */

components/bt/esp_ble_mesh/mesh_common/include/mesh_ffs.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015, Wind River Systems, Inc.
+ * Copyright (c) 2017, Oticon A/S
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef _BLE_MESH_FFS_H_
+#define _BLE_MESH_FFS_H_
+
+#include "mesh_types.h"
+#include "mesh_compiler.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ *
+ * @brief find most significant bit set in a 32-bit word
+ *
+ * This routine finds the first bit set starting from the most significant bit
+ * in the argument passed in and returns the index of that bit.  Bits are
+ * numbered starting at 1 from the least significant bit.  A return value of
+ * zero indicates that the value passed is zero.
+ *
+ * @return most significant bit set, 0 if @a op is 0
+ */
+
+static ALWAYS_INLINE unsigned int find_msb_set(u32_t op)
+{
+    if (op == 0) {
+        return 0;
+    }
+
+    return 32 - __builtin_clz(op);
+}
+
+/**
+ *
+ * @brief find least significant bit set in a 32-bit word
+ *
+ * This routine finds the first bit set starting from the least significant bit
+ * in the argument passed in and returns the index of that bit.  Bits are
+ * numbered starting at 1 from the least significant bit.  A return value of
+ * zero indicates that the value passed is zero.
+ *
+ * @return least significant bit set, 0 if @a op is 0
+ */
+
+static ALWAYS_INLINE unsigned int find_lsb_set(u32_t op)
+{
+    return __builtin_ffs(op);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _BLE_MESH_FFS_H_ */

components/bt/esp_ble_mesh/mesh_common/include/mesh_kernel.h

@@ -20,7 +20,11 @@ extern "C" {
 #endif
 
 #ifdef CONFIG_BLUEDROID_ENABLED
-#define BLE_MESH_ADV_TASK_CORE  TASK_PINNED_TO_CORE
+#ifdef CONFIG_BLUEDROID_PINNED_TO_CORE
+#define BLE_MESH_ADV_TASK_CORE  (CONFIG_BLUEDROID_PINNED_TO_CORE < portNUM_PROCESSORS ? CONFIG_BLUEDROID_PINNED_TO_CORE : tskNO_AFFINITY)
+#else
+#define BLE_MESH_ADV_TASK_CORE  (0)
+#endif
 #endif
 
 #ifdef CONFIG_NIMBLE_ENABLED
@@ -29,7 +33,6 @@ extern "C" {
 #else
 #define BLE_MESH_ADV_TASK_CORE  (0)
 #endif
-
 #endif
 
 #define BLE_MESH_ADV_TASK_STACK_SIZE    3072

components/bt/esp_ble_mesh/mesh_common/include/mesh_trace.h

@@ -10,6 +10,7 @@
 #define _BLE_MESH_TRACE_H_
 
 #include "esp_log.h"
+#include "mesh_util.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -56,10 +57,6 @@ extern "C" {
 #define BLE_MESH_LOG_LOCAL_LEVEL_MAPPING    LOG_LOCAL_LEVEL
 #endif
 
-#ifndef MAX
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
-#endif /* MAX(a, b) */
-
 #define BLE_MESH_LOG_LEVEL_CHECK(LAYER, LEVEL) (MAX(LAYER##_LOG_LEVEL, BLE_MESH_LOG_LOCAL_LEVEL_MAPPING) >= LOG_LEVEL_##LEVEL)
 
 #define BLE_MESH_PRINT_E(tag, format, ...)   {esp_log_write(ESP_LOG_ERROR,   tag, LOG_FORMAT(E, format), esp_log_timestamp(), tag, ##__VA_ARGS__); }

components/bt/esp_ble_mesh/mesh_common/include/mesh_util.h

@@ -15,9 +15,7 @@
 #define _BLE_MESH_UTIL_H_
 
 #include <stddef.h>
-#include "soc/soc.h"
 #include "mesh_types.h"
-#include "mesh_trace.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -26,238 +24,99 @@ extern "C" {
 /* Helper to pass a int as a pointer or vice-versa.
  * Those are available for 32 bits architectures:
  */
+#ifndef POINTER_TO_UINT
 #define POINTER_TO_UINT(x) ((u32_t)  (x))
+#endif
+#ifndef UINT_TO_POINTER
 #define UINT_TO_POINTER(x) ((void *) (x))
+#endif
+#ifndef POINTER_TO_INT
 #define POINTER_TO_INT(x)  ((s32_t)  (x))
+#endif
+#ifndef INT_TO_POINTER
 #define INT_TO_POINTER(x)  ((void *) (x))
+#endif
 
 /* Evaluates to 0 if cond is true-ish; compile error otherwise */
+#ifndef ZERO_OR_COMPILE_ERROR
 #define ZERO_OR_COMPILE_ERROR(cond) ((int) sizeof(char[1 - 2 * !(cond)]) - 1)
+#endif
 
 /* Evaluates to 0 if array is an array; compile error if not array (e.g.
  * pointer)
  */
-#define IS_ARRAY(array)                                     \
-    ZERO_OR_COMPILE_ERROR(                                  \
-        !__builtin_types_compatible_p(__typeof__(array),    \
-                          __typeof__(&(array)[0])))
+#ifndef IS_ARRAY
+#define IS_ARRAY(array) \
+        ZERO_OR_COMPILE_ERROR( \
+        !__builtin_types_compatible_p(__typeof__(array), \
+            __typeof__(&(array)[0])))
+#endif
 
 /* Evaluates to number of elements in an array; compile error if not
  * an array (e.g. pointer)
  */
-#define ARRAY_SIZE(array)               \
-    ((unsigned long) (IS_ARRAY(array) + \
-        (sizeof(array) / sizeof((array)[0]))))
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(array) \
+        ((unsigned long) (IS_ARRAY(array) + \
+            (sizeof(array) / sizeof((array)[0]))))
+#endif
 
 /* Evaluates to 1 if ptr is part of array, 0 otherwise; compile error if
  * "array" argument is not an array (e.g. "ptr" and "array" mixed up)
  */
+#ifndef PART_OF_ARRAY
 #define PART_OF_ARRAY(array, ptr) \
-    ((ptr) && ((ptr) >= &array[0] && (ptr) < &array[ARRAY_SIZE(array)]))
+        ((ptr) && ((ptr) >= &array[0] && (ptr) < &array[ARRAY_SIZE(array)]))
+#endif
 
+#ifndef CONTAINER_OF
 #define CONTAINER_OF(ptr, type, field) \
-    ((type *)(((char *)(ptr)) - offsetof(type, field)))
+        ((type *)(((char *)(ptr)) - offsetof(type, field)))
+#endif
 
 /* round "x" up/down to next multiple of "align" (which must be a power of 2) */
-#define ROUND_UP(x, align)                                  \
-    (((unsigned long)(x) + ((unsigned long)align - 1)) &    \
-     ~((unsigned long)align - 1))
-#define ROUND_DOWN(x, align) ((unsigned long)(x) & ~((unsigned long)align - 1))
-
-#define ceiling_fraction(numerator, divider) \
-    (((numerator) + ((divider) - 1)) / (divider))
-
-/* Internal helpers only used by the sys_* APIs further below */
-#ifndef __bswap_16
-#define __bswap_16(x) ((u16_t) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
+#ifndef ROUND_UP
+#define ROUND_UP(x, align) \
+        (((unsigned long)(x) + ((unsigned long)align - 1)) & \
+        ~((unsigned long)align - 1))
 #endif
 
-#ifndef __bswap_24
-#define __bswap_24(x) ((u32_t) ((((x) >> 16) & 0xff) |  \
-                                (((x)) & 0xff00) |      \
-                                (((x) & 0xff) << 16)))
+#ifndef ROUND_DOWN
+#define ROUND_DOWN(x, align) ((unsigned long)(x) & ~((unsigned long)align - 1))
 #endif
 
-#ifndef __bswap_32
-#define __bswap_32(x) ((u32_t) ((((x) >> 24) & 0xff) |  \
-                                (((x) >> 8) & 0xff00) | \
-                                (((x) & 0xff00) << 8) | \
-                                (((x) & 0xff) << 24)))
+/* round up/down to the next word boundary */
+#ifndef WB_UP
+#define WB_UP(x) ROUND_UP(x, sizeof(void *))
 #endif
 
-#ifndef __bswap_48
-#define __bswap_48(x) ((u64_t) ((((x) >> 40) & 0xff) |      \
-                                (((x) >> 24) & 0xff00) |    \
-                                (((x) >> 8) & 0xff0000) |   \
-                                (((x) & 0xff0000) << 8) |   \
-                                (((x) & 0xff00) << 24) |    \
-                                (((x) & 0xff) << 40)))
+#ifndef WB_DN
+#define WB_DN(x) ROUND_DOWN(x, sizeof(void *))
 #endif
 
-#ifndef __bswap_64
-#define __bswap_64(x) ((u64_t) ((((x) >> 56) & 0xff) |      \
-                                (((x) >> 40) & 0xff00) |    \
-                                (((x) >> 24) & 0xff0000) |  \
-                                (((x) >> 8) & 0xff000000) | \
-                                (((x) & 0xff000000) << 8) | \
-                                (((x) & 0xff0000) << 24) |  \
-                                (((x) & 0xff00) << 40) |    \
-                                (((x) & 0xff) << 56)))
+#ifndef ceiling_fraction
+#define ceiling_fraction(numerator, divider) \
+        (((numerator) + ((divider) - 1)) / (divider))
 #endif
 
-/** @def sys_le16_to_cpu
- *  @brief Convert 16-bit integer from little-endian to host endianness.
- *
- *  @param val 16-bit integer in little-endian format.
- *
- *  @return 16-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_le16
- *  @brief Convert 16-bit integer from host endianness to little-endian.
- *
- *  @param val 16-bit integer in host endianness.
- *
- *  @return 16-bit integer in little-endian format.
- */
-
-/** @def sys_le24_to_cpu
- *  @brief Convert 24-bit integer from little-endian to host endianness.
- *
- *  @param val 24-bit integer in little-endian format.
- *
- *  @return 24-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_le24
- *  @brief Convert 24-bit integer from host endianness to little-endian.
- *
- *  @param val 24-bit integer in host endianness.
- *
- *  @return 24-bit integer in little-endian format.
- */
-
-/** @def sys_le32_to_cpu
- *  @brief Convert 32-bit integer from little-endian to host endianness.
- *
- *  @param val 32-bit integer in little-endian format.
- *
- *  @return 32-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_le32
- *  @brief Convert 32-bit integer from host endianness to little-endian.
- *
- *  @param val 32-bit integer in host endianness.
- *
- *  @return 32-bit integer in little-endian format.
- */
-
-/** @def sys_le48_to_cpu
- *  @brief Convert 48-bit integer from little-endian to host endianness.
- *
- *  @param val 48-bit integer in little-endian format.
- *
- *  @return 48-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_le48
- *  @brief Convert 48-bit integer from host endianness to little-endian.
- *
- *  @param val 48-bit integer in host endianness.
- *
- *  @return 48-bit integer in little-endian format.
- */
-
-/** @def sys_be16_to_cpu
- *  @brief Convert 16-bit integer from big-endian to host endianness.
- *
- *  @param val 16-bit integer in big-endian format.
- *
- *  @return 16-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_be16
- *  @brief Convert 16-bit integer from host endianness to big-endian.
- *
- *  @param val 16-bit integer in host endianness.
- *
- *  @return 16-bit integer in big-endian format.
- */
-
-/** @def sys_be24_to_cpu
- *  @brief Convert 24-bit integer from big-endian to host endianness.
- *
- *  @param val 24-bit integer in big-endian format.
- *
- *  @return 24-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_be24
- *  @brief Convert 24-bit integer from host endianness to big-endian.
- *
- *  @param val 24-bit integer in host endianness.
- *
- *  @return 24-bit integer in big-endian format.
- */
-
-/** @def sys_be32_to_cpu
- *  @brief Convert 32-bit integer from big-endian to host endianness.
- *
- *  @param val 32-bit integer in big-endian format.
- *
- *  @return 32-bit integer in host endianness.
- */
-
-/** @def sys_cpu_to_be32
- *  @brief Convert 32-bit integer from host endianness to big-endian.
- *
- *  @param val 32-bit integer in host endianness.
- *
- *  @return 32-bit integer in big-endian format.
- */
-
-/** @def sys_be48_to_cpu
- *  @brief Convert 48-bit integer from big-endian to host endianness.
- *
- *  @param val 48-bit integer in big-endian format.
- *
- *  @return 48-bit integer in host endianness.
- */
+#ifndef CHECKIF
+#define CHECKIF(expr)   if (expr)
+#endif
 
-/** @def sys_cpu_to_be48
- *  @brief Convert 48-bit integer from host endianness to big-endian.
+/** @brief Return larger value of two provided expressions.
  *
- *  @param val 48-bit integer in host endianness.
- *
- *  @return 48-bit integer in big-endian format.
+ * @note Arguments are evaluated twice. See Z_MAX for GCC only, single
+ * evaluation version.
  */
-
-#define sys_le16_to_cpu(val) (val)
-#define sys_cpu_to_le16(val) (val)
-#define sys_le24_to_cpu(val) (val)
-#define sys_cpu_to_le24(val) (val)
-#define sys_le32_to_cpu(val) (val)
-#define sys_cpu_to_le32(val) (val)
-#define sys_le48_to_cpu(val) (val)
-#define sys_cpu_to_le48(val) (val)
-#define sys_le64_to_cpu(val) (val)
-#define sys_cpu_to_le64(val) (val)
-#define sys_be16_to_cpu(val) __bswap_16(val)
-#define sys_cpu_to_be16(val) __bswap_16(val)
-#define sys_be24_to_cpu(val) __bswap_24(val)
-#define sys_cpu_to_be24(val) __bswap_24(val)
-#define sys_be32_to_cpu(val) __bswap_32(val)
-#define sys_cpu_to_be32(val) __bswap_32(val)
-#define sys_be48_to_cpu(val) __bswap_48(val)
-#define sys_cpu_to_be48(val) __bswap_48(val)
-#define sys_be64_to_cpu(val) __bswap_64(val)
-#define sys_cpu_to_be64(val) __bswap_64(val)
-
 #ifndef MAX
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
+/** @brief Return smaller value of two provided expressions.
+ *
+ * @note Arguments are evaluated twice. See Z_MIN for GCC only, single
+ * evaluation version.
+ */
 #ifndef MIN
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
@@ -291,14 +150,14 @@ extern "C" {
  * value to be e.g. a literal "1" at expansion time in the next macro,
  * not "(1)", etc...  Standard recursive expansion does not work.
  */
-#define IS_ENABLED(config_macro) _IS_ENABLED1(config_macro)
+#define IS_ENABLED(config_macro) Z_IS_ENABLED1(config_macro)
 
 /* Now stick on a "_XXXX" prefix, it will now be "_XXXX1" if config_macro
  * is "1", or just "_XXXX" if it's undefined.
- *   ENABLED:   _IS_ENABLED2(_XXXX1)
- *   DISABLED   _IS_ENABLED2(_XXXX)
+ *   ENABLED:   Z_IS_ENABLED2(_XXXX1)
+ *   DISABLED   Z_IS_ENABLED2(_XXXX)
  */
-#define _IS_ENABLED1(config_macro) _IS_ENABLED2(_XXXX##config_macro)
+#define Z_IS_ENABLED1(config_macro) Z_IS_ENABLED2(_XXXX##config_macro)
 
 /* Here's the core trick, we map "_XXXX1" to "_YYYY," (i.e. a string
  * with a trailing comma), so it has the effect of making this a
@@ -312,371 +171,20 @@ extern "C" {
 /* Then we append an extra argument to fool the gcc preprocessor into
  * accepting it as a varargs macro.
  *                         arg1   arg2  arg3
- *   ENABLED:   _IS_ENABLED3(_YYYY,    1,    0)
- *   DISABLED   _IS_ENABLED3(_XXXX 1,  0)
+ *   ENABLED:   Z_IS_ENABLED3(_YYYY,    1,    0)
+ *   DISABLED   Z_IS_ENABLED3(_XXXX 1,  0)
  */
-#define _IS_ENABLED2(one_or_two_args) _IS_ENABLED3(one_or_two_args 1, 0)
+#define Z_IS_ENABLED2(one_or_two_args) Z_IS_ENABLED3(one_or_two_args true, false)
 
 /* And our second argument is thus now cooked to be 1 in the case
  * where the value is defined to 1, and 0 if not:
  */
-#define _IS_ENABLED3(ignore_this, val, ...) val
-
-/* ESP Toolchain doesn't support section */
-#define ___in_section(a, b, c)
-#define __in_section(a, b, c) ___in_section(a, b, c)
-
-#define __in_section_unique(seg) ___in_section(seg, __FILE__, __COUNTER__)
-
-#define popcount(x) __builtin_popcount(x)
-
-/**
- *
- * @brief find most significant bit set in a 32-bit word
- *
- * This routine finds the first bit set starting from the most significant bit
- * in the argument passed in and returns the index of that bit.  Bits are
- * numbered starting at 1 from the least significant bit.  A return value of
- * zero indicates that the value passed is zero.
- *
- * @return most significant bit set, 0 if @a op is 0
- */
-
-#if defined(__GNUC__)
-static inline unsigned int find_msb_set(u32_t op)
-{
-    if (!op) {
-        return 0;
-    }
-    return 32 - __builtin_clz(op);
-}
-#endif
-
-/**
- *
- * @brief find least significant bit set in a 32-bit word
- *
- * This routine finds the first bit set starting from the least significant bit
- * in the argument passed in and returns the index of that bit.  Bits are
- * numbered starting at 1 from the least significant bit.  A return value of
- * zero indicates that the value passed is zero.
- *
- * @return least significant bit set, 0 if @a op is 0
- */
-
-#if defined(__GNUC__)
-static inline unsigned int find_lsb_set(u32_t op)
-{
-    return __builtin_ffs(op);
-}
-#endif
-
-/**
- *  @brief Put a 16-bit integer as big-endian to arbitrary location.
- *
- *  Put a 16-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in big-endian format.
- *
- *  @param val 16-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_be16(u16_t val, u8_t dst[2])
-{
-    dst[0] = val >> 8;
-    dst[1] = val;
-}
-
-/**
- *  @brief Put a 24-bit integer as big-endian to arbitrary location.
- *
- *  Put a 24-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in big-endian format.
- *
- *  @param val 24-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_be24(u32_t val, u8_t dst[3])
-{
-    dst[0] = val >> 16;
-    sys_put_be16(val, &dst[1]);
-}
-
-/**
- *  @brief Put a 32-bit integer as big-endian to arbitrary location.
- *
- *  Put a 32-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in big-endian format.
- *
- *  @param val 32-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_be32(u32_t val, u8_t dst[4])
-{
-    sys_put_be16(val >> 16, dst);
-    sys_put_be16(val, &dst[2]);
-}
-
-/**
- *  @brief Put a 48-bit integer as big-endian to arbitrary location.
- *
- *  Put a 48-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in big-endian format.
- *
- *  @param val 48-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_be48(u64_t val, u8_t dst[6])
-{
-    sys_put_be16(val >> 32, dst);
-    sys_put_be32(val, &dst[2]);
-}
-
-/**
- *  @brief Put a 64-bit integer as big-endian to arbitrary location.
- *
- *  Put a 64-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in big-endian format.
- *
- *  @param val 64-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_be64(u64_t val, u8_t dst[8])
-{
-    sys_put_be32(val >> 32, dst);
-    sys_put_be32(val, &dst[4]);
-}
-
-/**
- *  @brief Put a 16-bit integer as little-endian to arbitrary location.
- *
- *  Put a 16-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in little-endian format.
- *
- *  @param val 16-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_le16(u16_t val, u8_t dst[2])
-{
-    dst[0] = val;
-    dst[1] = val >> 8;
-}
-
-/**
- *  @brief Put a 24-bit integer as little-endian to arbitrary location.
- *
- *  Put a 24-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in littel-endian format.
- *
- *  @param val 24-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_le24(u32_t val, u8_t dst[3])
-{
-    sys_put_le16(val, dst);
-    dst[2] = val >> 16;
-}
-
-/**
- *  @brief Put a 32-bit integer as little-endian to arbitrary location.
- *
- *  Put a 32-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in little-endian format.
- *
- *  @param val 32-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_le32(u32_t val, u8_t dst[4])
-{
-    sys_put_le16(val, dst);
-    sys_put_le16(val >> 16, &dst[2]);
-}
-
-/**
- *  @brief Put a 48-bit integer as little-endian to arbitrary location.
- *
- *  Put a 48-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in little-endian format.
- *
- *  @param val 48-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_le48(u64_t val, u8_t dst[6])
-{
-    sys_put_le32(val, dst);
-    sys_put_le16(val >> 32, &dst[4]);
-}
-
-/**
- *  @brief Put a 64-bit integer as little-endian to arbitrary location.
- *
- *  Put a 64-bit integer, originally in host endianness, to a
- *  potentially unaligned memory location in little-endian format.
- *
- *  @param val 64-bit integer in host endianness.
- *  @param dst Destination memory address to store the result.
- */
-static inline void sys_put_le64(u64_t val, u8_t dst[8])
-{
-    sys_put_le32(val, dst);
-    sys_put_le32(val >> 32, &dst[4]);
-}
-
-/**
- *  @brief Get a 16-bit integer stored in big-endian format.
- *
- *  Get a 16-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 16-bit integer to get.
- *
- *  @return 16-bit integer in host endianness.
- */
-static inline u16_t sys_get_be16(const u8_t src[2])
-{
-    return ((u16_t)src[0] << 8) | src[1];
-}
-
-/**
- *  @brief Get a 24-bit integer stored in big-endian format.
- *
- *  Get a 24-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 24-bit integer to get.
- *
- *  @return 24-bit integer in host endianness.
- */
-static inline u32_t sys_get_be24(const u8_t src[3])
-{
-    return ((u32_t)src[0] << 16) | sys_get_be16(&src[1]);
-}
-
-/**
- *  @brief Get a 32-bit integer stored in big-endian format.
- *
- *  Get a 32-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 32-bit integer to get.
- *
- *  @return 32-bit integer in host endianness.
- */
-static inline u32_t sys_get_be32(const u8_t src[4])
-{
-    return ((u32_t)sys_get_be16(&src[0]) << 16) | sys_get_be16(&src[2]);
-}
-
-/**
- *  @brief Get a 48-bit integer stored in big-endian format.
- *
- *  Get a 48-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 48-bit integer to get.
- *
- *  @return 48-bit integer in host endianness.
- */
-static inline u64_t sys_get_be48(const u8_t src[6])
-{
-    return ((u64_t)sys_get_be32(&src[0]) << 32) | sys_get_be16(&src[4]);
-}
-
-/**
- *  @brief Get a 64-bit integer stored in big-endian format.
- *
- *  Get a 64-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 64-bit integer to get.
- *
- *  @return 64-bit integer in host endianness.
- */
-static inline u64_t sys_get_be64(const u8_t src[8])
-{
-    return ((u64_t)sys_get_be32(&src[0]) << 32) | sys_get_be32(&src[4]);
-}
-
-/**
- *  @brief Get a 16-bit integer stored in little-endian format.
- *
- *  Get a 16-bit integer, stored in little-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the little-endian 16-bit integer to get.
- *
- *  @return 16-bit integer in host endianness.
- */
-static inline u16_t sys_get_le16(const u8_t src[2])
-{
-    return ((u16_t)src[1] << 8) | src[0];
-}
-
-/**
- *  @brief Get a 24-bit integer stored in big-endian format.
- *
- *  Get a 24-bit integer, stored in big-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the big-endian 24-bit integer to get.
- *
- *  @return 24-bit integer in host endianness.
- */
-static inline u32_t sys_get_le24(const u8_t src[3])
-{
-    return ((u32_t)src[2] << 16) | sys_get_le16(&src[0]);
-}
-
-/**
- *  @brief Get a 32-bit integer stored in little-endian format.
- *
- *  Get a 32-bit integer, stored in little-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the little-endian 32-bit integer to get.
- *
- *  @return 32-bit integer in host endianness.
- */
-static inline u32_t sys_get_le32(const u8_t src[4])
-{
-    return ((u32_t)sys_get_le16(&src[2]) << 16) | sys_get_le16(&src[0]);
-}
-
-/**
- *  @brief Get a 48-bit integer stored in little-endian format.
- *
- *  Get a 48-bit integer, stored in little-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the little-endian 48-bit integer to get.
- *
- *  @return 48-bit integer in host endianness.
- */
-static inline u64_t sys_get_le48(const u8_t src[6])
-{
-    return ((u64_t)sys_get_le32(&src[2]) << 32) | sys_get_le16(&src[0]);
-}
-
-/**
- *  @brief Get a 64-bit integer stored in little-endian format.
- *
- *  Get a 64-bit integer, stored in little-endian format in a potentially
- *  unaligned memory location, and convert it to the host endianness.
- *
- *  @param src Location of the little-endian 64-bit integer to get.
- *
- *  @return 64-bit integer in host endianness.
- */
-static inline u64_t sys_get_le64(const u8_t src[8])
-{
-    return ((u64_t)sys_get_le32(&src[4]) << 32) | sys_get_le32(&src[0]);
-}
+#define Z_IS_ENABLED3(ignore_this, val, ...) val
 
 const char *bt_hex(const void *buf, size_t len);
 
 void mem_rcopy(u8_t *dst, u8_t const *src, u16_t len);
 
-void _set(void *to, uint8_t val, unsigned int len);
-
 unsigned int _copy(uint8_t *to, unsigned int to_len,
                    const uint8_t *from, unsigned int from_len);
 
@@ -686,57 +194,6 @@ uint8_t _double_byte(uint8_t a);
 
 int _compare(const uint8_t *a, const uint8_t *b, size_t size);
 
-/**
- * @brief Swap one buffer content into another
- *
- * Copy the content of src buffer into dst buffer in reversed order,
- * i.e.: src[n] will be put in dst[end-n]
- * Where n is an index and 'end' the last index in both arrays.
- * The 2 memory pointers must be pointing to different areas, and have
- * a minimum size of given length.
- *
- * @param dst A valid pointer on a memory area where to copy the data in
- * @param src A valid pointer on a memory area where to copy the data from
- * @param length Size of both dst and src memory areas
- */
-static inline void sys_memcpy_swap(void *dst, const void *src, size_t length)
-{
-    u8_t *pdst = (u8_t *)dst;
-    const u8_t *psrc = (const u8_t *)src;
-
-    __ASSERT(((psrc < pdst && (psrc + length) <= pdst) ||
-            (psrc > pdst && (pdst + length) <= psrc)),
-            "Source and destination buffers must not overlap");
-
-    psrc += length - 1;
-
-    for (; length > 0; length--) {
-        *pdst++ = *psrc--;
-    }
-}
-
-/**
- * @brief Swap buffer content
- *
- * In-place memory swap, where final content will be reversed.
- * I.e.: buf[n] will be put in buf[end-n]
- * Where n is an index and 'end' the last index of buf.
- *
- * @param buf A valid pointer on a memory area to swap
- * @param length Size of buf memory area
- */
-static inline void sys_mem_swap(void *buf, size_t length)
-{
-    size_t i;
-
-    for (i = 0; i < (length / 2); i++) {
-        u8_t tmp = ((u8_t *)buf)[i];
-
-        ((u8_t *)buf)[i] = ((u8_t *)buf)[length - 1 - i];
-        ((u8_t *)buf)[length - 1 - i] = tmp;
-    }
-}
-
 #ifdef __cplusplus
 }
 #endif

components/bt/esp_ble_mesh/mesh_common/mesh_buf.c

@@ -6,10 +6,7 @@
  */
 
 #include <string.h>
-
-#include "mesh_buf.h"
-#include "mesh_trace.h"
-#include "mesh_mutex.h"
+#include "mesh_common.h"
 
 int net_buf_id(struct net_buf *buf)
 {

components/bt/esp_ble_mesh/mesh_common/mesh_mutex.c

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "mesh_mutex.h"
+#include "mesh_common.h"
 
 static bt_mesh_mutex_t alarm_lock;
 static bt_mesh_mutex_t list_lock;

components/bt/esp_ble_mesh/mesh_core/adv.c

@@ -11,8 +11,6 @@
 #include <string.h>
 #include <errno.h>
 
-#include "bt_common.h"
-
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_ADV)
 
 #include "mesh_kernel.h"

components/bt/esp_ble_mesh/mesh_core/cfg_cli.c

@@ -13,13 +13,13 @@
 
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_MODEL)
 
+#include "btc_ble_mesh_config_model.h"
+
 #include "mesh.h"
 #include "foundation.h"
 #include "mesh_common.h"
 #include "cfg_cli.h"
 
-#include "btc_ble_mesh_config_model.h"
-
 #define CID_NVAL 0xffff
 
 /* 2 byte dummy opcode for getting compile time buffer sizes. */

components/bt/esp_ble_mesh/mesh_core/cfg_srv.c

@@ -13,6 +13,8 @@
 
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_MODEL)
 
+#include "btc_ble_mesh_config_model.h"
+
 #include "mesh.h"
 #include "adv.h"
 #include "lpn.h"
@@ -28,8 +30,6 @@
 #include "mesh_main.h"
 #include "mesh_common.h"
 
-#include "btc_ble_mesh_config_model.h"
-
 #define DEFAULT_TTL 7
 
 /* Maximum message length is 384 in BLE Mesh. Here for composition data,

components/bt/esp_ble_mesh/mesh_core/crypto.c

@@ -13,6 +13,7 @@
 
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_CRYPTO)
 
+#include "mesh_common.h"
 #include "crypto.h"
 #include "mesh_aes_encrypt.h"
 #include "mesh_bearer_adapt.h"

components/bt/esp_ble_mesh/mesh_core/foundation.h

@@ -8,6 +8,7 @@
 #ifndef _FOUNDATION_H_
 #define _FOUNDATION_H_
 
+#include "mesh_byteorder.h"
 #include "net.h"
 
 #ifdef __cplusplus

components/bt/esp_ble_mesh/mesh_core/health_cli.c

@@ -12,12 +12,12 @@
 
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_MODEL)
 
+#include "btc_ble_mesh_health_model.h"
+
 #include "foundation.h"
 #include "mesh_common.h"
 #include "health_cli.h"
 
-#include "btc_ble_mesh_health_model.h"
-
 s32_t health_msg_timeout;
 
 static bt_mesh_health_client_t *health_cli;

components/bt/esp_ble_mesh/mesh_core/health_srv.c

@@ -12,13 +12,13 @@
 
 #define BT_DBG_ENABLED IS_ENABLED(CONFIG_BLE_MESH_DEBUG_MODEL)
 
+#include "btc_ble_mesh_health_model.h"
+
 #include "access.h"
 #include "foundation.h"
 #include "mesh_common.h"
 #include "health_srv.h"
 
-#include "btc_ble_mesh_health_model.h"
-
 #define HEALTH_TEST_STANDARD    0x00
 
 #define HEALTH_NO_FAULT         0x00

components/bt/esp_ble_mesh/mesh_core/include/mesh_access.h

@@ -11,8 +11,7 @@
 #ifndef _BLE_MESH_ACCESS_H_
 #define _BLE_MESH_ACCESS_H_
 
-#include "mesh_types.h"
-#include "mesh_util.h"
+#include "sdkconfig.h"
 #include "mesh_buf.h"
 #include "mesh_timer.h"
 

components/bt/esp_ble_mesh/mesh_models/client/generic_client.c

@@ -15,11 +15,11 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_generic_model.h"
+
 #include "model_opcode.h"
 #include "generic_client.h"
 
-#include "btc_ble_mesh_generic_model.h"
-
 /** The following are the macro definitions of generic client
  *  model messages length, and a message is composed of three
  *  parts: Opcode + msg_value + MIC

components/bt/esp_ble_mesh/mesh_models/client/lighting_client.c

@@ -15,11 +15,11 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_lighting_model.h"
+
 #include "model_opcode.h"
 #include "lighting_client.h"
 
-#include "btc_ble_mesh_lighting_model.h"
-
 /** The following are the macro definitions of lighting client
  *  model messages length, and a message is composed of three
  *  parts: Opcode + msg_value + MIC

components/bt/esp_ble_mesh/mesh_models/client/sensor_client.c

@@ -15,11 +15,11 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_sensor_model.h"
+
 #include "model_opcode.h"
 #include "sensor_client.h"
 
-#include "btc_ble_mesh_sensor_model.h"
-
 /** The following are the macro definitions of sensor client
  *  model messages length, and a message is composed of three
  *  parts: Opcode + msg_value + MIC

components/bt/esp_ble_mesh/mesh_models/client/time_scene_client.c

@@ -15,11 +15,11 @@
 #include <string.h>
 #include <errno.h>
 
+#include "btc_ble_mesh_time_scene_model.h"
+
 #include "model_opcode.h"
 #include "time_scene_client.h"
 
-#include "btc_ble_mesh_time_scene_model.h"
-
 /** The following are the macro definitions of time and client
  *  scene model messages length, and a message is composed of
  *  three parts: Opcode + msg_value + MIC

components/bt/esp_ble_mesh/mesh_models/server/device_property.c

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "mesh_common.h"
 #include "server_common.h"
 #include "device_property.h"
 

components/bt/esp_ble_mesh/mesh_models/server/generic_server.c

@@ -8,14 +8,14 @@
 
 #include <errno.h>
 
+#include "btc_ble_mesh_generic_model.h"
+
 #include "access.h"
 #include "transport.h"
 #include "model_opcode.h"
 #include "state_transition.h"
 #include "device_property.h"
 
-#include "btc_ble_mesh_generic_model.h"
-
 static bt_mesh_mutex_t generic_server_lock;
 
 static void bt_mesh_generic_server_mutex_new(void)

components/bt/esp_ble_mesh/mesh_models/server/lighting_server.c

@@ -8,14 +8,14 @@
 
 #include <errno.h>
 
+#include "btc_ble_mesh_lighting_model.h"
+
 #include "access.h"
 #include "transport.h"
 #include "model_opcode.h"
 #include "state_transition.h"
 #include "device_property.h"
 
-#include "btc_ble_mesh_lighting_model.h"
-
 static bt_mesh_mutex_t light_server_lock;
 
 static void bt_mesh_light_server_mutex_new(void)

components/bt/esp_ble_mesh/mesh_models/server/sensor_server.c

@@ -14,14 +14,14 @@
 
 #include <errno.h>
 
+#include "btc_ble_mesh_sensor_model.h"
+
 #include "access.h"
 #include "transport.h"
 #include "model_opcode.h"
 #include "state_transition.h"
 #include "device_property.h"
 
-#include "btc_ble_mesh_sensor_model.h"
-
 static void update_sensor_periodic_pub(struct bt_mesh_model *model, u16_t prop_id);
 
 /* message handlers (Start) */

components/bt/esp_ble_mesh/mesh_models/server/state_binding.c

@@ -8,6 +8,7 @@
 
 #include <errno.h>
 
+#include "mesh_common.h"
 #include "model_opcode.h"
 #include "state_binding.h"
 #include "state_transition.h"

components/bt/esp_ble_mesh/mesh_models/server/state_transition.c

@@ -6,14 +6,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "model_opcode.h"
-#include "state_transition.h"
-
 #include "btc_ble_mesh_generic_model.h"
 #include "btc_ble_mesh_lighting_model.h"
 #include "btc_ble_mesh_time_scene_model.h"
 #include "btc_ble_mesh_sensor_model.h"
 
+#include "model_opcode.h"
+#include "state_transition.h"
+
 /* Function to calculate Remaining Time (Start) */
 
 void bt_mesh_server_calc_remain_time(struct bt_mesh_state_transition *transition)

components/bt/esp_ble_mesh/mesh_models/server/time_scene_server.c

@@ -14,13 +14,13 @@
 
 #include <errno.h>
 
+#include "btc_ble_mesh_time_scene_model.h"
+
 #include "access.h"
 #include "transport.h"
 #include "model_opcode.h"
 #include "state_transition.h"
 
-#include "btc_ble_mesh_time_scene_model.h"
-
 static bt_mesh_mutex_t time_scene_server_lock;
 
 static void bt_mesh_time_scene_server_mutex_new(void)