conn_mw_ble.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  1. /**
  2. * Copyright (c) 2014 - 2020, Nordic Semiconductor ASA
  3. *
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without modification,
  7. * are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. *
  12. * 2. Redistributions in binary form, except as embedded into a Nordic
  13. * Semiconductor ASA integrated circuit in a product or a software update for
  14. * such product, must reproduce the above copyright notice, this list of
  15. * conditions and the following disclaimer in the documentation and/or other
  16. * materials provided with the distribution.
  17. *
  18. * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
  19. * contributors may be used to endorse or promote products derived from this
  20. * software without specific prior written permission.
  21. *
  22. * 4. This software, with or without modification, must only be used with a
  23. * Nordic Semiconductor ASA integrated circuit.
  24. *
  25. * 5. Any software provided in binary form under this license must not be reverse
  26. * engineered, decompiled, modified and/or disassembled.
  27. *
  28. * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
  29. * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  30. * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
  31. * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
  32. * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  34. * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  37. * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38. *
  39. */
  40. #include "ble_conn.h"
  41. #include "conn_mw_ble.h"
  42. #include "ble_serialization.h"
  43. #include "conn_ble_user_mem.h"
  44. #if defined(NRF_SD_BLE_API_VERSION) && ( (NRF_SD_BLE_API_VERSION >= 5) || (NRF_SD_BLE_API_VERSION == 3))
  45. #include "nrf_sdh_ble.h"
  46. #endif
  47. #include <string.h>
  48. extern sercon_ble_user_mem_t m_conn_user_mem_table[];
  49. #if defined(NRF_SD_BLE_API_VERSION) && NRF_SD_BLE_API_VERSION < 4
  50. uint32_t conn_mw_ble_tx_packet_count_get(uint8_t const * const p_rx_buf,
  51. uint32_t rx_buf_len,
  52. uint8_t * const p_tx_buf,
  53. uint32_t * const p_tx_buf_len)
  54. {
  55. SER_ASSERT_NOT_NULL(p_rx_buf);
  56. SER_ASSERT_NOT_NULL(p_tx_buf);
  57. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  58. uint8_t count;
  59. uint16_t conn_handle;
  60. uint8_t * p_count = &count;
  61. uint32_t err_code = NRF_SUCCESS;
  62. uint32_t sd_err_code;
  63. err_code = ble_tx_packet_count_get_req_dec(p_rx_buf, rx_buf_len, &conn_handle, &p_count);
  64. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  65. sd_err_code = sd_ble_tx_packet_count_get(conn_handle, p_count);
  66. err_code = ble_tx_packet_count_get_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, p_count);
  67. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  68. return err_code;
  69. }
  70. #endif
  71. uint32_t conn_mw_ble_uuid_vs_add(uint8_t const * const p_rx_buf,
  72. uint32_t rx_buf_len,
  73. uint8_t * const p_tx_buf,
  74. uint32_t * const p_tx_buf_len)
  75. {
  76. SER_ASSERT_NOT_NULL(p_rx_buf);
  77. SER_ASSERT_NOT_NULL(p_tx_buf);
  78. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  79. ble_uuid128_t uuid;
  80. ble_uuid128_t * p_uuid = &uuid;
  81. uint8_t uuid_type;
  82. uint8_t * p_uuid_type = &uuid_type;
  83. uint32_t err_code = NRF_SUCCESS;
  84. uint32_t sd_err_code;
  85. err_code = ble_uuid_vs_add_req_dec(p_rx_buf, rx_buf_len, &p_uuid, &p_uuid_type);
  86. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  87. sd_err_code = sd_ble_uuid_vs_add(p_uuid, p_uuid_type);
  88. err_code = ble_uuid_vs_add_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, p_uuid_type);
  89. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  90. return err_code;
  91. }
  92. uint32_t conn_mw_ble_uuid_decode(uint8_t const * const p_rx_buf,
  93. uint32_t rx_buf_len,
  94. uint8_t * const p_tx_buf,
  95. uint32_t * const p_tx_buf_len)
  96. {
  97. SER_ASSERT_NOT_NULL(p_rx_buf);
  98. SER_ASSERT_NOT_NULL(p_tx_buf);
  99. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  100. uint8_t raw_uuid[16];
  101. uint8_t uuid_len = sizeof (raw_uuid);
  102. uint8_t * p_raw_uuid = raw_uuid;
  103. ble_uuid_t uuid;
  104. ble_uuid_t * p_uuid = &uuid;
  105. uint32_t err_code = NRF_SUCCESS;
  106. uint32_t sd_err_code;
  107. err_code = ble_uuid_decode_req_dec(p_rx_buf, rx_buf_len, &uuid_len, &p_raw_uuid, &p_uuid);
  108. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  109. sd_err_code = sd_ble_uuid_decode(uuid_len, p_raw_uuid, p_uuid);
  110. err_code = ble_uuid_decode_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, p_uuid);
  111. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  112. return err_code;
  113. }
  114. uint32_t conn_mw_ble_uuid_encode(uint8_t const * const p_rx_buf,
  115. uint32_t rx_buf_len,
  116. uint8_t * const p_tx_buf,
  117. uint32_t * const p_tx_buf_len)
  118. {
  119. SER_ASSERT_NOT_NULL(p_rx_buf);
  120. SER_ASSERT_NOT_NULL(p_tx_buf);
  121. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  122. uint8_t raw_uuid[16];
  123. uint8_t uuid_len = sizeof (raw_uuid);
  124. uint8_t * p_uuid_len = &uuid_len;
  125. uint8_t * p_raw_uuid = raw_uuid;
  126. ble_uuid_t uuid;
  127. ble_uuid_t * p_uuid = &uuid;
  128. uint32_t err_code = NRF_SUCCESS;
  129. uint32_t sd_err_code;
  130. memset(&uuid, 0, sizeof(uuid));
  131. err_code = ble_uuid_encode_req_dec(p_rx_buf, rx_buf_len, &p_uuid, &p_uuid_len, &p_raw_uuid);
  132. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  133. sd_err_code = sd_ble_uuid_encode(p_uuid, p_uuid_len, p_raw_uuid);
  134. err_code = ble_uuid_encode_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, uuid_len, p_raw_uuid);
  135. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  136. return err_code;
  137. }
  138. uint32_t conn_mw_ble_version_get(uint8_t const * const p_rx_buf,
  139. uint32_t rx_buf_len,
  140. uint8_t * const p_tx_buf,
  141. uint32_t * const p_tx_buf_len)
  142. {
  143. SER_ASSERT_NOT_NULL(p_rx_buf);
  144. SER_ASSERT_NOT_NULL(p_tx_buf);
  145. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  146. ble_version_t version;
  147. ble_version_t * p_version = &version;
  148. uint32_t err_code = NRF_SUCCESS;
  149. uint32_t sd_err_code;
  150. err_code = ble_version_get_req_dec(p_rx_buf, rx_buf_len, &p_version);
  151. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  152. sd_err_code = sd_ble_version_get(p_version);
  153. err_code = ble_version_get_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, p_version);
  154. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  155. return err_code;
  156. }
  157. uint32_t conn_mw_ble_opt_get(uint8_t const * const p_rx_buf,
  158. uint32_t rx_buf_len,
  159. uint8_t * const p_tx_buf,
  160. uint32_t * const p_tx_buf_len)
  161. {
  162. SER_ASSERT_NOT_NULL(p_rx_buf);
  163. SER_ASSERT_NOT_NULL(p_tx_buf);
  164. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  165. uint32_t opt_id;
  166. ble_opt_t opt;
  167. ble_opt_t *p_opt = &opt;
  168. uint32_t err_code = NRF_SUCCESS;
  169. uint32_t sd_err_code;
  170. err_code = ble_opt_get_req_dec(p_rx_buf, rx_buf_len, &opt_id, &p_opt);
  171. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  172. uint16_t act_latency;
  173. uint8_t passkey[BLE_GAP_PASSKEY_LEN];
  174. /* Initialaize appropriate pointers inside opt union based on opt_id */
  175. switch (opt_id)
  176. {
  177. case BLE_GAP_OPT_LOCAL_CONN_LATENCY:
  178. opt.gap_opt.local_conn_latency.p_actual_latency = &act_latency;
  179. break;
  180. case BLE_GAP_OPT_PASSKEY:
  181. opt.gap_opt.passkey.p_passkey = passkey;
  182. break;
  183. }
  184. sd_err_code = sd_ble_opt_get(opt_id, p_opt);
  185. err_code = ble_opt_get_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len, opt_id, p_opt);
  186. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  187. return err_code;
  188. }
  189. uint32_t conn_mw_ble_opt_set(uint8_t const * const p_rx_buf,
  190. uint32_t rx_buf_len,
  191. uint8_t * const p_tx_buf,
  192. uint32_t * const p_tx_buf_len)
  193. {
  194. SER_ASSERT_NOT_NULL(p_rx_buf);
  195. SER_ASSERT_NOT_NULL(p_tx_buf);
  196. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  197. uint32_t opt_id = 0xFFFFFFFF;
  198. uint16_t act_latency;
  199. uint8_t passkey[BLE_GAP_PASSKEY_LEN];
  200. uint32_t err_code = NRF_SUCCESS;
  201. /* Pre-decode type of ble_opt_t union */
  202. err_code = ble_opt_id_pre_dec(p_rx_buf, rx_buf_len, &opt_id);
  203. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  204. ble_opt_t opt;
  205. ble_opt_t *p_opt = &opt;
  206. /* Initialaize appropriate pointers inside opt union based on opt_id */
  207. switch (opt_id)
  208. {
  209. case BLE_GAP_OPT_LOCAL_CONN_LATENCY:
  210. opt.gap_opt.local_conn_latency.p_actual_latency = &act_latency;
  211. break;
  212. case BLE_GAP_OPT_PASSKEY:
  213. opt.gap_opt.passkey.p_passkey = passkey;
  214. break;
  215. }
  216. uint32_t sd_err_code;
  217. err_code = ble_opt_set_req_dec(p_rx_buf, rx_buf_len, &opt_id, &p_opt);
  218. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  219. sd_err_code = sd_ble_opt_set(opt_id, p_opt);
  220. err_code = ble_opt_set_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
  221. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  222. return err_code;
  223. }
  224. uint32_t conn_mw_ble_enable(uint8_t const * const p_rx_buf,
  225. uint32_t rx_buf_len,
  226. uint8_t * const p_tx_buf,
  227. uint32_t * const p_tx_buf_len)
  228. {
  229. SER_ASSERT_NOT_NULL(p_rx_buf);
  230. SER_ASSERT_NOT_NULL(p_tx_buf);
  231. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  232. uint32_t app_ram_base;
  233. /*lint --e{10} --e{19} --e{27} --e{40} --e{529} -save suppress Error 27: Illegal character */
  234. #if defined(_WIN32) || defined(__unix) || defined(__APPLE__)
  235. uint32_t ram_start = 0;
  236. #elif defined ( __CC_ARM )
  237. extern uint32_t Image$$RW_IRAM1$$Base;
  238. volatile uint32_t ram_start = (uint32_t) &Image$$RW_IRAM1$$Base;
  239. #elif defined ( __ICCARM__ )
  240. extern uint32_t __ICFEDIT_region_RAM_start__;
  241. volatile uint32_t ram_start = (uint32_t) &__ICFEDIT_region_RAM_start__;
  242. #elif defined ( __GNUC__ )
  243. extern uint32_t __data_start__;
  244. volatile uint32_t ram_start = (uint32_t) &__data_start__;
  245. #endif
  246. app_ram_base = ram_start;
  247. uint32_t err_code = NRF_SUCCESS;
  248. uint32_t sd_err_code;
  249. #if defined(NRF_SD_BLE_API_VERSION) && NRF_SD_BLE_API_VERSION < 4
  250. ble_enable_params_t params;
  251. ble_enable_params_t * p_params = &params;
  252. ble_conn_bw_counts_t conn_bw_counts;
  253. params.common_enable_params.p_conn_bw_counts = &conn_bw_counts;
  254. uint8_t gap_device_name_value[BLE_GAP_DEVNAME_MAX_LEN];
  255. ble_gap_device_name_t device_name;
  256. device_name.max_len = BLE_GAP_DEVNAME_MAX_LEN;
  257. device_name.p_value = gap_device_name_value;
  258. params.gap_enable_params.p_device_name = &device_name;
  259. err_code = ble_enable_req_dec(p_rx_buf, rx_buf_len, &p_params);
  260. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  261. #ifndef UNIT_TEST
  262. sd_err_code = nrf_sdh_ble_enable(p_params, &app_ram_base);
  263. #else
  264. sd_err_code = NRF_SUCCESS;
  265. #endif
  266. #else
  267. err_code = ble_enable_req_dec(p_rx_buf, rx_buf_len);
  268. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  269. #if defined(NRF_SD_BLE_API_VERSION) && NRF_SD_BLE_API_VERSION <= 4
  270. //Enable BLE SDH to enable events from BLE.
  271. sd_err_code = sd_ble_enable(&app_ram_base);
  272. #else
  273. //Enable BLE SDH to enable events from BLE.
  274. sd_err_code = nrf_sdh_ble_enable(&app_ram_base);
  275. #endif
  276. #endif
  277. err_code = ble_enable_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
  278. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  279. (void)app_ram_base;
  280. return err_code;
  281. }
  282. uint32_t conn_mw_ble_user_mem_reply(uint8_t const * const p_rx_buf,
  283. uint32_t rx_buf_len,
  284. uint8_t * const p_tx_buf,
  285. uint32_t * const p_tx_buf_len)
  286. {
  287. SER_ASSERT_NOT_NULL(p_rx_buf);
  288. SER_ASSERT_NOT_NULL(p_tx_buf);
  289. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  290. ble_user_mem_block_t mem_block;
  291. ble_user_mem_block_t * p_mem_block = &mem_block;
  292. uint32_t err_code = NRF_SUCCESS;
  293. uint32_t user_mem_tab_index;
  294. uint16_t conn_handle;
  295. /* Allocate user memory context for SoftDevice */
  296. uint32_t sd_err_code;
  297. err_code = ble_user_mem_reply_req_dec(p_rx_buf, rx_buf_len, &conn_handle, &p_mem_block);
  298. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  299. if (p_mem_block != NULL)
  300. {
  301. //Use the context if p_mem_block was not null
  302. err_code = conn_ble_user_mem_context_create(&user_mem_tab_index);
  303. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  304. m_conn_user_mem_table[user_mem_tab_index].conn_handle = conn_handle;
  305. m_conn_user_mem_table[user_mem_tab_index].mem_block.len = p_mem_block->len;
  306. p_mem_block = &(m_conn_user_mem_table[user_mem_tab_index].mem_block);
  307. }
  308. sd_err_code = sd_ble_user_mem_reply(conn_handle, p_mem_block);
  309. err_code = ble_user_mem_reply_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
  310. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  311. return err_code;
  312. }
  313. #if NRF_SD_BLE_API_VERSION >= 4
  314. uint32_t conn_mw_ble_cfg_set(uint8_t const * const p_rx_buf,
  315. uint32_t rx_buf_len,
  316. uint8_t * const p_tx_buf,
  317. uint32_t * const p_tx_buf_len)
  318. {
  319. SER_ASSERT_NOT_NULL(p_rx_buf);
  320. SER_ASSERT_NOT_NULL(p_tx_buf);
  321. SER_ASSERT_NOT_NULL(p_tx_buf_len);
  322. uint32_t app_ram_base;
  323. /*lint --e{10} --e{19} --e{27} --e{40} --e{529} -save suppress Error 27: Illegal character */
  324. #if defined(_WIN32) || defined(__unix) || defined(__APPLE__)
  325. uint32_t ram_start = 0;
  326. #elif defined ( __CC_ARM )
  327. extern uint32_t Image$$RW_IRAM1$$Base;
  328. volatile uint32_t ram_start = (uint32_t) &Image$$RW_IRAM1$$Base;
  329. #elif defined ( __ICCARM__ )
  330. extern uint32_t __ICFEDIT_region_RAM_start__;
  331. volatile uint32_t ram_start = (uint32_t) &__ICFEDIT_region_RAM_start__;
  332. #elif defined ( __GNUC__ )
  333. extern uint32_t __data_start__;
  334. volatile uint32_t ram_start = (uint32_t) &__data_start__;
  335. #endif
  336. app_ram_base = ram_start;
  337. uint32_t err_code = NRF_SUCCESS;
  338. uint32_t sd_err_code;
  339. uint32_t cfg_id;
  340. ble_cfg_t cfg;
  341. uint8_t gap_device_name_value[BLE_GAP_DEVNAME_MAX_LEN];
  342. cfg.gap_cfg.device_name_cfg.p_value = gap_device_name_value;
  343. cfg.gap_cfg.device_name_cfg.max_len = BLE_GAP_DEVNAME_MAX_LEN;
  344. ble_cfg_t * p_cfg = &cfg;
  345. err_code = ble_cfg_set_req_dec(p_rx_buf, rx_buf_len, &cfg_id, &p_cfg);
  346. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  347. sd_err_code = sd_ble_cfg_set(cfg_id,p_cfg, app_ram_base);
  348. err_code = ble_cfg_set_rsp_enc(sd_err_code, p_tx_buf, p_tx_buf_len);
  349. SER_ASSERT(err_code == NRF_SUCCESS, err_code);
  350. return err_code;
  351. }
  352. #endif