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

Commit c6f19363 authored by Chris Manton's avatar Chris Manton Committed by Automerger Merge Worker
Browse files

tBTM_BLE_INQ_CB:[1-10] Use longform stack::btm:: am: c52a88ba am: 341928c9 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2873094



Change-Id: I3d0033d60e57271c1ec5a12b018553c5363f75f2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents bf8cab2b 341928c9

system/main/shim/le_scanning_manager.cc

+3 −4
Original line number Diff line number Diff line
@@ -342,14 +342,13 @@ void BleScannerInterfaceImpl::SetScanParameters(int scanner_id, 
                                                int scan_interval,

                                                int scan_window, Callback cb) {

  LOG(INFO) << __func__ << " in shim layer";

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;

  if (BTM_BLE_ISVALID_PARAM(scan_interval, BTM_BLE_SCAN_INT_MIN,

                            BTM_BLE_EXT_SCAN_INT_MAX) &&

      BTM_BLE_ISVALID_PARAM(scan_window, BTM_BLE_SCAN_WIN_MIN,

                            BTM_BLE_EXT_SCAN_WIN_MAX)) {

    p_cb->scan_type = BTM_BLE_SCAN_MODE_ACTI;

    p_cb->scan_interval = scan_interval;

    p_cb->scan_window = scan_window;

    btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_ACTI;

    btm_cb.ble_ctr_cb.inq_var.scan_interval = scan_interval;

    btm_cb.ble_ctr_cb.inq_var.scan_window = scan_window;

  }



  // use active scan

system/stack/btm/btm_ble_bgconn.cc

+15 −13
Original line number Diff line number Diff line
@@ -70,23 +70,25 @@ static std::unordered_map<RawAddress, BackgroundConnection, BgConnHash> 
 * Description      This function updates the filter policy of scanner

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

void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy) {

  tBTM_BLE_INQ_CB* p_inq = &btm_cb.ble_ctr_cb.inq_var;



  uint32_t scan_interval =

      !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;

  uint32_t scan_window =

      !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;

  uint32_t scan_interval = !btm_cb.ble_ctr_cb.inq_var.scan_interval

                               ? BTM_BLE_GAP_DISC_SCAN_INT

                               : btm_cb.ble_ctr_cb.inq_var.scan_interval;

  uint32_t scan_window = !btm_cb.ble_ctr_cb.inq_var.scan_window

                             ? BTM_BLE_GAP_DISC_SCAN_WIN

                             : btm_cb.ble_ctr_cb.inq_var.scan_window;



  LOG_VERBOSE("%s", __func__);



  p_inq->sfp = scan_policy;

  p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE

  btm_cb.ble_ctr_cb.inq_var.sfp = scan_policy;

  btm_cb.ble_ctr_cb.inq_var.scan_type =

      btm_cb.ble_ctr_cb.inq_var.scan_type == BTM_BLE_SCAN_MODE_NONE

          ? BTM_BLE_SCAN_MODE_ACTI

                         : p_inq->scan_type;

          : btm_cb.ble_ctr_cb.inq_var.scan_type;



  btm_send_hci_set_scan_params(

      p_inq->scan_type, (uint16_t)scan_interval, (uint16_t)scan_window,

      btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, scan_policy);

  btm_send_hci_set_scan_params(btm_cb.ble_ctr_cb.inq_var.scan_type,

                               (uint16_t)scan_interval, (uint16_t)scan_window,

                               btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,

                               scan_policy);

}



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

system/stack/btm/btm_ble_gap.cc

+81 −74
Original line number Diff line number Diff line
@@ -504,13 +504,14 @@ void BTM_BleTargetAnnouncementObserve(bool enable, 
tBTM_STATUS BTM_BleObserve(bool start, uint8_t duration,

                           tBTM_INQ_RESULTS_CB* p_results_cb,

                           tBTM_CMPL_CB* p_cmpl_cb, bool low_latency_scan) {

  tBTM_BLE_INQ_CB* p_inq = &btm_cb.ble_ctr_cb.inq_var;

  tBTM_STATUS status = BTM_WRONG_MODE;



  uint32_t scan_interval =

      !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;

  uint32_t scan_window =

      !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;

  uint32_t scan_interval = !btm_cb.ble_ctr_cb.inq_var.scan_interval

                               ? BTM_BLE_GAP_DISC_SCAN_INT

                               : btm_cb.ble_ctr_cb.inq_var.scan_interval;

  uint32_t scan_window = !btm_cb.ble_ctr_cb.inq_var.scan_window

                             ? BTM_BLE_GAP_DISC_SCAN_WIN

                             : btm_cb.ble_ctr_cb.inq_var.scan_window;



  // use low latency scanning if the scanning is active

  if (low_latency_scan) {
@@ -518,8 +519,8 @@ tBTM_STATUS BTM_BleObserve(bool start, uint8_t duration, 
    scan_window = BTM_BLE_LOW_LATENCY_SCAN_WIN;

  }



  LOG_VERBOSE("%s : scan_type:%d, %d, %d", __func__, p_inq->scan_type,

              scan_interval, scan_window);

  LOG_VERBOSE("%s : scan_type:%d, %d, %d", __func__,

              btm_cb.ble_ctr_cb.inq_var.scan_type, scan_interval, scan_window);



  if (!controller_get_interface()->supports_ble()) return BTM_ILLEGAL_VALUE;
@@ -546,8 +547,9 @@ tBTM_STATUS BTM_BleObserve(bool start, uint8_t duration, 
       * 2. current ongoing scanning is low latency

       */

      bool is_ongoing_low_latency =

          p_inq->scan_interval == BTM_BLE_GAP_DISC_SCAN_INT &&

          p_inq->scan_window == BTM_BLE_LOW_LATENCY_SCAN_WIN;

          btm_cb.ble_ctr_cb.inq_var.scan_interval ==

              BTM_BLE_GAP_DISC_SCAN_INT &&

          btm_cb.ble_ctr_cb.inq_var.scan_window == BTM_BLE_LOW_LATENCY_SCAN_WIN;

      if (!low_latency_scan || is_ongoing_low_latency) {

        LOG_WARN("%s Observer was already active, is_low_latency: %d", __func__,

                 is_ongoing_low_latency);
@@ -565,12 +567,14 @@ tBTM_STATUS BTM_BleObserve(bool start, uint8_t duration, 
    if (!btm_cb.ble_ctr_cb.is_ble_scan_active()) {

      /* allow config of scan type */

      cache.ClearAll();

      p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE)

      btm_cb.ble_ctr_cb.inq_var.scan_type =

          (btm_cb.ble_ctr_cb.inq_var.scan_type == BTM_BLE_SCAN_MODE_NONE)

              ? BTM_BLE_SCAN_MODE_ACTI

                             : p_inq->scan_type;

              : btm_cb.ble_ctr_cb.inq_var.scan_type;

      btm_send_hci_set_scan_params(

          p_inq->scan_type, (uint16_t)scan_interval, (uint16_t)scan_window,

          btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, BTM_BLE_DEFAULT_SFP);

          btm_cb.ble_ctr_cb.inq_var.scan_type, (uint16_t)scan_interval,

          (uint16_t)scan_window, btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type,

          BTM_BLE_DEFAULT_SFP);



      btm_ble_start_scan();

    }
@@ -1591,12 +1595,11 @@ void BTM_BlePeriodicSyncTxParameters(RawAddress addr, uint8_t mode, 
static uint8_t btm_set_conn_mode_adv_init_addr(

    RawAddress& p_peer_addr_ptr, tBLE_ADDR_TYPE* p_peer_addr_type,

    tBLE_ADDR_TYPE* p_own_addr_type) {

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;

  uint8_t evt_type;

  tBTM_SEC_DEV_REC* p_dev_rec;



  if (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE) {

    if (p_cb->scan_rsp) {

  if (btm_cb.ble_ctr_cb.inq_var.connectable_mode == BTM_BLE_NON_CONNECTABLE) {

    if (btm_cb.ble_ctr_cb.inq_var.scan_rsp) {

      evt_type = BTM_BLE_DISCOVER_EVT;

    } else {

      evt_type = BTM_BLE_NON_CONNECT_EVT;
@@ -1613,18 +1616,21 @@ static uint8_t btm_set_conn_mode_adv_init_addr( 
    };

    LOG_DEBUG("Received BLE connect event %s", ADDRESS_TO_LOGGABLE_CSTR(ble_bd_addr));



    evt_type = p_cb->directed_conn;

    evt_type = btm_cb.ble_ctr_cb.inq_var.directed_conn;



    if (static_cast<std::underlying_type_t<tBTM_BLE_EVT>>(

            p_cb->directed_conn) == BTM_BLE_CONNECT_DIR_EVT ||

            btm_cb.ble_ctr_cb.inq_var.directed_conn) ==

            BTM_BLE_CONNECT_DIR_EVT ||

        static_cast<std::underlying_type_t<tBTM_BLE_EVT>>(

            p_cb->directed_conn) == BTM_BLE_CONNECT_LO_DUTY_DIR_EVT) {

            btm_cb.ble_ctr_cb.inq_var.directed_conn) ==

            BTM_BLE_CONNECT_LO_DUTY_DIR_EVT) {

      /* for privacy 1.2, convert peer address as static, own address set as ID

       * addr */

      if (btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_1_2 ||

          btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_MIXED) {

        /* only do so for bonded device */

        if ((p_dev_rec = btm_find_or_alloc_dev(p_cb->direct_bda.bda)) != NULL &&

        if ((p_dev_rec = btm_find_or_alloc_dev(

                 btm_cb.ble_ctr_cb.inq_var.direct_bda.bda)) != NULL &&

            p_dev_rec->ble.in_controller_list & BTM_RESOLVING_LIST_BIT) {

          p_peer_addr_ptr = p_dev_rec->ble.identity_address_with_type.bda;

          *p_peer_addr_type = p_dev_rec->ble.identity_address_with_type.type;
@@ -1634,8 +1640,8 @@ static uint8_t btm_set_conn_mode_adv_init_addr( 
        /* otherwise fall though as normal directed adv */

      }

      /* direct adv mode does not have privacy, if privacy is not enabled  */

      *p_peer_addr_type = p_cb->direct_bda.type;

      p_peer_addr_ptr = p_cb->direct_bda.bda;

      *p_peer_addr_type = btm_cb.ble_ctr_cb.inq_var.direct_bda.type;

      p_peer_addr_ptr = btm_cb.ble_ctr_cb.inq_var.direct_bda.bda;

      return evt_type;

    }

  }
@@ -1643,7 +1649,7 @@ static uint8_t btm_set_conn_mode_adv_init_addr( 
  /* undirect adv mode or non-connectable mode*/

  /* when privacy 1.2 privacy only mode is used, or mixed mode */

  if ((btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_1_2 &&

       p_cb->afp != AP_SCAN_CONN_ALL) ||

       btm_cb.ble_ctr_cb.inq_var.afp != AP_SCAN_CONN_ALL) ||

      btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_MIXED) {

    list_node_t* n =

        list_foreach(btm_sec_cb.sec_dev_rec, is_resolving_list_bit_set, NULL);
@@ -1825,7 +1831,6 @@ void btm_ble_set_adv_flag(uint16_t connect_mode, uint16_t disc_mode) { 
 ******************************************************************************/

tBTM_STATUS btm_ble_set_discoverability(uint16_t combined_mode) {

  tBTM_LE_RANDOM_CB* p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;

  uint16_t mode = (combined_mode & BTM_BLE_DISCOVERABLE_MASK);

  uint8_t new_mode = BTM_BLE_ADV_ENABLE;

  uint8_t evt_type;
@@ -1841,49 +1846,53 @@ tBTM_STATUS btm_ble_set_discoverability(uint16_t combined_mode) { 
  /*** Check mode parameter ***/

  if (mode > BTM_BLE_MAX_DISCOVERABLE) return (BTM_ILLEGAL_VALUE);



  p_cb->discoverable_mode = mode;

  btm_cb.ble_ctr_cb.inq_var.discoverable_mode = mode;



  evt_type =

      btm_set_conn_mode_adv_init_addr(address, &init_addr_type, &own_addr_type);



  if (p_cb->connectable_mode == BTM_BLE_NON_CONNECTABLE &&

  if (btm_cb.ble_ctr_cb.inq_var.connectable_mode == BTM_BLE_NON_CONNECTABLE &&

      mode == BTM_BLE_NON_DISCOVERABLE)

    new_mode = BTM_BLE_ADV_DISABLE;



  btm_ble_select_adv_interval(evt_type, &adv_int_min, &adv_int_max);



  alarm_cancel(p_cb->fast_adv_timer);

  alarm_cancel(btm_cb.ble_ctr_cb.inq_var.fast_adv_timer);



  /* update adv params if start advertising */

  LOG_VERBOSE("evt_type=0x%x p-cb->evt_type=0x%x ", evt_type, p_cb->evt_type);

  LOG_VERBOSE("evt_type=0x%x p-cb->evt_type=0x%x ", evt_type,

              btm_cb.ble_ctr_cb.inq_var.evt_type);



  if (new_mode == BTM_BLE_ADV_ENABLE) {

    btm_ble_set_adv_flag(btm_cb.btm_inq_vars.connectable_mode, combined_mode);



    if (evt_type != p_cb->evt_type || p_cb->adv_addr_type != own_addr_type ||

        !p_cb->fast_adv_on) {

    if (evt_type != btm_cb.ble_ctr_cb.inq_var.evt_type ||

        btm_cb.ble_ctr_cb.inq_var.adv_addr_type != own_addr_type ||

        !btm_cb.ble_ctr_cb.inq_var.fast_adv_on) {

      btm_ble_stop_adv();



      /* update adv params */

      btsnd_hcic_ble_write_adv_params(adv_int_min, adv_int_max, evt_type,

                                      own_addr_type, init_addr_type, address,

                                      p_cb->adv_chnl_map, p_cb->afp);

      p_cb->evt_type = evt_type;

      p_cb->adv_addr_type = own_addr_type;

                                      btm_cb.ble_ctr_cb.inq_var.adv_chnl_map,

                                      btm_cb.ble_ctr_cb.inq_var.afp);

      btm_cb.ble_ctr_cb.inq_var.evt_type = evt_type;

      btm_cb.ble_ctr_cb.inq_var.adv_addr_type = own_addr_type;

    }

  }



  if (status == BTM_SUCCESS && p_cb->adv_mode != new_mode) {

  if (status == BTM_SUCCESS && btm_cb.ble_ctr_cb.inq_var.adv_mode != new_mode) {

    if (new_mode == BTM_BLE_ADV_ENABLE)

      status = btm_ble_start_adv();

    else

      status = btm_ble_stop_adv();

  }



  if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {

    p_cb->fast_adv_on = true;

  if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {

    btm_cb.ble_ctr_cb.inq_var.fast_adv_on = true;

    /* start initial GAP mode adv timer */

    alarm_set_on_mloop(p_cb->fast_adv_timer, BTM_BLE_GAP_FAST_ADV_TIMEOUT_MS,

    alarm_set_on_mloop(btm_cb.ble_ctr_cb.inq_var.fast_adv_timer,

                       BTM_BLE_GAP_FAST_ADV_TIMEOUT_MS,

                       btm_ble_fast_adv_timer_timeout, NULL);

  }
@@ -1892,9 +1901,9 @@ tBTM_STATUS btm_ble_set_discoverability(uint16_t combined_mode) { 
    LOG_VERBOSE("start timer for limited disc mode duration=%d ms",

                BTM_BLE_GAP_LIM_TIMEOUT_MS);

    /* start Tgap(lim_timeout) */

    alarm_set_on_mloop(p_cb->inquiry_timer, BTM_BLE_GAP_LIM_TIMEOUT_MS,

                       btm_ble_inquiry_timer_gap_limited_discovery_timeout,

                       NULL);

    alarm_set_on_mloop(

        btm_cb.ble_ctr_cb.inq_var.inquiry_timer, BTM_BLE_GAP_LIM_TIMEOUT_MS,

        btm_ble_inquiry_timer_gap_limited_discovery_timeout, NULL);

  }

  return status;

}
@@ -1912,7 +1921,6 @@ tBTM_STATUS btm_ble_set_discoverability(uint16_t combined_mode) { 
 ******************************************************************************/

tBTM_STATUS btm_ble_set_connectability(uint16_t combined_mode) {

  tBTM_LE_RANDOM_CB* p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;

  uint16_t mode = (combined_mode & BTM_BLE_CONNECTABLE_MASK);

  uint8_t new_mode = BTM_BLE_ADV_ENABLE;

  uint8_t evt_type;
@@ -1928,45 +1936,48 @@ tBTM_STATUS btm_ble_set_connectability(uint16_t combined_mode) { 
  /*** Check mode parameter ***/

  if (mode > BTM_BLE_MAX_CONNECTABLE) return (BTM_ILLEGAL_VALUE);



  p_cb->connectable_mode = mode;

  btm_cb.ble_ctr_cb.inq_var.connectable_mode = mode;



  evt_type =

      btm_set_conn_mode_adv_init_addr(address, &peer_addr_type, &own_addr_type);



  if (mode == BTM_BLE_NON_CONNECTABLE &&

      p_cb->discoverable_mode == BTM_BLE_NON_DISCOVERABLE)

      btm_cb.ble_ctr_cb.inq_var.discoverable_mode == BTM_BLE_NON_DISCOVERABLE)

    new_mode = BTM_BLE_ADV_DISABLE;



  btm_ble_select_adv_interval(evt_type, &adv_int_min, &adv_int_max);



  alarm_cancel(p_cb->fast_adv_timer);

  alarm_cancel(btm_cb.ble_ctr_cb.inq_var.fast_adv_timer);

  /* update adv params if needed */

  if (new_mode == BTM_BLE_ADV_ENABLE) {

    btm_ble_set_adv_flag(combined_mode, btm_cb.btm_inq_vars.discoverable_mode);

    if (p_cb->evt_type != evt_type ||

        p_cb->adv_addr_type != p_addr_cb->own_addr_type || !p_cb->fast_adv_on) {

    if (btm_cb.ble_ctr_cb.inq_var.evt_type != evt_type ||

        btm_cb.ble_ctr_cb.inq_var.adv_addr_type != p_addr_cb->own_addr_type ||

        !btm_cb.ble_ctr_cb.inq_var.fast_adv_on) {

      btm_ble_stop_adv();



      btsnd_hcic_ble_write_adv_params(adv_int_min, adv_int_max, evt_type,

                                      own_addr_type, peer_addr_type, address,

                                      p_cb->adv_chnl_map, p_cb->afp);

      p_cb->evt_type = evt_type;

      p_cb->adv_addr_type = own_addr_type;

                                      btm_cb.ble_ctr_cb.inq_var.adv_chnl_map,

                                      btm_cb.ble_ctr_cb.inq_var.afp);

      btm_cb.ble_ctr_cb.inq_var.evt_type = evt_type;

      btm_cb.ble_ctr_cb.inq_var.adv_addr_type = own_addr_type;

    }

  }



  /* update advertising mode */

  if (status == BTM_SUCCESS && new_mode != p_cb->adv_mode) {

  if (status == BTM_SUCCESS && new_mode != btm_cb.ble_ctr_cb.inq_var.adv_mode) {

    if (new_mode == BTM_BLE_ADV_ENABLE)

      status = btm_ble_start_adv();

    else

      status = btm_ble_stop_adv();

  }



  if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {

    p_cb->fast_adv_on = true;

  if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {

    btm_cb.ble_ctr_cb.inq_var.fast_adv_on = true;

    /* start initial GAP mode adv timer */

    alarm_set_on_mloop(p_cb->fast_adv_timer, BTM_BLE_GAP_FAST_ADV_TIMEOUT_MS,

    alarm_set_on_mloop(btm_cb.ble_ctr_cb.inq_var.fast_adv_timer,

                       BTM_BLE_GAP_FAST_ADV_TIMEOUT_MS,

                       btm_ble_fast_adv_timer_timeout, NULL);

  }

  return status;
@@ -3180,14 +3191,14 @@ static bool btm_ble_adv_states_operation(BTM_TOPOLOGY_FUNC_PTR* p_handler, 
 *

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

static tBTM_STATUS btm_ble_start_adv(void) {

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;



  if (!btm_ble_adv_states_operation(btm_ble_topology_check, p_cb->evt_type))

  if (!btm_ble_adv_states_operation(btm_ble_topology_check,

                                    btm_cb.ble_ctr_cb.inq_var.evt_type))

    return BTM_WRONG_MODE;



  btsnd_hcic_ble_set_adv_enable(BTM_BLE_ADV_ENABLE);

  p_cb->adv_mode = BTM_BLE_ADV_ENABLE;

  btm_ble_adv_states_operation(btm_ble_set_topology_mask, p_cb->evt_type);

  btm_cb.ble_ctr_cb.inq_var.adv_mode = BTM_BLE_ADV_ENABLE;

  btm_ble_adv_states_operation(btm_ble_set_topology_mask,

                               btm_cb.ble_ctr_cb.inq_var.evt_type);

  power_telemetry::GetInstance().LogBleAdvStarted();



  return BTM_SUCCESS;
@@ -3203,13 +3214,11 @@ static tBTM_STATUS btm_ble_start_adv(void) { 
 *

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

static tBTM_STATUS btm_ble_stop_adv(void) {

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;



  if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {

  if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {

    btsnd_hcic_ble_set_adv_enable(BTM_BLE_ADV_DISABLE);



    p_cb->fast_adv_on = false;

    p_cb->adv_mode = BTM_BLE_ADV_DISABLE;

    btm_cb.ble_ctr_cb.inq_var.fast_adv_on = false;

    btm_cb.ble_ctr_cb.inq_var.adv_mode = BTM_BLE_ADV_DISABLE;

    /* clear all adv states */

    btm_ble_clear_topology_mask(BTM_BLE_STATE_ALL_ADV_MASK);

    power_telemetry::GetInstance().LogBleAdvStopped();
@@ -3232,9 +3241,7 @@ static void btm_ble_fast_adv_timer_timeout(UNUSED_ATTR void* data) { 
 *

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

static void btm_ble_start_slow_adv(void) {

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;



  if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE) {

  if (btm_cb.ble_ctr_cb.inq_var.adv_mode == BTM_BLE_ADV_ENABLE) {

    tBTM_LE_RANDOM_CB* p_addr_cb = &btm_cb.ble_ctr_cb.addr_mgnt_cb;

    RawAddress address = RawAddress::kEmpty;

    tBLE_ADDR_TYPE init_addr_type = BLE_ADDR_PUBLIC;
@@ -3242,13 +3249,15 @@ static void btm_ble_start_slow_adv(void) { 


    btm_ble_stop_adv();



    p_cb->evt_type = btm_set_conn_mode_adv_init_addr(address, &init_addr_type,

                                                     &own_addr_type);

    btm_cb.ble_ctr_cb.inq_var.evt_type = btm_set_conn_mode_adv_init_addr(

        address, &init_addr_type, &own_addr_type);



    /* slow adv mode never goes into directed adv */

    btsnd_hcic_ble_write_adv_params(

        BTM_BLE_GAP_ADV_SLOW_INT, BTM_BLE_GAP_ADV_SLOW_INT, p_cb->evt_type,

        own_addr_type, init_addr_type, address, p_cb->adv_chnl_map, p_cb->afp);

        BTM_BLE_GAP_ADV_SLOW_INT, BTM_BLE_GAP_ADV_SLOW_INT,

        btm_cb.ble_ctr_cb.inq_var.evt_type, own_addr_type, init_addr_type,

        address, btm_cb.ble_ctr_cb.inq_var.adv_chnl_map,

        btm_cb.ble_ctr_cb.inq_var.afp);



    btm_ble_start_adv();

  }
@@ -3334,12 +3343,10 @@ err_out: 
 *

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

void btm_ble_write_adv_enable_complete(uint8_t* p, uint16_t evt_len) {

  tBTM_BLE_INQ_CB* p_cb = &btm_cb.ble_ctr_cb.inq_var;



  /* if write adv enable/disbale not succeed */

  if (evt_len < 1 || *p != HCI_SUCCESS) {

    /* toggle back the adv mode */

    p_cb->adv_mode = !p_cb->adv_mode;

    btm_cb.ble_ctr_cb.inq_var.adv_mode = !btm_cb.ble_ctr_cb.inq_var.adv_mode;

  }

}