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

Commit 8069c4bc authored by Chris Manton's avatar Chris Manton
Browse files

tBTM_INQUIRY_VAR_ST:INQ [1-9] Use longform stack::btm 

Bug: 315853986
Test: m .
Flag: EXEMPT, mechanical refactor

Ic22f0d1e71878ebc39e5148fab877d1d881e9a8c
Ifb4be06e4ad4c0f1e327e7b0403780787533492a
I52c71cfe189193a73041bd0d43e5f7708d4f0565
I7b39471e90047cbaf3919fdeb3d1c0f99905b20d
I973af989748f300379df0e96588681b3c3abab8a
I1a664fe86cb40ba1275821b33f1140888b7dc195
Ifec259f101e5a693b306dfcab4abd21b003f4762
I3eb07ee6ea3b4bf94c8443be497ac4b93bedd69a
I7ae397793101e80e428779548561d60b28fde28d

Change-Id: I54d025798739948aef5c546c0b39e60b0766a5bc
parent a433c5aa

system/stack/btm/btm_inq.cc

+89 −93
Original line number Diff line number Diff line
@@ -426,14 +426,14 @@ tBTM_STATUS BTM_SetInquiryMode(uint8_t mode) { 
 ******************************************************************************/

tBTM_STATUS BTM_SetConnectability(uint16_t page_mode) {

  uint8_t scan_mode = 0;

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;



  if (controller_get_interface()->supports_ble()) {

    if (btm_ble_set_connectability(page_mode) != BTM_SUCCESS) {

      return BTM_NO_RESOURCES;

    }

    p_inq->connectable_mode &= (~BTM_BLE_CONNECTABLE_MASK);

    p_inq->connectable_mode |= (page_mode & BTM_BLE_CONNECTABLE_MASK);

    btm_cb.btm_inq_vars.connectable_mode &= (~BTM_BLE_CONNECTABLE_MASK);

    btm_cb.btm_inq_vars.connectable_mode |=

        (page_mode & BTM_BLE_CONNECTABLE_MASK);

  }

  page_mode &= ~BTM_BLE_CONNECTABLE_MASK;
@@ -457,21 +457,21 @@ tBTM_STATUS BTM_SetConnectability(uint16_t page_mode) { 
  LOG_VERBOSE("mode=%d [NonConn-0, Conn-1], page scan interval=(%d * 0.625)ms",

              page_mode, interval);



  if ((window != p_inq->page_scan_window) ||

      (interval != p_inq->page_scan_period)) {

    p_inq->page_scan_window = window;

    p_inq->page_scan_period = interval;

  if ((window != btm_cb.btm_inq_vars.page_scan_window) ||

      (interval != btm_cb.btm_inq_vars.page_scan_period)) {

    btm_cb.btm_inq_vars.page_scan_window = window;

    btm_cb.btm_inq_vars.page_scan_period = interval;

    btsnd_hcic_write_pagescan_cfg(interval, window);

  }



  /* Keep the inquiry scan as previouosly set */

  if (p_inq->discoverable_mode & BTM_DISCOVERABLE_MASK)

  if (btm_cb.btm_inq_vars.discoverable_mode & BTM_DISCOVERABLE_MASK)

    scan_mode |= HCI_INQUIRY_SCAN_ENABLED;



  btm_log_history_scan_mode(scan_mode);

  btsnd_hcic_write_scan_enable(scan_mode);

  p_inq->connectable_mode &= (~BTM_CONNECTABLE_MASK);

  p_inq->connectable_mode |= page_mode;

  btm_cb.btm_inq_vars.connectable_mode &= (~BTM_CONNECTABLE_MASK);

  btm_cb.btm_inq_vars.connectable_mode |= page_mode;

  return (BTM_SUCCESS);

}
@@ -500,7 +500,6 @@ uint16_t BTM_IsInquiryActive(void) { 
 *

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

void BTM_CancelInquiry(void) {

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;

  LOG_VERBOSE("");



  CHECK(BTM_IsDeviceUp());
@@ -528,29 +527,31 @@ void BTM_CancelInquiry(void) { 
          (end_time_ms - btm_cb.neighbor.classic_inquiry.start_time_ms) /

              1000.0,

          btm_cb.neighbor.classic_inquiry.results,

          p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_STANDARD],

          p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_WITH_RSSI],

          p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_EXTENDED]));

          btm_cb.btm_inq_vars.inq_cmpl_info.resp_type[BTM_INQ_RESULT_STANDARD],

          btm_cb.btm_inq_vars.inq_cmpl_info.resp_type[BTM_INQ_RESULT_WITH_RSSI],

          btm_cb.btm_inq_vars.inq_cmpl_info

              .resp_type[BTM_INQ_RESULT_EXTENDED]));

  btm_cb.neighbor.classic_inquiry = {};



  /* Only cancel if not in periodic mode, otherwise the caller should call

   * BTM_CancelPeriodicMode */

  if ((p_inq->inq_active & BTM_INQUIRY_ACTIVE_MASK) != 0) {

    p_inq->inq_active = BTM_INQUIRY_INACTIVE;

    p_inq->state = BTM_INQ_INACTIVE_STATE;

    p_inq->p_inq_results_cb = NULL; /* Do not notify caller anymore */

    p_inq->p_inq_cmpl_cb = NULL;    /* Do not notify caller anymore */



    if ((p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK) != 0) {

  if ((btm_cb.btm_inq_vars.inq_active & BTM_INQUIRY_ACTIVE_MASK) != 0) {

    btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;

    btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;

    btm_cb.btm_inq_vars.p_inq_results_cb =

        NULL;                                 /* Do not notify caller anymore */

    btm_cb.btm_inq_vars.p_inq_cmpl_cb = NULL; /* Do not notify caller anymore */



    if ((btm_cb.btm_inq_vars.inqparms.mode & BTM_BR_INQUIRY_MASK) != 0) {

      bluetooth::legacy::hci::GetInterface().InquiryCancel();

    }



    if (!bluetooth::shim::is_classic_discovery_only_enabled()) {

      if ((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0)

      if ((btm_cb.btm_inq_vars.inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0)

        btm_ble_stop_inquiry();

    }



    p_inq->inq_counter++;

    btm_cb.btm_inq_vars.inq_counter++;

    btm_clr_inq_result_flt();

  }

}
@@ -748,18 +749,16 @@ tBTM_STATUS BTM_ReadRemoteDeviceName(const RawAddress& remote_bda, 
 *

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

tBTM_STATUS BTM_CancelRemoteDeviceName(void) {

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;



  LOG_VERBOSE("");



  /* Make sure there is not already one in progress */

  if (p_inq->remname_active) {

    if (BTM_UseLeLink(p_inq->remname_bda)) {

  if (btm_cb.btm_inq_vars.remname_active) {

    if (BTM_UseLeLink(btm_cb.btm_inq_vars.remname_bda)) {

      /* Cancel remote name request for LE device, and process remote name

       * callback. */

      btm_inq_rmt_name_failed_cancelled();

    } else

      btsnd_hcic_rmt_name_req_cancel(p_inq->remname_bda);

      btsnd_hcic_rmt_name_req_cancel(btm_cb.btm_inq_vars.remname_bda);

    return (BTM_CMD_STARTED);

  } else

    return (BTM_WRONG_MODE);
@@ -854,10 +853,8 @@ tBTM_INQ_INFO* BTM_InqDbNext(tBTM_INQ_INFO* p_cur) { 
 *

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

tBTM_STATUS BTM_ClearInqDb(const RawAddress* p_bda) {

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;



  /* If an inquiry or remote name is in progress return busy */

  if (p_inq->inq_active != BTM_INQUIRY_INACTIVE) return (BTM_BUSY);

  if (btm_cb.btm_inq_vars.inq_active != BTM_INQUIRY_INACTIVE) return (BTM_BUSY);



  btm_clr_inq_db(p_bda);
@@ -908,56 +905,56 @@ void btm_clear_all_pending_le_entry(void) { 
 ******************************************************************************/

void btm_inq_db_reset(void) {

  tBTM_REMOTE_DEV_NAME rem_name = {};

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;

  uint8_t num_responses;

  uint8_t temp_inq_active;



  LOG_DEBUG("Resetting inquiry database");



  /* If an inquiry or periodic inquiry is active, reset the mode to inactive */

  if (p_inq->inq_active != BTM_INQUIRY_INACTIVE) {

    temp_inq_active = p_inq->inq_active; /* Save so state can change BEFORE

  if (btm_cb.btm_inq_vars.inq_active != BTM_INQUIRY_INACTIVE) {

    temp_inq_active =

        btm_cb.btm_inq_vars.inq_active; /* Save so state can change BEFORE

                                  callback is called */

    p_inq->inq_active = BTM_INQUIRY_INACTIVE;

    btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;



    /* If not a periodic inquiry, the complete callback must be called to notify

     * caller */

    if (temp_inq_active == BTM_GENERAL_INQUIRY_ACTIVE) {

      if (p_inq->p_inq_cmpl_cb) {

      if (btm_cb.btm_inq_vars.p_inq_cmpl_cb) {

        num_responses = 0;

        (*p_inq->p_inq_cmpl_cb)(&num_responses);

        (*btm_cb.btm_inq_vars.p_inq_cmpl_cb)(&num_responses);

      }

    }

  }



  /* Cancel a remote name request if active, and notify the caller (if waiting)

   */

  if (p_inq->remname_active) {

    alarm_cancel(p_inq->remote_name_timer);

    p_inq->remname_active = false;

    p_inq->remname_bda = RawAddress::kEmpty;

  if (btm_cb.btm_inq_vars.remname_active) {

    alarm_cancel(btm_cb.btm_inq_vars.remote_name_timer);

    btm_cb.btm_inq_vars.remname_active = false;

    btm_cb.btm_inq_vars.remname_bda = RawAddress::kEmpty;



    if (p_inq->p_remname_cmpl_cb) {

    if (btm_cb.btm_inq_vars.p_remname_cmpl_cb) {

      rem_name.status = BTM_DEV_RESET;

      rem_name.hci_status = HCI_SUCCESS;



      (*p_inq->p_remname_cmpl_cb)(&rem_name);

      p_inq->p_remname_cmpl_cb = NULL;

      (*btm_cb.btm_inq_vars.p_remname_cmpl_cb)(&rem_name);

      btm_cb.btm_inq_vars.p_remname_cmpl_cb = NULL;

    }

  }



  p_inq->state = BTM_INQ_INACTIVE_STATE;

  p_inq->p_inq_results_cb = NULL;

  btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;

  btm_cb.btm_inq_vars.p_inq_results_cb = NULL;

  btm_clr_inq_db(NULL); /* Clear out all the entries in the database */

  btm_clr_inq_result_flt();



  p_inq->discoverable_mode = BTM_NON_DISCOVERABLE;

  p_inq->connectable_mode = BTM_NON_CONNECTABLE;

  p_inq->page_scan_type = BTM_SCAN_TYPE_STANDARD;

  p_inq->inq_scan_type = BTM_SCAN_TYPE_STANDARD;

  btm_cb.btm_inq_vars.discoverable_mode = BTM_NON_DISCOVERABLE;

  btm_cb.btm_inq_vars.connectable_mode = BTM_NON_CONNECTABLE;

  btm_cb.btm_inq_vars.page_scan_type = BTM_SCAN_TYPE_STANDARD;

  btm_cb.btm_inq_vars.inq_scan_type = BTM_SCAN_TYPE_STANDARD;



  p_inq->discoverable_mode |= BTM_BLE_NON_DISCOVERABLE;

  p_inq->connectable_mode |= BTM_BLE_NON_CONNECTABLE;

  btm_cb.btm_inq_vars.discoverable_mode |= BTM_BLE_NON_DISCOVERABLE;

  btm_cb.btm_inq_vars.connectable_mode |= BTM_BLE_NON_CONNECTABLE;

  return;

}
@@ -1235,8 +1232,7 @@ void btm_process_inq_results(const uint8_t* p, uint8_t hci_evt_len, 
  bool is_new = true;

  bool update = false;

  int8_t i_rssi;

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;

  tBTM_INQ_RESULTS_CB* p_inq_results_cb = p_inq->p_inq_results_cb;

  tBTM_INQ_RESULTS_CB* p_inq_results_cb = btm_cb.btm_inq_vars.p_inq_results_cb;

  uint8_t page_scan_rep_mode = 0;

  uint8_t page_scan_per_mode = 0;

  uint8_t page_scan_mode = 0;
@@ -1249,7 +1245,7 @@ void btm_process_inq_results(const uint8_t* p, uint8_t hci_evt_len, 
            btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);



  /* Only process the results if the BR inquiry is still active */

  if (!(p_inq->inq_active & BTM_BR_INQ_ACTIVE_MASK)) {

  if (!(btm_cb.btm_inq_vars.inq_active & BTM_BR_INQ_ACTIVE_MASK)) {

    LOG_INFO("Inquiry is inactive so dropping inquiry result");

    return;

  }
@@ -1341,7 +1337,7 @@ void btm_process_inq_results(const uint8_t* p, uint8_t hci_evt_len, 
       same

       inquiry.

    */

    else if (p_i->inq_count == p_inq->inq_counter &&

    else if (p_i->inq_count == btm_cb.btm_inq_vars.inq_counter &&

             (p_i->inq_info.results.device_type == BT_DEVICE_TYPE_BREDR))

      is_new = false;
@@ -1364,7 +1360,7 @@ void btm_process_inq_results(const uint8_t* p, uint8_t hci_evt_len, 


      p_i->time_of_resp = bluetooth::common::time_get_os_boottime_ms();



      if (p_i->inq_count != p_inq->inq_counter) {

      if (p_i->inq_count != btm_cb.btm_inq_vars.inq_counter) {

        /* A new response was found */

        btm_cb.btm_inq_vars.inq_cmpl_info.num_resp++;

        switch (static_cast<tBTM_INQ_RESULT>(inq_res_mode)) {
@@ -1381,12 +1377,13 @@ void btm_process_inq_results(const uint8_t* p, uint8_t hci_evt_len, 
      }



      p_cur->inq_result_type |= BTM_INQ_RESULT_BR;

      if (p_i->inq_count != p_inq->inq_counter) {

      if (p_i->inq_count != btm_cb.btm_inq_vars.inq_counter) {

        p_cur->device_type = BT_DEVICE_TYPE_BREDR;

        p_i->scan_rsp = false;

      } else

        p_cur->device_type |= BT_DEVICE_TYPE_BREDR;

      p_i->inq_count = p_inq->inq_counter; /* Mark entry for current inquiry */

      p_i->inq_count =

          btm_cb.btm_inq_vars.inq_counter; /* Mark entry for current inquiry */



      /* Initialize flag to false. This flag is set/used by application */

      p_i->inq_info.appl_knows_rem_name = false;
@@ -1465,10 +1462,8 @@ void btm_sort_inq_result(void) { 
 *

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

void btm_process_inq_complete(tHCI_STATUS status, uint8_t mode) {

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;



  p_inq->inqparms.mode &= ~(mode);

  const auto inq_active = p_inq->inq_active;

  btm_cb.btm_inq_vars.inqparms.mode &= ~(mode);

  const auto inq_active = btm_cb.btm_inq_vars.inq_active;



  btm_acl_update_inquiry_status(BTM_INQUIRY_COMPLETE);
@@ -1478,17 +1473,17 @@ void btm_process_inq_complete(tHCI_STATUS status, uint8_t mode) { 
  }



  /* Ignore any stray or late complete messages if the inquiry is not active */

  if (p_inq->inq_active) {

    p_inq->inq_cmpl_info.hci_status = status;

  if (btm_cb.btm_inq_vars.inq_active) {

    btm_cb.btm_inq_vars.inq_cmpl_info.hci_status = status;



    /* Notify caller that the inquiry has completed; (periodic inquiries do not

     * send completion events */

    if (p_inq->inqparms.mode == 0) {

    if (btm_cb.btm_inq_vars.inqparms.mode == 0) {

      btm_clear_all_pending_le_entry();

      p_inq->state = BTM_INQ_INACTIVE_STATE;

      btm_cb.btm_inq_vars.state = BTM_INQ_INACTIVE_STATE;



      /* Increment so the start of a next inquiry has a new count */

      p_inq->inq_counter++;

      btm_cb.btm_inq_vars.inq_counter++;



      btm_clr_inq_result_flt();
@@ -1499,7 +1494,7 @@ void btm_process_inq_complete(tHCI_STATUS status, uint8_t mode) { 


      if (btm_cb.btm_inq_vars.p_inq_cmpl_cb) {

        (btm_cb.btm_inq_vars.p_inq_cmpl_cb)(

            (tBTM_INQUIRY_CMPL*)&p_inq->inq_cmpl_info);

            (tBTM_INQUIRY_CMPL*)&btm_cb.btm_inq_vars.inq_cmpl_info);

      } else {

        LOG_WARN("No callback to return inquiry result");

      }
@@ -1527,16 +1522,19 @@ void btm_process_inq_complete(tHCI_STATUS status, uint8_t mode) { 
              (end_time_ms - btm_cb.neighbor.classic_inquiry.start_time_ms) /

                  1000.0,

              btm_cb.neighbor.classic_inquiry.results, inq_active,

              p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_STANDARD],

              p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_WITH_RSSI],

              p_inq->inq_cmpl_info.resp_type[BTM_INQ_RESULT_EXTENDED],

              btm_cb.btm_inq_vars.inq_cmpl_info

                  .resp_type[BTM_INQ_RESULT_STANDARD],

              btm_cb.btm_inq_vars.inq_cmpl_info

                  .resp_type[BTM_INQ_RESULT_WITH_RSSI],

              btm_cb.btm_inq_vars.inq_cmpl_info

                  .resp_type[BTM_INQ_RESULT_EXTENDED],

              hci_error_code_text(status).c_str()));



      btm_cb.neighbor.classic_inquiry.start_time_ms = 0;

      /* Clear the results callback if set */

      p_inq->p_inq_results_cb = NULL;

      p_inq->inq_active = BTM_INQUIRY_INACTIVE;

      p_inq->p_inq_cmpl_cb = NULL;

      btm_cb.btm_inq_vars.p_inq_results_cb = NULL;

      btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;

      btm_cb.btm_inq_vars.p_inq_cmpl_cb = NULL;



    } else {

      LOG_INFO(
@@ -1588,20 +1586,18 @@ void btm_process_cancel_complete(tHCI_STATUS status, uint8_t mode) { 
tBTM_STATUS btm_initiate_rem_name(const RawAddress& remote_bda, uint8_t origin,

                                  uint64_t timeout_ms,

                                  tBTM_NAME_CMPL_CB* p_cb) {

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;



  /*** Make sure the device is ready ***/

  if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE);

  if (origin == BTM_RMT_NAME_EXT) {

    if (p_inq->remname_active) {

    if (btm_cb.btm_inq_vars.remname_active) {

      return (BTM_BUSY);

    } else {

      /* If there is no remote name request running,call the callback function

       * and start timer */

      p_inq->p_remname_cmpl_cb = p_cb;

      p_inq->remname_bda = remote_bda;

      btm_cb.btm_inq_vars.p_remname_cmpl_cb = p_cb;

      btm_cb.btm_inq_vars.remname_bda = remote_bda;



      alarm_set_on_mloop(p_inq->remote_name_timer, timeout_ms,

      alarm_set_on_mloop(btm_cb.btm_inq_vars.remote_name_timer, timeout_ms,

                         btm_inq_remote_name_timer_timeout, NULL);



      /* If the database entry exists for the device, use its clock offset */
@@ -1630,7 +1626,7 @@ tBTM_STATUS btm_initiate_rem_name(const RawAddress& remote_bda, uint8_t origin, 
                                HCI_MANDATARY_PAGE_SCAN_MODE, clock_offset);

      }



      p_inq->remname_active = true;

      btm_cb.btm_inq_vars.remname_active = true;

      return BTM_CMD_STARTED;

    }

  } else {
@@ -1652,8 +1648,7 @@ tBTM_STATUS btm_initiate_rem_name(const RawAddress& remote_bda, uint8_t origin, 
void btm_process_remote_name(const RawAddress* bda, const BD_NAME bdn,

                             uint16_t evt_len, tHCI_STATUS hci_status) {

  tBTM_REMOTE_DEV_NAME rem_name;

  tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;

  tBTM_NAME_CMPL_CB* p_cb = p_inq->p_remname_cmpl_cb;

  tBTM_NAME_CMPL_CB* p_cb = btm_cb.btm_inq_vars.p_remname_cmpl_cb;

  uint8_t* p_n1;



  uint16_t temp_evt_len;
@@ -1667,17 +1662,18 @@ void btm_process_remote_name(const RawAddress* bda, const BD_NAME bdn, 
  LOG_INFO("btm_process_remote_name for %s",

           ADDRESS_TO_LOGGABLE_CSTR(rem_name.bd_addr));



  VLOG(2) << "Inquire BDA " << p_inq->remname_bda;

  VLOG(2) << "Inquire BDA " << btm_cb.btm_inq_vars.remname_bda;



  /* If the inquire BDA and remote DBA are the same, then stop the timer and set

   * the active to false */

  if ((p_inq->remname_active) && (!bda || (*bda == p_inq->remname_bda))) {

    if (BTM_UseLeLink(p_inq->remname_bda)) {

  if ((btm_cb.btm_inq_vars.remname_active) &&

      (!bda || (*bda == btm_cb.btm_inq_vars.remname_bda))) {

    if (BTM_UseLeLink(btm_cb.btm_inq_vars.remname_bda)) {

      if (hci_status == HCI_ERR_UNSPECIFIED)

        btm_ble_cancel_remote_name(p_inq->remname_bda);

        btm_ble_cancel_remote_name(btm_cb.btm_inq_vars.remname_bda);

    }

    alarm_cancel(p_inq->remote_name_timer);

    p_inq->remname_active = false;

    alarm_cancel(btm_cb.btm_inq_vars.remote_name_timer);

    btm_cb.btm_inq_vars.remname_active = false;

    /* Clean up and return the status if the command was not successful */

    /* Note: If part of the inquiry, the name is not stored, and the    */

    /*       inquiry complete callback is called.                       */
@@ -1707,9 +1703,9 @@ void btm_process_remote_name(const RawAddress* bda, const BD_NAME bdn, 
      rem_name.remote_bd_name[0] = 0;

    }

    /* Reset the remote BAD to zero and call callback if possible */

    p_inq->remname_bda = RawAddress::kEmpty;

    btm_cb.btm_inq_vars.remname_bda = RawAddress::kEmpty;



    p_inq->p_remname_cmpl_cb = NULL;

    btm_cb.btm_inq_vars.p_remname_cmpl_cb = NULL;

    if (p_cb) (p_cb)(&rem_name);

  }

}