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

Commit 91236cff authored by Myles Watson's avatar Myles Watson Committed by Gerrit Code Review
Browse files

Merge changes I11d0188a,I92a70be5 

* changes:
  Remove unused btsnd_hcic_ble commands
  Remove unused paging code
parents a93dffc0 762825a4

system/stack/acl/btm_acl.cc

+0 −77
Original line number Diff line number Diff line
@@ -552,8 +552,6 @@ void btm_acl_device_down(void) { 
  BTM_db_reset();

}



void btm_acl_set_paging(bool value) { btm_cb.is_paging = value; }



void btm_acl_update_inquiry_status(uint8_t status) {

  btm_cb.is_inquiry = status == BTM_INQUIRY_STARTED;

  BTIF_dm_report_inquiry_status_change(status);
@@ -2273,79 +2271,6 @@ void btm_cont_rswitch_from_handle(uint16_t hci_handle) { 
  }

}



/*******************************************************************************

 *

 * Function         btm_acl_resubmit_page

 *

 * Description      send pending page request

 *

 ******************************************************************************/

void btm_acl_resubmit_page(void) {

  BT_HDR* p_buf;

  uint8_t* pp;

  /* If there were other page request schedule can start the next one */

  p_buf = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue);

  if (p_buf != NULL) {

    /* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr

     * for both create_conn and rmt_name */

    pp = (uint8_t*)(p_buf + 1) + p_buf->offset + 3;



    RawAddress bda;

    STREAM_TO_BDADDR(bda, pp);



    btm_cb.connecting_bda = bda;

    memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN);



    btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p_buf);

  } else {

    btm_cb.paging = false;

  }

}



/*******************************************************************************

 *

 * Function         btm_acl_reset_paging

 *

 * Description      set paging to false and free the page queue - called at

 *                  hci_reset

 *

 ******************************************************************************/

void btm_acl_reset_paging(void) {

  BT_HDR* p;

  /* If we sent reset we are definitely not paging any more */

  while ((p = (BT_HDR*)fixed_queue_try_dequeue(btm_cb.page_queue)) != NULL)

    osi_free(p);



  btm_cb.paging = false;

}



/*******************************************************************************

 *

 * Function         btm_acl_paging

 *

 * Description      send a paging command or queue it in btm_cb

 *

 ******************************************************************************/

void btm_acl_paging(BT_HDR* p, const RawAddress& bda) {

  if (!BTM_IsAclConnectionUp(bda, BT_TRANSPORT_BR_EDR)) {

    VLOG(1) << "connecting_bda: "

            << ADDRESS_TO_LOGGABLE_STR(btm_cb.connecting_bda);

    if (btm_cb.paging && bda == btm_cb.connecting_bda) {

      fixed_queue_enqueue(btm_cb.page_queue, p);

    } else {

      btm_cb.connecting_bda = bda;

      memcpy(btm_cb.connecting_dc, btm_get_dev_class(bda), DEV_CLASS_LEN);



      btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

    }



    btm_cb.paging = true;

  } else /* ACL is already up */

  {

    btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);

  }

}



/*******************************************************************************

 *

 * Function         btm_acl_notif_conn_collision
@@ -2685,7 +2610,6 @@ void on_acl_br_edr_connected(const RawAddress& bda, uint16_t handle, 
    btm_sec_connected(bda, handle, HCI_SUCCESS, enc_mode);

  }

  delayed_role_change_ = nullptr;

  btm_acl_set_paging(false);

  l2c_link_hci_conn_comp(HCI_SUCCESS, handle, bda);

  uint16_t link_supervision_timeout =

      osi_property_get_int32(PROPERTY_LINK_SUPERVISION_TIMEOUT, 8000);
@@ -2719,7 +2643,6 @@ void on_acl_br_edr_failed(const RawAddress& bda, tHCI_STATUS status, 
    btm_sec_connected(bda, HCI_INVALID_HANDLE, status, false);

  }

  delayed_role_change_ = nullptr;

  btm_acl_set_paging(false);

  l2c_link_hci_conn_comp(status, HCI_INVALID_HANDLE, bda);



  acl_set_locally_initiated(locally_initiated);

system/stack/acl/btm_pm.cc

+1 −4
Original line number Diff line number Diff line
@@ -859,10 +859,7 @@ static bool btm_pm_device_in_scan_state(void) { 
  /* Scan state-paging, inquiry, and trying to connect */



  /* Check for paging */

  if (btm_cb.is_paging || !fixed_queue_is_empty(btm_cb.page_queue)) {

    BTM_TRACE_DEBUG("btm_pm_device_in_scan_state- paging");

    return true;

  }

  // TODO: Get this information from connection manager?



  /* Check for inquiry */

  if ((btm_cb.btm_inq_vars.inq_active &

system/stack/btm/btm_int_types.h

+0 −13
Original line number Diff line number Diff line
@@ -289,16 +289,7 @@ typedef struct tBTM_CB { 
  RawAddress connecting_bda;

  DEV_CLASS connecting_dc;

  uint8_t trace_level;

  bool is_paging{false};  /* true, if paging is in progess */

  bool is_inquiry{false}; /* true, if inquiry is in progess */

  fixed_queue_t* page_queue{nullptr};



  bool paging{false};

  void set_paging() { paging = true; }

  void reset_paging() { paging = false; }

  bool is_paging_active() const {

    return paging;

  }  // TODO remove all this paging state



  fixed_queue_t* sec_pending_q{nullptr}; /* pending sequrity requests in

                                            tBTM_SEC_QUEUE_ENTRY format */
@@ -345,7 +336,6 @@ typedef struct tBTM_CB { 
    acl_cb_ = {};

    neighbor = {};



    page_queue = fixed_queue_new(SIZE_MAX);

    sec_pending_q = fixed_queue_new(SIZE_MAX);

    sec_collision_timer = alarm_new("btm.sec_collision_timer");

    pairing_timer = alarm_new("btm.pairing_timer");
@@ -384,9 +374,6 @@ typedef struct tBTM_CB { 
    sco_cb.Free();

    btm_inq_vars.Free();



    fixed_queue_free(page_queue, nullptr);

    page_queue = nullptr;



    fixed_queue_free(sec_pending_q, nullptr);

    sec_pending_q = nullptr;

system/stack/btm/btm_sec.cc

+0 −5
Original line number Diff line number Diff line
@@ -2289,7 +2289,6 @@ void btm_sec_rmt_name_request_complete(const RawAddress* p_bd_addr, 
       !BTM_IsAclConnectionUp(btm_cb.connecting_bda, BT_TRANSPORT_BR_EDR)) ||

      (p_bd_addr && !BTM_IsAclConnectionUp(*p_bd_addr, BT_TRANSPORT_BR_EDR))) {

    LOG_WARN("Remote read request complete with no underlying link connection");

    btm_acl_resubmit_page();

  }



  /* If remote name request failed, p_bd_addr is null and we need to search */
@@ -3558,8 +3557,6 @@ void btm_sec_connected(const RawAddress& bda, uint16_t handle, 
  bool addr_matched;

  uint8_t bit_shift = 0;



  btm_acl_resubmit_page();



  tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(bda);

  if (!p_dev_rec) {

    LOG_DEBUG(
@@ -3860,8 +3857,6 @@ void btm_sec_disconnected(uint16_t handle, tHCI_REASON reason, 
             hci_error_code_text(reason).c_str(), handle, comment.c_str());

  }



  btm_acl_resubmit_page();



  tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev_by_handle(handle);

  if (p_dev_rec == nullptr) {

    LOG_WARN("Got disconnect for unknown device record handle:0x%04x", handle);

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) {