1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19 #include <stdint.h>
20 #include <stdio.h>
21 #include <assert.h>
22 #include <string.h>
23 #include "os/os.h"
24 #include "nimble/hci_common.h"
25 #include "nimble/ble_hci_trans.h"
26 #include "host/ble_monitor.h"
27 #include "ble_hs_priv.h"
28
29 static void
ble_hs_dbg_le_event_disp(uint8_t subev,uint8_t len,uint8_t * evdata)30 ble_hs_dbg_le_event_disp(uint8_t subev, uint8_t len, uint8_t *evdata)
31 {
32 int8_t rssi;
33 uint8_t advlen;
34 uint8_t status;
35 int i;
36 int imax;
37 uint8_t *dptr;
38 char *adv_ptr;
39 char adv_data_buf[32];
40
41 switch (subev) {
42 case BLE_HCI_LE_SUBEV_ENH_CONN_COMPLETE:
43 case BLE_HCI_LE_SUBEV_CONN_COMPLETE:
44 status = evdata[0];
45 if (status == BLE_ERR_SUCCESS) {
46 BLE_HS_LOG(DEBUG, "LE connection complete. handle=%u role=%u "
47 "paddrtype=%u addr=%x.%x.%x.%x.%x.%x ",
48 get_le16(evdata + 1), evdata[3], evdata[4],
49 evdata[10], evdata[9], evdata[8], evdata[7],
50 evdata[6], evdata[5]);
51
52 evdata += 11;
53 if (subev == BLE_HCI_LE_SUBEV_ENH_CONN_COMPLETE) {
54 BLE_HS_LOG(DEBUG, "local_rpa=%x.%x.%x.%x.%x.%x "
55 "peer_rpa=%x.%x.%x.%x.%x.%x ",
56 evdata[5], evdata[4], evdata[3], evdata[2],
57 evdata[1], evdata[0],
58 evdata[11], evdata[10], evdata[9], evdata[8],
59 evdata[7], evdata[6]);
60
61 evdata += 12;
62 }
63 BLE_HS_LOG(DEBUG, "itvl=%u latency=%u spvn_tmo=%u mca=%u\n",
64 get_le16(evdata), get_le16(evdata + 2),
65 get_le16(evdata + 4), evdata[6]);
66 } else {
67 BLE_HS_LOG(DEBUG, "LE connection complete. FAIL (status=%u)\n",
68 status);
69 }
70 break;
71 case BLE_HCI_LE_SUBEV_ADV_RPT:
72 advlen = evdata[9];
73 rssi = evdata[10 + advlen];
74 BLE_HS_LOG(DEBUG, "LE advertising report. len=%u num=%u evtype=%u "
75 "addrtype=%u addr=%x.%x.%x.%x.%x.%x advlen=%u "
76 "rssi=%d\n", len, evdata[0], evdata[1], evdata[2],
77 evdata[8], evdata[7], evdata[6], evdata[5],
78 evdata[4], evdata[3], advlen, rssi);
79 if (advlen) {
80 dptr = &evdata[10];
81 while (advlen > 0) {
82 memset(adv_data_buf, 0, 32);
83 imax = advlen;
84 if (imax > 8) {
85 imax = 8;
86 }
87 adv_ptr = &adv_data_buf[0];
88 for (i = 0; i < imax; ++i) {
89 snprintf(adv_ptr, 4, "%02x ", *dptr);
90 adv_ptr += 3;
91 ++dptr;
92 }
93 advlen -= imax;
94 BLE_HS_LOG(DEBUG, "%s\n", adv_data_buf);
95 }
96 }
97 break;
98 case BLE_HCI_LE_SUBEV_CONN_UPD_COMPLETE:
99 status = evdata[0];
100 if (status == BLE_ERR_SUCCESS) {
101 BLE_HS_LOG(DEBUG, "LE Connection Update Complete. handle=%u "
102 "itvl=%u latency=%u timeout=%u\n",
103 get_le16(evdata + 1), get_le16(evdata + 3),
104 get_le16(evdata + 5), get_le16(evdata + 7));
105 } else {
106 BLE_HS_LOG(DEBUG, "LE Connection Update Complete. FAIL "
107 "(status=%u)\n", status);
108 }
109 break;
110
111 case BLE_HCI_LE_SUBEV_DATA_LEN_CHG:
112 BLE_HS_LOG(DEBUG, "LE Data Length Change. handle=%u max_tx_bytes=%u "
113 "max_tx_time=%u max_rx_bytes=%u max_rx_time=%u\n",
114 get_le16(evdata), get_le16(evdata + 2),
115 get_le16(evdata + 4), get_le16(evdata + 6),
116 get_le16(evdata + 8));
117 break;
118 case BLE_HCI_LE_SUBEV_REM_CONN_PARM_REQ:
119 BLE_HS_LOG(DEBUG, "LE Remote Connection Parameter Request. handle=%u "
120 "min_itvl=%u max_itvl=%u latency=%u timeout=%u\n",
121 get_le16(evdata), get_le16(evdata + 2),
122 get_le16(evdata + 4), get_le16(evdata + 6),
123 get_le16(evdata + 8));
124 break;
125
126 case BLE_HCI_LE_SUBEV_RD_REM_USED_FEAT:
127 status = evdata[0];
128 if (status == BLE_ERR_SUCCESS) {
129 BLE_HS_LOG(DEBUG, "LE Remote Used Features. handle=%u feat=",
130 get_le16(evdata + 1));
131 for (i = 0; i < BLE_HCI_RD_LOC_SUPP_FEAT_RSPLEN; ++i) {
132 BLE_HS_LOG(DEBUG, "%02x ", evdata[3 + i]);
133 }
134 BLE_HS_LOG(DEBUG, "\n");
135 } else {
136 BLE_HS_LOG(DEBUG, "LE Remote Used Features. FAIL (status=%u)\n",
137 status);
138 }
139 break;
140
141 case BLE_HCI_LE_SUBEV_LT_KEY_REQ:
142 BLE_HS_LOG(DEBUG, "LE LTK Req. handle=%u rand=%lx%lx encdiv=%u\n",
143 get_le16(evdata), get_le32(evdata + 6),
144 get_le32(evdata + 2), get_le16(evdata + 10));
145 break;
146
147 case BLE_HCI_LE_SUBEV_PHY_UPDATE_COMPLETE:
148 BLE_HS_LOG(DEBUG, "PHY update. handle=%u tx=%u rx=%u\n",
149 get_le16(evdata + 1), evdata[3], evdata[4]);
150 break;
151
152 case BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT:
153 {
154 struct hci_le_subev_direct_adv_rpt *data = (void *) evdata;
155 struct hci_le_subev_direct_adv_rpt_param *params = data->params;
156
157 if (len < sizeof(*data) ||
158 len < sizeof(*data) + data->num_reports * sizeof(*params)) {
159 BLE_HS_LOG(DEBUG, "Corrupted LE Directed Advertising Report "
160 "len=%u\n", len);
161 break;
162 }
163
164 BLE_HS_LOG(DEBUG, "LE Directed Advertising Report len=%u "
165 "num=0x%02x ", len, data->num_reports);
166
167 for (i = 0; i < data->num_reports; i++) {
168 BLE_HS_LOG(DEBUG, "[%d]={evttype=0x%02x}\n", i, params->evt_type);
169 params += 1;
170 }
171 break;
172 }
173
174 case BLE_HCI_LE_SUBEV_RD_LOC_P256_PUBKEY:
175 {
176 struct hci_le_subev_rd_loc_p256_pubkey *data = (void *) evdata;
177
178 if (len != sizeof(*data)) {
179 BLE_HS_LOG(DEBUG, "Corrupted LE Read Local P-256 Public Key "
180 "Complete Event len=%u\n", len);
181 break;
182 }
183
184 BLE_HS_LOG(DEBUG, "LE Read Local P-256 Public Key Complete "
185 "len=%u status=0x%02x", len, data->status);
186 break;
187 }
188
189 case BLE_HCI_LE_SUBEV_GEN_DHKEY_COMPLETE:
190 {
191 struct hci_le_subev_gen_dhkey_complete *data = (void *) evdata;
192
193 if (len != sizeof(*data)) {
194 BLE_HS_LOG(DEBUG, "Corrupted LE Generate DHKey Complete "
195 "len=%u\n", len);
196 break;
197 }
198
199 BLE_HS_LOG(DEBUG, "LE Generate DHKey Complete Event len=%u "
200 "status=0x%02x", len, data->status);
201 break;
202 }
203
204 #if MYNEWT_VAL(BLE_EXT_ADV)
205 case BLE_HCI_LE_SUBEV_EXT_ADV_RPT:
206 {
207 struct hci_le_subev_ext_adv_rpt *data = (void *) evdata;
208 struct hci_ext_adv_report_param *params;
209
210 if (len < sizeof(*data) + sizeof(*params)) {
211 BLE_HS_LOG(DEBUG, "Corrupted LE Extended Advertising Report "
212 "len=%u\n", len);
213 break;
214 }
215
216 BLE_HS_LOG(DEBUG, "LE Extended Advertising Report len=%u num=0x%02x ",
217 len, data->num_reports);
218
219 for (i = 0, dptr = &evdata[1]; i < data->num_reports; i++) {
220 params = (void *) dptr;
221 BLE_HS_LOG(DEBUG, "[%d]={evttype=0x%04x advlen=%u}\n",
222 i, le16toh(params->evt_type), params->adv_data_len);
223 dptr += sizeof(*params) + params->adv_data_len;
224 }
225 break;
226 }
227
228 case BLE_HCI_LE_SUBEV_PER_ADV_SYNC_ESTAB:
229 {
230 struct hci_le_subev_per_adv_sync_estab *data = (void *) evdata;
231
232 if (len != sizeof(*data)) {
233 BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Sync "
234 "Established len=%u\n", len);
235 break;
236 }
237
238 BLE_HS_LOG(DEBUG, "LE Periodic Advertising Sync Established "
239 "len=%u status=0x%02x handle=0x%04x", len, data->status,
240 le16toh(data->sync_handle));
241 break;
242 }
243
244 case BLE_HCI_LE_SUBEV_PER_ADV_RPT:
245 {
246 struct hci_le_subev_per_adv_rpt *data = (void *) evdata;
247
248 if (len < sizeof(*data) || len != sizeof(*data) + data->data_length) {
249 BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Report "
250 "len=%u\n", len);
251 break;
252 }
253
254 BLE_HS_LOG(DEBUG, "LE Periodic Advertising Report "
255 "len=%u handle=0x%04x data_status=0x%02x data_len=0x%02x",
256 len, le16toh(data->sync_handle), data->data_status,
257 data->data_length);
258 break;
259 }
260
261 case BLE_HCI_LE_SUBEV_PER_ADV_SYNC_LOST:
262 {
263 struct hci_le_subev_per_adv_sync_lost *data = (void *) evdata;
264
265 if (len != sizeof(*data)) {
266 BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Sync Lost "
267 "len=%u\n", len);
268 break;
269 }
270
271 BLE_HS_LOG(DEBUG, "LE Periodic Advertising Sync Lost "
272 "len=%u handle=0x%04x", len, le16toh(data->sync_handle));
273 break;
274 }
275
276 case BLE_HCI_LE_SUBEV_SCAN_TIMEOUT:
277 if (len) {
278 BLE_HS_LOG(DEBUG, "Corrupted LE Scan Timeout len=%u", len);
279 break;
280 }
281
282 BLE_HS_LOG(DEBUG, "LE Scan Timeout Event len=%u", len);
283 break;
284
285 case BLE_HCI_LE_SUBEV_ADV_SET_TERMINATED:
286 {
287 struct hci_le_subev_adv_set_terminated *data = (void *) evdata;
288
289 if (len != sizeof(*data)) {
290 BLE_HS_LOG(DEBUG, "Corrupted LE Advertising Set Terminated "
291 "len=%u\n", len);
292 break;
293 }
294
295 BLE_HS_LOG(DEBUG, "LE Advertising Set Terminated len=%u "
296 "status=0x%02x adv_handle=0x%02x conn_handle=0x%04x "
297 "num_compl_ext_adv_ev=0x%02x", len, data->adv_handle,
298 le16toh(data->conn_handle), data->num_compl_ext_adv_ev);
299 break;
300 }
301
302 case BLE_HCI_LE_SUBEV_SCAN_REQ_RCVD:
303 {
304 struct hci_le_subev_scan_req_rcvd *data = (void *) evdata;
305
306 if (len != sizeof(*data)) {
307 BLE_HS_LOG(DEBUG, "Corrupted LE Scan Request Received "
308 "len=%u\n", len);
309 break;
310 }
311
312 BLE_HS_LOG(DEBUG, "LE Scan Request Received len=%u "
313 "adv_handle=0x%02x", len, data->adv_handle);
314 break;
315 }
316 #endif /* MYNEWT_VAL(BLE_EXT_ADV) */
317
318 case BLE_HCI_LE_SUBEV_CHAN_SEL_ALG:
319 {
320 struct hci_le_subev_chan_sel_alg *data = (void *) evdata;
321
322 if (len != sizeof(*data)) {
323 BLE_HS_LOG(DEBUG, "Corrupted LE Channel Selection Algorithm "
324 "len=%u\n", len);
325 break;
326 }
327
328 BLE_HS_LOG(DEBUG, "LE Channel Selection Algorithm len=%u "
329 "conn_handle=0x%04x chan_sel_alg=0x%02x", len,
330 le16toh(data->conn_handle), data->chan_sel_alg);
331 break;
332 }
333
334 default:
335 BLE_HS_LOG(DEBUG, "LE Meta SubEvent op=0x%02x\n", subev);
336 break;
337 }
338 }
339
340 /**
341 * Display a disconnection complete command.
342 *
343 *
344 * @param evdata
345 * @param len
346 */
347 static void
ble_hs_dbg_disconn_comp_disp(uint8_t * evdata,uint8_t len)348 ble_hs_dbg_disconn_comp_disp(uint8_t *evdata, uint8_t len)
349 {
350 uint8_t status;
351 uint8_t reason;
352 uint16_t handle;
353
354 status = evdata[0];
355 handle = get_le16(evdata + 1);
356 /* Ignore reason if status is not success */
357 if (status != BLE_ERR_SUCCESS) {
358 reason = 0;
359 } else {
360 reason = evdata[3];
361 }
362 BLE_HS_LOG(DEBUG, "Disconnection Complete: status=%u handle=%u "
363 "reason=%u\n", status, handle, reason);
364 }
365
366 /**
367 * Display an encryption change event or encryption key refresh event
368 *
369 * @param evdata
370 * @param len
371 */
372 static void
ble_hs_dbg_encrypt_chg_disp(uint8_t * evdata,uint8_t len)373 ble_hs_dbg_encrypt_chg_disp(uint8_t *evdata, uint8_t len)
374 {
375 uint8_t status;
376 uint8_t enabled;
377 uint16_t handle;
378
379 status = evdata[0];
380 handle = get_le16(evdata + 1);
381
382 /* Ignore reason if status is not success */
383 if (status != BLE_ERR_SUCCESS) {
384 enabled = 0;
385 } else {
386 enabled = evdata[3];
387 }
388 BLE_HS_LOG(DEBUG, "Encrypt change: status=%u handle=%u state=%u\n",
389 status, handle, enabled);
390 }
391
392 /**
393 * Display an encryption encryption key refresh event
394 *
395 * @param evdata
396 * @param len
397 */
398 static void
ble_hs_dbg_encrypt_refresh_disp(uint8_t * evdata,uint8_t len)399 ble_hs_dbg_encrypt_refresh_disp(uint8_t *evdata, uint8_t len)
400 {
401 uint8_t status;
402 uint16_t handle;
403
404 status = evdata[0];
405 handle = get_le16(evdata + 1);
406
407 BLE_HS_LOG(DEBUG, "Encrypt key refresh: status=%u handle=%u\n",
408 status, handle);
409 }
410
411 /**
412 * Display a version information event
413 *
414 * @param evdata
415 * @param len
416 */
417 static void
ble_hs_dbg_rd_rem_ver_disp(uint8_t * evdata,uint8_t len)418 ble_hs_dbg_rd_rem_ver_disp(uint8_t *evdata, uint8_t len)
419 {
420 BLE_HS_LOG(DEBUG, "Remote Version Info: status=%u handle=%u vers_nr=%u "
421 "compid=%u subver=%u\n",
422 evdata[0], get_le16(evdata + 1), evdata[3],
423 get_le16(evdata + 4), get_le16(evdata + 6));
424 }
425
426 /**
427 * Display the number of completed packets event
428 *
429 * @param evdata
430 * @param len
431 */
432 static void
ble_hs_dbg_num_comp_pkts_disp(uint8_t * evdata,uint8_t len)433 ble_hs_dbg_num_comp_pkts_disp(uint8_t *evdata, uint8_t len)
434 {
435 uint8_t handles;
436 uint8_t *handle_ptr;
437 uint16_t handle;
438 uint16_t pkts;
439
440 handles = evdata[0];
441 if (len != ((handles * 4) + 1)) {
442 BLE_HS_LOG(DEBUG, "ERR: Number of Completed Packets bad length: "
443 "num_handles=%u len=%u\n", handles, len);
444 return;
445
446 }
447
448 BLE_HS_LOG(DEBUG, "Number of Completed Packets: num_handles=%u\n",
449 handles);
450 if (handles) {
451 handle_ptr = evdata + 1;
452 while (handles) {
453 handle = get_le16(handle_ptr);
454 pkts = get_le16(handle_ptr + 2);
455 handle_ptr += 4;
456 BLE_HS_LOG(DEBUG, "handle:%u pkts:%u\n", handle, pkts);
457 --handles;
458 }
459 }
460 }
461
462 /**
463 * Display the authenticated payload timeout event
464 *
465 * @param evdata
466 * @param len
467 */
468 static void
ble_hs_dbg_auth_pyld_tmo_disp(uint8_t * evdata,uint8_t len)469 ble_hs_dbg_auth_pyld_tmo_disp(uint8_t *evdata, uint8_t len)
470 {
471 uint16_t handle;
472
473 if (len != sizeof(uint16_t)) {
474 BLE_HS_LOG(DEBUG, "ERR: AuthPyldTmoEvent bad length %u\n", len);
475 return;
476
477 }
478
479 handle = get_le16(evdata);
480 BLE_HS_LOG(DEBUG, "AuthPyldTmo: handle=%u\n", handle);
481 }
482
483
484 static void
ble_hs_dbg_cmd_comp_info_params(uint8_t status,uint8_t ocf,uint8_t * evdata)485 ble_hs_dbg_cmd_comp_info_params(uint8_t status, uint8_t ocf, uint8_t *evdata)
486 {
487 int i;
488 uint8_t *dptr;
489
490 if (status != BLE_ERR_SUCCESS) {
491 return;
492 }
493
494 switch (ocf) {
495 case BLE_HCI_OCF_IP_RD_LOCAL_VER:
496 BLE_HS_LOG(DEBUG, "hci_ver=%u hci_rev=%u lmp_ver=%u mfrg=%u "
497 "lmp_subver=%u",
498 evdata[0], get_le16(evdata + 1), evdata[3],
499 get_le16(evdata + 4), get_le16(evdata + 6));
500 break;
501 case BLE_HCI_OCF_IP_RD_LOC_SUPP_CMD:
502 BLE_HS_LOG(DEBUG, "supp_cmds=");
503 dptr = evdata;
504 for (i = 0; i < 8; ++i) {
505 BLE_HS_LOG(DEBUG, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:",
506 dptr[0], dptr[1], dptr[2], dptr[3],
507 dptr[4], dptr[5], dptr[6], dptr[7]);
508 dptr += 8;
509 }
510 break;
511 case BLE_HCI_OCF_IP_RD_LOC_SUPP_FEAT:
512 BLE_HS_LOG(DEBUG, "supp_feat=0x%lx%08lx",
513 get_le32(evdata + 4), get_le32(evdata));
514 break;
515 case BLE_HCI_OCF_IP_RD_BD_ADDR:
516 BLE_HS_LOG(DEBUG, "bd_addr=%x:%x:%x:%x:%x:%x",
517 evdata[5], evdata[4], evdata[3],
518 evdata[2], evdata[1], evdata[0]);
519 break;
520 default:
521 break;
522 }
523 }
524
525 static void
ble_hs_dbg_cmd_complete_disp(uint8_t * evdata,uint8_t len)526 ble_hs_dbg_cmd_complete_disp(uint8_t *evdata, uint8_t len)
527 {
528 uint8_t cmd_pkts;
529 uint8_t ogf;
530 uint8_t ocf;
531 uint8_t status;
532 uint16_t opcode;
533
534 if (len < 3) {
535 BLE_HS_LOG(DEBUG, "Invalid command complete: len=%d "
536 "(expected >= 3)", len);
537 goto done;
538 }
539
540 cmd_pkts = evdata[0];
541 opcode = get_le16(evdata + 1);
542 ogf = BLE_HCI_OGF(opcode);
543 ocf = BLE_HCI_OCF(opcode);
544
545 BLE_HS_LOG(DEBUG, "Command complete: cmd_pkts=%u ogf=0x%x ocf=0x%x",
546 cmd_pkts, ogf, ocf);
547
548 if (len == 3) {
549 goto done;
550 }
551
552 status = evdata[3];
553 BLE_HS_LOG(DEBUG, " status=%u ", status);
554
555 /* Move past header and status */
556 evdata += 4;
557
558 /* Display parameters based on command. */
559 switch (ogf) {
560 case BLE_HCI_OGF_INFO_PARAMS:
561 ble_hs_dbg_cmd_comp_info_params(status, ocf, evdata);
562 break;
563 case BLE_HCI_OGF_STATUS_PARAMS:
564 switch (ocf) {
565 case BLE_HCI_OCF_RD_RSSI:
566 BLE_HS_LOG(DEBUG, "handle=%u rssi=%d", get_le16(evdata),
567 (int8_t)evdata[2]);
568 break;
569 default:
570 break;
571 }
572 break;
573 case BLE_HCI_OGF_LE:
574 switch (ocf) {
575 case BLE_HCI_OCF_LE_RD_CHAN_MAP:
576 BLE_HS_LOG(DEBUG, "handle=%u chanmap=%x.%x.%x.%x.%x",
577 get_le16(evdata), evdata[2], evdata[3], evdata[4],
578 evdata[5], evdata[6]);
579 break;
580 case BLE_HCI_OCF_LE_RD_MAX_DATA_LEN:
581 BLE_HS_LOG(DEBUG, "txoct=%u txtime=%u rxoct=%u rxtime=%u",
582 get_le16(evdata), get_le16(evdata + 2),
583 get_le16(evdata + 4), get_le16(evdata + 6));
584 break;
585 case BLE_HCI_OCF_LE_RD_SUPP_STATES:
586 BLE_HS_LOG(DEBUG, "states=0x%lx%08lx", get_le32(evdata + 4),
587 get_le32(evdata));
588 break;
589 case BLE_HCI_OCF_LE_ENCRYPT:
590 BLE_HS_LOG(DEBUG, "encdata=0x%02x%02x%02x%02x%02x%02x%02x%02x",
591 evdata[15], evdata[14], evdata[13], evdata[12],
592 evdata[11], evdata[10], evdata[9], evdata[8]);
593 BLE_HS_LOG(DEBUG, "%02x%02x%02x%02x%02x%02x%02x%02x",
594 evdata[7], evdata[6], evdata[5], evdata[4],
595 evdata[3], evdata[2], evdata[1], evdata[0]);
596
597 break;
598 case BLE_HCI_OCF_LE_RAND:
599 BLE_HS_LOG(DEBUG, "rand=0x%02x%02x%02x%02x%02x%02x%02x%02x",
600 evdata[0], evdata[1], evdata[2], evdata[3],
601 evdata[4], evdata[5], evdata[6], evdata[7]);
602 break;
603 case BLE_HCI_OCF_LE_RD_SUGG_DEF_DATA_LEN:
604 BLE_HS_LOG(DEBUG, "txoct=%u txtime=%u", get_le16(evdata),
605 get_le16(evdata + 2));
606 break;
607 case BLE_HCI_OCF_LE_LT_KEY_REQ_REPLY:
608 case BLE_HCI_OCF_LE_LT_KEY_REQ_NEG_REPLY:
609 case BLE_HCI_OCF_LE_SET_DATA_LEN:
610 BLE_HS_LOG(DEBUG, "handle=%u", get_le16(evdata));
611 break;
612 default:
613 break;
614 }
615 break;
616 default:
617 break;
618 }
619
620 done:
621 BLE_HS_LOG(DEBUG, "\n");
622 }
623
624 static void
ble_hs_dbg_cmd_status_disp(uint8_t * evdata,uint8_t len)625 ble_hs_dbg_cmd_status_disp(uint8_t *evdata, uint8_t len)
626 {
627 uint8_t ogf;
628 uint8_t ocf;
629 uint16_t opcode;
630
631 opcode = get_le16(evdata + 2);
632 ogf = BLE_HCI_OGF(opcode);
633 ocf = BLE_HCI_OCF(opcode);
634
635 BLE_HS_LOG(DEBUG, "Command Status: status=%u cmd_pkts=%u ocf=0x%x "
636 "ogf=0x%x\n", evdata[0], evdata[1], ocf, ogf);
637 }
638
639 void
ble_hs_dbg_event_disp(uint8_t * evbuf)640 ble_hs_dbg_event_disp(uint8_t *evbuf)
641 {
642 #if MYNEWT_VAL(LOG_LEVEL) > LOG_LEVEL_DEBUG || BLE_MONITOR
643 return;
644 #endif
645
646 uint8_t *evdata;
647 uint8_t evcode;
648 uint8_t len;
649
650 /* Extract event code and length; move pointer to event parameter data */
651 evcode = evbuf[0];
652 len = evbuf[1];
653 evdata = evbuf + BLE_HCI_EVENT_HDR_LEN;
654
655 switch (evcode) {
656 case BLE_HCI_EVCODE_DISCONN_CMP:
657 ble_hs_dbg_disconn_comp_disp(evdata, len);
658 break;
659 case BLE_HCI_EVCODE_ENC_KEY_REFRESH:
660 ble_hs_dbg_encrypt_refresh_disp(evdata, len);
661 break;
662 case BLE_HCI_EVCODE_ENCRYPT_CHG:
663 ble_hs_dbg_encrypt_chg_disp(evdata, len);
664 break;
665 case BLE_HCI_EVCODE_RD_REM_VER_INFO_CMP:
666 ble_hs_dbg_rd_rem_ver_disp(evdata, len);
667 break;
668 case BLE_HCI_EVCODE_COMMAND_COMPLETE:
669 ble_hs_dbg_cmd_complete_disp(evdata, len);
670 break;
671 case BLE_HCI_EVCODE_COMMAND_STATUS:
672 ble_hs_dbg_cmd_status_disp(evdata, len);
673 break;
674 case BLE_HCI_EVCODE_NUM_COMP_PKTS:
675 ble_hs_dbg_num_comp_pkts_disp(evdata, len);
676 break;
677 case BLE_HCI_EVCODE_LE_META:
678 ble_hs_dbg_le_event_disp(evdata[0], len-1, evdata + 1);
679 break;
680 case BLE_HCI_EVCODE_AUTH_PYLD_TMO:
681 ble_hs_dbg_auth_pyld_tmo_disp(evdata, len);
682 break;
683 default:
684 BLE_HS_LOG(DEBUG, "Unknown event 0x%x len=%u\n", evcode, len);
685 break;
686 }
687 }
688
689 void
ble_hs_dbg_set_sync_state(uint8_t sync_state)690 ble_hs_dbg_set_sync_state(uint8_t sync_state)
691 {
692 ble_hs_sync_state = sync_state;
693 }
694