/*
 * Copyright 2018 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#ifndef _INCLUDED_FROM_HCI_H_
#error "do not ever include this file anywhere"
#endif

#include <alloca.h>

/*
 * This generates simple SYNC functions for BT commands.
 * We need a lot of them, so we play with macros here.
 * It's either this, magic number mess, or hundreds of
 * functions. Deal with it.
 *
 *
 *
 * for all generated funcs this applies:
 *
 * RETURN:   status byte or negatives on error
 * NOTES:    sync
 *
 * WRITE funcs just return status value, the reset of the event is discarded. expects cmd complete event
 * READ funcs take "evt" param to save event to. expects cmd complete event
 * NOCMDPARAMS funcs do not have params. expects cmd complete event
 * W_STATUS - expects cmd status event
 */

#define HCI_SIMPLY_SYNC_CMD_W_STATUS(name, params, ogf, ocf)                                                         \
                                           static int hci##name##Sync params                                         \
                                           {                                                                         \
                                               struct hci##name cmdD;                                                \
                                               struct hci##name *cmd = &cmdD;                                        \
                                               const uint32_t cmdSz = sizeof(*cmd);                                  \
                                               struct hciEvtCmdStatus evtD;                                          \
                                               struct hciEvtCmdStatus *evt = &evtD;                                  \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = true;

#define HCI_SIMPLY_SYNC_WRITE(name, params, ogf, ocf)                                                                \
                                           static int hci##name##Sync params                                         \
                                           {                                                                         \
                                               struct hci##name cmdD;                                                \
                                               struct hci##name *cmd = &cmdD;                                        \
                                               const uint32_t cmdSz = sizeof(*cmd);                                  \
                                               struct hciCmpl##name evtD;                                            \
                                               struct hciCmpl##name *evt = &evtD;                                    \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = false;

#define HCI_SIMPLY_SYNC_WRITE_VAR_LEN(name, params, ogf, ocf, lenParam)                                              \
                                           static int hci##name##Sync params                                         \
                                           {                                                                         \
                                               struct hci##name *cmd;                                                \
                                               const uint32_t cmdSz = sizeof(*cmd) + lenParam;                       \
                                               struct hciCmpl##name evtD;                                            \
                                               struct hciCmpl##name *evt = &evtD;                                    \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = false;                                          \
                                               const uint8_t varLenWriteMarker = 1; /* allow COPY_IN_VAR_LEN_DATA */ \
                                               if (cmdSz > 255) {                                                    \
                                                   loge("attempt to call 0x%02X.%04X  with %ub of data\n",           \
                                                         _ogf, _ocf, (int)(lenParam + sizeof(struct hci##name)));    \
                                                   return -2;                                                        \
                                               }                                                                     \
                                               cmd = alloca(cmdSz);

#define HCI_SIMPLY_SYNC_WRITE_NOCMDPARAMS(name, ogf, ocf)                                                            \
                                           static int hci##name##Sync (void)                                         \
                                           {                                                                         \
                                               struct hci##name *cmd = NULL;                                         \
                                               const uint32_t cmdSz = 0;                                             \
                                               struct hciCmpl##name evtD;                                            \
                                               struct hciCmpl##name *evt = &evtD;                                    \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = false;

#define HCI_SIMPLY_SYNC_READ(name, params, ogf, ocf)                                                                 \
                                           static int hci##name##Sync params                                         \
                                           {                                                                         \
                                               struct hci##name cmdD;                                                \
                                               struct hci##name *cmd = &cmdD;                                        \
                                               const uint32_t cmdSz = sizeof(*cmd);                                  \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = false;

#define HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(name, params, ogf, ocf)                                                     \
                                           static int hci##name##Sync params                                         \
                                           {                                                                         \
                                               struct hci##name *cmd = NULL;                                         \
                                               const uint32_t cmdSz = 0;                                             \
                                               const uint8_t _ogf = ogf;                                             \
                                               const uint16_t _ocf = ocf;                                            \
                                               const bool want_sta = false;

#define REQUIRE_VERSION(_v)                    if (mBtVer < _v) {                                                    \
                                                   loge("attempt to call 0x%02X.%04X on v%u\n", _ogf, _ocf, mBtVer); \
                                                   return -2;                                                        \
                                               }

#define REQUIRE_FEATURE(_page, _v)             if (!(mLocalFtrs[_page] & _v)) {                                       \
                                                   loge("attempt to call 0x%02X.%04X w/o feature\n", _ogf, _ocf);    \
                                                   return -2;                                                        \
                                               }

#define REQUIRE_LE_FEATURE(_v)                 if (!(mLocalLeFtrs & _v)) {                                           \
                                                   loge("attempt to call 0x%02X.%04X w/o feature\n", _ogf, _ocf);    \
                                                   return -2;                                                        \
                                               }


#define HCI_COPY_IN_U64(name)                  utilSetLE64(&cmd->name, name);
#define HCI_COPY_IN_U32(name)                  utilSetLE32(&cmd->name, name);
#define HCI_COPY_IN_U24(name)                  utilSetLE24(&cmd->name, name);
#define HCI_COPY_IN_U16(name)                  utilSetLE16(&cmd->name, name);
#define HCI_COPY_IN_U8(name)                   utilSetLE8(&cmd->name, name);
#define HCI_COPY_IN_BOOL(name)                 utilSetLE8(&cmd->name, name ? 1 : 0);
#define HCI_COPY_IN_MAC(name)                  memcpy(cmd->name, name, sizeof(cmd->name));
#define HCI_COPY_IN_VAR_LEN_DATA(name,len)     if (varLenWriteMarker)                                                \
                                                   memcpy(cmd->name, name, len);  //only allowed in HCI_SIMPLY_SYNC_WRITE_VAR_LEN
#define HCI_COPY_IN_DATA(name,len)             if (len > sizeof(cmd->name)) {                                        \
                                                   logw("Truncating "#name" to %ub\n",(int)sizeof(cmd->name));       \
                                                   len = sizeof(cmd->name);                                          \
                                               }                                                                     \
                                               memcpy(cmd->name, name, len);

#define HCI_SIMPLY_SYNC_END                    if (!want_sta && !hciCmdSubmitSimpleWithCompleteSync(_ogf, _ocf, cmd, \
                                                      cmdSz, evt, sizeof(*evt)))                                     \
                                                   return -1;                                                        \
                                               if (want_sta && !hciCmdSubmitSimpleWithStatusSync(_ogf, _ocf, cmd,    \
                                                      cmdSz, (struct hciEvtCmdStatus*)evt))                          \
                                                   return -1;                                                        \
                                               return (unsigned)utilGetLE8(&evt->status);                            \
                                           }

/*
 * FUNCTION: hciLeSetExtendedAdvParamsSync
 * USE:      set extended adv params (BT5)
 * PARAMS:   advSetHandle - the adv set handle
 *           advSetProperties - adv type to use (bitfield)
 *           primaryAdvIntervalMin - minimum adv interval (in units of 0.625ms), actually a uint24_t
 *           primaryAdvIntervalMax - maximum adv interval (in units of 0.625ms), actually a uint24_t
 *           primaryAdvChannelMap - channels to use: bitmask of HCI_ADV_CHAN_MAP_USE_*
 *           ownAddrType - own addr type: HCI_ADV_OWN_ADDR_TYPE_*
 *           peerAddrType - set to 1 if direct adv to random addr, else ignored
 *           peerMac - if direct adv, the mac address of target, else ignored
 *           filterPolicy - filter policy: HCI_ADV_FILTER_POL_*
 *           txPower - requested adv transmit power in dBm
 *           primaryAdvPhy - PHY to use for primary adv, one of HCI_LE_PHY_* (CANNOT be HCI_LE_PHY_2M)
 *           secondaryAdvMaxSkip - how many adv can be skipped for secondary adv
 *           secondaryAdvPhy - PHY to use for secondary adv one of HCI_LE_PHY_*
 *           advSid - the SID value to send in adv packets (0x00..0x0f)
 *           enableScanRequestNotif - do we want an event when we are scanned?
 *           evt - the event structure to stash the chip's relpy in
 */
HCI_SIMPLY_SYNC_READ(LeSetExtendedAdvParams, (uint8_t advSetHandle, uint16_t advSetProperties, uint32_t primaryAdvIntervalMin, uint32_t primaryAdvIntervalMax, uint8_t primaryAdvChannelMap, uint8_t ownAddrType, uint8_t peerAddrType, const uint8_t *peerMac, uint8_t filterPolicy, int8_t txPower, uint8_t primaryAdvPhy, uint8_t secondaryAdvMaxSkip, uint8_t secondaryAdvPhy, uint8_t advSid, bool enableScanRequestNotif, struct hciCmplLeSetExtendedAdvParams *evt), HCI_OGF_LE, HCI_CMD_LE_Set_Extended_Adv_Params )
    REQUIRE_VERSION(HCI_VERSION_5_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U8(advSetHandle);
    HCI_COPY_IN_U16(advSetProperties);
    HCI_COPY_IN_U24(primaryAdvIntervalMin);
    HCI_COPY_IN_U24(primaryAdvIntervalMax);
    HCI_COPY_IN_U8(primaryAdvChannelMap);
    HCI_COPY_IN_U8(ownAddrType);
    HCI_COPY_IN_U8(peerAddrType);
    HCI_COPY_IN_MAC(peerMac);
    HCI_COPY_IN_U8(filterPolicy);
    HCI_COPY_IN_U8(txPower);
    HCI_COPY_IN_U8(primaryAdvPhy);
    HCI_COPY_IN_U8(secondaryAdvMaxSkip);
    HCI_COPY_IN_U8(secondaryAdvPhy);
    HCI_COPY_IN_U8(advSid);
    HCI_COPY_IN_BOOL(enableScanRequestNotif)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetExtendedAdvDataSync
 * USE:      set extended adv data (BT5)
 * PARAMS:   advSetHandle - the adv set handle
 *           operation - one of HCI_EXTD_ADV_DATA_OP_*
 *           fragmentPreference - may the chip choose to fragment data over the air? (merely a suggestion)
 *           advDataLen - number of bytes that follow
 *           advData - the data
 */
HCI_SIMPLY_SYNC_WRITE_VAR_LEN(LeSetExtendedAdvData, (uint8_t advSetHandle, uint8_t operation, bool fragmentPreference, uint8_t advDataLen, const uint8_t *advData), HCI_OGF_LE, HCI_CMD_LE_Set_Extended_Adv_Data, advDataLen)
    REQUIRE_VERSION(HCI_VERSION_5_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U8(advSetHandle);
    HCI_COPY_IN_U8(operation);
    HCI_COPY_IN_BOOL(fragmentPreference);
    HCI_COPY_IN_U8(advDataLen);
    HCI_COPY_IN_VAR_LEN_DATA(advData, advDataLen);
HCI_SIMPLY_SYNC_END


/*
 * FUNCTION: hciLeSetExtendedScanRspDataSync
 * USE:      set extended adv scan rsp data (BT5)
 * PARAMS:   advSetHandle - the adv set handle
 *           operation - one of HCI_EXTD_ADV_DATA_OP_*, but HCI_EXTD_ADV_DATA_OP_UNCHANGED is not allowed
 *           fragmentPreference - may the chip choose to fragment data over the air? (merely a suggestion)
 *           scanRspDataLen - number of bytes that follow
 *           scanRspData - the data
 */
HCI_SIMPLY_SYNC_WRITE_VAR_LEN(LeSetExtendedScanRspData, (uint8_t advSetHandle, uint8_t operation, bool fragmentPreference, uint8_t scanRspDataLen, const uint8_t *scanRspData), HCI_OGF_LE, HCI_CMD_LE_Set_Extended_Scan_Rsp_Data, scanRspDataLen)
    REQUIRE_VERSION(HCI_VERSION_5_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U8(advSetHandle);
    HCI_COPY_IN_U8(operation);
    HCI_COPY_IN_BOOL(fragmentPreference);
    HCI_COPY_IN_U8(scanRspDataLen);
    HCI_COPY_IN_VAR_LEN_DATA(scanRspData, scanRspDataLen);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetExtendedAdvEnableSync
 * USE:      set extended adv on or off (BT5)
 * PARAMS:   enable - enable or disable this set?
 *           advSetHandle - the adv set handle
 *           duration - adv duration in units of 10ms, or 0 for forever
 *           maxExtdAdvEvts - max number of extended adv events, or 0 for forever
 * NOTES:    this is a limited version of what this command can do, but
 *           it is more convenient - this gives us control over just one
 *           set at a time, whcih is OK for us.
 */
HCI_SIMPLY_SYNC_WRITE(LeSetExtendedAdvEnable, (bool enable, uint8_t advSetHandle, uint16_t duration, uint8_t maxExtdAdvEvts), HCI_OGF_LE, HCI_CMD_LE_Set_Extended_Adv_Enable)
    REQUIRE_VERSION(HCI_VERSION_5_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_BOOL(enable);
    utilSetLE8(&cmd->numSets, 1);
    utilSetLE8(&cmd->sets[0].advSetHandle, advSetHandle);
    utilSetLE16(&cmd->sets[0].duration, duration);
    utilSetLE16(&cmd->sets[0].maxExtdAdvEvts, maxExtdAdvEvts);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeLtkRequestReplySync
 * USE:      give the chip the for a given connection
 * PARAMS:   conn - the connection id
 *           LTK - the key to use
 */
HCI_SIMPLY_SYNC_WRITE(LeLtkRequestReply, (uint16_t conn, const uint8_t *LTK), HCI_OGF_LE, HCI_CMD_LE_LTK_Request_Reply)
    uint8_t ltkLen = HCI_LE_KEY_LEN;
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    REQUIRE_LE_FEATURE(HCI_LE_FTR_ENCRYPTION)
    HCI_COPY_IN_U16(conn)
    HCI_COPY_IN_DATA(LTK, ltkLen);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeLtkRequestNegativeReplySync
 * USE:      tell the chip we have no key to give for a given connection
 * PARAMS:   conn - the connection id
 */
HCI_SIMPLY_SYNC_WRITE(LeLtkRequestNegativeReply, (uint16_t conn), HCI_OGF_LE, HCI_CMD_LE_LTK_Request_Negative_Reply)
    uint8_t ltkLen = HCI_LE_KEY_LEN;
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    REQUIRE_LE_FEATURE(HCI_LE_FTR_ENCRYPTION)
    HCI_COPY_IN_U16(conn)
HCI_SIMPLY_SYNC_END


/*
 * FUNCTION: hciLeReadAdvChannelTxPowerSync
 * USE:      read default adv channel tx power
 * PARAMS:   evt - the returned event
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(LeReadAdvChannelTxPower, (struct hciCmplLeReadAdvChannelTxPower *evt), HCI_OGF_LE, HCI_CMD_LE_Read_Adv_Channel_TX_Power)
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetAdvParamsSync
 * USE:      set adv params
 * PARAMS:   advIntervalMin - minimum adv interval (in units of 0.625ms)
 *           advIntervalMax - maximum adv interval (in units of 0.625ms)
 *           advType - adv type: HCI_ADV_TYPE_ADV_*
 *           ownAddressType - own addr type: HCI_ADV_OWN_ADDR_TYPE_*
 *           directRandomAddress - set to 1 if direct adv to random addr, else ignored
 *           directAddr - if direct adv, the mac address of target, else ignored
 *           advChannelMap - channels to use: bitmask of HCI_ADV_CHAN_MAP_USE_*
 *           advFilterPolicy - filter policy: HCI_ADV_FILTER_POL_*
 */
HCI_SIMPLY_SYNC_WRITE(LeSetAdvParams, (uint16_t advIntervalMin, uint16_t advIntervalMax, uint8_t advType, uint8_t ownAddressType, uint8_t directRandomAddress, const uint8_t *directAddr, uint8_t advChannelMap, uint8_t advFilterPolicy), HCI_OGF_LE, HCI_CMD_LE_Set_Adv_Params)
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U16(advIntervalMin);
    HCI_COPY_IN_U16(advIntervalMax);
    HCI_COPY_IN_U8(advType);
    HCI_COPY_IN_U8(ownAddressType);
    HCI_COPY_IN_U8(directRandomAddress);
    HCI_COPY_IN_MAC(directAddr);
    HCI_COPY_IN_U8(advChannelMap);
    HCI_COPY_IN_U8(advFilterPolicy);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetRandomAddressSync
 * USE:      set random address
 * PARAMS:   mac - the address to use
 */
HCI_SIMPLY_SYNC_WRITE(LeSetRandomAddress, (uint8_t *mac), HCI_OGF_LE, HCI_CMD_LE_Set_Random_Address)
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_MAC(mac);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeMultiAdvSetAdvParamsSync
 * USE:      set adv params for an advertising set
 * PARAMS:   advIntervalMin - minimum adv interval (in units of 0.625ms)
 *           advIntervalMax - maximum adv interval (in units of 0.625ms)
 *           advType - adv type: HCI_ADV_TYPE_ADV_*
 *           ownAddressType - own addr type: HCI_ADV_OWN_ADDR_TYPE_*
 *           directRandomAddress - set to 1 if direct adv to random addr, else ignored
 *           directAddr - if direct adv, the mac address of target, else ignored
 *           advChannelMap - channels to use: bitmask of HCI_ADV_CHAN_MAP_USE_*
 *           advFilterPolicy - filter policy: HCI_ADV_FILTER_POL_*
 *           advInstanceIdx - the instance number
 *           txPower - the desired TX power  (actually an int8_t)
 * NOTES:    android vendor BT 4.0 extension - additional tests neede to make sure it is usable
 */
HCI_SIMPLY_SYNC_WRITE(VendorLeMultiAdvSetAdvParams, (uint16_t advIntervalMin, uint16_t advIntervalMax, uint8_t advType, uint8_t ownAddressType, const uint8_t *ownAddress, uint8_t directRandomAddress, const uint8_t *directAddr, uint8_t advChannelMap, uint8_t advFilterPolicy, uint8_t advInstanceIdx, uint8_t txPower), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Params)
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    cmd->subOcf = HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Params_sub_ocf;
    HCI_COPY_IN_U16(advIntervalMin);
    HCI_COPY_IN_U16(advIntervalMax);
    HCI_COPY_IN_U8(advType);
    HCI_COPY_IN_U8(ownAddressType);
    HCI_COPY_IN_MAC(ownAddress);
    HCI_COPY_IN_U8(directRandomAddress);
    HCI_COPY_IN_MAC(directAddr);
    HCI_COPY_IN_U8(advChannelMap);
    HCI_COPY_IN_U8(advFilterPolicy);
    HCI_COPY_IN_U8(advInstanceIdx);
    HCI_COPY_IN_U8(txPower);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeMultiAdvSetAdvDataSync
 * USE:      Set advertising data for an advertising set
 * PARAMS:   advDataLen - the length of the data
 *           advData - the data itself
 *           advInstanceIdx - the instance number
 * NOTES:    android vendor BT 4.0 extension - additional tests neede to make sure it is usable
 */
HCI_SIMPLY_SYNC_WRITE(VendorLeMultiAdvSetAdvData, (uint8_t advDataLen, const uint8_t *advData, uint8_t advInstanceIdx), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Data)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    cmd->subOcf = HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Data_sub_ocf;
    HCI_COPY_IN_U8(advDataLen);
    HCI_COPY_IN_DATA(advData, advDataLen);
    HCI_COPY_IN_U8(advInstanceIdx);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeMultiAdvSetScanRspDataSync
 * USE:      Set scan response data for an advertising set
 * PARAMS:   scanRspDataLen - the length of the data
 *           scanRspData - the data itself
 *           advInstanceIdx - the instance number
 * NOTES:    android vendor BT 4.0 extension - additional tests neede to make sure it is usable
 */
HCI_SIMPLY_SYNC_WRITE(VendorLeMultiAdvSetScanRspData, (uint8_t scanRspDataLen, const uint8_t *scanRspData, uint8_t advInstanceIdx), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Multi_Adv_Set_Scan_Rsp_Data)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    cmd->subOcf = HCI_CMD_Vendor_LE_Multi_Adv_Set_Scan_Rsp_Data_sub_ocf;
    HCI_COPY_IN_U8(scanRspDataLen);
    HCI_COPY_IN_DATA(scanRspData, scanRspDataLen);
    HCI_COPY_IN_U8(advInstanceIdx);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeMultiAdvSetRandomAddrSync
 * USE:      set random address
 * PARAMS:   mac - the address to use
 *           advInstanceIdx - the instance number
 * NOTES:    android vendor BT 4.0 extension - additional tests neede to make sure it is usable
 */
HCI_SIMPLY_SYNC_WRITE(VendorLeMultiAdvSetRandomAddr, (uint8_t *mac, uint8_t advInstanceIdx), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Multi_Adv_Set_Random_Addr)
    REQUIRE_VERSION(HCI_VERSION_4_0);
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    cmd->subOcf = HCI_CMD_Vendor_LE_Multi_Adv_Set_Random_Addr_sub_ocf;
    HCI_COPY_IN_MAC(mac);
    HCI_COPY_IN_U8(advInstanceIdx);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeMultiAdvSetAdvEnableSync
 * USE:      Enable/Disable an advertising set
 * PARAMS:   enabled - on?
 *           advInstanceIdx - the instance number
 * NOTES:    android vendor BT 4.0 extension - additional tests neede to make sure it is usable
 */
HCI_SIMPLY_SYNC_WRITE(VendorLeMultiAdvSetAdvEnable, (bool enabled, uint8_t advInstanceIdx), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Enable)
    cmd->subOcf = HCI_CMD_Vendor_LE_Multi_Adv_Set_Adv_Enable_sub_ocf;
    HCI_COPY_IN_BOOL(enabled);
    HCI_COPY_IN_U8(advInstanceIdx);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciSetEventMaskSync
 * USE:      Set event mask
 * PARAMS:   mask - the wanted mask
 */
HCI_SIMPLY_SYNC_WRITE(SetEventMask, (uint64_t mask), HCI_OGF_Controller_and_Baseband, HCI_CMD_Set_Event_Mask)
    HCI_COPY_IN_U64(mask)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciSetEventMaskPage2Sync
 * USE:      Set event mask page 2
 * PARAMS:   mask - the wanted mask
 */
HCI_SIMPLY_SYNC_WRITE(SetEventMaskPage2, (uint64_t mask), HCI_OGF_Controller_and_Baseband, HCI_CMD_Set_Event_Mask_Page_2)
    REQUIRE_VERSION(HCI_VERSION_3_0)
    HCI_COPY_IN_U64(mask)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWritePinTypeSync
 * USE:      Set whether we have a fixed or variable PIN
 * PARAMS:   isFixed - is the pin fixed?
 */
HCI_SIMPLY_SYNC_WRITE(WritePinType, (bool isFixed), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_PIN_Type)
    HCI_COPY_IN_BOOL(isFixed)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWritePageTimeoutSync
 * USE:      Set how long we try to connect at link layer
 * PARAMS:   timeout - the timeout in unit of 0.625ms
 */
HCI_SIMPLY_SYNC_WRITE(WritePageTimeout, (uint16_t timeout), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Page_Timeout)
    HCI_COPY_IN_U16(timeout)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteSyncFlowCtrlEnableSync
 * USE:      Set whether we get command complete packets for SCO data
 * PARAMS:   syncFlowCtrlOn - set if we will get those packets, false else
 */
HCI_SIMPLY_SYNC_WRITE(WriteSyncFlowCtrlEnable, (bool syncFlowCtrlOn), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_SCO_Flow_Control_Enable)
    HCI_COPY_IN_BOOL(syncFlowCtrlOn)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteConnAcceptTimeoutSync
 * USE:      Set how long after a connection request comes in taht we auto-reject it
 * PARAMS:   timeout - timeout in units of 0.625ms
 */
HCI_SIMPLY_SYNC_WRITE(WriteConnAcceptTimeout, (uint16_t timeout), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Connection_Accept_Timeout)
    HCI_COPY_IN_U16(timeout)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteInquiryModeSync
 * USE:      Set what kind of inquiry result we want
 * PARAMS:   inqMode - the result format (INQ_MODE_*)
 */
HCI_SIMPLY_SYNC_WRITE(WriteInquiryMode, (uint8_t inqMode), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Inquiry_Mode)
    REQUIRE_VERSION(HCI_VERSION_1_2)
    HCI_COPY_IN_U8(inqMode)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteSimplePairingModeSync
 * USE:      Enable/disable SSP
 * PARAMS:   sspOn - use ssp?
 */
HCI_SIMPLY_SYNC_WRITE(WriteSimplePairingMode, (bool useSsp), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Simple_Pairing_Mode)
    REQUIRE_VERSION(HCI_VERSION_2_1)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_SSP)
    HCI_COPY_IN_BOOL(useSsp)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteLeHostSupportedSync
 * USE:      Enable/disable LE
 * PARAMS:   leSupportedHost - does host support LE?
 *           simultaneousLeHost - does host support simultaneous LE/EDR to same device
 */
HCI_SIMPLY_SYNC_WRITE(WriteLeHostSupported, (uint8_t leSupportedHost, uint8_t simultaneousLeHost), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_LE_Host_Supported)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER)

    if (simultaneousLeHost) {
        REQUIRE_FEATURE(0, HCI_LMP_FTR_SIMUL_LE_EDR_CAPABLE_CONTROLLER)
    }

    HCI_COPY_IN_BOOL(leSupportedHost)
    HCI_COPY_IN_BOOL(simultaneousLeHost)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWritePageScanActivitySync
 * USE:      Set connectivity settings (page scan)
 * PARAMS:   scanInterval - the scan interval
 *           scanWindow - the scan window
 */
HCI_SIMPLY_SYNC_WRITE(WritePageScanActivity, (uint16_t scanInterval, uint16_t scanWindow), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Page_Scan_Activity)
    HCI_COPY_IN_U16(scanInterval)
    HCI_COPY_IN_U16(scanWindow)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciWriteInquiryScanActivitySync
 * USE:      Set discoverability settings (inquiry scan)
 * PARAMS:   scanInterval - the scan interval
 *           scanWindow - the scan window
 */
HCI_SIMPLY_SYNC_WRITE(WriteInquiryScanActivity, (uint16_t scanInterval, uint16_t scanWindow), HCI_OGF_Controller_and_Baseband, HCI_CMD_Write_Inquiry_Scan_Activity)
    HCI_COPY_IN_U16(scanInterval)
    HCI_COPY_IN_U16(scanWindow)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciReadLocalVersionSync
 * USE:      read local version
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(ReadLocalVersion, (struct hciCmplReadLocalVersion *evt), HCI_OGF_Informational, HCI_CMD_Read_Local_Version_Information)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciReadLocalSupportedFeaturesSync
 * USE:      read local supported features
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(ReadLocalSupportedFeatures, (struct hciCmplReadLocalSupportedFeatures *evt), HCI_OGF_Informational, HCI_CMD_Read_Local_Supported_Features)
HCI_SIMPLY_SYNC_END


/*
 * FUNCTION: hciReadLocalExtendedFeaturesSync
 * USE:      read local extended features
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ(ReadLocalExtendedFeatures, (uint8_t page, struct hciCmplReadLocalExtendedFeatures *evt), HCI_OGF_Informational, HCI_CMD_Read_Local_Extended_Features)
    REQUIRE_VERSION(HCI_VERSION_2_1)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_EXTENDED_FEATURES)
    HCI_COPY_IN_U8(page)
HCI_SIMPLY_SYNC_END


/*
 * FUNCTION: hciReadBufferSizeSync
 * USE:      read local EDR buffer sizes
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(ReadBufferSize, (struct hciCmplReadBufferSize *evt), HCI_OGF_Informational, HCI_CMD_Read_Buffer_Size)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeReadBufferSizeSync
 * USE:      read local LE buffer sizes
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(LeReadBufferSize, (struct hciCmplLeReadBufferSize *evt), HCI_OGF_LE, HCI_CMD_LE_Read_Buffer_Size)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciReadBdAddrSync
 * USE:      read local MAC Address
 * PARAMS:   evt - event to return
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(ReadBdAddr, (struct hciCmplReadBdAddr *evt), HCI_OGF_Informational, HCI_CMD_Read_BD_ADDR)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciInquiryCancelSync
 * USE:      Cancel inquiry
 * PARAMS:   NONE
 */
HCI_SIMPLY_SYNC_WRITE_NOCMDPARAMS(InquiryCancel, HCI_OGF_Link_Control, HCI_CMD_Inquiry_Cancel)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetEventMaskSync
 * USE:      Set LE event mask
 * PARAMS:   events - the wanted event mask
 */
HCI_SIMPLY_SYNC_WRITE(LeSetEventMask, (uint64_t events), HCI_OGF_LE, HCI_CMD_LE_Set_Event_Mask)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U64(events)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetScanEnableSync
 * USE:      Enable/disable LE scan
 * PARAMS:   scanOn - scan on/off
 *           filterDuplicates - this rarely works, do not use
 */
HCI_SIMPLY_SYNC_WRITE(LeSetScanEnable, (bool scanOn, bool filterDuplicates), HCI_OGF_LE, HCI_CMD_LE_Set_Scan_Enable)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_BOOL(scanOn)
    HCI_COPY_IN_BOOL(filterDuplicates)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetScanParamsSync
 * USE:      Set LE scan parameters
 * PARAMS:   activeScan - as per spec
 *           scanInterval - as per spec
 *           scanWindow - as per spec
 *           useOwnRandomAddr - as per spec
 *           onlyWhitelist - as per spec
 */
HCI_SIMPLY_SYNC_WRITE(LeSetScanParams, (uint8_t activeScan, uint16_t scanInterval, uint16_t scanWindow, bool useOwnRandomAddr, bool onlyWhitelist), HCI_OGF_LE, HCI_CMD_LE_Set_Scan_Parameters)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U16(activeScan);
    HCI_COPY_IN_U16(scanInterval);
    HCI_COPY_IN_U16(scanWindow);
    HCI_COPY_IN_BOOL(useOwnRandomAddr);
    HCI_COPY_IN_BOOL(onlyWhitelist);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeReadNumberOfSupportedAdvertisingSetsSync
 * USE:      Read num adv sets we support
 * PARAMS:   None
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(LeReadNumberOfSupportedAdvertisingSets, (struct hciCmplLeReadNumSupportedAdvSets* evt), HCI_OGF_LE, HCI_CMD_LE_Read_Num_Supported_Adv_Sets)
    REQUIRE_VERSION(HCI_VERSION_5_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciVendorLeGetVendorCapabilitiesSync
 * USE:      Read android-vendor supported chip info
 * PARAMS:   None
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(VendorLeGetVendorCapabilities, (struct hciCmplVendorLeGetVendorCapabilities* evt), HCI_OGF_Vendor, HCI_CMD_Vendor_LE_Get_Vendor_Capabilities)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeReadLocalSupportedFeaturesSync
 * USE:      Read suported LE features locally
 * PARAMS:   *evt = the return event
 */
HCI_SIMPLY_SYNC_READ_NOCMDPARAMS(LeReadLocalSupportedFeatures, (struct hciCmplLeReadLocalSupportedFeatures* evt), HCI_OGF_LE, HCI_CMD_LE_Read_Local_Supported_Features)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetAdvEnableSync
 * USE:      Enable or disable advertising
 * PARAMS:   advOn - is advertising on?
 */
HCI_SIMPLY_SYNC_WRITE(LeSetAdvEnable, (bool advOn), HCI_OGF_LE, HCI_CMD_LE_Set_Advertise_Enable)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_BOOL(advOn);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetAdvDataSync
 * USE:      Set advertising data
 * PARAMS:   advDataLen - the length of the data
 *           advData - the data itself
 */
HCI_SIMPLY_SYNC_WRITE(LeSetAdvData, (uint8_t advDataLen, const uint8_t *advData), HCI_OGF_LE, HCI_CMD_LE_Set_Advertising_Data)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U8(advDataLen);
    HCI_COPY_IN_DATA(advData, advDataLen);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeSetScanResponseDataSync
 * USE:      Set scan response data
 * PARAMS:   scanRspDataLen - the length of the data
 *           scanRspData - the data itself
 */
HCI_SIMPLY_SYNC_WRITE(LeSetScanResponseData, (uint8_t scanRspDataLen, const uint8_t *scanRspData), HCI_OGF_LE, HCI_CMD_LE_Set_Scan_Response_Data)
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER);
    HCI_COPY_IN_U8(scanRspDataLen);
    HCI_COPY_IN_DATA(scanRspData, scanRspDataLen);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciRemoteNameRequestCancelSync
 * USE:      Cancel a remote name request
 * PARAMS:   mac - the mac
 */
HCI_SIMPLY_SYNC_WRITE(RemoteNameRequestCancel, (const uint8_t *mac), HCI_OGF_Link_Control, HCI_CMD_Remote_Name_Request_Cancel)
    HCI_COPY_IN_MAC(mac);
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciInquirySync
 * USE:      Enable EDR scan
 * PARAMS:   lap - the lap to use
 *           inqLen - how long for (max is 0x30 -> 61.44 sec)
 *           numResp - max responses (0 = unlimited)
 */
HCI_SIMPLY_SYNC_CMD_W_STATUS(Inquiry, (uint32_t lap, uint8_t inqLen, uint8_t numResp), HCI_OGF_Link_Control, HCI_CMD_Inquiry)
    HCI_COPY_IN_U24(lap)
    HCI_COPY_IN_U8(inqLen)
    HCI_COPY_IN_U8(numResp)
HCI_SIMPLY_SYNC_END

/*
 * FUNCTION: hciLeStartEncryption
 * USE:      Encrypt the connection using the given parameters
 * PARAMS:   conn - connection handle
 *           rand - random value
 *           diversifier - encrypted diversifier
 *           LTK - 16 bytes long term key
 */
HCI_SIMPLY_SYNC_CMD_W_STATUS(LeStartEncryption, (uint16_t conn, uint64_t rand, uint16_t diversifier, const uint8_t *LTK), HCI_OGF_LE, HCI_CMD_LE_Start_Encryption)
    uint8_t ltkLen = HCI_LE_KEY_LEN;
    REQUIRE_VERSION(HCI_VERSION_4_0)
    REQUIRE_FEATURE(0, HCI_LMP_FTR_LE_SUPPORTED_CONTROLLER)
    REQUIRE_LE_FEATURE(HCI_LE_FTR_ENCRYPTION)
    HCI_COPY_IN_U16(conn)
    HCI_COPY_IN_U64(rand)
    HCI_COPY_IN_U16(diversifier)
    HCI_COPY_IN_DATA(LTK, ltkLen);
HCI_SIMPLY_SYNC_END