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

Commit 7efcd82a authored by Christine Hallstrom's avatar Christine Hallstrom
Browse files

Delete unused periodic sync methods

This is all implemented in GD now.

Bug: 304574849
Test: m .
Flag: EXEMPT, dead code deletion
Change-Id: I8c196aff08321f9b178bea81222a9d0066948bf4
parent c39cc151
Loading
Loading
Loading
Loading
+0 −231
Original line number Diff line number Diff line
@@ -1074,17 +1074,6 @@ static void btm_ble_start_sync_timeout(void* data) {
  p->in_use = false;
}

static int btm_ble_get_free_psync_index() {
  int i;
  for (i = 0; i < MAX_SYNC_TRANSACTION; i++) {
    if (btm_ble_pa_sync_cb.p_sync[i].in_use == false) {
      LOG_DEBUG("found index at %d", i);
      return i;
    }
  }
  return i;
}

static int btm_ble_get_psync_index_from_handle(uint16_t handle) {
  int i;
  for (i = 0; i < MAX_SYNC_TRANSACTION; i++) {
@@ -1109,17 +1098,6 @@ static int btm_ble_get_psync_index(uint8_t adv_sid, RawAddress addr) {
  return i;
}

static int btm_ble_get_free_sync_transfer_index() {
  int i;
  for (i = 0; i < MAX_SYNC_TRANSACTION; i++) {
    if (!btm_ble_pa_sync_cb.sync_transfer[i].in_use) {
      LOG_DEBUG("found index at %d", i);
      return i;
    }
  }
  return i;
}

static int btm_ble_get_sync_transfer_index(uint16_t conn_handle) {
  int i;
  for (i = 0; i < MAX_SYNC_TRANSACTION; i++) {
@@ -1248,102 +1226,6 @@ void btm_ble_periodic_adv_sync_lost(uint16_t sync_handle) {
  ps->remote_bda = RawAddress::kEmpty;
}

/*******************************************************************************
 *
 * Function        BTM_BleStartPeriodicSync
 *
 * Description     Create sync request to PA associated with address and sid
 *
 ******************************************************************************/
void BTM_BleStartPeriodicSync(uint8_t adv_sid, RawAddress address,
                              uint16_t skip, uint16_t timeout,
                              StartSyncCb syncCb, SyncReportCb reportCb,
                              SyncLostCb lostCb, BigInfoReportCb biginfo_reportCb) {
  LOG_DEBUG("%s", "[PSync]");
  int index = btm_ble_get_free_psync_index();

  if (index == MAX_SYNC_TRANSACTION) {
    syncCb.Run(BTM_NO_RESOURCES, 0, adv_sid, BLE_ADDR_RANDOM, address, 0, 0);
    return;
  }

  tBTM_BLE_PERIODIC_SYNC* p = &btm_ble_pa_sync_cb.p_sync[index];

  p->in_use = true;
  p->remote_bda = address;
  p->sid = adv_sid;
  p->sync_start_cb = syncCb;
  p->sync_report_cb = reportCb;
  p->sync_lost_cb = lostCb;
  p->biginfo_report_cb = biginfo_reportCb;
  btm_queue_start_sync_req(adv_sid, address, skip, timeout);
}

/*******************************************************************************
 *
 * Function        BTM_BleStopPeriodicSync
 *
 * Description     Terminate sync request to PA associated with sync handle
 *
 ******************************************************************************/
void BTM_BleStopPeriodicSync(uint16_t handle) {
  LOG_DEBUG("[PSync]: handle = %u", handle);
  int index = btm_ble_get_psync_index_from_handle(handle);
  if (index == MAX_SYNC_TRANSACTION) {
    LOG_ERROR("[PSync]: invalid index for handle %u", handle);
    if (BleScanningManager::IsInitialized()) {
      BleScanningManager::Get()->PeriodicScanTerminate(handle);
    }
    return;
  }
  tBTM_BLE_PERIODIC_SYNC* p = &btm_ble_pa_sync_cb.p_sync[index];
  p->sync_state = PERIODIC_SYNC_IDLE;
  p->in_use = false;
  p->remote_bda = RawAddress::kEmpty;
  p->sid = 0;
  p->sync_handle = 0;
  p->in_use = false;
  if (BleScanningManager::IsInitialized()) {
    BleScanningManager::Get()->PeriodicScanTerminate(handle);
  }
}

/*******************************************************************************
 *
 * Function        BTM_BleCancelPeriodicSync
 *
 * Description     Cancel create sync request to PA associated with sid and
 *                 address
 *
 ******************************************************************************/
void BTM_BleCancelPeriodicSync(uint8_t adv_sid, RawAddress address) {
  LOG_DEBUG("%s", "[PSync]");
  int index = btm_ble_get_psync_index(adv_sid, address);
  if (index == MAX_SYNC_TRANSACTION) {
    LOG_ERROR("[PSync]:Invalid index for sid=%u", adv_sid);
    return;
  }
  tBTM_BLE_PERIODIC_SYNC* p = &btm_ble_pa_sync_cb.p_sync[index];
  if (p->sync_state == PERIODIC_SYNC_PENDING) {
    LOG_WARN("[PSync]: Sync state is pending for index %d", index);
    if (BleScanningManager::IsInitialized()) {
      BleScanningManager::Get()->PeriodicScanCancelStart();
    }
  } else if (p->sync_state == PERIODIC_SYNC_IDLE) {
    LOG_DEBUG("[PSync]: Removing Sync request from queue for index %d", index);
    remove_sync_node_t remove_node;
    remove_node.sid = adv_sid;
    remove_node.address = address;
    btm_ble_sync_queue_handle(BTM_QUEUE_SYNC_CLEANUP_EVT, (char*)&remove_node);
  }
  p->sync_state = PERIODIC_SYNC_IDLE;
  p->in_use = false;
  p->remote_bda = RawAddress::kEmpty;
  p->sid = 0;
  p->sync_handle = 0;
  p->in_use = false;
}

/*******************************************************************************
 *
 * Function        btm_ble_periodic_syc_transfer_cmd_cmpl
@@ -1374,96 +1256,6 @@ void btm_ble_periodic_syc_transfer_param_cmpl(uint8_t status) {
  LOG_DEBUG("[PAST]: status = %d", status);
}

/*******************************************************************************
 *
 * Function        BTM_BlePeriodicSyncTransfer
 *
 * Description     Initiate PAST to connected remote device with sync handle
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncTransfer(RawAddress addr, uint16_t service_data,
                                 uint16_t sync_handle, SyncTransferCb cb) {
  uint16_t conn_handle = BTM_GetHCIConnHandle(addr, BT_TRANSPORT_LE);
  tACL_CONN* p_acl = btm_acl_for_bda(addr, BT_TRANSPORT_LE);
  LOG_VERBOSE("[PAST]%s for connection_handle = %x", __func__, conn_handle);
  if (conn_handle == 0xFFFF || p_acl == NULL) {
    LOG_ERROR("[PAST]%s:Invalid connection handle or no LE ACL link", __func__);
    cb.Run(BTM_UNKNOWN_ADDR, addr);
    return;
  }

  if (!HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT(
          p_acl->peer_le_features)) {
    LOG_ERROR("[PAST]%s:Remote doesn't support PAST", __func__);
    cb.Run(BTM_MODE_UNSUPPORTED, addr);
    return;
  }

  int index = btm_ble_get_free_sync_transfer_index();
  if (index == MAX_SYNC_TRANSACTION) {
    LOG_ERROR("Failed to get sync transfer index");
    cb.Run(BTM_ILLEGAL_VALUE, addr);
    return;
  }

  tBTM_BLE_PERIODIC_SYNC_TRANSFER* p_sync_transfer =
      &btm_ble_pa_sync_cb.sync_transfer[index];
  p_sync_transfer->in_use = true;
  p_sync_transfer->conn_handle = conn_handle;
  p_sync_transfer->addr = addr;
  p_sync_transfer->cb = cb;
  if (BleScanningManager::IsInitialized()) {
    BleScanningManager::Get()->PeriodicAdvSyncTransfer(
        addr, service_data, sync_handle,
        base::Bind(&btm_ble_periodic_syc_transfer_cmd_cmpl));
  }
}

/*******************************************************************************
 *
 * Function        BTM_BlePeriodicSyncSetInfo
 *
 * Description     Initiate PAST to connected remote device with adv handle
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncSetInfo(RawAddress addr, uint16_t service_data,
                                uint8_t adv_handle, SyncTransferCb cb) {
  uint16_t conn_handle = BTM_GetHCIConnHandle(addr, BT_TRANSPORT_LE);
  tACL_CONN* p_acl = btm_acl_for_bda(addr, BT_TRANSPORT_LE);
  LOG_DEBUG("[PAST] for connection_handle = %u", conn_handle);
  if (conn_handle == 0xFFFF || p_acl == nullptr) {
    LOG_ERROR("[PAST]:Invalid connection handle %u or no LE ACL link",
              conn_handle);
    cb.Run(BTM_UNKNOWN_ADDR, addr);
    return;
  }
  if (!HCI_LE_PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT(
          p_acl->peer_le_features)) {
    LOG_ERROR("%s", "[PAST]:Remote doesn't support PAST");
    cb.Run(BTM_MODE_UNSUPPORTED, addr);
    return;
  }

  int index = btm_ble_get_free_sync_transfer_index();
  if (index == MAX_SYNC_TRANSACTION) {
    LOG_ERROR("Failed to get sync transfer index");
    cb.Run(BTM_ILLEGAL_VALUE, addr);
    return;
  }

  tBTM_BLE_PERIODIC_SYNC_TRANSFER* p_sync_transfer =
      &btm_ble_pa_sync_cb.sync_transfer[index];
  p_sync_transfer->in_use = true;
  p_sync_transfer->conn_handle = conn_handle;
  p_sync_transfer->addr = addr;
  p_sync_transfer->cb = cb;
  if (BleScanningManager::IsInitialized()) {
    BleScanningManager::Get()->PeriodicAdvSetInfoTransfer(
        addr, service_data, adv_handle,
        base::Bind(&btm_ble_periodic_syc_transfer_cmd_cmpl));
  }
}

/*******************************************************************************
 *
 * Function        btm_ble_biginfo_adv_report_rcvd
@@ -1557,29 +1349,6 @@ void btm_ble_periodic_adv_sync_tx_rcvd(const uint8_t* p, uint16_t param_len) {
  }
}

/*******************************************************************************
 *
 * Function        BTM_BlePeriodicSyncTxParameters
 *
 * Description     On receiver side this command is used to specify how BT SoC
 *                 will process PA sync info received from the remote device
 *                 identified by the addr.
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncTxParameters(RawAddress addr, uint8_t mode,
                                     uint16_t skip, uint16_t timeout,
                                     StartSyncCb syncCb) {
  LOG_DEBUG("[PAST]: mode=%u, skip=%u, timeout=%u", mode, skip, timeout);
  uint8_t cte_type = 7;
  sync_rcvd_cb = syncCb;
  syncRcvdCbRegistered = true;
  if (BleScanningManager::IsInitialized()) {
    BleScanningManager::Get()->SetPeriodicAdvSyncTransferParams(
        addr, mode, skip, timeout, cte_type, true,
        base::Bind(&btm_ble_periodic_syc_transfer_param_cmpl));
  }
}

/*******************************************************************************
 *
 * Function         btm_set_conn_mode_adv_init_addr
+0 −99
Original line number Diff line number Diff line
@@ -431,105 +431,6 @@ void btm_ble_periodic_adv_sync_lost(uint16_t sync_handle);
void btm_ble_biginfo_adv_report_rcvd(const uint8_t* param, uint16_t param_len);
void btm_ble_periodic_adv_sync_tx_rcvd(const uint8_t* param,
                                       uint16_t param_len);
/*******************************************************************************
 *
 * Function         BTM_BleStartPeriodicSync
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_PERIODIC_ADVERTISING_CREATE_SYNC to synchronize to
 *                  PA train specified in input parameters.
 *
 * Parameters       PA train info corresponding to particualr PA train and
 *                  callbacks to sync established, pa report and sync lost
 *events
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BleStartPeriodicSync(uint8_t adv_sid, RawAddress address,
                              uint16_t skip, uint16_t timeout,
                              StartSyncCb syncCb, SyncReportCb reportCb,
                              SyncLostCb lostCb,
                              BigInfoReportCb biginfo_reportCb);
/*******************************************************************************
 *
 * Function         BTM_BleStopPeriodicSync
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_PERIODIC_ADVERTISING_TERMINATE_SYNC to stop
 *synchronising to PA train.
 *
 * Parameters       sync handle
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BleStopPeriodicSync(uint16_t handle);
/*******************************************************************************
 *
 * Function         BTM_BleCancelPeriodicSync
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_PERIODIC_ADVERTISING_CREATE_SYNC_CANCEL to
 *                  cancel pending sync to PA train.
 *
 * Parameters       adv sid, address corrosponds to PA train
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BleCancelPeriodicSync(uint8_t adv_sid, RawAddress address);

using SyncTransferCb = base::Callback<void(uint8_t /*status*/, RawAddress)>;

/*******************************************************************************
 *
 * Function         BTM_BlePeriodicSyncTransfer
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER to transfer
 *                  sync info of remote advertiser to connected remote device
 *
 * Parameters       PAST specific parameters
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncTransfer(RawAddress addr, uint16_t service_data,
                                 uint16_t sync_handle, SyncTransferCb cb);
/*******************************************************************************
 *
 * Function         BTM_BlePeriodicSyncSetInfo
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_SET_PERIODIC_ADVERTISING_SET_INFO_TRANSFER to
 *transfer colocated advertiser sync info to connected remote device
 *
 * Parameters       PAST specific parameters
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncSetInfo(RawAddress addr, uint16_t service_data,
                                uint8_t adv_handle, SyncTransferCb cb);
/*******************************************************************************
 *
 * Function         BTM_BlePeriodicSyncTxParameters
 *
 * Description      This function is called to invoke HCI Command
 *                  HCI_LE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS,
 *                  this command is used to specify how BT SoC will process PA
 *                  sync information received from the remote device identified
 *                  by the addr.
 *
 * Parameters       HCI command  specific parameters
 *
 * Returns          void
 *
 ******************************************************************************/
void BTM_BlePeriodicSyncTxParameters(RawAddress addr, uint8_t mode,
                                     uint16_t skip, uint16_t timeout,
                                     StartSyncCb syncCb);

/*******************************************************************************
 *
+0 −32
Original line number Diff line number Diff line
@@ -217,38 +217,6 @@ void btm_send_hci_set_scan_params(uint8_t /* scan_type */,
                                  uint8_t /* scan_filter_policy */) {
  inc_func_call_count(__func__);
}
void BTM_BleStartPeriodicSync(uint8_t /* adv_sid */, RawAddress /* address */,
                              uint16_t /* skip */, uint16_t /* timeout */,
                              StartSyncCb /* syncCb */,
                              SyncReportCb /* reportCb */,
                              SyncLostCb /* lostCb */) {
  inc_func_call_count(__func__);
}
void BTM_BleStopPeriodicSync(uint16_t /* handle */) {
  inc_func_call_count(__func__);
}
void BTM_BleCancelPeriodicSync(uint8_t /* adv_sid */,
                               RawAddress /* address */) {
  inc_func_call_count(__func__);
}
void BTM_BlePeriodicSyncTransfer(RawAddress /* addr */,
                                 uint16_t /* service_data */,
                                 uint16_t /* sync_handle */,
                                 SyncTransferCb /* cb */) {
  inc_func_call_count(__func__);
}
void BTM_BlePeriodicSyncSetInfo(RawAddress /* addr */,
                                uint16_t /* service_data */,
                                uint8_t /* adv_handle */,
                                SyncTransferCb /* cb */) {
  inc_func_call_count(__func__);
}
void BTM_BlePeriodicSyncTxParameters(RawAddress /* addr */, uint8_t /* mode */,
                                     uint16_t /* skip */,
                                     uint16_t /* timeout */,
                                     StartSyncCb /* syncCb */) {
  inc_func_call_count(__func__);
}
void btm_ble_periodic_adv_sync_tx_rcvd(const uint8_t* /* p */,
                                       uint16_t /* param_len */) {
  inc_func_call_count(__func__);