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

Commit 9d43fa94 authored by Zach Johnson's avatar Zach Johnson Committed by Gerrit Code Review
Browse files

Merge changes I3fc119b0,I94961f9f,Ic8a86d7a,Iec1e469b,Ic510bf88, ... 

* changes:
  Factor BTA_SYS_PLCY_DEF_CLR into its own function
  Factor BTA_SYS_PLCY_DEF_SET into its own function
  Factor BTA_SYS_PLCY_CLR into its own function
  Factor BTA_SYS_PLCY_SET into its own function
  remove p_policy_cb, call into bta_dm directly
  Remove BTA_DM_LP*
  BTA_SYS_EVT_DISABLED_EVT only ever comes in the HW_STOPPING state
  Make BTA_dm_sys_hw_cback just about hw on
  Pull hw off out of BTA_dm_sys_hw_cback
  Pull hardware errors out of BTA_dm_sys_hw_cback
  bta_sys_hw_evt_stack_enabled -> direct call
  bta_sys_hw_evt_disabled -> direct call
  Call BTA_dm_sys_hw_cback directly
  Remove indirection for reporting hardware events
  Don't use event indirection for bta sys hw events
parents 63707dac 4ff7a01d

system/bta/dm/bta_dm_act.cc

+122 −179
Original line number Diff line number Diff line
@@ -82,7 +82,7 @@ static uint8_t bta_dm_authentication_complete_cback(const RawAddress& bd_addr, 
static void bta_dm_local_name_cback(void* p_name);

static bool bta_dm_check_av(uint16_t event);



static void bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,

void BTA_dm_update_policy(tBTA_SYS_CONN_STATUS status, uint8_t id,

                          uint8_t app_id, const RawAddress& peer_addr);



/* Extended Inquiry Response */
@@ -106,7 +106,6 @@ static bool bta_dm_read_remote_device_name(const RawAddress& bd_addr, 
                                           tBT_TRANSPORT transport);

static void bta_dm_discover_device(const RawAddress& remote_bd_addr);



static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status);

static void bta_dm_disable_search_and_disc(void);



static uint8_t bta_dm_ble_smp_cback(tBTM_LE_EVT event, const RawAddress& bda,
@@ -118,7 +117,6 @@ static void btm_dm_start_gatt_discovery(const RawAddress& bd_addr); 
static void bta_dm_cancel_gatt_discovery(const RawAddress& bd_addr);

static void bta_dm_gattc_callback(tBTA_GATTC_EVT event, tBTA_GATTC* p_data);

extern tBTA_DM_CONTRL_STATE bta_dm_pm_obtain_controller_state(void);



#if (BLE_VND_INCLUDED == TRUE)

static void bta_dm_ctrl_features_rd_cmpl_cback(tBTM_STATUS result);

#endif
@@ -261,9 +259,6 @@ void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback) { 
    return;

  }



  /* first, register our callback to SYS HW manager */

  bta_sys_hw_register(bta_dm_sys_hw_cback);



  /* make sure security callback is saved - if no callback, do not erase the

  previous one,

  it could be an error recovery mechanism */
@@ -271,12 +266,7 @@ void bta_dm_enable(tBTA_DM_SEC_CBACK* p_sec_cback) { 
  /* notify BTA DM is now active */

  bta_dm_cb.is_bta_dm_active = true;



  /* send a message to BTA SYS */

  tBTA_SYS_HW_MSG* sys_enable_event =

      (tBTA_SYS_HW_MSG*)osi_malloc(sizeof(tBTA_SYS_HW_MSG));

  sys_enable_event->hdr.event = BTA_SYS_API_ENABLE_EVT;



  bta_sys_sendmsg(sys_enable_event);

  send_bta_sys_hw_event(BTA_SYS_API_ENABLE_EVT);



  btm_local_io_caps = btif_storage_get_local_io_caps();

}
@@ -327,32 +317,13 @@ void bta_dm_deinit_cb(void) { 
  memset(&bta_dm_cb, 0, sizeof(bta_dm_cb));

}



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

 *

 * Function         bta_dm_sys_hw_cback

 *

 * Description     callback register to SYS to get HW status updates

 *

 *

 * Returns          void

 *

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

static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status) {

  DEV_CLASS dev_class;

  tBTA_DM_SEC_CBACK* temp_cback;

  uint8_t key_mask = 0;

  tBTA_BLE_LOCAL_ID_KEYS id_key;



  APPL_TRACE_DEBUG("%s with event: %i", __func__, status);



  /* On H/W error evt, report to the registered DM application callback */

  if (status == BTA_SYS_HW_ERROR_EVT) {

    if (bta_dm_cb.p_sec_cback != NULL)

void BTA_dm_on_hw_error() {

  if (bta_dm_cb.p_sec_cback != NULL) {

    bta_dm_cb.p_sec_cback(BTA_DM_HW_ERROR_EVT, NULL);

    return;

  }

}



  if (status == BTA_SYS_HW_OFF_EVT) {

void BTA_dm_on_hw_off() {

  if (bta_dm_cb.p_sec_cback != NULL)

    bta_dm_cb.p_sec_cback(BTA_DM_DISABLE_EVT, NULL);
@@ -364,11 +335,16 @@ static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status) { 
  alarm_free(bta_dm_search_cb.gatt_close_timer);

  memset(&bta_dm_search_cb, 0, sizeof(bta_dm_search_cb));



    /* unregister from SYS */

    bta_sys_hw_unregister();

  /* notify BTA DM is now unactive */

  bta_dm_cb.is_bta_dm_active = false;

  } else if (status == BTA_SYS_HW_ON_EVT) {

}



void BTA_dm_on_hw_on() {

  DEV_CLASS dev_class;

  tBTA_DM_SEC_CBACK* temp_cback;

  uint8_t key_mask = 0;

  tBTA_BLE_LOCAL_ID_KEYS id_key;



  /* save security callback */

  temp_cback = bta_dm_cb.p_sec_cback;

  /* make sure the control block is properly initialized */
@@ -400,8 +376,7 @@ static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status) { 
  bta_dm_co_ble_load_local_keys(&key_mask, &er, &id_key);



  if (key_mask & BTA_BLE_LOCAL_KEY_TYPE_ER) {

      BTM_BleLoadLocalKeys(BTA_BLE_LOCAL_KEY_TYPE_ER,

                           (tBTM_BLE_LOCAL_KEYS*)&er);

    BTM_BleLoadLocalKeys(BTA_BLE_LOCAL_KEY_TYPE_ER, (tBTM_BLE_LOCAL_KEYS*)&er);

  }

  if (key_mask & BTA_BLE_LOCAL_KEY_TYPE_ID) {

    BTM_BleLoadLocalKeys(BTA_BLE_LOCAL_KEY_TYPE_ID,
@@ -419,7 +394,7 @@ static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status) { 
  BTM_BleReadControllerFeatures(bta_dm_ctrl_features_rd_cmpl_cback);

#else

  /* If VSC multi adv commands are available, advertising will be initialized

     * when capabilities are read. If they are not avaliable, initialize

   * when capabilities are read. If they are not available, initialize

   * advertising here */

  btm_ble_adv_init();

#endif
@@ -441,12 +416,7 @@ static void bta_dm_sys_hw_cback(tBTA_SYS_HW_EVT status) { 
  /* initialize bluetooth low power manager */

  bta_dm_init_pm();



    bta_sys_policy_register(bta_dm_policy_cback);



  bta_dm_gattc_register();



  } else

    APPL_TRACE_DEBUG(" --- ignored event");

}



/** Disables the BT device manager */
@@ -857,36 +827,20 @@ void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg) { 
  }

}



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

 *

 * Function         bta_dm_policy_cback

 *

 * Description      process the link policy changes

 *

 * Returns          void

 *

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

static void bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,

                                uint8_t app_id, const RawAddress& peer_addr) {

  tBTA_DM_PEER_DEVICE* p_dev = NULL;

  uint16_t policy = app_id;

  uint32_t mask = (uint32_t)(1 << id);



  if (peer_addr != RawAddress::kEmpty) {

    p_dev = bta_dm_find_peer_device(peer_addr);

void BTA_dm_set_policy(uint8_t policy, const RawAddress& peer_addr) {

  auto p_dev = bta_dm_find_peer_device(peer_addr);

  if (!p_dev) {

    return;

  }



  APPL_TRACE_DEBUG(" bta_dm_policy_cback cmd:%d, policy:0x%x", status, policy);

  switch (status) {

    case BTA_SYS_PLCY_SET:

      if (!p_dev) return;

      /* restore the default link policy */

  p_dev->link_policy |= policy;

  BTM_SetLinkPolicy(p_dev->peer_bdaddr, &(p_dev->link_policy));

      break;

}



    case BTA_SYS_PLCY_CLR:

      if (!p_dev) return;

void BTA_dm_clear_policy(uint8_t policy, const RawAddress& peer_addr) {

  auto p_dev = bta_dm_find_peer_device(peer_addr);

  if (!p_dev) {

    return;

  }

  /* clear the policy from the default link policy */

  p_dev->link_policy &= (~policy);

  BTM_SetLinkPolicy(p_dev->peer_bdaddr, &(p_dev->link_policy));
@@ -895,25 +849,23 @@ static void bta_dm_policy_cback(tBTA_SYS_CONN_STATUS status, uint8_t id, 
    /* if clearing sniff/park, wake the link */

    bta_dm_pm_active(p_dev->peer_bdaddr);

  }

      break;

}



    case BTA_SYS_PLCY_DEF_SET:

      /* want to restore/set the role switch policy */

void BTA_dm_set_default_policy(uint8_t app_id) {

  uint32_t mask = (uint32_t)(1 << app_id);

  bta_dm_cb.role_policy_mask &= ~mask;

  if (0 == bta_dm_cb.role_policy_mask) {

    /* if nobody wants to insist on the role */

    bta_dm_cb.cur_policy |= HCI_ENABLE_MASTER_SLAVE_SWITCH;

    BTM_SetDefaultLinkPolicy(bta_dm_cb.cur_policy);

  }

      break;

}



    case BTA_SYS_PLCY_DEF_CLR:

      /* want to remove the role switch policy */

void BTA_dm_clear_default_policy(uint8_t app_id) {

  uint32_t mask = (uint32_t)(1 << app_id);

  bta_dm_cb.role_policy_mask |= mask;

  bta_dm_cb.cur_policy &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;

  BTM_SetDefaultLinkPolicy(bta_dm_cb.cur_policy);

      break;

  }

}



/** Send the user confirm request reply in response to a request from BTM */
@@ -2603,8 +2555,7 @@ static void handle_role_change(const RawAddress& bd_addr, uint8_t new_role, 
    }



    if (need_policy_change) {

      bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH,

                          p_dev->peer_bdaddr);

      BTA_dm_clear_policy(HCI_ENABLE_MASTER_SLAVE_SWITCH, p_dev->peer_bdaddr);

    }

  } else {

    /* there's AV no activity on this link and role switch happened
@@ -2833,8 +2784,7 @@ static bool bta_dm_check_av(uint16_t event) { 
          switching = true;

        }

        /* else either already master or can not switch for some reasons */

        bta_dm_policy_cback(BTA_SYS_PLCY_CLR, 0, HCI_ENABLE_MASTER_SLAVE_SWITCH,

                            p_dev->peer_bdaddr);

        BTA_dm_clear_policy(HCI_ENABLE_MASTER_SLAVE_SWITCH, p_dev->peer_bdaddr);

        break;

      }

    }
@@ -2853,18 +2803,11 @@ static bool bta_dm_check_av(uint16_t event) { 
 *

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

static void bta_dm_disable_conn_down_timer_cback(UNUSED_ATTR void* data) {

  tBTA_SYS_HW_MSG* sys_enable_event =

      (tBTA_SYS_HW_MSG*)osi_malloc(sizeof(tBTA_SYS_HW_MSG));



  /* disable the power managment module */

  bta_dm_disable_pm();



  /* register our callback to SYS HW manager */

  bta_sys_hw_register(bta_dm_sys_hw_cback);



  /* send a message to BTA SYS */

  sys_enable_event->hdr.event = BTA_SYS_API_DISABLE_EVT;

  bta_sys_sendmsg(sys_enable_event);

  send_bta_sys_hw_event(BTA_SYS_API_DISABLE_EVT);



  bta_dm_cb.disabling = false;

}

system/bta/include/bta_api.h

+0 −7
Original line number Diff line number Diff line
@@ -759,13 +759,6 @@ typedef void(tBTA_BLE_ENERGY_INFO_CBACK)(tBTM_BLE_TX_TIME_MS tx_time, 
#define BTA_SERVICE_DESP_LEN BTA_SERVICE_NAME_LEN

#define BTA_PROVIDER_NAME_LEN BTA_SERVICE_NAME_LEN



/* link policy masks  */

#define BTA_DM_LP_SWITCH HCI_ENABLE_MASTER_SLAVE_SWITCH

#define BTA_DM_LP_HOLD HCI_ENABLE_HOLD_MODE

#define BTA_DM_LP_SNIFF HCI_ENABLE_SNIFF_MODE

#define BTA_DM_LP_PARK HCI_ENABLE_PARK_MODE

typedef uint16_t tBTA_DM_LP_MASK;



/* power mode actions  */

#define BTA_DM_PM_NO_ACTION 0x00 /* no change to the current pm setting */

#define BTA_DM_PM_PARK 0x10      /* prefers park mode */

system/bta/sys/bta_sys.h

+1 −27
Original line number Diff line number Diff line
@@ -110,11 +110,6 @@ typedef uint8_t tBTA_SYS_ID; 
#define BTA_SYS_CONN_IDLE 0x06

#define BTA_SYS_CONN_BUSY 0x07



/* for link policy */

#define BTA_SYS_PLCY_SET 0x10     /* set the link policy to the given addr */

#define BTA_SYS_PLCY_CLR 0x11     /* clear the link policy to the given addr */

#define BTA_SYS_PLCY_DEF_SET 0x12 /* set the default link policy */

#define BTA_SYS_PLCY_DEF_CLR 0x13 /* clear the default link policy */

#define BTA_SYS_ROLE_CHANGE 0x14  /* role change */



typedef uint8_t tBTA_SYS_CONN_STATUS;
@@ -145,11 +140,6 @@ typedef struct { 
  tBTA_SYS_DISABLE* disable;

} tBTA_SYS_REG;



/* data type to send events to BTA SYS HW manager */

typedef struct {

  BT_HDR hdr;

} tBTA_SYS_HW_MSG;



typedef void (*tBTA_SYS_REGISTER)(uint8_t id, const tBTA_SYS_REG* p_reg);



/*****************************************************************************
@@ -177,26 +167,12 @@ enum { 
  BTA_SYS_API_ENABLE_EVT = BTA_SYS_EVT_START(BTA_ID_SYS),

  BTA_SYS_EVT_STACK_ENABLED_EVT,

  BTA_SYS_API_DISABLE_EVT,

  BTA_SYS_EVT_DISABLED_EVT,

  BTA_SYS_ERROR_EVT,



  BTA_SYS_MAX_EVT

};



/* SYS HW status events - returned by SYS HW manager to other modules. */

enum {

  BTA_SYS_HW_OFF_EVT,

  BTA_SYS_HW_ON_EVT,

  BTA_SYS_HW_STARTING_EVT,

  BTA_SYS_HW_STOPPING_EVT,

  BTA_SYS_HW_ERROR_EVT



};

typedef uint8_t tBTA_SYS_HW_EVT;



/* HW enable callback type */

typedef void(tBTA_SYS_HW_CBACK)(tBTA_SYS_HW_EVT status);



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

 *  Function declarations

 ****************************************************************************/
@@ -208,15 +184,13 @@ extern void bta_sys_set_trace_level(uint8_t level); 
extern void bta_sys_register(uint8_t id, const tBTA_SYS_REG* p_reg);

extern void bta_sys_deregister(uint8_t id);

extern bool bta_sys_is_register(uint8_t id);

extern void send_bta_sys_hw_event(tBTA_SYS_HW_EVT event);

extern void bta_sys_sendmsg(void* p_msg);

extern void bta_sys_sendmsg_delayed(void* p_msg, const base::TimeDelta& delay);

extern void bta_sys_start_timer(alarm_t* alarm, uint64_t interval_ms,

                                uint16_t event, uint16_t layer_specific);

extern void bta_sys_disable();



extern void bta_sys_hw_register(tBTA_SYS_HW_CBACK* cback);

extern void bta_sys_hw_unregister();



extern void bta_sys_rm_register(tBTA_SYS_CONN_CBACK* p_cback);

extern void bta_sys_pm_register(tBTA_SYS_CONN_CBACK* p_cback);

system/bta/sys/bta_sys_conn.cc

+9 −28
Original line number Diff line number Diff line
@@ -31,6 +31,11 @@ 
#include "osi/include/osi.h"

#include "utl.h"



void BTA_dm_set_policy(uint8_t policy, const RawAddress& peer_addr);

void BTA_dm_clear_policy(uint8_t policy, const RawAddress& peer_addr);

void BTA_dm_set_default_policy(uint8_t app_id);

void BTA_dm_clear_default_policy(uint8_t app_id);



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

 *

 * Function         bta_sys_rm_register
@@ -45,20 +50,6 @@ void bta_sys_rm_register(tBTA_SYS_CONN_CBACK* p_cback) { 
  bta_sys_cb.prm_cb = p_cback;

}



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

 *

 * Function         bta_sys_policy_register

 *

 * Description      Called by BTA DM to register link policy change callbacks

 *

 *

 * Returns          void

 *

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

void bta_sys_policy_register(tBTA_SYS_CONN_CBACK* p_cback) {

  bta_sys_cb.p_policy_cb = p_cback;

}



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

 *

 * Function         bta_sys_role_chg_register
@@ -370,9 +361,7 @@ void bta_sys_set_policy(uint8_t id, uint8_t policy, 
                        const RawAddress& peer_addr) {

  APPL_TRACE_DEBUG("%s: peer %s id:%d policy:0x%x", __func__,

                   peer_addr.ToString().c_str(), id, policy);

  if (bta_sys_cb.p_policy_cb) {

    bta_sys_cb.p_policy_cb(BTA_SYS_PLCY_SET, id, policy, peer_addr);

  }

  BTA_dm_set_policy(policy, peer_addr);

}



/*******************************************************************************
@@ -389,9 +378,7 @@ void bta_sys_clear_policy(uint8_t id, uint8_t policy, 
                          const RawAddress& peer_addr) {

  APPL_TRACE_DEBUG("%s: peer %s id:%d policy:0x%x", __func__,

                   peer_addr.ToString().c_str(), id, policy);

  if (bta_sys_cb.p_policy_cb) {

    bta_sys_cb.p_policy_cb(BTA_SYS_PLCY_CLR, id, policy, peer_addr);

  }

  BTA_dm_clear_policy(policy, peer_addr);

}



/*******************************************************************************
@@ -406,10 +393,7 @@ void bta_sys_clear_policy(uint8_t id, uint8_t policy, 
 ******************************************************************************/

void bta_sys_set_default_policy(uint8_t id, uint8_t policy) {

  APPL_TRACE_DEBUG("%s: id:%d policy:0x%x", __func__, id, policy);

  if (bta_sys_cb.p_policy_cb) {

    bta_sys_cb.p_policy_cb(BTA_SYS_PLCY_DEF_SET, id, policy,

                           RawAddress::kEmpty);

  }

  BTA_dm_set_default_policy(id);

}



/*******************************************************************************
@@ -424,10 +408,7 @@ void bta_sys_set_default_policy(uint8_t id, uint8_t policy) { 
 ******************************************************************************/

void bta_sys_clear_default_policy(uint8_t id, uint8_t policy) {

  APPL_TRACE_DEBUG("%s: id:%d policy:0x%x", __func__, id, policy);

  if (bta_sys_cb.p_policy_cb) {

    bta_sys_cb.p_policy_cb(BTA_SYS_PLCY_DEF_CLR, id, policy,

                           RawAddress::kEmpty);

  }

  BTA_dm_clear_default_policy(id);

}



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

system/bta/sys/bta_sys_int.h

+0 −8
Original line number Diff line number Diff line
@@ -54,15 +54,12 @@ typedef struct { 
  tBTA_SYS_REG* reg[BTA_ID_MAX]; /* registration structures */

  bool is_reg[BTA_ID_MAX];       /* registration structures */

  tBTA_SYS_HW_STATE state;

  tBTA_SYS_HW_CBACK* sys_hw_cback;

  bool bluetooth_active;

  uint16_t sys_features;         /* Bitmask of sys features */



  tBTA_SYS_CONN_CBACK* prm_cb; /* role management callback registered by DM */

  tBTA_SYS_CONN_CBACK*

      ppm_cb; /* low power management callback registered by DM */

  tBTA_SYS_CONN_CBACK*

      p_policy_cb; /* link policy change callback registered by DM */

  tBTA_SYS_CONN_CBACK*

      p_sco_cb; /* SCO connection change callback registered by AV */

  tBTA_SYS_CONN_CBACK* p_role_cb; /* role change callback registered by AV */
@@ -86,14 +83,9 @@ typedef struct { 
extern tBTA_SYS_CB bta_sys_cb;



/* functions used for BTA SYS HW state machine */

void bta_sys_hw_btm_cback(tBTM_DEV_STATUS status);

void bta_sys_hw_error();

void bta_sys_hw_api_enable();

void bta_sys_hw_api_disable();

void bta_sys_hw_evt_enabled();

void bta_sys_hw_evt_disabled();

void bta_sys_hw_evt_stack_enabled();



bool bta_sys_sm_execute(BT_HDR* p_msg);



#endif /* BTA_SYS_INT_H */