use zephyr include files; wip: compiles

12 files changed, 4988 insertions, 722 deletions

diff --git a/devices/ble_hci/common-hal/_bleio/Adapter.c b/devices/ble_hci/common-hal/_bleio/Adapter.c
index 5f5259f7e..9dbeca68f 100644
--- a/devices/ble_hci/common-hal/_bleio/Adapter.c
+++ b/devices/ble_hci/common-hal/_bleio/Adapter.c
@@ -31,7 +31,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "hci.h"
+#include "hci_api.h"
 
 #include "py/gc.h"
 #include "py/mphal.h"
@@ -179,13 +179,10 @@ char default_ble_name[] = { 'C', 'I', 'R', 'C', 'U', 'I', 'T', 'P', 'Y', 0, 0, 0
 //     common_hal_bleio_adapter_set_name(self, (char*) default_ble_name);
 // }
 
-void common_hal_bleio_adapter_hci_init(bleio_adapter_obj_t *self, const mcu_pin_obj_t *tx, const mcu_pin_obj_t *rx, const mcu_pin_obj_t *rts, const mcu_pin_obj_t *cts, uint32_t baudrate, uint32_t buffer_size) {
-    self->tx_pin = tx;
-    self->rx_pin = rx;
+void common_hal_bleio_adapter_hci_init(bleio_adapter_obj_t *self, busio_uart_obj_t *uart, const mcu_pin_obj_t *rts, const mcu_pin_obj_t *cts) {
+    self->hci_uart = uart;
     self->rts_pin = rts;
     self->cts_pin = cts;
-    self->baudrate = baudrate;
-    self->buffer_size = buffer_size;
     self->enabled = false;
 }
 
@@ -198,34 +195,15 @@ void common_hal_bleio_adapter_set_enabled(bleio_adapter_obj_t *self, bool enable
     }
 
     if (enabled) {
-        common_hal_busio_uart_construct(
-            &self->hci_uart,
-            self->tx_pin,       // tx pin
-            self->rx_pin,       // rx pin
-            NULL,               // rts pin
-            NULL,               // cts pin
-            NULL,               // rs485 dir pin
-            false,              // rs485 invert
-            0,                  // timeout
-            self->baudrate,     // baudrate
-            8,                  // nbits
-            PARITY_NONE,        // parity
-            1,                  // stop bits
-            self->buffer_size,  // buffer size
-            NULL,               // buffer
-            false               // sigint_enabled
-            );
         common_hal_digitalio_digitalinout_construct(&self->rts_digitalinout, self->rts_pin);
         common_hal_digitalio_digitalinout_construct(&self->cts_digitalinout, self->cts_pin);
 
         hci_init(self);
     } else {
-        common_hal_busio_uart_deinit(&self->hci_uart);
         common_hal_digitalio_digitalinout_deinit(&self->rts_digitalinout);
         common_hal_digitalio_digitalinout_deinit(&self->cts_digitalinout);
     }
 
-
     //FIX enable/disable HCI adapter, but don't reset it, since we don't know how.
     self->enabled = enabled;
 }
@@ -235,35 +213,22 @@ bool common_hal_bleio_adapter_get_enabled(bleio_adapter_obj_t *self) {
 }
 
 bleio_address_obj_t *common_hal_bleio_adapter_get_address(bleio_adapter_obj_t *self) {
-    common_hal_bleio_adapter_set_enabled(self, true);
-
-    uint8_t addr[6];
-    hci_readBdAddr(addr);
+    bt_addr_le_t addr;
+    hci_read_bd_addr(&addr.a);
 
     bleio_address_obj_t *address = m_new_obj(bleio_address_obj_t);
     address->base.type = &bleio_address_type;
 
-    // 0 is the type designating a public address.
-    common_hal_bleio_address_construct(address, addr, 0);
+    common_hal_bleio_address_construct(address, addr.a.val, addr.type);
     return address;
 }
 
 mp_obj_str_t* common_hal_bleio_adapter_get_name(bleio_adapter_obj_t *self) {
-    uint16_t len = 0;
-//    sd_ble_gap_device_name_get(NULL, &len);
-    uint8_t buf[len];
-//    uint32_t err_code = sd_ble_gap_device_name_get(buf, &len);
-//    if (err_code != NRF_SUCCESS) {
-//        return NULL;
-//    }
-    return mp_obj_new_str((char*) buf, len);
+    return self->name;
 }
 
 void common_hal_bleio_adapter_set_name(bleio_adapter_obj_t *self, const char* name) {
-    // ble_gap_conn_sec_mode_t sec;
-    // sec.lv = 0;
-    // sec.sm = 0;
-    // sd_ble_gap_device_name_set(&sec, (const uint8_t*) name, strlen(name));
+    self->name = mp_obj_new_str(name, strlen(name));
 }
 
 // STATIC bool scan_on_ble_evt(ble_evt_t *ble_evt, void *scan_results_in) {
diff --git a/devices/ble_hci/common-hal/_bleio/Adapter.h b/devices/ble_hci/common-hal/_bleio/Adapter.h
index 565963dc0..73b9fed0b 100644
--- a/devices/ble_hci/common-hal/_bleio/Adapter.h
+++ b/devices/ble_hci/common-hal/_bleio/Adapter.h
@@ -52,13 +52,9 @@ typedef struct {
     bleio_scanresults_obj_t* scan_results;
     mp_obj_t name;
     mp_obj_tuple_t *connection_objs;
-    const mcu_pin_obj_t* tx_pin;
-    const mcu_pin_obj_t* rx_pin;
+    busio_uart_obj_t* hci_uart;
     const mcu_pin_obj_t* rts_pin;
     const mcu_pin_obj_t* cts_pin;
-    uint32_t baudrate;
-    uint16_t buffer_size;
-    busio_uart_obj_t hci_uart;
     digitalio_digitalinout_obj_t rts_digitalinout;
     digitalio_digitalinout_obj_t cts_digitalinout;
     bool enabled;
diff --git a/devices/ble_hci/common-hal/_bleio/hci.c b/devices/ble_hci/common-hal/_bleio/hci.c
deleted file mode 100644
index 7d4add9af..000000000
--- a/devices/ble_hci/common-hal/_bleio/hci.c
+++ /dev/null
@@ -1,674 +0,0 @@
-/*
-  This file is part of the ArduinoBLE library.
-  Copyright (c) 2018 Arduino SA. All rights reserved.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-#include "hci.h"
-#include <string.h>
-
-#include "supervisor/shared/tick.h"
-
-#define ATT_CID       0x0004
-
-#define HCI_COMMAND_PKT 0x01
-#define HCI_ACLDATA_PKT 0x02
-#define HCI_EVENT_PKT   0x04
-
-#define EVT_DISCONN_COMPLETE 0x05
-#define EVT_CMD_COMPLETE     0xe
-#define EVT_CMD_STATUS       0x0f
-#define EVT_NUM_COMP_PKTS    0x13
-#define EVT_LE_META_EVENT    0x3e
-
-#define EVT_LE_CONN_COMPLETE      0x01
-#define EVT_LE_ADVERTISING_REPORT 0x02
-
-#define OGF_LINK_CTL           0x01
-#define OGF_HOST_CTL           0x03
-#define OGF_INFO_PARAM         0x04
-#define OGF_STATUS_PARAM       0x05
-#define OGF_LE_CTL             0x08
-
-// OGF_LINK_CTL
-#define OCF_DISCONNECT         0x0006
-
-// OGF_HOST_CTL
-#define OCF_SET_EVENT_MASK     0x0001
-#define OCF_RESET              0x0003
-
-// OGF_INFO_PARAM
-#define OCF_READ_LOCAL_VERSION 0x0001
-#define OCF_READ_BD_ADDR       0x0009
-
-// OGF_STATUS_PARAM
-#define OCF_READ_RSSI          0x0005
-
-// OGF_LE_CTL
-#define OCF_LE_READ_BUFFER_SIZE           0x0002
-#define OCF_LE_SET_RANDOM_ADDRESS         0x0005
-#define OCF_LE_SET_ADVERTISING_PARAMETERS 0x0006
-#define OCF_LE_SET_ADVERTISING_DATA       0x0008
-#define OCF_LE_SET_SCAN_RESPONSE_DATA     0x0009
-#define OCF_LE_SET_ADVERTISE_ENABLE       0x000a
-#define OCF_LE_SET_SCAN_PARAMETERS        0x000b
-#define OCF_LE_SET_SCAN_ENABLE            0x000c
-#define OCF_LE_CREATE_CONN                0x000d
-#define OCF_LE_CANCEL_CONN                0x000e
-#define OCF_LE_CONN_UPDATE                0x0013
-
-#define HCI_OE_USER_ENDED_CONNECTION 0x13
-
-
-#define RECV_BUFFER_SIZE (3 + 255)
-#define ACL_PKT_BUFFER_SIZE (255)
-
-STATIC bleio_adapter_obj_t *adapter;
-
-STATIC int recv_idx;
-STATIC uint8_t recv_buffer[RECV_BUFFER_SIZE];
-STATIC uint16_t cmd_complete_opcode;
-STATIC int cmd_complete_status;
-STATIC uint8_t cmd_response_len;
-STATIC uint8_t* cmd_response;
-
-STATIC uint8_t max_pkt;
-STATIC uint8_t pending_pkt;
-
-//FIX STATIC uint8_t acl_pkt_buffer[255];
-
-STATIC bool debug = true;
-
-typedef struct __attribute__ ((packed)) {
-    uint8_t evt;
-    uint8_t plen;
-} HCIEventHdr;
-
-STATIC void dumpPkt(const char* prefix, uint8_t plen, uint8_t pdata[])
-{
-    if (debug) {
-        mp_printf(&mp_plat_print, "%s", prefix);
-
-        for (uint8_t i = 0; i < plen; i++) {
-            mp_printf(&mp_plat_print, "%02x", pdata[i]);
-        }
-        mp_printf(&mp_plat_print, "\n");
-    }
-}
-
-
-STATIC void handleAclDataPkt(uint8_t plen, uint8_t pdata[])
-{
-    // typedef struct __attribute__ ((packed)) {
-    //     uint16_t handle;
-    //     uint16_t dlen;
-    //     uint16_t len;
-    //     uint16_t cid;
-    // } HCIACLHdr;
-
-    // HCIACLHdr *aclHdr = (HCIACLHdr*)pdata;
-
-    // uint16_t aclFlags = (aclHdr->handle & 0xf000) >> 12;
-
-    // if ((aclHdr->dlen - 4) != aclHdr->len) {
-    //     // packet is fragmented
-    //     if (aclFlags != 0x01) {
-    //         // copy into ACL buffer
-    //         memcpy(acl_pkt_buffer, &recv_buffer[1], sizeof(HCIACLHdr) + aclHdr->dlen - 4);
-    //     } else {
-    //         // copy next chunk into the buffer
-    //         HCIACLHdr* aclBufferHeader = (HCIACLHdr*)acl_pkt_buffer;
-
-    //         memcpy(&acl_pkt_buffer[sizeof(HCIACLHdr) + aclBufferHeader->dlen - 4], &recv_buffer[1 + sizeof(aclHdr->handle) + sizeof(aclHdr->dlen)], aclHdr->dlen);
-
-    //         aclBufferHeader->dlen += aclHdr->dlen;
-    //         aclHdr = aclBufferHeader;
-    //     }
-    // }
-
-    // if ((aclHdr->dlen - 4) != aclHdr->len) {
-    //     // don't have the full packet yet
-    //     return;
-    // }
-
-    // if (aclHdr->cid == ATT_CID) {
-    //     if (aclFlags == 0x01) {
-    //         // use buffered packet
-    //         ATT.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &acl_pkt_buffer[sizeof(HCIACLHdr)]);
-    //     } else {
-    //         // use the recv buffer
-    //         ATT.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &recv_buffer[1 + sizeof(HCIACLHdr)]);
-    //     }
-    // } else if (aclHdr->cid == SIGNALING_CID) {
-    //     L2CAPSignaling.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &recv_buffer[1 + sizeof(HCIACLHdr)]);
-    // } else {
-    //     struct __attribute__ ((packed)) {
-    //         uint8_t op;
-    //         uint8_t id;
-    //         uint16_t length;
-    //         uint16_t reason;
-    //         uint16_t localCid;
-    //         uint16_t remoteCid;
-    //     } l2capRejectCid= { 0x01, 0x00, 0x006, 0x0002, aclHdr->cid, 0x0000 };
-
-    //     sendAclPkt(aclHdr->handle & 0x0fff, 0x0005, sizeof(l2capRejectCid), &l2capRejectCid);
-    // }
-}
-
-STATIC void handleNumCompPkts(uint16_t handle, uint16_t numPkts)
-{
-    if (numPkts && pending_pkt > numPkts) {
-        pending_pkt -= numPkts;
-    } else {
-        pending_pkt = 0;
-    }
-}
-
-STATIC void handleEventPkt(uint8_t plen, uint8_t pdata[])
-{
-    HCIEventHdr *eventHdr = (HCIEventHdr*)pdata;
-
-    if (eventHdr->evt == EVT_DISCONN_COMPLETE) {
-        typedef struct __attribute__ ((packed)) {
-            uint8_t status;
-            uint16_t handle;
-            uint8_t reason;
-        } DisconnComplete;
-
-        DisconnComplete *disconnComplete = (DisconnComplete*)&pdata[sizeof(HCIEventHdr)];
-        (void) disconnComplete;
-        //FIX
-        // ATT.removeConnection(disconnComplete->handle, disconnComplete->reason);
-        // L2CAPSignaling.removeConnection(disconnComplete->handle, disconnComplete->reason);
-
-        hci_leSetAdvertiseEnable(0x01);
-    } else if (eventHdr->evt == EVT_CMD_COMPLETE) {
-        typedef struct __attribute__ ((packed)) {
-            uint8_t ncmd;
-            uint16_t opcode;
-            uint8_t status;
-        } CmdComplete;
-
-        CmdComplete *cmdCompleteHeader = (CmdComplete*)&pdata[sizeof(HCIEventHdr)];
-        cmd_complete_opcode = cmdCompleteHeader->opcode;
-        cmd_complete_status = cmdCompleteHeader->status;
-        cmd_response_len = pdata[1] - sizeof(CmdComplete);
-        cmd_response = &pdata[sizeof(HCIEventHdr) + sizeof(CmdComplete)];
-
-    } else if (eventHdr->evt == EVT_CMD_STATUS) {
-        typedef struct __attribute__ ((packed)) {
-            uint8_t status;
-            uint8_t ncmd;
-            uint16_t opcode;
-        } CmdStatus;
-
-        CmdStatus *cmdStatusHeader = (CmdStatus*)&pdata[sizeof(HCIEventHdr)];
-        cmd_complete_opcode = cmdStatusHeader->opcode;
-        cmd_complete_status = cmdStatusHeader->status;
-        cmd_response_len = 0;
-    } else if (eventHdr->evt == EVT_NUM_COMP_PKTS) {
-        uint8_t numHandles = pdata[sizeof(HCIEventHdr)];
-        uint8_t* data = &pdata[sizeof(HCIEventHdr) + sizeof(numHandles)];
-
-        for (uint8_t i = 0; i < numHandles; i++) {
-            handleNumCompPkts(data[0], data[1]);
-
-            data += 2;
-        }
-    } else if (eventHdr->evt == EVT_LE_META_EVENT) {
-        typedef struct __attribute__ ((packed)) {
-            uint8_t subevent;
-        } LeMetaEventHeader;
-
-        LeMetaEventHeader *leMetaHeader = (LeMetaEventHeader*)&pdata[sizeof(HCIEventHdr)];
-        if (leMetaHeader->subevent == EVT_LE_CONN_COMPLETE) {
-            typedef struct __attribute__ ((packed)) {
-                uint8_t status;
-                uint16_t handle;
-                uint8_t role;
-                uint8_t peerBdaddrType;
-                uint8_t peerBdaddr[6];
-                uint16_t interval;
-                uint16_t latency;
-                uint16_t supervisionTimeout;
-                uint8_t masterClockAccuracy;
-            } EvtLeConnectionComplete;
-
-            EvtLeConnectionComplete *leConnectionComplete = (EvtLeConnectionComplete*)&pdata[sizeof(HCIEventHdr) + sizeof(LeMetaEventHeader)];
-
-            if (leConnectionComplete->status == 0x00) {
-                // ATT.addConnection(leConnectionComplete->handle,
-                //                   leConnectionComplete->role,
-                //                   leConnectionComplete->peerBdaddrType,
-                //                   leConnectionComplete->peerBdaddr,
-                //                   leConnectionComplete->interval,
-                //                   leConnectionComplete->latency,
-                //                   leConnectionComplete->supervisionTimeout,
-                //                   leConnectionComplete->masterClockAccuracy);
-
-                // L2CAPSignaling.addConnection(leConnectionComplete->handle,
-                //                              leConnectionComplete->role,
-                //                              leConnectionComplete->peerBdaddrType,
-                //                              leConnectionComplete->peerBdaddr,
-                //                              leConnectionComplete->interval,
-                //                              leConnectionComplete->latency,
-                //                              leConnectionComplete->supervisionTimeout,
-                //                              leConnectionComplete->masterClockAccuracy);
-            }
-        } else if (leMetaHeader->subevent == EVT_LE_ADVERTISING_REPORT) {
-            typedef struct __attribute__ ((packed)) {
-                uint8_t status;
-                uint8_t type;
-                uint8_t peerBdaddrType;
-                uint8_t peerBdaddr[6];
-                uint8_t eirLength;
-                uint8_t eirData[31];
-            } EvtLeAdvertisingReport;
-
-            EvtLeAdvertisingReport*leAdvertisingReport = (EvtLeAdvertisingReport*)&pdata[sizeof(HCIEventHdr) + sizeof(LeMetaEventHeader)];
-
-            if (leAdvertisingReport->status == 0x01) {
-                // last byte is RSSI
-                //FIX int8_t rssi = leAdvertisingReport->eirData[leAdvertisingReport->eirLength];
-
-                // GAP.handleLeAdvertisingReport(leAdvertisingReport->type,
-                //                               leAdvertisingReport->peerBdaddrType,
-                //                               leAdvertisingReport->peerBdaddr,
-                //                               leAdvertisingReport->eirLength,
-                //                               leAdvertisingReport->eirData,
-                //                               rssi);
-
-            }
-        }
-    }
-}
-
-void hci_init(bleio_adapter_obj_t *adapter_in) {
-    adapter = adapter_in;
-    recv_idx = 0;
-    pending_pkt = 0;
-}
-
-void hci_poll(void) {
-    // Assert RTS low to say we're ready to read data.
-    common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, false);
-
-    int errcode = 0;
-    while (common_hal_busio_uart_rx_characters_available(&adapter->hci_uart)) {
-        // Read just one character.
-        common_hal_busio_uart_read(&adapter->hci_uart, recv_buffer + recv_idx, 1, &errcode);
-        recv_idx++;
-
-        if (recv_buffer[0] == HCI_ACLDATA_PKT) {
-            if (recv_idx > 5 && recv_idx >= (5 + (recv_buffer[3] + (recv_buffer[4] << 8)))) {
-                if (debug) {
-                    dumpPkt("HCI ACLDATA RX <- ", recv_idx, recv_buffer);
-                }
-                // Hold data while processing packet.
-                common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, true);
-                size_t pktLen = recv_idx - 1;
-                recv_idx = 0;
-
-                handleAclDataPkt(pktLen, &recv_buffer[1]);
-
-                common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, false);
-            }
-        } else if (recv_buffer[0] == HCI_EVENT_PKT) {
-            if (recv_idx > 3 && recv_idx >= (3 + recv_buffer[2])) {
-                if (debug) {
-                    dumpPkt("HCI EVENT RX <- ", recv_idx, recv_buffer);
-                }
-                // Hold data while processing packet.
-                common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, true);
-                // Received full event. Reset buffer and handle packet.
-                size_t pktLen = recv_idx - 1;
-                recv_idx = 0;
-
-                handleEventPkt(pktLen, &recv_buffer[1]);
-
-                common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, false);
-            }
-        } else {
-            recv_idx = 0;
-        }
-    }
-
-    common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, true);
-}
-
-
-int hci_sendCommand(uint8_t ogf, uint16_t ocf, uint8_t plen, void* parameters)
-{
-    uint16_t opcode = ogf << 10 | ocf;
-
-    struct __attribute__ ((packed)) {
-        uint8_t pktType;
-        uint16_t opcode;
-        uint8_t plen;
-    } pktHdr = {HCI_COMMAND_PKT, opcode, plen};
-
-    uint8_t txBuffer[sizeof(pktHdr) + plen];
-    memcpy(txBuffer, &pktHdr, sizeof(pktHdr));
-    memcpy(&txBuffer[sizeof(pktHdr)], parameters, plen);
-
-    if (debug) {
-        dumpPkt("HCI COMMAND TX -> ", sizeof(pktHdr) + plen, txBuffer);
-    }
-
-    int errcode = 0;
-    common_hal_busio_uart_write(&adapter->hci_uart, txBuffer, sizeof(pktHdr) + plen, &errcode);
-    if (errcode) {
-        return -1;
-    }
-
-    cmd_complete_opcode = 0xffff;
-    cmd_complete_status = -1;
-
-    // Wait up to one second for a response.
-    for (uint64_t start = supervisor_ticks_ms64();
-         cmd_complete_opcode != opcode && supervisor_ticks_ms64() < (start + 5000);
-        ) {
-        hci_poll();
-    }
-
-    return cmd_complete_status;
-}
-
-int hci_reset(void) {
-    return hci_sendCommand(OGF_HOST_CTL, OCF_RESET, 0, NULL);
-}
-
-int hci_readLocalVersion(uint8_t *hciVer, uint16_t *hciRev, uint8_t *lmpVer, uint16_t *manufacturer, uint16_t *lmpSubVer) {
-    int result = hci_sendCommand(OGF_INFO_PARAM, OCF_READ_LOCAL_VERSION, 0, NULL);
-
-    if (result == 0) {
-        typedef struct __attribute__ ((packed)) {
-            uint8_t hciVer;
-            uint16_t hciRev;
-            uint8_t lmpVer;
-            uint16_t manufacturer;
-            uint16_t lmpSubVer;
-        } HCILocalVersion;
-
-        HCILocalVersion *localVersion = (HCILocalVersion*)cmd_response;
-        *hciVer = localVersion->hciVer;
-        *hciRev = localVersion->hciRev;
-        *lmpVer = localVersion->lmpVer;
-        *manufacturer = localVersion->manufacturer;
-        *lmpSubVer = localVersion->lmpSubVer;
-    }
-
-    return result;
-}
-
-int hci_readBdAddr(uint8_t addr[6]) {
-    int result = hci_sendCommand(OGF_INFO_PARAM, OCF_READ_BD_ADDR, 0, NULL);
-
-    if (result == 0) {
-        memcpy(addr, cmd_response, 6);
-    }
-
-    return result;
-}
-
-int hci_readRssi(uint16_t handle) {
-    int result = hci_sendCommand(OGF_STATUS_PARAM, OCF_READ_RSSI, sizeof(handle), &handle);
-    int rssi = 127;
-
-    if (result == 0) {
-        typedef struct __attribute__ ((packed)) {
-            uint16_t handle;
-            int8_t rssi;
-        } HCIReadRssi;
-
-        HCIReadRssi *readRssi = (HCIReadRssi*)cmd_response;
-        if (readRssi->handle == handle) {
-            rssi = readRssi->rssi;
-        }
-    }
-
-    return rssi;
-}
-
-int hci_setEventMask(uint64_t eventMask) {
-    return hci_sendCommand(OGF_HOST_CTL, OCF_SET_EVENT_MASK, sizeof(eventMask), &eventMask);
-}
-
-int hci_readLeBufferSize(uint16_t *pktLen, uint8_t *maxPkt)
-{
-    int result = hci_sendCommand(OGF_LE_CTL, OCF_LE_READ_BUFFER_SIZE, 0, NULL);
-
-    if (result == 0) {
-        typedef struct __attribute__ ((packed)) {
-            uint16_t pktLen;
-            uint8_t maxPkt;
-        } HCILeBufferSize;
-
-        HCILeBufferSize *leBufferSize = (HCILeBufferSize*)cmd_response;
-        *pktLen = leBufferSize->pktLen;
-        *maxPkt = leBufferSize->maxPkt;
-
-#ifndef __AVR__
-        // FIX (needed?) ATT.setMaxMtu(pktLen - 9); // max pkt len - ACL header size
-#endif
-    }
-
-    return result;
-}
-
-int hci_leSetRandomAddress(uint8_t addr[6])
-{
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_RANDOM_ADDRESS, 6, addr);
-}
-
-int hci_leSetAdvertisingParameters(uint16_t minInterval, uint16_t maxInterval,
-                                         uint8_t advType, uint8_t ownBdaddrType,
-                                         uint8_t directBdaddrType, uint8_t directBdaddr[6],
-                                         uint8_t chanMap,
-                                         uint8_t filter)
-{
-    struct __attribute__ ((packed)) HCILeAdvertisingParameters {
-        uint16_t minInterval;
-        uint16_t maxInterval;
-        uint8_t advType;
-        uint8_t ownBdaddrType;
-        uint8_t directBdaddrType;
-        uint8_t directBdaddr[6];
-        uint8_t chanMap;
-        uint8_t filter;
-    } leAdvertisingParamters;
-
-    leAdvertisingParamters.minInterval = minInterval;
-    leAdvertisingParamters.maxInterval = maxInterval;
-    leAdvertisingParamters.advType = advType;
-    leAdvertisingParamters.ownBdaddrType = ownBdaddrType;
-    leAdvertisingParamters.directBdaddrType = directBdaddrType;
-    memcpy(leAdvertisingParamters.directBdaddr, directBdaddr, 6);
-    leAdvertisingParamters.chanMap = chanMap;
-    leAdvertisingParamters.filter = filter;
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_ADVERTISING_PARAMETERS, sizeof(leAdvertisingParamters), &leAdvertisingParamters);
-}
-
-int hci_leSetAdvertisingData(uint8_t length, uint8_t data[])
-{
-    struct __attribute__ ((packed)) HCILeAdvertisingData {
-        uint8_t length;
-        uint8_t data[31];
-    } leAdvertisingData;
-
-    memset(&leAdvertisingData, 0, sizeof(leAdvertisingData));
-    leAdvertisingData.length = length;
-    memcpy(leAdvertisingData.data, data, length);
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_ADVERTISING_DATA, sizeof(leAdvertisingData), &leAdvertisingData);
-}
-
-int hci_leSetScanResponseData(uint8_t length, uint8_t data[])
-{
-    struct __attribute__ ((packed)) HCILeScanResponseData {
-        uint8_t length;
-        uint8_t data[31];
-    } leScanResponseData;
-
-    memset(&leScanResponseData, 0, sizeof(leScanResponseData));
-    leScanResponseData.length = length;
-    memcpy(leScanResponseData.data, data, length);
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_SCAN_RESPONSE_DATA, sizeof(leScanResponseData), &leScanResponseData);
-}
-
-int hci_leSetAdvertiseEnable(uint8_t enable)
-{
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_ADVERTISE_ENABLE, sizeof(enable), &enable);
-}
-
-int hci_leSetScanParameters(uint8_t type, uint16_t interval, uint16_t window,
-                                  uint8_t ownBdaddrType, uint8_t filter)
-{
-    struct __attribute__ ((packed)) HCILeSetScanParameters {
-        uint8_t type;
-        uint16_t interval;
-        uint16_t window;
-        uint8_t ownBdaddrType;
-        uint8_t filter;
-    } leScanParameters;
-
-    leScanParameters.type = type;
-    leScanParameters.interval = interval;
-    leScanParameters.window = window;
-    leScanParameters.ownBdaddrType = ownBdaddrType;
-    leScanParameters.filter = filter;
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS, sizeof(leScanParameters), &leScanParameters);
-}
-
-int hci_leSetScanEnable(uint8_t enabled, uint8_t duplicates)
-{
-    struct __attribute__ ((packed)) HCILeSetScanEnableData {
-        uint8_t enabled;
-        uint8_t duplicates;
-    } leScanEnableData;
-
-    leScanEnableData.enabled = enabled;
-    leScanEnableData.duplicates = duplicates;
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, sizeof(leScanEnableData), &leScanEnableData);
-}
-
-int hci_leCreateConn(uint16_t interval, uint16_t window, uint8_t initiatorFilter,
-                           uint8_t peerBdaddrType, uint8_t peerBdaddr[6], uint8_t ownBdaddrType,
-                           uint16_t minInterval, uint16_t maxInterval, uint16_t latency,
-                           uint16_t supervisionTimeout, uint16_t minCeLength, uint16_t maxCeLength)
-{
-    struct __attribute__ ((packed)) HCILeCreateConnData {
-        uint16_t interval;
-        uint16_t window;
-        uint8_t initiatorFilter;
-        uint8_t peerBdaddrType;
-        uint8_t peerBdaddr[6];
-        uint8_t ownBdaddrType;
-        uint16_t minInterval;
-        uint16_t maxInterval;
-        uint16_t latency;
-        uint16_t supervisionTimeout;
-        uint16_t minCeLength;
-        uint16_t maxCeLength;
-    } leCreateConnData;
-
-    leCreateConnData.interval = interval;
-    leCreateConnData.window = window;
-    leCreateConnData.initiatorFilter = initiatorFilter;
-    leCreateConnData.peerBdaddrType = peerBdaddrType;
-    memcpy(leCreateConnData.peerBdaddr, peerBdaddr, sizeof(leCreateConnData.peerBdaddr));
-    leCreateConnData.ownBdaddrType = ownBdaddrType;
-    leCreateConnData.minInterval = minInterval;
-    leCreateConnData.maxInterval = maxInterval;
-    leCreateConnData.latency = latency;
-    leCreateConnData.supervisionTimeout = supervisionTimeout;
-    leCreateConnData.minCeLength = minCeLength;
-    leCreateConnData.maxCeLength = maxCeLength;
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_CREATE_CONN, sizeof(leCreateConnData), &leCreateConnData);
-}
-
-int hci_leCancelConn()
-{
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_CANCEL_CONN, 0, NULL);
-}
-
-int hci_leConnUpdate(uint16_t handle, uint16_t minInterval, uint16_t maxInterval,
-                           uint16_t latency, uint16_t supervisionTimeout)
-{
-    struct __attribute__ ((packed)) HCILeConnUpdateData {
-        uint16_t handle;
-        uint16_t minInterval;
-        uint16_t maxInterval;
-        uint16_t latency;
-        uint16_t supervisionTimeout;
-        uint16_t minCeLength;
-        uint16_t maxCeLength;
-    } leConnUpdateData;
-
-    leConnUpdateData.handle = handle;
-    leConnUpdateData.minInterval = minInterval;
-    leConnUpdateData.maxInterval = maxInterval;
-    leConnUpdateData.latency = latency;
-    leConnUpdateData.supervisionTimeout = supervisionTimeout;
-    leConnUpdateData.minCeLength = 0x0004;
-    leConnUpdateData.maxCeLength = 0x0006;
-
-    return hci_sendCommand(OGF_LE_CTL, OCF_LE_CONN_UPDATE, sizeof(leConnUpdateData), &leConnUpdateData);
-}
-
-int hci_sendAclPkt(uint16_t handle, uint8_t cid, uint8_t plen, void* data) {
-    while (pending_pkt >= max_pkt) {
-        hci_poll();
-    }
-
-    typedef struct __attribute__ ((packed)) {
-        uint8_t pktType;
-        uint16_t handle;
-        uint16_t dlen;
-        uint16_t plen;
-        uint16_t cid;
-    }  HCIACLHdr;
-
-    HCIACLHdr aclHdr = { HCI_ACLDATA_PKT, handle, (uint8_t)(plen + 4), plen, cid };
-
-    uint8_t txBuffer[sizeof(aclHdr) + plen];
-    memcpy(txBuffer, &aclHdr, sizeof(aclHdr));
-    memcpy(&txBuffer[sizeof(aclHdr)], data, plen);
-
-    if (debug) {
-        dumpPkt("HCI ACLDATA TX -> ", sizeof(aclHdr) + plen, txBuffer);
-    }
-
-    pending_pkt++;
-
-    int errcode = 0;
-    common_hal_busio_uart_write(&adapter->hci_uart, txBuffer, sizeof(aclHdr) + plen, &errcode);
-    if (errcode) {
-        return -1;
-    }
-
-    return 0;
-}
-
-int hci_disconnect(uint16_t handle)
-{
-    struct __attribute__ ((packed)) HCIDisconnectData {
-        uint16_t handle;
-        uint8_t reason;
-    } disconnectData = { handle, HCI_OE_USER_ENDED_CONNECTION };
-
-    return hci_sendCommand(OGF_LINK_CTL, OCF_DISCONNECT, sizeof(disconnectData), &disconnectData);
-}
diff --git a/devices/ble_hci/common-hal/_bleio/hci_api.c b/devices/ble_hci/common-hal/_bleio/hci_api.c
new file mode 100644
index 000000000..180ab6f5e
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_api.c
@@ -0,0 +1,646 @@
+/*
+  This file is part of the ArduinoBLE library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "hci_api.h"
+
+// Zephyr include files to define HCI communication values and structs.
+#include "hci_include/hci.h"
+#include "hci_include/hci_err.h"
+
+#include <string.h>
+
+#include "supervisor/shared/tick.h"
+
+// HCI H4 protocol packet types: first byte in the packet.
+#define H4_CMD 0x01
+#define H4_ACL 0x02
+#define H4_SCO 0x03
+#define H4_EVT 0x04
+
+//FIX replace
+#define ATT_CID       0x0004
+
+#define RX_BUFFER_SIZE (3 + 255)
+#define ACL_PKT_BUFFER_SIZE (255)
+
+#define CTS_TIMEOUT_MSECS (1000)
+#define RESPONSE_TIMEOUT_MSECS (1000)
+
+STATIC bleio_adapter_obj_t *adapter;
+
+STATIC uint8_t rx_buffer[RX_BUFFER_SIZE];
+STATIC size_t rx_idx;
+
+STATIC size_t num_command_packets_allowed;
+STATIC size_t max_pkt;
+STATIC size_t pending_pkt;
+
+// Results from parsing a command response packet.
+STATIC bool cmd_response_received;
+STATIC uint16_t cmd_response_opcode;
+STATIC uint8_t cmd_response_status;
+STATIC size_t cmd_response_len;
+STATIC uint8_t* cmd_response_data;
+
+//FIX STATIC uint8_t acl_pkt_buffer[ACL_PKT_BUFFER_SIZE];
+
+STATIC bool debug = true;
+
+// These are the headers of the full packets that are sent over the serial interface.
+// They all have a one-byte type-field at the front, one of the H4_xxx packet types.
+
+typedef struct __attribute__ ((packed)) {
+        uint8_t pkt_type;
+        uint16_t opcode;
+        uint8_t param_len;
+} h4_hci_cmd_hdr_t;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t pkt_type;
+    uint16_t handle;
+    uint16_t total_data_len;
+    uint16_t acl_data_len;
+    uint16_t cid;
+}  h4_hci_acl_hdr_t;
+
+typedef struct __attribute__ ((packed)) {
+    uint8_t pkt_type;
+    uint8_t evt;
+    uint8_t param_len;
+} h4_hci_evt_hdr_t;
+
+
+
+STATIC void dump_pkt(const char* prefix, uint8_t pkt_len, uint8_t pkt_data[]) {
+    if (debug) {
+        mp_printf(&mp_plat_print, "%s", prefix);
+        for (uint8_t i = 0; i < pkt_len; i++) {
+            mp_printf(&mp_plat_print, "%02x", pkt_data[i]);
+        }
+        mp_printf(&mp_plat_print, "\n");
+    }
+}
+
+STATIC void process_acl_data_pkt(uint8_t pkt_len, uint8_t pkt_data[]) {
+    //FIX pkt_len is +1 than before, because it includes the pkt_type.
+    // h4_hci_acl_hdr_t *aclHdr = (h4_hci_acl_hdr_t*)pkt_data;
+
+    // uint16_t aclFlags = (aclHdr->handle & 0xf000) >> 12;
+
+    // if ((aclHdr->data_len - 4) != aclHdr->len) {
+    //     // packet is fragmented
+    //     if (aclFlags != 0x01) {
+    //         // copy into ACL buffer
+    //         memcpy(acl_pkt_buffer, &rx_buffer[1], sizeof(HCIACLHdr) + aclHdr->data_len - 4);
+    //     } else {
+    //         // copy next chunk into the buffer
+    //         HCIACLHdr* aclBufferHeader = (HCIACLHdr*)acl_pkt_buffer;
+
+    //         memcpy(&acl_pkt_buffer[sizeof(HCIACLHdr) + aclBufferHeader->data_len - 4], &rx_buffer[1 + sizeof(aclHdr->handle) + sizeof(aclHdr->data_len)], aclHdr->data_len);
+
+    //         aclBufferHeader->data_len += aclHdr->data_len;
+    //         aclHdr = aclBufferHeader;
+    //     }
+    // }
+
+    // if ((aclHdr->data_len - 4) != aclHdr->len) {
+    //     // don't have the full packet yet
+    //     return;
+    // }
+
+    // if (aclHdr->cid == ATT_CID) {
+    //     if (aclFlags == 0x01) {
+    //         // use buffered packet
+    //         ATT.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &acl_pkt_buffer[sizeof(HCIACLHdr)]);
+    //     } else {
+    //         // use the rx buffer
+    //         ATT.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &rx_buffer[1 + sizeof(HCIACLHdr)]);
+    //     }
+    // } else if (aclHdr->cid == SIGNALING_CID) {
+    //     L2CAPSignaling.handleData(aclHdr->handle & 0x0fff, aclHdr->len, &rx_buffer[1 + sizeof(HCIACLHdr)]);
+    // } else {
+    //     struct __attribute__ ((packed)) {
+    //         uint8_t op;
+    //         uint8_t id;
+    //         uint16_t length;
+    //         uint16_t reason;
+    //         uint16_t localCid;
+    //         uint16_t remoteCid;
+    //     } l2capRejectCid= { 0x01, 0x00, 0x006, 0x0002, aclHdr->cid, 0x0000 };
+
+    //     sendAclPkt(aclHdr->handle & 0x0fff, 0x0005, sizeof(l2capRejectCid), &l2capRejectCid);
+    // }
+}
+
+// Process number of completed packets. Reduce number of pending packets by reported
+// number of completed.
+STATIC void process_num_comp_pkts(uint16_t handle, uint16_t num_pkts) {
+    if (num_pkts && pending_pkt > num_pkts) {
+        pending_pkt -= num_pkts;
+    } else {
+        pending_pkt = 0;
+    }
+}
+
+STATIC void process_evt_pkt(size_t pkt_len, uint8_t pkt[])
+{
+    h4_hci_evt_hdr_t *evt_hdr = (h4_hci_evt_hdr_t*) pkt;
+    // The data itself, after the header.
+    uint8_t *evt_data = pkt + sizeof(h4_hci_evt_hdr_t);
+
+    switch (evt_hdr->evt) {
+        case BT_HCI_EVT_DISCONN_COMPLETE: {
+            struct bt_hci_evt_disconn_complete *disconn_complete = (struct bt_hci_evt_disconn_complete*) evt_data;
+            (void) disconn_complete;
+            //FIX
+            // ATT.removeConnection(disconn_complete->handle, disconn_complete->reason);
+            // L2CAPSignaling.removeConnection(disconn_complete->handle, disconn_complete->reason);
+            hci_le_set_advertise_enable(0x01);
+            break;
+        }
+
+        case BT_HCI_EVT_CMD_COMPLETE: {
+
+            struct cmd_complete_with_status {
+                struct bt_hci_evt_cmd_complete cmd_complete;
+                struct bt_hci_evt_cc_status cc_status;
+            } __packed;
+
+            struct cmd_complete_with_status *evt = (struct cmd_complete_with_status *) evt_data;
+
+            num_command_packets_allowed = evt->cmd_complete.ncmd;
+
+            cmd_response_received = true;
+            cmd_response_opcode = evt->cmd_complete.opcode;
+            cmd_response_status = evt->cc_status.status;
+            // All the bytes following status.
+            cmd_response_data = &evt_data[sizeof(struct cmd_complete_with_status)];
+            cmd_response_len = evt_hdr->param_len - sizeof(struct cmd_complete_with_status);
+
+            break;
+        }
+
+        case BT_HCI_EVT_CMD_STATUS: {
+            struct bt_hci_evt_cmd_status *evt = (struct bt_hci_evt_cmd_status *) evt_data;
+
+            num_command_packets_allowed = evt->ncmd;
+
+            cmd_response_received = true;
+            cmd_response_opcode = evt->opcode;
+            cmd_response_status = evt->status;
+            cmd_response_data = NULL;
+            cmd_response_len = 0;
+
+            break;
+        }
+
+        case BT_HCI_EVT_NUM_COMPLETED_PACKETS: {
+            struct bt_hci_evt_num_completed_packets *evt = (struct bt_hci_evt_num_completed_packets *) evt_data;
+
+            // Start at zero-th pair: (conn handle, num completed packets).
+            struct bt_hci_handle_count *handle_and_count = &(evt->h[0]);
+            for (uint8_t i = 0; i < evt->num_handles; i++) {
+                process_num_comp_pkts(handle_and_count->handle, handle_and_count->count);
+                handle_and_count++;
+            }
+            break;
+        }
+
+        case BT_HCI_EVT_LE_META_EVENT: {
+            struct bt_hci_evt_le_meta_event *meta_evt = (struct bt_hci_evt_le_meta_event *) evt_data;
+            // Start of the encapsulated LE event.
+            uint8_t *le_evt = evt_data + sizeof (struct bt_hci_evt_le_meta_event);
+
+            if (meta_evt->subevent == BT_HCI_EVT_LE_CONN_COMPLETE) {
+                struct bt_hci_evt_le_conn_complete *le_conn_complete =
+                    (struct bt_hci_evt_le_conn_complete *) le_evt;
+
+                if (le_conn_complete->status == 0x00) {
+                    // ATT.addConnection(le_conn_complete->handle,
+                    //                   le_conn_complete->role,
+                    //                   le_conn_complete->peer_addr  //FIX struct
+                    //                   le_conn_complete->interval,
+                    //                   le_conn_complete->latency,
+                    //                   le_conn_complete->supv_timeout
+                    //                   le_conn_complete->clock_accuracy);
+
+                    // L2CAPSignaling.addConnection(le_conn_complete->handle,
+                    //                              le_conn_complete->role,
+                    //                              le_conn_complete->peer_addr, //FIX struct
+                    //                              le_conn_complete->interval,
+                    //                              le_conn_complete->latency,
+                    //                              le_conn_complete->supv_timeout,
+                    //                              le_conn_complete->clock_accuracy);
+                }
+            } else if (meta_evt->subevent == BT_HCI_EVT_LE_ADVERTISING_REPORT) {
+                struct bt_hci_evt_le_advertising_info *le_advertising_info =
+                    (struct bt_hci_evt_le_advertising_info *) le_evt;
+                if (le_advertising_info->evt_type == BT_HCI_ADV_DIRECT_IND) {  //FIX handle kind of advertising
+                    // last byte is RSSI
+                    // GAP.handleLeAdvertisingReport(leAdvertisingReport->type,
+                    //                               leAdvertisingReport->peerBdaddrType,
+                    //                               leAdvertisingReport->peerBdaddr,
+                    //                               leAdvertisingReport->eirLength,
+                    //                               leAdvertisingReport->eirData,
+                    //                               rssi); //FIX, don't separate
+
+                }
+            }
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
+void hci_init(bleio_adapter_obj_t *adapter_in) {
+    adapter = adapter_in;
+    rx_idx = 0;
+    pending_pkt = 0;
+}
+
+hci_result_t hci_poll_for_incoming_pkt(void) {
+    // Assert RTS low to say we're ready to read data.
+    common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, false);
+
+    int errcode = 0;
+    bool packet_is_complete = false;
+
+    // Read bytes until we run out, or accumulate a complete packet.
+    while (common_hal_busio_uart_rx_characters_available(adapter->hci_uart)) {
+        common_hal_busio_uart_read(adapter->hci_uart, rx_buffer + rx_idx, 1, &errcode);
+        if (!errcode) {
+            return HCI_READ_ERROR;
+        }
+        rx_idx++;
+
+        switch (rx_buffer[0]) {
+            case H4_ACL:
+                if (rx_idx > sizeof(h4_hci_acl_hdr_t) &&
+                    rx_idx >= sizeof(h4_hci_acl_hdr_t) + ((h4_hci_acl_hdr_t *) rx_buffer)->total_data_len) {
+                    packet_is_complete = true;
+                }
+                break;
+
+            case H4_EVT:
+                if (rx_idx > sizeof(h4_hci_evt_hdr_t) &&
+                    rx_idx >= sizeof(h4_hci_evt_hdr_t) + ((h4_hci_evt_hdr_t *) rx_buffer)->param_len) {
+                    packet_is_complete = true;
+                }
+                break;
+
+            default:
+                // Unknown or bad packet type. Start over.
+                rx_idx = 0;
+                break;
+        }
+    }
+
+    if (!packet_is_complete) {
+        return HCI_OK;
+    }
+
+    // Stop incoming data while processing packet.
+    common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, true);
+    size_t pkt_len = rx_idx;
+    rx_idx = 0;
+
+    switch (rx_buffer[0]) {
+        case H4_ACL:
+            if (debug) {
+                dump_pkt("HCI EVENT RX <- ", rx_idx, rx_buffer);
+            }
+
+            process_acl_data_pkt(pkt_len, rx_buffer);
+            break;
+
+        case H4_EVT:
+            if (debug) {
+                dump_pkt("HCI ACLDATA RX <- ", rx_idx, rx_buffer);
+            }
+
+            process_evt_pkt(pkt_len, rx_buffer);
+            break;
+
+        default:
+            break;
+    }
+
+    common_hal_digitalio_digitalinout_set_value(&adapter->rts_digitalinout, true);
+
+    return HCI_OK;
+}
+
+
+// Returns
+STATIC hci_result_t write_pkt(uint8_t *buffer, size_t len) {
+    // Wait for CTS to go low before writing to HCI adapter.
+    uint64_t start = supervisor_ticks_ms64();
+    while (common_hal_digitalio_digitalinout_get_value(&adapter->cts_digitalinout)) {
+        RUN_BACKGROUND_TASKS;
+        if (supervisor_ticks_ms64() - start > CTS_TIMEOUT_MSECS) {
+            return HCI_WRITE_TIMEOUT;
+        }
+    }
+
+    int errcode = 0;
+    common_hal_busio_uart_write(adapter->hci_uart, buffer, len, &errcode);
+    if (errcode) {
+        return HCI_WRITE_ERROR;
+    }
+
+    return HCI_OK;
+}
+
+STATIC hci_result_t send_command(uint16_t opcode, uint8_t params_len, void* params) {
+    uint8_t tx_buffer[sizeof(h4_hci_cmd_hdr_t) + params_len];
+
+    // cmd header is at the beginning of tx_buffer
+    h4_hci_cmd_hdr_t *cmd_hdr = (h4_hci_cmd_hdr_t *) tx_buffer;
+    cmd_hdr->pkt_type = H4_CMD;
+    cmd_hdr->opcode = opcode;
+    cmd_hdr->param_len = params_len;
+
+    // Copy the params data into the space after the header.
+    memcpy(&tx_buffer[sizeof(h4_hci_cmd_hdr_t)], params, params_len);
+
+    if (debug) {
+        dump_pkt("HCI COMMAND TX -> ", sizeof(tx_buffer), tx_buffer);
+    }
+
+    int result = write_pkt(tx_buffer, sizeof(h4_hci_cmd_hdr_t) + params_len);
+    if (result != HCI_OK) {
+        return result;
+    }
+
+    cmd_response_received = false;
+
+    // Wait for a response. Note that other packets may be received that are not
+    // command responses.
+    uint64_t start = supervisor_ticks_ms64();
+    while (1) {
+        result = hci_poll_for_incoming_pkt();
+        if (result != HCI_OK) {
+            // I/O error.
+            return result;
+        }
+
+        if (cmd_response_received && cmd_response_opcode == opcode) {
+            // If this is definitely a response to the command that was sent,
+            // return the status value, which will will be
+            // BT_HCI_ERR_SUCCESS (0x00) if the command succeeded,
+            // or a BT_HCI_ERR_x value (> 0x00) if there ws a problem.
+            return cmd_response_status;
+        }
+
+        if (supervisor_ticks_ms64() - start > RESPONSE_TIMEOUT_MSECS) {
+            return HCI_READ_TIMEOUT;
+        }
+        RUN_BACKGROUND_TASKS;
+    }
+
+    // No I/O error, but no response sent back in time.
+    return HCI_NO_RESPONSE;
+}
+
+//FIX remove unused
+STATIC int __attribute__((unused)) send_acl_pkt(uint16_t handle, uint8_t cid, void* data, uint8_t data_len) {
+    int result;
+    while (pending_pkt >= max_pkt) {
+        result = hci_poll_for_incoming_pkt();
+        if (result != HCI_OK) {
+            return result;
+        }
+    }
+
+    // data_len does not include cid.
+    const size_t cid_len = sizeof(((h4_hci_acl_hdr_t *)0)->cid);
+    // buf_len is size of entire packet including header.
+    const size_t buf_len = sizeof(h4_hci_acl_hdr_t) + cid_len + data_len;
+    uint8_t tx_buffer[buf_len];
+
+    h4_hci_acl_hdr_t *acl_hdr = (h4_hci_acl_hdr_t *) tx_buffer;
+    acl_hdr->pkt_type = H4_ACL;
+    acl_hdr->handle = handle;
+    acl_hdr->total_data_len = (uint8_t)(cid_len + data_len);
+    acl_hdr->acl_data_len = (uint8_t) data_len;
+    acl_hdr->cid = cid;
+
+    memcpy(&tx_buffer[sizeof(h4_hci_acl_hdr_t)], data, data_len);
+
+    if (debug) {
+        dump_pkt("HCI ACLDATA TX -> ", buf_len, tx_buffer);
+    }
+
+    pending_pkt++;
+
+    int errcode = 0;
+    common_hal_busio_uart_write(adapter->hci_uart, tx_buffer, buf_len, &errcode);
+    if (errcode) {
+        return HCI_WRITE_ERROR;
+    }
+
+    return HCI_OK;
+}
+
+hci_result_t hci_reset(void) {
+    return send_command(BT_HCI_OP_RESET, 0, NULL);
+}
+
+hci_result_t hci_read_local_version(uint8_t *hci_version, uint16_t *hci_revision, uint8_t *lmp_version, uint16_t *manufacturer, uint16_t *lmp_subversion) {
+    hci_result_t result = send_command(BT_HCI_OP_READ_LOCAL_VERSION_INFO, 0, NULL);
+    if (result == HCI_OK) {
+        struct bt_hci_rp_read_local_version_info *response =
+            (struct bt_hci_rp_read_local_version_info *) cmd_response_data;
+        *hci_version = response->hci_version;
+        *hci_revision = response->hci_revision;
+        *lmp_version = response->lmp_version;
+        *manufacturer = response->manufacturer;
+        *lmp_subversion = response->lmp_subversion;
+    }
+
+    return result;
+}
+
+hci_result_t hci_read_bd_addr(bt_addr_t *addr) {
+    int result = send_command(BT_HCI_OP_READ_BD_ADDR, 0, NULL);
+    if (result == HCI_OK) {
+        struct bt_hci_rp_read_bd_addr *response = (struct bt_hci_rp_read_bd_addr *) cmd_response_data;
+        memcpy(addr->val, response->bdaddr.val, sizeof(bt_addr_t));
+    }
+
+    return result;
+}
+
+hci_result_t hci_read_rssi(uint16_t handle, int *rssi) {
+    int result = send_command(BT_HCI_OP_READ_RSSI, sizeof(handle), &handle);
+    if (result == HCI_OK) {
+        struct bt_hci_rp_read_rssi *response = (struct bt_hci_rp_read_rssi *) cmd_response_data;
+        if (response->handle != handle) {
+            // Handle doesn't match.
+            return HCI_NO_RESPONSE;
+        }
+
+        *rssi = response->rssi;
+    }
+
+    return result;
+}
+
+hci_result_t hci_set_evt_mask(uint64_t event_mask) {
+    return send_command(BT_HCI_OP_SET_EVENT_MASK, sizeof(event_mask), &event_mask);
+}
+
+hci_result_t hci_read_le_buffer_size(uint16_t *le_max_len, uint8_t *le_max_num) {
+    int result = send_command(BT_HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL);
+    if (result == HCI_OK) {
+        struct bt_hci_rp_le_read_buffer_size *response =
+            (struct bt_hci_rp_le_read_buffer_size *) cmd_response_data;
+        *le_max_len = response->le_max_len;
+        *le_max_num = response->le_max_num;
+    }
+
+    return result;
+}
+
+hci_result_t hci_le_set_random_address(uint8_t addr[6]) {
+    return send_command(BT_HCI_OP_LE_SET_RANDOM_ADDRESS, 6, addr);
+}
+
+hci_result_t hci_le_set_advertising_parameters(uint16_t min_interval, uint16_t max_interval, uint8_t type, uint8_t own_addr_type, bt_addr_le_t *direct_addr, uint8_t channel_map, uint8_t filter_policy) {
+    struct bt_hci_cp_le_set_adv_param params = {
+        .min_interval = min_interval,
+        .max_interval = max_interval,
+        .type = type,
+        .own_addr_type = own_addr_type,
+        // .direct_addr set below.
+        .channel_map = channel_map,
+        .filter_policy = filter_policy,
+    };
+    params.direct_addr.type = direct_addr->type;
+    memcpy(params.direct_addr.a.val, direct_addr->a.val, sizeof(params.direct_addr.a.val));
+
+    return send_command(BT_HCI_OP_LE_SET_ADV_PARAM, sizeof(params), &params);
+}
+
+hci_result_t hci_le_read_maximum_advertising_data_length(int *max_adv_data_len) {
+    int result = send_command(BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN, 0, NULL);
+    if (result == HCI_OK) {
+        struct bt_hci_rp_le_read_max_adv_data_len *response =
+            (struct bt_hci_rp_le_read_max_adv_data_len *) cmd_response_data;
+        if (response->status == BT_HCI_ERR_SUCCESS) {
+            *max_adv_data_len = response->max_adv_data_len;
+        }
+    }
+
+    return result;
+}
+
+hci_result_t hci_le_set_advertising_data(uint8_t len, uint8_t data[]) {
+    struct bt_hci_cp_le_set_adv_data params = {
+        // Zero out unused data bytes.
+        .data = { 0 },
+    };
+
+    params.len = len;
+    memcpy(params.data, data, len);
+
+    // All data bytes are sent even if some are unused.
+    return send_command(BT_HCI_OP_LE_SET_ADV_DATA, sizeof(params), &params);
+}
+
+hci_result_t hci_le_set_scan_response_data(uint8_t len, uint8_t data[]) {
+    struct bt_hci_cp_le_set_scan_rsp_data params = {
+        // Zero out unused data bytes.
+        .data = { 0 },
+    };
+    params.len = len;
+    memcpy(params.data, data, len);
+
+    // All data bytes are sent even if some are unused.
+    return send_command(BT_HCI_OP_LE_SET_SCAN_RSP_DATA, sizeof(params), &params);
+}
+
+hci_result_t hci_le_set_advertise_enable(uint8_t enable) {
+    return send_command(BT_HCI_OP_LE_SET_ADV_ENABLE, sizeof(enable), &enable);
+}
+
+hci_result_t hci_le_set_scan_parameters(uint8_t scan_type, uint16_t interval, uint16_t window, uint8_t addr_type, uint8_t filter_policy) {
+    struct bt_hci_cp_le_set_scan_param params = {
+        .scan_type = scan_type,
+        .interval = interval,
+        .window = window,
+        .addr_type = addr_type,
+        .filter_policy = filter_policy,
+    };
+
+    return send_command(BT_HCI_OP_LE_SET_SCAN_PARAM, sizeof(params), &params);
+}
+
+hci_result_t hci_le_set_scan_enable(uint8_t enable, uint8_t filter_dup) {
+    struct bt_hci_cp_le_set_scan_enable params = {
+        .enable = enable,
+        .filter_dup = filter_dup,
+    };
+
+    return send_command(BT_HCI_OP_LE_SET_SCAN_ENABLE, sizeof(params), &params);
+}
+
+hci_result_t hci_le_create_conn(uint16_t scan_interval, uint16_t scan_window, uint8_t filter_policy, bt_addr_le_t *peer_addr, uint8_t own_addr_type, uint16_t conn_interval_min, uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout, uint16_t min_ce_len, uint16_t max_ce_len) {
+    struct bt_hci_cp_le_create_conn params = {
+        .scan_interval = scan_interval,
+        .scan_window = scan_window,
+        .filter_policy = filter_policy,
+        // .peer_addr is set below
+        .own_addr_type = own_addr_type,
+        .conn_interval_min = conn_interval_min,
+        .conn_interval_max = conn_interval_max,
+        .conn_latency = conn_latency,
+        .supervision_timeout = supervision_timeout,
+        .min_ce_len = min_ce_len,
+        .max_ce_len = max_ce_len,
+    };
+    params.peer_addr.type = peer_addr->type;
+    memcpy(params.peer_addr.a.val, peer_addr->a.val, sizeof(params.peer_addr.a.val));
+
+    return send_command(BT_HCI_OP_LE_CREATE_CONN, sizeof(params), &params);
+}
+
+hci_result_t hci_le_cancel_conn(void) {
+    return send_command(BT_HCI_OP_CONNECT_CANCEL, 0, NULL);
+}
+
+hci_result_t hci_le_conn_update(uint16_t handle, uint16_t conn_interval_min, uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout) {
+    struct hci_cp_le_conn_update params = {
+        .handle = handle,
+        .conn_interval_min = conn_interval_min,
+        .conn_interval_max = conn_interval_max,
+        .conn_latency = conn_latency,
+        .supervision_timeout = supervision_timeout,
+        .min_ce_len = 4,
+        .max_ce_len = 6,
+    };
+
+    return send_command(BT_HCI_OP_LE_CONN_UPDATE, sizeof(params), &params);
+}
+
+hci_result_t hci_disconnect(uint16_t handle) {
+    struct bt_hci_cp_disconnect params = {
+        .handle = handle,
+        .reason = BT_HCI_ERR_REMOTE_USER_TERM_CONN,
+    };
+
+    return send_command(BT_HCI_OP_DISCONNECT, sizeof(params), &params);
+}
diff --git a/devices/ble_hci/common-hal/_bleio/hci_api.h b/devices/ble_hci/common-hal/_bleio/hci_api.h
new file mode 100644
index 000000000..a2235ec8c
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_api.h
@@ -0,0 +1,69 @@
+/*
+  This file is part of the ArduinoBLE library.
+  Copyright (c) 2018 Arduino SA. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef MICROPY_INCLUDED_DEVICES_BLE_HCI_COMMON_HAL_BLEIO_HCI_H
+#define MICROPY_INCLUDED_DEVICES_BLE_HCI_COMMON_HAL_BLEIO_HCI_H
+
+#include <stdint.h>
+
+#include "common-hal/_bleio/hci_include/hci.h"
+
+#include "common-hal/_bleio/Adapter.h"
+
+// An hci_result_t is one of the HCI_x values below,
+// or is it > 0 and is an HCI command status value (see hci_include/hci_err.h)
+typedef int hci_result_t;
+#define HCI_OK (0)
+#define HCI_NO_RESPONSE (-1)
+#define HCI_ERR_RESPONSE (-2)
+#define HCI_READ_TIMEOUT (-3)
+#define HCI_WRITE_TIMEOUT (-4)
+#define HCI_READ_ERROR (-5)
+#define HCI_WRITE_ERROR (-6)
+
+void hci_init(bleio_adapter_obj_t *adapter_in);
+
+hci_result_t hci_disconnect(uint16_t handle);
+
+hci_result_t hci_le_cancel_conn(void);
+hci_result_t hci_le_conn_update(uint16_t handle, uint16_t conn_interval_min, uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout);
+hci_result_t hci_le_create_conn(uint16_t scan_interval, uint16_t scan_window, uint8_t filter_policy, bt_addr_le_t *peer_addr, uint8_t own_addr_type, uint16_t conn_interval_min, uint16_t conn_interval_max, uint16_t conn_latency, uint16_t supervision_timeout, uint16_t min_ce_len, uint16_t max_ce_len);
+
+hci_result_t hci_le_read_maximum_advertising_data_length(int *max_adv_data_len);
+
+hci_result_t hci_le_set_advertise_enable(uint8_t enable);
+hci_result_t hci_le_set_advertising_data(uint8_t length, uint8_t data[]);
+hci_result_t hci_le_set_advertising_parameters(uint16_t min_interval, uint16_t max_interval, uint8_t type, uint8_t own_addr_type, bt_addr_le_t *direct_addr, uint8_t channel_map, uint8_t filter_policy);
+hci_result_t hci_le_set_random_address(uint8_t addr[6]);
+hci_result_t hci_le_set_scan_enable(uint8_t enable, uint8_t filter_dup);
+hci_result_t hci_le_set_scan_parameters(uint8_t scan_type, uint16_t interval, uint16_t window, uint8_t addr_type, uint8_t filter_policy);
+hci_result_t hci_le_set_scan_response_data(uint8_t length, uint8_t data[]);
+
+hci_result_t hci_poll_for_incoming_pkt(void);
+
+hci_result_t hci_read_bd_addr(bt_addr_t *addr);
+hci_result_t hci_read_le_buffer_size(uint16_t *le_max_len, uint8_t *le_max_num);
+hci_result_t hci_read_local_version(uint8_t *hci_version, uint16_t *hci_revision, uint8_t *lmp_version, uint16_t *manufacturer, uint16_t *lmp_subversion);
+hci_result_t hci_read_rssi(uint16_t handle, int *rssi);
+
+hci_result_t hci_reset(void);
+
+hci_result_t hci_set_evt_mask(uint64_t event_mask);
+
+#endif // MICROPY_INCLUDED_DEVICES_BLE_HCI_COMMON_HAL_BLEIO_HCI_H
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/#hci.h# b/devices/ble_hci/common-hal/_bleio/hci_include/#hci.h#
new file mode 100644
index 000000000..942a82a3c
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/#hci.h#
@@ -0,0 +1,1775 @@
+/* hci.h - Bluetooth Host Control Interface definitions */
+
+/*
+ * Copyright (c) 2015-2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_
+
+#include <toolchain.h>
+#include <zephyr/types.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/util.h>
+#include <net/buf.h>
+#include <bluetooth/addr.h>
+#include <bluetooth/hci_err.h>
+#include <bluetooth/conn.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Special own address types for LL privacy (used in adv & scan parameters) */
+#define BT_HCI_OWN_ADDR_RPA_OR_PUBLIC  0x02
+#define BT_HCI_OWN_ADDR_RPA_OR_RANDOM  0x03
+#define BT_HCI_OWN_ADDR_RPA_MASK       0x02
+
+#define BT_HCI_PEER_ADDR_RPA_UNRESOLVED 0xfe
+#define BT_HCI_PEER_ADDR_ANONYMOUS      0xff
+
+#define BT_ENC_KEY_SIZE_MIN                     0x07
+#define BT_ENC_KEY_SIZE_MAX                     0x10
+
+struct bt_hci_evt_hdr {
+	uint8_t  evt;
+	uint8_t  len;
+} __packed;
+#define BT_HCI_EVT_HDR_SIZE             2
+
+#define BT_ACL_START_NO_FLUSH           0x00
+#define BT_ACL_CONT                     0x01
+#define BT_ACL_START                    0x02
+#define BT_ACL_COMPLETE                 0x03
+
+#define BT_ACL_POINT_TO_POINT           0x00
+#define BT_ACL_BROADCAST                0x01
+
+#define bt_acl_handle(h)                ((h) & BIT_MASK(12))
+#define bt_acl_flags(h)                 ((h) >> 12)
+#define bt_acl_flags_pb(f)              ((f) & BIT_MASK(2))
+#define bt_acl_flags_bc(f)              ((f) >> 2)
+#define bt_acl_handle_pack(h, f)        ((h) | ((f) << 12))
+
+struct bt_hci_acl_hdr {
+	uint16_t handle;
+	uint16_t len;
+} __packed;
+#define BT_HCI_ACL_HDR_SIZE             4
+
+struct bt_hci_cmd_hdr {
+	uint16_t opcode;
+	uint8_t  param_len;
+} __packed;
+#define BT_HCI_CMD_HDR_SIZE             3
+
+/* Supported Commands */
+#define BT_CMD_TEST(cmd, octet, bit)            (cmd[octet] & BIT(bit))
+#define BT_CMD_LE_STATES(cmd)                   BT_CMD_TEST(cmd, 28, 3)
+
+#define BT_FEAT_TEST(feat, page, octet, bit)    (feat[page][octet] & BIT(bit))
+
+#define BT_FEAT_BREDR(feat)                     !BT_FEAT_TEST(feat, 0, 4, 5)
+#define BT_FEAT_LE(feat)                        BT_FEAT_TEST(feat, 0, 4, 6)
+#define BT_FEAT_EXT_FEATURES(feat)              BT_FEAT_TEST(feat, 0, 7, 7)
+#define BT_FEAT_HOST_SSP(feat)                  BT_FEAT_TEST(feat, 1, 0, 0)
+#define BT_FEAT_SC(feat)                        BT_FEAT_TEST(feat, 2, 1, 0)
+
+#define BT_FEAT_LMP_ESCO_CAPABLE(feat)          BT_FEAT_TEST(feat, 0, 3, 7)
+#define BT_FEAT_HV2_PKT(feat)                   BT_FEAT_TEST(feat, 0, 1, 4)
+#define BT_FEAT_HV3_PKT(feat)                   BT_FEAT_TEST(feat, 0, 1, 5)
+#define BT_FEAT_EV4_PKT(feat)                   BT_FEAT_TEST(feat, 0, 4, 0)
+#define BT_FEAT_EV5_PKT(feat)                   BT_FEAT_TEST(feat, 0, 4, 1)
+#define BT_FEAT_2EV3_PKT(feat)                  BT_FEAT_TEST(feat, 0, 5, 5)
+#define BT_FEAT_3EV3_PKT(feat)                  BT_FEAT_TEST(feat, 0, 5, 6)
+#define BT_FEAT_3SLOT_PKT(feat)                 BT_FEAT_TEST(feat, 0, 5, 7)
+
+/* LE features */
+#define BT_LE_FEAT_BIT_ENC                      0
+#define BT_LE_FEAT_BIT_CONN_PARAM_REQ           1
+#define BT_LE_FEAT_BIT_EXT_REJ_IND              2
+#define BT_LE_FEAT_BIT_SLAVE_FEAT_REQ           3
+#define BT_LE_FEAT_BIT_PING                     4
+#define BT_LE_FEAT_BIT_DLE                      5
+#define BT_LE_FEAT_BIT_PRIVACY                  6
+#define BT_LE_FEAT_BIT_EXT_SCAN                 7
+#define BT_LE_FEAT_BIT_PHY_2M                   8
+#define BT_LE_FEAT_BIT_SMI_TX                   9
+#define BT_LE_FEAT_BIT_SMI_RX                   10
+#define BT_LE_FEAT_BIT_PHY_CODED                11
+#define BT_LE_FEAT_BIT_EXT_ADV                  12
+#define BT_LE_FEAT_BIT_PER_ADV                  13
+#define BT_LE_FEAT_BIT_CHAN_SEL_ALGO_2          14
+#define BT_LE_FEAT_BIT_PWR_CLASS_1              15
+#define BT_LE_FEAT_BIT_MIN_USED_CHAN_PROC       16
+#define BT_LE_FEAT_BIT_CONN_CTE_REQ             17
+#define BT_LE_FEAT_BIT_CONN_CTE_RESP            18
+#define BT_LE_FEAT_BIT_CONNECTIONLESS_CTE_TX    19
+#define BT_LE_FEAT_BIT_CONNECTIONLESS_CTE_RX    20
+#define BT_LE_FEAT_BIT_ANT_SWITCH_TX_AOD        21
+#define BT_LE_FEAT_BIT_ANT_SWITCH_RX_AOA        22
+#define BT_LE_FEAT_BIT_RX_CTE                   23
+#define BT_LE_FEAT_BIT_PERIODIC_SYNC_XFER_SEND  24
+#define BT_LE_FEAT_BIT_PERIODIC_SYNC_XFER_RECV  25
+#define BT_LE_FEAT_BIT_SCA_UPDATE               26
+#define BT_LE_FEAT_BIT_REMOTE_PUB_KEY_VALIDATE  27
+#define BT_LE_FEAT_BIT_CIS_MASTER               28
+#define BT_LE_FEAT_BIT_CIS_SLAVE                29
+#define BT_LE_FEAT_BIT_ISO_BROADCASTER          30
+#define BT_LE_FEAT_BIT_SYNC_RECEIVER            31
+#define BT_LE_FEAT_BIT_ISO_CHANNELS             32
+#define BT_LE_FEAT_BIT_PWR_CTRL_REQ             33
+#define BT_LE_FEAT_BIT_PWR_CHG_IND              34
+#define BT_LE_FEAT_BIT_PATH_LOSS_MONITOR        35
+
+#define BT_LE_FEAT_TEST(feat, n)                (feat[(n) >> 3] & \
+						 BIT((n) & 7))
+
+#define BT_FEAT_LE_ENCR(feat)                   BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_ENC)
+#define BT_FEAT_LE_CONN_PARAM_REQ_PROC(feat)    BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_CONN_PARAM_REQ)
+#define BT_FEAT_LE_SLAVE_FEATURE_XCHG(feat)     BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
+#define BT_FEAT_LE_DLE(feat)                    BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_DLE)
+#define BT_FEAT_LE_PHY_2M(feat)                 BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PHY_2M)
+#define BT_FEAT_LE_PHY_CODED(feat)              BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PHY_CODED)
+#define BT_FEAT_LE_PRIVACY(feat)                BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PRIVACY)
+#define BT_FEAT_LE_EXT_ADV(feat)                BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_EXT_ADV)
+
+/* LE States */
+#define BT_LE_STATES_SLAVE_CONN_ADV(states)     (states & 0x0000004000000000)
+
+/* Bonding/authentication types */
+#define BT_HCI_NO_BONDING                       0x00
+#define BT_HCI_NO_BONDING_MITM                  0x01
+#define BT_HCI_DEDICATED_BONDING                0x02
+#define BT_HCI_DEDICATED_BONDING_MITM           0x03
+#define BT_HCI_GENERAL_BONDING                  0x04
+#define BT_HCI_GENERAL_BONDING_MITM             0x05
+
+/*
+ * MITM protection is enabled in SSP authentication requirements octet when
+ * LSB bit is set.
+ */
+#define BT_MITM                                 0x01
+
+/* I/O capabilities */
+#define BT_IO_DISPLAY_ONLY                      0x00
+#define BT_IO_DISPLAY_YESNO                     0x01
+#define BT_IO_KEYBOARD_ONLY                     0x02
+#define BT_IO_NO_INPUT_OUTPUT                   0x03
+
+/* SCO packet types */
+#define HCI_PKT_TYPE_HV1                        0x0020
+#define HCI_PKT_TYPE_HV2                        0x0040
+#define HCI_PKT_TYPE_HV3                        0x0080
+
+/* eSCO packet types */
+#define HCI_PKT_TYPE_ESCO_HV1                   0x0001
+#define HCI_PKT_TYPE_ESCO_HV2                   0x0002
+#define HCI_PKT_TYPE_ESCO_HV3                   0x0004
+#define HCI_PKT_TYPE_ESCO_EV3                   0x0008
+#define HCI_PKT_TYPE_ESCO_EV4                   0x0010
+#define HCI_PKT_TYPE_ESCO_EV5                   0x0020
+#define HCI_PKT_TYPE_ESCO_2EV3                  0x0040
+#define HCI_PKT_TYPE_ESCO_3EV3                  0x0080
+#define HCI_PKT_TYPE_ESCO_2EV5                  0x0100
+#define HCI_PKT_TYPE_ESCO_3EV5                  0x0200
+
+
+#define ESCO_PKT_MASK                           (HCI_PKT_TYPE_ESCO_HV1 | \
+						 HCI_PKT_TYPE_ESCO_HV2 | \
+						 HCI_PKT_TYPE_ESCO_HV3)
+#define SCO_PKT_MASK                            (HCI_PKT_TYPE_HV1 | \
+						 HCI_PKT_TYPE_HV2 | \
+						 HCI_PKT_TYPE_HV3)
+#define EDR_ESCO_PKT_MASK                       (HCI_PKT_TYPE_ESCO_2EV3 | \
+						 HCI_PKT_TYPE_ESCO_3EV3 | \
+						 HCI_PKT_TYPE_ESCO_2EV5 | \
+						 HCI_PKT_TYPE_ESCO_3EV5)
+
+/* HCI BR/EDR link types */
+#define BT_HCI_SCO                              0x00
+#define BT_HCI_ACL                              0x01
+#define BT_HCI_ESCO                             0x02
+
+/* OpCode Group Fields */
+#define BT_OGF_LINK_CTRL                        0x01
+#define BT_OGF_BASEBAND                         0x03
+#define BT_OGF_INFO                             0x04
+#define BT_OGF_STATUS                           0x05
+#define BT_OGF_LE                               0x08
+#define BT_OGF_VS                               0x3f
+
+/* Construct OpCode from OGF and OCF */
+#define BT_OP(ogf, ocf)                         ((ocf) | ((ogf) << 10))
+
+/* Invalid opcode */
+#define BT_OP_NOP				0x0000
+
+/* Obtain OGF from OpCode */
+#define BT_OGF(opcode)                          (((opcode) >> 10) & BIT_MASK(6))
+/* Obtain OCF from OpCode */
+#define BT_OCF(opcode)                          ((opcode) & BIT_MASK(10))
+
+#define BT_HCI_OP_INQUIRY                       BT_OP(BT_OGF_LINK_CTRL, 0x0001)
+struct bt_hci_op_inquiry {
+	uint8_t lap[3];
+	uint8_t length;
+	uint8_t num_rsp;
+} __packed;
+
+#define BT_HCI_OP_INQUIRY_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0002)
+
+#define BT_HCI_OP_CONNECT                       BT_OP(BT_OGF_LINK_CTRL, 0x0005)
+struct bt_hci_cp_connect {
+	bt_addr_t bdaddr;
+	uint16_t  packet_type;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint16_t  clock_offset;
+	uint8_t   allow_role_switch;
+} __packed;
+
+#define BT_HCI_OP_DISCONNECT                    BT_OP(BT_OGF_LINK_CTRL, 0x0006)
+struct bt_hci_cp_disconnect {
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+
+#define BT_HCI_OP_CONNECT_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0008)
+struct bt_hci_cp_connect_cancel {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_connect_cancel {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_ACCEPT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x0009)
+struct bt_hci_cp_accept_conn_req {
+	bt_addr_t bdaddr;
+	uint8_t   role;
+} __packed;
+
+#define BT_HCI_OP_SETUP_SYNC_CONN               BT_OP(BT_OGF_LINK_CTRL, 0x0028)
+struct bt_hci_cp_setup_sync_conn {
+	uint16_t  handle;
+	uint32_t  tx_bandwidth;
+	uint32_t  rx_bandwidth;
+	uint16_t  max_latency;
+	uint16_t  content_format;
+	uint8_t   retrans_effort;
+	uint16_t  pkt_type;
+} __packed;
+
+#define BT_HCI_OP_ACCEPT_SYNC_CONN_REQ          BT_OP(BT_OGF_LINK_CTRL, 0x0029)
+struct bt_hci_cp_accept_sync_conn_req {
+	bt_addr_t bdaddr;
+	uint32_t  tx_bandwidth;
+	uint32_t  rx_bandwidth;
+	uint16_t  max_latency;
+	uint16_t  content_format;
+	uint8_t   retrans_effort;
+	uint16_t  pkt_type;
+} __packed;
+
+#define BT_HCI_OP_REJECT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x000a)
+struct bt_hci_cp_reject_conn_req {
+	bt_addr_t bdaddr;
+	uint8_t   reason;
+} __packed;
+
+#define BT_HCI_OP_LINK_KEY_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000b)
+struct bt_hci_cp_link_key_reply {
+	bt_addr_t bdaddr;
+	uint8_t   link_key[16];
+} __packed;
+
+#define BT_HCI_OP_LINK_KEY_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000c)
+struct bt_hci_cp_link_key_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_PIN_CODE_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000d)
+struct bt_hci_cp_pin_code_reply {
+	bt_addr_t bdaddr;
+	uint8_t   pin_len;
+	uint8_t   pin_code[16];
+} __packed;
+struct bt_hci_rp_pin_code_reply {
+	uint8_t      status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_PIN_CODE_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000e)
+struct bt_hci_cp_pin_code_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_pin_code_neg_reply {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_AUTH_REQUESTED                BT_OP(BT_OGF_LINK_CTRL, 0x0011)
+struct bt_hci_cp_auth_requested {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_SET_CONN_ENCRYPT              BT_OP(BT_OGF_LINK_CTRL, 0x0013)
+struct bt_hci_cp_set_conn_encrypt {
+	uint16_t handle;
+	uint8_t  encrypt;
+} __packed;
+
+#define BT_HCI_OP_REMOTE_NAME_REQUEST           BT_OP(BT_OGF_LINK_CTRL, 0x0019)
+struct bt_hci_cp_remote_name_request {
+	bt_addr_t bdaddr;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint16_t  clock_offset;
+} __packed;
+
+#define BT_HCI_OP_REMOTE_NAME_CANCEL            BT_OP(BT_OGF_LINK_CTRL, 0x001a)
+struct bt_hci_cp_remote_name_cancel {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_remote_name_cancel {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_FEATURES          BT_OP(BT_OGF_LINK_CTRL, 0x001b)
+struct bt_hci_cp_read_remote_features {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_EXT_FEATURES      BT_OP(BT_OGF_LINK_CTRL, 0x001c)
+struct bt_hci_cp_read_remote_ext_features {
+	uint16_t handle;
+	uint8_t  page;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_VERSION_INFO      BT_OP(BT_OGF_LINK_CTRL, 0x001d)
+struct bt_hci_cp_read_remote_version_info {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_IO_CAPABILITY_REPLY           BT_OP(BT_OGF_LINK_CTRL, 0x002b)
+struct bt_hci_cp_io_capability_reply {
+	bt_addr_t bdaddr;
+	uint8_t   capability;
+	uint8_t   oob_data;
+	uint8_t   authentication;
+} __packed;
+
+#define BT_HCI_OP_USER_CONFIRM_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002c)
+#define BT_HCI_OP_USER_CONFIRM_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002d)
+struct bt_hci_cp_user_confirm_reply {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_user_confirm_reply {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_USER_PASSKEY_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002e)
+struct bt_hci_cp_user_passkey_reply {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_OP_USER_PASSKEY_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002f)
+struct bt_hci_cp_user_passkey_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_IO_CAPABILITY_NEG_REPLY       BT_OP(BT_OGF_LINK_CTRL, 0x0034)
+struct bt_hci_cp_io_capability_neg_reply {
+	bt_addr_t bdaddr;
+	uint8_t   reason;
+} __packed;
+
+#define BT_HCI_OP_SET_EVENT_MASK                BT_OP(BT_OGF_BASEBAND, 0x0001)
+struct bt_hci_cp_set_event_mask {
+	uint8_t  events[8];
+} __packed;
+
+#define BT_HCI_OP_RESET                         BT_OP(BT_OGF_BASEBAND, 0x0003)
+
+#define BT_HCI_OP_WRITE_LOCAL_NAME              BT_OP(BT_OGF_BASEBAND, 0x0013)
+struct bt_hci_write_local_name {
+	uint8_t local_name[248];
+} __packed;
+
+#define BT_HCI_OP_WRITE_PAGE_TIMEOUT            BT_OP(BT_OGF_BASEBAND, 0x0018)
+
+#define BT_HCI_OP_WRITE_SCAN_ENABLE             BT_OP(BT_OGF_BASEBAND, 0x001a)
+#define BT_BREDR_SCAN_DISABLED                  0x00
+#define BT_BREDR_SCAN_INQUIRY                   0x01
+#define BT_BREDR_SCAN_PAGE                      0x02
+
+#define BT_TX_POWER_LEVEL_CURRENT               0x00
+#define BT_TX_POWER_LEVEL_MAX                   0x01
+#define BT_HCI_OP_READ_TX_POWER_LEVEL           BT_OP(BT_OGF_BASEBAND, 0x002d)
+struct bt_hci_cp_read_tx_power_level {
+	uint16_t handle;
+	uint8_t  type;
+} __packed;
+
+struct bt_hci_rp_read_tx_power_level {
+	uint8_t  status;
+	uint16_t handle;
+	int8_t   tx_power_level;
+} __packed;
+
+#define BT_HCI_CTL_TO_HOST_FLOW_DISABLE         0x00
+#define BT_HCI_CTL_TO_HOST_FLOW_ENABLE          0x01
+#define BT_HCI_OP_SET_CTL_TO_HOST_FLOW          BT_OP(BT_OGF_BASEBAND, 0x0031)
+struct bt_hci_cp_set_ctl_to_host_flow {
+	uint8_t  flow_enable;
+} __packed;
+
+#define BT_HCI_OP_HOST_BUFFER_SIZE              BT_OP(BT_OGF_BASEBAND, 0x0033)
+struct bt_hci_cp_host_buffer_size {
+	uint16_t acl_mtu;
+	uint8_t  sco_mtu;
+	uint16_t acl_pkts;
+	uint16_t sco_pkts;
+} __packed;
+
+struct bt_hci_handle_count {
+	uint16_t handle;
+	uint16_t count;
+} __packed;
+
+#define BT_HCI_OP_HOST_NUM_COMPLETED_PACKETS    BT_OP(BT_OGF_BASEBAND, 0x0035)
+struct bt_hci_cp_host_num_completed_packets {
+	uint8_t  num_handles;
+	struct bt_hci_handle_count h[0];
+} __packed;
+
+#define BT_HCI_OP_WRITE_INQUIRY_MODE            BT_OP(BT_OGF_BASEBAND, 0x0045)
+struct bt_hci_cp_write_inquiry_mode {
+	uint8_t  mode;
+} __packed;
+
+#define BT_HCI_OP_WRITE_SSP_MODE                BT_OP(BT_OGF_BASEBAND, 0x0056)
+struct bt_hci_cp_write_ssp_mode {
+	uint8_t mode;
+} __packed;
+
+#define BT_HCI_OP_SET_EVENT_MASK_PAGE_2         BT_OP(BT_OGF_BASEBAND, 0x0063)
+struct bt_hci_cp_set_event_mask_page_2 {
+	uint8_t  events_page_2[8];
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_LE_HOST_SUPP         BT_OP(BT_OGF_BASEBAND, 0x006d)
+struct bt_hci_cp_write_le_host_supp {
+	uint8_t  le;
+	uint8_t  simul;
+} __packed;
+
+#define BT_HCI_OP_WRITE_SC_HOST_SUPP            BT_OP(BT_OGF_BASEBAND, 0x007a)
+struct bt_hci_cp_write_sc_host_supp {
+	uint8_t  sc_support;
+} __packed;
+
+#define BT_HCI_OP_READ_AUTH_PAYLOAD_TIMEOUT     BT_OP(BT_OGF_BASEBAND, 0x007b)
+struct bt_hci_cp_read_auth_payload_timeout {
+	uint16_t handle;
+} __packed;
+
+struct bt_hci_rp_read_auth_payload_timeout {
+	uint8_t  status;
+	uint16_t handle;
+	uint16_t auth_payload_timeout;
+} __packed;
+
+#define BT_HCI_OP_WRITE_AUTH_PAYLOAD_TIMEOUT    BT_OP(BT_OGF_BASEBAND, 0x007c)
+struct bt_hci_cp_write_auth_payload_timeout {
+	uint16_t handle;
+	uint16_t auth_payload_timeout;
+} __packed;
+
+struct bt_hci_rp_write_auth_payload_timeout {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+/* HCI version from Assigned Numbers */
+#define BT_HCI_VERSION_1_0B                     0
+#define BT_HCI_VERSION_1_1                      1
+#define BT_HCI_VERSION_1_2                      2
+#define BT_HCI_VERSION_2_0                      3
+#define BT_HCI_VERSION_2_1                      4
+#define BT_HCI_VERSION_3_0                      5
+#define BT_HCI_VERSION_4_0                      6
+#define BT_HCI_VERSION_4_1                      7
+#define BT_HCI_VERSION_4_2                      8
+#define BT_HCI_VERSION_5_0                      9
+#define BT_HCI_VERSION_5_1                      10
+#define BT_HCI_VERSION_5_2                      11
+
+#define BT_HCI_OP_READ_LOCAL_VERSION_INFO       BT_OP(BT_OGF_INFO, 0x0001)
+struct bt_hci_rp_read_local_version_info {
+	uint8_t  status;
+	uint8_t  hci_version;
+	uint16_t hci_revision;
+	uint8_t  lmp_version;
+	uint16_t manufacturer;
+	uint16_t lmp_subversion;
+} __packed;
+
+#define BT_HCI_OP_READ_SUPPORTED_COMMANDS       BT_OP(BT_OGF_INFO, 0x0002)
+struct bt_hci_rp_read_supported_commands {
+	uint8_t  status;
+	uint8_t  commands[64];
+} __packed;
+
+#define BT_HCI_OP_READ_LOCAL_EXT_FEATURES       BT_OP(BT_OGF_INFO, 0x0004)
+struct bt_hci_cp_read_local_ext_features {
+	uint8_t page;
+};
+struct bt_hci_rp_read_local_ext_features {
+	uint8_t  status;
+	uint8_t  page;
+	uint8_t  max_page;
+	uint8_t  ext_features[8];
+} __packed;
+
+#define BT_HCI_OP_READ_LOCAL_FEATURES           BT_OP(BT_OGF_INFO, 0x0003)
+struct bt_hci_rp_read_local_features {
+	uint8_t  status;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_OP_READ_BUFFER_SIZE              BT_OP(BT_OGF_INFO, 0x0005)
+struct bt_hci_rp_read_buffer_size {
+	uint8_t  status;
+	uint16_t acl_max_len;
+	uint8_t  sco_max_len;
+	uint16_t acl_max_num;
+	uint16_t sco_max_num;
+} __packed;
+
+#define BT_HCI_OP_READ_BD_ADDR                  BT_OP(BT_OGF_INFO, 0x0009)
+struct bt_hci_rp_read_bd_addr {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_READ_RSSI                     BT_OP(BT_OGF_STATUS, 0x0005)
+struct bt_hci_cp_read_rssi {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_read_rssi {
+	uint8_t  status;
+	uint16_t handle;
+	int8_t   rssi;
+} __packed;
+
+#define BT_HCI_ENCRYPTION_KEY_SIZE_MIN          7
+#define BT_HCI_ENCRYPTION_KEY_SIZE_MAX          16
+
+#define BT_HCI_OP_READ_ENCRYPTION_KEY_SIZE      BT_OP(BT_OGF_STATUS, 0x0008)
+struct bt_hci_cp_read_encryption_key_size {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_read_encryption_key_size {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  key_size;
+} __packed;
+
+/* BLE */
+
+#define BT_HCI_OP_LE_SET_EVENT_MASK             BT_OP(BT_OGF_LE, 0x0001)
+struct bt_hci_cp_le_set_event_mask {
+	uint8_t events[8];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_BUFFER_SIZE           BT_OP(BT_OGF_LE, 0x0002)
+struct bt_hci_rp_le_read_buffer_size {
+	uint8_t  status;
+	uint16_t le_max_len;
+	uint8_t  le_max_num;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_LOCAL_FEATURES        BT_OP(BT_OGF_LE, 0x0003)
+struct bt_hci_rp_le_read_local_features {
+	uint8_t  status;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_RANDOM_ADDRESS         BT_OP(BT_OGF_LE, 0x0005)
+struct bt_hci_cp_le_set_random_address {
+	bt_addr_t bdaddr;
+} __packed;
+
+/* LE Advertising Types (LE Advertising Parameters Set)*/
+#define BT_LE_ADV_IND                  (__DEPRECATED_MACRO 0x00)
+#define BT_LE_ADV_DIRECT_IND           (__DEPRECATED_MACRO 0x01)
+#define BT_LE_ADV_SCAN_IND             (__DEPRECATED_MACRO 0x02)
+#define BT_LE_ADV_NONCONN_IND          (__DEPRECATED_MACRO 0x03)
+#define BT_LE_ADV_DIRECT_IND_LOW_DUTY  (__DEPRECATED_MACRO 0x04)
+/* LE Advertising PDU Types. */
+#define BT_LE_ADV_SCAN_RSP             (__DEPRECATED_MACRO 0x04)
+
+#define BT_HCI_ADV_IND                          0x00
+#define BT_HCI_ADV_DIRECT_IND                   0x01
+#define BT_HCI_ADV_SCAN_IND                     0x02
+#define BT_HCI_ADV_NONCONN_IND                  0x03
+#define BT_HCI_ADV_DIRECT_IND_LOW_DUTY          0x04
+#define BT_HCI_ADV_SCAN_RSP                     0x04
+
+#define BT_LE_ADV_FP_NO_WHITELIST               0x00
+#define BT_LE_ADV_FP_WHITELIST_SCAN_REQ         0x01
+#define BT_LE_ADV_FP_WHITELIST_CONN_IND         0x02
+#define BT_LE_ADV_FP_WHITELIST_BOTH             0x03
+
+#define BT_HCI_OP_LE_SET_ADV_PARAM              BT_OP(BT_OGF_LE, 0x0006)
+struct bt_hci_cp_le_set_adv_param {
+	uint16_t     min_interval;
+	uint16_t     max_interval;
+	uint8_t      type;
+	uint8_t      own_addr_type;
+	bt_addr_le_t direct_addr;
+	uint8_t      channel_map;
+	uint8_t      filter_policy;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_ADV_CHAN_TX_POWER     BT_OP(BT_OGF_LE, 0x0007)
+struct bt_hci_rp_le_read_chan_tx_power {
+	uint8_t status;
+	int8_t  tx_power_level;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_ADV_DATA               BT_OP(BT_OGF_LE, 0x0008)
+struct bt_hci_cp_le_set_adv_data {
+	uint8_t  len;
+	uint8_t  data[31];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_SCAN_RSP_DATA          BT_OP(BT_OGF_LE, 0x0009)
+struct bt_hci_cp_le_set_scan_rsp_data {
+	uint8_t  len;
+	uint8_t  data[31];
+} __packed;
+
+#define BT_HCI_LE_ADV_DISABLE                   0x00
+#define BT_HCI_LE_ADV_ENABLE                    0x01
+
+#define BT_HCI_OP_LE_SET_ADV_ENABLE             BT_OP(BT_OGF_LE, 0x000a)
+struct bt_hci_cp_le_set_adv_enable {
+	uint8_t  enable;
+} __packed;
+
+/* Scan types */
+#define BT_HCI_OP_LE_SET_SCAN_PARAM             BT_OP(BT_OGF_LE, 0x000b)
+#define BT_HCI_LE_SCAN_PASSIVE                  0x00
+#define BT_HCI_LE_SCAN_ACTIVE                   0x01
+
+#define BT_HCI_LE_SCAN_FP_NO_WHITELIST          0x00
+#define BT_HCI_LE_SCAN_FP_USE_WHITELIST         0x01
+
+struct bt_hci_cp_le_set_scan_param {
+	uint8_t  scan_type;
+	uint16_t interval;
+	uint16_t window;
+	uint8_t  addr_type;
+	uint8_t  filter_policy;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_SCAN_ENABLE            BT_OP(BT_OGF_LE, 0x000c)
+
+#define BT_HCI_LE_SCAN_DISABLE                  0x00
+#define BT_HCI_LE_SCAN_ENABLE                   0x01
+
+#define BT_HCI_LE_SCAN_FILTER_DUP_DISABLE       0x00
+#define BT_HCI_LE_SCAN_FILTER_DUP_ENABLE        0x01
+
+struct bt_hci_cp_le_set_scan_enable {
+	uint8_t  enable;
+	uint8_t  filter_dup;
+} __packed;
+
+#define BT_HCI_OP_LE_CREATE_CONN                BT_OP(BT_OGF_LE, 0x000d)
+
+#define BT_HCI_LE_CREATE_CONN_FP_DIRECT         0x00
+#define BT_HCI_LE_CREATE_CONN_FP_WHITELIST      0x01
+
+struct bt_hci_cp_le_create_conn {
+	uint16_t     scan_interval;
+	uint16_t     scan_window;
+	uint8_t      filter_policy;
+	bt_addr_le_t peer_addr;
+	uint8_t      own_addr_type;
+	uint16_t     conn_interval_min;
+	uint16_t     conn_interval_max;
+	uint16_t     conn_latency;
+	uint16_t     supervision_timeout;
+	uint16_t     min_ce_len;
+	uint16_t     max_ce_len;
+} __packed;
+
+#define BT_HCI_OP_LE_CREATE_CONN_CANCEL         BT_OP(BT_OGF_LE, 0x000e)
+
+#define BT_HCI_OP_LE_READ_WL_SIZE               BT_OP(BT_OGF_LE, 0x000f)
+struct bt_hci_rp_le_read_wl_size {
+	uint8_t  status;
+	uint8_t  wl_size;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_WL                   BT_OP(BT_OGF_LE, 0x0010)
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_WL              BT_OP(BT_OGF_LE, 0x0011)
+struct bt_hci_cp_le_add_dev_to_wl {
+	bt_addr_le_t  addr;
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_WL            BT_OP(BT_OGF_LE, 0x0012)
+struct bt_hci_cp_le_rem_dev_from_wl {
+	bt_addr_le_t  addr;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_UPDATE                BT_OP(BT_OGF_LE, 0x0013)
+struct hci_cp_le_conn_update {
+	uint16_t handle;
+	uint16_t conn_interval_min;
+	uint16_t conn_interval_max;
+	uint16_t conn_latency;
+	uint16_t supervision_timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_HOST_CHAN_CLASSIF      BT_OP(BT_OGF_LE, 0x0014)
+struct bt_hci_cp_le_set_host_chan_classif {
+	uint8_t  ch_map[5];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_CHAN_MAP              BT_OP(BT_OGF_LE, 0x0015)
+struct bt_hci_cp_le_read_chan_map {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_read_chan_map {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  ch_map[5];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_REMOTE_FEATURES       BT_OP(BT_OGF_LE, 0x0016)
+struct bt_hci_cp_le_read_remote_features {
+	uint16_t  handle;
+} __packed;
+
+#define BT_HCI_OP_LE_ENCRYPT                    BT_OP(BT_OGF_LE, 0x0017)
+struct bt_hci_cp_le_encrypt {
+	uint8_t  key[16];
+	uint8_t  plaintext[16];
+} __packed;
+struct bt_hci_rp_le_encrypt {
+	uint8_t  status;
+	uint8_t  enc_data[16];
+} __packed;
+
+#define BT_HCI_OP_LE_RAND                       BT_OP(BT_OGF_LE, 0x0018)
+struct bt_hci_rp_le_rand {
+	uint8_t  status;
+	uint8_t  rand[8];
+} __packed;
+
+#define BT_HCI_OP_LE_START_ENCRYPTION           BT_OP(BT_OGF_LE, 0x0019)
+struct bt_hci_cp_le_start_encryption {
+	uint16_t handle;
+	uint64_t rand;
+	uint16_t ediv;
+	uint8_t  ltk[16];
+} __packed;
+
+#define BT_HCI_OP_LE_LTK_REQ_REPLY              BT_OP(BT_OGF_LE, 0x001a)
+struct bt_hci_cp_le_ltk_req_reply {
+	uint16_t handle;
+	uint8_t  ltk[16];
+} __packed;
+struct bt_hci_rp_le_ltk_req_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_LTK_REQ_NEG_REPLY          BT_OP(BT_OGF_LE, 0x001b)
+struct bt_hci_cp_le_ltk_req_neg_reply {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_ltk_req_neg_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_SUPP_STATES           BT_OP(BT_OGF_LE, 0x001c)
+struct bt_hci_rp_le_read_supp_states {
+	uint8_t  status;
+	uint8_t  le_states[8];
+} __packed;
+
+#define BT_HCI_OP_LE_RX_TEST                    BT_OP(BT_OGF_LE, 0x001d)
+struct bt_hci_cp_le_rx_test {
+	uint8_t  rx_ch;
+} __packed;
+
+#define BT_HCI_OP_LE_TX_TEST                    BT_OP(BT_OGF_LE, 0x001e)
+struct bt_hci_cp_le_tx_test {
+	uint8_t  tx_ch;
+	uint8_t  test_data_len;
+	uint8_t  pkt_payload;
+} __packed;
+
+#define BT_HCI_OP_LE_TEST_END                   BT_OP(BT_OGF_LE, 0x001f)
+struct bt_hci_rp_le_test_end {
+	uint8_t  status;
+	uint16_t rx_pkt_count;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_PARAM_REQ_REPLY       BT_OP(BT_OGF_LE, 0x0020)
+struct bt_hci_cp_le_conn_param_req_reply {
+	uint16_t handle;
+	uint16_t interval_min;
+	uint16_t interval_max;
+	uint16_t latency;
+	uint16_t timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+struct bt_hci_rp_le_conn_param_req_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY   BT_OP(BT_OGF_LE, 0x0021)
+struct bt_hci_cp_le_conn_param_req_neg_reply {
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+struct bt_hci_rp_le_conn_param_req_neg_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_DATA_LEN               BT_OP(BT_OGF_LE, 0x0022)
+struct bt_hci_cp_le_set_data_len {
+	uint16_t handle;
+	uint16_t tx_octets;
+	uint16_t tx_time;
+} __packed;
+struct bt_hci_rp_le_set_data_len {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_DEFAULT_DATA_LEN      BT_OP(BT_OGF_LE, 0x0023)
+struct bt_hci_rp_le_read_default_data_len {
+	uint8_t  status;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_DEFAULT_DATA_LEN     BT_OP(BT_OGF_LE, 0x0024)
+struct bt_hci_cp_le_write_default_data_len {
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+} __packed;
+
+#define BT_HCI_OP_LE_P256_PUBLIC_KEY            BT_OP(BT_OGF_LE, 0x0025)
+
+#define BT_HCI_OP_LE_GENERATE_DHKEY             BT_OP(BT_OGF_LE, 0x0026)
+struct bt_hci_cp_le_generate_dhkey {
+	uint8_t key[64];
+} __packed;
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_RL              BT_OP(BT_OGF_LE, 0x0027)
+struct bt_hci_cp_le_add_dev_to_rl {
+	bt_addr_le_t  peer_id_addr;
+	uint8_t       peer_irk[16];
+	uint8_t       local_irk[16];
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_RL            BT_OP(BT_OGF_LE, 0x0028)
+struct bt_hci_cp_le_rem_dev_from_rl {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_RL                   BT_OP(BT_OGF_LE, 0x0029)
+
+#define BT_HCI_OP_LE_READ_RL_SIZE               BT_OP(BT_OGF_LE, 0x002a)
+struct bt_hci_rp_le_read_rl_size {
+	uint8_t  status;
+	uint8_t  rl_size;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_PEER_RPA              BT_OP(BT_OGF_LE, 0x002b)
+struct bt_hci_cp_le_read_peer_rpa {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+struct bt_hci_rp_le_read_peer_rpa {
+	uint8_t    status;
+	bt_addr_t  peer_rpa;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_LOCAL_RPA             BT_OP(BT_OGF_LE, 0x002c)
+struct bt_hci_cp_le_read_local_rpa {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+struct bt_hci_rp_le_read_local_rpa {
+	uint8_t    status;
+	bt_addr_t  local_rpa;
+} __packed;
+
+#define BT_HCI_ADDR_RES_DISABLE                 0x00
+#define BT_HCI_ADDR_RES_ENABLE                  0x01
+
+#define BT_HCI_OP_LE_SET_ADDR_RES_ENABLE        BT_OP(BT_OGF_LE, 0x002d)
+struct bt_hci_cp_le_set_addr_res_enable {
+	uint8_t  enable;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_RPA_TIMEOUT            BT_OP(BT_OGF_LE, 0x002e)
+struct bt_hci_cp_le_set_rpa_timeout {
+	uint16_t rpa_timeout;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_MAX_DATA_LEN          BT_OP(BT_OGF_LE, 0x002f)
+struct bt_hci_rp_le_read_max_data_len {
+	uint8_t  status;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+	uint16_t max_rx_octets;
+	uint16_t max_rx_time;
+} __packed;
+
+#define BT_HCI_LE_PHY_1M                        0x01
+#define BT_HCI_LE_PHY_2M                        0x02
+#define BT_HCI_LE_PHY_CODED                     0x03
+
+#define BT_HCI_OP_LE_READ_PHY                   BT_OP(BT_OGF_LE, 0x0030)
+struct bt_hci_cp_le_read_phy {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_read_phy {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  tx_phy;
+	uint8_t  rx_phy;
+} __packed;
+
+#define BT_HCI_LE_PHY_TX_ANY                    BIT(0)
+#define BT_HCI_LE_PHY_RX_ANY                    BIT(1)
+
+#define BT_HCI_LE_PHY_PREFER_1M                 BIT(0)
+#define BT_HCI_LE_PHY_PREFER_2M                 BIT(1)
+#define BT_HCI_LE_PHY_PREFER_CODED              BIT(2)
+
+#define BT_HCI_OP_LE_SET_DEFAULT_PHY            BT_OP(BT_OGF_LE, 0x0031)
+struct bt_hci_cp_le_set_default_phy {
+	uint8_t all_phys;
+	uint8_t tx_phys;
+	uint8_t rx_phys;
+} __packed;
+
+#define BT_HCI_LE_PHY_CODED_ANY                 0x00
+#define BT_HCI_LE_PHY_CODED_S2                  0x01
+#define BT_HCI_LE_PHY_CODED_S8                  0x02
+
+#define BT_HCI_OP_LE_SET_PHY                    BT_OP(BT_OGF_LE, 0x0032)
+struct bt_hci_cp_le_set_phy {
+	uint16_t  handle;
+	uint8_t   all_phys;
+	uint8_t   tx_phys;
+	uint8_t   rx_phys;
+	uint16_t  phy_opts;
+} __packed;
+
+#define BT_HCI_LE_MOD_INDEX_STANDARD            0x00
+#define BT_HCI_LE_MOD_INDEX_STABLE              0x01
+
+#define BT_HCI_OP_LE_ENH_RX_TEST                BT_OP(BT_OGF_LE, 0x0033)
+struct bt_hci_cp_le_enh_rx_test {
+	uint8_t  rx_ch;
+	uint8_t  phy;
+	uint8_t  mod_index;
+} __packed;
+
+/* Extends BT_HCI_LE_PHY */
+#define BT_HCI_LE_TX_PHY_CODED_S8               0x03
+#define BT_HCI_LE_TX_PHY_CODED_S2               0x04
+
+#define BT_HCI_OP_LE_ENH_TX_TEST                BT_OP(BT_OGF_LE, 0x0034)
+struct bt_hci_cp_le_enh_tx_test {
+	uint8_t  tx_ch;
+	uint8_t  test_data_len;
+	uint8_t  pkt_payload;
+	uint8_t  phy;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_ADV_SET_RANDOM_ADDR    BT_OP(BT_OGF_LE, 0x0035)
+struct bt_hci_cp_le_set_adv_set_random_addr {
+	uint8_t   handle;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_LE_ADV_PROP_CONN                 BIT(0)
+#define BT_HCI_LE_ADV_PROP_SCAN                 BIT(1)
+#define BT_HCI_LE_ADV_PROP_DIRECT               BIT(2)
+#define BT_HCI_LE_ADV_PROP_HI_DC_CONN           BIT(3)
+#define BT_HCI_LE_ADV_PROP_LEGACY               BIT(4)
+#define BT_HCI_LE_ADV_PROP_ANON                 BIT(5)
+#define BT_HCI_LE_ADV_PROP_TX_POWER             BIT(6)
+
+#define BT_HCI_LE_ADV_SCAN_REQ_ENABLE  1
+#define BT_HCI_LE_ADV_SCAN_REQ_DISABLE 0
+
+#define BT_HCI_LE_ADV_TX_POWER_NO_PREF 0x7F
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_PARAM          BT_OP(BT_OGF_LE, 0x0036)
+struct bt_hci_cp_le_set_ext_adv_param {
+	uint8_t      handle;
+	uint16_t     props;
+	uint8_t      prim_min_interval[3];
+	uint8_t      prim_max_interval[3];
+	uint8_t      prim_channel_map;
+	uint8_t      own_addr_type;
+	bt_addr_le_t peer_addr;
+	uint8_t      filter_policy;
+	int8_t       tx_power;
+	uint8_t      prim_adv_phy;
+	uint8_t      sec_adv_max_skip;
+	uint8_t      sec_adv_phy;
+	uint8_t      sid;
+	uint8_t      scan_req_notify_enable;
+} __packed;
+struct bt_hci_rp_le_set_ext_adv_param {
+	uint8_t status;
+	int8_t  tx_power;
+} __packed;
+
+#define BT_HCI_LE_EXT_ADV_OP_INTERM_FRAG        0x00
+#define BT_HCI_LE_EXT_ADV_OP_FIRST_FRAG         0x01
+#define BT_HCI_LE_EXT_ADV_OP_LAST_FRAG          0x02
+#define BT_HCI_LE_EXT_ADV_OP_COMPLETE_DATA      0x03
+#define BT_HCI_LE_EXT_ADV_OP_UNCHANGED_DATA     0x04
+
+#define BT_HCI_LE_EXT_ADV_FRAG_ENABLED          0x00
+#define BT_HCI_LE_EXT_ADV_FRAG_DISABLED         0x01
+
+#define BT_HCI_LE_EXT_ADV_FRAG_MAX_LEN          251
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_DATA           BT_OP(BT_OGF_LE, 0x0037)
+struct bt_hci_cp_le_set_ext_adv_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  frag_pref;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_RSP_DATA      BT_OP(BT_OGF_LE, 0x0038)
+struct bt_hci_cp_le_set_ext_scan_rsp_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  frag_pref;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0039)
+struct bt_hci_ext_adv_set {
+	uint8_t  handle;
+	uint16_t duration;
+	uint8_t  max_ext_adv_evts;
+} __packed;
+
+struct bt_hci_cp_le_set_ext_adv_enable {
+	uint8_t  enable;
+	uint8_t  set_num;
+	struct bt_hci_ext_adv_set s[0];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN      BT_OP(BT_OGF_LE, 0x003a)
+struct bt_hci_rp_le_read_max_adv_data_len {
+	uint8_t  status;
+	uint16_t max_adv_data_len;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_NUM_ADV_SETS          BT_OP(BT_OGF_LE, 0x003b)
+struct bt_hci_rp_le_read_num_adv_sets {
+	uint8_t  status;
+	uint8_t  num_sets;
+} __packed;
+
+#define BT_HCI_OP_LE_REMOVE_ADV_SET             BT_OP(BT_OGF_LE, 0x003c)
+struct bt_hci_cp_le_remove_adv_set {
+	uint8_t  handle;
+} __packed;
+
+#define BT_HCI_OP_CLEAR_ADV_SETS                BT_OP(BT_OGF_LE, 0x003d)
+
+#define BT_HCI_OP_LE_SET_PER_ADV_PARAM          BT_OP(BT_OGF_LE, 0x003e)
+struct bt_hci_cp_le_set_per_adv_param {
+	uint8_t  handle;
+	uint16_t min_interval;
+	uint16_t max_interval;
+	uint16_t props;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_PER_ADV_DATA           BT_OP(BT_OGF_LE, 0x003f)
+struct bt_hci_cp_le_set_per_adv_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_PER_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0040)
+struct bt_hci_cp_le_set_per_adv_enable {
+	uint8_t  enable;
+	uint8_t  handle;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_PARAM         BT_OP(BT_OGF_LE, 0x0041)
+struct bt_hci_ext_scan_phy {
+	uint8_t  type;
+	uint16_t interval;
+	uint16_t window;
+} __packed;
+
+#define BT_HCI_LE_EXT_SCAN_PHY_1M               BIT(0)
+#define BT_HCI_LE_EXT_SCAN_PHY_2M               BIT(1)
+#define BT_HCI_LE_EXT_SCAN_PHY_CODED            BIT(2)
+
+struct bt_hci_cp_le_set_ext_scan_param {
+	uint8_t  own_addr_type;
+	uint8_t  filter_policy;
+	uint8_t  phys;
+	struct bt_hci_ext_scan_phy p[0];
+} __packed;
+
+/* Extends BT_HCI_LE_SCAN_FILTER_DUP */
+#define BT_HCI_LE_EXT_SCAN_FILTER_DUP_ENABLE_RESET  0x02
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_ENABLE        BT_OP(BT_OGF_LE, 0x0042)
+struct bt_hci_cp_le_set_ext_scan_enable {
+	uint8_t  enable;
+	uint8_t  filter_dup;
+	uint16_t duration;
+	uint16_t period;
+} __packed;
+
+#define BT_HCI_OP_LE_EXT_CREATE_CONN            BT_OP(BT_OGF_LE, 0x0043)
+struct bt_hci_ext_conn_phy {
+	uint16_t scan_interval;
+	uint16_t scan_window;
+	uint16_t conn_interval_min;
+	uint16_t conn_interval_max;
+	uint16_t conn_latency;
+	uint16_t supervision_timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+
+struct bt_hci_cp_le_ext_create_conn {
+	uint8_t      filter_policy;
+	uint8_t      own_addr_type;
+	bt_addr_le_t peer_addr;
+	uint8_t      phys;
+	struct bt_hci_ext_conn_phy p[0];
+} __packed;
+
+#define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC        BT_OP(BT_OGF_LE, 0x0044)
+struct bt_hci_cp_le_per_adv_create_sync {
+	uint8_t      filter_policy;
+	uint8_t      sid;
+	bt_addr_le_t addr;
+	uint16_t     skip;
+	uint16_t     sync_timeout;
+	uint8_t      unused;
+} __packed;
+
+#define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC_CANCEL BT_OP(BT_OGF_LE, 0x0045)
+
+#define BT_HCI_OP_LE_PER_ADV_TERMINATE_SYNC     BT_OP(BT_OGF_LE, 0x0046)
+struct bt_hci_cp_le_per_adv_terminate_sync {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_PER_ADV_LIST    BT_OP(BT_OGF_LE, 0x0047)
+struct bt_hci_cp_le_add_dev_to_per_adv_list {
+	bt_addr_le_t addr;
+	uint8_t      sid;
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_PER_ADV_LIST  BT_OP(BT_OGF_LE, 0x0048)
+struct bt_hci_cp_le_rem_dev_from_per_adv_list {
+	bt_addr_le_t addr;
+	uint8_t      sid;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_PER_ADV_LIST         BT_OP(BT_OGF_LE, 0x0049)
+
+#define BT_HCI_OP_LE_READ_PER_ADV_LIST_SIZE     BT_OP(BT_OGF_LE, 0x004a)
+struct bt_hci_rp_le_read_per_adv_list_size {
+	uint8_t  status;
+	uint8_t  list_size;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_TX_POWER              BT_OP(BT_OGF_LE, 0x004b)
+struct bt_hci_rp_le_read_tx_power {
+	uint8_t status;
+	int8_t  min_tx_power;
+	int8_t  max_tx_power;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_RF_PATH_COMP          BT_OP(BT_OGF_LE, 0x004c)
+struct bt_hci_rp_le_read_rf_path_comp {
+	uint8_t status;
+	int16_t tx_path_comp;
+	int16_t rx_path_comp;
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_RF_PATH_COMP         BT_OP(BT_OGF_LE, 0x004d)
+struct bt_hci_cp_le_write_rf_path_comp {
+	int16_t  tx_path_comp;
+	int16_t  rx_path_comp;
+} __packed;
+
+#define BT_HCI_LE_PRIVACY_MODE_NETWORK          0x00
+#define BT_HCI_LE_PRIVACY_MODE_DEVICE           0x01
+
+#define BT_HCI_OP_LE_SET_PRIVACY_MODE           BT_OP(BT_OGF_LE, 0x004e)
+struct bt_hci_cp_le_set_privacy_mode {
+	bt_addr_le_t id_addr;
+	uint8_t         mode;
+} __packed;
+
+/* Event definitions */
+
+#define BT_HCI_EVT_UNKNOWN                      0x00
+#define BT_HCI_EVT_VENDOR                       0xff
+
+#define BT_HCI_EVT_INQUIRY_COMPLETE             0x01
+struct bt_hci_evt_inquiry_complete {
+	uint8_t status;
+} __packed;
+
+#define BT_HCI_EVT_CONN_COMPLETE                0x03
+struct bt_hci_evt_conn_complete {
+	uint8_t   status;
+	uint16_t  handle;
+	bt_addr_t bdaddr;
+	uint8_t   link_type;
+	uint8_t   encr_enabled;
+} __packed;
+
+#define BT_HCI_EVT_CONN_REQUEST                 0x04
+struct bt_hci_evt_conn_request {
+	bt_addr_t bdaddr;
+	uint8_t   dev_class[3];
+	uint8_t   link_type;
+} __packed;
+
+#define BT_HCI_EVT_DISCONN_COMPLETE             0x05
+struct bt_hci_evt_disconn_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+
+#define BT_HCI_EVT_AUTH_COMPLETE                0x06
+struct bt_hci_evt_auth_complete {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_NAME_REQ_COMPLETE     0x07
+struct bt_hci_evt_remote_name_req_complete {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+	uint8_t   name[248];
+} __packed;
+
+#define BT_HCI_EVT_ENCRYPT_CHANGE               0x08
+struct bt_hci_evt_encrypt_change {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  encrypt;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_FEATURES              0x0b
+struct bt_hci_evt_remote_features {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_VERSION_INFO          0x0c
+struct bt_hci_evt_remote_version_info {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  version;
+	uint16_t manufacturer;
+	uint16_t subversion;
+} __packed;
+
+#define BT_HCI_EVT_CMD_COMPLETE                 0x0e
+struct bt_hci_evt_cmd_complete {
+	uint8_t  ncmd;
+	uint16_t opcode;
+} __packed;
+
+struct bt_hci_evt_cc_status {
+	uint8_t  status;
+} __packed;
+
+#define BT_HCI_EVT_CMD_STATUS                   0x0f
+struct bt_hci_evt_cmd_status {
+	uint8_t  status;
+	uint8_t  ncmd;
+	uint16_t opcode;
+} __packed;
+
+#define BT_HCI_EVT_ROLE_CHANGE                  0x12
+struct bt_hci_evt_role_change {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+	uint8_t   role;
+} __packed;
+
+#define BT_HCI_EVT_NUM_COMPLETED_PACKETS        0x13
+struct bt_hci_evt_num_completed_packets {
+	uint8_t  num_handles;
+	struct bt_hci_handle_count h[0];
+} __packed;
+
+#define BT_HCI_EVT_PIN_CODE_REQ                 0x16
+struct bt_hci_evt_pin_code_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_LINK_KEY_REQ                 0x17
+struct bt_hci_evt_link_key_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+/* Link Key types */
+#define BT_LK_COMBINATION                       0x00
+#define BT_LK_LOCAL_UNIT                        0x01
+#define BT_LK_REMOTE_UNIT                       0x02
+#define BT_LK_DEBUG_COMBINATION                 0x03
+#define BT_LK_UNAUTH_COMBINATION_P192           0x04
+#define BT_LK_AUTH_COMBINATION_P192             0x05
+#define BT_LK_CHANGED_COMBINATION               0x06
+#define BT_LK_UNAUTH_COMBINATION_P256           0x07
+#define BT_LK_AUTH_COMBINATION_P256             0x08
+
+#define BT_HCI_EVT_LINK_KEY_NOTIFY              0x18
+struct bt_hci_evt_link_key_notify {
+	bt_addr_t bdaddr;
+	uint8_t   link_key[16];
+	uint8_t   key_type;
+} __packed;
+
+/* Overflow link types */
+#define BT_OVERFLOW_LINK_SYNCH                  0x00
+#define BT_OVERFLOW_LINK_ACL                    0x01
+
+#define BT_HCI_EVT_DATA_BUF_OVERFLOW            0x1a
+struct bt_hci_evt_data_buf_overflow {
+	uint8_t  link_type;
+} __packed;
+
+#define BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI     0x22
+struct bt_hci_evt_inquiry_result_with_rssi {
+	bt_addr_t addr;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint8_t   cod[3];
+	uint16_t  clock_offset;
+	int8_t    rssi;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_EXT_FEATURES          0x23
+struct bt_hci_evt_remote_ext_features {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  page;
+	uint8_t  max_page;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_SYNC_CONN_COMPLETE           0x2c
+struct bt_hci_evt_sync_conn_complete {
+	uint8_t    status;
+	uint16_t   handle;
+	bt_addr_t  bdaddr;
+	uint8_t    link_type;
+	uint8_t    tx_interval;
+	uint8_t    retansmission_window;
+	uint16_t   rx_pkt_length;
+	uint16_t   tx_pkt_length;
+	uint8_t    air_mode;
+} __packed;
+
+#define BT_HCI_EVT_EXTENDED_INQUIRY_RESULT      0x2f
+struct bt_hci_evt_extended_inquiry_result {
+	uint8_t    num_reports;
+	bt_addr_t  addr;
+	uint8_t    pscan_rep_mode;
+	uint8_t    reserved;
+	uint8_t    cod[3];
+	uint16_t   clock_offset;
+	int8_t     rssi;
+	uint8_t    eir[240];
+} __packed;
+
+#define BT_HCI_EVT_ENCRYPT_KEY_REFRESH_COMPLETE 0x30
+struct bt_hci_evt_encrypt_key_refresh_complete {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_IO_CAPA_REQ                  0x31
+struct bt_hci_evt_io_capa_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_IO_CAPA_RESP                 0x32
+struct bt_hci_evt_io_capa_resp {
+	bt_addr_t bdaddr;
+	uint8_t   capability;
+	uint8_t   oob_data;
+	uint8_t   authentication;
+} __packed;
+
+#define BT_HCI_EVT_USER_CONFIRM_REQ             0x33
+struct bt_hci_evt_user_confirm_req {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_EVT_USER_PASSKEY_REQ             0x34
+struct bt_hci_evt_user_passkey_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_SSP_COMPLETE                 0x36
+struct bt_hci_evt_ssp_complete {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_USER_PASSKEY_NOTIFY          0x3b
+struct bt_hci_evt_user_passkey_notify {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_EVT_LE_META_EVENT                0x3e
+struct bt_hci_evt_le_meta_event {
+	uint8_t  subevent;
+} __packed;
+
+#define BT_HCI_EVT_AUTH_PAYLOAD_TIMEOUT_EXP     0x57
+struct bt_hci_evt_auth_payload_timeout_exp {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_ROLE_MASTER                      0x00
+#define BT_HCI_ROLE_SLAVE                       0x01
+
+#define BT_HCI_EVT_LE_CONN_COMPLETE             0x01
+struct bt_hci_evt_le_conn_complete {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      role;
+	bt_addr_le_t peer_addr;
+	uint16_t     interval;
+	uint16_t     latency;
+	uint16_t     supv_timeout;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_ADVERTISING_REPORT        0x02
+struct bt_hci_evt_le_advertising_info {
+	uint8_t      evt_type;
+	bt_addr_le_t addr;
+	uint8_t      length;
+	uint8_t      data[0];
+} __packed;
+struct bt_hci_evt_le_advertising_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_advertising_info adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE      0x03
+struct bt_hci_evt_le_conn_update_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint16_t interval;
+	uint16_t latency;
+	uint16_t supv_timeout;
+} __packed;
+
+#define BT_HCI_EV_LE_REMOTE_FEAT_COMPLETE       0x04
+struct bt_hci_evt_le_remote_feat_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_LE_LTK_REQUEST               0x05
+struct bt_hci_evt_le_ltk_request {
+	uint16_t handle;
+	uint64_t rand;
+	uint16_t ediv;
+} __packed;
+
+#define BT_HCI_EVT_LE_CONN_PARAM_REQ            0x06
+struct bt_hci_evt_le_conn_param_req {
+	uint16_t handle;
+	uint16_t interval_min;
+	uint16_t interval_max;
+	uint16_t latency;
+	uint16_t timeout;
+} __packed;
+
+#define BT_HCI_EVT_LE_DATA_LEN_CHANGE           0x07
+struct bt_hci_evt_le_data_len_change {
+	uint16_t handle;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+	uint16_t max_rx_octets;
+	uint16_t max_rx_time;
+} __packed;
+
+#define BT_HCI_EVT_LE_P256_PUBLIC_KEY_COMPLETE  0x08
+struct bt_hci_evt_le_p256_public_key_complete {
+	uint8_t status;
+	uint8_t key[64];
+} __packed;
+
+#define BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE   0x09
+struct bt_hci_evt_le_generate_dhkey_complete {
+	uint8_t status;
+	uint8_t dhkey[32];
+} __packed;
+
+#define BT_HCI_EVT_LE_ENH_CONN_COMPLETE         0x0a
+struct bt_hci_evt_le_enh_conn_complete {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      role;
+	bt_addr_le_t peer_addr;
+	bt_addr_t    local_rpa;
+	bt_addr_t    peer_rpa;
+	uint16_t     interval;
+	uint16_t     latency;
+	uint16_t     supv_timeout;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_DIRECT_ADV_REPORT         0x0b
+struct bt_hci_evt_le_direct_adv_info {
+	uint8_t      evt_type;
+	bt_addr_le_t addr;
+	bt_addr_le_t dir_addr;
+	int8_t       rssi;
+} __packed;
+struct bt_hci_evt_le_direct_adv_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_direct_adv_info direct_adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PHY_UPDATE_COMPLETE       0x0c
+struct bt_hci_evt_le_phy_update_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  tx_phy;
+	uint8_t  rx_phy;
+} __packed;
+
+#define BT_HCI_EVT_LE_EXT_ADVERTISING_REPORT    0x0d
+
+#define BT_HCI_LE_ADV_EVT_TYPE_CONN                 BIT(0)
+#define BT_HCI_LE_ADV_EVT_TYPE_SCAN                 BIT(1)
+#define BT_HCI_LE_ADV_EVT_TYPE_DIRECT               BIT(2)
+#define BT_HCI_LE_ADV_EVT_TYPE_SCAN_RSP             BIT(3)
+#define BT_HCI_LE_ADV_EVT_TYPE_LEGACY               BIT(4)
+
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS(ev_type) (((ev_type) >> 5) & 0x03)
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_COMPLETE   0
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_PARTIAL    1
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_INCOMPLETE 2
+
+struct bt_hci_evt_le_ext_advertising_info {
+	uint16_t     evt_type;
+	bt_addr_le_t addr;
+	uint8_t      prim_phy;
+	uint8_t      sec_phy;
+	uint8_t      sid;
+	int8_t       tx_power;
+	int8_t       rssi;
+	uint16_t     interval;
+	bt_addr_le_t direct_addr;
+	uint8_t      length;
+	uint8_t      data[0];
+} __packed;
+struct bt_hci_evt_le_ext_advertising_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_ext_advertising_info adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADV_SYNC_ESTABLISHED  0x0e
+struct bt_hci_evt_le_per_adv_sync_established {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      sid;
+	bt_addr_le_t adv_addr;
+	uint8_t      phy;
+	uint16_t     interval;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADVERTISING_REPORT    0x0f
+struct bt_hci_evt_le_per_advertising_report {
+	uint16_t handle;
+	int8_t   tx_power;
+	int8_t   rssi;
+	uint8_t  unused;
+	uint8_t  data_status;
+	uint8_t  length;
+	uint8_t  data[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADV_SYNC_LOST         0x10
+struct bt_hci_evt_le_per_adv_sync_lost {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_LE_SCAN_TIMEOUT              0x11
+
+#define BT_HCI_EVT_LE_ADV_SET_TERMINATED        0x12
+struct bt_hci_evt_le_adv_set_terminated {
+	uint8_t  status;
+	uint8_t  adv_handle;
+	uint16_t conn_handle;
+	uint8_t  num_completed_ext_adv_evts;
+} __packed;
+
+#define BT_HCI_EVT_LE_SCAN_REQ_RECEIVED         0x13
+struct bt_hci_evt_le_scan_req_received {
+	uint8_t      handle;
+	bt_addr_le_t addr;
+} __packed;
+
+#define BT_HCI_LE_CHAN_SEL_ALGO_1               0x00
+#define BT_HCI_LE_CHAN_SEL_ALGO_2               0x01
+
+#define BT_HCI_EVT_LE_CHAN_SEL_ALGO             0x14
+struct bt_hci_evt_le_chan_sel_algo {
+	uint16_t handle;
+	uint8_t  chan_sel_algo;
+} __packed;
+
+/* Event mask bits */
+
+#define BT_EVT_BIT(n) (1ULL << (n))
+
+#define BT_EVT_MASK_INQUIRY_COMPLETE             BT_EVT_BIT(0)
+#define BT_EVT_MASK_CONN_COMPLETE                BT_EVT_BIT(2)
+#define BT_EVT_MASK_CONN_REQUEST                 BT_EVT_BIT(3)
+#define BT_EVT_MASK_DISCONN_COMPLETE             BT_EVT_BIT(4)
+#define BT_EVT_MASK_AUTH_COMPLETE                BT_EVT_BIT(5)
+#define BT_EVT_MASK_REMOTE_NAME_REQ_COMPLETE     BT_EVT_BIT(6)
+#define BT_EVT_MASK_ENCRYPT_CHANGE               BT_EVT_BIT(7)
+#define BT_EVT_MASK_REMOTE_FEATURES              BT_EVT_BIT(10)
+#define BT_EVT_MASK_REMOTE_VERSION_INFO          BT_EVT_BIT(11)
+#define BT_EVT_MASK_HARDWARE_ERROR               BT_EVT_BIT(15)
+#define BT_EVT_MASK_ROLE_CHANGE                  BT_EVT_BIT(17)
+#define BT_EVT_MASK_PIN_CODE_REQ                 BT_EVT_BIT(21)
+#define BT_EVT_MASK_LINK_KEY_REQ                 BT_EVT_BIT(22)
+#define BT_EVT_MASK_LINK_KEY_NOTIFY              BT_EVT_BIT(23)
+#define BT_EVT_MASK_DATA_BUFFER_OVERFLOW         BT_EVT_BIT(25)
+#define BT_EVT_MASK_INQUIRY_RESULT_WITH_RSSI     BT_EVT_BIT(33)
+#define BT_EVT_MASK_REMOTE_EXT_FEATURES          BT_EVT_BIT(34)
+#define BT_EVT_MASK_SYNC_CONN_COMPLETE           BT_EVT_BIT(43)
+#define BT_EVT_MASK_EXTENDED_INQUIRY_RESULT      BT_EVT_BIT(46)
+#define BT_EVT_MASK_ENCRYPT_KEY_REFRESH_COMPLETE BT_EVT_BIT(47)
+#define BT_EVT_MASK_IO_CAPA_REQ                  BT_EVT_BIT(48)
+#define BT_EVT_MASK_IO_CAPA_RESP                 BT_EVT_BIT(49)
+#define BT_EVT_MASK_USER_CONFIRM_REQ             BT_EVT_BIT(50)
+#define BT_EVT_MASK_USER_PASSKEY_REQ             BT_EVT_BIT(51)
+#define BT_EVT_MASK_SSP_COMPLETE                 BT_EVT_BIT(53)
+#define BT_EVT_MASK_USER_PASSKEY_NOTIFY          BT_EVT_BIT(58)
+#define BT_EVT_MASK_LE_META_EVENT                BT_EVT_BIT(61)
+
+/* Page 2 */
+#define BT_EVT_MASK_PHY_LINK_COMPLETE            BT_EVT_BIT(0)
+#define BT_EVT_MASK_CH_SELECTED_COMPLETE         BT_EVT_BIT(1)
+#define BT_EVT_MASK_DISCONN_PHY_LINK_COMPLETE    BT_EVT_BIT(2)
+#define BT_EVT_MASK_PHY_LINK_LOSS_EARLY_WARN     BT_EVT_BIT(3)
+#define BT_EVT_MASK_PHY_LINK_RECOVERY            BT_EVT_BIT(4)
+#define BT_EVT_MASK_LOG_LINK_COMPLETE            BT_EVT_BIT(5)
+#define BT_EVT_MASK_DISCONN_LOG_LINK_COMPLETE    BT_EVT_BIT(6)
+#define BT_EVT_MASK_FLOW_SPEC_MODIFY_COMPLETE    BT_EVT_BIT(7)
+#define BT_EVT_MASK_NUM_COMPLETE_DATA_BLOCKS     BT_EVT_BIT(8)
+#define BT_EVT_MASK_AMP_START_TEST               BT_EVT_BIT(9)
+#define BT_EVT_MASK_AMP_TEST_END                 BT_EVT_BIT(10)
+#define BT_EVT_MASK_AMP_RX_REPORT                BT_EVT_BIT(11)
+#define BT_EVT_MASK_AMP_SR_MODE_CHANGE_COMPLETE  BT_EVT_BIT(12)
+#define BT_EVT_MASK_AMP_STATUS_CHANGE            BT_EVT_BIT(13)
+#define BT_EVT_MASK_TRIGG_CLOCK_CAPTURE          BT_EVT_BIT(14)
+#define BT_EVT_MASK_SYNCH_TRAIN_COMPLETE         BT_EVT_BIT(15)
+#define BT_EVT_MASK_SYNCH_TRAIN_RX               BT_EVT_BIT(16)
+#define BT_EVT_MASK_CL_SLAVE_BC_RX               BT_EVT_BIT(17)
+#define BT_EVT_MASK_CL_SLAVE_BC_TIMEOUT          BT_EVT_BIT(18)
+#define BT_EVT_MASK_TRUNC_PAGE_COMPLETE          BT_EVT_BIT(19)
+#define BT_EVT_MASK_SLAVE_PAGE_RSP_TIMEOUT       BT_EVT_BIT(20)
+#define BT_EVT_MASK_CL_SLAVE_BC_CH_MAP_CHANGE    BT_EVT_BIT(21)
+#define BT_EVT_MASK_INQUIRY_RSP_NOT              BT_EVT_BIT(22)
+#define BT_EVT_MASK_AUTH_PAYLOAD_TIMEOUT_EXP     BT_EVT_BIT(23)
+#define BT_EVT_MASK_SAM_STATUS_CHANGE            BT_EVT_BIT(24)
+
+#define BT_EVT_MASK_LE_CONN_COMPLETE             BT_EVT_BIT(0)
+#define BT_EVT_MASK_LE_ADVERTISING_REPORT        BT_EVT_BIT(1)
+#define BT_EVT_MASK_LE_CONN_UPDATE_COMPLETE      BT_EVT_BIT(2)
+#define BT_EVT_MASK_LE_REMOTE_FEAT_COMPLETE      BT_EVT_BIT(3)
+#define BT_EVT_MASK_LE_LTK_REQUEST               BT_EVT_BIT(4)
+#define BT_EVT_MASK_LE_CONN_PARAM_REQ            BT_EVT_BIT(5)
+#define BT_EVT_MASK_LE_DATA_LEN_CHANGE           BT_EVT_BIT(6)
+#define BT_EVT_MASK_LE_P256_PUBLIC_KEY_COMPLETE  BT_EVT_BIT(7)
+#define BT_EVT_MASK_LE_GENERATE_DHKEY_COMPLETE   BT_EVT_BIT(8)
+#define BT_EVT_MASK_LE_ENH_CONN_COMPLETE         BT_EVT_BIT(9)
+#define BT_EVT_MASK_LE_DIRECT_ADV_REPORT         BT_EVT_BIT(10)
+#define BT_EVT_MASK_LE_PHY_UPDATE_COMPLETE       BT_EVT_BIT(11)
+#define BT_EVT_MASK_LE_EXT_ADVERTISING_REPORT    BT_EVT_BIT(12)
+#define BT_EVT_MASK_LE_PER_ADV_SYNC_ESTABLISHED  BT_EVT_BIT(13)
+#define BT_EVT_MASK_LE_PER_ADVERTISING_REPORT    BT_EVT_BIT(14)
+#define BT_EVT_MASK_LE_PER_ADV_SYNC_LOST         BT_EVT_BIT(15)
+#define BT_EVT_MASK_LE_SCAN_TIMEOUT              BT_EVT_BIT(16)
+#define BT_EVT_MASK_LE_ADV_SET_TERMINATED        BT_EVT_BIT(17)
+#define BT_EVT_MASK_LE_SCAN_REQ_RECEIVED         BT_EVT_BIT(18)
+#define BT_EVT_MASK_LE_CHAN_SEL_ALGO             BT_EVT_BIT(19)
+
+  //
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/README.md b/devices/ble_hci/common-hal/_bleio/hci_include/README.md
new file mode 100644
index 000000000..4d2968c39
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/README.md
@@ -0,0 +1,2 @@
+The HCI-related include files here are copied from the Zephyr project:
+https://github.com/zephyrproject-rtos/zephyr/tree/master/include/bluetooth
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/addr.h b/devices/ble_hci/common-hal/_bleio/hci_include/addr.h
new file mode 100644
index 000000000..8f503b8a1
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/addr.h
@@ -0,0 +1,100 @@
+// CircuitPython: Adapted from Zephyer include files.
+/** @file
+ *  @brief Bluetooth device address definitions and utilities.
+ */
+
+/*
+ * Copyright (c) 2019 Nordic Semiconductor ASA
+ * Copyright 2020 Dan Halbert for Adafruit Industries
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_
+
+#include <string.h>
+
+/**
+ * @brief Bluetooth device address definitions and utilities.
+ * @defgroup bt_addr Device Address
+ * @ingroup bluetooth
+ * @{
+ */
+
+#define BT_ADDR_LE_PUBLIC       0x00
+#define BT_ADDR_LE_RANDOM       0x01
+#define BT_ADDR_LE_PUBLIC_ID    0x02
+#define BT_ADDR_LE_RANDOM_ID    0x03
+
+/** Bluetooth Device Address */
+typedef struct {
+	uint8_t  val[6];
+} bt_addr_t;
+
+/** Bluetooth LE Device Address */
+typedef struct {
+	uint8_t      type;
+	bt_addr_t a;
+} bt_addr_le_t;
+
+#define BT_ADDR_ANY     ((bt_addr_t[]) { { { 0, 0, 0, 0, 0, 0 } } })
+#define BT_ADDR_NONE    ((bt_addr_t[]) { { \
+			 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } })
+#define BT_ADDR_LE_ANY  ((bt_addr_le_t[]) { { 0, { { 0, 0, 0, 0, 0, 0 } } } })
+#define BT_ADDR_LE_NONE ((bt_addr_le_t[]) { { 0, \
+			 { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } } })
+
+static inline int bt_addr_cmp(const bt_addr_t *a, const bt_addr_t *b)
+{
+	return memcmp(a, b, sizeof(*a));
+}
+
+static inline int bt_addr_le_cmp(const bt_addr_le_t *a, const bt_addr_le_t *b)
+{
+	return memcmp(a, b, sizeof(*a));
+}
+
+static inline void bt_addr_copy(bt_addr_t *dst, const bt_addr_t *src)
+{
+	memcpy(dst, src, sizeof(*dst));
+}
+
+static inline void bt_addr_le_copy(bt_addr_le_t *dst, const bt_addr_le_t *src)
+{
+	memcpy(dst, src, sizeof(*dst));
+}
+
+#define BT_ADDR_IS_RPA(a)     (((a)->val[5] & 0xc0) == 0x40)
+#define BT_ADDR_IS_NRPA(a)    (((a)->val[5] & 0xc0) == 0x00)
+#define BT_ADDR_IS_STATIC(a)  (((a)->val[5] & 0xc0) == 0xc0)
+
+#define BT_ADDR_SET_RPA(a)    ((a)->val[5] = (((a)->val[5] & 0x3f) | 0x40))
+#define BT_ADDR_SET_NRPA(a)   ((a)->val[5] &= 0x3f)
+#define BT_ADDR_SET_STATIC(a) ((a)->val[5] |= 0xc0)
+
+int bt_addr_le_create_nrpa(bt_addr_le_t *addr);
+int bt_addr_le_create_static(bt_addr_le_t *addr);
+
+static inline bool bt_addr_le_is_rpa(const bt_addr_le_t *addr)
+{
+	if (addr->type != BT_ADDR_LE_RANDOM) {
+		return false;
+	}
+
+	return BT_ADDR_IS_RPA(&addr->a);
+}
+
+static inline bool bt_addr_le_is_identity(const bt_addr_le_t *addr)
+{
+	if (addr->type == BT_ADDR_LE_PUBLIC) {
+		return true;
+	}
+
+	return BT_ADDR_IS_STATIC(&addr->a);
+}
+
+/**
+ * @}
+ */
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci.h
new file mode 100644
index 000000000..dbe233fef
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci.h
@@ -0,0 +1,1764 @@
+// CircuitPython: Adapted from Zephyr include file.
+/* hci.h - Bluetooth Host Control Interface definitions */
+
+/*
+ * Copyright 2020 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2015-2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_
+
+#include <stdbool.h>
+#include <string.h>
+#include "addr.h"
+
+/* Special own address types for LL privacy (used in adv & scan parameters) */
+#define BT_HCI_OWN_ADDR_RPA_OR_PUBLIC  0x02
+#define BT_HCI_OWN_ADDR_RPA_OR_RANDOM  0x03
+#define BT_HCI_OWN_ADDR_RPA_MASK       0x02
+
+#define BT_HCI_PEER_ADDR_RPA_UNRESOLVED 0xfe
+#define BT_HCI_PEER_ADDR_ANONYMOUS      0xff
+
+#define BT_ENC_KEY_SIZE_MIN                     0x07
+#define BT_ENC_KEY_SIZE_MAX                     0x10
+
+struct bt_hci_evt_hdr {
+	uint8_t  evt;
+	uint8_t  len;
+} __packed;
+#define BT_HCI_EVT_HDR_SIZE             2
+
+#define BT_ACL_START_NO_FLUSH           0x00
+#define BT_ACL_CONT                     0x01
+#define BT_ACL_START                    0x02
+#define BT_ACL_COMPLETE                 0x03
+
+#define BT_ACL_POINT_TO_POINT           0x00
+#define BT_ACL_BROADCAST                0x01
+
+#define bt_acl_handle(h)                ((h) & BIT_MASK(12))
+#define bt_acl_flags(h)                 ((h) >> 12)
+#define bt_acl_flags_pb(f)              ((f) & BIT_MASK(2))
+#define bt_acl_flags_bc(f)              ((f) >> 2)
+#define bt_acl_handle_pack(h, f)        ((h) | ((f) << 12))
+
+struct bt_hci_acl_hdr {
+	uint16_t handle;
+	uint16_t len;
+} __packed;
+#define BT_HCI_ACL_HDR_SIZE             4
+
+struct bt_hci_cmd_hdr {
+	uint16_t opcode;
+	uint8_t  param_len;
+} __packed;
+#define BT_HCI_CMD_HDR_SIZE             3
+
+/* Supported Commands */
+#define BT_CMD_TEST(cmd, octet, bit)            (cmd[octet] & BIT(bit))
+#define BT_CMD_LE_STATES(cmd)                   BT_CMD_TEST(cmd, 28, 3)
+
+#define BT_FEAT_TEST(feat, page, octet, bit)    (feat[page][octet] & BIT(bit))
+
+#define BT_FEAT_BREDR(feat)                     !BT_FEAT_TEST(feat, 0, 4, 5)
+#define BT_FEAT_LE(feat)                        BT_FEAT_TEST(feat, 0, 4, 6)
+#define BT_FEAT_EXT_FEATURES(feat)              BT_FEAT_TEST(feat, 0, 7, 7)
+#define BT_FEAT_HOST_SSP(feat)                  BT_FEAT_TEST(feat, 1, 0, 0)
+#define BT_FEAT_SC(feat)                        BT_FEAT_TEST(feat, 2, 1, 0)
+
+#define BT_FEAT_LMP_ESCO_CAPABLE(feat)          BT_FEAT_TEST(feat, 0, 3, 7)
+#define BT_FEAT_HV2_PKT(feat)                   BT_FEAT_TEST(feat, 0, 1, 4)
+#define BT_FEAT_HV3_PKT(feat)                   BT_FEAT_TEST(feat, 0, 1, 5)
+#define BT_FEAT_EV4_PKT(feat)                   BT_FEAT_TEST(feat, 0, 4, 0)
+#define BT_FEAT_EV5_PKT(feat)                   BT_FEAT_TEST(feat, 0, 4, 1)
+#define BT_FEAT_2EV3_PKT(feat)                  BT_FEAT_TEST(feat, 0, 5, 5)
+#define BT_FEAT_3EV3_PKT(feat)                  BT_FEAT_TEST(feat, 0, 5, 6)
+#define BT_FEAT_3SLOT_PKT(feat)                 BT_FEAT_TEST(feat, 0, 5, 7)
+
+/* LE features */
+#define BT_LE_FEAT_BIT_ENC                      0
+#define BT_LE_FEAT_BIT_CONN_PARAM_REQ           1
+#define BT_LE_FEAT_BIT_EXT_REJ_IND              2
+#define BT_LE_FEAT_BIT_SLAVE_FEAT_REQ           3
+#define BT_LE_FEAT_BIT_PING                     4
+#define BT_LE_FEAT_BIT_DLE                      5
+#define BT_LE_FEAT_BIT_PRIVACY                  6
+#define BT_LE_FEAT_BIT_EXT_SCAN                 7
+#define BT_LE_FEAT_BIT_PHY_2M                   8
+#define BT_LE_FEAT_BIT_SMI_TX                   9
+#define BT_LE_FEAT_BIT_SMI_RX                   10
+#define BT_LE_FEAT_BIT_PHY_CODED                11
+#define BT_LE_FEAT_BIT_EXT_ADV                  12
+#define BT_LE_FEAT_BIT_PER_ADV                  13
+#define BT_LE_FEAT_BIT_CHAN_SEL_ALGO_2          14
+#define BT_LE_FEAT_BIT_PWR_CLASS_1              15
+#define BT_LE_FEAT_BIT_MIN_USED_CHAN_PROC       16
+#define BT_LE_FEAT_BIT_CONN_CTE_REQ             17
+#define BT_LE_FEAT_BIT_CONN_CTE_RESP            18
+#define BT_LE_FEAT_BIT_CONNECTIONLESS_CTE_TX    19
+#define BT_LE_FEAT_BIT_CONNECTIONLESS_CTE_RX    20
+#define BT_LE_FEAT_BIT_ANT_SWITCH_TX_AOD        21
+#define BT_LE_FEAT_BIT_ANT_SWITCH_RX_AOA        22
+#define BT_LE_FEAT_BIT_RX_CTE                   23
+#define BT_LE_FEAT_BIT_PERIODIC_SYNC_XFER_SEND  24
+#define BT_LE_FEAT_BIT_PERIODIC_SYNC_XFER_RECV  25
+#define BT_LE_FEAT_BIT_SCA_UPDATE               26
+#define BT_LE_FEAT_BIT_REMOTE_PUB_KEY_VALIDATE  27
+#define BT_LE_FEAT_BIT_CIS_MASTER               28
+#define BT_LE_FEAT_BIT_CIS_SLAVE                29
+#define BT_LE_FEAT_BIT_ISO_BROADCASTER          30
+#define BT_LE_FEAT_BIT_SYNC_RECEIVER            31
+#define BT_LE_FEAT_BIT_ISO_CHANNELS             32
+#define BT_LE_FEAT_BIT_PWR_CTRL_REQ             33
+#define BT_LE_FEAT_BIT_PWR_CHG_IND              34
+#define BT_LE_FEAT_BIT_PATH_LOSS_MONITOR        35
+
+#define BT_LE_FEAT_TEST(feat, n)                (feat[(n) >> 3] & \
+						 BIT((n) & 7))
+
+#define BT_FEAT_LE_ENCR(feat)                   BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_ENC)
+#define BT_FEAT_LE_CONN_PARAM_REQ_PROC(feat)    BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_CONN_PARAM_REQ)
+#define BT_FEAT_LE_SLAVE_FEATURE_XCHG(feat)     BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_SLAVE_FEAT_REQ)
+#define BT_FEAT_LE_DLE(feat)                    BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_DLE)
+#define BT_FEAT_LE_PHY_2M(feat)                 BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PHY_2M)
+#define BT_FEAT_LE_PHY_CODED(feat)              BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PHY_CODED)
+#define BT_FEAT_LE_PRIVACY(feat)                BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_PRIVACY)
+#define BT_FEAT_LE_EXT_ADV(feat)                BT_LE_FEAT_TEST(feat, \
+						BT_LE_FEAT_BIT_EXT_ADV)
+
+/* LE States */
+#define BT_LE_STATES_SLAVE_CONN_ADV(states)     (states & 0x0000004000000000)
+
+/* Bonding/authentication types */
+#define BT_HCI_NO_BONDING                       0x00
+#define BT_HCI_NO_BONDING_MITM                  0x01
+#define BT_HCI_DEDICATED_BONDING                0x02
+#define BT_HCI_DEDICATED_BONDING_MITM           0x03
+#define BT_HCI_GENERAL_BONDING                  0x04
+#define BT_HCI_GENERAL_BONDING_MITM             0x05
+
+/*
+ * MITM protection is enabled in SSP authentication requirements octet when
+ * LSB bit is set.
+ */
+#define BT_MITM                                 0x01
+
+/* I/O capabilities */
+#define BT_IO_DISPLAY_ONLY                      0x00
+#define BT_IO_DISPLAY_YESNO                     0x01
+#define BT_IO_KEYBOARD_ONLY                     0x02
+#define BT_IO_NO_INPUT_OUTPUT                   0x03
+
+/* SCO packet types */
+#define HCI_PKT_TYPE_HV1                        0x0020
+#define HCI_PKT_TYPE_HV2                        0x0040
+#define HCI_PKT_TYPE_HV3                        0x0080
+
+/* eSCO packet types */
+#define HCI_PKT_TYPE_ESCO_HV1                   0x0001
+#define HCI_PKT_TYPE_ESCO_HV2                   0x0002
+#define HCI_PKT_TYPE_ESCO_HV3                   0x0004
+#define HCI_PKT_TYPE_ESCO_EV3                   0x0008
+#define HCI_PKT_TYPE_ESCO_EV4                   0x0010
+#define HCI_PKT_TYPE_ESCO_EV5                   0x0020
+#define HCI_PKT_TYPE_ESCO_2EV3                  0x0040
+#define HCI_PKT_TYPE_ESCO_3EV3                  0x0080
+#define HCI_PKT_TYPE_ESCO_2EV5                  0x0100
+#define HCI_PKT_TYPE_ESCO_3EV5                  0x0200
+
+
+#define ESCO_PKT_MASK                           (HCI_PKT_TYPE_ESCO_HV1 | \
+						 HCI_PKT_TYPE_ESCO_HV2 | \
+						 HCI_PKT_TYPE_ESCO_HV3)
+#define SCO_PKT_MASK                            (HCI_PKT_TYPE_HV1 | \
+						 HCI_PKT_TYPE_HV2 | \
+						 HCI_PKT_TYPE_HV3)
+#define EDR_ESCO_PKT_MASK                       (HCI_PKT_TYPE_ESCO_2EV3 | \
+						 HCI_PKT_TYPE_ESCO_3EV3 | \
+						 HCI_PKT_TYPE_ESCO_2EV5 | \
+						 HCI_PKT_TYPE_ESCO_3EV5)
+
+/* HCI BR/EDR link types */
+#define BT_HCI_SCO                              0x00
+#define BT_HCI_ACL                              0x01
+#define BT_HCI_ESCO                             0x02
+
+/* OpCode Group Fields */
+#define BT_OGF_LINK_CTRL                        0x01
+#define BT_OGF_BASEBAND                         0x03
+#define BT_OGF_INFO                             0x04
+#define BT_OGF_STATUS                           0x05
+#define BT_OGF_LE                               0x08
+#define BT_OGF_VS                               0x3f
+
+/* Construct OpCode from OGF and OCF */
+#define BT_OP(ogf, ocf)                         ((ocf) | ((ogf) << 10))
+
+/* Invalid opcode */
+#define BT_OP_NOP				0x0000
+
+/* Obtain OGF from OpCode */
+#define BT_OGF(opcode)                          (((opcode) >> 10) & BIT_MASK(6))
+/* Obtain OCF from OpCode */
+#define BT_OCF(opcode)                          ((opcode) & BIT_MASK(10))
+
+#define BT_HCI_OP_INQUIRY                       BT_OP(BT_OGF_LINK_CTRL, 0x0001)
+struct bt_hci_op_inquiry {
+	uint8_t lap[3];
+	uint8_t length;
+	uint8_t num_rsp;
+} __packed;
+
+#define BT_HCI_OP_INQUIRY_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0002)
+
+#define BT_HCI_OP_CONNECT                       BT_OP(BT_OGF_LINK_CTRL, 0x0005)
+struct bt_hci_cp_connect {
+	bt_addr_t bdaddr;
+	uint16_t  packet_type;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint16_t  clock_offset;
+	uint8_t   allow_role_switch;
+} __packed;
+
+#define BT_HCI_OP_DISCONNECT                    BT_OP(BT_OGF_LINK_CTRL, 0x0006)
+struct bt_hci_cp_disconnect {
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+
+#define BT_HCI_OP_CONNECT_CANCEL                BT_OP(BT_OGF_LINK_CTRL, 0x0008)
+struct bt_hci_cp_connect_cancel {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_connect_cancel {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_ACCEPT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x0009)
+struct bt_hci_cp_accept_conn_req {
+	bt_addr_t bdaddr;
+	uint8_t   role;
+} __packed;
+
+#define BT_HCI_OP_SETUP_SYNC_CONN               BT_OP(BT_OGF_LINK_CTRL, 0x0028)
+struct bt_hci_cp_setup_sync_conn {
+	uint16_t  handle;
+	uint32_t  tx_bandwidth;
+	uint32_t  rx_bandwidth;
+	uint16_t  max_latency;
+	uint16_t  content_format;
+	uint8_t   retrans_effort;
+	uint16_t  pkt_type;
+} __packed;
+
+#define BT_HCI_OP_ACCEPT_SYNC_CONN_REQ          BT_OP(BT_OGF_LINK_CTRL, 0x0029)
+struct bt_hci_cp_accept_sync_conn_req {
+	bt_addr_t bdaddr;
+	uint32_t  tx_bandwidth;
+	uint32_t  rx_bandwidth;
+	uint16_t  max_latency;
+	uint16_t  content_format;
+	uint8_t   retrans_effort;
+	uint16_t  pkt_type;
+} __packed;
+
+#define BT_HCI_OP_REJECT_CONN_REQ               BT_OP(BT_OGF_LINK_CTRL, 0x000a)
+struct bt_hci_cp_reject_conn_req {
+	bt_addr_t bdaddr;
+	uint8_t   reason;
+} __packed;
+
+#define BT_HCI_OP_LINK_KEY_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000b)
+struct bt_hci_cp_link_key_reply {
+	bt_addr_t bdaddr;
+	uint8_t   link_key[16];
+} __packed;
+
+#define BT_HCI_OP_LINK_KEY_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000c)
+struct bt_hci_cp_link_key_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_PIN_CODE_REPLY                BT_OP(BT_OGF_LINK_CTRL, 0x000d)
+struct bt_hci_cp_pin_code_reply {
+	bt_addr_t bdaddr;
+	uint8_t   pin_len;
+	uint8_t   pin_code[16];
+} __packed;
+struct bt_hci_rp_pin_code_reply {
+	uint8_t      status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_PIN_CODE_NEG_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x000e)
+struct bt_hci_cp_pin_code_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_pin_code_neg_reply {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_AUTH_REQUESTED                BT_OP(BT_OGF_LINK_CTRL, 0x0011)
+struct bt_hci_cp_auth_requested {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_SET_CONN_ENCRYPT              BT_OP(BT_OGF_LINK_CTRL, 0x0013)
+struct bt_hci_cp_set_conn_encrypt {
+	uint16_t handle;
+	uint8_t  encrypt;
+} __packed;
+
+#define BT_HCI_OP_REMOTE_NAME_REQUEST           BT_OP(BT_OGF_LINK_CTRL, 0x0019)
+struct bt_hci_cp_remote_name_request {
+	bt_addr_t bdaddr;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint16_t  clock_offset;
+} __packed;
+
+#define BT_HCI_OP_REMOTE_NAME_CANCEL            BT_OP(BT_OGF_LINK_CTRL, 0x001a)
+struct bt_hci_cp_remote_name_cancel {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_remote_name_cancel {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_FEATURES          BT_OP(BT_OGF_LINK_CTRL, 0x001b)
+struct bt_hci_cp_read_remote_features {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_EXT_FEATURES      BT_OP(BT_OGF_LINK_CTRL, 0x001c)
+struct bt_hci_cp_read_remote_ext_features {
+	uint16_t handle;
+	uint8_t  page;
+} __packed;
+
+#define BT_HCI_OP_READ_REMOTE_VERSION_INFO      BT_OP(BT_OGF_LINK_CTRL, 0x001d)
+struct bt_hci_cp_read_remote_version_info {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_IO_CAPABILITY_REPLY           BT_OP(BT_OGF_LINK_CTRL, 0x002b)
+struct bt_hci_cp_io_capability_reply {
+	bt_addr_t bdaddr;
+	uint8_t   capability;
+	uint8_t   oob_data;
+	uint8_t   authentication;
+} __packed;
+
+#define BT_HCI_OP_USER_CONFIRM_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002c)
+#define BT_HCI_OP_USER_CONFIRM_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002d)
+struct bt_hci_cp_user_confirm_reply {
+	bt_addr_t bdaddr;
+} __packed;
+struct bt_hci_rp_user_confirm_reply {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_USER_PASSKEY_REPLY            BT_OP(BT_OGF_LINK_CTRL, 0x002e)
+struct bt_hci_cp_user_passkey_reply {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_OP_USER_PASSKEY_NEG_REPLY        BT_OP(BT_OGF_LINK_CTRL, 0x002f)
+struct bt_hci_cp_user_passkey_neg_reply {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_IO_CAPABILITY_NEG_REPLY       BT_OP(BT_OGF_LINK_CTRL, 0x0034)
+struct bt_hci_cp_io_capability_neg_reply {
+	bt_addr_t bdaddr;
+	uint8_t   reason;
+} __packed;
+
+#define BT_HCI_OP_SET_EVENT_MASK                BT_OP(BT_OGF_BASEBAND, 0x0001)
+struct bt_hci_cp_set_event_mask {
+	uint8_t  events[8];
+} __packed;
+
+#define BT_HCI_OP_RESET                         BT_OP(BT_OGF_BASEBAND, 0x0003)
+
+#define BT_HCI_OP_WRITE_LOCAL_NAME              BT_OP(BT_OGF_BASEBAND, 0x0013)
+struct bt_hci_write_local_name {
+	uint8_t local_name[248];
+} __packed;
+
+#define BT_HCI_OP_WRITE_PAGE_TIMEOUT            BT_OP(BT_OGF_BASEBAND, 0x0018)
+
+#define BT_HCI_OP_WRITE_SCAN_ENABLE             BT_OP(BT_OGF_BASEBAND, 0x001a)
+#define BT_BREDR_SCAN_DISABLED                  0x00
+#define BT_BREDR_SCAN_INQUIRY                   0x01
+#define BT_BREDR_SCAN_PAGE                      0x02
+
+#define BT_TX_POWER_LEVEL_CURRENT               0x00
+#define BT_TX_POWER_LEVEL_MAX                   0x01
+#define BT_HCI_OP_READ_TX_POWER_LEVEL           BT_OP(BT_OGF_BASEBAND, 0x002d)
+struct bt_hci_cp_read_tx_power_level {
+	uint16_t handle;
+	uint8_t  type;
+} __packed;
+
+struct bt_hci_rp_read_tx_power_level {
+	uint8_t  status;
+	uint16_t handle;
+	int8_t   tx_power_level;
+} __packed;
+
+#define BT_HCI_CTL_TO_HOST_FLOW_DISABLE         0x00
+#define BT_HCI_CTL_TO_HOST_FLOW_ENABLE          0x01
+#define BT_HCI_OP_SET_CTL_TO_HOST_FLOW          BT_OP(BT_OGF_BASEBAND, 0x0031)
+struct bt_hci_cp_set_ctl_to_host_flow {
+	uint8_t  flow_enable;
+} __packed;
+
+#define BT_HCI_OP_HOST_BUFFER_SIZE              BT_OP(BT_OGF_BASEBAND, 0x0033)
+struct bt_hci_cp_host_buffer_size {
+	uint16_t acl_mtu;
+	uint8_t  sco_mtu;
+	uint16_t acl_pkts;
+	uint16_t sco_pkts;
+} __packed;
+
+struct bt_hci_handle_count {
+	uint16_t handle;
+	uint16_t count;
+} __packed;
+
+#define BT_HCI_OP_HOST_NUM_COMPLETED_PACKETS    BT_OP(BT_OGF_BASEBAND, 0x0035)
+struct bt_hci_cp_host_num_completed_packets {
+	uint8_t  num_handles;
+	struct bt_hci_handle_count h[0];
+} __packed;
+
+#define BT_HCI_OP_WRITE_INQUIRY_MODE            BT_OP(BT_OGF_BASEBAND, 0x0045)
+struct bt_hci_cp_write_inquiry_mode {
+	uint8_t  mode;
+} __packed;
+
+#define BT_HCI_OP_WRITE_SSP_MODE                BT_OP(BT_OGF_BASEBAND, 0x0056)
+struct bt_hci_cp_write_ssp_mode {
+	uint8_t mode;
+} __packed;
+
+#define BT_HCI_OP_SET_EVENT_MASK_PAGE_2         BT_OP(BT_OGF_BASEBAND, 0x0063)
+struct bt_hci_cp_set_event_mask_page_2 {
+	uint8_t  events_page_2[8];
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_LE_HOST_SUPP         BT_OP(BT_OGF_BASEBAND, 0x006d)
+struct bt_hci_cp_write_le_host_supp {
+	uint8_t  le;
+	uint8_t  simul;
+} __packed;
+
+#define BT_HCI_OP_WRITE_SC_HOST_SUPP            BT_OP(BT_OGF_BASEBAND, 0x007a)
+struct bt_hci_cp_write_sc_host_supp {
+	uint8_t  sc_support;
+} __packed;
+
+#define BT_HCI_OP_READ_AUTH_PAYLOAD_TIMEOUT     BT_OP(BT_OGF_BASEBAND, 0x007b)
+struct bt_hci_cp_read_auth_payload_timeout {
+	uint16_t handle;
+} __packed;
+
+struct bt_hci_rp_read_auth_payload_timeout {
+	uint8_t  status;
+	uint16_t handle;
+	uint16_t auth_payload_timeout;
+} __packed;
+
+#define BT_HCI_OP_WRITE_AUTH_PAYLOAD_TIMEOUT    BT_OP(BT_OGF_BASEBAND, 0x007c)
+struct bt_hci_cp_write_auth_payload_timeout {
+	uint16_t handle;
+	uint16_t auth_payload_timeout;
+} __packed;
+
+struct bt_hci_rp_write_auth_payload_timeout {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+/* HCI version from Assigned Numbers */
+#define BT_HCI_VERSION_1_0B                     0
+#define BT_HCI_VERSION_1_1                      1
+#define BT_HCI_VERSION_1_2                      2
+#define BT_HCI_VERSION_2_0                      3
+#define BT_HCI_VERSION_2_1                      4
+#define BT_HCI_VERSION_3_0                      5
+#define BT_HCI_VERSION_4_0                      6
+#define BT_HCI_VERSION_4_1                      7
+#define BT_HCI_VERSION_4_2                      8
+#define BT_HCI_VERSION_5_0                      9
+#define BT_HCI_VERSION_5_1                      10
+#define BT_HCI_VERSION_5_2                      11
+
+#define BT_HCI_OP_READ_LOCAL_VERSION_INFO       BT_OP(BT_OGF_INFO, 0x0001)
+struct bt_hci_rp_read_local_version_info {
+	uint8_t  status;
+	uint8_t  hci_version;
+	uint16_t hci_revision;
+	uint8_t  lmp_version;
+	uint16_t manufacturer;
+	uint16_t lmp_subversion;
+} __packed;
+
+#define BT_HCI_OP_READ_SUPPORTED_COMMANDS       BT_OP(BT_OGF_INFO, 0x0002)
+struct bt_hci_rp_read_supported_commands {
+	uint8_t  status;
+	uint8_t  commands[64];
+} __packed;
+
+#define BT_HCI_OP_READ_LOCAL_EXT_FEATURES       BT_OP(BT_OGF_INFO, 0x0004)
+struct bt_hci_cp_read_local_ext_features {
+	uint8_t page;
+};
+struct bt_hci_rp_read_local_ext_features {
+	uint8_t  status;
+	uint8_t  page;
+	uint8_t  max_page;
+	uint8_t  ext_features[8];
+} __packed;
+
+#define BT_HCI_OP_READ_LOCAL_FEATURES           BT_OP(BT_OGF_INFO, 0x0003)
+struct bt_hci_rp_read_local_features {
+	uint8_t  status;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_OP_READ_BUFFER_SIZE              BT_OP(BT_OGF_INFO, 0x0005)
+struct bt_hci_rp_read_buffer_size {
+	uint8_t  status;
+	uint16_t acl_max_len;
+	uint8_t  sco_max_len;
+	uint16_t acl_max_num;
+	uint16_t sco_max_num;
+} __packed;
+
+#define BT_HCI_OP_READ_BD_ADDR                  BT_OP(BT_OGF_INFO, 0x0009)
+struct bt_hci_rp_read_bd_addr {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_OP_READ_RSSI                     BT_OP(BT_OGF_STATUS, 0x0005)
+struct bt_hci_cp_read_rssi {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_read_rssi {
+	uint8_t  status;
+	uint16_t handle;
+	int8_t   rssi;
+} __packed;
+
+#define BT_HCI_ENCRYPTION_KEY_SIZE_MIN          7
+#define BT_HCI_ENCRYPTION_KEY_SIZE_MAX          16
+
+#define BT_HCI_OP_READ_ENCRYPTION_KEY_SIZE      BT_OP(BT_OGF_STATUS, 0x0008)
+struct bt_hci_cp_read_encryption_key_size {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_read_encryption_key_size {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  key_size;
+} __packed;
+
+/* BLE */
+
+#define BT_HCI_OP_LE_SET_EVENT_MASK             BT_OP(BT_OGF_LE, 0x0001)
+struct bt_hci_cp_le_set_event_mask {
+	uint8_t events[8];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_BUFFER_SIZE           BT_OP(BT_OGF_LE, 0x0002)
+struct bt_hci_rp_le_read_buffer_size {
+	uint8_t  status;
+	uint16_t le_max_len;
+	uint8_t  le_max_num;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_LOCAL_FEATURES        BT_OP(BT_OGF_LE, 0x0003)
+struct bt_hci_rp_le_read_local_features {
+	uint8_t  status;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_RANDOM_ADDRESS         BT_OP(BT_OGF_LE, 0x0005)
+struct bt_hci_cp_le_set_random_address {
+	bt_addr_t bdaddr;
+} __packed;
+
+/* LE Advertising Types (LE Advertising Parameters Set)*/
+#define BT_LE_ADV_IND                  (__DEPRECATED_MACRO 0x00)
+#define BT_LE_ADV_DIRECT_IND           (__DEPRECATED_MACRO 0x01)
+#define BT_LE_ADV_SCAN_IND             (__DEPRECATED_MACRO 0x02)
+#define BT_LE_ADV_NONCONN_IND          (__DEPRECATED_MACRO 0x03)
+#define BT_LE_ADV_DIRECT_IND_LOW_DUTY  (__DEPRECATED_MACRO 0x04)
+/* LE Advertising PDU Types. */
+#define BT_LE_ADV_SCAN_RSP             (__DEPRECATED_MACRO 0x04)
+
+#define BT_HCI_ADV_IND                          0x00
+#define BT_HCI_ADV_DIRECT_IND                   0x01
+#define BT_HCI_ADV_SCAN_IND                     0x02
+#define BT_HCI_ADV_NONCONN_IND                  0x03
+#define BT_HCI_ADV_DIRECT_IND_LOW_DUTY          0x04
+#define BT_HCI_ADV_SCAN_RSP                     0x04
+
+#define BT_LE_ADV_FP_NO_WHITELIST               0x00
+#define BT_LE_ADV_FP_WHITELIST_SCAN_REQ         0x01
+#define BT_LE_ADV_FP_WHITELIST_CONN_IND         0x02
+#define BT_LE_ADV_FP_WHITELIST_BOTH             0x03
+
+#define BT_HCI_OP_LE_SET_ADV_PARAM              BT_OP(BT_OGF_LE, 0x0006)
+struct bt_hci_cp_le_set_adv_param {
+	uint16_t     min_interval;
+	uint16_t     max_interval;
+	uint8_t      type;
+	uint8_t      own_addr_type;
+	bt_addr_le_t direct_addr;
+	uint8_t      channel_map;
+	uint8_t      filter_policy;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_ADV_CHAN_TX_POWER     BT_OP(BT_OGF_LE, 0x0007)
+struct bt_hci_rp_le_read_chan_tx_power {
+	uint8_t status;
+	int8_t  tx_power_level;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_ADV_DATA               BT_OP(BT_OGF_LE, 0x0008)
+struct bt_hci_cp_le_set_adv_data {
+	uint8_t  len;
+	uint8_t  data[31];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_SCAN_RSP_DATA          BT_OP(BT_OGF_LE, 0x0009)
+struct bt_hci_cp_le_set_scan_rsp_data {
+	uint8_t  len;
+	uint8_t  data[31];
+} __packed;
+
+#define BT_HCI_LE_ADV_DISABLE                   0x00
+#define BT_HCI_LE_ADV_ENABLE                    0x01
+
+#define BT_HCI_OP_LE_SET_ADV_ENABLE             BT_OP(BT_OGF_LE, 0x000a)
+struct bt_hci_cp_le_set_adv_enable {
+	uint8_t  enable;
+} __packed;
+
+/* Scan types */
+#define BT_HCI_OP_LE_SET_SCAN_PARAM             BT_OP(BT_OGF_LE, 0x000b)
+#define BT_HCI_LE_SCAN_PASSIVE                  0x00
+#define BT_HCI_LE_SCAN_ACTIVE                   0x01
+
+#define BT_HCI_LE_SCAN_FP_NO_WHITELIST          0x00
+#define BT_HCI_LE_SCAN_FP_USE_WHITELIST         0x01
+
+struct bt_hci_cp_le_set_scan_param {
+	uint8_t  scan_type;
+	uint16_t interval;
+	uint16_t window;
+	uint8_t  addr_type;
+	uint8_t  filter_policy;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_SCAN_ENABLE            BT_OP(BT_OGF_LE, 0x000c)
+
+#define BT_HCI_LE_SCAN_DISABLE                  0x00
+#define BT_HCI_LE_SCAN_ENABLE                   0x01
+
+#define BT_HCI_LE_SCAN_FILTER_DUP_DISABLE       0x00
+#define BT_HCI_LE_SCAN_FILTER_DUP_ENABLE        0x01
+
+struct bt_hci_cp_le_set_scan_enable {
+	uint8_t  enable;
+	uint8_t  filter_dup;
+} __packed;
+
+#define BT_HCI_OP_LE_CREATE_CONN                BT_OP(BT_OGF_LE, 0x000d)
+
+#define BT_HCI_LE_CREATE_CONN_FP_DIRECT         0x00
+#define BT_HCI_LE_CREATE_CONN_FP_WHITELIST      0x01
+
+struct bt_hci_cp_le_create_conn {
+	uint16_t     scan_interval;
+	uint16_t     scan_window;
+	uint8_t      filter_policy;
+	bt_addr_le_t peer_addr;
+	uint8_t      own_addr_type;
+	uint16_t     conn_interval_min;
+	uint16_t     conn_interval_max;
+	uint16_t     conn_latency;
+	uint16_t     supervision_timeout;
+	uint16_t     min_ce_len;
+	uint16_t     max_ce_len;
+} __packed;
+
+#define BT_HCI_OP_LE_CREATE_CONN_CANCEL         BT_OP(BT_OGF_LE, 0x000e)
+
+#define BT_HCI_OP_LE_READ_WL_SIZE               BT_OP(BT_OGF_LE, 0x000f)
+struct bt_hci_rp_le_read_wl_size {
+	uint8_t  status;
+	uint8_t  wl_size;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_WL                   BT_OP(BT_OGF_LE, 0x0010)
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_WL              BT_OP(BT_OGF_LE, 0x0011)
+struct bt_hci_cp_le_add_dev_to_wl {
+	bt_addr_le_t  addr;
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_WL            BT_OP(BT_OGF_LE, 0x0012)
+struct bt_hci_cp_le_rem_dev_from_wl {
+	bt_addr_le_t  addr;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_UPDATE                BT_OP(BT_OGF_LE, 0x0013)
+struct hci_cp_le_conn_update {
+	uint16_t handle;
+	uint16_t conn_interval_min;
+	uint16_t conn_interval_max;
+	uint16_t conn_latency;
+	uint16_t supervision_timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_HOST_CHAN_CLASSIF      BT_OP(BT_OGF_LE, 0x0014)
+struct bt_hci_cp_le_set_host_chan_classif {
+	uint8_t  ch_map[5];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_CHAN_MAP              BT_OP(BT_OGF_LE, 0x0015)
+struct bt_hci_cp_le_read_chan_map {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_read_chan_map {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  ch_map[5];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_REMOTE_FEATURES       BT_OP(BT_OGF_LE, 0x0016)
+struct bt_hci_cp_le_read_remote_features {
+	uint16_t  handle;
+} __packed;
+
+#define BT_HCI_OP_LE_ENCRYPT                    BT_OP(BT_OGF_LE, 0x0017)
+struct bt_hci_cp_le_encrypt {
+	uint8_t  key[16];
+	uint8_t  plaintext[16];
+} __packed;
+struct bt_hci_rp_le_encrypt {
+	uint8_t  status;
+	uint8_t  enc_data[16];
+} __packed;
+
+#define BT_HCI_OP_LE_RAND                       BT_OP(BT_OGF_LE, 0x0018)
+struct bt_hci_rp_le_rand {
+	uint8_t  status;
+	uint8_t  rand[8];
+} __packed;
+
+#define BT_HCI_OP_LE_START_ENCRYPTION           BT_OP(BT_OGF_LE, 0x0019)
+struct bt_hci_cp_le_start_encryption {
+	uint16_t handle;
+	uint64_t rand;
+	uint16_t ediv;
+	uint8_t  ltk[16];
+} __packed;
+
+#define BT_HCI_OP_LE_LTK_REQ_REPLY              BT_OP(BT_OGF_LE, 0x001a)
+struct bt_hci_cp_le_ltk_req_reply {
+	uint16_t handle;
+	uint8_t  ltk[16];
+} __packed;
+struct bt_hci_rp_le_ltk_req_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_LTK_REQ_NEG_REPLY          BT_OP(BT_OGF_LE, 0x001b)
+struct bt_hci_cp_le_ltk_req_neg_reply {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_ltk_req_neg_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_SUPP_STATES           BT_OP(BT_OGF_LE, 0x001c)
+struct bt_hci_rp_le_read_supp_states {
+	uint8_t  status;
+	uint8_t  le_states[8];
+} __packed;
+
+#define BT_HCI_OP_LE_RX_TEST                    BT_OP(BT_OGF_LE, 0x001d)
+struct bt_hci_cp_le_rx_test {
+	uint8_t  rx_ch;
+} __packed;
+
+#define BT_HCI_OP_LE_TX_TEST                    BT_OP(BT_OGF_LE, 0x001e)
+struct bt_hci_cp_le_tx_test {
+	uint8_t  tx_ch;
+	uint8_t  test_data_len;
+	uint8_t  pkt_payload;
+} __packed;
+
+#define BT_HCI_OP_LE_TEST_END                   BT_OP(BT_OGF_LE, 0x001f)
+struct bt_hci_rp_le_test_end {
+	uint8_t  status;
+	uint16_t rx_pkt_count;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_PARAM_REQ_REPLY       BT_OP(BT_OGF_LE, 0x0020)
+struct bt_hci_cp_le_conn_param_req_reply {
+	uint16_t handle;
+	uint16_t interval_min;
+	uint16_t interval_max;
+	uint16_t latency;
+	uint16_t timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+struct bt_hci_rp_le_conn_param_req_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_CONN_PARAM_REQ_NEG_REPLY   BT_OP(BT_OGF_LE, 0x0021)
+struct bt_hci_cp_le_conn_param_req_neg_reply {
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+struct bt_hci_rp_le_conn_param_req_neg_reply {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_DATA_LEN               BT_OP(BT_OGF_LE, 0x0022)
+struct bt_hci_cp_le_set_data_len {
+	uint16_t handle;
+	uint16_t tx_octets;
+	uint16_t tx_time;
+} __packed;
+struct bt_hci_rp_le_set_data_len {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_DEFAULT_DATA_LEN      BT_OP(BT_OGF_LE, 0x0023)
+struct bt_hci_rp_le_read_default_data_len {
+	uint8_t  status;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_DEFAULT_DATA_LEN     BT_OP(BT_OGF_LE, 0x0024)
+struct bt_hci_cp_le_write_default_data_len {
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+} __packed;
+
+#define BT_HCI_OP_LE_P256_PUBLIC_KEY            BT_OP(BT_OGF_LE, 0x0025)
+
+#define BT_HCI_OP_LE_GENERATE_DHKEY             BT_OP(BT_OGF_LE, 0x0026)
+struct bt_hci_cp_le_generate_dhkey {
+	uint8_t key[64];
+} __packed;
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_RL              BT_OP(BT_OGF_LE, 0x0027)
+struct bt_hci_cp_le_add_dev_to_rl {
+	bt_addr_le_t  peer_id_addr;
+	uint8_t       peer_irk[16];
+	uint8_t       local_irk[16];
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_RL            BT_OP(BT_OGF_LE, 0x0028)
+struct bt_hci_cp_le_rem_dev_from_rl {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_RL                   BT_OP(BT_OGF_LE, 0x0029)
+
+#define BT_HCI_OP_LE_READ_RL_SIZE               BT_OP(BT_OGF_LE, 0x002a)
+struct bt_hci_rp_le_read_rl_size {
+	uint8_t  status;
+	uint8_t  rl_size;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_PEER_RPA              BT_OP(BT_OGF_LE, 0x002b)
+struct bt_hci_cp_le_read_peer_rpa {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+struct bt_hci_rp_le_read_peer_rpa {
+	uint8_t    status;
+	bt_addr_t  peer_rpa;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_LOCAL_RPA             BT_OP(BT_OGF_LE, 0x002c)
+struct bt_hci_cp_le_read_local_rpa {
+	bt_addr_le_t  peer_id_addr;
+} __packed;
+struct bt_hci_rp_le_read_local_rpa {
+	uint8_t    status;
+	bt_addr_t  local_rpa;
+} __packed;
+
+#define BT_HCI_ADDR_RES_DISABLE                 0x00
+#define BT_HCI_ADDR_RES_ENABLE                  0x01
+
+#define BT_HCI_OP_LE_SET_ADDR_RES_ENABLE        BT_OP(BT_OGF_LE, 0x002d)
+struct bt_hci_cp_le_set_addr_res_enable {
+	uint8_t  enable;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_RPA_TIMEOUT            BT_OP(BT_OGF_LE, 0x002e)
+struct bt_hci_cp_le_set_rpa_timeout {
+	uint16_t rpa_timeout;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_MAX_DATA_LEN          BT_OP(BT_OGF_LE, 0x002f)
+struct bt_hci_rp_le_read_max_data_len {
+	uint8_t  status;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+	uint16_t max_rx_octets;
+	uint16_t max_rx_time;
+} __packed;
+
+#define BT_HCI_LE_PHY_1M                        0x01
+#define BT_HCI_LE_PHY_2M                        0x02
+#define BT_HCI_LE_PHY_CODED                     0x03
+
+#define BT_HCI_OP_LE_READ_PHY                   BT_OP(BT_OGF_LE, 0x0030)
+struct bt_hci_cp_le_read_phy {
+	uint16_t handle;
+} __packed;
+struct bt_hci_rp_le_read_phy {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  tx_phy;
+	uint8_t  rx_phy;
+} __packed;
+
+#define BT_HCI_LE_PHY_TX_ANY                    BIT(0)
+#define BT_HCI_LE_PHY_RX_ANY                    BIT(1)
+
+#define BT_HCI_LE_PHY_PREFER_1M                 BIT(0)
+#define BT_HCI_LE_PHY_PREFER_2M                 BIT(1)
+#define BT_HCI_LE_PHY_PREFER_CODED              BIT(2)
+
+#define BT_HCI_OP_LE_SET_DEFAULT_PHY            BT_OP(BT_OGF_LE, 0x0031)
+struct bt_hci_cp_le_set_default_phy {
+	uint8_t all_phys;
+	uint8_t tx_phys;
+	uint8_t rx_phys;
+} __packed;
+
+#define BT_HCI_LE_PHY_CODED_ANY                 0x00
+#define BT_HCI_LE_PHY_CODED_S2                  0x01
+#define BT_HCI_LE_PHY_CODED_S8                  0x02
+
+#define BT_HCI_OP_LE_SET_PHY                    BT_OP(BT_OGF_LE, 0x0032)
+struct bt_hci_cp_le_set_phy {
+	uint16_t  handle;
+	uint8_t   all_phys;
+	uint8_t   tx_phys;
+	uint8_t   rx_phys;
+	uint16_t  phy_opts;
+} __packed;
+
+#define BT_HCI_LE_MOD_INDEX_STANDARD            0x00
+#define BT_HCI_LE_MOD_INDEX_STABLE              0x01
+
+#define BT_HCI_OP_LE_ENH_RX_TEST                BT_OP(BT_OGF_LE, 0x0033)
+struct bt_hci_cp_le_enh_rx_test {
+	uint8_t  rx_ch;
+	uint8_t  phy;
+	uint8_t  mod_index;
+} __packed;
+
+/* Extends BT_HCI_LE_PHY */
+#define BT_HCI_LE_TX_PHY_CODED_S8               0x03
+#define BT_HCI_LE_TX_PHY_CODED_S2               0x04
+
+#define BT_HCI_OP_LE_ENH_TX_TEST                BT_OP(BT_OGF_LE, 0x0034)
+struct bt_hci_cp_le_enh_tx_test {
+	uint8_t  tx_ch;
+	uint8_t  test_data_len;
+	uint8_t  pkt_payload;
+	uint8_t  phy;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_ADV_SET_RANDOM_ADDR    BT_OP(BT_OGF_LE, 0x0035)
+struct bt_hci_cp_le_set_adv_set_random_addr {
+	uint8_t   handle;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_LE_ADV_PROP_CONN                 BIT(0)
+#define BT_HCI_LE_ADV_PROP_SCAN                 BIT(1)
+#define BT_HCI_LE_ADV_PROP_DIRECT               BIT(2)
+#define BT_HCI_LE_ADV_PROP_HI_DC_CONN           BIT(3)
+#define BT_HCI_LE_ADV_PROP_LEGACY               BIT(4)
+#define BT_HCI_LE_ADV_PROP_ANON                 BIT(5)
+#define BT_HCI_LE_ADV_PROP_TX_POWER             BIT(6)
+
+#define BT_HCI_LE_ADV_SCAN_REQ_ENABLE  1
+#define BT_HCI_LE_ADV_SCAN_REQ_DISABLE 0
+
+#define BT_HCI_LE_ADV_TX_POWER_NO_PREF 0x7F
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_PARAM          BT_OP(BT_OGF_LE, 0x0036)
+struct bt_hci_cp_le_set_ext_adv_param {
+	uint8_t      handle;
+	uint16_t     props;
+	uint8_t      prim_min_interval[3];
+	uint8_t      prim_max_interval[3];
+	uint8_t      prim_channel_map;
+	uint8_t      own_addr_type;
+	bt_addr_le_t peer_addr;
+	uint8_t      filter_policy;
+	int8_t       tx_power;
+	uint8_t      prim_adv_phy;
+	uint8_t      sec_adv_max_skip;
+	uint8_t      sec_adv_phy;
+	uint8_t      sid;
+	uint8_t      scan_req_notify_enable;
+} __packed;
+struct bt_hci_rp_le_set_ext_adv_param {
+	uint8_t status;
+	int8_t  tx_power;
+} __packed;
+
+#define BT_HCI_LE_EXT_ADV_OP_INTERM_FRAG        0x00
+#define BT_HCI_LE_EXT_ADV_OP_FIRST_FRAG         0x01
+#define BT_HCI_LE_EXT_ADV_OP_LAST_FRAG          0x02
+#define BT_HCI_LE_EXT_ADV_OP_COMPLETE_DATA      0x03
+#define BT_HCI_LE_EXT_ADV_OP_UNCHANGED_DATA     0x04
+
+#define BT_HCI_LE_EXT_ADV_FRAG_ENABLED          0x00
+#define BT_HCI_LE_EXT_ADV_FRAG_DISABLED         0x01
+
+#define BT_HCI_LE_EXT_ADV_FRAG_MAX_LEN          251
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_DATA           BT_OP(BT_OGF_LE, 0x0037)
+struct bt_hci_cp_le_set_ext_adv_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  frag_pref;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_RSP_DATA      BT_OP(BT_OGF_LE, 0x0038)
+struct bt_hci_cp_le_set_ext_scan_rsp_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  frag_pref;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0039)
+struct bt_hci_ext_adv_set {
+	uint8_t  handle;
+	uint16_t duration;
+	uint8_t  max_ext_adv_evts;
+} __packed;
+
+struct bt_hci_cp_le_set_ext_adv_enable {
+	uint8_t  enable;
+	uint8_t  set_num;
+	struct bt_hci_ext_adv_set s[0];
+} __packed;
+
+#define BT_HCI_OP_LE_READ_MAX_ADV_DATA_LEN      BT_OP(BT_OGF_LE, 0x003a)
+struct bt_hci_rp_le_read_max_adv_data_len {
+	uint8_t  status;
+	uint16_t max_adv_data_len;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_NUM_ADV_SETS          BT_OP(BT_OGF_LE, 0x003b)
+struct bt_hci_rp_le_read_num_adv_sets {
+	uint8_t  status;
+	uint8_t  num_sets;
+} __packed;
+
+#define BT_HCI_OP_LE_REMOVE_ADV_SET             BT_OP(BT_OGF_LE, 0x003c)
+struct bt_hci_cp_le_remove_adv_set {
+	uint8_t  handle;
+} __packed;
+
+#define BT_HCI_OP_CLEAR_ADV_SETS                BT_OP(BT_OGF_LE, 0x003d)
+
+#define BT_HCI_OP_LE_SET_PER_ADV_PARAM          BT_OP(BT_OGF_LE, 0x003e)
+struct bt_hci_cp_le_set_per_adv_param {
+	uint8_t  handle;
+	uint16_t min_interval;
+	uint16_t max_interval;
+	uint16_t props;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_PER_ADV_DATA           BT_OP(BT_OGF_LE, 0x003f)
+struct bt_hci_cp_le_set_per_adv_data {
+	uint8_t  handle;
+	uint8_t  op;
+	uint8_t  len;
+	uint8_t  data[251];
+} __packed;
+
+#define BT_HCI_OP_LE_SET_PER_ADV_ENABLE         BT_OP(BT_OGF_LE, 0x0040)
+struct bt_hci_cp_le_set_per_adv_enable {
+	uint8_t  enable;
+	uint8_t  handle;
+} __packed;
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_PARAM         BT_OP(BT_OGF_LE, 0x0041)
+struct bt_hci_ext_scan_phy {
+	uint8_t  type;
+	uint16_t interval;
+	uint16_t window;
+} __packed;
+
+#define BT_HCI_LE_EXT_SCAN_PHY_1M               BIT(0)
+#define BT_HCI_LE_EXT_SCAN_PHY_2M               BIT(1)
+#define BT_HCI_LE_EXT_SCAN_PHY_CODED            BIT(2)
+
+struct bt_hci_cp_le_set_ext_scan_param {
+	uint8_t  own_addr_type;
+	uint8_t  filter_policy;
+	uint8_t  phys;
+	struct bt_hci_ext_scan_phy p[0];
+} __packed;
+
+/* Extends BT_HCI_LE_SCAN_FILTER_DUP */
+#define BT_HCI_LE_EXT_SCAN_FILTER_DUP_ENABLE_RESET  0x02
+
+#define BT_HCI_OP_LE_SET_EXT_SCAN_ENABLE        BT_OP(BT_OGF_LE, 0x0042)
+struct bt_hci_cp_le_set_ext_scan_enable {
+	uint8_t  enable;
+	uint8_t  filter_dup;
+	uint16_t duration;
+	uint16_t period;
+} __packed;
+
+#define BT_HCI_OP_LE_EXT_CREATE_CONN            BT_OP(BT_OGF_LE, 0x0043)
+struct bt_hci_ext_conn_phy {
+	uint16_t scan_interval;
+	uint16_t scan_window;
+	uint16_t conn_interval_min;
+	uint16_t conn_interval_max;
+	uint16_t conn_latency;
+	uint16_t supervision_timeout;
+	uint16_t min_ce_len;
+	uint16_t max_ce_len;
+} __packed;
+
+struct bt_hci_cp_le_ext_create_conn {
+	uint8_t      filter_policy;
+	uint8_t      own_addr_type;
+	bt_addr_le_t peer_addr;
+	uint8_t      phys;
+	struct bt_hci_ext_conn_phy p[0];
+} __packed;
+
+#define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC        BT_OP(BT_OGF_LE, 0x0044)
+struct bt_hci_cp_le_per_adv_create_sync {
+	uint8_t      filter_policy;
+	uint8_t      sid;
+	bt_addr_le_t addr;
+	uint16_t     skip;
+	uint16_t     sync_timeout;
+	uint8_t      unused;
+} __packed;
+
+#define BT_HCI_OP_LE_PER_ADV_CREATE_SYNC_CANCEL BT_OP(BT_OGF_LE, 0x0045)
+
+#define BT_HCI_OP_LE_PER_ADV_TERMINATE_SYNC     BT_OP(BT_OGF_LE, 0x0046)
+struct bt_hci_cp_le_per_adv_terminate_sync {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_OP_LE_ADD_DEV_TO_PER_ADV_LIST    BT_OP(BT_OGF_LE, 0x0047)
+struct bt_hci_cp_le_add_dev_to_per_adv_list {
+	bt_addr_le_t addr;
+	uint8_t      sid;
+} __packed;
+
+#define BT_HCI_OP_LE_REM_DEV_FROM_PER_ADV_LIST  BT_OP(BT_OGF_LE, 0x0048)
+struct bt_hci_cp_le_rem_dev_from_per_adv_list {
+	bt_addr_le_t addr;
+	uint8_t      sid;
+} __packed;
+
+#define BT_HCI_OP_LE_CLEAR_PER_ADV_LIST         BT_OP(BT_OGF_LE, 0x0049)
+
+#define BT_HCI_OP_LE_READ_PER_ADV_LIST_SIZE     BT_OP(BT_OGF_LE, 0x004a)
+struct bt_hci_rp_le_read_per_adv_list_size {
+	uint8_t  status;
+	uint8_t  list_size;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_TX_POWER              BT_OP(BT_OGF_LE, 0x004b)
+struct bt_hci_rp_le_read_tx_power {
+	uint8_t status;
+	int8_t  min_tx_power;
+	int8_t  max_tx_power;
+} __packed;
+
+#define BT_HCI_OP_LE_READ_RF_PATH_COMP          BT_OP(BT_OGF_LE, 0x004c)
+struct bt_hci_rp_le_read_rf_path_comp {
+	uint8_t status;
+	int16_t tx_path_comp;
+	int16_t rx_path_comp;
+} __packed;
+
+#define BT_HCI_OP_LE_WRITE_RF_PATH_COMP         BT_OP(BT_OGF_LE, 0x004d)
+struct bt_hci_cp_le_write_rf_path_comp {
+	int16_t  tx_path_comp;
+	int16_t  rx_path_comp;
+} __packed;
+
+#define BT_HCI_LE_PRIVACY_MODE_NETWORK          0x00
+#define BT_HCI_LE_PRIVACY_MODE_DEVICE           0x01
+
+#define BT_HCI_OP_LE_SET_PRIVACY_MODE           BT_OP(BT_OGF_LE, 0x004e)
+struct bt_hci_cp_le_set_privacy_mode {
+	bt_addr_le_t id_addr;
+	uint8_t         mode;
+} __packed;
+
+/* Event definitions */
+
+#define BT_HCI_EVT_UNKNOWN                      0x00
+#define BT_HCI_EVT_VENDOR                       0xff
+
+#define BT_HCI_EVT_INQUIRY_COMPLETE             0x01
+struct bt_hci_evt_inquiry_complete {
+	uint8_t status;
+} __packed;
+
+#define BT_HCI_EVT_CONN_COMPLETE                0x03
+struct bt_hci_evt_conn_complete {
+	uint8_t   status;
+	uint16_t  handle;
+	bt_addr_t bdaddr;
+	uint8_t   link_type;
+	uint8_t   encr_enabled;
+} __packed;
+
+#define BT_HCI_EVT_CONN_REQUEST                 0x04
+struct bt_hci_evt_conn_request {
+	bt_addr_t bdaddr;
+	uint8_t   dev_class[3];
+	uint8_t   link_type;
+} __packed;
+
+#define BT_HCI_EVT_DISCONN_COMPLETE             0x05
+struct bt_hci_evt_disconn_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  reason;
+} __packed;
+
+#define BT_HCI_EVT_AUTH_COMPLETE                0x06
+struct bt_hci_evt_auth_complete {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_NAME_REQ_COMPLETE     0x07
+struct bt_hci_evt_remote_name_req_complete {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+	uint8_t   name[248];
+} __packed;
+
+#define BT_HCI_EVT_ENCRYPT_CHANGE               0x08
+struct bt_hci_evt_encrypt_change {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  encrypt;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_FEATURES              0x0b
+struct bt_hci_evt_remote_features {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_VERSION_INFO          0x0c
+struct bt_hci_evt_remote_version_info {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  version;
+	uint16_t manufacturer;
+	uint16_t subversion;
+} __packed;
+
+#define BT_HCI_EVT_CMD_COMPLETE                 0x0e
+struct bt_hci_evt_cmd_complete {
+	uint8_t  ncmd;
+	uint16_t opcode;
+} __packed;
+
+struct bt_hci_evt_cc_status {
+	uint8_t  status;
+} __packed;
+
+#define BT_HCI_EVT_CMD_STATUS                   0x0f
+struct bt_hci_evt_cmd_status {
+	uint8_t  status;
+	uint8_t  ncmd;
+	uint16_t opcode;
+} __packed;
+
+#define BT_HCI_EVT_ROLE_CHANGE                  0x12
+struct bt_hci_evt_role_change {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+	uint8_t   role;
+} __packed;
+
+#define BT_HCI_EVT_NUM_COMPLETED_PACKETS        0x13
+struct bt_hci_evt_num_completed_packets {
+	uint8_t  num_handles;
+	struct bt_hci_handle_count h[0];
+} __packed;
+
+#define BT_HCI_EVT_PIN_CODE_REQ                 0x16
+struct bt_hci_evt_pin_code_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_LINK_KEY_REQ                 0x17
+struct bt_hci_evt_link_key_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+/* Link Key types */
+#define BT_LK_COMBINATION                       0x00
+#define BT_LK_LOCAL_UNIT                        0x01
+#define BT_LK_REMOTE_UNIT                       0x02
+#define BT_LK_DEBUG_COMBINATION                 0x03
+#define BT_LK_UNAUTH_COMBINATION_P192           0x04
+#define BT_LK_AUTH_COMBINATION_P192             0x05
+#define BT_LK_CHANGED_COMBINATION               0x06
+#define BT_LK_UNAUTH_COMBINATION_P256           0x07
+#define BT_LK_AUTH_COMBINATION_P256             0x08
+
+#define BT_HCI_EVT_LINK_KEY_NOTIFY              0x18
+struct bt_hci_evt_link_key_notify {
+	bt_addr_t bdaddr;
+	uint8_t   link_key[16];
+	uint8_t   key_type;
+} __packed;
+
+/* Overflow link types */
+#define BT_OVERFLOW_LINK_SYNCH                  0x00
+#define BT_OVERFLOW_LINK_ACL                    0x01
+
+#define BT_HCI_EVT_DATA_BUF_OVERFLOW            0x1a
+struct bt_hci_evt_data_buf_overflow {
+	uint8_t  link_type;
+} __packed;
+
+#define BT_HCI_EVT_INQUIRY_RESULT_WITH_RSSI     0x22
+struct bt_hci_evt_inquiry_result_with_rssi {
+	bt_addr_t addr;
+	uint8_t   pscan_rep_mode;
+	uint8_t   reserved;
+	uint8_t   cod[3];
+	uint16_t  clock_offset;
+	int8_t    rssi;
+} __packed;
+
+#define BT_HCI_EVT_REMOTE_EXT_FEATURES          0x23
+struct bt_hci_evt_remote_ext_features {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  page;
+	uint8_t  max_page;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_SYNC_CONN_COMPLETE           0x2c
+struct bt_hci_evt_sync_conn_complete {
+	uint8_t    status;
+	uint16_t   handle;
+	bt_addr_t  bdaddr;
+	uint8_t    link_type;
+	uint8_t    tx_interval;
+	uint8_t    retansmission_window;
+	uint16_t   rx_pkt_length;
+	uint16_t   tx_pkt_length;
+	uint8_t    air_mode;
+} __packed;
+
+#define BT_HCI_EVT_EXTENDED_INQUIRY_RESULT      0x2f
+struct bt_hci_evt_extended_inquiry_result {
+	uint8_t    num_reports;
+	bt_addr_t  addr;
+	uint8_t    pscan_rep_mode;
+	uint8_t    reserved;
+	uint8_t    cod[3];
+	uint16_t   clock_offset;
+	int8_t     rssi;
+	uint8_t    eir[240];
+} __packed;
+
+#define BT_HCI_EVT_ENCRYPT_KEY_REFRESH_COMPLETE 0x30
+struct bt_hci_evt_encrypt_key_refresh_complete {
+	uint8_t  status;
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_IO_CAPA_REQ                  0x31
+struct bt_hci_evt_io_capa_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_IO_CAPA_RESP                 0x32
+struct bt_hci_evt_io_capa_resp {
+	bt_addr_t bdaddr;
+	uint8_t   capability;
+	uint8_t   oob_data;
+	uint8_t   authentication;
+} __packed;
+
+#define BT_HCI_EVT_USER_CONFIRM_REQ             0x33
+struct bt_hci_evt_user_confirm_req {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_EVT_USER_PASSKEY_REQ             0x34
+struct bt_hci_evt_user_passkey_req {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_SSP_COMPLETE                 0x36
+struct bt_hci_evt_ssp_complete {
+	uint8_t   status;
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_EVT_USER_PASSKEY_NOTIFY          0x3b
+struct bt_hci_evt_user_passkey_notify {
+	bt_addr_t bdaddr;
+	uint32_t  passkey;
+} __packed;
+
+#define BT_HCI_EVT_LE_META_EVENT                0x3e
+struct bt_hci_evt_le_meta_event {
+	uint8_t  subevent;
+} __packed;
+
+#define BT_HCI_EVT_AUTH_PAYLOAD_TIMEOUT_EXP     0x57
+struct bt_hci_evt_auth_payload_timeout_exp {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_ROLE_MASTER                      0x00
+#define BT_HCI_ROLE_SLAVE                       0x01
+
+#define BT_HCI_EVT_LE_CONN_COMPLETE             0x01
+struct bt_hci_evt_le_conn_complete {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      role;
+	bt_addr_le_t peer_addr;
+	uint16_t     interval;
+	uint16_t     latency;
+	uint16_t     supv_timeout;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_ADVERTISING_REPORT        0x02
+struct bt_hci_evt_le_advertising_info {
+	uint8_t      evt_type;
+	bt_addr_le_t addr;
+	uint8_t      length;
+	uint8_t      data[0];
+} __packed;
+struct bt_hci_evt_le_advertising_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_advertising_info adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_CONN_UPDATE_COMPLETE      0x03
+struct bt_hci_evt_le_conn_update_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint16_t interval;
+	uint16_t latency;
+	uint16_t supv_timeout;
+} __packed;
+
+#define BT_HCI_EV_LE_REMOTE_FEAT_COMPLETE       0x04
+struct bt_hci_evt_le_remote_feat_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_EVT_LE_LTK_REQUEST               0x05
+struct bt_hci_evt_le_ltk_request {
+	uint16_t handle;
+	uint64_t rand;
+	uint16_t ediv;
+} __packed;
+
+#define BT_HCI_EVT_LE_CONN_PARAM_REQ            0x06
+struct bt_hci_evt_le_conn_param_req {
+	uint16_t handle;
+	uint16_t interval_min;
+	uint16_t interval_max;
+	uint16_t latency;
+	uint16_t timeout;
+} __packed;
+
+#define BT_HCI_EVT_LE_DATA_LEN_CHANGE           0x07
+struct bt_hci_evt_le_data_len_change {
+	uint16_t handle;
+	uint16_t max_tx_octets;
+	uint16_t max_tx_time;
+	uint16_t max_rx_octets;
+	uint16_t max_rx_time;
+} __packed;
+
+#define BT_HCI_EVT_LE_P256_PUBLIC_KEY_COMPLETE  0x08
+struct bt_hci_evt_le_p256_public_key_complete {
+	uint8_t status;
+	uint8_t key[64];
+} __packed;
+
+#define BT_HCI_EVT_LE_GENERATE_DHKEY_COMPLETE   0x09
+struct bt_hci_evt_le_generate_dhkey_complete {
+	uint8_t status;
+	uint8_t dhkey[32];
+} __packed;
+
+#define BT_HCI_EVT_LE_ENH_CONN_COMPLETE         0x0a
+struct bt_hci_evt_le_enh_conn_complete {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      role;
+	bt_addr_le_t peer_addr;
+	bt_addr_t    local_rpa;
+	bt_addr_t    peer_rpa;
+	uint16_t     interval;
+	uint16_t     latency;
+	uint16_t     supv_timeout;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_DIRECT_ADV_REPORT         0x0b
+struct bt_hci_evt_le_direct_adv_info {
+	uint8_t      evt_type;
+	bt_addr_le_t addr;
+	bt_addr_le_t dir_addr;
+	int8_t       rssi;
+} __packed;
+struct bt_hci_evt_le_direct_adv_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_direct_adv_info direct_adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PHY_UPDATE_COMPLETE       0x0c
+struct bt_hci_evt_le_phy_update_complete {
+	uint8_t  status;
+	uint16_t handle;
+	uint8_t  tx_phy;
+	uint8_t  rx_phy;
+} __packed;
+
+#define BT_HCI_EVT_LE_EXT_ADVERTISING_REPORT    0x0d
+
+#define BT_HCI_LE_ADV_EVT_TYPE_CONN                 BIT(0)
+#define BT_HCI_LE_ADV_EVT_TYPE_SCAN                 BIT(1)
+#define BT_HCI_LE_ADV_EVT_TYPE_DIRECT               BIT(2)
+#define BT_HCI_LE_ADV_EVT_TYPE_SCAN_RSP             BIT(3)
+#define BT_HCI_LE_ADV_EVT_TYPE_LEGACY               BIT(4)
+
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS(ev_type) (((ev_type) >> 5) & 0x03)
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_COMPLETE   0
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_PARTIAL    1
+#define BT_HCI_LE_ADV_EVT_TYPE_DATA_STATUS_INCOMPLETE 2
+
+struct bt_hci_evt_le_ext_advertising_info {
+	uint16_t     evt_type;
+	bt_addr_le_t addr;
+	uint8_t      prim_phy;
+	uint8_t      sec_phy;
+	uint8_t      sid;
+	int8_t       tx_power;
+	int8_t       rssi;
+	uint16_t     interval;
+	bt_addr_le_t direct_addr;
+	uint8_t      length;
+	uint8_t      data[0];
+} __packed;
+struct bt_hci_evt_le_ext_advertising_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_le_ext_advertising_info adv_info[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADV_SYNC_ESTABLISHED  0x0e
+struct bt_hci_evt_le_per_adv_sync_established {
+	uint8_t      status;
+	uint16_t     handle;
+	uint8_t      sid;
+	bt_addr_le_t adv_addr;
+	uint8_t      phy;
+	uint16_t     interval;
+	uint8_t      clock_accuracy;
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADVERTISING_REPORT    0x0f
+struct bt_hci_evt_le_per_advertising_report {
+	uint16_t handle;
+	int8_t   tx_power;
+	int8_t   rssi;
+	uint8_t  unused;
+	uint8_t  data_status;
+	uint8_t  length;
+	uint8_t  data[0];
+} __packed;
+
+#define BT_HCI_EVT_LE_PER_ADV_SYNC_LOST         0x10
+struct bt_hci_evt_le_per_adv_sync_lost {
+	uint16_t handle;
+} __packed;
+
+#define BT_HCI_EVT_LE_SCAN_TIMEOUT              0x11
+
+#define BT_HCI_EVT_LE_ADV_SET_TERMINATED        0x12
+struct bt_hci_evt_le_adv_set_terminated {
+	uint8_t  status;
+	uint8_t  adv_handle;
+	uint16_t conn_handle;
+	uint8_t  num_completed_ext_adv_evts;
+} __packed;
+
+#define BT_HCI_EVT_LE_SCAN_REQ_RECEIVED         0x13
+struct bt_hci_evt_le_scan_req_received {
+	uint8_t      handle;
+	bt_addr_le_t addr;
+} __packed;
+
+#define BT_HCI_LE_CHAN_SEL_ALGO_1               0x00
+#define BT_HCI_LE_CHAN_SEL_ALGO_2               0x01
+
+#define BT_HCI_EVT_LE_CHAN_SEL_ALGO             0x14
+struct bt_hci_evt_le_chan_sel_algo {
+	uint16_t handle;
+	uint8_t  chan_sel_algo;
+} __packed;
+
+/* Event mask bits */
+
+#define BT_EVT_BIT(n) (1ULL << (n))
+
+#define BT_EVT_MASK_INQUIRY_COMPLETE             BT_EVT_BIT(0)
+#define BT_EVT_MASK_CONN_COMPLETE                BT_EVT_BIT(2)
+#define BT_EVT_MASK_CONN_REQUEST                 BT_EVT_BIT(3)
+#define BT_EVT_MASK_DISCONN_COMPLETE             BT_EVT_BIT(4)
+#define BT_EVT_MASK_AUTH_COMPLETE                BT_EVT_BIT(5)
+#define BT_EVT_MASK_REMOTE_NAME_REQ_COMPLETE     BT_EVT_BIT(6)
+#define BT_EVT_MASK_ENCRYPT_CHANGE               BT_EVT_BIT(7)
+#define BT_EVT_MASK_REMOTE_FEATURES              BT_EVT_BIT(10)
+#define BT_EVT_MASK_REMOTE_VERSION_INFO          BT_EVT_BIT(11)
+#define BT_EVT_MASK_HARDWARE_ERROR               BT_EVT_BIT(15)
+#define BT_EVT_MASK_ROLE_CHANGE                  BT_EVT_BIT(17)
+#define BT_EVT_MASK_PIN_CODE_REQ                 BT_EVT_BIT(21)
+#define BT_EVT_MASK_LINK_KEY_REQ                 BT_EVT_BIT(22)
+#define BT_EVT_MASK_LINK_KEY_NOTIFY              BT_EVT_BIT(23)
+#define BT_EVT_MASK_DATA_BUFFER_OVERFLOW         BT_EVT_BIT(25)
+#define BT_EVT_MASK_INQUIRY_RESULT_WITH_RSSI     BT_EVT_BIT(33)
+#define BT_EVT_MASK_REMOTE_EXT_FEATURES          BT_EVT_BIT(34)
+#define BT_EVT_MASK_SYNC_CONN_COMPLETE           BT_EVT_BIT(43)
+#define BT_EVT_MASK_EXTENDED_INQUIRY_RESULT      BT_EVT_BIT(46)
+#define BT_EVT_MASK_ENCRYPT_KEY_REFRESH_COMPLETE BT_EVT_BIT(47)
+#define BT_EVT_MASK_IO_CAPA_REQ                  BT_EVT_BIT(48)
+#define BT_EVT_MASK_IO_CAPA_RESP                 BT_EVT_BIT(49)
+#define BT_EVT_MASK_USER_CONFIRM_REQ             BT_EVT_BIT(50)
+#define BT_EVT_MASK_USER_PASSKEY_REQ             BT_EVT_BIT(51)
+#define BT_EVT_MASK_SSP_COMPLETE                 BT_EVT_BIT(53)
+#define BT_EVT_MASK_USER_PASSKEY_NOTIFY          BT_EVT_BIT(58)
+#define BT_EVT_MASK_LE_META_EVENT                BT_EVT_BIT(61)
+
+/* Page 2 */
+#define BT_EVT_MASK_PHY_LINK_COMPLETE            BT_EVT_BIT(0)
+#define BT_EVT_MASK_CH_SELECTED_COMPLETE         BT_EVT_BIT(1)
+#define BT_EVT_MASK_DISCONN_PHY_LINK_COMPLETE    BT_EVT_BIT(2)
+#define BT_EVT_MASK_PHY_LINK_LOSS_EARLY_WARN     BT_EVT_BIT(3)
+#define BT_EVT_MASK_PHY_LINK_RECOVERY            BT_EVT_BIT(4)
+#define BT_EVT_MASK_LOG_LINK_COMPLETE            BT_EVT_BIT(5)
+#define BT_EVT_MASK_DISCONN_LOG_LINK_COMPLETE    BT_EVT_BIT(6)
+#define BT_EVT_MASK_FLOW_SPEC_MODIFY_COMPLETE    BT_EVT_BIT(7)
+#define BT_EVT_MASK_NUM_COMPLETE_DATA_BLOCKS     BT_EVT_BIT(8)
+#define BT_EVT_MASK_AMP_START_TEST               BT_EVT_BIT(9)
+#define BT_EVT_MASK_AMP_TEST_END                 BT_EVT_BIT(10)
+#define BT_EVT_MASK_AMP_RX_REPORT                BT_EVT_BIT(11)
+#define BT_EVT_MASK_AMP_SR_MODE_CHANGE_COMPLETE  BT_EVT_BIT(12)
+#define BT_EVT_MASK_AMP_STATUS_CHANGE            BT_EVT_BIT(13)
+#define BT_EVT_MASK_TRIGG_CLOCK_CAPTURE          BT_EVT_BIT(14)
+#define BT_EVT_MASK_SYNCH_TRAIN_COMPLETE         BT_EVT_BIT(15)
+#define BT_EVT_MASK_SYNCH_TRAIN_RX               BT_EVT_BIT(16)
+#define BT_EVT_MASK_CL_SLAVE_BC_RX               BT_EVT_BIT(17)
+#define BT_EVT_MASK_CL_SLAVE_BC_TIMEOUT          BT_EVT_BIT(18)
+#define BT_EVT_MASK_TRUNC_PAGE_COMPLETE          BT_EVT_BIT(19)
+#define BT_EVT_MASK_SLAVE_PAGE_RSP_TIMEOUT       BT_EVT_BIT(20)
+#define BT_EVT_MASK_CL_SLAVE_BC_CH_MAP_CHANGE    BT_EVT_BIT(21)
+#define BT_EVT_MASK_INQUIRY_RSP_NOT              BT_EVT_BIT(22)
+#define BT_EVT_MASK_AUTH_PAYLOAD_TIMEOUT_EXP     BT_EVT_BIT(23)
+#define BT_EVT_MASK_SAM_STATUS_CHANGE            BT_EVT_BIT(24)
+
+#define BT_EVT_MASK_LE_CONN_COMPLETE             BT_EVT_BIT(0)
+#define BT_EVT_MASK_LE_ADVERTISING_REPORT        BT_EVT_BIT(1)
+#define BT_EVT_MASK_LE_CONN_UPDATE_COMPLETE      BT_EVT_BIT(2)
+#define BT_EVT_MASK_LE_REMOTE_FEAT_COMPLETE      BT_EVT_BIT(3)
+#define BT_EVT_MASK_LE_LTK_REQUEST               BT_EVT_BIT(4)
+#define BT_EVT_MASK_LE_CONN_PARAM_REQ            BT_EVT_BIT(5)
+#define BT_EVT_MASK_LE_DATA_LEN_CHANGE           BT_EVT_BIT(6)
+#define BT_EVT_MASK_LE_P256_PUBLIC_KEY_COMPLETE  BT_EVT_BIT(7)
+#define BT_EVT_MASK_LE_GENERATE_DHKEY_COMPLETE   BT_EVT_BIT(8)
+#define BT_EVT_MASK_LE_ENH_CONN_COMPLETE         BT_EVT_BIT(9)
+#define BT_EVT_MASK_LE_DIRECT_ADV_REPORT         BT_EVT_BIT(10)
+#define BT_EVT_MASK_LE_PHY_UPDATE_COMPLETE       BT_EVT_BIT(11)
+#define BT_EVT_MASK_LE_EXT_ADVERTISING_REPORT    BT_EVT_BIT(12)
+#define BT_EVT_MASK_LE_PER_ADV_SYNC_ESTABLISHED  BT_EVT_BIT(13)
+#define BT_EVT_MASK_LE_PER_ADVERTISING_REPORT    BT_EVT_BIT(14)
+#define BT_EVT_MASK_LE_PER_ADV_SYNC_LOST         BT_EVT_BIT(15)
+#define BT_EVT_MASK_LE_SCAN_TIMEOUT              BT_EVT_BIT(16)
+#define BT_EVT_MASK_LE_ADV_SET_TERMINATED        BT_EVT_BIT(17)
+#define BT_EVT_MASK_LE_SCAN_REQ_RECEIVED         BT_EVT_BIT(18)
+#define BT_EVT_MASK_LE_CHAN_SEL_ALGO             BT_EVT_BIT(19)
+
+//
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_HCI_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci_err.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci_err.h
new file mode 100644
index 000000000..476d3f463
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci_err.h
@@ -0,0 +1,92 @@
+/** @file
+ *  @brief Bluetooth Host Control Interface status codes.
+ */
+
+/*
+ * Copyright (c) 2019 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_HCI_STATUS_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_HCI_STATUS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** HCI Error Codes, BT Core Spec v5.2 [Vol 1, Part F]. */
+#define BT_HCI_ERR_SUCCESS                      0x00
+#define BT_HCI_ERR_UNKNOWN_CMD                  0x01
+#define BT_HCI_ERR_UNKNOWN_CONN_ID              0x02
+#define BT_HCI_ERR_HW_FAILURE                   0x03
+#define BT_HCI_ERR_PAGE_TIMEOUT                 0x04
+#define BT_HCI_ERR_AUTH_FAIL                    0x05
+#define BT_HCI_ERR_PIN_OR_KEY_MISSING           0x06
+#define BT_HCI_ERR_MEM_CAPACITY_EXCEEDED        0x07
+#define BT_HCI_ERR_CONN_TIMEOUT                 0x08
+#define BT_HCI_ERR_CONN_LIMIT_EXCEEDED          0x09
+#define BT_HCI_ERR_SYNC_CONN_LIMIT_EXCEEDED     0x0a
+#define BT_HCI_ERR_CONN_ALREADY_EXISTS          0x0b
+#define BT_HCI_ERR_CMD_DISALLOWED               0x0c
+#define BT_HCI_ERR_INSUFFICIENT_RESOURCES       0x0d
+#define BT_HCI_ERR_INSUFFICIENT_SECURITY        0x0e
+#define BT_HCI_ERR_BD_ADDR_UNACCEPTABLE         0x0f
+#define BT_HCI_ERR_CONN_ACCEPT_TIMEOUT          0x10
+#define BT_HCI_ERR_UNSUPP_FEATURE_PARAM_VAL     0x11
+#define BT_HCI_ERR_INVALID_PARAM                0x12
+#define BT_HCI_ERR_REMOTE_USER_TERM_CONN        0x13
+#define BT_HCI_ERR_REMOTE_LOW_RESOURCES         0x14
+#define BT_HCI_ERR_REMOTE_POWER_OFF             0x15
+#define BT_HCI_ERR_LOCALHOST_TERM_CONN          0x16
+#define BT_HCI_ERR_REPEATED_ATTEMPTS            0x17
+#define BT_HCI_ERR_PAIRING_NOT_ALLOWED          0x18
+#define BT_HCI_ERR_UNKNOWN_LMP_PDU              0x19
+#define BT_HCI_ERR_UNSUPP_REMOTE_FEATURE        0x1a
+#define BT_HCI_ERR_SCO_OFFSET_REJECTED          0x1b
+#define BT_HCI_ERR_SCO_INTERVAL_REJECTED        0x1c
+#define BT_HCI_ERR_SCO_AIR_MODE_REJECTED        0x1d
+#define BT_HCI_ERR_INVALID_LL_PARAM             0x1e
+#define BT_HCI_ERR_UNSPECIFIED                  0x1f
+#define BT_HCI_ERR_UNSUPP_LL_PARAM_VAL          0x20
+#define BT_HCI_ERR_ROLE_CHANGE_NOT_ALLOWED      0x21
+#define BT_HCI_ERR_LL_RESP_TIMEOUT              0x22
+#define BT_HCI_ERR_LL_PROC_COLLISION            0x23
+#define BT_HCI_ERR_LMP_PDU_NOT_ALLOWED          0x24
+#define BT_HCI_ERR_ENC_MODE_NOT_ACCEPTABLE      0x25
+#define BT_HCI_ERR_LINK_KEY_CANNOT_BE_CHANGED   0x26
+#define BT_HCI_ERR_REQUESTED_QOS_NOT_SUPPORTED  0x27
+#define BT_HCI_ERR_INSTANT_PASSED               0x28
+#define BT_HCI_ERR_PAIRING_NOT_SUPPORTED        0x29
+#define BT_HCI_ERR_DIFF_TRANS_COLLISION         0x2a
+#define BT_HCI_ERR_QOS_UNACCEPTABLE_PARAM       0x2c
+#define BT_HCI_ERR_QOS_REJECTED                 0x2d
+#define BT_HCI_ERR_CHAN_ASSESS_NOT_SUPPORTED    0x2e
+#define BT_HCI_ERR_INSUFF_SECURITY              0x2f
+#define BT_HCI_ERR_PARAM_OUT_OF_MANDATORY_RANGE 0x30
+#define BT_HCI_ERR_ROLE_SWITCH_PENDING          0x32
+#define BT_HCI_ERR_RESERVED_SLOT_VIOLATION      0x34
+#define BT_HCI_ERR_ROLE_SWITCH_FAILED           0x35
+#define BT_HCI_ERR_EXT_INQ_RESP_TOO_LARGE       0x36
+#define BT_HCI_ERR_SIMPLE_PAIR_NOT_SUPP_BY_HOST 0x37
+#define BT_HCI_ERR_HOST_BUSY_PAIRING            0x38
+#define BT_HCI_ERR_CONN_REJECTED_DUE_TO_NO_CHAN 0x39
+#define BT_HCI_ERR_CONTROLLER_BUSY              0x3a
+#define BT_HCI_ERR_UNACCEPT_CONN_PARAM          0x3b
+#define BT_HCI_ERR_ADV_TIMEOUT                  0x3c
+#define BT_HCI_ERR_TERM_DUE_TO_MIC_FAIL         0x3d
+#define BT_HCI_ERR_CONN_FAIL_TO_ESTAB           0x3e
+#define BT_HCI_ERR_MAC_CONN_FAILED              0x3f
+#define BT_HCI_ERR_CLOCK_ADJUST_REJECTED        0x40
+#define BT_HCI_ERR_SUBMAP_NOT_DEFINED           0x41
+#define BT_HCI_ERR_UNKNOWN_ADV_IDENTIFIER       0x42
+#define BT_HCI_ERR_LIMIT_REACHED                0x43
+#define BT_HCI_ERR_OP_CANCELLED_BY_HOST         0x44
+#define BT_HCI_ERR_PACKET_TOO_LONG              0x45
+
+#define BT_HCI_ERR_AUTHENTICATION_FAIL __DEPRECATED_MACRO BT_HCI_ERR_AUTH_FAIL
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_HCI_STATUS_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h
new file mode 100644
index 000000000..030fb0ca3
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci_raw.h
@@ -0,0 +1,152 @@
+/** @file
+ *  @brief Bluetooth HCI RAW channel handling
+ */
+
+/*
+ * Copyright (c) 2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_HCI_RAW_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_HCI_RAW_H_
+
+/**
+ * @brief HCI RAW channel
+ * @defgroup hci_raw HCI RAW channel
+ * @ingroup bluetooth
+ * @{
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(CONFIG_BT_CTLR_TX_BUFFER_SIZE)
+#define BT_L2CAP_MTU (CONFIG_BT_CTLR_TX_BUFFER_SIZE - BT_L2CAP_HDR_SIZE)
+#else
+#define BT_L2CAP_MTU 65 /* 64-byte public key + opcode */
+#endif /* CONFIG_BT_CTLR */
+
+/** Data size needed for ACL buffers */
+#define BT_BUF_ACL_SIZE BT_L2CAP_BUF_SIZE(BT_L2CAP_MTU)
+
+#if defined(CONFIG_BT_CTLR_TX_BUFFERS)
+#define BT_HCI_ACL_COUNT CONFIG_BT_CTLR_TX_BUFFERS
+#else
+#define BT_HCI_ACL_COUNT 6
+#endif
+
+#define BT_BUF_TX_SIZE MAX(BT_BUF_RX_SIZE, BT_BUF_ACL_SIZE)
+
+/** @brief Send packet to the Bluetooth controller
+ *
+ * Send packet to the Bluetooth controller. Caller needs to
+ * implement netbuf pool.
+ *
+ * @param buf netbuf packet to be send
+ *
+ * @return Zero on success or (negative) error code otherwise.
+ */
+int bt_send(struct net_buf *buf);
+
+enum {
+	/** Passthrough mode
+	 *
+	 *  While in this mode the buffers are passed as is between the stack
+	 *  and the driver.
+	 */
+	BT_HCI_RAW_MODE_PASSTHROUGH = 0x00,
+
+	/** H:4 mode
+	 *
+	 *  While in this mode H:4 headers will added into the buffers
+	 *  according to the buffer type when coming from the stack and will be
+	 *  removed and used to set the buffer type.
+	 */
+	BT_HCI_RAW_MODE_H4 = 0x01,
+};
+
+/** @brief Set Bluetooth RAW channel mode
+ *
+ *  Set access mode of Bluetooth RAW channel.
+ *
+ *  @param mode Access mode.
+ *
+ *  @return Zero on success or (negative) error code otherwise.
+ */
+int bt_hci_raw_set_mode(uint8_t mode);
+
+/** @brief Get Bluetooth RAW channel mode
+ *
+ *  Get access mode of Bluetooth RAW channel.
+ *
+ *  @return Access mode.
+ */
+uint8_t bt_hci_raw_get_mode(void);
+
+#define BT_HCI_ERR_EXT_HANDLED  0xff
+
+/** Helper macro to define a command extension
+ *
+ *  @param _op Opcode of the command.
+ *  @param _min_len Minimal length of the command.
+ *  @param _func Handler function to be called.
+ */
+#define BT_HCI_RAW_CMD_EXT(_op, _min_len, _func) \
+	{ \
+		.op = _op, \
+		.min_len = _min_len, \
+		.func = _func, \
+	}
+
+struct bt_hci_raw_cmd_ext {
+	/** Opcode of the command */
+	uint16_t  op;
+
+	/** Minimal length of the command */
+	size_t min_len;
+
+	/** Handler function.
+	 *
+	 *  Handler function to be called when a command is intercepted.
+	 *
+	 *  @param buf Buffer containing the command.
+	 *
+	 *  @return HCI Status code or BT_HCI_ERR_EXT_HANDLED if command has
+	 *  been handled already and a response has been sent as oppose to
+	 *  BT_HCI_ERR_SUCCESS which just indicates that the command can be
+	 *  sent to the controller to be processed.
+	 */
+	uint8_t   (*func)(struct net_buf *buf);
+};
+
+/** @brief Register Bluetooth RAW command extension table
+ *
+ *  Register Bluetooth RAW channel command extension table, opcodes in this
+ *  table are intercepted to sent to the handler function.
+ *
+ *  @param cmds Pointer to the command extension table.
+ *  @param size Size of the command extension table.
+ */
+void bt_hci_raw_cmd_ext_register(struct bt_hci_raw_cmd_ext *cmds, size_t size);
+
+/** @brief Enable Bluetooth RAW channel:
+ *
+ *  Enable Bluetooth RAW HCI channel.
+ *
+ *  @param rx_queue netbuf queue where HCI packets received from the Bluetooth
+ *  controller are to be queued. The queue is defined in the caller while
+ *  the available buffers pools are handled in the stack.
+ *
+ *  @return Zero on success or (negative) error code otherwise.
+ */
+int bt_enable_raw(struct k_fifo *rx_queue);
+
+#ifdef __cplusplus
+}
+#endif
+/**
+ * @}
+ */
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_HCI_RAW_H_ */
diff --git a/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h b/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h
new file mode 100644
index 000000000..e4f94b6a8
--- /dev/null
+++ b/devices/ble_hci/common-hal/_bleio/hci_include/hci_vs.h
@@ -0,0 +1,379 @@
+/* hci_vs.h - Bluetooth Host Control Interface Vendor Specific definitions */
+
+/*
+ * Copyright (c) 2017-2018 Nordic Semiconductor ASA
+ * Copyright (c) 2015-2016 Intel Corporation
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#ifndef ZEPHYR_INCLUDE_BLUETOOTH_HCI_VS_H_
+#define ZEPHYR_INCLUDE_BLUETOOTH_HCI_VS_H_
+
+#include <bluetooth/hci.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BT_VS_CMD_BIT_VERSION                       0
+#define BT_VS_CMD_BIT_SUP_CMD                       1
+#define BT_VS_CMD_BIT_SUP_FEAT                      2
+#define BT_VS_CMD_BIT_SET_EVT_MASK                  3
+#define BT_VS_CMD_BIT_RESET                         4
+#define BT_VS_CMD_BIT_WRITE_BDADDR                  5
+#define BT_VS_CMD_BIT_SET_TRACE_ENABLE              6
+#define BT_VS_CMD_BIT_READ_BUILD_INFO               7
+#define BT_VS_CMD_BIT_READ_STATIC_ADDRS             8
+#define BT_VS_CMD_BIT_READ_KEY_ROOTS                9
+#define BT_VS_CMD_BIT_READ_CHIP_TEMP               10
+#define BT_VS_CMD_BIT_READ_HOST_STACK_CMD          11
+#define BT_VS_CMD_BIT_SET_SCAN_REP_ENABLE          12
+#define BT_VS_CMD_BIT_WRITE_TX_POWER               13
+#define BT_VS_CMD_BIT_READ_TX_POWER                14
+
+#define BT_VS_CMD_SUP_FEAT(cmd)                 BT_LE_FEAT_TEST(cmd, \
+						BT_VS_CMD_BIT_SUP_FEAT)
+#define BT_VS_CMD_READ_STATIC_ADDRS(cmd)        BT_LE_FEAT_TEST(cmd, \
+						BT_VS_CMD_BIT_READ_STATIC_ADDRS)
+#define BT_VS_CMD_READ_KEY_ROOTS(cmd)           BT_LE_FEAT_TEST(cmd, \
+						BT_VS_CMD_BIT_READ_KEY_ROOTS)
+
+#define BT_HCI_VS_HW_PLAT_INTEL                 0x0001
+#define BT_HCI_VS_HW_PLAT_NORDIC                0x0002
+#define BT_HCI_VS_HW_PLAT_NXP                   0x0003
+
+#define BT_HCI_VS_HW_VAR_NORDIC_NRF51X          0x0001
+#define BT_HCI_VS_HW_VAR_NORDIC_NRF52X          0x0002
+#define BT_HCI_VS_HW_VAR_NORDIC_NRF53X          0x0003
+
+#define BT_HCI_VS_FW_VAR_STANDARD_CTLR          0x0001
+#define BT_HCI_VS_FW_VAR_VS_CTLR                0x0002
+#define BT_HCI_VS_FW_VAR_FW_LOADER              0x0003
+#define BT_HCI_VS_FW_VAR_RESCUE_IMG             0x0004
+#define BT_HCI_OP_VS_READ_VERSION_INFO		BT_OP(BT_OGF_VS, 0x0001)
+struct bt_hci_rp_vs_read_version_info {
+	uint8_t  status;
+	uint16_t hw_platform;
+	uint16_t hw_variant;
+	uint8_t  fw_variant;
+	uint8_t  fw_version;
+	uint16_t fw_revision;
+	uint32_t fw_build;
+} __packed;
+
+#define BT_HCI_OP_VS_READ_SUPPORTED_COMMANDS	BT_OP(BT_OGF_VS, 0x0002)
+struct bt_hci_rp_vs_read_supported_commands {
+	uint8_t  status;
+	uint8_t  commands[64];
+} __packed;
+
+#define BT_HCI_OP_VS_READ_SUPPORTED_FEATURES	BT_OP(BT_OGF_VS, 0x0003)
+struct bt_hci_rp_vs_read_supported_features {
+	uint8_t  status;
+	uint8_t  features[8];
+} __packed;
+
+#define BT_HCI_OP_VS_SET_EVENT_MASK             BT_OP(BT_OGF_VS, 0x0004)
+struct bt_hci_cp_vs_set_event_mask {
+	uint8_t  event_mask[8];
+} __packed;
+
+#define BT_HCI_VS_RESET_SOFT                    0x00
+#define BT_HCI_VS_RESET_HARD                    0x01
+#define BT_HCI_OP_VS_RESET                      BT_OP(BT_OGF_VS, 0x0005)
+struct bt_hci_cp_vs_reset {
+	uint8_t  type;
+} __packed;
+
+#define BT_HCI_OP_VS_WRITE_BD_ADDR              BT_OP(BT_OGF_VS, 0x0006)
+struct bt_hci_cp_vs_write_bd_addr {
+	bt_addr_t bdaddr;
+} __packed;
+
+#define BT_HCI_VS_TRACE_DISABLED                0x00
+#define BT_HCI_VS_TRACE_ENABLED                 0x01
+
+#define BT_HCI_VS_TRACE_HCI_EVTS                0x00
+#define BT_HCI_VS_TRACE_VDC                     0x01
+#define BT_HCI_OP_VS_SET_TRACE_ENABLE           BT_OP(BT_OGF_VS, 0x0007)
+struct bt_hci_cp_vs_set_trace_enable {
+	uint8_t  enable;
+	uint8_t  type;
+} __packed;
+
+#define BT_HCI_OP_VS_READ_BUILD_INFO            BT_OP(BT_OGF_VS, 0x0008)
+struct bt_hci_rp_vs_read_build_info {
+	uint8_t  status;
+	uint8_t  info[0];
+} __packed;
+
+struct bt_hci_vs_static_addr {
+	bt_addr_t bdaddr;
+	uint8_t      ir[16];
+} __packed;
+
+#define BT_HCI_OP_VS_READ_STATIC_ADDRS          BT_OP(BT_OGF_VS, 0x0009)
+struct bt_hci_rp_vs_read_static_addrs {
+	uint8_t   status;
+	uint8_t   num_addrs;
+	struct bt_hci_vs_static_addr a[0];
+} __packed;
+
+#define BT_HCI_OP_VS_READ_KEY_HIERARCHY_ROOTS   BT_OP(BT_OGF_VS, 0x000a)
+struct bt_hci_rp_vs_read_key_hierarchy_roots {
+	uint8_t  status;
+	uint8_t  ir[16];
+	uint8_t  er[16];
+} __packed;
+
+#define BT_HCI_OP_VS_READ_CHIP_TEMP             BT_OP(BT_OGF_VS, 0x000b)
+struct bt_hci_rp_vs_read_chip_temp {
+	uint8_t  status;
+	int8_t  temps;
+} __packed;
+
+struct bt_hci_vs_cmd {
+	uint16_t vendor_id;
+	uint16_t opcode_base;
+} __packed;
+
+#define BT_HCI_VS_VID_ANDROID                   0x0001
+#define BT_HCI_VS_VID_MICROSOFT                 0x0002
+#define BT_HCI_OP_VS_READ_HOST_STACK_CMDS       BT_OP(BT_OGF_VS, 0x000c)
+struct bt_hci_rp_vs_read_host_stack_cmds {
+	uint8_t   status;
+	uint8_t   num_cmds;
+	struct bt_hci_vs_cmd c[0];
+} __packed;
+
+#define BT_HCI_VS_SCAN_REQ_REPORTS_DISABLED     0x00
+#define BT_HCI_VS_SCAN_REQ_REPORTS_ENABLED      0x01
+#define BT_HCI_OP_VS_SET_SCAN_REQ_REPORTS       BT_OP(BT_OGF_VS, 0x000d)
+struct bt_hci_cp_vs_set_scan_req_reports {
+	uint8_t  enable;
+} __packed;
+
+#define BT_HCI_VS_LL_HANDLE_TYPE_ADV       0x00
+#define BT_HCI_VS_LL_HANDLE_TYPE_SCAN      0x01
+#define BT_HCI_VS_LL_HANDLE_TYPE_CONN      0x02
+#define BT_HCI_VS_LL_TX_POWER_LEVEL_NO_PREF     0x7F
+#define BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL       BT_OP(BT_OGF_VS, 0x000e)
+struct bt_hci_cp_vs_write_tx_power_level {
+	uint8_t  handle_type;
+	uint16_t handle;
+	int8_t  tx_power_level;
+} __packed;
+
+struct bt_hci_rp_vs_write_tx_power_level {
+	uint8_t  status;
+	uint8_t  handle_type;
+	uint16_t handle;
+	int8_t  selected_tx_power;
+} __packed;
+
+#define BT_HCI_OP_VS_READ_TX_POWER_LEVEL        BT_OP(BT_OGF_VS, 0x000f)
+struct bt_hci_cp_vs_read_tx_power_level {
+	uint8_t  handle_type;
+	uint16_t handle;
+} __packed;
+
+struct bt_hci_rp_vs_read_tx_power_level {
+	uint8_t  status;
+	uint8_t  handle_type;
+	uint16_t handle;
+	int8_t  tx_power_level;
+} __packed;
+
+#define BT_HCI_OP_VS_READ_USB_TRANSPORT_MODE    BT_OP(BT_OGF_VS, 0x0010)
+
+struct bt_hci_rp_vs_read_usb_transport_mode {
+	uint8_t  status;
+	uint8_t  num_supported_modes;
+	uint8_t  supported_mode[0];
+} __packed;
+
+#define BT_HCI_VS_USB_H2_MODE                  0x00
+#define BT_HCI_VS_USB_H4_MODE                  0x01
+
+#define BT_HCI_OP_VS_SET_USB_TRANSPORT_MODE    BT_OP(BT_OGF_VS, 0x0011)
+
+struct bt_hci_cp_vs_set_usb_transport_mode {
+	uint8_t  mode;
+} __packed;
+
+/* Events */
+
+struct bt_hci_evt_vs {
+	uint8_t  subevent;
+} __packed;
+
+#define BT_HCI_EVT_VS_FATAL_ERROR              0x02
+struct bt_hci_evt_vs_fatal_error {
+	uint64_t pc;
+	uint8_t  err_info[0];
+} __packed;
+
+#define BT_HCI_VS_TRACE_LMP_TX                 0x01
+#define BT_HCI_VS_TRACE_LMP_RX                 0x02
+#define BT_HCI_VS_TRACE_LLCP_TX                0x03
+#define BT_HCI_VS_TRACE_LLCP_RX                0x04
+#define BT_HCI_VS_TRACE_LE_CONN_IND            0x05
+#define BT_HCI_EVT_VS_TRACE_INFO               0x03
+struct bt_hci_evt_vs_trace_info {
+	uint8_t  type;
+	uint8_t  data[0];
+} __packed;
+
+#define BT_HCI_EVT_VS_SCAN_REQ_RX              0x04
+struct bt_hci_evt_vs_scan_req_rx {
+	bt_addr_le_t addr;
+	int8_t         rssi;
+} __packed;
+
+/* Event mask bits */
+
+#define BT_EVT_MASK_VS_FATAL_ERROR             BT_EVT_BIT(1)
+#define BT_EVT_MASK_VS_TRACE_INFO              BT_EVT_BIT(2)
+#define BT_EVT_MASK_VS_SCAN_REQ_RX             BT_EVT_BIT(3)
+
+/* Mesh HCI commands */
+#define BT_HCI_MESH_REVISION                   0x01
+
+#define BT_HCI_OP_VS_MESH                      BT_OP(BT_OGF_VS, 0x0042)
+#define BT_HCI_MESH_EVT_PREFIX                 0xF0
+
+struct bt_hci_cp_mesh {
+	uint8_t         opcode;
+} __packed;
+
+#define BT_HCI_OC_MESH_GET_OPTS                0x00
+struct bt_hci_rp_mesh_get_opts {
+	uint8_t      status;
+	uint8_t      opcode;
+	uint8_t      revision;
+	uint8_t      ch_map;
+	int8_t      min_tx_power;
+	int8_t      max_tx_power;
+	uint8_t      max_scan_filter;
+	uint8_t      max_filter_pattern;
+	uint8_t      max_adv_slot;
+	uint8_t      max_tx_window;
+	uint8_t      evt_prefix_len;
+	uint8_t      evt_prefix;
+} __packed;
+
+#define BT_HCI_MESH_PATTERN_LEN_MAX            0x0f
+
+#define BT_HCI_OC_MESH_SET_SCAN_FILTER         0x01
+struct bt_hci_mesh_pattern {
+	uint8_t pattern_len;
+	uint8_t pattern[0];
+} __packed;
+
+struct bt_hci_cp_mesh_set_scan_filter {
+	uint8_t      scan_filter;
+	uint8_t      filter_dup;
+	uint8_t      num_patterns;
+	struct    bt_hci_mesh_pattern patterns[0];
+} __packed;
+struct bt_hci_rp_mesh_set_scan_filter {
+	uint8_t      status;
+	uint8_t      opcode;
+	uint8_t      scan_filter;
+} __packed;
+
+#define BT_HCI_OC_MESH_ADVERTISE               0x02
+struct bt_hci_cp_mesh_advertise {
+	uint8_t      adv_slot;
+	uint8_t      own_addr_type;
+	bt_addr_t random_addr;
+	uint8_t      ch_map;
+	int8_t      tx_power;
+	uint8_t      min_tx_delay;
+	uint8_t      max_tx_delay;
+	uint8_t      retx_count;
+	uint8_t      retx_interval;
+	uint8_t      scan_delay;
+	uint16_t     scan_duration;
+	uint8_t      scan_filter;
+	uint8_t      data_len;
+	uint8_t      data[31];
+} __packed;
+struct bt_hci_rp_mesh_advertise {
+	uint8_t      status;
+	uint8_t      opcode;
+	uint8_t      adv_slot;
+} __packed;
+
+#define BT_HCI_OC_MESH_ADVERTISE_TIMED         0x03
+struct bt_hci_cp_mesh_advertise_timed {
+	uint8_t      adv_slot;
+	uint8_t      own_addr_type;
+	bt_addr_t random_addr;
+	uint8_t      ch_map;
+	int8_t      tx_power;
+	uint8_t      retx_count;
+	uint8_t      retx_interval;
+	uint32_t     instant;
+	uint16_t     tx_delay;
+	uint16_t     tx_window;
+	uint8_t      data_len;
+	uint8_t      data[31];
+} __packed;
+struct bt_hci_rp_mesh_advertise_timed {
+	uint8_t      status;
+	uint8_t      opcode;
+	uint8_t      adv_slot;
+} __packed;
+
+#define BT_HCI_OC_MESH_ADVERTISE_CANCEL        0x04
+struct bt_hci_cp_mesh_advertise_cancel {
+	uint8_t      adv_slot;
+} __packed;
+struct bt_hci_rp_mesh_advertise_cancel {
+	uint8_t      status;
+	uint8_t      opcode;
+	uint8_t      adv_slot;
+} __packed;
+
+#define BT_HCI_OC_MESH_SET_SCANNING            0x05
+struct bt_hci_cp_mesh_set_scanning {
+	uint8_t      enable;
+	uint8_t      ch_map;
+	uint8_t      scan_filter;
+} __packed;
+struct bt_hci_rp_mesh_set_scanning {
+	uint8_t      status;
+	uint8_t      opcode;
+} __packed;
+
+/* Events */
+struct bt_hci_evt_mesh {
+	uint8_t  prefix;
+	uint8_t  subevent;
+} __packed;
+
+#define BT_HCI_EVT_MESH_ADV_COMPLETE           0x00
+struct bt_hci_evt_mesh_adv_complete {
+	uint8_t         adv_slot;
+} __packed;
+
+#define BT_HCI_EVT_MESH_SCANNING_REPORT        0x01
+struct bt_hci_evt_mesh_scan_report {
+	bt_addr_le_t addr;
+	uint8_t         chan;
+	int8_t         rssi;
+	uint32_t        instant;
+	uint8_t         data_len;
+	uint8_t         data[0];
+} __packed;
+struct bt_hci_evt_mesh_scanning_report {
+	uint8_t num_reports;
+	struct bt_hci_evt_mesh_scan_report reports[0];
+} __packed;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZEPHYR_INCLUDE_BLUETOOTH_HCI_VS_H_ */