1*042d53a7SEvalZero /*
2*042d53a7SEvalZero * Licensed to the Apache Software Foundation (ASF) under one
3*042d53a7SEvalZero * or more contributor license agreements. See the NOTICE file
4*042d53a7SEvalZero * distributed with this work for additional information
5*042d53a7SEvalZero * regarding copyright ownership. The ASF licenses this file
6*042d53a7SEvalZero * to you under the Apache License, Version 2.0 (the
7*042d53a7SEvalZero * "License"); you may not use this file except in compliance
8*042d53a7SEvalZero * with the License. You may obtain a copy of the License at
9*042d53a7SEvalZero *
10*042d53a7SEvalZero * http://www.apache.org/licenses/LICENSE-2.0
11*042d53a7SEvalZero *
12*042d53a7SEvalZero * Unless required by applicable law or agreed to in writing,
13*042d53a7SEvalZero * software distributed under the License is distributed on an
14*042d53a7SEvalZero * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15*042d53a7SEvalZero * KIND, either express or implied. See the License for the
16*042d53a7SEvalZero * specific language governing permissions and limitations
17*042d53a7SEvalZero * under the License.
18*042d53a7SEvalZero */
19*042d53a7SEvalZero
20*042d53a7SEvalZero #ifndef _MESH_GLUE_
21*042d53a7SEvalZero #define _MESH_GLUE_
22*042d53a7SEvalZero
23*042d53a7SEvalZero #include <assert.h>
24*042d53a7SEvalZero #include <errno.h>
25*042d53a7SEvalZero
26*042d53a7SEvalZero #include "syscfg/syscfg.h"
27*042d53a7SEvalZero #include "nimble/nimble_npl.h"
28*042d53a7SEvalZero
29*042d53a7SEvalZero #include "os/os_mbuf.h"
30*042d53a7SEvalZero #include "os/queue.h"
31*042d53a7SEvalZero
32*042d53a7SEvalZero #include "nimble/ble.h"
33*042d53a7SEvalZero #include "host/ble_hs.h"
34*042d53a7SEvalZero #include "host/ble_uuid.h"
35*042d53a7SEvalZero #include "../src/ble_sm_priv.h"
36*042d53a7SEvalZero #include "../src/ble_hs_hci_priv.h"
37*042d53a7SEvalZero
38*042d53a7SEvalZero #include "tinycrypt/aes.h"
39*042d53a7SEvalZero #include "tinycrypt/constants.h"
40*042d53a7SEvalZero #include "tinycrypt/utils.h"
41*042d53a7SEvalZero #include "tinycrypt/cmac_mode.h"
42*042d53a7SEvalZero #include "tinycrypt/ecc_dh.h"
43*042d53a7SEvalZero
44*042d53a7SEvalZero #if MYNEWT_VAL(BLE_MESH_SETTINGS)
45*042d53a7SEvalZero #include "config/config.h"
46*042d53a7SEvalZero #endif
47*042d53a7SEvalZero
48*042d53a7SEvalZero #define u8_t uint8_t
49*042d53a7SEvalZero #define s8_t int8_t
50*042d53a7SEvalZero #define u16_t uint16_t
51*042d53a7SEvalZero #define s16_t int16_t
52*042d53a7SEvalZero #define u32_t uint32_t
53*042d53a7SEvalZero #define u64_t uint64_t
54*042d53a7SEvalZero #define s64_t int64_t
55*042d53a7SEvalZero #define s32_t int32_t
56*042d53a7SEvalZero
57*042d53a7SEvalZero /** @brief Helper to declare elements of bt_data arrays
58*042d53a7SEvalZero *
59*042d53a7SEvalZero * This macro is mainly for creating an array of struct bt_data
60*042d53a7SEvalZero * elements which is then passed to bt_le_adv_start().
61*042d53a7SEvalZero *
62*042d53a7SEvalZero * @param _type Type of advertising data field
63*042d53a7SEvalZero * @param _data Pointer to the data field payload
64*042d53a7SEvalZero * @param _data_len Number of bytes behind the _data pointer
65*042d53a7SEvalZero */
66*042d53a7SEvalZero #define BT_DATA(_type, _data, _data_len) \
67*042d53a7SEvalZero { \
68*042d53a7SEvalZero .type = (_type), \
69*042d53a7SEvalZero .data_len = (_data_len), \
70*042d53a7SEvalZero .data = (const u8_t *)(_data), \
71*042d53a7SEvalZero }
72*042d53a7SEvalZero
73*042d53a7SEvalZero /** @brief Helper to declare elements of bt_data arrays
74*042d53a7SEvalZero *
75*042d53a7SEvalZero * This macro is mainly for creating an array of struct bt_data
76*042d53a7SEvalZero * elements which is then passed to bt_le_adv_start().
77*042d53a7SEvalZero *
78*042d53a7SEvalZero * @param _type Type of advertising data field
79*042d53a7SEvalZero * @param _bytes Variable number of single-byte parameters
80*042d53a7SEvalZero */
81*042d53a7SEvalZero #define BT_DATA_BYTES(_type, _bytes...) \
82*042d53a7SEvalZero BT_DATA(_type, ((u8_t []) { _bytes }), \
83*042d53a7SEvalZero sizeof((u8_t []) { _bytes }))
84*042d53a7SEvalZero
85*042d53a7SEvalZero /* EIR/AD data type definitions */
86*042d53a7SEvalZero #define BT_DATA_FLAGS 0x01 /* AD flags */
87*042d53a7SEvalZero #define BT_DATA_UUID16_SOME 0x02 /* 16-bit UUID, more available */
88*042d53a7SEvalZero #define BT_DATA_UUID16_ALL 0x03 /* 16-bit UUID, all listed */
89*042d53a7SEvalZero #define BT_DATA_UUID32_SOME 0x04 /* 32-bit UUID, more available */
90*042d53a7SEvalZero #define BT_DATA_UUID32_ALL 0x05 /* 32-bit UUID, all listed */
91*042d53a7SEvalZero #define BT_DATA_UUID128_SOME 0x06 /* 128-bit UUID, more available */
92*042d53a7SEvalZero #define BT_DATA_UUID128_ALL 0x07 /* 128-bit UUID, all listed */
93*042d53a7SEvalZero #define BT_DATA_NAME_SHORTENED 0x08 /* Shortened name */
94*042d53a7SEvalZero #define BT_DATA_NAME_COMPLETE 0x09 /* Complete name */
95*042d53a7SEvalZero #define BT_DATA_TX_POWER 0x0a /* Tx Power */
96*042d53a7SEvalZero #define BT_DATA_SOLICIT16 0x14 /* Solicit UUIDs, 16-bit */
97*042d53a7SEvalZero #define BT_DATA_SOLICIT128 0x15 /* Solicit UUIDs, 128-bit */
98*042d53a7SEvalZero #define BT_DATA_SVC_DATA16 0x16 /* Service data, 16-bit UUID */
99*042d53a7SEvalZero #define BT_DATA_GAP_APPEARANCE 0x19 /* GAP appearance */
100*042d53a7SEvalZero #define BT_DATA_SOLICIT32 0x1f /* Solicit UUIDs, 32-bit */
101*042d53a7SEvalZero #define BT_DATA_SVC_DATA32 0x20 /* Service data, 32-bit UUID */
102*042d53a7SEvalZero #define BT_DATA_SVC_DATA128 0x21 /* Service data, 128-bit UUID */
103*042d53a7SEvalZero #define BT_DATA_URI 0x24 /* URI */
104*042d53a7SEvalZero #define BT_DATA_MESH_PROV 0x29 /* Mesh Provisioning PDU */
105*042d53a7SEvalZero #define BT_DATA_MESH_MESSAGE 0x2a /* Mesh Networking PDU */
106*042d53a7SEvalZero #define BT_DATA_MESH_BEACON 0x2b /* Mesh Beacon */
107*042d53a7SEvalZero
108*042d53a7SEvalZero #define BT_DATA_MANUFACTURER_DATA 0xff /* Manufacturer Specific Data */
109*042d53a7SEvalZero
110*042d53a7SEvalZero #define BT_LE_AD_LIMITED 0x01 /* Limited Discoverable */
111*042d53a7SEvalZero #define BT_LE_AD_GENERAL 0x02 /* General Discoverable */
112*042d53a7SEvalZero #define BT_LE_AD_NO_BREDR 0x04 /* BR/EDR not supported */
113*042d53a7SEvalZero
114*042d53a7SEvalZero #define sys_put_be16(a,b) put_be16(b, a)
115*042d53a7SEvalZero #define sys_put_le16(a,b) put_le16(b, a)
116*042d53a7SEvalZero #define sys_put_be32(a,b) put_be32(b, a)
117*042d53a7SEvalZero #define sys_get_be16(a) get_be16(a)
118*042d53a7SEvalZero #define sys_get_le16(a) get_le16(a)
119*042d53a7SEvalZero #define sys_get_be32(a) get_be32(a)
120*042d53a7SEvalZero #define sys_cpu_to_be16(a) htobe16(a)
121*042d53a7SEvalZero #define sys_cpu_to_be32(a) htobe32(a)
122*042d53a7SEvalZero #define sys_be32_to_cpu(a) be32toh(a)
123*042d53a7SEvalZero #define sys_be16_to_cpu(a) be16toh(a)
124*042d53a7SEvalZero #define sys_le16_to_cpu(a) le16toh(a)
125*042d53a7SEvalZero
126*042d53a7SEvalZero #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
127*042d53a7SEvalZero #define CODE_UNREACHABLE __builtin_unreachable()
128*042d53a7SEvalZero #define __ASSERT(code, str) \
129*042d53a7SEvalZero do { \
130*042d53a7SEvalZero if (!(code)) BT_ERR(str); \
131*042d53a7SEvalZero assert(code); \
132*042d53a7SEvalZero } while (0);
133*042d53a7SEvalZero
134*042d53a7SEvalZero #define __ASSERT_NO_MSG(test) __ASSERT(test, "")
135*042d53a7SEvalZero
136*042d53a7SEvalZero /* Mesh is designed to not use mbuf chains */
137*042d53a7SEvalZero #if BT_DBG_ENABLED
138*042d53a7SEvalZero #define ASSERT_NOT_CHAIN(om) assert(SLIST_NEXT(om, om_next) == NULL)
139*042d53a7SEvalZero #else
140*042d53a7SEvalZero #define ASSERT_NOT_CHAIN(om) (void)(om)
141*042d53a7SEvalZero #endif
142*042d53a7SEvalZero
143*042d53a7SEvalZero #define __packed __attribute__((__packed__))
144*042d53a7SEvalZero
145*042d53a7SEvalZero #define MSEC_PER_SEC (1000)
146*042d53a7SEvalZero #define K_MSEC(ms) (ms)
147*042d53a7SEvalZero #define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
148*042d53a7SEvalZero #define K_MINUTES(m) K_SECONDS((m) * 60)
149*042d53a7SEvalZero #define K_HOURS(h) K_MINUTES((h) * 60)
150*042d53a7SEvalZero
151*042d53a7SEvalZero #ifndef BIT
152*042d53a7SEvalZero #define BIT(n) (1UL << (n))
153*042d53a7SEvalZero #endif
154*042d53a7SEvalZero
155*042d53a7SEvalZero #define BIT_MASK(n) (BIT(n) - 1)
156*042d53a7SEvalZero
157*042d53a7SEvalZero #define BT_GAP_ADV_FAST_INT_MIN_1 0x0030 /* 30 ms */
158*042d53a7SEvalZero #define BT_GAP_ADV_FAST_INT_MAX_1 0x0060 /* 60 ms */
159*042d53a7SEvalZero #define BT_GAP_ADV_FAST_INT_MIN_2 0x00a0 /* 100 ms */
160*042d53a7SEvalZero #define BT_GAP_ADV_FAST_INT_MAX_2 0x00f0 /* 150 ms */
161*042d53a7SEvalZero #define BT_GAP_ADV_SLOW_INT_MIN 0x0640 /* 1 s */
162*042d53a7SEvalZero #define BT_GAP_ADV_SLOW_INT_MAX 0x0780 /* 1.2 s */
163*042d53a7SEvalZero
164*042d53a7SEvalZero #define BT_DBG(fmt, ...) \
165*042d53a7SEvalZero if (BT_DBG_ENABLED) { \
166*042d53a7SEvalZero BLE_HS_LOG(DEBUG, "%s: " fmt "\n", __func__, ## __VA_ARGS__); \
167*042d53a7SEvalZero }
168*042d53a7SEvalZero #define BT_INFO(fmt, ...) BLE_HS_LOG(INFO, "%s: " fmt "\n", __func__, ## __VA_ARGS__);
169*042d53a7SEvalZero #define BT_WARN(fmt, ...) BLE_HS_LOG(WARN, "%s: " fmt "\n", __func__, ## __VA_ARGS__);
170*042d53a7SEvalZero #define BT_ERR(fmt, ...) BLE_HS_LOG(ERROR, "%s: " fmt "\n", __func__, ## __VA_ARGS__);
171*042d53a7SEvalZero #define BT_GATT_ERR(_att_err) (-(_att_err))
172*042d53a7SEvalZero
173*042d53a7SEvalZero typedef ble_addr_t bt_addr_le_t;
174*042d53a7SEvalZero
175*042d53a7SEvalZero #define k_fifo_init(queue) ble_npl_eventq_init(queue)
176*042d53a7SEvalZero #define net_buf_simple_tailroom(buf) OS_MBUF_TRAILINGSPACE(buf)
177*042d53a7SEvalZero #define net_buf_tailroom(buf) net_buf_simple_tailroom(buf)
178*042d53a7SEvalZero #define net_buf_headroom(buf) ((buf)->om_data - &(buf)->om_databuf[buf->om_pkthdr_len])
179*042d53a7SEvalZero #define net_buf_simple_headroom(buf) net_buf_headroom(buf)
180*042d53a7SEvalZero #define net_buf_simple_tail(buf) ((buf)->om_data + (buf)->om_len)
181*042d53a7SEvalZero
182*042d53a7SEvalZero struct net_buf_simple_state {
183*042d53a7SEvalZero /** Offset of the data pointer from the beginning of the storage */
184*042d53a7SEvalZero u16_t offset;
185*042d53a7SEvalZero /** Length of data */
186*042d53a7SEvalZero u16_t len;
187*042d53a7SEvalZero };
188*042d53a7SEvalZero
NET_BUF_SIMPLE(uint16_t size)189*042d53a7SEvalZero static inline struct os_mbuf * NET_BUF_SIMPLE(uint16_t size)
190*042d53a7SEvalZero {
191*042d53a7SEvalZero struct os_mbuf *buf;
192*042d53a7SEvalZero
193*042d53a7SEvalZero buf = os_msys_get(size, 0);
194*042d53a7SEvalZero assert(buf);
195*042d53a7SEvalZero
196*042d53a7SEvalZero return buf;
197*042d53a7SEvalZero }
198*042d53a7SEvalZero
199*042d53a7SEvalZero #define K_NO_WAIT (0)
200*042d53a7SEvalZero #define K_FOREVER (-1)
201*042d53a7SEvalZero
202*042d53a7SEvalZero /* This is by purpose */
net_buf_simple_init(struct os_mbuf * buf,size_t reserve_head)203*042d53a7SEvalZero static inline void net_buf_simple_init(struct os_mbuf *buf,
204*042d53a7SEvalZero size_t reserve_head)
205*042d53a7SEvalZero {
206*042d53a7SEvalZero /* This is called in Zephyr after init.
207*042d53a7SEvalZero * Note in Mynewt case we don't care abour reserved head*/
208*042d53a7SEvalZero buf->om_data = &buf->om_databuf[buf->om_pkthdr_len] + reserve_head;
209*042d53a7SEvalZero buf->om_len = 0;
210*042d53a7SEvalZero }
211*042d53a7SEvalZero
212*042d53a7SEvalZero void net_buf_put(struct ble_npl_eventq *fifo, struct os_mbuf *buf);
213*042d53a7SEvalZero void * net_buf_ref(struct os_mbuf *om);
214*042d53a7SEvalZero void net_buf_unref(struct os_mbuf *om);
215*042d53a7SEvalZero uint16_t net_buf_simple_pull_le16(struct os_mbuf *om);
216*042d53a7SEvalZero uint16_t net_buf_simple_pull_be16(struct os_mbuf *om);
217*042d53a7SEvalZero uint32_t net_buf_simple_pull_be32(struct os_mbuf *om);
218*042d53a7SEvalZero uint32_t net_buf_simple_pull_le32(struct os_mbuf *om);
219*042d53a7SEvalZero uint8_t net_buf_simple_pull_u8(struct os_mbuf *om);
220*042d53a7SEvalZero void net_buf_simple_add_le16(struct os_mbuf *om, uint16_t val);
221*042d53a7SEvalZero void net_buf_simple_add_be16(struct os_mbuf *om, uint16_t val);
222*042d53a7SEvalZero void net_buf_simple_add_u8(struct os_mbuf *om, uint8_t val);
223*042d53a7SEvalZero void net_buf_simple_add_be32(struct os_mbuf *om, uint32_t val);
224*042d53a7SEvalZero void net_buf_simple_add_le32(struct os_mbuf *om, uint32_t val);
225*042d53a7SEvalZero void net_buf_add_zeros(struct os_mbuf *om, uint8_t len);
226*042d53a7SEvalZero void net_buf_simple_push_le16(struct os_mbuf *om, uint16_t val);
227*042d53a7SEvalZero void net_buf_simple_push_be16(struct os_mbuf *om, uint16_t val);
228*042d53a7SEvalZero void net_buf_simple_push_u8(struct os_mbuf *om, uint8_t val);
229*042d53a7SEvalZero void *net_buf_simple_pull(struct os_mbuf *om, uint8_t len);
230*042d53a7SEvalZero void *net_buf_simple_add(struct os_mbuf *om, uint8_t len);
231*042d53a7SEvalZero bool k_fifo_is_empty(struct ble_npl_eventq *q);
232*042d53a7SEvalZero void *net_buf_get(struct ble_npl_eventq *fifo,s32_t t);
233*042d53a7SEvalZero uint8_t *net_buf_simple_push(struct os_mbuf *om, uint8_t len);
234*042d53a7SEvalZero void net_buf_reserve(struct os_mbuf *om, size_t reserve);
235*042d53a7SEvalZero
236*042d53a7SEvalZero #define net_buf_add_mem(a,b,c) os_mbuf_append(a,b,c)
237*042d53a7SEvalZero #define net_buf_simple_add_mem(a,b,c) os_mbuf_append(a,b,c)
238*042d53a7SEvalZero #define net_buf_add_u8(a,b) net_buf_simple_add_u8(a,b)
239*042d53a7SEvalZero #define net_buf_add(a,b) net_buf_simple_add(a,b)
240*042d53a7SEvalZero
241*042d53a7SEvalZero #define net_buf_clone(a, b) os_mbuf_dup(a)
242*042d53a7SEvalZero #define net_buf_add_be32(a, b) net_buf_simple_add_be32(a, b)
243*042d53a7SEvalZero #define net_buf_add_be16(a, b) net_buf_simple_add_be16(a, b)
244*042d53a7SEvalZero
245*042d53a7SEvalZero #define BT_GATT_CCC_NOTIFY BLE_GATT_CHR_PROP_NOTIFY
246*042d53a7SEvalZero #define bt_gatt_attr ble_gatt_attr
247*042d53a7SEvalZero
248*042d53a7SEvalZero /** Description of different data types that can be encoded into
249*042d53a7SEvalZero * advertising data. Used to form arrays that are passed to the
250*042d53a7SEvalZero * bt_le_adv_start() function.
251*042d53a7SEvalZero */
252*042d53a7SEvalZero struct bt_data {
253*042d53a7SEvalZero u8_t type;
254*042d53a7SEvalZero u8_t data_len;
255*042d53a7SEvalZero const u8_t *data;
256*042d53a7SEvalZero };
257*042d53a7SEvalZero
258*042d53a7SEvalZero struct bt_pub_key_cb {
259*042d53a7SEvalZero /** @brief Callback type for Public Key generation.
260*042d53a7SEvalZero *
261*042d53a7SEvalZero * Used to notify of the local public key or that the local key is not
262*042d53a7SEvalZero * available (either because of a failure to read it or because it is
263*042d53a7SEvalZero * being regenerated).
264*042d53a7SEvalZero *
265*042d53a7SEvalZero * @param key The local public key, or NULL in case of no key.
266*042d53a7SEvalZero */
267*042d53a7SEvalZero void (*func)(const u8_t key[64]);
268*042d53a7SEvalZero
269*042d53a7SEvalZero struct bt_pub_key_cb *_next;
270*042d53a7SEvalZero };
271*042d53a7SEvalZero
272*042d53a7SEvalZero typedef void (*bt_dh_key_cb_t)(const u8_t key[32]);
273*042d53a7SEvalZero int bt_dh_key_gen(const u8_t remote_pk[64], bt_dh_key_cb_t cb);
274*042d53a7SEvalZero int bt_pub_key_gen(struct bt_pub_key_cb *new_cb);
275*042d53a7SEvalZero uint8_t *bt_pub_key_get(void);
276*042d53a7SEvalZero int bt_rand(void *buf, size_t len);
277*042d53a7SEvalZero const char * bt_hex(const void *buf, size_t len);
278*042d53a7SEvalZero int bt_encrypt_be(const uint8_t *key, const uint8_t *plaintext, uint8_t *enc_data);
279*042d53a7SEvalZero void bt_mesh_register_gatt(void);
280*042d53a7SEvalZero int bt_le_adv_start(const struct ble_gap_adv_params *param,
281*042d53a7SEvalZero const struct bt_data *ad, size_t ad_len,
282*042d53a7SEvalZero const struct bt_data *sd, size_t sd_len);
283*042d53a7SEvalZero int bt_le_adv_stop(bool proxy);
284*042d53a7SEvalZero
285*042d53a7SEvalZero struct k_delayed_work {
286*042d53a7SEvalZero struct ble_npl_callout work;
287*042d53a7SEvalZero };
288*042d53a7SEvalZero
289*042d53a7SEvalZero void k_work_init(struct ble_npl_callout *work, ble_npl_event_fn handler);
290*042d53a7SEvalZero void k_delayed_work_init(struct k_delayed_work *w, ble_npl_event_fn *f);
291*042d53a7SEvalZero void k_delayed_work_cancel(struct k_delayed_work *w);
292*042d53a7SEvalZero void k_delayed_work_submit(struct k_delayed_work *w, uint32_t ms);
293*042d53a7SEvalZero int64_t k_uptime_get(void);
294*042d53a7SEvalZero u32_t k_uptime_get_32(void);
295*042d53a7SEvalZero void k_sleep(int32_t duration);
296*042d53a7SEvalZero void k_work_submit(struct ble_npl_callout *w);
297*042d53a7SEvalZero void k_work_add_arg(struct ble_npl_callout *w, void *arg);
298*042d53a7SEvalZero void k_delayed_work_add_arg(struct k_delayed_work *w, void *arg);
299*042d53a7SEvalZero uint32_t k_delayed_work_remaining_get(struct k_delayed_work *w);
300*042d53a7SEvalZero
net_buf_simple_save(struct os_mbuf * buf,struct net_buf_simple_state * state)301*042d53a7SEvalZero static inline void net_buf_simple_save(struct os_mbuf *buf,
302*042d53a7SEvalZero struct net_buf_simple_state *state)
303*042d53a7SEvalZero {
304*042d53a7SEvalZero state->offset = net_buf_simple_headroom(buf);
305*042d53a7SEvalZero state->len = buf->om_len;
306*042d53a7SEvalZero }
307*042d53a7SEvalZero
net_buf_simple_restore(struct os_mbuf * buf,struct net_buf_simple_state * state)308*042d53a7SEvalZero static inline void net_buf_simple_restore(struct os_mbuf *buf,
309*042d53a7SEvalZero struct net_buf_simple_state *state)
310*042d53a7SEvalZero {
311*042d53a7SEvalZero buf->om_data = &buf->om_databuf[buf->om_pkthdr_len] + state->offset;
312*042d53a7SEvalZero buf->om_len = state->len;
313*042d53a7SEvalZero }
314*042d53a7SEvalZero
sys_memcpy_swap(void * dst,const void * src,size_t length)315*042d53a7SEvalZero static inline void sys_memcpy_swap(void *dst, const void *src, size_t length)
316*042d53a7SEvalZero {
317*042d53a7SEvalZero __ASSERT(((src < dst && (src + length) <= dst) ||
318*042d53a7SEvalZero (src > dst && (dst + length) <= src)),
319*042d53a7SEvalZero "Source and destination buffers must not overlap");
320*042d53a7SEvalZero
321*042d53a7SEvalZero src += length - 1;
322*042d53a7SEvalZero
323*042d53a7SEvalZero for (; length > 0; length--) {
324*042d53a7SEvalZero *((u8_t *)dst++) = *((u8_t *)src--);
325*042d53a7SEvalZero }
326*042d53a7SEvalZero }
327*042d53a7SEvalZero
328*042d53a7SEvalZero #define popcount(x) __builtin_popcount(x)
329*042d53a7SEvalZero
find_lsb_set(u32_t op)330*042d53a7SEvalZero static inline unsigned int find_lsb_set(u32_t op)
331*042d53a7SEvalZero {
332*042d53a7SEvalZero return __builtin_ffs(op);
333*042d53a7SEvalZero }
334*042d53a7SEvalZero
find_msb_set(u32_t op)335*042d53a7SEvalZero static inline unsigned int find_msb_set(u32_t op)
336*042d53a7SEvalZero {
337*042d53a7SEvalZero if (!op)
338*042d53a7SEvalZero return 0;
339*042d53a7SEvalZero
340*042d53a7SEvalZero return 32 - __builtin_clz(op);
341*042d53a7SEvalZero }
342*042d53a7SEvalZero
343*042d53a7SEvalZero #define CONFIG_BT_MESH_FRIEND BLE_MESH_FRIEND
344*042d53a7SEvalZero #define CONFIG_BT_MESH_GATT_PROXY BLE_MESH_GATT_PROXY
345*042d53a7SEvalZero #define CONFIG_BT_MESH_IV_UPDATE_TEST BLE_MESH_IV_UPDATE_TEST
346*042d53a7SEvalZero #define CONFIG_BT_MESH_LOW_POWER BLE_MESH_LOW_POWER
347*042d53a7SEvalZero #define CONFIG_BT_MESH_LPN_AUTO BLE_MESH_LPN_AUTO
348*042d53a7SEvalZero #define CONFIG_BT_MESH_LPN_ESTABLISHMENT BLE_MESH_LPN_ESTABLISHMENT
349*042d53a7SEvalZero #define CONFIG_BT_MESH_PB_ADV BLE_MESH_PB_ADV
350*042d53a7SEvalZero #define CONFIG_BT_MESH_PB_GATT BLE_MESH_PB_GATT
351*042d53a7SEvalZero #define CONFIG_BT_MESH_PROV BLE_MESH_PROV
352*042d53a7SEvalZero #define CONFIG_BT_TESTING BLE_MESH_TESTING
353*042d53a7SEvalZero #define CONFIG_BT_SETTINGS BLE_MESH_SETTINGS
354*042d53a7SEvalZero #define CONFIG_SETTINGS BLE_MESH_SETTINGS
355*042d53a7SEvalZero #define BT_SETTINGS BLE_MESH_SETTINGS
356*042d53a7SEvalZero
357*042d53a7SEvalZero /* Above flags are used with IS_ENABLED macro */
358*042d53a7SEvalZero #define IS_ENABLED(config) MYNEWT_VAL(config)
359*042d53a7SEvalZero
360*042d53a7SEvalZero #define CONFIG_BT_MESH_LPN_GROUPS MYNEWT_VAL(BLE_MESH_LPN_GROUPS)
361*042d53a7SEvalZero #define CONFIG_BT_MESH_ADV_BUF_COUNT MYNEWT_VAL(BLE_MESH_ADV_BUF_COUNT)
362*042d53a7SEvalZero #define CONFIG_BT_MESH_FRIEND_QUEUE_SIZE MYNEWT_VAL(BLE_MESH_FRIEND_QUEUE_SIZE)
363*042d53a7SEvalZero #define CONFIG_BT_MESH_FRIEND_RECV_WIN MYNEWT_VAL(BLE_MESH_FRIEND_RECV_WIN)
364*042d53a7SEvalZero #define CONFIG_BT_MESH_LPN_POLL_TIMEOUT MYNEWT_VAL(BLE_MESH_LPN_POLL_TIMEOUT)
365*042d53a7SEvalZero #define CONFIG_BT_MESH_MODEL_GROUP_COUNT MYNEWT_VAL(BLE_MESH_MODEL_GROUP_COUNT)
366*042d53a7SEvalZero #define CONFIG_BT_MESH_MODEL_KEY_COUNT MYNEWT_VAL(BLE_MESH_MODEL_KEY_COUNT)
367*042d53a7SEvalZero #define CONFIG_BT_MESH_NODE_ID_TIMEOUT MYNEWT_VAL(BLE_MESH_NODE_ID_TIMEOUT)
368*042d53a7SEvalZero #define CONFIG_BT_MAX_CONN MYNEWT_VAL(BLE_MAX_CONNECTIONS)
369*042d53a7SEvalZero #define CONFIG_BT_MESH_SEQ_STORE_RATE MYNEWT_VAL(BLE_MESH_SEQ_STORE_RATE)
370*042d53a7SEvalZero #define CONFIG_BT_MESH_RPL_STORE_TIMEOUT MYNEWT_VAL(BLE_MESH_RPL_STORE_TIMEOUT)
371*042d53a7SEvalZero #define CONFIG_BT_MESH_APP_KEY_COUNT MYNEWT_VAL(BLE_MESH_APP_KEY_COUNT)
372*042d53a7SEvalZero #define CONFIG_BT_MESH_SUBNET_COUNT MYNEWT_VAL(BLE_MESH_SUBNET_COUNT)
373*042d53a7SEvalZero #define CONFIG_BT_MESH_STORE_TIMEOUT MYNEWT_VAL(BLE_MESH_STORE_TIMEOUT)
374*042d53a7SEvalZero #define CONFIG_BT_MESH_IVU_DIVIDER MYNEWT_VAL(BLE_MESH_IVU_DIVIDER)
375*042d53a7SEvalZero #define CONFIG_BT_DEVICE_NAME MYNEWT_VAL(BLE_MESH_DEVICE_NAME)
376*042d53a7SEvalZero #define CONFIG_BT_MESH_TX_SEG_MAX MYNEWT_VAL(BLE_MESH_TX_SEG_MAX)
377*042d53a7SEvalZero
378*042d53a7SEvalZero #define printk console_printf
379*042d53a7SEvalZero
380*042d53a7SEvalZero #define CONTAINER_OF(ptr, type, field) \
381*042d53a7SEvalZero ((type *)(((char *)(ptr)) - offsetof(type, field)))
382*042d53a7SEvalZero
383*042d53a7SEvalZero
384*042d53a7SEvalZero #define k_sem ble_npl_sem
385*042d53a7SEvalZero
k_sem_init(struct k_sem * sem,unsigned int initial_count,unsigned int limit)386*042d53a7SEvalZero static inline void k_sem_init(struct k_sem *sem, unsigned int initial_count,
387*042d53a7SEvalZero unsigned int limit)
388*042d53a7SEvalZero {
389*042d53a7SEvalZero ble_npl_sem_init(sem, initial_count);
390*042d53a7SEvalZero }
391*042d53a7SEvalZero
k_sem_take(struct k_sem * sem,s32_t timeout)392*042d53a7SEvalZero static inline int k_sem_take(struct k_sem *sem, s32_t timeout)
393*042d53a7SEvalZero {
394*042d53a7SEvalZero uint32_t ticks;
395*042d53a7SEvalZero
396*042d53a7SEvalZero ble_npl_time_ms_to_ticks(timeout, &ticks);
397*042d53a7SEvalZero return - ble_npl_sem_pend(sem, ticks);
398*042d53a7SEvalZero }
399*042d53a7SEvalZero
k_sem_give(struct k_sem * sem)400*042d53a7SEvalZero static inline void k_sem_give(struct k_sem *sem)
401*042d53a7SEvalZero {
402*042d53a7SEvalZero ble_npl_sem_release(sem);
403*042d53a7SEvalZero }
404*042d53a7SEvalZero
405*042d53a7SEvalZero /* Helpers to access the storage array, since we don't have access to its
406*042d53a7SEvalZero * type at this point anymore.
407*042d53a7SEvalZero */
408*042d53a7SEvalZero
409*042d53a7SEvalZero #define BUF_SIZE(pool) (pool->omp_pool->mp_block_size)
410*042d53a7SEvalZero
net_buf_id(struct os_mbuf * buf)411*042d53a7SEvalZero static inline int net_buf_id(struct os_mbuf *buf)
412*042d53a7SEvalZero {
413*042d53a7SEvalZero struct os_mbuf_pool *pool = buf->om_omp;
414*042d53a7SEvalZero u8_t *pool_start = (u8_t *)pool->omp_pool->mp_membuf_addr;
415*042d53a7SEvalZero u8_t *buf_ptr = (u8_t *)buf;
416*042d53a7SEvalZero
417*042d53a7SEvalZero return (buf_ptr - pool_start) / BUF_SIZE(pool);
418*042d53a7SEvalZero }
419*042d53a7SEvalZero
420*042d53a7SEvalZero /* XXX: We should not use os_mbuf_pkthdr chains to represent a list of
421*042d53a7SEvalZero * packets, this is a hack. For now this is not an issue, because mesh
422*042d53a7SEvalZero * does not use os_mbuf chains. We should change this in the future.
423*042d53a7SEvalZero */
424*042d53a7SEvalZero STAILQ_HEAD(net_buf_slist_t, os_mbuf_pkthdr);
425*042d53a7SEvalZero
426*042d53a7SEvalZero void net_buf_slist_init(struct net_buf_slist_t *list);
427*042d53a7SEvalZero bool net_buf_slist_is_empty(struct net_buf_slist_t *list);
428*042d53a7SEvalZero struct os_mbuf *net_buf_slist_peek_head(struct net_buf_slist_t *list);
429*042d53a7SEvalZero struct os_mbuf *net_buf_slist_peek_next(struct os_mbuf *buf);
430*042d53a7SEvalZero struct os_mbuf *net_buf_slist_get(struct net_buf_slist_t *list);
431*042d53a7SEvalZero void net_buf_slist_put(struct net_buf_slist_t *list, struct os_mbuf *buf);
432*042d53a7SEvalZero void net_buf_slist_remove(struct net_buf_slist_t *list, struct os_mbuf *prev,
433*042d53a7SEvalZero struct os_mbuf *cur);
434*042d53a7SEvalZero void net_buf_slist_merge_slist(struct net_buf_slist_t *list,
435*042d53a7SEvalZero struct net_buf_slist_t *list_to_append);
436*042d53a7SEvalZero #define NET_BUF_SLIST_FOR_EACH_NODE(head, var) STAILQ_FOREACH(var, head, omp_next)
437*042d53a7SEvalZero
438*042d53a7SEvalZero #if MYNEWT_VAL(BLE_MESH_SETTINGS)
439*042d53a7SEvalZero
440*042d53a7SEvalZero #define settings_load conf_load
441*042d53a7SEvalZero int settings_bytes_from_str(char *val_str, void *vp, int *len);
442*042d53a7SEvalZero char *settings_str_from_bytes(void *vp, int vp_len, char *buf, int buf_len);
443*042d53a7SEvalZero
444*042d53a7SEvalZero #define snprintk snprintf
445*042d53a7SEvalZero #define BT_SETTINGS_SIZE(in_size) ((((((in_size) - 1) / 3) * 4) + 4) + 1)
446*042d53a7SEvalZero #define settings_save_one conf_save_one
447*042d53a7SEvalZero
448*042d53a7SEvalZero #else
449*042d53a7SEvalZero
450*042d53a7SEvalZero static inline int
settings_load(void)451*042d53a7SEvalZero settings_load(void)
452*042d53a7SEvalZero {
453*042d53a7SEvalZero return 0;
454*042d53a7SEvalZero }
455*042d53a7SEvalZero
456*042d53a7SEvalZero #endif /* MYNEWT_VAL(MYNEWT_VAL_BLE_MESH_SETTINGS) */
457*042d53a7SEvalZero
458*042d53a7SEvalZero #define BUILD_ASSERT(cond) _Static_assert(cond, "")
459*042d53a7SEvalZero
460*042d53a7SEvalZero #endif
461