/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "os/os.h"
#include "nimble/hci_common.h"
#include "nimble/ble_hci_trans.h"
#include "host/ble_monitor.h"
#include "ble_hs_priv.h"

static void
ble_hs_dbg_le_event_disp(uint8_t subev, uint8_t len, uint8_t *evdata)
{
    int8_t rssi;
    uint8_t advlen;
    uint8_t status;
    int i;
    int imax;
    uint8_t *dptr;
    char *adv_ptr;
    char adv_data_buf[32];

    switch (subev) {
    case BLE_HCI_LE_SUBEV_ENH_CONN_COMPLETE:
    case BLE_HCI_LE_SUBEV_CONN_COMPLETE:
        status = evdata[0];
        if (status == BLE_ERR_SUCCESS) {
            BLE_HS_LOG(DEBUG, "LE connection complete. handle=%u role=%u "
                              "paddrtype=%u addr=%x.%x.%x.%x.%x.%x ",
                       get_le16(evdata + 1), evdata[3], evdata[4],
                       evdata[10], evdata[9], evdata[8], evdata[7],
                       evdata[6], evdata[5]);

            evdata += 11;
            if (subev == BLE_HCI_LE_SUBEV_ENH_CONN_COMPLETE) {
                BLE_HS_LOG(DEBUG, "local_rpa=%x.%x.%x.%x.%x.%x "
                                   "peer_rpa=%x.%x.%x.%x.%x.%x ",
                           evdata[5], evdata[4], evdata[3], evdata[2],
                           evdata[1], evdata[0],
                           evdata[11], evdata[10], evdata[9], evdata[8],
                           evdata[7], evdata[6]);

                evdata += 12;
            }
            BLE_HS_LOG(DEBUG, "itvl=%u latency=%u spvn_tmo=%u mca=%u\n",
                       get_le16(evdata), get_le16(evdata + 2),
                       get_le16(evdata + 4), evdata[6]);
        } else {
            BLE_HS_LOG(DEBUG, "LE connection complete. FAIL (status=%u)\n",
                       status);
        }
        break;
    case BLE_HCI_LE_SUBEV_ADV_RPT:
        advlen = evdata[9];
        rssi = evdata[10 + advlen];
        BLE_HS_LOG(DEBUG, "LE advertising report. len=%u num=%u evtype=%u "
                          "addrtype=%u addr=%x.%x.%x.%x.%x.%x advlen=%u "
                          "rssi=%d\n", len, evdata[0], evdata[1], evdata[2],
                   evdata[8], evdata[7], evdata[6], evdata[5],
                   evdata[4], evdata[3], advlen, rssi);
        if (advlen) {
            dptr = &evdata[10];
            while (advlen > 0) {
                memset(adv_data_buf, 0, 32);
                imax = advlen;
                if (imax > 8) {
                    imax = 8;
                }
                adv_ptr = &adv_data_buf[0];
                for (i = 0; i < imax; ++i) {
                    snprintf(adv_ptr, 4, "%02x ", *dptr);
                    adv_ptr += 3;
                    ++dptr;
                }
                advlen -= imax;
                BLE_HS_LOG(DEBUG, "%s\n", adv_data_buf);
            }
        }
        break;
    case BLE_HCI_LE_SUBEV_CONN_UPD_COMPLETE:
        status = evdata[0];
        if (status == BLE_ERR_SUCCESS) {
            BLE_HS_LOG(DEBUG, "LE Connection Update Complete. handle=%u "
                              "itvl=%u latency=%u timeout=%u\n",
                       get_le16(evdata + 1), get_le16(evdata + 3),
                       get_le16(evdata + 5), get_le16(evdata + 7));
        } else {
            BLE_HS_LOG(DEBUG, "LE Connection Update Complete. FAIL "
                              "(status=%u)\n", status);
        }
        break;

    case BLE_HCI_LE_SUBEV_DATA_LEN_CHG:
        BLE_HS_LOG(DEBUG, "LE Data Length Change. handle=%u max_tx_bytes=%u "
                          "max_tx_time=%u max_rx_bytes=%u max_rx_time=%u\n",
                   get_le16(evdata), get_le16(evdata + 2),
                   get_le16(evdata + 4), get_le16(evdata + 6),
                   get_le16(evdata + 8));
        break;
    case BLE_HCI_LE_SUBEV_REM_CONN_PARM_REQ:
        BLE_HS_LOG(DEBUG, "LE Remote Connection Parameter Request. handle=%u "
                          "min_itvl=%u max_itvl=%u latency=%u timeout=%u\n",
                   get_le16(evdata), get_le16(evdata + 2),
                   get_le16(evdata + 4), get_le16(evdata + 6),
                   get_le16(evdata + 8));
        break;

    case BLE_HCI_LE_SUBEV_RD_REM_USED_FEAT:
        status = evdata[0];
        if (status == BLE_ERR_SUCCESS) {
            BLE_HS_LOG(DEBUG, "LE Remote Used Features. handle=%u feat=",
                       get_le16(evdata + 1));
            for (i = 0; i < BLE_HCI_RD_LOC_SUPP_FEAT_RSPLEN; ++i) {
                BLE_HS_LOG(DEBUG, "%02x ", evdata[3 + i]);
            }
            BLE_HS_LOG(DEBUG, "\n");
        } else {
            BLE_HS_LOG(DEBUG, "LE Remote Used Features. FAIL (status=%u)\n",
                       status);
        }
        break;

    case BLE_HCI_LE_SUBEV_LT_KEY_REQ:
            BLE_HS_LOG(DEBUG, "LE LTK Req. handle=%u rand=%lx%lx encdiv=%u\n",
                       get_le16(evdata), get_le32(evdata + 6),
                       get_le32(evdata + 2), get_le16(evdata + 10));
        break;

    case BLE_HCI_LE_SUBEV_PHY_UPDATE_COMPLETE:
            BLE_HS_LOG(DEBUG, "PHY update. handle=%u tx=%u rx=%u\n",
                       get_le16(evdata + 1), evdata[3], evdata[4]);
        break;

    case BLE_HCI_LE_SUBEV_DIRECT_ADV_RPT:
    {
        struct hci_le_subev_direct_adv_rpt *data = (void *) evdata;
        struct hci_le_subev_direct_adv_rpt_param *params = data->params;

        if (len < sizeof(*data) ||
                len < sizeof(*data) + data->num_reports * sizeof(*params)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Directed Advertising Report "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Directed Advertising Report len=%u "
                   "num=0x%02x ", len, data->num_reports);

        for (i = 0; i < data->num_reports; i++) {
            BLE_HS_LOG(DEBUG, "[%d]={evttype=0x%02x}\n", i, params->evt_type);
            params += 1;
        }
        break;
    }

    case BLE_HCI_LE_SUBEV_RD_LOC_P256_PUBKEY:
    {
        struct hci_le_subev_rd_loc_p256_pubkey *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Read Local P-256 Public Key "
                       "Complete Event len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Read Local P-256 Public Key Complete "
                   "len=%u status=0x%02x\n", len, data->status);
        break;
    }

    case BLE_HCI_LE_SUBEV_GEN_DHKEY_COMPLETE:
    {
        struct hci_le_subev_gen_dhkey_complete *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Generate DHKey Complete "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Generate DHKey Complete Event len=%u "
                   "status=0x%02x\n", len, data->status);
        break;
    }

#if MYNEWT_VAL(BLE_EXT_ADV)
    case BLE_HCI_LE_SUBEV_EXT_ADV_RPT:
    {
        struct hci_le_subev_ext_adv_rpt *data = (void *) evdata;
        struct hci_ext_adv_report_param *params;

        if (len < sizeof(*data) + sizeof(*params)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Extended Advertising Report "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Extended Advertising Report len=%u num=0x%02x ",
                   len, data->num_reports);

        for (i = 0, dptr = &evdata[1]; i < data->num_reports;  i++) {
            params = (void *) dptr;
            BLE_HS_LOG(DEBUG, "[%d]={evttype=0x%04x advlen=%u}\n",
                       i, le16toh(params->evt_type), params->adv_data_len);
            dptr += sizeof(*params) + params->adv_data_len;
        }
        break;
    }

    case BLE_HCI_LE_SUBEV_PER_ADV_SYNC_ESTAB:
    {
        struct hci_le_subev_per_adv_sync_estab *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Sync "
                       "Established len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Periodic Advertising Sync Established "
                   "len=%u status=0x%02x handle=0x%04x", len, data->status,
                   le16toh(data->sync_handle));
        break;
    }

    case BLE_HCI_LE_SUBEV_PER_ADV_RPT:
    {
        struct hci_le_subev_per_adv_rpt *data = (void *) evdata;

        if (len < sizeof(*data) || len != sizeof(*data) + data->data_length) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Report "
                    "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Periodic Advertising Report "
                   "len=%u handle=0x%04x data_status=0x%02x data_len=0x%02x",
                   len, le16toh(data->sync_handle), data->data_status,
                   data->data_length);
        break;
    }

    case BLE_HCI_LE_SUBEV_PER_ADV_SYNC_LOST:
    {
        struct hci_le_subev_per_adv_sync_lost *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Periodic Advertising Sync Lost "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Periodic Advertising Sync Lost "
                   "len=%u handle=0x%04x", len, le16toh(data->sync_handle));
        break;
    }

    case BLE_HCI_LE_SUBEV_SCAN_TIMEOUT:
        if (len) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Scan Timeout len=%u", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Scan Timeout Event len=%u", len);
        break;

    case BLE_HCI_LE_SUBEV_ADV_SET_TERMINATED:
    {
        struct hci_le_subev_adv_set_terminated *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Advertising Set Terminated "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Advertising Set Terminated len=%u "
                   "status=0x%02x adv_handle=0x%02x conn_handle=0x%04x "
                   "num_compl_ext_adv_ev=0x%02x", len, data->adv_handle,
                   le16toh(data->conn_handle), data->num_compl_ext_adv_ev);
        break;
    }

    case BLE_HCI_LE_SUBEV_SCAN_REQ_RCVD:
    {
        struct hci_le_subev_scan_req_rcvd *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Scan Request Received "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Scan Request Received len=%u "
                   "adv_handle=0x%02x", len, data->adv_handle);
        break;
    }
#endif /* MYNEWT_VAL(BLE_EXT_ADV) */

    case BLE_HCI_LE_SUBEV_CHAN_SEL_ALG:
    {
        struct hci_le_subev_chan_sel_alg *data = (void *) evdata;

        if (len != sizeof(*data)) {
            BLE_HS_LOG(DEBUG, "Corrupted LE Channel Selection Algorithm "
                       "len=%u\n", len);
            break;
        }

        BLE_HS_LOG(DEBUG, "LE Channel Selection Algorithm len=%u "
                   "conn_handle=0x%04x chan_sel_alg=0x%02x\n", len,
                   le16toh(data->conn_handle), data->chan_sel_alg);
        break;
    }

    default:
        BLE_HS_LOG(DEBUG, "LE Meta SubEvent op=0x%02x\n", subev);
        break;
    }
}

/**
 * Display a disconnection complete command.
 *
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_disconn_comp_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t status;
    uint8_t reason;
    uint16_t handle;

    status = evdata[0];
    handle = get_le16(evdata + 1);
    /* Ignore reason if status is not success */
    if (status != BLE_ERR_SUCCESS) {
        reason = 0;
    } else {
        reason = evdata[3];
    }
    BLE_HS_LOG(DEBUG, "Disconnection Complete: status=%u handle=%u "
                      "reason=%u\n", status, handle, reason);
}

/**
 * Display an encryption change event or encryption key refresh event
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_encrypt_chg_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t status;
    uint8_t enabled;
    uint16_t handle;

    status = evdata[0];
    handle = get_le16(evdata + 1);

    /* Ignore reason if status is not success */
    if (status != BLE_ERR_SUCCESS) {
        enabled = 0;
    } else {
        enabled = evdata[3];
    }
    BLE_HS_LOG(DEBUG, "Encrypt change: status=%u handle=%u state=%u\n",
               status, handle, enabled);
}

/**
 * Display an encryption encryption key refresh event
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_encrypt_refresh_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t status;
    uint16_t handle;

    status = evdata[0];
    handle = get_le16(evdata + 1);

    BLE_HS_LOG(DEBUG, "Encrypt key refresh: status=%u handle=%u\n",
               status, handle);
}

/**
 * Display a version information event
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_rd_rem_ver_disp(uint8_t *evdata, uint8_t len)
{
    BLE_HS_LOG(DEBUG, "Remote Version Info: status=%u handle=%u vers_nr=%u "
                      "compid=%u subver=%u\n",
               evdata[0], get_le16(evdata + 1), evdata[3],
               get_le16(evdata + 4), get_le16(evdata + 6));
}

/**
 * Display the number of completed packets event
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_num_comp_pkts_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t handles;
    uint8_t *handle_ptr;
    uint16_t handle;
    uint16_t pkts;

    handles = evdata[0];
    if (len != ((handles * 4) + 1)) {
        BLE_HS_LOG(DEBUG, "ERR: Number of Completed Packets bad length: "
                          "num_handles=%u len=%u\n", handles, len);
        return;

    }

    BLE_HS_LOG(DEBUG, "Number of Completed Packets: num_handles=%u\n",
               handles);
    if (handles) {
        handle_ptr = evdata + 1;
        while (handles) {
            handle = get_le16(handle_ptr);
            pkts = get_le16(handle_ptr + 2);
            handle_ptr += 4;
            BLE_HS_LOG(DEBUG, "handle:%u pkts:%u\n", handle, pkts);
            --handles;
        }
    }
}

/**
 * Display the authenticated payload timeout event
 *
 * @param evdata
 * @param len
 */
static void
ble_hs_dbg_auth_pyld_tmo_disp(uint8_t *evdata, uint8_t len)
{
    uint16_t handle;

    if (len != sizeof(uint16_t)) {
        BLE_HS_LOG(DEBUG, "ERR: AuthPyldTmoEvent bad length %u\n", len);
        return;

    }

    handle = get_le16(evdata);
    BLE_HS_LOG(DEBUG, "AuthPyldTmo: handle=%u\n", handle);
}


static void
ble_hs_dbg_cmd_comp_info_params(uint8_t status, uint8_t ocf, uint8_t *evdata)
{
    int i;
    uint8_t *dptr;

    if (status != BLE_ERR_SUCCESS) {
        return;
    }

    switch (ocf) {
    case BLE_HCI_OCF_IP_RD_LOCAL_VER:
        BLE_HS_LOG(DEBUG, "hci_ver=%u hci_rev=%u lmp_ver=%u mfrg=%u "
                          "lmp_subver=%u",
                   evdata[0], get_le16(evdata + 1), evdata[3],
                   get_le16(evdata + 4), get_le16(evdata + 6));
        break;
    case BLE_HCI_OCF_IP_RD_LOC_SUPP_CMD:
        BLE_HS_LOG(DEBUG, "supp_cmds=");
        dptr = evdata;
        for (i = 0; i < 8; ++i) {
            BLE_HS_LOG(DEBUG, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:",
                       dptr[0], dptr[1], dptr[2], dptr[3],
                       dptr[4], dptr[5], dptr[6], dptr[7]);
            dptr += 8;
        }
        break;
    case BLE_HCI_OCF_IP_RD_LOC_SUPP_FEAT:
        BLE_HS_LOG(DEBUG, "supp_feat=0x%lx%08lx",
                   get_le32(evdata + 4), get_le32(evdata));
        break;
    case BLE_HCI_OCF_IP_RD_BD_ADDR:
        BLE_HS_LOG(DEBUG, "bd_addr=%x:%x:%x:%x:%x:%x",
                   evdata[5], evdata[4], evdata[3],
                   evdata[2], evdata[1], evdata[0]);
        break;
    default:
        break;
    }
}

static void
ble_hs_dbg_cmd_complete_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t cmd_pkts;
    uint8_t ogf;
    uint8_t ocf;
    uint8_t status;
    uint16_t opcode;

    if (len < 3) {
        BLE_HS_LOG(DEBUG, "Invalid command complete: len=%d "
                          "(expected >= 3)", len);
        goto done;
    }

    cmd_pkts = evdata[0];
    opcode = get_le16(evdata + 1);
    ogf = BLE_HCI_OGF(opcode);
    ocf = BLE_HCI_OCF(opcode);

    BLE_HS_LOG(DEBUG, "Command complete: cmd_pkts=%u ogf=0x%x ocf=0x%x",
               cmd_pkts, ogf, ocf);

    if (len == 3) {
        goto done;
    }

    status = evdata[3];
    BLE_HS_LOG(DEBUG, " status=%u ", status);

    /* Move past header and status */
    evdata += 4;

    /* Display parameters based on command. */
    switch (ogf) {
    case BLE_HCI_OGF_INFO_PARAMS:
        ble_hs_dbg_cmd_comp_info_params(status, ocf, evdata);
        break;
    case BLE_HCI_OGF_STATUS_PARAMS:
        switch (ocf) {
        case BLE_HCI_OCF_RD_RSSI:
            BLE_HS_LOG(DEBUG, "handle=%u rssi=%d", get_le16(evdata),
                       (int8_t)evdata[2]);
            break;
        default:
            break;
        }
        break;
    case BLE_HCI_OGF_LE:
        switch (ocf) {
        case BLE_HCI_OCF_LE_RD_CHAN_MAP:
            BLE_HS_LOG(DEBUG, "handle=%u chanmap=%x.%x.%x.%x.%x",
                       get_le16(evdata), evdata[2], evdata[3], evdata[4],
                       evdata[5], evdata[6]);
            break;
        case BLE_HCI_OCF_LE_RD_MAX_DATA_LEN:
            BLE_HS_LOG(DEBUG, "txoct=%u txtime=%u rxoct=%u rxtime=%u",
                       get_le16(evdata), get_le16(evdata + 2),
                       get_le16(evdata + 4), get_le16(evdata + 6));
            break;
        case BLE_HCI_OCF_LE_RD_SUPP_STATES:
            BLE_HS_LOG(DEBUG, "states=0x%lx%08lx", get_le32(evdata + 4),
                       get_le32(evdata));
            break;
        case BLE_HCI_OCF_LE_ENCRYPT:
            BLE_HS_LOG(DEBUG, "encdata=0x%02x%02x%02x%02x%02x%02x%02x%02x",
                       evdata[15], evdata[14], evdata[13], evdata[12],
                       evdata[11], evdata[10], evdata[9], evdata[8]);
            BLE_HS_LOG(DEBUG, "%02x%02x%02x%02x%02x%02x%02x%02x",
                       evdata[7], evdata[6], evdata[5], evdata[4],
                       evdata[3], evdata[2], evdata[1], evdata[0]);

            break;
        case BLE_HCI_OCF_LE_RAND:
            BLE_HS_LOG(DEBUG, "rand=0x%02x%02x%02x%02x%02x%02x%02x%02x",
                       evdata[0], evdata[1], evdata[2], evdata[3],
                       evdata[4], evdata[5], evdata[6], evdata[7]);
            break;
        case BLE_HCI_OCF_LE_RD_SUGG_DEF_DATA_LEN:
            BLE_HS_LOG(DEBUG, "txoct=%u txtime=%u", get_le16(evdata),
                       get_le16(evdata + 2));
            break;
        case BLE_HCI_OCF_LE_LT_KEY_REQ_REPLY:
        case BLE_HCI_OCF_LE_LT_KEY_REQ_NEG_REPLY:
        case BLE_HCI_OCF_LE_SET_DATA_LEN:
            BLE_HS_LOG(DEBUG, "handle=%u", get_le16(evdata));
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }

done:
    BLE_HS_LOG(DEBUG, "\n");
}

static void
ble_hs_dbg_cmd_status_disp(uint8_t *evdata, uint8_t len)
{
    uint8_t ogf;
    uint8_t ocf;
    uint16_t opcode;

    opcode = get_le16(evdata + 2);
    ogf = BLE_HCI_OGF(opcode);
    ocf = BLE_HCI_OCF(opcode);

    BLE_HS_LOG(DEBUG, "Command Status: status=%u cmd_pkts=%u ocf=0x%x "
                      "ogf=0x%x\n", evdata[0], evdata[1], ocf, ogf);
}

void
ble_hs_dbg_event_disp(uint8_t *evbuf)
{
#if MYNEWT_VAL(LOG_LEVEL) > LOG_LEVEL_DEBUG || BLE_MONITOR
    return;
#endif

    uint8_t *evdata;
    uint8_t evcode;
    uint8_t len;

    /* Extract event code and length; move pointer to event parameter data */
    evcode = evbuf[0];
    len = evbuf[1];
    evdata = evbuf + BLE_HCI_EVENT_HDR_LEN;

    switch (evcode) {
    case BLE_HCI_EVCODE_DISCONN_CMP:
        ble_hs_dbg_disconn_comp_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_ENC_KEY_REFRESH:
        ble_hs_dbg_encrypt_refresh_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_ENCRYPT_CHG:
        ble_hs_dbg_encrypt_chg_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_RD_REM_VER_INFO_CMP:
        ble_hs_dbg_rd_rem_ver_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_COMMAND_COMPLETE:
        ble_hs_dbg_cmd_complete_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_COMMAND_STATUS:
        ble_hs_dbg_cmd_status_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_NUM_COMP_PKTS:
        ble_hs_dbg_num_comp_pkts_disp(evdata, len);
        break;
    case BLE_HCI_EVCODE_LE_META:
        ble_hs_dbg_le_event_disp(evdata[0], len-1, evdata + 1);
        break;
    case BLE_HCI_EVCODE_AUTH_PYLD_TMO:
        ble_hs_dbg_auth_pyld_tmo_disp(evdata, len);
        break;
    default:
        BLE_HS_LOG(DEBUG, "Unknown event 0x%x len=%u\n", evcode, len);
        break;
    }
}

void
ble_hs_dbg_set_sync_state(uint8_t sync_state)
{
    ble_hs_sync_state = sync_state;
}