Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 762825a4 authored by Myles Watson's avatar Myles Watson
Browse files

Remove unused btsnd_hcic_ble commands 

Bug: 286460419
Test: mma -j32
Change-Id: I11d0188aa94c4d801f5adcf626ad030e247144c9
parent c4f0725d

system/stack/hcic/hciblecmds.cc

+0 −249
Original line number Diff line number Diff line
@@ -110,34 +110,6 @@ 
#define HCIC_PARAM_SIZE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMS 8

#define HCIC_PARAM_SIZE_SET_DEFAULT_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMS 8



void btsnd_hcic_ble_set_local_used_feat(uint8_t feat_set[8]) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_USED_FEAT_CMD;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_WRITE_LOCAL_SPT_FEAT);

  ARRAY_TO_STREAM(pp, feat_set, HCIC_PARAM_SIZE_SET_USED_FEAT_CMD);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_set_random_addr(const RawAddress& random_bda) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_WRITE_RANDOM_ADDR);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD);



  BDADDR_TO_STREAM(pp, random_bda);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_write_adv_params(uint16_t adv_int_min, uint16_t adv_int_max,

                                     uint8_t adv_type,

                                     tBLE_ADDR_TYPE addr_type_own,
@@ -200,29 +172,6 @@ void btsnd_hcic_ble_set_adv_data(uint8_t data_len, uint8_t* p_data) { 
  }

  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}

void btsnd_hcic_ble_set_scan_rsp_data(uint8_t data_len, uint8_t* p_scan_rsp) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_WRITE_SCAN_RSP_DATA);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1);



  memset(pp, 0, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP);



  if (p_scan_rsp != NULL && data_len > 0) {

    if (data_len > HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP)

      data_len = HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP;



    UINT8_TO_STREAM(pp, data_len);



    ARRAY_TO_STREAM(pp, p_scan_rsp, data_len);

  }



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_set_adv_enable(uint8_t adv_enable) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);
@@ -275,56 +224,6 @@ void btsnd_hcic_ble_set_scan_enable(uint8_t scan_enable, uint8_t duplicate) { 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



/* link layer connection management commands */

void btsnd_hcic_ble_create_ll_conn(uint16_t scan_int, uint16_t scan_win,

                                   uint8_t init_filter_policy,

                                   tBLE_ADDR_TYPE addr_type_peer,

                                   const RawAddress& bda_peer,

                                   tBLE_ADDR_TYPE addr_type_own,

                                   uint16_t conn_int_min, uint16_t conn_int_max,

                                   uint16_t conn_latency, uint16_t conn_timeout,

                                   uint16_t min_ce_len, uint16_t max_ce_len) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_CREATE_LL_CONN);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN);



  UINT16_TO_STREAM(pp, scan_int);

  UINT16_TO_STREAM(pp, scan_win);

  UINT8_TO_STREAM(pp, init_filter_policy);



  UINT8_TO_STREAM(pp, addr_type_peer);

  BDADDR_TO_STREAM(pp, bda_peer);

  UINT8_TO_STREAM(pp, addr_type_own);



  UINT16_TO_STREAM(pp, conn_int_min);

  UINT16_TO_STREAM(pp, conn_int_max);

  UINT16_TO_STREAM(pp, conn_latency);

  UINT16_TO_STREAM(pp, conn_timeout);



  UINT16_TO_STREAM(pp, min_ce_len);

  UINT16_TO_STREAM(pp, max_ce_len);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_create_conn_cancel(void) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_CREATE_CONN_CANCEL);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_upd_ll_conn_params(uint16_t handle, uint16_t conn_int_min,

                                       uint16_t conn_int_max,

                                       uint16_t conn_latency,
@@ -352,37 +251,6 @@ void btsnd_hcic_ble_upd_ll_conn_params(uint16_t handle, uint16_t conn_int_min, 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_set_host_chnl_class(

    uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE]) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_SET_HOST_CHNL_CLASS);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS);



  ARRAY_TO_STREAM(pp, chnl_map, HCIC_BLE_CHNL_MAP_SIZE);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_read_chnl_map(uint16_t handle) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CHNL_MAP;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_READ_CHNL_MAP);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_CHNL_MAP);



  UINT16_TO_STREAM(pp, handle);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_read_remote_feat(uint16_t handle) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);
@@ -507,19 +375,6 @@ void btsnd_hcic_ble_test_end(void) { 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_read_host_supported(void) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_READ_LE_HOST_SUPPORT);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_CMD);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_rc_param_req_reply(uint16_t handle, uint16_t conn_int_min,

                                       uint16_t conn_int_max,

                                       uint16_t conn_latency,
@@ -578,36 +433,6 @@ void btsnd_hcic_ble_read_resolvable_addr_peer(uint8_t addr_type_peer, 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_read_resolvable_addr_local(uint8_t addr_type_peer,

                                               const RawAddress& bda_peer) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_READ_RESOLVABLE_ADDR_LOCAL);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL);

  UINT8_TO_STREAM(pp, addr_type_peer);

  BDADDR_TO_STREAM(pp, bda_peer);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_set_addr_resolution_enable(uint8_t addr_resolution_enable) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_BLE_SET_ADDR_RESOLUTION_ENABLE);

  UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE);

  UINT8_TO_STREAM(pp, addr_resolution_enable);



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_set_rand_priv_addr_timeout(uint16_t rpa_timout) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);
@@ -728,61 +553,6 @@ void btsnd_hcic_ble_set_extended_scan_enable(uint8_t enable, 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_ble_ext_create_conn(uint8_t init_filter_policy,

                                    tBLE_ADDR_TYPE addr_type_own,

                                    tBLE_ADDR_TYPE addr_type_peer,

                                    const RawAddress& bda_peer,

                                    uint8_t initiating_phys,

                                    EXT_CONN_PHY_CFG* phy_cfg) {

  BT_HDR* p = (BT_HDR*)osi_malloc(HCI_CMD_BUF_SIZE);

  uint8_t* pp = (uint8_t*)(p + 1);



  int phy_cnt =

      std::bitset<std::numeric_limits<uint8_t>::digits>(initiating_phys)

          .count();



  /* param_len = initial_params + size_per_channel * num_of_channels */

  uint8_t param_len = 10 + (16 * phy_cnt);



  p->len = HCIC_PREAMBLE_SIZE + param_len;

  p->offset = 0;



  UINT16_TO_STREAM(pp, HCI_LE_EXTENDED_CREATE_CONNECTION);

  UINT8_TO_STREAM(pp, param_len);



  UINT8_TO_STREAM(pp, init_filter_policy);

  UINT8_TO_STREAM(pp, addr_type_own);

  UINT8_TO_STREAM(pp, addr_type_peer);

  BDADDR_TO_STREAM(pp, bda_peer);



  UINT8_TO_STREAM(pp, initiating_phys);



  for (int i = 0; i < phy_cnt; i++) {

    UINT16_TO_STREAM(pp, phy_cfg[i].scan_int);

    UINT16_TO_STREAM(pp, phy_cfg[i].scan_win);

    UINT16_TO_STREAM(pp, phy_cfg[i].conn_int_min);

    UINT16_TO_STREAM(pp, phy_cfg[i].conn_int_max);

    UINT16_TO_STREAM(pp, phy_cfg[i].conn_latency);

    UINT16_TO_STREAM(pp, phy_cfg[i].sup_timeout);

    UINT16_TO_STREAM(pp, phy_cfg[i].min_ce_len);

    UINT16_TO_STREAM(pp, phy_cfg[i].max_ce_len);

  }



  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_read_iso_tx_sync(

    uint16_t iso_handle, base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

  const int params_len = 2;

  uint8_t param[params_len];

  uint8_t* pp = param;



  UINT16_TO_STREAM(pp, iso_handle);



  btu_hcif_send_cmd_with_cb(FROM_HERE, HCI_LE_READ_ISO_TX_SYNC, param,

                            params_len, std::move(cb));

}



void btsnd_hcic_set_cig_params(

    uint8_t cig_id, uint32_t sdu_itv_mtos, uint32_t sdu_itv_stom, uint8_t sca,

    uint8_t packing, uint8_t framing, uint16_t max_trans_lat_stom,
@@ -940,18 +710,6 @@ void btsnd_hcic_term_big(uint8_t big_handle, uint8_t reason) { 
  btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

}



void btsnd_hcic_big_term_sync(uint8_t big_handle,

                              base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

  const int params_len = 1;

  uint8_t param[params_len];

  uint8_t* pp = param;



  UINT8_TO_STREAM(pp, big_handle);



  btu_hcif_send_cmd_with_cb(FROM_HERE, HCI_LE_BIG_TERM_SYNC, param, params_len,

                            std::move(cb));

}



void btsnd_hcic_setup_iso_data_path(

    uint16_t iso_handle, uint8_t data_path_dir, uint8_t data_path_id,

    uint8_t codec_id_format, uint16_t codec_id_company,
@@ -1083,13 +841,6 @@ void btsnd_hci_ble_clear_periodic_advertiser_list( 
      HCIC_PARAM_SIZE_CLEAR_PERIODIC_ADVERTISER_LIST, std::move(cb));

}



void btsnd_hci_ble_read_periodic_advertiser_list_size(

    base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

  btu_hcif_send_cmd_with_cb(

      FROM_HERE, HCI_BLE_READ_PERIODIC_ADVERTISER_LIST_SIZE, nullptr,

      HCIC_PARAM_SIZE_READ_PERIODIC_ADVERTISER_LIST_SIZE, std::move(cb));

}



void btsnd_hcic_ble_set_periodic_advertising_receive_enable(

    uint16_t sync_handle, bool enable,

    base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

system/stack/include/hcimsgs.h

+0 −46
Original line number Diff line number Diff line
@@ -305,8 +305,6 @@ void btsnd_hcic_vendor_spec_cmd(uint16_t opcode, uint8_t len, uint8_t* p_data, 
/* ULP HCI command */

void btsnd_hcic_ble_set_local_used_feat(uint8_t feat_set[8]);



void btsnd_hcic_ble_set_random_addr(const RawAddress& random_addr);



void btsnd_hcic_ble_write_adv_params(uint16_t adv_int_min, uint16_t adv_int_max,

                                     uint8_t adv_type,

                                     tBLE_ADDR_TYPE addr_type_own,
@@ -319,8 +317,6 @@ void btsnd_hcic_ble_read_adv_chnl_tx_power(void); 


void btsnd_hcic_ble_set_adv_data(uint8_t data_len, uint8_t* p_data);



void btsnd_hcic_ble_set_scan_rsp_data(uint8_t data_len, uint8_t* p_scan_rsp);



void btsnd_hcic_ble_set_adv_enable(uint8_t adv_enable);



void btsnd_hcic_ble_set_scan_params(uint8_t scan_type, uint16_t scan_int,
@@ -329,17 +325,6 @@ void btsnd_hcic_ble_set_scan_params(uint8_t scan_type, uint16_t scan_int, 


void btsnd_hcic_ble_set_scan_enable(uint8_t scan_enable, uint8_t duplicate);



void btsnd_hcic_ble_create_ll_conn(uint16_t scan_int, uint16_t scan_win,

                                   uint8_t init_filter_policy,

                                   tBLE_ADDR_TYPE addr_type_peer,

                                   const RawAddress& bda_peer,

                                   tBLE_ADDR_TYPE addr_type_own,

                                   uint16_t conn_int_min, uint16_t conn_int_max,

                                   uint16_t conn_latency, uint16_t conn_timeout,

                                   uint16_t min_ce_len, uint16_t max_ce_len);



void btsnd_hcic_ble_create_conn_cancel(void);



void btsnd_hcic_ble_read_acceptlist_size(void);



void btsnd_hcic_ble_upd_ll_conn_params(uint16_t handle, uint16_t conn_int_min,
@@ -348,11 +333,6 @@ void btsnd_hcic_ble_upd_ll_conn_params(uint16_t handle, uint16_t conn_int_min, 
                                       uint16_t conn_timeout, uint16_t min_len,

                                       uint16_t max_len);



void btsnd_hcic_ble_set_host_chnl_class(

    uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE]);



void btsnd_hcic_ble_read_chnl_map(uint16_t handle);



void btsnd_hcic_ble_read_remote_feat(uint16_t handle);



void btsnd_hcic_ble_rand(base::Callback<void(BT_OCTET8)> cb);
@@ -367,11 +347,6 @@ void btsnd_hcic_ble_ltk_req_neg_reply(uint16_t handle); 


void btsnd_hcic_ble_read_supported_states(void);



void btsnd_hcic_ble_write_host_supported(uint8_t le_host_spt,

                                         uint8_t simul_le_host_spt);



void btsnd_hcic_ble_read_host_supported(void);



void btsnd_hcic_ble_receiver_test(uint8_t rx_freq);



void btsnd_hcic_ble_transmitter_test(uint8_t tx_freq, uint8_t test_data_len,
@@ -417,21 +392,9 @@ struct EXT_CONN_PHY_CFG { 
  uint16_t max_ce_len;

};



void btsnd_hcic_ble_ext_create_conn(uint8_t init_filter_policy,

                                    uint8_t addr_type_own,

                                    uint8_t addr_type_peer,

                                    const RawAddress& bda_peer,

                                    uint8_t initiating_phys,

                                    EXT_CONN_PHY_CFG* phy_cfg);



void btsnd_hcic_ble_read_resolvable_addr_peer(uint8_t addr_type_peer,

                                              const RawAddress& bda_peer);



void btsnd_hcic_ble_read_resolvable_addr_local(uint8_t addr_type_peer,

                                               const RawAddress& bda_peer);



void btsnd_hcic_ble_set_addr_resolution_enable(uint8_t addr_resolution_enable);



void btsnd_hcic_ble_set_rand_priv_addr_timeout(uint16_t rpa_timout);



void btsnd_hcic_read_authenticated_payload_tout(uint16_t handle);
@@ -439,9 +402,6 @@ void btsnd_hcic_read_authenticated_payload_tout(uint16_t handle); 
void btsnd_hcic_write_authenticated_payload_tout(uint16_t handle,

                                                 uint16_t timeout);



void btsnd_hcic_read_iso_tx_sync(

    uint16_t iso_handle, base::OnceCallback<void(uint8_t*, uint16_t)> cb);



struct EXT_CIS_CFG {

  uint8_t cis_id;

  uint16_t max_sdu_size_mtos;
@@ -501,9 +461,6 @@ void btsnd_hcic_create_big(uint8_t big_handle, uint8_t adv_handle, 


void btsnd_hcic_term_big(uint8_t big_handle, uint8_t reason);



void btsnd_hcic_big_term_sync(uint8_t big_handle,

                              base::OnceCallback<void(uint8_t*, uint16_t)> cb);



void btsnd_hcic_setup_iso_data_path(

    uint16_t iso_handle, uint8_t data_path_dir, uint8_t data_path_id,

    uint8_t codec_id_format, uint16_t codec_id_company,
@@ -540,9 +497,6 @@ void btsnd_hci_ble_remove_device_from_periodic_advertiser_list( 
void btsnd_hci_ble_clear_periodic_advertiser_list(

    base::OnceCallback<void(uint8_t*, uint16_t)> cb);



void btsnd_hci_ble_read_periodic_advertiser_list_size(

    base::OnceCallback<void(uint8_t*, uint16_t)> cb);



void btsnd_hcic_ble_set_periodic_advertising_receive_enable(

    uint16_t sync_handle, bool enable,

    base::OnceCallback<void(uint8_t*, uint16_t)> cb);

system/test/mock/mock_stack_hcic_hciblecmds.cc

+0 −103

File changed.

Preview size limit exceeded, changes collapsed.

system/test/mock/mock_stack_hcic_hciblecmds.h

+0 −191
Original line number Diff line number Diff line
@@ -87,19 +87,6 @@ struct btsnd_hci_ble_clear_periodic_advertiser_list { 
extern struct btsnd_hci_ble_clear_periodic_advertiser_list

    btsnd_hci_ble_clear_periodic_advertiser_list;



// Name: btsnd_hci_ble_read_periodic_advertiser_list_size

// Params: base::OnceCallback<void(uint8_t*, uint16_t

// Return: void

struct btsnd_hci_ble_read_periodic_advertiser_list_size {

  std::function<void(base::OnceCallback<void(uint8_t*, uint16_t)>)> body{

      [](base::OnceCallback<void(uint8_t*, uint16_t)> cb) {}};

  void operator()(base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

    body(std::move(cb));

  };

};

extern struct btsnd_hci_ble_read_periodic_advertiser_list_size

    btsnd_hci_ble_read_periodic_advertiser_list_size;



// Name: btsnd_hci_ble_remove_device_from_periodic_advertiser_list

// Params: uint8_t adv_addr_type, const RawAddress& adv_addr, uint8_t adv_sid,

// base::OnceCallback<void(uint8_t*, uint16_t Return: void
@@ -127,20 +114,6 @@ struct btsnd_hcic_accept_cis_req { 
};

extern struct btsnd_hcic_accept_cis_req btsnd_hcic_accept_cis_req;



// Name: btsnd_hcic_big_term_sync

// Params: uint8_t big_handle, base::OnceCallback<void(uint8_t*, uint16_t

// Return: void

struct btsnd_hcic_big_term_sync {

  std::function<void(uint8_t, base::OnceCallback<void(uint8_t*, uint16_t)>)>

      body{[](uint8_t big_handle,

              base::OnceCallback<void(uint8_t*, uint16_t)>) {}};

  void operator()(uint8_t big_handle,

                  base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

    body(big_handle, std::move(cb));

  };

};

extern struct btsnd_hcic_big_term_sync btsnd_hcic_big_term_sync;



// Name: btsnd_hcic_ble_add_device_resolving_list

// Params: uint8_t addr_type_peer, const RawAddress& bda_peer, const Octet16&

// irk_peer, const Octet16& irk_local Return: void
@@ -167,48 +140,6 @@ struct btsnd_hcic_ble_clear_resolving_list { 
extern struct btsnd_hcic_ble_clear_resolving_list

    btsnd_hcic_ble_clear_resolving_list;



// Name: btsnd_hcic_ble_create_conn_cancel

// Params: void

// Return: void

struct btsnd_hcic_ble_create_conn_cancel {

  std::function<void(void)> body{[](void) {}};

  void operator()(void) { body(); };

};

extern struct btsnd_hcic_ble_create_conn_cancel

    btsnd_hcic_ble_create_conn_cancel;



// Name: btsnd_hcic_ble_create_ll_conn

// Params: uint16_t scan_int, uint16_t scan_win, uint8_t init_filter_policy,

// tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer, tBLE_ADDR_TYPE

// addr_type_own, uint16_t conn_int_min, uint16_t conn_int_max, uint16_t

// conn_latency, uint16_t conn_timeout, uint16_t min_ce_len, uint16_t max_ce_len

// Return: void

struct btsnd_hcic_ble_create_ll_conn {

  std::function<void(uint16_t scan_int, uint16_t scan_win,

                     uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_peer,

                     const RawAddress& bda_peer, tBLE_ADDR_TYPE addr_type_own,

                     uint16_t conn_int_min, uint16_t conn_int_max,

                     uint16_t conn_latency, uint16_t conn_timeout,

                     uint16_t min_ce_len, uint16_t max_ce_len)>

      body{[](uint16_t scan_int, uint16_t scan_win, uint8_t init_filter_policy,

              tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer,

              tBLE_ADDR_TYPE addr_type_own, uint16_t conn_int_min,

              uint16_t conn_int_max, uint16_t conn_latency,

              uint16_t conn_timeout, uint16_t min_ce_len,

              uint16_t max_ce_len) {}};

  void operator()(uint16_t scan_int, uint16_t scan_win,

                  uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_peer,

                  const RawAddress& bda_peer, tBLE_ADDR_TYPE addr_type_own,

                  uint16_t conn_int_min, uint16_t conn_int_max,

                  uint16_t conn_latency, uint16_t conn_timeout,

                  uint16_t min_ce_len, uint16_t max_ce_len) {

    body(scan_int, scan_win, init_filter_policy, addr_type_peer, bda_peer,

         addr_type_own, conn_int_min, conn_int_max, conn_latency, conn_timeout,

         min_ce_len, max_ce_len);

  };

};

extern struct btsnd_hcic_ble_create_ll_conn btsnd_hcic_ble_create_ll_conn;



// Name: btsnd_hcic_ble_enh_rx_test

// Params: uint8_t rx_chan, uint8_t phy, uint8_t mod_index

// Return: void
@@ -236,26 +167,6 @@ struct btsnd_hcic_ble_enh_tx_test { 
};

extern struct btsnd_hcic_ble_enh_tx_test btsnd_hcic_ble_enh_tx_test;



// Name: btsnd_hcic_ble_ext_create_conn

// Params: uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_own,

// tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer, uint8_t

// initiating_phys, EXT_CONN_PHY_CFG* phy_cfg Return: void

struct btsnd_hcic_ble_ext_create_conn {

  std::function<void(uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_own,

                     tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer,

                     uint8_t initiating_phys, EXT_CONN_PHY_CFG* phy_cfg)>

      body{[](uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_own,

              tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer,

              uint8_t initiating_phys, EXT_CONN_PHY_CFG* phy_cfg) {}};

  void operator()(uint8_t init_filter_policy, tBLE_ADDR_TYPE addr_type_own,

                  tBLE_ADDR_TYPE addr_type_peer, const RawAddress& bda_peer,

                  uint8_t initiating_phys, EXT_CONN_PHY_CFG* phy_cfg) {

    body(init_filter_policy, addr_type_own, addr_type_peer, bda_peer,

         initiating_phys, phy_cfg);

  };

};

extern struct btsnd_hcic_ble_ext_create_conn btsnd_hcic_ble_ext_create_conn;



// Name: btsnd_hcic_ble_ltk_req_neg_reply

// Params: uint16_t handle

// Return: void
@@ -411,25 +322,6 @@ struct btsnd_hcic_ble_read_adv_chnl_tx_power { 
extern struct btsnd_hcic_ble_read_adv_chnl_tx_power

    btsnd_hcic_ble_read_adv_chnl_tx_power;



// Name: btsnd_hcic_ble_read_chnl_map

// Params: uint16_t handle

// Return: void

struct btsnd_hcic_ble_read_chnl_map {

  std::function<void(uint16_t handle)> body{[](uint16_t handle) {}};

  void operator()(uint16_t handle) { body(handle); };

};

extern struct btsnd_hcic_ble_read_chnl_map btsnd_hcic_ble_read_chnl_map;



// Name: btsnd_hcic_ble_read_host_supported

// Params: void

// Return: void

struct btsnd_hcic_ble_read_host_supported {

  std::function<void(void)> body{[](void) {}};

  void operator()(void) { body(); };

};

extern struct btsnd_hcic_ble_read_host_supported

    btsnd_hcic_ble_read_host_supported;



// Name: btsnd_hcic_ble_read_remote_feat

// Params: uint16_t handle

// Return: void
@@ -439,19 +331,6 @@ struct btsnd_hcic_ble_read_remote_feat { 
};

extern struct btsnd_hcic_ble_read_remote_feat btsnd_hcic_ble_read_remote_feat;



// Name: btsnd_hcic_ble_read_resolvable_addr_local

// Params: uint8_t addr_type_peer, const RawAddress& bda_peer

// Return: void

struct btsnd_hcic_ble_read_resolvable_addr_local {

  std::function<void(uint8_t addr_type_peer, const RawAddress& bda_peer)> body{

      [](uint8_t addr_type_peer, const RawAddress& bda_peer) {}};

  void operator()(uint8_t addr_type_peer, const RawAddress& bda_peer) {

    body(addr_type_peer, bda_peer);

  };

};

extern struct btsnd_hcic_ble_read_resolvable_addr_local

    btsnd_hcic_ble_read_resolvable_addr_local;



// Name: btsnd_hcic_ble_read_resolvable_addr_peer

// Params: uint8_t addr_type_peer, const RawAddress& bda_peer

// Return: void
@@ -487,19 +366,6 @@ struct btsnd_hcic_ble_rm_device_resolving_list { 
extern struct btsnd_hcic_ble_rm_device_resolving_list

    btsnd_hcic_ble_rm_device_resolving_list;



// Name: btsnd_hcic_ble_set_addr_resolution_enable

// Params: uint8_t addr_resolution_enable

// Return: void

struct btsnd_hcic_ble_set_addr_resolution_enable {

  std::function<void(uint8_t addr_resolution_enable)> body{

      [](uint8_t addr_resolution_enable) {}};

  void operator()(uint8_t addr_resolution_enable) {

    body(addr_resolution_enable);

  };

};

extern struct btsnd_hcic_ble_set_addr_resolution_enable

    btsnd_hcic_ble_set_addr_resolution_enable;



// Name: btsnd_hcic_ble_set_adv_data

// Params: uint8_t data_len, uint8_t* p_data

// Return: void
@@ -586,27 +452,6 @@ struct btsnd_hcic_ble_set_extended_scan_params { 
extern struct btsnd_hcic_ble_set_extended_scan_params

    btsnd_hcic_ble_set_extended_scan_params;



// Name: btsnd_hcic_ble_set_host_chnl_class

// Params: uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE]

// Return: void

struct btsnd_hcic_ble_set_host_chnl_class {

  std::function<void(uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE])> body{

      [](uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE]) {}};

  void operator()(uint8_t chnl_map[HCIC_BLE_CHNL_MAP_SIZE]) { body(chnl_map); };

};

extern struct btsnd_hcic_ble_set_host_chnl_class

    btsnd_hcic_ble_set_host_chnl_class;



// Name: btsnd_hcic_ble_set_local_used_feat

// Params: uint8_t feat_set[8]

// Return: void

struct btsnd_hcic_ble_set_local_used_feat {

  std::function<void(uint8_t feat_set[8])> body{[](uint8_t feat_set[8]) {}};

  void operator()(uint8_t feat_set[]) { body(feat_set); };

};

extern struct btsnd_hcic_ble_set_local_used_feat

    btsnd_hcic_ble_set_local_used_feat;



// Name: btsnd_hcic_ble_set_periodic_advertising_receive_enable

// Params: uint16_t sync_handle, bool enable, base::OnceCallback<void(uint8_t*,

// uint16_t Return: void
@@ -667,16 +512,6 @@ struct btsnd_hcic_ble_set_rand_priv_addr_timeout { 
extern struct btsnd_hcic_ble_set_rand_priv_addr_timeout

    btsnd_hcic_ble_set_rand_priv_addr_timeout;



// Name: btsnd_hcic_ble_set_random_addr

// Params: const RawAddress& random_bda

// Return: void

struct btsnd_hcic_ble_set_random_addr {

  std::function<void(const RawAddress& random_bda)> body{

      [](const RawAddress& random_bda) {}};

  void operator()(const RawAddress& random_bda) { body(random_bda); };

};

extern struct btsnd_hcic_ble_set_random_addr btsnd_hcic_ble_set_random_addr;



// Name: btsnd_hcic_ble_set_scan_enable

// Params: uint8_t scan_enable, uint8_t duplicate

// Return: void
@@ -704,18 +539,6 @@ struct btsnd_hcic_ble_set_scan_params { 
};

extern struct btsnd_hcic_ble_set_scan_params btsnd_hcic_ble_set_scan_params;



// Name: btsnd_hcic_ble_set_scan_rsp_data

// Params: uint8_t data_len, uint8_t* p_scan_rsp

// Return: void

struct btsnd_hcic_ble_set_scan_rsp_data {

  std::function<void(uint8_t data_len, uint8_t* p_scan_rsp)> body{

      [](uint8_t data_len, uint8_t* p_scan_rsp) {}};

  void operator()(uint8_t data_len, uint8_t* p_scan_rsp) {

    body(data_len, p_scan_rsp);

  };

};

extern struct btsnd_hcic_ble_set_scan_rsp_data btsnd_hcic_ble_set_scan_rsp_data;



// Name: btsnd_hcic_ble_start_enc

// Params: uint16_t handle, uint8_t rand[HCIC_BLE_RAND_DI_SIZE], uint16_t ediv,

// const Octet16& ltk Return: void
@@ -853,20 +676,6 @@ struct btsnd_hcic_read_iso_link_quality { 
};

extern struct btsnd_hcic_read_iso_link_quality btsnd_hcic_read_iso_link_quality;



// Name: btsnd_hcic_read_iso_tx_sync

// Params: uint16_t iso_handle, base::OnceCallback<void(uint8_t*, uint16_t

// Return: void

struct btsnd_hcic_read_iso_tx_sync {

  std::function<void(uint16_t, base::OnceCallback<void(uint8_t*, uint16_t)>)>

      body{[](uint16_t iso_handle,

              base::OnceCallback<void(uint8_t*, uint16_t)> cb) {}};

  void operator()(uint16_t iso_handle,

                  base::OnceCallback<void(uint8_t*, uint16_t)> cb) {

    body(iso_handle, std::move(cb));

  };

};

extern struct btsnd_hcic_read_iso_tx_sync btsnd_hcic_read_iso_tx_sync;



// Name: btsnd_hcic_rej_cis_req

// Params: uint16_t conn_handle, uint8_t reason,

// base::OnceCallback<void(uint8_t*, uint16_t Return: void