Merge changes I228ee25f,I85914c62,I3a5c970d,I5f54b858,I6a885f21, ... (910e5990) · Commits · e / os / android_packages_modules_Bluetooth

system/main/shim/btm_api.cc

+1 −2

Original line number	Diff line number	Diff line
		@@ -165,7 +165,7 @@ void btm_api_process_inquiry_result_with_rssi(RawAddress raw_address,

		bool update = false;
		if (btm_inq_find_bdaddr(raw_address)) {
		if (btm_cb.btm_inq_vars.inqparms.report_dup && p_i != nullptr &&
		if (p_i != nullptr &&
		(rssi > p_i->inq_info.results.rssi \|\| p_i->inq_info.results.rssi == 0 \|\|
		has_classic_device(p_i->inq_info.results.device_type))) {
		update = true;
		@@ -291,7 +291,6 @@ tBTM_STATUS bluetooth::shim::BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,
		inqparms.duration = BTIF_DM_DEFAULT_INQ_MAX_DURATION;

		inqparms.max_resps = BTIF_DM_DEFAULT_INQ_MAX_RESULTS;
		inqparms.report_dup = true;

		std::lock_guard<std::mutex> lock(btm_cb_mutex_);

system/stack/btm/btm_inq.cc

+24 −205

Original line number	Diff line number	Diff line
		@@ -118,8 +118,7 @@ const uint16_t BTM_EIR_UUID_LKUP_TBL[BTM_EIR_MAX_SERVICES] = {
		/******************************************************************************/
		/* L O C A L F U N C T I O N P R O T O T Y P E S */
		/******************************************************************************/
		static void btm_initiate_inquiry(tBTM_INQUIRY_VAR_ST* p_inq);
		static tBTM_STATUS btm_set_inq_event_filter();
		static void btm_initiate_inquiry();
		void btm_clr_inq_result_flt(void);

		static uint8_t btm_convert_uuid_to_eir_service(uint16_t uuid16);
		@@ -385,12 +384,6 @@ tBTM_STATUS BTM_CancelPeriodicInquiry(void) {

		btsnd_hcic_exit_per_inq();

		/* If the event filter is in progress, mark it so that the processing of the
		return
		event will be ignored */
		if (p_inq->inqfilt_active) p_inq->pending_filt_complete_event++;

		p_inq->inqfilt_active = false;
		p_inq->inq_counter++;
		}

		@@ -553,21 +546,11 @@ void BTM_CancelInquiry(void) {
		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 the event filter is in progress, mark it so that the processing of the
		return
		event will be ignored */
		if (p_inq->inqfilt_active) {
		p_inq->inqfilt_active = false;
		p_inq->pending_filt_complete_event++;
		}
		/* Initiate the cancel inquiry */
		else {
		if ((p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK) != 0) {
		btsnd_hcic_inq_cancel();
		}
		if ((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0)
		btm_ble_stop_inquiry();
		}

		p_inq->inq_counter++;
		btm_clr_inq_result_flt();
		@@ -621,7 +604,7 @@ tBTM_STATUS BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,

		/* Only one active inquiry is allowed in this implementation.
		Also do not allow an inquiry if the inquiry filter is being updated */
		if (p_inq->inq_active \|\| p_inq->inqfilt_active) {
		if (p_inq->inq_active) {
		LOG(ERROR) << __func__ << ": BTM_BUSY";
		return (BTM_BUSY);
		} else {
		@@ -641,7 +624,6 @@ tBTM_STATUS BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,
		p_inq->inqparms.duration = BTIF_DM_DEFAULT_INQ_MAX_DURATION;

		p_inq->inqparms.max_resps = BTIF_DM_DEFAULT_INQ_MAX_RESULTS;
		p_inq->inqparms.report_dup = true;

		/* Initialize the inquiry variables */
		p_inq->state = BTM_INQ_ACTIVE_STATE;
		@@ -680,17 +662,8 @@ tBTM_STATUS BTM_StartInquiry(tBTM_INQ_RESULTS_CB* p_results_cb,
		return status;
		}

		p_inq->state = BTM_INQ_SET_FILT_STATE;

		/* Before beginning the inquiry the current filter must be cleared, so
		* initiate the command */
		status = btm_set_inq_event_filter();
		if (status != BTM_CMD_STARTED) {
		LOG(ERROR) << __func__ << ": failed to set inquiry event filter";
		p_inq->state = BTM_INQ_INACTIVE_STATE;
		}

		return (status);
		btm_initiate_inquiry();
		return BTM_CMD_STARTED;
		}

		/*******************************************************************************
		@@ -865,8 +838,7 @@ 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 \|\| p_inq->inqfilt_active)
		return (BTM_BUSY);
		if (p_inq->inq_active != BTM_INQUIRY_INACTIVE) return (BTM_BUSY);

		btm_clr_inq_db(p_bda);

		@@ -895,7 +867,6 @@ void btm_inq_db_reset(void) {
		tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;
		uint8_t num_responses;
		uint8_t temp_inq_active;
		tBTM_STATUS status;

		/* If an inquiry or periodic inquiry is active, reset the mode to inactive */
		if (p_inq->inq_active != BTM_INQUIRY_INACTIVE) {
		@@ -929,19 +900,7 @@ void btm_inq_db_reset(void) {
		}
		}

		/* Cancel an inquiry filter request if active, and notify the caller (if
		* waiting) */
		if (p_inq->inqfilt_active) {
		p_inq->inqfilt_active = false;

		if (p_inq->p_inqfilter_cmpl_cb) {
		status = BTM_DEV_RESET;
		(*p_inq->p_inqfilter_cmpl_cb)(&status);
		}
		}

		p_inq->state = BTM_INQ_INACTIVE_STATE;
		p_inq->pending_filt_complete_event = 0;
		p_inq->p_inq_results_cb = NULL;
		btm_clr_inq_db(NULL); /* Clear out all the entries in the database */
		btm_clr_inq_result_flt();
		@@ -988,10 +947,9 @@ void btm_inq_stop_on_ssp(void) {

		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG(
		"btm_inq_stop_on_ssp: no_inc_ssp=%d inq_active:0x%x state:%d "
		"inqfilt_active:%d",
		"btm_inq_stop_on_ssp: no_inc_ssp=%d inq_active:0x%x state:%d ",
		btm_cb.btm_inq_vars.no_inc_ssp, btm_cb.btm_inq_vars.inq_active,
		btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
		btm_cb.btm_inq_vars.state);
		#endif
		if (btm_cb.btm_inq_vars.no_inc_ssp) {
		if (btm_cb.btm_inq_vars.state == BTM_INQ_ACTIVE_STATE) {
		@@ -1173,141 +1131,6 @@ tINQ_DB_ENT* btm_inq_db_new(const RawAddress& p_bda) {
		return (p_old);
		}

		/*******************************************************************************
		*
		* Function btm_set_inq_event_filter
		*
		* Description This function is called to set the inquiry event filter.
		* It is called by either internally, or by the external API
		* function (BTM_SetInqEventFilter). It is used internally as
		* part of the inquiry processing.
		*
		* Input Params:
		* filter_cond_type - this is the type of inquiry filter to
		* apply:
		* BTM_FILTER_COND_DEVICE_CLASS,
		* BTM_FILTER_COND_BD_ADDR, or
		* BTM_CLR_INQUIRY_FILTER
		*
		* p_filt_cond - this is either a BD_ADDR or DEV_CLASS
		* depending on the filter_cond_type
		* (See section 4.7.3 of Core Spec 1.0b).
		*
		* Returns BTM_CMD_STARTED if successfully initiated
		* BTM_NO_RESOURCES if couldn't get a memory pool buffer
		* BTM_ILLEGAL_VALUE if a bad parameter was detected
		*
		******************************************************************************/
		static tBTM_STATUS btm_set_inq_event_filter() {
		uint8_t condition_length = 0;
		uint8_t condition_buf[DEV_CLASS_LEN * 2];
		uint8_t* p_cond = condition_buf; /* points to the condition to pass to HCI */

		btm_cb.btm_inq_vars.inqfilt_active = true;

		/* Filter the inquiry results for the specified condition type and value */
		btsnd_hcic_set_event_filter(HCI_FILTER_INQUIRY_RESULT, BTM_CLR_INQUIRY_FILTER,
		p_cond, condition_length);
		return (BTM_CMD_STARTED);
		}

		/*******************************************************************************
		*
		* Function btm_event_filter_complete
		*
		* Description This function is called when a set event filter has
		* completed.
		* Note: This routine currently only handles inquiry filters.
		* Connection filters are ignored for now.
		*
		* Returns void
		*
		******************************************************************************/
		void btm_event_filter_complete(uint8_t* p) {
		uint8_t hci_status;
		tBTM_STATUS status;
		tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;
		tBTM_CMPL_CB* p_cb = p_inq->p_inqfilter_cmpl_cb;

		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG(
		"btm_event_filter_complete: inq_active:0x%x state:%d inqfilt_active:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state,
		btm_cb.btm_inq_vars.inqfilt_active);
		#endif
		/* If the filter complete event is from an old or cancelled request, ignore it
		*/
		if (p_inq->pending_filt_complete_event) {
		p_inq->pending_filt_complete_event--;
		return;
		}

		/* Only process the inquiry filter; Ignore the connection filter until it
		is used by the upper layers */
		if (p_inq->inqfilt_active) {
		/* Extract the returned status from the buffer */
		STREAM_TO_UINT8(hci_status, p);
		if (hci_status != HCI_SUCCESS) {
		/* If standalone operation, return the error status; if embedded in the
		* inquiry, continue the inquiry */
		BTM_TRACE_WARNING(
		"BTM Warning: Set Event Filter Failed (HCI returned 0x%x)",
		hci_status);
		status = BTM_ERR_PROCESSING;
		} else
		status = BTM_SUCCESS;

		/* If the set filter was initiated externally (via BTM_SetInqEventFilter),
		call the
		callback function to notify the initiator that it has completed */
		if (p_inq->state == BTM_INQ_INACTIVE_STATE) {
		p_inq->inqfilt_active = false;
		if (p_cb) (*p_cb)(&status);
		} else /* An inquiry is active (the set filter command was internally
		generated),
		process the next state of the process (Set a new filter or start
		the inquiry). */
		{
		if (status != BTM_SUCCESS) {
		/* Process the inquiry complete (Error Status) */
		btm_process_inq_complete(
		BTM_ERR_PROCESSING,
		(uint8_t)(p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK));

		/* btm_process_inq_complete() does not restore the following settings on
		* periodic inquiry */
		p_inq->inqfilt_active = false;
		p_inq->inq_active = BTM_INQUIRY_INACTIVE;
		p_inq->state = BTM_INQ_INACTIVE_STATE;

		return;
		}

		/* Check to see if a new filter needs to be set up */
		if (p_inq->state == BTM_INQ_CLR_FILT_STATE) {
		status = btm_set_inq_event_filter();
		if (status == BTM_CMD_STARTED) {
		p_inq->state = BTM_INQ_SET_FILT_STATE;
		} else /* Error setting the filter: Call the initiator's callback
		function to indicate a failure */
		{
		p_inq->inqfilt_active = false;

		/* Process the inquiry complete (Error Status) */
		btm_process_inq_complete(
		BTM_ERR_PROCESSING,
		(uint8_t)(p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK));
		}
		} else /* Initiate the Inquiry or Periodic Inquiry */
		{
		p_inq->state = BTM_INQ_ACTIVE_STATE;
		p_inq->inqfilt_active = false;
		btm_initiate_inquiry(p_inq);
		}
		}
		}
		}

		/*******************************************************************************
		*
		* Function btm_initiate_inquiry
		@@ -1333,15 +1156,16 @@ void btm_event_filter_complete(uint8_t* p) {
		* the error status.
		*
		******************************************************************************/
		static void btm_initiate_inquiry(tBTM_INQUIRY_VAR_ST* p_inq) {
		static void btm_initiate_inquiry() {
		const LAP* lap;
		tBTM_INQUIRY_VAR_ST* p_inq = &btm_cb.btm_inq_vars;
		tBTM_INQ_PARMS* p_inqparms = &p_inq->inqparms;

		p_inq->state = BTM_INQ_ACTIVE_STATE;

		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG(
		"btm_initiate_inquiry: inq_active:0x%x state:%d inqfilt_active:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state,
		btm_cb.btm_inq_vars.inqfilt_active);
		BTM_TRACE_DEBUG("btm_initiate_inquiry: inq_active:0x%x state:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);
		#endif
		btm_acl_update_inquiry_status(BTM_INQUIRY_STARTED);

		@@ -1410,10 +1234,8 @@ void btm_process_inq_results(uint8_t* p, uint8_t hci_evt_len,
		uint8_t* p_eir_data = NULL;

		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG(
		"btm_process_inq_results inq_active:0x%x state:%d inqfilt_active:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state,
		btm_cb.btm_inq_vars.inqfilt_active);
		BTM_TRACE_DEBUG("btm_process_inq_results inq_active:0x%x state:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);
		#endif
		/* Only process the results if the BR inquiry is still active */
		if (!(p_inq->inq_active & BTM_BR_INQ_ACTIVE_MASK)) return;
		@@ -1488,7 +1310,7 @@ void btm_process_inq_results(uint8_t* p, uint8_t hci_evt_len,
		i_rssi = (int8_t)rssi;

		/* If this new RSSI is higher than the last one */
		if (p_inq->inqparms.report_dup && (rssi != 0) && p_i &&
		if ((rssi != 0) && p_i &&
		(i_rssi > p_i->inq_info.results.rssi \|\|
		p_i->inq_info.results.rssi == 0
		/* BR/EDR inquiry information update */
		@@ -1657,10 +1479,8 @@ void btm_process_inq_complete(uint8_t status, uint8_t mode) {
		p_inq->inqparms.mode &= ~(mode);

		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG(
		"btm_process_inq_complete inq_active:0x%x state:%d inqfilt_active:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state,
		btm_cb.btm_inq_vars.inqfilt_active);
		BTM_TRACE_DEBUG("btm_process_inq_complete inq_active:0x%x state:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);
		#endif
		btm_acl_update_inquiry_status(BTM_INQUIRY_COMPLETE);
		/* Ignore any stray or late complete messages if the inquiry is not active */
		@@ -1704,9 +1524,8 @@ void btm_process_inq_complete(uint8_t status, uint8_t mode) {
		p_inq->scan_type = INQ_NONE;
		}
		#if (BTM_INQ_DEBUG == TRUE)
		BTM_TRACE_DEBUG("inq_active:0x%x state:%d inqfilt_active:%d",
		btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state,
		btm_cb.btm_inq_vars.inqfilt_active);
		BTM_TRACE_DEBUG("inq_active:0x%x state:%d", btm_cb.btm_inq_vars.inq_active,
		btm_cb.btm_inq_vars.state);
		#endif
		}

system/stack/btm/btm_int.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -69,7 +69,6 @@ extern void btm_process_inq_results(uint8_t* p, uint8_t hci_evt_len,
		uint8_t inq_res_mode);
		extern void btm_process_inq_complete(uint8_t status, uint8_t mode);
		extern void btm_process_cancel_complete(uint8_t status, uint8_t mode);
		extern void btm_event_filter_complete(uint8_t* p);
		extern void btm_inq_stop_on_ssp(void);
		extern void btm_inq_clear_ssp(void);
		extern tINQ_DB_ENT* btm_inq_db_find(const RawAddress& p_bda);

system/stack/btm/security_device_record.h

+0 −11

Original line number	Diff line number	Diff line
		@@ -187,8 +187,6 @@ typedef struct {

		tBTM_CMPL_CB* p_inq_cmpl_cb;
		tBTM_INQ_RESULTS_CB* p_inq_results_cb;
		tBTM_CMPL_CB* p_inqfilter_cmpl_cb; /* Called (if not NULL) after inquiry
		filter completed */
		uint32_t inq_counter; /* Counter incremented each time an inquiry completes */
		/* Used for determining whether or not duplicate devices */
		/* have responded to the same inquiry */
		@@ -202,20 +200,11 @@ typedef struct {

		uint16_t per_min_delay; /* Current periodic minimum delay */
		uint16_t per_max_delay; /* Current periodic maximum delay */
		bool inqfilt_active;
		uint8_t pending_filt_complete_event; /* to take care of
		btm_event_filter_complete
		corresponding to */
		/* inquiry that has been cancelled*/
		uint8_t inqfilt_type; /* Contains the inquiry filter type (BD ADDR, COD, or
		Clear) */

		#define BTM_INQ_INACTIVE_STATE 0
		#define BTM_INQ_CLR_FILT_STATE \
		1 /* Currently clearing the inquiry filter preceding the inquiry request */
		/* (bypassed if filtering is not used) */
		#define BTM_INQ_SET_FILT_STATE \
		2 /* Sets the new filter (or turns off filtering) in this state */
		#define BTM_INQ_ACTIVE_STATE \
		3 /* Actual inquiry or periodic inquiry is in progress */

system/stack/btu/btu_hcif.cc

+0 −1

Original line number	Diff line number	Diff line
		@@ -1237,7 +1237,6 @@ static void btu_hcif_hdl_command_complete(uint16_t opcode, uint8_t* p,
		btm_process_cancel_complete(HCI_SUCCESS, BTM_BR_INQUIRY_MASK);
		break;
		case HCI_SET_EVENT_FILTER:
		btm_event_filter_complete(p);
		break;

		case HCI_DELETE_STORED_LINK_KEY: