1 /*
2 * Copyright (C) 2017 C-SKY Microsystems Co., All rights reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <string.h>
18
19 #include <aos/ble.h>
20 //#include <aos/osal_debug.h>
21 #include <string.h>
22 #include <ble_os.h>
23 #include <bluetooth/bluetooth.h>
24 #include "bluetooth/conn.h" //yulong change < to "
25 #include <bluetooth/hci.h>
26 #include <bluetooth/addr.h>
27 //#include "conn.h" // yulong added
28 #include "host/conn_internal.h"
29
30 #include <bluetooth/gatt.h>
31 #include <settings/settings.h>
32 #include <hci_api.h>
33
34 #define EVENT_BLE_BASE
35 #define TAG "BLE"
36 #define BLE_LOGD(fmt, ...) LOGD(TAG, "[%s]"fmt,__FUNCTION__, ##__VA_ARGS__)
37 #define BLE_LOGE(fmt, ...) LOGE(TAG, "[%s]"fmt,__FUNCTION__, ##__VA_ARGS__)
38
39 typedef struct _ble_dev_t {
40 uint8_t is_init;
41 slist_t cb_list;
42 uint8_t io_cap;
43 init_param_t init;
44 } ble_dev_t;
45
46 struct _params_pool_t {
47 struct bt_gatt_write_params write_params[3];
48 union {
49 struct bt_uuid_16 uuid16;
50 struct bt_uuid_32 uuid32;
51 struct bt_uuid_128 uuid128;
52 } uuid;
53 struct bt_gatt_discover_params disc_params[1];
54 struct bt_gatt_read_params read_params[4];
55
56 } ble_param_pool = {0};
57
58 ble_dev_t ble_dev = {0};
59
60 typedef struct _ble_attr_notify_t {
61 struct bt_conn *conn;
62 const uint8_t *data;
63 uint16_t len;
64 int err;
65 } ble_attr_notify_t;
66
67 void ble_adv_timeout_cb();
68
uuid_covert(uuid_t * uuid,const struct bt_uuid * btuuid)69 static inline uuid_t *uuid_covert(uuid_t *uuid, const struct bt_uuid *btuuid)
70 {
71 uuid->type = btuuid->type;
72
73 if (btuuid->type == BT_UUID_TYPE_16) {
74 UUID16(uuid) = BT_UUID_16(btuuid)->val;
75 } else if (btuuid->type == BT_UUID_TYPE_32) {
76 UUID32(uuid) = BT_UUID_32(btuuid)->val;
77 } else if (btuuid->type == BT_UUID_TYPE_128) {
78 memcpy(UUID128(uuid), BT_UUID_128(btuuid)->val, 16);
79 }
80
81 return uuid;
82 }
83
btuuid_covert(struct bt_uuid * btuuid,const uuid_t * uuid)84 static inline struct bt_uuid *btuuid_covert(struct bt_uuid *btuuid, const uuid_t *uuid)
85 {
86 btuuid->type = uuid->type;
87
88 if (uuid->type == UUID_TYPE_16) {
89 BT_UUID_16(btuuid)->val = UUID16(uuid);
90 } else if (uuid->type == UUID_TYPE_32) {
91 BT_UUID_32(btuuid)->val = UUID32(uuid);
92 } else if (uuid->type == UUID_TYPE_128) {
93 memcpy(BT_UUID_128(btuuid)->val, UUID128(uuid), 16);
94 }
95
96 return btuuid;
97 }
98
UUID_EQUAL(uuid_t * uuid1,uuid_t * uuid2)99 uint8_t UUID_EQUAL(uuid_t *uuid1, uuid_t *uuid2)
100 {
101 if (UUID_TYPE(uuid1) != UUID_TYPE(uuid2)) {
102 return false;
103 }
104
105 if (uuid1->type == BT_UUID_TYPE_16) {
106 return (0 == memcmp(&((struct bt_uuid_16 *)uuid1)->val, &((struct bt_uuid_16 *)uuid2)->val, UUID_LEN(uuid1)));
107 } else if (uuid1->type == BT_UUID_TYPE_32) {
108 return (0 == memcmp(&((struct bt_uuid_32 *)uuid1)->val, &((struct bt_uuid_32 *)uuid2)->val, UUID_LEN(uuid1)));
109 } else if (uuid1->type == BT_UUID_TYPE_128) {
110 return (0 == memcmp(&((struct bt_uuid_128 *)uuid1)->val, &((struct bt_uuid_128 *)uuid2)->val, UUID_LEN(uuid1)));
111 }
112
113 return false;
114 }
115
get_uuid_val(uuid_t * uuid)116 uint8_t *get_uuid_val(uuid_t *uuid)
117 {
118 if (uuid->type == BT_UUID_TYPE_16) {
119 return (uint8_t *) & ((struct bt_uuid_16 *)uuid)->val;
120 } else if (uuid->type == BT_UUID_TYPE_32) {
121 return (uint8_t *) & ((struct bt_uuid_32 *)uuid)->val;
122 } else if (uuid->type == BT_UUID_TYPE_128) {
123 return (uint8_t *) & ((struct bt_uuid_128 *)uuid)->val;
124 } else {
125 return NULL;
126 }
127 }
128
ble_stack_event_callback(ble_event_en event,void * event_data,uint32_t event_len)129 static int ble_stack_event_callback(ble_event_en event, void *event_data, uint32_t event_len)
130 {
131 slist_t *tmp;
132 ble_event_cb_t *node;
133
134
135 slist_for_each_entry_safe(&ble_dev.cb_list, tmp, node, ble_event_cb_t, next) {
136 if (node->callback) {
137 node->callback(event, event_data);
138 }
139 }
140
141 return 0;
142 }
143
connected(struct bt_conn * conn,u8_t err)144 static void connected(struct bt_conn *conn, u8_t err)
145 {
146 evt_data_gap_conn_change_t event_data;
147 event_data.conn_handle = bt_conn_index(conn);
148
149 if (err) {
150 event_data.err = err;
151 event_data.connected = DISCONNECTED;
152 } else {
153 event_data.err = 0;
154 event_data.connected = CONNECTED;
155 }
156
157 ble_stack_event_callback(EVENT_GAP_CONN_CHANGE, &event_data, sizeof(event_data));
158 }
159
disconnected(struct bt_conn * conn,u8_t reason)160 static void disconnected(struct bt_conn *conn, u8_t reason)
161 {
162 evt_data_gap_conn_change_t event_data;
163
164 if (reason == BT_HCI_ERR_ADV_TIMEOUT)
165 {
166 ble_adv_timeout_cb();
167 }
168 else
169 {
170 event_data.conn_handle = bt_conn_index(conn);
171 event_data.connected = DISCONNECTED;
172 event_data.err = reason;
173 ble_stack_event_callback(EVENT_GAP_CONN_CHANGE, &event_data, sizeof(event_data));
174
175 memset(&ble_param_pool, 0, sizeof(ble_param_pool));
176 }
177 }
178
le_param_req_cb(struct bt_conn * conn,struct bt_le_conn_param * param)179 static bool le_param_req_cb(struct bt_conn *conn, struct bt_le_conn_param *param)
180 {
181 evt_data_gap_conn_param_req_t event_data;
182 event_data.conn_handle = bt_conn_index(conn);
183 event_data.param = *(conn_param_t *)param;
184 event_data.accept = 1;
185 ble_stack_event_callback(EVENT_GAP_CONN_PARAM_REQ, &event_data, sizeof(event_data));
186
187 if (event_data.accept) {
188 return true;
189 } else {
190 return false;
191 }
192 }
193
le_param_update_cb(struct bt_conn * conn,u16_t interval,u16_t latency,u16_t timeout)194 static void le_param_update_cb(struct bt_conn *conn, u16_t interval, u16_t latency, u16_t timeout)
195 {
196 evt_data_gap_conn_param_update_t event_data;
197 event_data.conn_handle = bt_conn_index(conn);
198 event_data.interval = interval;
199 event_data.latency = latency;
200 event_data.timeout = timeout;
201 ble_stack_event_callback(EVENT_GAP_CONN_PARAM_UPDATE, &event_data, sizeof(event_data));
202 }
203
204 #ifdef CONFIG_BT_SMP
security_changed_cb(struct bt_conn * conn,bt_security_t level,enum bt_security_err err)205 static void security_changed_cb(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
206 {
207 evt_data_gap_security_change_t event_data;
208 event_data.conn_handle = bt_conn_index(conn);
209 event_data.level = level;
210 event_data.err = err;
211 ble_stack_event_callback(EVENT_GAP_CONN_SECURITY_CHANGE, &event_data, sizeof(event_data));
212 }
213 #endif
214
scan_cb(const bt_addr_le_t * addr,s8_t rssi,u8_t adv_type,struct net_buf_simple * buf)215 static void scan_cb(const bt_addr_le_t *addr, s8_t rssi, u8_t adv_type, struct net_buf_simple *buf)
216 {
217 evt_data_gap_dev_find_t event_data;
218
219 memcpy(&event_data.dev_addr, addr, sizeof(dev_addr_t));
220 event_data.adv_type = adv_type;
221
222 if (buf->len > 31) {
223 return;
224 }
225
226 memcpy(event_data.adv_data, buf->data, buf->len);
227 event_data.adv_len = buf->len;
228 event_data.rssi = rssi;
229
230 ble_stack_event_callback(EVENT_GAP_DEV_FIND, &event_data, sizeof(event_data));
231 }
232
auth_passkey_display(struct bt_conn * conn,unsigned int passkey)233 static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
234 {
235 char passkey_str[7] = {0};
236 evt_data_smp_passkey_display_t event_data;
237
238 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
239 snprintf(passkey_str, 7, "%06u", passkey);
240
241 event_data.conn_handle = bt_conn_index(conn);
242 event_data.passkey = passkey_str;
243 ble_stack_event_callback(EVENT_SMP_PASSKEY_DISPLAY, &event_data, sizeof(event_data));
244 }
245
auth_passkey_confirm(struct bt_conn * conn,unsigned int passkey)246 static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey)
247 {
248 char passkey_str[7] = {0};
249 evt_data_smp_passkey_confirm_t event_data;
250
251 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
252 snprintf(passkey_str, 7, "%06u", passkey);
253
254 event_data.conn_handle = bt_conn_index(conn);
255 event_data.passkey = passkey_str;
256 ble_stack_event_callback(EVENT_SMP_PASSKEY_CONFIRM, &event_data, sizeof(event_data));
257 }
258
auth_passkey_entry(struct bt_conn * conn)259 static void auth_passkey_entry(struct bt_conn *conn)
260 {
261 evt_data_smp_passkey_enter_t event_data;
262
263 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
264
265 event_data.conn_handle = bt_conn_index(conn);
266 ble_stack_event_callback(EVENT_SMP_PASSKEY_ENTER, &event_data, sizeof(event_data));
267 }
268
auth_cancel(struct bt_conn * conn)269 static void auth_cancel(struct bt_conn *conn)
270 {
271 evt_data_smp_cancel_t event_data;
272
273 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
274
275 event_data.conn_handle = bt_conn_index(conn);
276 ble_stack_event_callback(EVENT_SMP_CANCEL, &event_data, sizeof(event_data));
277 }
278
auth_pairing_confirm(struct bt_conn * conn)279 static void auth_pairing_confirm(struct bt_conn *conn)
280 {
281 evt_data_smp_pairing_confirm_t event_data;
282
283 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
284
285 event_data.conn_handle = bt_conn_index(conn);
286 ble_stack_event_callback(EVENT_SMP_PAIRING_CONFIRM, &event_data, sizeof(event_data));
287 }
288
auth_pairing_complete(struct bt_conn * conn,bool bonded)289 static void auth_pairing_complete(struct bt_conn *conn, bool bonded)
290 {
291 evt_data_smp_pairing_complete_t event_data;
292
293 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
294
295 event_data.conn_handle = bt_conn_index(conn);
296 event_data.bonded = bonded;
297 event_data.err = 0;
298 ble_stack_event_callback(EVENT_SMP_PAIRING_COMPLETE, &event_data, sizeof(event_data));
299 }
300
auth_pairing_failed(struct bt_conn * conn,enum bt_security_err reason)301 static void auth_pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
302 {
303 evt_data_smp_pairing_complete_t event_data;
304
305 memcpy(&event_data.peer_addr, bt_conn_get_dst(conn), sizeof(dev_addr_t));
306
307 event_data.conn_handle = bt_conn_index(conn);
308 event_data.err = reason;
309 ble_stack_event_callback(EVENT_SMP_PAIRING_COMPLETE, &event_data, sizeof(event_data));
310 }
311
312 static struct bt_conn_cb conn_callbacks = {
313 .connected = connected,
314 .disconnected = disconnected,
315 .le_param_req = le_param_req_cb,
316 .le_param_updated = le_param_update_cb,
317 #ifdef CONFIG_BT_SMP
318 .identity_resolved = NULL,
319 .security_changed = security_changed_cb,
320 #endif
321 };
322
323 static struct bt_conn_auth_cb auth_callbacks = {
324 .cancel = auth_cancel,
325 .pairing_failed = auth_pairing_failed,
326 .pairing_complete = auth_pairing_complete,
327 };
328
ble_stack_init(init_param_t * param)329 int ble_stack_init(init_param_t *param)
330 {
331 int ret = BLE_STACK_OK;
332
333 if (param == NULL) {
334 return -BLE_STACK_ERR_NULL;
335 }
336
337 if (ble_dev.is_init) {
338 return -BLE_STACK_ERR_ALREADY;
339 }
340
341 hci_h4_driver_init();
342 ble_dev.init = *param;
343
344 if (ble_dev.init.dev_addr) {
345 bt_addr_le_t addr = *(bt_addr_le_t *)ble_dev.init.dev_addr;
346
347 if (addr.type == BT_ADDR_LE_RANDOM) {
348 ret = bt_set_id_addr(&addr);
349
350 if (ret) {
351 ret = -BLE_STACK_ERR_PARAM;
352 return ret;
353 }
354 } else if (addr.type == BT_ADDR_LE_PUBLIC) {
355 extern int bt_set_bdaddr(const bt_addr_le_t *addr);
356 ret = bt_set_bdaddr(&addr);
357
358 if (ret) {
359 ret = -BLE_STACK_ERR_PARAM;
360 return ret;
361 }
362 } else if (addr.type == BT_ADDR_LE_PUBLIC_ID) {
363 } else if (addr.type == BT_ADDR_LE_RANDOM_ID) {
364 } else {
365 ret = -BLE_STACK_ERR_PARAM;
366 return ret;
367 }
368 }
369
370 bt_conn_cb_register(&conn_callbacks);
371
372 ret = bt_enable(NULL);
373
374 if (ret) {
375 return ret;
376 }
377
378 if (ble_dev.init.dev_name) {
379 ret = bt_set_name(ble_dev.init.dev_name);
380
381 if (ret) {
382 ret = -BLE_STACK_ERR_PARAM;
383 return ret;
384 }
385 }
386
387 slist_init(&ble_dev.cb_list);
388
389 ble_stack_setting_load();
390 #if AOS_COMP_CLI
391 cli_reg_cmd_ble();
392 #endif
393 ble_dev.is_init = 1;
394
395 return ret;
396 }
397
ble_stack_iocapability_set(uint8_t io_cap)398 int ble_stack_iocapability_set(uint8_t io_cap)
399 {
400 int ret = 0;
401
402 int data = (io_cap & (IO_CAP_IN_NONE | IO_CAP_IN_YESNO | IO_CAP_IN_KEYBOARD));
403
404 if ((data != IO_CAP_IN_NONE) && (data != IO_CAP_IN_YESNO) && (data != IO_CAP_IN_KEYBOARD)) {
405 return -BLE_STACK_ERR_PARAM;
406 }
407
408 int sdata = (io_cap & (IO_CAP_OUT_DISPLAY | IO_CAP_OUT_NONE));
409
410 if ((sdata != IO_CAP_OUT_DISPLAY) && (sdata != IO_CAP_OUT_NONE)) {
411 return -BLE_STACK_ERR_PARAM;
412 }
413
414 if ((io_cap & IO_CAP_IN_NONE) && (io_cap & IO_CAP_OUT_DISPLAY)) {
415 auth_callbacks.passkey_display = auth_passkey_display;
416 auth_callbacks.cancel = auth_cancel;
417 auth_callbacks.pairing_confirm = auth_pairing_confirm;
418 auth_callbacks.pairing_failed = auth_pairing_failed;
419 auth_callbacks.pairing_complete = auth_pairing_complete;
420 } else if ((io_cap & IO_CAP_IN_YESNO) && (io_cap & IO_CAP_OUT_DISPLAY)) {
421 auth_callbacks.passkey_display = auth_passkey_display;
422 auth_callbacks.passkey_confirm = auth_passkey_confirm;
423 auth_callbacks.cancel = auth_cancel;
424 auth_callbacks.pairing_confirm = auth_pairing_confirm;
425 auth_callbacks.pairing_failed = auth_pairing_failed;
426 auth_callbacks.pairing_complete = auth_pairing_complete;
427 } else if ((io_cap & IO_CAP_IN_KEYBOARD) && (io_cap & IO_CAP_OUT_DISPLAY)) {
428 auth_callbacks.passkey_display = auth_passkey_display;
429 auth_callbacks.passkey_entry = auth_passkey_entry;
430 auth_callbacks.passkey_confirm = auth_passkey_confirm;
431 auth_callbacks.cancel = auth_cancel;
432 auth_callbacks.pairing_confirm = auth_pairing_confirm;
433 auth_callbacks.pairing_failed = auth_pairing_failed;
434 auth_callbacks.pairing_complete = auth_pairing_complete;
435 } else if ((io_cap & IO_CAP_IN_KEYBOARD) && (io_cap & IO_CAP_OUT_NONE)) {
436 auth_callbacks.passkey_entry = auth_passkey_entry;
437 auth_callbacks.passkey_confirm = auth_passkey_confirm;
438 auth_callbacks.cancel = auth_cancel;
439 auth_callbacks.pairing_confirm = auth_pairing_confirm;
440 auth_callbacks.pairing_failed = auth_pairing_failed;
441 auth_callbacks.pairing_complete = auth_pairing_complete;
442 }
443
444 if (auth_callbacks.cancel != NULL) {
445 ret = bt_conn_auth_cb_register(&auth_callbacks);
446
447 if (ret) {
448 return ret;
449 }
450 }
451
452 ble_dev.io_cap = io_cap;
453 return ret;
454 }
455
ble_stack_event_register(ble_event_cb_t * callback)456 int ble_stack_event_register(ble_event_cb_t *callback)
457 {
458 if (!ble_dev.is_init) {
459 return -BLE_STACK_ERR_INIT;
460 }
461
462 if (NULL == callback) {
463 return -BLE_STACK_ERR_NULL;
464 }
465
466 slist_add(&callback->next, &ble_dev.cb_list);
467 return 0;
468 }
469
ble_stack_adv_start(adv_param_t * param)470 int ble_stack_adv_start(adv_param_t *param)
471 {
472 struct bt_le_adv_param p = {0};
473
474 if (!ble_dev.is_init) {
475 return -BLE_STACK_ERR_INIT;
476 }
477
478 if (param == NULL) {
479 return -BLE_STACK_ERR_NULL;
480 }
481
482 if ((param->ad == NULL || (param->ad != NULL && param->ad_num == 0))
483 || ((param->sd == NULL && param->sd_num != 0) || (param->sd != NULL && param->sd_num == 0))
484 ) {
485 return -BLE_STACK_ERR_PARAM;
486 }
487
488 if (param->channel_map > ADV_DEFAULT_CHAN_MAP) {
489 return -BLE_STACK_ERR_PARAM;
490 }
491
492 if (param->filter_policy > ADV_FILTER_POLICY_ALL_REQ) {
493 return -BLE_STACK_ERR_PARAM;
494 }
495
496 if (param->type == ADV_IND || param->type == ADV_DIRECT_IND || param->type == ADV_DIRECT_IND_LOW_DUTY) {
497 p.options |= BT_LE_ADV_OPT_CONNECTABLE;
498 } else if (param->type == ADV_NONCONN_IND || param->type == ADV_SCAN_IND) {
499 p.options |= BT_LE_ADV_OPT_NONE;
500 } else {
501 return -BLE_STACK_ERR_PARAM;
502 }
503
504 if (param->type == ADV_DIRECT_IND_LOW_DUTY) {
505 p.options |= BT_LE_ADV_OPT_DIR_MODE_LOW_DUTY;
506 }
507
508 p.options |= BT_LE_ADV_OPT_ONE_TIME;
509
510 if (ble_dev.init.dev_name) {
511 p.options |= BT_LE_ADV_OPT_USE_NAME;
512 }
513
514 if (param->filter_policy == ADV_FILTER_POLICY_ALL_REQ)
515 {
516 p.options |= (BT_LE_ADV_OPT_FILTER_SCAN_REQ | BT_LE_ADV_OPT_FILTER_CONN);
517 }
518 else if (param->filter_policy == ADV_FILTER_POLICY_CONN_REQ)
519 {
520 p.options |= BT_LE_ADV_OPT_FILTER_CONN;
521 }
522 else if (param->filter_policy == ADV_FILTER_POLICY_SCAN_REQ)
523 {
524 p.options |= BT_LE_ADV_OPT_FILTER_SCAN_REQ;
525 }
526
527 p.options |= BT_LE_ADV_OPT_USE_IDENTITY;
528
529 p.id = 0;
530 p.interval_min = param->interval_min;
531 p.interval_max = param->interval_max;
532 p.channel_map = param->channel_map;
533
534 if (param->type == ADV_DIRECT_IND_LOW_DUTY || param->type == ADV_DIRECT_IND) {
535 if (!bt_addr_le_cmp((const bt_addr_le_t *)¶m->direct_peer_addr, BT_ADDR_LE_ANY)) {
536 return -BLE_STACK_ERR_PARAM;
537 }
538
539 param->ad = NULL;
540 param->ad_num = 0;
541 param->sd = NULL;
542 param->sd_num = 0;
543 }
544
545 bt_addr_le_t peer_addr = {0};
546
547 if (param->type == ADV_DIRECT_IND_LOW_DUTY || param->type == ADV_DIRECT_IND)
548 {
549 p.peer = &peer_addr;
550 peer_addr.type = param->direct_peer_addr.type;
551 memcpy(peer_addr.a.val, param->direct_peer_addr.val, 6);
552 }
553
554 return bt_le_adv_start(&p, (struct bt_data *)param->ad, param->ad_num,
555 (struct bt_data *)param->sd, param->sd_num);;
556 }
557
ble_stack_adv_stop()558 int ble_stack_adv_stop()
559 {
560 int ret;
561
562 if (!ble_dev.is_init) {
563 return -BLE_STACK_ERR_INIT;
564 }
565
566 ret = bt_le_adv_stop();
567
568 return ret;
569 }
570
ble_stack_scan_start(const scan_param_t * param)571 int ble_stack_scan_start(const scan_param_t *param)
572 {
573 int ret;
574 struct bt_le_scan_param p = {0};
575
576 if (param == NULL) {
577 return -BLE_STACK_ERR_NULL;
578 }
579
580 if (!ble_dev.is_init) {
581 return -BLE_STACK_ERR_INIT;
582 }
583
584 if (param->scan_filter > SCAN_FILTER_POLICY_WHITE_LIST) {
585 return -BLE_STACK_ERR_PARAM;
586 }
587
588 p.type = param->type;
589 p.interval = param->interval;
590 p.window = param->window;
591
592 if (param->filter_dup == SCAN_FILTER_DUP_ENABLE)
593 {
594 p.options |= BT_LE_SCAN_OPT_FILTER_DUPLICATE;
595 }
596
597 if (param->scan_filter == SCAN_FILTER_POLICY_WHITE_LIST)
598 {
599 p.options |= BT_LE_SCAN_OPT_FILTER_WHITELIST;
600 }
601
602 ret = bt_le_scan_start(&p, scan_cb);
603
604 return ret;
605 }
606
ble_stack_scan_stop()607 int ble_stack_scan_stop()
608 {
609 int ret;
610
611 if (!ble_dev.is_init) {
612 return -BLE_STACK_ERR_INIT;
613 }
614
615 ret = bt_le_scan_stop();
616
617 return ret;
618 }
619
gatt_read_handle(struct bt_conn * conn,const struct bt_gatt_attr * attr,void * buf,u16_t len,u16_t offset)620 static ssize_t gatt_read_handle(struct bt_conn *conn,
621 const struct bt_gatt_attr *attr, void *buf,
622 u16_t len, u16_t offset)
623 {
624 evt_data_gatt_char_read_t event_data = {0};
625
626 event_data.conn_handle = bt_conn_index(conn);
627 event_data.char_handle = attr->handle;
628 event_data.offset = offset;
629
630 ble_stack_event_callback(EVENT_GATT_CHAR_READ, &event_data, sizeof(event_data));
631
632 if (event_data.len < 0) {
633 return event_data.len;
634 }
635
636 if (event_data.data && event_data.len > 0) {
637 return bt_gatt_attr_read(conn, attr, buf, len, offset, event_data.data, event_data.len);
638 }
639
640 return 0;
641 }
642
gatt_write_handle(struct bt_conn * conn,const struct bt_gatt_attr * attr,const void * buf,u16_t len,u16_t offset,u8_t flags)643 static ssize_t gatt_write_handle(struct bt_conn *conn,
644 const struct bt_gatt_attr *attr,
645 const void *buf, u16_t len, u16_t offset,
646 u8_t flags)
647 {
648 evt_data_gatt_char_write_t event_data;
649
650 event_data.conn_handle = bt_conn_index(conn);
651 event_data.char_handle = attr->handle;
652 event_data.data = buf;
653 event_data.len = len;
654 event_data.offset = offset;
655 event_data.flag = flags;
656
657 ble_stack_event_callback(EVENT_GATT_CHAR_WRITE, &event_data, sizeof(event_data));
658
659 return event_data.len;
660 }
661
gatt_cfg_write(struct bt_conn * conn,const struct bt_gatt_attr * attr,u16_t value)662 static int gatt_cfg_write(struct bt_conn *conn, const struct bt_gatt_attr *attr, u16_t value)
663 {
664 evt_data_gatt_char_ccc_write_t event_data;
665
666 event_data.conn_handle = bt_conn_index(conn);
667 event_data.char_handle = attr->handle;
668 event_data.ccc_value = value;
669 event_data.allow_write = true;
670
671 ble_stack_event_callback(EVENT_GATT_CHAR_CCC_WRITE, &event_data, sizeof(event_data));
672
673 return event_data.allow_write? true:false;
674 }
675
gatt_cfg_match(struct bt_conn * conn,const struct bt_gatt_attr * attr)676 static bool gatt_cfg_match(struct bt_conn *conn, const struct bt_gatt_attr *attr)
677 {
678 evt_data_gatt_char_ccc_match_t event_data;
679
680 event_data.conn_handle = bt_conn_index(conn);
681 event_data.char_handle = attr->handle;
682 event_data.is_matched = true;
683
684 ble_stack_event_callback(EVENT_GATT_CHAR_CCC_MATCH, &event_data, sizeof(event_data));
685
686 return event_data.is_matched? true:false;
687 }
688
cfg_changed_cb(const struct bt_gatt_attr * attr,u16_t value)689 static void cfg_changed_cb(const struct bt_gatt_attr *attr,
690 u16_t value)
691 {
692 evt_data_gatt_char_ccc_change_t event_data;
693
694 event_data.char_handle = attr->handle;
695 event_data.ccc_value = value;
696
697 ble_stack_event_callback(EVENT_GATT_CHAR_CCC_CHANGE, &event_data, sizeof(event_data));
698 }
699
uuid_compare(const uuid_t * uuid1,const uuid_t * uuid2)700 int uuid_compare(const uuid_t *uuid1, const uuid_t *uuid2)
701 {
702 return bt_uuid_cmp((struct bt_uuid *)uuid1, (struct bt_uuid *)uuid2);
703 }
704
ble_stack_gatt_registe_service(gatt_service * s,gatt_attr_t attrs[],uint16_t attr_num)705 int ble_stack_gatt_registe_service(gatt_service *s, gatt_attr_t attrs[], uint16_t attr_num)
706 {
707 int ret;
708 int i;
709 struct bt_gatt_service *ss;
710
711 ss = (struct bt_gatt_service *)s;
712
713 if (!ble_dev.is_init) {
714 return -BLE_STACK_ERR_INIT;
715 }
716
717 if (attrs == NULL || attr_num == 0) {
718 return -BLE_STACK_ERR_NULL;
719 }
720
721 ss->attr_count = attr_num;
722 ss->attrs = (struct bt_gatt_attr *)attrs;
723
724 for (i = 0; i < attr_num; i++) {
725 if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_PRIMARY) || UUID_EQUAL(attrs[i].uuid, UUID_GATT_SECONDARY)
726 || UUID_EQUAL(attrs[i].uuid, UUID_GATT_INCLUDE)) {
727 ss->attrs[i].read = bt_gatt_attr_read_service;
728 } else if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_CHRC)) {
729 if (i + 1 >= attr_num) {
730 return -BLE_STACK_ERR_PARAM;
731 }
732
733 ss->attrs[i].read = bt_gatt_attr_read_chrc;
734 ss->attrs[i + 1].read = gatt_read_handle;
735 ss->attrs[i + 1].write = gatt_write_handle;
736 i++;
737 } else if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_CCC)) {
738 struct _bt_gatt_ccc *val = NULL;
739 val = (struct _bt_gatt_ccc *)(attrs[i].user_data);
740 val->cfg_changed = cfg_changed_cb;
741 val->cfg_write = gatt_cfg_write;
742 val->cfg_match = gatt_cfg_match;
743 ss->attrs[i].perm = GATT_PERM_READ | GATT_PERM_WRITE;
744 ss->attrs[i].read = bt_gatt_attr_read_ccc;
745 ss->attrs[i].write = bt_gatt_attr_write_ccc;
746 ss->attrs[i].user_data = val;
747 } else if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_CEP)) {
748 ss->attrs[i].read = bt_gatt_attr_read_cep;
749 } else if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_CUD)) {
750 ss->attrs[i].read = gatt_read_handle;
751 ss->attrs[i].write = gatt_write_handle;
752 } else if (UUID_EQUAL(attrs[i].uuid, UUID_GATT_CPF)) {
753 ss->attrs[i].read = bt_gatt_attr_read_cpf;
754 } else {
755 ss->attrs[i].read = gatt_read_handle;
756 ss->attrs[i].write = gatt_write_handle;
757 }
758 }
759
760 ret = bt_gatt_service_register(ss);
761
762 if (ret < 0) {
763 return ret;
764 }
765
766 return ss->attrs[0].handle;
767 }
768
ble_gatt_attr_notify(const struct bt_gatt_attr * attr,void * user_data)769 static uint8_t ble_gatt_attr_notify(const struct bt_gatt_attr *attr, void *user_data)
770 {
771 ble_attr_notify_t *notify = (ble_attr_notify_t *)user_data;
772 notify->err = bt_gatt_notify(notify->conn, attr, notify->data, notify->len);
773
774 return BT_GATT_ITER_STOP;
775 }
776
ble_gatt_indicate_cb(struct bt_conn * conn,const struct bt_gatt_attr * attr,u8_t err)777 static void ble_gatt_indicate_cb(struct bt_conn *conn,
778 const struct bt_gatt_attr *attr,
779 u8_t err)
780 {
781 evt_data_gatt_indicate_cb_t event_data;
782 event_data.conn_handle = bt_conn_index(conn);
783 event_data.char_handle = attr->handle;
784 event_data.err = err;
785
786 ble_stack_event_callback(EVENT_GATT_INDICATE_CB, &event_data, sizeof(event_data));
787 }
788
789
ble_gatt_attr_indicate(const struct bt_gatt_attr * attr,void * user_data)790 static uint8_t ble_gatt_attr_indicate(const struct bt_gatt_attr *attr, void *user_data)
791 {
792 ble_attr_notify_t *notify = (ble_attr_notify_t *)user_data;
793 static struct bt_gatt_indicate_params param = {0};
794 param.attr = attr;
795 param.func = ble_gatt_indicate_cb;
796 param.data = notify->data;
797 param.len = notify->len;
798
799 notify->err = bt_gatt_indicate(notify->conn, ¶m);
800
801 return BT_GATT_ITER_STOP;
802 }
803
804
ble_stack_gatt_notificate(int16_t conn_handle,uint16_t char_handle,const uint8_t * data,uint16_t len)805 int ble_stack_gatt_notificate(int16_t conn_handle, uint16_t char_handle, const uint8_t *data, uint16_t len)
806 {
807 ble_attr_notify_t notify;
808 struct bt_conn *conn;
809
810 if (conn_handle < 0 || data == NULL || len == 0) {
811 return -BLE_STACK_ERR_PARAM;
812 }
813
814 conn = bt_conn_lookup_index(conn_handle);
815
816 if (conn == NULL) {
817 return -BLE_STACK_ERR_CONN;
818 }
819
820 notify.conn = conn;
821 notify.data = data;
822 notify.len = len;
823 notify.err = 0;
824
825 bt_gatt_foreach_attr(char_handle, char_handle,
826 ble_gatt_attr_notify, ¬ify);
827
828 if (notify.conn) {
829 bt_conn_unref(notify.conn);
830 }
831
832 return notify.err;
833 }
834
ble_stack_gatt_indicate(int16_t conn_handle,int16_t char_handle,const uint8_t * data,uint16_t len)835 int ble_stack_gatt_indicate(int16_t conn_handle, int16_t char_handle, const uint8_t *data, uint16_t len)
836 {
837 ble_attr_notify_t notify;
838 struct bt_conn *conn;
839
840 if (conn_handle < 0 || data == NULL || len == 0) {
841 return -BLE_STACK_ERR_PARAM;
842 }
843
844 conn = bt_conn_lookup_index(conn_handle);
845
846 if (conn == NULL) {
847 return -BLE_STACK_ERR_CONN;
848 }
849
850 notify.conn = conn;
851 notify.data = data;
852 notify.len = len;
853 notify.err = 0;
854
855 bt_gatt_foreach_attr(char_handle, char_handle,
856 ble_gatt_attr_indicate, ¬ify);
857
858 if (notify.conn) {
859 bt_conn_unref(notify.conn);
860 }
861
862 return notify.err;
863 }
864
ble_adv_timeout_cb()865 void ble_adv_timeout_cb()
866 {
867 ble_stack_event_callback(EVENT_GAP_ADV_TIMEOUT, NULL, 0);
868 }
869
mtu_exchange_cb(struct bt_conn * conn,u8_t err,struct bt_gatt_exchange_params * params)870 void mtu_exchange_cb(struct bt_conn *conn, u8_t err,
871 struct bt_gatt_exchange_params *params)
872 {
873 evt_data_gatt_mtu_exchange_t event_data;
874 event_data.conn_handle = bt_conn_index(conn);
875 event_data.err = err;
876
877 ble_stack_event_callback(EVENT_GATT_MTU_EXCHANGE, &event_data, sizeof(event_data));
878 }
879
ble_stack_gatt_mtu_get(int16_t conn_handle)880 int ble_stack_gatt_mtu_get(int16_t conn_handle)
881 {
882 int ret;
883 struct bt_conn *conn = NULL;
884
885 if (conn_handle < 0) {
886 return -BLE_STACK_ERR_PARAM;
887 }
888
889 conn = bt_conn_lookup_index(conn_handle);
890
891 if (conn == NULL) {
892 return -BLE_STACK_ERR_CONN;
893 }
894
895 ret = bt_gatt_get_mtu(conn);
896
897 if (conn) {
898 bt_conn_unref(conn);
899 }
900
901 return ret;
902 }
903
ble_stack_gatt_mtu_exchange(int16_t conn_handle)904 int ble_stack_gatt_mtu_exchange(int16_t conn_handle)
905 {
906 static struct bt_gatt_exchange_params params;
907 int ret;
908 struct bt_conn *conn;
909
910 if (conn_handle < 0) {
911 return -BLE_STACK_ERR_PARAM;
912 }
913
914 conn = bt_conn_lookup_index(conn_handle);
915
916 if (conn == NULL) {
917 return -BLE_STACK_ERR_CONN;
918 }
919
920 params.func = mtu_exchange_cb;
921 ret = bt_gatt_exchange_mtu(conn, ¶ms);
922
923 if (conn) {
924 bt_conn_unref(conn);
925 }
926
927 return ret;
928 }
929
discover_func(struct bt_conn * conn,const struct bt_gatt_attr * attr,struct bt_gatt_discover_params * params)930 static u8_t discover_func(struct bt_conn *conn,
931 const struct bt_gatt_attr *attr,
932 struct bt_gatt_discover_params *params)
933 {
934 int event = EVENT_STACK_UNKNOWN;
935 union {
936 evt_data_gatt_discovery_svc_t svc;
937 evt_data_gatt_discovery_inc_svc_t svc_inc;
938 evt_data_gatt_discovery_char_t char_c;
939 evt_data_gatt_discovery_char_des_t char_des;
940 evt_data_gatt_discovery_complete_t comp;
941 } event_data;
942
943 if (attr == NULL) {
944 if (params) {
945 params->func = NULL;
946 }
947
948 event_data.comp.conn_handle = bt_conn_index(conn);
949 event_data.comp.err = 0;
950 event = EVENT_GATT_DISCOVERY_COMPLETE;
951 ble_stack_event_callback(event, &event_data, sizeof(event_data));
952 return BT_GATT_ITER_STOP;
953 }
954
955 if (params->type == BT_GATT_DISCOVER_PRIMARY) {
956 struct bt_gatt_service_val *value = attr->user_data;
957 event_data.svc.conn_handle = bt_conn_index(conn);
958 event_data.svc.start_handle = attr->handle;
959 event_data.svc.end_handle = value->end_handle;
960 uuid_covert(&event_data.svc.uuid, value->uuid);
961 event = EVENT_GATT_DISCOVERY_SVC;
962 } else if (params->type == BT_GATT_DISCOVER_INCLUDE) {
963 struct bt_gatt_include *inc_val = (struct bt_gatt_include *)attr->user_data;
964 event_data.svc_inc.conn_handle = bt_conn_index(conn);
965 event_data.svc_inc.attr_handle = attr->handle;
966 event_data.svc_inc.start_handle = inc_val->start_handle;
967 event_data.svc_inc.end_handle = inc_val->end_handle;
968 uuid_covert(&event_data.svc_inc.uuid, inc_val->uuid);
969 event = EVENT_GATT_DISCOVERY_INC_SVC;
970 } else if (params->type == BT_GATT_DISCOVER_CHARACTERISTIC) {
971 struct bt_gatt_chrc *chrc = (struct bt_gatt_chrc *)attr->user_data;
972 event_data.char_c.conn_handle = bt_conn_index(conn);
973 event_data.char_c.attr_handle = attr->handle;
974 event_data.char_c.val_handle = attr->handle + 1;
975 event_data.char_c.props = chrc->properties;
976 uuid_covert(&event_data.char_c.uuid, chrc->uuid);
977 event = EVENT_GATT_DISCOVERY_CHAR;
978 } else if (params->type == BT_GATT_DISCOVER_DESCRIPTOR) {
979 event_data.char_des.conn_handle = bt_conn_index(conn);
980 event_data.char_des.attr_handle = attr->handle;
981 uuid_covert(&event_data.char_des.uuid, params->uuid);
982 event = EVENT_GATT_DISCOVERY_CHAR_DES;
983 }
984
985 ble_stack_event_callback(event, &event_data, sizeof(event_data));
986
987 return BT_GATT_ITER_CONTINUE;
988 }
989
ble_stack_gatt_discovery(int16_t conn_handle,gatt_discovery_type_en type,uuid_t * uuid,uint16_t start_handle,uint16_t end_handle)990 int ble_stack_gatt_discovery(int16_t conn_handle,
991 gatt_discovery_type_en type,
992 uuid_t *uuid,
993 uint16_t start_handle,
994 uint16_t end_handle)
995 {
996 int ret;
997 struct bt_conn *conn;
998
999 if (conn_handle < 0) {
1000 return -BLE_STACK_ERR_PARAM;
1001 }
1002
1003 if (ble_param_pool.disc_params[0].func) {
1004 return -BLE_STACK_ERR_ALREADY;
1005 }
1006
1007 conn = bt_conn_lookup_index(conn_handle);
1008
1009 if (conn == NULL) {
1010 return -BLE_STACK_ERR_CONN;
1011 }
1012
1013 struct bt_gatt_discover_params *params = &ble_param_pool.disc_params[0];
1014
1015 struct bt_uuid *u;
1016
1017 if (uuid) {
1018 u = (struct bt_uuid *)&ble_param_pool.uuid;
1019 params->uuid = btuuid_covert(u, uuid);
1020 } else {
1021 params->uuid = NULL;
1022 }
1023
1024 if (type == GATT_FIND_PRIMARY_SERVICE) {
1025 params->type = BT_GATT_DISCOVER_PRIMARY;
1026 } else if (type == GATT_FIND_INC_SERVICE) {
1027 params->type = BT_GATT_DISCOVER_INCLUDE;
1028 } else if (type == GATT_FIND_CHAR) {
1029 params->type = BT_GATT_DISCOVER_CHARACTERISTIC;
1030 } else if (type == GATT_FIND_CHAR_DESCRIPTOR) {
1031 params->type = BT_GATT_DISCOVER_DESCRIPTOR;
1032 } else {
1033 return -BLE_STACK_ERR_PARAM;
1034 }
1035
1036 params->start_handle = start_handle;
1037 params->end_handle = end_handle;
1038 params->func = discover_func;
1039
1040 ret = bt_gatt_discover(conn, params);
1041
1042 if (ret) {
1043 params->func = NULL;
1044 }
1045
1046 if (conn) {
1047 bt_conn_unref(conn);
1048 }
1049
1050 return ret;
1051 }
1052
gatt_write_cb(struct bt_conn * conn,u8_t err,struct bt_gatt_write_params * params)1053 static void gatt_write_cb(struct bt_conn *conn, u8_t err, struct bt_gatt_write_params *params)
1054 {
1055 if (NULL == params) {
1056 return;
1057 }
1058
1059 evt_data_gatt_write_cb_t event_data;
1060 event_data.conn_handle = bt_conn_index(conn);
1061 event_data.err = err;
1062 event_data.char_handle = params->handle;
1063
1064 if (params) {
1065 params->func = NULL;
1066 }
1067
1068 ble_stack_event_callback(EVENT_GATT_CHAR_WRITE_CB, &event_data, sizeof(event_data));
1069 }
1070
ble_stack_gatt_notify_cb(int16_t conn_handle,uint16_t attr_handle,const uint8_t * data,uint16_t len)1071 int ble_stack_gatt_notify_cb(int16_t conn_handle, uint16_t attr_handle, const uint8_t *data, uint16_t len)
1072 {
1073 evt_data_gatt_notify_t event_data;
1074 event_data.conn_handle = conn_handle;
1075 event_data.char_handle = attr_handle;
1076 event_data.data = data;
1077 event_data.len = len;
1078
1079 ble_stack_event_callback(EVENT_GATT_NOTIFY, &event_data, sizeof(event_data));
1080 return 0;
1081 }
1082
ble_stack_gatt_write(int16_t conn_handle,uint16_t attr_handle,uint8_t * data,uint16_t len,uint16_t offset,gatt_write_en type)1083 int ble_stack_gatt_write(int16_t conn_handle, uint16_t attr_handle, uint8_t *data, uint16_t len, uint16_t offset, gatt_write_en type)
1084 {
1085 int ret = -BLE_STACK_ERR_INTERNAL;
1086 int i;
1087 struct bt_gatt_write_params *params = NULL;
1088
1089 if ((data == NULL) || (len == 0)) {
1090 return -BLE_STACK_ERR_PARAM;
1091 }
1092
1093 if (conn_handle < 0) {
1094 return -BLE_STACK_ERR_CONN;
1095 }
1096
1097 if (attr_handle <= 0) {
1098 return -BLE_STACK_ERR_NULL;
1099 }
1100
1101 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1102
1103 if (conn == NULL) {
1104 return -BLE_STACK_ERR_CONN;
1105 }
1106
1107 if (type == GATT_WRITE) {
1108
1109 for (i = 0; i < sizeof(ble_param_pool.write_params) / (sizeof(struct bt_gatt_write_params)); i++) {
1110 if (ble_param_pool.write_params[i].func == NULL) {
1111 break;
1112 }
1113 }
1114
1115 if (i == sizeof(ble_param_pool.write_params) / (sizeof(struct bt_gatt_write_params))) {
1116 return -BLE_STACK_ERR_NULL;
1117 }
1118
1119 params = &ble_param_pool.write_params[i];
1120
1121 params->handle = attr_handle;
1122 params->data = data;
1123 params->length = len;
1124 params->offset = offset;
1125 params->func = gatt_write_cb;
1126 ret = bt_gatt_write(conn, params);
1127 } else if (type == GATT_WRITE_WITHOUT_RESPONSE || type == GATT_WRITE_SINGED) {
1128 ret = bt_gatt_write_without_response(conn, attr_handle, data, len, type == GATT_WRITE_SINGED);
1129 }
1130
1131 if (ret && params) {
1132 params->func = NULL;
1133 }
1134
1135 if (conn) {
1136 bt_conn_unref(conn);
1137 }
1138
1139 return ret;
1140 }
1141
gatt_read_cb(struct bt_conn * conn,u8_t err,struct bt_gatt_read_params * params,const void * data,u16_t length)1142 u8_t gatt_read_cb(struct bt_conn *conn, u8_t err,
1143 struct bt_gatt_read_params *params,
1144 const void *data, u16_t length)
1145 {
1146 evt_data_gatt_read_cb_t event_data = {0};
1147
1148 event_data.conn_handle = bt_conn_index(conn);
1149
1150 if (err || data == NULL || length == 0) {
1151 if (params) {
1152 params->func = NULL;
1153 }
1154 event_data.err = err;
1155 event_data.data = NULL;
1156 event_data.len = 0;
1157 ble_stack_event_callback(EVENT_GATT_CHAR_READ_CB, &event_data, sizeof(event_data));
1158 return BT_GATT_ITER_STOP;
1159 }
1160
1161 event_data.data = data;
1162 event_data.len = length;
1163 event_data.err = err;
1164
1165 ble_stack_event_callback(EVENT_GATT_CHAR_READ_CB, &event_data, sizeof(event_data));
1166
1167 return BT_GATT_ITER_CONTINUE;
1168 }
1169
1170
ble_stack_gatt_read(int16_t conn_handle,uint16_t attr_handle,uint16_t offset)1171 int ble_stack_gatt_read(int16_t conn_handle, uint16_t attr_handle, uint16_t offset)
1172 {
1173 int ret = -BLE_STACK_ERR_INTERNAL;
1174 struct bt_conn *conn;
1175 int i;
1176
1177 if (conn_handle < 0) {
1178 return -BLE_STACK_ERR_PARAM;
1179 }
1180
1181 conn = bt_conn_lookup_index(conn_handle);
1182
1183 if (conn == NULL) {
1184 return -BLE_STACK_ERR_CONN;
1185 }
1186
1187 for (i = 0; i < sizeof(ble_param_pool.read_params) / (sizeof(struct bt_gatt_read_params)); i++) {
1188 if (ble_param_pool.read_params[i].func == NULL) {
1189 break;
1190 }
1191 }
1192
1193 if (i == sizeof(ble_param_pool.read_params) / (sizeof(struct bt_gatt_read_params))) {
1194 return -BLE_STACK_ERR_NULL;
1195 }
1196
1197 struct bt_gatt_read_params *params = &ble_param_pool.read_params[i];
1198
1199 params->func = gatt_read_cb;
1200
1201 params->handle_count = 1;
1202
1203 params->single.handle = attr_handle;
1204
1205 params->single.offset = offset;
1206
1207 ret = bt_gatt_read(conn, params);
1208
1209 if (conn) {
1210 bt_conn_unref(conn);
1211 }
1212
1213 return ret;
1214 }
1215
ble_stack_gatt_read_multiple(int16_t conn_handle,uint16_t attr_count,uint16_t attr_handle[])1216 int ble_stack_gatt_read_multiple(int16_t conn_handle, uint16_t attr_count, uint16_t attr_handle[])
1217 {
1218 int ret = -BLE_STACK_ERR_INTERNAL;
1219 //struct bt_gatt_read_params params;
1220 struct bt_conn *conn;
1221 //uint16_t *attr_list;
1222 int i;
1223
1224 if (conn_handle < 0) {
1225 return -BLE_STACK_ERR_PARAM;
1226 }
1227
1228 if (attr_handle == NULL || attr_count <= 1) {
1229 return -BLE_STACK_ERR_PARAM;
1230 }
1231
1232 conn = bt_conn_lookup_index(conn_handle);
1233
1234 if (conn == NULL) {
1235 return -BLE_STACK_ERR_CONN;
1236 }
1237
1238 for (i = 0; i < sizeof(ble_param_pool.read_params) / (sizeof(struct bt_gatt_read_params)); i++) {
1239 if (ble_param_pool.read_params[i].func == NULL) {
1240 break;
1241 }
1242 }
1243
1244 if (i == sizeof(ble_param_pool.read_params) / (sizeof(struct bt_gatt_read_params))) {
1245 return -BLE_STACK_ERR_NULL;
1246 }
1247
1248 struct bt_gatt_read_params *params = &ble_param_pool.read_params[i];
1249
1250 params->func = gatt_read_cb;
1251
1252 params->handle_count = attr_count;
1253
1254 params->handles = attr_handle;
1255
1256 ret = bt_gatt_read(conn, params);
1257
1258 if (conn) {
1259 bt_conn_unref(conn);
1260 }
1261
1262 return ret;
1263 }
1264
ble_stack_get_local_addr(dev_addr_t * addr)1265 int ble_stack_get_local_addr(dev_addr_t *addr)
1266 {
1267 struct bt_le_oob oob;
1268
1269 if (addr == NULL) {
1270 return -BLE_STACK_ERR_NULL;
1271 }
1272
1273 bt_le_oob_get_local(0, &oob);
1274 memcpy(addr, &oob.addr, sizeof(dev_addr_t));
1275
1276 return 0;
1277 }
1278
ble_stack_connect(dev_addr_t * peer_addr,conn_param_t * param,uint8_t auto_connect)1279 int ble_stack_connect(dev_addr_t *peer_addr, conn_param_t *param, uint8_t auto_connect)
1280 {
1281 int ret;
1282 struct bt_conn *conn = NULL;
1283 int16_t conn_handle;
1284 bt_addr_le_t peer;
1285 struct bt_le_conn_param conn_param;
1286
1287 if (peer_addr == NULL) {
1288 return -BLE_STACK_ERR_NULL;
1289 }
1290
1291 #if !defined(CONFIG_BT_WHITELIST)
1292 if (auto_connect) {
1293 return -BLE_STACK_ERR_PARAM;
1294 }
1295 #endif
1296 if (auto_connect > 1) {
1297 return -BLE_STACK_ERR_PARAM;
1298 }
1299
1300 peer = *(bt_addr_le_t *)peer_addr;
1301
1302 if (param) {
1303 conn_param = *(struct bt_le_conn_param *)param;
1304
1305 if (auto_connect) {
1306 #if !defined(CONFIG_BT_WHITELIST)
1307 ret = bt_le_set_auto_conn(&peer, &conn_param);
1308
1309 if (ret) {
1310 return ret;
1311 }
1312
1313 conn = bt_conn_lookup_addr_le(0, &peer);
1314 #endif
1315 } else {
1316 conn = bt_conn_create_le(&peer, &conn_param);
1317 }
1318 } else if (!auto_connect) {
1319 #if !defined(CONFIG_BT_WHITELIST)
1320 ret = bt_le_set_auto_conn(&peer, NULL);
1321
1322 if (ret) {
1323 return ret;
1324 }
1325 #endif
1326 } else {
1327 return -BLE_STACK_ERR_PARAM;
1328 }
1329
1330 if (conn) {
1331 conn_handle = bt_conn_index(conn);
1332 bt_conn_unref(conn);
1333 return conn_handle;
1334 }
1335 (void)ret;
1336 return -BLE_STACK_ERR_CONN;
1337 }
1338
ble_stack_disconnect(int16_t conn_handle)1339 int ble_stack_disconnect(int16_t conn_handle)
1340 {
1341 int ret = -BLE_STACK_ERR_PARAM;
1342
1343 if (conn_handle < 0) {
1344 return -BLE_STACK_ERR_PARAM;
1345 }
1346
1347 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1348
1349 if (conn) {
1350 ret = bt_conn_disconnect(conn, BT_HCI_ERR_REMOTE_USER_TERM_CONN);
1351 bt_conn_unref(conn);
1352 }
1353
1354 return ret;
1355 }
1356
ble_stack_connect_info_get(int16_t conn_handle,connect_info_t * info)1357 int ble_stack_connect_info_get(int16_t conn_handle, connect_info_t *info)
1358 {
1359 if (conn_handle < 0 || NULL == info) {
1360 return -BLE_STACK_ERR_PARAM;
1361 }
1362
1363 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1364
1365 if (conn) {
1366 info->conn_handle = conn_handle;
1367 info->role = conn->role;
1368 info->interval = conn->le.interval;
1369 info->latency = conn->le.latency;
1370 info->timeout = conn->le.timeout;
1371
1372 if (conn->role == BT_HCI_ROLE_MASTER) {
1373 info->local_addr.type = conn->le.init_addr.type;
1374 memcpy(info->local_addr.val, conn->le.init_addr.a.val, 6);
1375 info->peer_addr.type = conn->le.resp_addr.type;
1376 memcpy(info->peer_addr.val, conn->le.resp_addr.a.val, 6);
1377 } else {
1378 info->local_addr.type = conn->le.resp_addr.type;
1379 memcpy(info->local_addr.val, conn->le.resp_addr.a.val, 6);
1380 info->peer_addr.type = conn->le.init_addr.type;
1381 memcpy(info->peer_addr.val, conn->le.init_addr.a.val, 6);
1382 }
1383
1384 bt_conn_unref(conn);
1385 } else {
1386 return -BLE_STACK_ERR_PARAM;
1387 }
1388
1389 return 0;
1390 }
1391
ble_stack_check_conn_params(const conn_param_t * param)1392 int ble_stack_check_conn_params(const conn_param_t *param)
1393 {
1394 if (param->interval_min > param->interval_max ||
1395 param->interval_min < 6 || param->interval_max > 3200) {
1396 return false;
1397 }
1398
1399 if (param->latency > 499) {
1400 return false;
1401 }
1402
1403 if (param->timeout < 10 || param->timeout > 3200 ||
1404 ((4 * param->timeout) <=
1405 ((1 + param->latency) * param->interval_max))) {
1406 return false;
1407 }
1408
1409 return true;
1410 }
1411
ble_stack_security(int16_t conn_handle,security_en level)1412 int ble_stack_security(int16_t conn_handle, security_en level)
1413 {
1414 int ret = -BLE_STACK_ERR_PARAM;
1415 struct bt_conn *conn;
1416
1417 if (conn_handle < 0) {
1418 return ret;
1419 }
1420
1421 conn = bt_conn_lookup_index(conn_handle);
1422
1423 if (conn) {
1424 ret = bt_conn_security(conn, level);
1425 bt_conn_unref(conn);
1426 }
1427
1428 return ret;
1429 }
1430
ble_stack_connect_param_update(int16_t conn_handle,conn_param_t * param)1431 int ble_stack_connect_param_update(int16_t conn_handle, conn_param_t *param)
1432 {
1433 int ret = -BLE_STACK_ERR_PARAM;
1434 struct bt_conn *conn;
1435
1436 if (param == NULL || conn_handle < 0) {
1437 return ret;
1438 }
1439
1440 conn = bt_conn_lookup_index(conn_handle);
1441
1442 if (conn) {
1443 ret = bt_conn_le_param_update(conn, (struct bt_le_conn_param *)param);
1444 bt_conn_unref(conn);
1445 }
1446
1447 return ret;
1448 }
1449
1450
ble_stack_smp_passkey_entry(int16_t conn_handle,uint32_t passkey)1451 int ble_stack_smp_passkey_entry(int16_t conn_handle, uint32_t passkey)
1452 {
1453 int ret = -BLE_STACK_ERR_PARAM;
1454
1455 if (conn_handle < 0) {
1456 return -BLE_STACK_ERR_PARAM;
1457 }
1458
1459 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1460
1461 if (conn) {
1462 ret = bt_conn_auth_passkey_entry(conn, passkey);
1463 bt_conn_unref(conn);
1464 }
1465
1466 return ret;
1467 }
1468
ble_stack_smp_cancel(int16_t conn_handle)1469 int ble_stack_smp_cancel(int16_t conn_handle)
1470 {
1471 int ret = -BLE_STACK_ERR_PARAM;
1472
1473 if (conn_handle < 0) {
1474 return -BLE_STACK_ERR_PARAM;
1475 }
1476
1477 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1478
1479 if (conn) {
1480 ret = bt_conn_auth_cancel(conn);
1481 bt_conn_unref(conn);
1482 }
1483
1484 return ret;
1485 }
1486
ble_stack_smp_passkey_confirm(int16_t conn_handle)1487 int ble_stack_smp_passkey_confirm(int16_t conn_handle)
1488 {
1489 int ret = -BLE_STACK_ERR_PARAM;
1490
1491 if (conn_handle < 0) {
1492 return -BLE_STACK_ERR_PARAM;
1493 }
1494
1495 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1496
1497 if (conn) {
1498 ret = bt_conn_auth_passkey_confirm(conn);
1499 bt_conn_unref(conn);
1500 }
1501
1502 return ret;
1503 }
1504
ble_stack_smp_pairing_confirm(int16_t conn_handle)1505 int ble_stack_smp_pairing_confirm(int16_t conn_handle)
1506 {
1507 int ret = -BLE_STACK_ERR_PARAM;
1508
1509 if (conn_handle < 0) {
1510 return -BLE_STACK_ERR_PARAM;
1511 }
1512
1513 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1514
1515 if (conn) {
1516 ret = bt_conn_auth_pairing_confirm(conn);
1517 bt_conn_unref(conn);
1518 }
1519
1520 return ret;
1521 }
1522
ble_stack_enc_key_size_get(int16_t conn_handle)1523 int ble_stack_enc_key_size_get(int16_t conn_handle)
1524 {
1525 int ret = -BLE_STACK_ERR_PARAM;
1526
1527 if (conn_handle < 0) {
1528 return -BLE_STACK_ERR_PARAM;
1529 }
1530
1531 struct bt_conn *conn = bt_conn_lookup_index(conn_handle);
1532
1533 if (conn) {
1534 #if defined(CONFIG_BT_SMP)
1535 ret = bt_conn_enc_key_size(conn);
1536 #else
1537 ret = 0;
1538 #endif
1539 bt_conn_unref(conn);
1540 }
1541
1542 return ret;
1543 }
1544
ble_stack_setting_load()1545 int ble_stack_setting_load()
1546 {
1547 #ifdef CONFIG_BT_SETTINGS
1548
1549 int ret = 0;
1550 static uint8_t is_setting_loaded = 0;
1551 if (is_setting_loaded)
1552 {
1553 return 0;
1554 }
1555
1556 ret = settings_load();
1557 if (!ret)
1558 {
1559 is_setting_loaded = 1;
1560 }
1561
1562 return ret;
1563 #else
1564 return 0;
1565 #endif
1566 }
1567
ble_stack_dev_unpair(dev_addr_t * peer_addr)1568 int ble_stack_dev_unpair(dev_addr_t *peer_addr)
1569 {
1570 bt_addr_le_t peer;
1571
1572 if (peer_addr == NULL) {
1573 return bt_unpair(0, NULL);
1574 }
1575
1576 peer = *(bt_addr_le_t *)peer_addr;
1577
1578 return bt_unpair(0, &peer);
1579 }
1580
ble_stack_white_list_clear()1581 int ble_stack_white_list_clear()
1582 {
1583 return bt_le_whitelist_clear();
1584 }
1585
ble_stack_white_list_add(dev_addr_t * peer_addr)1586 int ble_stack_white_list_add(dev_addr_t *peer_addr)
1587 {
1588 return bt_le_whitelist_add((bt_addr_le_t *)peer_addr);
1589 }
1590
ble_stack_white_list_remove(dev_addr_t * peer_addr)1591 int ble_stack_white_list_remove(dev_addr_t *peer_addr)
1592 {
1593 return bt_le_whitelist_rem((bt_addr_le_t *)peer_addr);
1594 }
1595
ble_stack_white_list_size()1596 int ble_stack_white_list_size()
1597 {
1598 uint8_t size = 0;
1599 int ret;
1600 ret = bt_le_whitelist_size(&size);
1601
1602 if (ret) {
1603 return -ret;
1604 }
1605
1606 return size;
1607 }
1608
ble_stack_set_name(const char * name)1609 int ble_stack_set_name(const char *name)
1610 {
1611 return bt_set_name(name);
1612 }
1613
uuid_str(uuid_t * uuid)1614 char *uuid_str(uuid_t *uuid)
1615 {
1616 static char uuid_str[37];
1617 uint32_t tmp1, tmp5;
1618 uint16_t tmp0, tmp2, tmp3, tmp4;
1619
1620 switch (uuid->type) {
1621 case UUID_TYPE_16:
1622 snprintf(uuid_str, 37, "%04x", UUID16(uuid));
1623 break;
1624
1625 case UUID_TYPE_32:
1626 snprintf(uuid_str, 37, "%04x", UUID32(uuid));
1627 break;
1628
1629 case UUID_TYPE_128:
1630 memcpy(&tmp0, &UUID128(uuid)[0], sizeof(tmp0));
1631 memcpy(&tmp1, &UUID128(uuid)[2], sizeof(tmp1));
1632 memcpy(&tmp2, &UUID128(uuid)[6], sizeof(tmp2));
1633 memcpy(&tmp3, &UUID128(uuid)[8], sizeof(tmp3));
1634 memcpy(&tmp4, &UUID128(uuid)[10], sizeof(tmp4));
1635 memcpy(&tmp5, &UUID128(uuid)[12], sizeof(tmp5));
1636
1637 snprintf(uuid_str, 37, "%08x-%04x-%04x-%04x-%08x%04x",
1638 tmp5, tmp4, tmp3, tmp2, tmp1, tmp0);
1639 break;
1640
1641 default:
1642 memset(uuid_str, 0, 37);
1643 }
1644
1645 return uuid_str;
1646 }
1647
1648