/****************************************************************************** * * Copyright (C) 1999-2012 Broadcom Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ /****************************************************************************** * * This file contains functions that handle inquiries. These include * setting discoverable mode, controlling the mode of the Baseband, and * maintaining a small database of inquiry responses, with API for people * to browse it. * ******************************************************************************/ #include #include #include #include #include "bt_types.h" #include "gki.h" #include "hcimsgs.h" #include "btu.h" #include "btm_api.h" #include "btm_int.h" #include "hcidefs.h" #define BTM_INQ_REPLY_TIMEOUT 3 /* 3 second timeout waiting for responses */ /* TRUE to enable DEBUG traces for btm_inq */ #ifndef BTM_INQ_DEBUG #define BTM_INQ_DEBUG FALSE #endif /********************************************************************************/ /* L O C A L D A T A D E F I N I T I O N S */ /********************************************************************************/ static const LAP general_inq_lap = {0x9e,0x8b,0x33}; static const LAP limited_inq_lap = {0x9e,0x8b,0x00}; #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE )) #ifndef BTM_EIR_UUID_LKUP_TBL const UINT16 BTM_EIR_UUID_LKUP_TBL[BTM_EIR_MAX_SERVICES] = { UUID_SERVCLASS_SERVICE_DISCOVERY_SERVER, /* UUID_SERVCLASS_BROWSE_GROUP_DESCRIPTOR, */ /* UUID_SERVCLASS_PUBLIC_BROWSE_GROUP, */ UUID_SERVCLASS_SERIAL_PORT, UUID_SERVCLASS_LAN_ACCESS_USING_PPP, UUID_SERVCLASS_DIALUP_NETWORKING, UUID_SERVCLASS_IRMC_SYNC, UUID_SERVCLASS_OBEX_OBJECT_PUSH, UUID_SERVCLASS_OBEX_FILE_TRANSFER, UUID_SERVCLASS_IRMC_SYNC_COMMAND, UUID_SERVCLASS_HEADSET, UUID_SERVCLASS_CORDLESS_TELEPHONY, UUID_SERVCLASS_AUDIO_SOURCE, UUID_SERVCLASS_AUDIO_SINK, UUID_SERVCLASS_AV_REM_CTRL_TARGET, /* UUID_SERVCLASS_ADV_AUDIO_DISTRIBUTION, */ UUID_SERVCLASS_AV_REMOTE_CONTROL, /* UUID_SERVCLASS_VIDEO_CONFERENCING, */ UUID_SERVCLASS_INTERCOM, UUID_SERVCLASS_FAX, UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, /* UUID_SERVCLASS_WAP, */ /* UUID_SERVCLASS_WAP_CLIENT, */ UUID_SERVCLASS_PANU, UUID_SERVCLASS_NAP, UUID_SERVCLASS_GN, UUID_SERVCLASS_DIRECT_PRINTING, /* UUID_SERVCLASS_REFERENCE_PRINTING, */ UUID_SERVCLASS_IMAGING, UUID_SERVCLASS_IMAGING_RESPONDER, UUID_SERVCLASS_IMAGING_AUTO_ARCHIVE, UUID_SERVCLASS_IMAGING_REF_OBJECTS, UUID_SERVCLASS_HF_HANDSFREE, UUID_SERVCLASS_AG_HANDSFREE, UUID_SERVCLASS_DIR_PRT_REF_OBJ_SERVICE, /* UUID_SERVCLASS_REFLECTED_UI, */ UUID_SERVCLASS_BASIC_PRINTING, UUID_SERVCLASS_PRINTING_STATUS, UUID_SERVCLASS_HUMAN_INTERFACE, UUID_SERVCLASS_CABLE_REPLACEMENT, UUID_SERVCLASS_HCRP_PRINT, UUID_SERVCLASS_HCRP_SCAN, /* UUID_SERVCLASS_COMMON_ISDN_ACCESS, */ /* UUID_SERVCLASS_VIDEO_CONFERENCING_GW, */ /* UUID_SERVCLASS_UDI_MT, */ /* UUID_SERVCLASS_UDI_TA, */ /* UUID_SERVCLASS_VCP, */ UUID_SERVCLASS_SAP, UUID_SERVCLASS_PBAP_PCE, UUID_SERVCLASS_PBAP_PSE, UUID_SERVCLASS_PHONE_ACCESS, UUID_SERVCLASS_HEADSET_HS, UUID_SERVCLASS_PNP_INFORMATION, /* UUID_SERVCLASS_GENERIC_NETWORKING, */ /* UUID_SERVCLASS_GENERIC_FILETRANSFER, */ /* UUID_SERVCLASS_GENERIC_AUDIO, */ /* UUID_SERVCLASS_GENERIC_TELEPHONY, */ /* UUID_SERVCLASS_UPNP_SERVICE, */ /* UUID_SERVCLASS_UPNP_IP_SERVICE, */ /* UUID_SERVCLASS_ESDP_UPNP_IP_PAN, */ /* UUID_SERVCLASS_ESDP_UPNP_IP_LAP, */ /* UUID_SERVCLASS_ESDP_UPNP_IP_L2CAP, */ UUID_SERVCLASS_VIDEO_SOURCE, UUID_SERVCLASS_VIDEO_SINK, /* UUID_SERVCLASS_VIDEO_DISTRIBUTION */ UUID_SERVCLASS_MESSAGE_ACCESS, UUID_SERVCLASS_MESSAGE_NOTIFICATION, UUID_SERVCLASS_HDP_SOURCE, UUID_SERVCLASS_HDP_SINK }; #else /* If customized UUID look-up table needs to be used, the followings should be defined in bdroid_buildcfg.h. BTM_EIR_UUID_LKUP_TBL = BTM_EIR_MAX_SERVICES = */ #if (BTM_EIR_MAX_SERVICES == 0) const UINT16 BTM_EIR_UUID_LKUP_TBL[]; #else extern UINT16 BTM_EIR_UUID_LKUP_TBL[BTM_EIR_MAX_SERVICES]; #endif #endif #endif /* BTM_EIR_UUID_LKUP_TBL*/ /********************************************************************************/ /* 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 (UINT8 filter_cond_type, tBTM_INQ_FILT_COND *p_filt_cond); static void btm_clr_inq_result_flt (void); #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE)) static UINT8 btm_convert_uuid_to_eir_service( UINT16 uuid16 ); #endif #if (BTM_EIR_CLIENT_INCLUDED == TRUE) static void btm_set_eir_uuid( UINT8 *p_eir, tBTM_INQ_RESULTS *p_results ); static UINT8 *btm_eir_get_uuid_list( UINT8 *p_eir, UINT8 uuid_size, UINT8 *p_num_uuid, UINT8 *p_uuid_list_type ); static UINT16 btm_convert_uuid_to_uuid16( UINT8 *p_uuid, UINT8 uuid_size ); #endif /******************************************************************************* ** ** Function BTM_SetDiscoverability ** ** Description This function is called to set the device into or out of ** discoverable mode. Discoverable mode means inquiry ** scans are enabled. If a value of '0' is entered for window or ** interval, the default values are used. ** ** Returns BTM_SUCCESS if successful ** BTM_BUSY if a setting of the filter is already in progress ** BTM_NO_RESOURCES if couldn't get a memory pool buffer ** BTM_ILLEGAL_VALUE if a bad parameter was detected ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetDiscoverability (UINT16 inq_mode, UINT16 window, UINT16 interval) { UINT8 scan_mode = 0; UINT16 service_class; UINT8 *p_cod; UINT8 major, minor; DEV_CLASS cod; LAP temp_lap[2]; BOOLEAN is_limited; BOOLEAN cod_limited; BTM_TRACE_API0 ("BTM_SetDiscoverability"); #if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE) if (btm_ble_set_discoverability((UINT16)(inq_mode)) == BTM_SUCCESS) { btm_cb.btm_inq_vars.discoverable_mode &= (~BTM_BLE_DISCOVERABLE_MASK); btm_cb.btm_inq_vars.discoverable_mode |= (inq_mode & BTM_BLE_CONNECTABLE_MASK); } inq_mode &= ~BTM_BLE_DISCOVERABLE_MASK; #endif /*** Check mode parameter ***/ if (inq_mode > BTM_MAX_DISCOVERABLE) return (BTM_ILLEGAL_VALUE); /* Make sure the controller is active */ if (btm_cb.devcb.state < BTM_DEV_STATE_READY) return (BTM_DEV_RESET); /* If the window and/or interval is '0', set to default values */ if (!window) window = BTM_DEFAULT_DISC_WINDOW; if (!interval) interval = BTM_DEFAULT_DISC_INTERVAL; BTM_TRACE_API3 ("BTM_SetDiscoverability: mode %d [NonDisc-0, Lim-1, Gen-2], window 0x%04x, interval 0x%04x", inq_mode, window, interval); /*** Check for valid window and interval parameters ***/ /*** Only check window and duration if mode is connectable ***/ if (inq_mode != BTM_NON_DISCOVERABLE) { /* window must be less than or equal to interval */ if (window < HCI_MIN_INQUIRYSCAN_WINDOW || window > HCI_MAX_INQUIRYSCAN_WINDOW || interval < HCI_MIN_INQUIRYSCAN_INTERVAL || interval > HCI_MAX_INQUIRYSCAN_INTERVAL || window > interval) { return (BTM_ILLEGAL_VALUE); } } /* Set the IAC if needed */ if (inq_mode != BTM_NON_DISCOVERABLE) { if (inq_mode & BTM_LIMITED_DISCOVERABLE) { /* Use the GIAC and LIAC codes for limited discoverable mode */ memcpy (temp_lap[0], limited_inq_lap, LAP_LEN); memcpy (temp_lap[1], general_inq_lap, LAP_LEN); if (!btsnd_hcic_write_cur_iac_lap (2, (LAP * const) temp_lap)) return (BTM_NO_RESOURCES); /* Cannot continue */ } else { if (!btsnd_hcic_write_cur_iac_lap (1, (LAP * const) &general_inq_lap)) return (BTM_NO_RESOURCES); /* Cannot continue */ } scan_mode |= HCI_INQUIRY_SCAN_ENABLED; } /* Send down the inquiry scan window and period if changed */ if ((window != btm_cb.btm_inq_vars.inq_scan_window) || (interval != btm_cb.btm_inq_vars.inq_scan_period)) { if (btsnd_hcic_write_inqscan_cfg (interval, window)) { btm_cb.btm_inq_vars.inq_scan_window = window; btm_cb.btm_inq_vars.inq_scan_period = interval; } else return (BTM_NO_RESOURCES); } if (btm_cb.btm_inq_vars.connectable_mode & BTM_CONNECTABLE_MASK) scan_mode |= HCI_PAGE_SCAN_ENABLED; if (btsnd_hcic_write_scan_enable (scan_mode)) { btm_cb.btm_inq_vars.discoverable_mode &= (~BTM_DISCOVERABLE_MASK); btm_cb.btm_inq_vars.discoverable_mode |= inq_mode; } else return (BTM_NO_RESOURCES); /* Change the service class bit if mode has changed */ p_cod = BTM_ReadDeviceClass(); BTM_COD_SERVICE_CLASS(service_class, p_cod); is_limited = (inq_mode & BTM_LIMITED_DISCOVERABLE) ? TRUE : FALSE; cod_limited = (service_class & BTM_COD_SERVICE_LMTD_DISCOVER) ? TRUE : FALSE; if (is_limited ^ cod_limited) { BTM_COD_MINOR_CLASS(minor, p_cod ); BTM_COD_MAJOR_CLASS(major, p_cod ); if (is_limited) service_class |= BTM_COD_SERVICE_LMTD_DISCOVER; else service_class &= ~BTM_COD_SERVICE_LMTD_DISCOVER; FIELDS_TO_COD(cod, minor, major, service_class); (void) BTM_SetDeviceClass (cod); } return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_SetInquiryScanType ** ** Description This function is called to set the iquiry scan-type to ** standard or interlaced. ** ** Returns BTM_SUCCESS if successful ** BTM_MODE_UNSUPPORTED if not a 1.2 device ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetInquiryScanType (UINT16 scan_type) { BTM_TRACE_API0 ("BTM_SetInquiryScanType"); if (scan_type != BTM_SCAN_TYPE_STANDARD && scan_type != BTM_SCAN_TYPE_INTERLACED) return (BTM_ILLEGAL_VALUE); /* whatever app wants if device is not 1.2 scan type should be STANDARD */ if (!HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(btm_cb.devcb.local_features)) return (BTM_MODE_UNSUPPORTED); /* Check for scan type if configuration has been changed */ if (scan_type != btm_cb.btm_inq_vars.inq_scan_type) { if (BTM_IsDeviceUp()) { if (btsnd_hcic_write_inqscan_type ((UINT8)scan_type)) btm_cb.btm_inq_vars.inq_scan_type = scan_type; else return (BTM_NO_RESOURCES); } else return (BTM_WRONG_MODE); } return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_SetPageScanType ** ** Description This function is called to set the page scan-type to ** standard or interlaced. ** ** Returns BTM_SUCCESS if successful ** BTM_MODE_UNSUPPORTED if not a 1.2 device ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetPageScanType (UINT16 scan_type) { BTM_TRACE_API0 ("BTM_SetPageScanType"); if (scan_type != BTM_SCAN_TYPE_STANDARD && scan_type != BTM_SCAN_TYPE_INTERLACED) return (BTM_ILLEGAL_VALUE); /* whatever app wants if device is not 1.2 scan type should be STANDARD */ if (!HCI_LMP_INTERLACED_PAGE_SCAN_SUPPORTED(btm_cb.devcb.local_features)) return (BTM_MODE_UNSUPPORTED); /* Check for scan type if configuration has been changed */ if (scan_type != btm_cb.btm_inq_vars.page_scan_type) { if (BTM_IsDeviceUp()) { if (btsnd_hcic_write_pagescan_type ((UINT8)scan_type)) btm_cb.btm_inq_vars.page_scan_type = scan_type; else return (BTM_NO_RESOURCES); } else return (BTM_WRONG_MODE); } return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_SetInquiryMode ** ** Description This function is called to set standard or with RSSI ** mode of the inquiry for local device. ** ** Output Params: mode - standard, with RSSI, extended ** ** Returns BTM_SUCCESS if successful ** BTM_NO_RESOURCES if couldn't get a memory pool buffer ** BTM_ILLEGAL_VALUE if a bad parameter was detected ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetInquiryMode (UINT8 mode) { BTM_TRACE_API0 ("BTM_SetInquiryMode"); if (mode == BTM_INQ_RESULT_STANDARD) { /* mandatory mode */ } else if (mode == BTM_INQ_RESULT_WITH_RSSI) { if (!HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_features)) return (BTM_MODE_UNSUPPORTED); } #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE )) else if (mode == BTM_INQ_RESULT_EXTENDED) { if (!HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_features)) return (BTM_MODE_UNSUPPORTED); } #endif else return (BTM_ILLEGAL_VALUE); if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); if (!btsnd_hcic_write_inquiry_mode (mode)) return (BTM_NO_RESOURCES); return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_ReadDiscoverability ** ** Description This function is called to read the current discoverability ** mode of the device. ** ** Output Params: p_window - current inquiry scan duration ** p_interval - current inquiry scan interval ** ** Returns BTM_NON_DISCOVERABLE, BTM_LIMITED_DISCOVERABLE, or ** BTM_GENERAL_DISCOVERABLE ** *******************************************************************************/ UINT16 BTM_ReadDiscoverability (UINT16 *p_window, UINT16 *p_interval) { BTM_TRACE_API0 ("BTM_ReadDiscoverability"); if (p_window) *p_window = btm_cb.btm_inq_vars.inq_scan_window; if (p_interval) *p_interval = btm_cb.btm_inq_vars.inq_scan_period; return (btm_cb.btm_inq_vars.discoverable_mode); } /******************************************************************************* ** ** Function BTM_SetPeriodicInquiryMode ** ** Description This function is called to set the device periodic inquiry mode. ** If the duration is zero, the periodic inquiry mode is cancelled. ** ** Note: We currently do not allow concurrent inquiry and periodic inquiry. ** ** Parameters: p_inqparms - pointer to the inquiry information ** mode - GENERAL or LIMITED inquiry ** duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED) ** max_resps - maximum amount of devices to search for before ending the inquiry ** filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or ** BTM_FILTER_COND_BD_ADDR ** filter_cond - value for the filter (based on filter_cond_type) ** ** max_delay - maximum amount of time between successive inquiries ** min_delay - minimum amount of time between successive inquiries ** p_results_cb - callback returning pointer to results (tBTM_INQ_RESULTS) ** ** Returns BTM_CMD_STARTED if successfully started ** BTM_ILLEGAL_VALUE if a bad parameter is detected ** BTM_NO_RESOURCES if could not allocate a message buffer ** BTM_SUCCESS - if cancelling the periodic inquiry ** BTM_BUSY - if an inquiry is already active ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetPeriodicInquiryMode (tBTM_INQ_PARMS *p_inqparms, UINT16 max_delay, UINT16 min_delay, tBTM_INQ_RESULTS_CB *p_results_cb) { tBTM_STATUS status; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; BTM_TRACE_API6 ("BTM_SetPeriodicInquiryMode: mode: %d, dur: %d, rsps: %d, flt: %d, min: %d, max: %d", p_inqparms->mode, p_inqparms->duration, p_inqparms->max_resps, p_inqparms->filter_cond_type, min_delay, max_delay); /*** Make sure the device is ready ***/ if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); /* 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) return (BTM_BUSY); /* If illegal parameters return FALSE */ if (p_inqparms->mode != BTM_GENERAL_INQUIRY && p_inqparms->mode != BTM_LIMITED_INQUIRY) return (BTM_ILLEGAL_VALUE); /* Verify the parameters for this command */ if (p_inqparms->duration < BTM_MIN_INQUIRY_LEN || p_inqparms->duration > BTM_MAX_INQUIRY_LENGTH || min_delay <= p_inqparms->duration || min_delay < BTM_PER_INQ_MIN_MIN_PERIOD || min_delay > BTM_PER_INQ_MAX_MIN_PERIOD || max_delay <= min_delay || max_delay < BTM_PER_INQ_MIN_MAX_PERIOD || max_delay > BTM_PER_INQ_MAX_MAX_PERIOD) { return (BTM_ILLEGAL_VALUE); } /* Save the inquiry parameters to be used upon the completion of setting/clearing the inquiry filter */ p_inq->inqparms = *p_inqparms; p_inq->per_min_delay = min_delay; p_inq->per_max_delay = max_delay; p_inq->inq_cmpl_info.num_resp = 0; /* Clear the results counter */ p_inq->p_inq_results_cb = p_results_cb; p_inq->inq_active = (UINT8)((p_inqparms->mode == BTM_LIMITED_INQUIRY) ? (BTM_LIMITED_INQUIRY_ACTIVE | BTM_PERIODIC_INQUIRY_ACTIVE) : (BTM_GENERAL_INQUIRY_ACTIVE | BTM_PERIODIC_INQUIRY_ACTIVE)); #if (defined(BTM_BYPASS_EVENT_FILTERING) && BTM_BYPASS_EVENT_FILTERING == TRUE) BTM_TRACE_WARNING0("BTM: Bypassing event filtering..."); p_inq->state = BTM_INQ_ACTIVE_STATE; p_inq->inqfilt_active = FALSE; btm_initiate_inquiry (p_inq); status = BTM_CMD_STARTED; #else /* If a filter is specified, then save it for later and clear the current filter. The setting of the filter is done upon completion of clearing of the previous filter. */ if (p_inqparms->filter_cond_type != BTM_CLR_INQUIRY_FILTER) { p_inq->state = BTM_INQ_CLR_FILT_STATE; p_inqparms->filter_cond_type = BTM_CLR_INQUIRY_FILTER; } else /* The filter is not being used so simply clear it; the inquiry can start after this operation */ p_inq->state = BTM_INQ_SET_FILT_STATE; /* Before beginning the inquiry the current filter must be cleared, so initiate the command */ if ((status = btm_set_inq_event_filter (p_inqparms->filter_cond_type, &p_inqparms->filter_cond)) != BTM_CMD_STARTED) { /* If set filter command is not succesful reset the state */ p_inq->p_inq_results_cb = NULL; p_inq->state = BTM_INQ_INACTIVE_STATE; } #endif return (status); } /******************************************************************************* ** ** Function BTM_CancelPeriodicInquiry ** ** Description This function cancels a periodic inquiry ** ** Returns ** BTM_NO_RESOURCES if could not allocate a message buffer ** BTM_SUCCESS - if cancelling the periodic inquiry ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_CancelPeriodicInquiry(void) { tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; tBTM_STATUS status = BTM_SUCCESS; BTM_TRACE_API0 ("BTM_CancelPeriodicInquiry called"); /*** Make sure the device is ready ***/ if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); /* Only cancel if one is active */ if (btm_cb.btm_inq_vars.inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) { btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE; btm_cb.btm_inq_vars.p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL; if (!btsnd_hcic_exit_per_inq ()) status = BTM_NO_RESOURCES; /* 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++; } return (status); } /******************************************************************************* ** ** Function BTM_SetConnectability ** ** Description This function is called to set the device into or out of ** connectable mode. Discoverable mode means page scans enabled. ** ** Returns BTM_SUCCESS if successful ** BTM_ILLEGAL_VALUE if a bad parameter is detected ** BTM_NO_RESOURCES if could not allocate a message buffer ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_SetConnectability (UINT16 page_mode, UINT16 window, UINT16 interval) { UINT8 scan_mode = 0; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; BTM_TRACE_API0 ("BTM_SetConnectability"); #if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE) if (btm_ble_set_connectability(page_mode) == BTM_SUCCESS) { p_inq->connectable_mode &= (~BTM_BLE_CONNECTABLE_MASK); p_inq->connectable_mode |= (page_mode & BTM_BLE_CONNECTABLE_MASK); } page_mode &= ~BTM_BLE_CONNECTABLE_MASK; #endif /*** Check mode parameter ***/ if (page_mode != BTM_NON_CONNECTABLE && page_mode != BTM_CONNECTABLE) return (BTM_ILLEGAL_VALUE); /* Make sure the controller is active */ if (btm_cb.devcb.state < BTM_DEV_STATE_READY) return (BTM_DEV_RESET); /* If the window and/or interval is '0', set to default values */ if (!window) window = BTM_DEFAULT_CONN_WINDOW; if (!interval) interval = BTM_DEFAULT_CONN_INTERVAL; BTM_TRACE_API3 ("BTM_SetConnectability: mode %d [NonConn-0, Conn-1], window 0x%04x, interval 0x%04x", page_mode, window, interval); /*** Check for valid window and interval parameters ***/ /*** Only check window and duration if mode is connectable ***/ if (page_mode == BTM_CONNECTABLE) { /* window must be less than or equal to interval */ if (window < HCI_MIN_PAGESCAN_WINDOW || window > HCI_MAX_PAGESCAN_WINDOW || interval < HCI_MIN_PAGESCAN_INTERVAL || interval > HCI_MAX_PAGESCAN_INTERVAL || window > interval) { return (BTM_ILLEGAL_VALUE); } scan_mode |= HCI_PAGE_SCAN_ENABLED; } 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 (!btsnd_hcic_write_pagescan_cfg (interval, window)) return (BTM_NO_RESOURCES); } /* Keep the inquiry scan as previouosly set */ if (p_inq->discoverable_mode & BTM_DISCOVERABLE_MASK) scan_mode |= HCI_INQUIRY_SCAN_ENABLED; if (btsnd_hcic_write_scan_enable (scan_mode)) { p_inq->connectable_mode &= (~BTM_CONNECTABLE_MASK); p_inq->connectable_mode |= page_mode; return (BTM_SUCCESS); } return (BTM_NO_RESOURCES); } /******************************************************************************* ** ** Function BTM_ReadConnectability ** ** Description This function is called to read the current discoverability ** mode of the device. ** Output Params p_window - current page scan duration ** p_interval - current time between page scans ** ** Returns BTM_NON_CONNECTABLE or BTM_CONNECTABLE ** *******************************************************************************/ UINT16 BTM_ReadConnectability (UINT16 *p_window, UINT16 *p_interval) { BTM_TRACE_API0 ("BTM_ReadConnectability"); if (p_window) *p_window = btm_cb.btm_inq_vars.page_scan_window; if (p_interval) *p_interval = btm_cb.btm_inq_vars.page_scan_period; return (btm_cb.btm_inq_vars.connectable_mode); } /******************************************************************************* ** ** Function BTM_IsInquiryActive ** ** Description This function returns a bit mask of the current inquiry state ** ** Returns BTM_INQUIRY_INACTIVE if inactive (0) ** BTM_LIMITED_INQUIRY_ACTIVE if a limted inquiry is active ** BTM_GENERAL_INQUIRY_ACTIVE if a general inquiry is active ** BTM_PERIODIC_INQUIRY_ACTIVE if a periodic inquiry is active ** *******************************************************************************/ UINT16 BTM_IsInquiryActive (void) { BTM_TRACE_API0 ("BTM_IsInquiryActive"); return(btm_cb.btm_inq_vars.inq_active); } /******************************************************************************* ** ** Function BTM_CancelInquiry ** ** Description This function cancels an inquiry if active ** ** Returns BTM_SUCCESS if successful ** BTM_NO_RESOURCES if could not allocate a message buffer ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_CancelInquiry(void) { tBTM_STATUS status = BTM_SUCCESS; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; BTM_TRACE_API0 ("BTM_CancelInquiry called"); /*** Make sure the device is ready ***/ if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); /* Only cancel if not in periodic mode, otherwise the caller should call BTM_CancelPeriodicMode */ if (p_inq->inq_active && (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE))) { p_inq->inq_active = BTM_INQUIRY_INACTIVE; p_inq->state = BTM_INQ_INACTIVE_STATE; p_inq->p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL; /* Do not notify caller anymore */ p_inq->p_inq_cmpl_cb = (tBTM_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 (!btsnd_hcic_inq_cancel()) status = BTM_NO_RESOURCES; #if BLE_INCLUDED == TRUE if ((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0) btm_ble_stop_scan(); #endif } #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE) /* Do not send the BUSY_LEVEL event yet. Wait for the cancel_complete event * and then send the BUSY_LEVEL event * btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT); */ #endif p_inq->inq_counter++; btm_clr_inq_result_flt(); } return (status); } /******************************************************************************* ** ** Function BTM_StartInquiry ** ** Description This function is called to start an inquiry. ** ** Parameters: p_inqparms - pointer to the inquiry information ** mode - GENERAL or LIMITED inquiry ** duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED) ** max_resps - maximum amount of devices to search for before ending the inquiry ** filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or ** BTM_FILTER_COND_BD_ADDR ** filter_cond - value for the filter (based on filter_cond_type) ** ** p_results_cb - Pointer to the callback routine which gets called ** upon receipt of an inquiry result. If this field is ** NULL, the application is not notified. ** ** p_cmpl_cb - Pointer to the callback routine which gets called ** upon completion. If this field is NULL, the ** application is not notified when completed. ** Returns tBTM_STATUS ** BTM_CMD_STARTED if successfully initiated ** BTM_BUSY if already in progress ** BTM_ILLEGAL_VALUE if parameter(s) are out of range ** BTM_NO_RESOURCES if could not allocate resources to start the command ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_StartInquiry (tBTM_INQ_PARMS *p_inqparms, tBTM_INQ_RESULTS_CB *p_results_cb, tBTM_CMPL_CB *p_cmpl_cb) { tBTM_STATUS status; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; BTM_TRACE_API4 ("BTM_StartInquiry: mode: %d, dur: %d, rsps: %d, flt: %d", p_inqparms->mode, p_inqparms->duration, p_inqparms->max_resps, p_inqparms->filter_cond_type); /* 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) return (BTM_BUSY); /*** Make sure the device is ready ***/ if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); if ((p_inqparms->mode & BTM_BR_INQUIRY_MASK)!= BTM_GENERAL_INQUIRY && (p_inqparms->mode & BTM_BR_INQUIRY_MASK)!= BTM_LIMITED_INQUIRY) return (BTM_ILLEGAL_VALUE); /* Save the inquiry parameters to be used upon the completion of setting/clearing the inquiry filter */ p_inq->inqparms = *p_inqparms; #if (BLE_INCLUDED == TRUE) p_inq->inqparms.mode = (UINT8)(p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) | (UINT8)(1 << (p_inqparms->mode & BTM_BR_INQUIRY_MASK)); #else p_inq->inqparms.mode = (UINT8)(1 << (p_inqparms->mode & BTM_BR_INQUIRY_MASK)); #endif /* Initialize the inquiry variables */ p_inq->state = BTM_INQ_ACTIVE_STATE; p_inq->p_inq_cmpl_cb = p_cmpl_cb; p_inq->p_inq_results_cb = p_results_cb; p_inq->inq_cmpl_info.num_resp = 0; /* Clear the results counter */ p_inq->inq_active = (UINT8)(1 << (p_inqparms->mode & BTM_BR_INQUIRY_MASK)); BTM_TRACE_DEBUG1("BTM_StartInquiry: p_inq->inq_active = 0x%02x", p_inq->inq_active); /* start LE inquiry here if requested */ #if BLE_INCLUDED == TRUE if (p_inqparms->mode & BTM_BLE_INQUIRY_MASK) { /* BLE for now does not support filter condition for inquiry */ if (btm_ble_start_inquiry((UINT8)(p_inqparms->mode & BTM_BLE_INQUIRY_MASK), p_inq->inqparms.duration) != BTM_SUCCESS) { BTM_TRACE_ERROR0("Err Starting LE Inquiry."); p_inq->inqparms.mode &= ~ BTM_BLE_INQUIRY_MASK; } p_inqparms->mode &= ~BTM_BLE_INQUIRY_MASK; BTM_TRACE_DEBUG1("BTM_StartInquiry: mode = %02x", p_inqparms->mode); } #endif /* end of BLE_INCLUDED */ #if (defined(BTM_BYPASS_EVENT_FILTERING) && BTM_BYPASS_EVENT_FILTERING == TRUE) BTM_TRACE_WARNING0("BTM: Bypassing event filtering..."); p_inq->inqfilt_active = FALSE; btm_initiate_inquiry (p_inq); status = BTM_CMD_STARTED; #else /* If a filter is specified, then save it for later and clear the current filter. The setting of the filter is done upon completion of clearing of the previous filter. */ switch (p_inqparms->filter_cond_type) { case BTM_CLR_INQUIRY_FILTER: p_inq->state = BTM_INQ_SET_FILT_STATE; break; case BTM_FILTER_COND_DEVICE_CLASS: case BTM_FILTER_COND_BD_ADDR: /* The filter is not being used so simply clear it; the inquiry can start after this operation */ p_inq->state = BTM_INQ_CLR_FILT_STATE; p_inqparms->filter_cond_type = BTM_CLR_INQUIRY_FILTER; /* =============>>>> adding LE filtering here ????? */ break; default: return (BTM_ILLEGAL_VALUE); } /* Before beginning the inquiry the current filter must be cleared, so initiate the command */ if ((status = btm_set_inq_event_filter (p_inqparms->filter_cond_type, &p_inqparms->filter_cond)) != BTM_CMD_STARTED) p_inq->state = BTM_INQ_INACTIVE_STATE; #endif return (status); } /******************************************************************************* ** ** Function BTM_ReadRemoteDeviceName ** ** Description This function initiates a remote device HCI command to the ** controller and calls the callback when the process has completed. ** ** Input Params: remote_bda - device address of name to retrieve ** p_cb - callback function called when BTM_CMD_STARTED ** is returned. ** A pointer to tBTM_REMOTE_DEV_NAME is passed to the ** callback. ** ** Returns ** BTM_CMD_STARTED is returned if the request was successfully sent ** to HCI. ** BTM_BUSY if already in progress ** BTM_UNKNOWN_ADDR if device address is bad ** BTM_NO_RESOURCES if could not allocate resources to start the command ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS BTM_ReadRemoteDeviceName (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb) { tBTM_INQ_INFO *p_cur = NULL; tINQ_DB_ENT *p_i; #if BLE_INCLUDED == TRUE tBT_DEVICE_TYPE dev_type; tBLE_ADDR_TYPE addr_type; #endif BTM_TRACE_API6 ("BTM_ReadRemoteDeviceName: bd addr [%02x%02x%02x%02x%02x%02x]", remote_bda[0], remote_bda[1], remote_bda[2], remote_bda[3], remote_bda[4], remote_bda[5]); /* Use the remote device's clock offset if it is in the local inquiry database */ if ((p_i = btm_inq_db_find (remote_bda)) != NULL) { p_cur = &p_i->inq_info; #if (BTM_INQ_GET_REMOTE_NAME == TRUE) p_cur->remote_name_state = BTM_INQ_RMT_NAME_EMPTY; #endif } BTM_TRACE_API0 ("no device found in inquiry db"); #if (BLE_INCLUDED == TRUE) BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type); if (dev_type == BT_DEVICE_TYPE_BLE) { return btm_ble_read_remote_name(remote_bda, p_cur, p_cb); } else #endif return (btm_initiate_rem_name (remote_bda, p_cur, BTM_RMT_NAME_EXT, BTM_EXT_RMT_NAME_TIMEOUT, p_cb)); } /******************************************************************************* ** ** Function BTM_CancelRemoteDeviceName ** ** Description This function initiates the cancel request for the specified ** remote device. ** ** Input Params: None ** ** Returns ** BTM_CMD_STARTED is returned if the request was successfully sent ** to HCI. ** BTM_NO_RESOURCES if could not allocate resources to start the command ** BTM_WRONG_MODE if there is not an active remote name request. ** *******************************************************************************/ tBTM_STATUS BTM_CancelRemoteDeviceName (void) { tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; #if BLE_INCLUDED == TRUE tBT_DEVICE_TYPE dev_type; tBLE_ADDR_TYPE addr_type; #endif BTM_TRACE_API0 ("BTM_CancelRemoteDeviceName()"); /* Make sure there is not already one in progress */ if (p_inq->remname_active) { #if BLE_INCLUDED == TRUE BTM_ReadDevInfo(p_inq->remname_bda, &dev_type, &addr_type); if (dev_type == BT_DEVICE_TYPE_BLE) { if (btm_ble_cancel_remote_name(p_inq->remname_bda)) return (BTM_CMD_STARTED); else return (BTM_UNKNOWN_ADDR); } else #endif if (btsnd_hcic_rmt_name_req_cancel (p_inq->remname_bda)) return (BTM_CMD_STARTED); else return (BTM_NO_RESOURCES); } else return (BTM_WRONG_MODE); } /******************************************************************************* ** ** Function BTM_InqFirstResult ** ** Description This function looks through the inquiry database for the first ** used entrysince the LAST inquiry. This is used in conjunction ** with BTM_InqNext by applications as a way to walk through the ** inquiry results database. ** ** Returns pointer to first in-use entry, or NULL if DB is empty ** *******************************************************************************/ tBTM_INQ_INFO *BTM_InqFirstResult (void) { UINT16 xx; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; UINT32 cur_inq_count = btm_cb.btm_inq_vars.inq_counter - 1; for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if (p_ent->in_use && p_ent->inq_count == cur_inq_count) return (&p_ent->inq_info); } /* If here, no used entry found */ return ((tBTM_INQ_INFO *)NULL); } /******************************************************************************* ** ** Function BTM_InqNextResult ** ** Description This function looks through the inquiry database for the next ** used entrysince the LAST inquiry. If the input parameter is NULL, ** the first entry is returned. ** ** Returns pointer to next in-use entry, or NULL if no more found. ** *******************************************************************************/ tBTM_INQ_INFO *BTM_InqNextResult (tBTM_INQ_INFO *p_cur) { tINQ_DB_ENT *p_ent; UINT16 inx; UINT32 cur_inq_count = btm_cb.btm_inq_vars.inq_counter - 1; if (p_cur) { p_ent = (tINQ_DB_ENT *) ((UINT8 *)p_cur - offsetof (tINQ_DB_ENT, inq_info)); inx = (UINT16)((p_ent - btm_cb.btm_inq_vars.inq_db) + 1); for (p_ent = &btm_cb.btm_inq_vars.inq_db[inx]; inx < BTM_INQ_DB_SIZE; inx++, p_ent++) { if (p_ent->in_use && p_ent->inq_count == cur_inq_count) return (&p_ent->inq_info); } /* If here, more entries found */ return ((tBTM_INQ_INFO *)NULL); } else return (BTM_InqDbFirst()); } /******************************************************************************* ** ** Function BTM_InqDbRead ** ** Description This function looks through the inquiry database for a match ** based on Bluetooth Device Address. This is the application's ** interface to get the inquiry details of a specific BD address. ** ** Returns pointer to entry, or NULL if not found ** *******************************************************************************/ tBTM_INQ_INFO *BTM_InqDbRead (BD_ADDR p_bda) { UINT16 xx; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; BTM_TRACE_API6 ("BTM_InqDbRead: bd addr [%02x%02x%02x%02x%02x%02x]", p_bda[0], p_bda[1], p_bda[2], p_bda[3], p_bda[4], p_bda[5]); for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if ((p_ent->in_use) && (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN))) return (&p_ent->inq_info); } /* If here, not found */ return ((tBTM_INQ_INFO *)NULL); } /******************************************************************************* ** ** Function BTM_InqDbFirst ** ** Description This function looks through the inquiry database for the first ** used entry, and returns that. This is used in conjunction with ** BTM_InqDbNext by applications as a way to walk through the ** inquiry database. ** ** Returns pointer to first in-use entry, or NULL if DB is empty ** *******************************************************************************/ tBTM_INQ_INFO *BTM_InqDbFirst (void) { UINT16 xx; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if (p_ent->in_use) return (&p_ent->inq_info); } /* If here, no used entry found */ return ((tBTM_INQ_INFO *)NULL); } /******************************************************************************* ** ** Function BTM_InqDbNext ** ** Description This function looks through the inquiry database for the next ** used entry, and returns that. If the input parameter is NULL, ** the first entry is returned. ** ** Returns pointer to next in-use entry, or NULL if no more found. ** *******************************************************************************/ tBTM_INQ_INFO *BTM_InqDbNext (tBTM_INQ_INFO *p_cur) { tINQ_DB_ENT *p_ent; UINT16 inx; if (p_cur) { p_ent = (tINQ_DB_ENT *) ((UINT8 *)p_cur - offsetof (tINQ_DB_ENT, inq_info)); inx = (UINT16)((p_ent - btm_cb.btm_inq_vars.inq_db) + 1); for (p_ent = &btm_cb.btm_inq_vars.inq_db[inx]; inx < BTM_INQ_DB_SIZE; inx++, p_ent++) { if (p_ent->in_use) return (&p_ent->inq_info); } /* If here, more entries found */ return ((tBTM_INQ_INFO *)NULL); } else return (BTM_InqDbFirst()); } /******************************************************************************* ** ** Function BTM_ClearInqDb ** ** Description This function is called to clear out a device or all devices ** from the inquiry database. ** ** Parameter p_bda - (input) BD_ADDR -> Address of device to clear ** (NULL clears all entries) ** ** Returns BTM_BUSY if an inquiry, get remote name, or event filter ** is active, otherwise BTM_SUCCESS ** *******************************************************************************/ tBTM_STATUS BTM_ClearInqDb (BD_ADDR 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); btm_clr_inq_db(p_bda); return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_ReadNumInqDbEntries ** ** Returns This function returns the number of entries in the inquiry database. ** *******************************************************************************/ UINT8 BTM_ReadNumInqDbEntries (void) { UINT8 num_entries; UINT8 num_results; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; for (num_entries = 0, num_results = 0; num_entries < BTM_INQ_DB_SIZE; num_entries++, p_ent++) { if (p_ent->in_use) num_results++; } return (num_results); } /******************************************************************************* ** ** Function BTM_InquiryRegisterForChanges ** ** Returns This function is called to register a callback for when the ** inquiry database changes, i.e. new entry or entry deleted. ** *******************************************************************************/ tBTM_STATUS BTM_InquiryRegisterForChanges (tBTM_INQ_DB_CHANGE_CB *p_cb) { if (!p_cb) btm_cb.btm_inq_vars.p_inq_change_cb = NULL; else if (btm_cb.btm_inq_vars.p_inq_change_cb) return (BTM_BUSY); else btm_cb.btm_inq_vars.p_inq_change_cb = p_cb; return (BTM_SUCCESS); } /******************************************************************************* ** ** Function BTM_SetInquiryFilterCallback ** ** Description Host can register to be asked whenever an inquiry result ** is received. If host does not like the device no name ** request is issued for the device ** ** Returns void ** *******************************************************************************/ void BTM_SetInquiryFilterCallback (tBTM_FILTER_CB *p_callback) { btm_cb.p_inq_filter_cb = p_callback; } /******************************************************************************* ** ** Function BTM_ReadInquiryRspTxPower ** ** Description This command will read the inquiry Transmit Power level used ** to transmit the FHS and EIR data packets. ** This can be used directly in the Tx Power Level EIR data type. ** ** Returns BTM_SUCCESS if successful ** *******************************************************************************/ tBTM_STATUS BTM_ReadInquiryRspTxPower (tBTM_CMPL_CB *p_cb) { if (btm_cb.devcb.p_txpwer_cmpl_cb) return (BTM_BUSY); btu_start_timer (&btm_cb.devcb.txpwer_timer, BTU_TTYPE_BTM_ACL, BTM_INQ_REPLY_TIMEOUT ); btm_cb.devcb.p_txpwer_cmpl_cb = p_cb; if (!btsnd_hcic_read_inq_tx_power ()) { btm_cb.devcb.p_txpwer_cmpl_cb = NULL; btu_stop_timer (&btm_cb.devcb.txpwer_timer); return (BTM_NO_RESOURCES); } else return (BTM_CMD_STARTED); } /******************************************************************************* ** ** Function BTM_WriteInquiryTxPower ** ** Description This command is used to write the inquiry transmit power level ** used to transmit the inquiry (ID) data packets. The Controller ** should use the supported TX power level closest to the Tx_Power ** parameter. ** ** Returns BTM_SUCCESS if successful ** *******************************************************************************/ tBTM_STATUS BTM_WriteInquiryTxPower (INT8 tx_power) { tBTM_STATUS status = BTM_SUCCESS; if (tx_power < BTM_MIN_INQ_TX_POWER || tx_power > BTM_MAX_INQ_TX_POWER) { status = BTM_ILLEGAL_VALUE; } else if (!btsnd_hcic_write_inq_tx_power(tx_power)) status = BTM_NO_RESOURCES; return status; } /********************************************************************************* ********************************************************************************** ** ** ** BTM Internal Inquiry Functions ** ** ** ********************************************************************************** *********************************************************************************/ /******************************************************************************* ** ** Function btm_inq_db_reset ** ** Description This function is called at at reset to clear the inquiry ** database & pending callback. ** ** Returns 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 num_responses; UINT8 temp_inq_active; tBTM_STATUS status; btu_stop_timer (&p_inq->inq_timer_ent); /* 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 callback is called */ p_inq->inq_active = BTM_INQUIRY_INACTIVE; /* If not a periodic inquiry, the complete callback must be called to notify caller */ if (temp_inq_active == BTM_LIMITED_INQUIRY_ACTIVE || temp_inq_active == BTM_GENERAL_INQUIRY_ACTIVE) { if (p_inq->p_inq_cmpl_cb) { num_responses = 0; (*p_inq->p_inq_cmpl_cb)(&num_responses); } } } /* Cancel a remote name request if active, and notify the caller (if waiting) */ if (p_inq->remname_active ) { btu_stop_timer (&p_inq->rmt_name_timer_ent); p_inq->remname_active = FALSE; memset(p_inq->remname_bda, 0, BD_ADDR_LEN); if (p_inq->p_remname_cmpl_cb) { rem_name.status = BTM_DEV_RESET; (*p_inq->p_remname_cmpl_cb)(&rem_name); p_inq->p_remname_cmpl_cb = NULL; } } /* 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(); 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; #if BLE_INCLUDED == TRUE p_inq->discoverable_mode |= BTM_BLE_NON_DISCOVERABLE; p_inq->connectable_mode |= BTM_BLE_NON_CONNECTABLE; #endif return; } /********************************************************************************* ** ** Function btm_inq_db_init ** ** Description This function is called at startup to initialize the inquiry ** database. ** ** Returns void ** *******************************************************************************/ void btm_inq_db_init (void) { #if 0 /* cleared in btm_init; put back in if called from anywhere else! */ memset (&btm_cb.btm_inq_vars, 0, sizeof (tBTM_INQUIRY_VAR_ST)); #endif btm_cb.btm_inq_vars.no_inc_ssp = BTM_NO_SSP_ON_INQUIRY; } /********************************************************************************* ** ** Function btm_inq_stop_on_ssp ** ** Description This function is called on incoming SSP ** ** Returns void ** *******************************************************************************/ void btm_inq_stop_on_ssp(void) { UINT8 normal_active = (BTM_GENERAL_INQUIRY_ACTIVE|BTM_LIMITED_INQUIRY_ACTIVE); #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG4 ("btm_inq_stop_on_ssp: no_inc_ssp=%d inq_active:0x%x state:%d inqfilt_active:%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); #endif if (btm_cb.btm_inq_vars.no_inc_ssp) { if (btm_cb.btm_inq_vars.state == BTM_INQ_ACTIVE_STATE) { if (btm_cb.btm_inq_vars.inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) { BTM_CancelPeriodicInquiry(); } else if (btm_cb.btm_inq_vars.inq_active & normal_active) { /* can not call BTM_CancelInquiry() here. We need to report inquiry complete evt */ btsnd_hcic_inq_cancel(); } } /* do not allow inquiry to start */ btm_cb.btm_inq_vars.inq_active |= BTM_SSP_INQUIRY_ACTIVE; } } /********************************************************************************* ** ** Function btm_inq_clear_ssp ** ** Description This function is called when pairing_state becomes idle ** ** Returns void ** *******************************************************************************/ void btm_inq_clear_ssp(void) { btm_cb.btm_inq_vars.inq_active &= ~BTM_SSP_INQUIRY_ACTIVE; } /********************************************************************************* ** ** Function btm_clr_inq_db ** ** Description This function is called to clear out a device or all devices ** from the inquiry database. ** ** Parameter p_bda - (input) BD_ADDR -> Address of device to clear ** (NULL clears all entries) ** ** Returns void ** *******************************************************************************/ void btm_clr_inq_db (BD_ADDR p_bda) { tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; tINQ_DB_ENT *p_ent = p_inq->inq_db; UINT16 xx; #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG2 ("btm_clr_inq_db: inq_active:0x%x state:%d", btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state); #endif for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if (p_ent->in_use) { /* If this is the specified BD_ADDR or clearing all devices */ if (p_bda == NULL || (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN))) { p_ent->in_use = FALSE; #if (BTM_INQ_GET_REMOTE_NAME == TRUE) p_ent->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY; #endif if (btm_cb.btm_inq_vars.p_inq_change_cb) (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_ent->inq_info, FALSE); } } } #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG2 ("inq_active:0x%x state:%d", btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state); #endif } /******************************************************************************* ** ** Function btm_clr_inq_result_flt ** ** Description This function looks through the bdaddr database for a match ** based on Bluetooth Device Address ** ** Returns TRUE if found, else FALSE (new entry) ** *******************************************************************************/ static void btm_clr_inq_result_flt (void) { #if BTM_USE_INQ_RESULTS_FILTER == TRUE tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; if (p_inq->p_bd_db) { GKI_freebuf(p_inq->p_bd_db); p_inq->p_bd_db = NULL; } p_inq->num_bd_entries = 0; p_inq->max_bd_entries = 0; #endif } /******************************************************************************* ** ** Function btm_inq_find_bdaddr ** ** Description This function looks through the bdaddr database for a match ** based on Bluetooth Device Address ** ** Returns TRUE if found, else FALSE (new entry) ** *******************************************************************************/ BOOLEAN btm_inq_find_bdaddr (BD_ADDR p_bda) { #if BTM_USE_INQ_RESULTS_FILTER == TRUE tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; tINQ_BDADDR *p_db = &p_inq->p_bd_db[0]; UINT16 xx; /* Don't bother searching, database doesn't exist or periodic mode */ if ((p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) || !p_db) return (FALSE); for (xx = 0; xx < p_inq->num_bd_entries; xx++, p_db++) { if (!memcmp(p_db->bd_addr, p_bda, BD_ADDR_LEN) && p_db->inq_count == p_inq->inq_counter) return (TRUE); } if (xx < p_inq->max_bd_entries) { p_db->inq_count = p_inq->inq_counter; memcpy(p_db->bd_addr, p_bda, BD_ADDR_LEN); p_inq->num_bd_entries++; } #endif /* If here, New Entry */ return (FALSE); } /******************************************************************************* ** ** Function btm_inq_db_find ** ** Description This function looks through the inquiry database for a match ** based on Bluetooth Device Address ** ** Returns pointer to entry, or NULL if not found ** *******************************************************************************/ tINQ_DB_ENT *btm_inq_db_find (BD_ADDR p_bda) { UINT16 xx; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if ((p_ent->in_use) && (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN))) return (p_ent); } /* If here, not found */ return (NULL); } /******************************************************************************* ** ** Function btm_inq_db_new ** ** Description This function looks through the inquiry database for an unused ** entry. If no entry is free, it allocates the oldest entry. ** ** Returns pointer to entry ** *******************************************************************************/ tINQ_DB_ENT *btm_inq_db_new (BD_ADDR p_bda) { UINT16 xx; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; tINQ_DB_ENT *p_old = btm_cb.btm_inq_vars.inq_db; UINT32 ot = 0xFFFFFFFF; for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++) { if (!p_ent->in_use) { memset (p_ent, 0, sizeof (tINQ_DB_ENT)); memcpy (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN); p_ent->in_use = TRUE; #if (BTM_INQ_GET_REMOTE_NAME==TRUE) p_ent->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY; #endif return (p_ent); } if (p_ent->time_of_resp < ot) { p_old = p_ent; ot = p_ent->time_of_resp; } } /* If here, no free entry found. Return the oldest. */ /* Before deleting the oldest, if anyone is registered for change */ /* notifications, then tell him we are deleting an entry. */ if (btm_cb.btm_inq_vars.p_inq_change_cb) (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_old->inq_info, FALSE); memset (p_old, 0, sizeof (tINQ_DB_ENT)); memcpy (p_old->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN); p_old->in_use = TRUE; #if (BTM_INQ_GET_REMOTE_NAME==TRUE) p_old->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY; #endif 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 filter_cond_type, tBTM_INQ_FILT_COND *p_filt_cond) { UINT8 condition_length = DEV_CLASS_LEN * 2; UINT8 condition_buf[DEV_CLASS_LEN * 2]; UINT8 *p_cond = condition_buf; /* points to the condition to pass to HCI */ #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG1 ("btm_set_inq_event_filter: filter type %d [Clear-0, COD-1, BDADDR-2]", filter_cond_type); BTM_TRACE_DEBUG6 (" condition [%02x%02x%02x %02x%02x%02x]", p_filt_cond->bdaddr_cond[0], p_filt_cond->bdaddr_cond[1], p_filt_cond->bdaddr_cond[2], p_filt_cond->bdaddr_cond[3], p_filt_cond->bdaddr_cond[4], p_filt_cond->bdaddr_cond[5]); #endif /* Load the correct filter condition to pass to the lower layer */ switch (filter_cond_type) { case BTM_FILTER_COND_DEVICE_CLASS: /* copy the device class and device class fields into contiguous memory to send to HCI */ memcpy (condition_buf, p_filt_cond->cod_cond.dev_class, DEV_CLASS_LEN); memcpy (&condition_buf[DEV_CLASS_LEN], p_filt_cond->cod_cond.dev_class_mask, DEV_CLASS_LEN); /* condition length should already be set as the default */ break; case BTM_FILTER_COND_BD_ADDR: p_cond = p_filt_cond->bdaddr_cond; /* condition length should already be set as the default */ break; case BTM_CLR_INQUIRY_FILTER: condition_length = 0; break; default: return (BTM_ILLEGAL_VALUE); /* Bad parameter was passed in */ } btm_cb.btm_inq_vars.inqfilt_active = TRUE; /* Filter the inquiry results for the specified condition type and value */ if (btsnd_hcic_set_event_filter(HCI_FILTER_INQUIRY_RESULT, filter_cond_type, p_cond, condition_length)) return (BTM_CMD_STARTED); else return (BTM_NO_RESOURCES); } /******************************************************************************* ** ** 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 *p) { UINT8 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_DEBUG3 ("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 == TRUE ) { /* 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_WARNING1 ("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)(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) { if ((status = btm_set_inq_event_filter (p_inq->inqparms.filter_cond_type, &p_inq->inqparms.filter_cond)) == 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)(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 ** ** Description This function is called to start an inquiry or periodic inquiry ** upon completion of the setting and/or clearing of the inquiry filter. ** ** Inputs: p_inq (btm_cb.btm_inq_vars) - pointer to saved inquiry information ** mode - GENERAL or LIMITED inquiry ** duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED) ** max_resps - maximum amount of devices to search for before ending the inquiry ** filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or ** BTM_FILTER_COND_BD_ADDR ** filter_cond - value for the filter (based on filter_cond_type) ** ** Returns If an error occurs the initiator's callback is called with the error status. ** *******************************************************************************/ static void btm_initiate_inquiry (tBTM_INQUIRY_VAR_ST *p_inq) { const LAP *lap; tBTM_INQ_PARMS *p_inqparms = &p_inq->inqparms; #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG3 ("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); #endif #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE) btm_acl_update_busy_level (BTM_BLI_INQ_EVT); #endif if (p_inq->inq_active & BTM_SSP_INQUIRY_ACTIVE) { btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK)); return; } /* Make sure the number of responses doesn't overflow the database configuration */ p_inqparms->max_resps = (UINT8)((p_inqparms->max_resps <= BTM_INQ_DB_SIZE) ? p_inqparms->max_resps : BTM_INQ_DB_SIZE); lap = (p_inq->inq_active & BTM_LIMITED_INQUIRY_ACTIVE) ? &limited_inq_lap : &general_inq_lap; if (p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) { if (!btsnd_hcic_per_inq_mode (p_inq->per_max_delay, p_inq->per_min_delay, *lap, p_inqparms->duration, p_inqparms->max_resps)) btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK)); } else { #if BTM_USE_INQ_RESULTS_FILTER == TRUE btm_clr_inq_result_flt(); /* Allocate memory to hold bd_addrs responding */ if ((p_inq->p_bd_db = (tINQ_BDADDR *)GKI_getbuf(GKI_MAX_BUF_SIZE)) != NULL) { p_inq->max_bd_entries = (UINT16)(GKI_MAX_BUF_SIZE / sizeof(tINQ_BDADDR)); memset(p_inq->p_bd_db, 0, GKI_MAX_BUF_SIZE); /* BTM_TRACE_DEBUG1("btm_initiate_inquiry: memory allocated for %d bdaddrs", p_inq->max_bd_entries); */ } if (!btsnd_hcic_inquiry(*lap, p_inqparms->duration, 0)) #else if (!btsnd_hcic_inquiry(*lap, p_inqparms->duration, p_inqparms->max_resps)) #endif /* BTM_USE_INQ_RESULTS_FILTER */ btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK)); } } /******************************************************************************* ** ** Function btm_process_inq_results ** ** Description This function is called when inquiry results are received from ** the device. It updates the inquiry database. If the inquiry ** database is full, the oldest entry is discarded. ** ** Parameters inq_res_mode - BTM_INQ_RESULT_STANDARD ** BTM_INQ_RESULT_WITH_RSSI ** BTM_INQ_RESULT_EXTENDED ** ** Returns void ** *******************************************************************************/ void btm_process_inq_results (UINT8 *p, UINT8 inq_res_mode) { UINT8 num_resp, xx; BD_ADDR bda; tINQ_DB_ENT *p_i; tBTM_INQ_RESULTS *p_cur; BOOLEAN is_new = TRUE; BOOLEAN update = FALSE; INT8 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; UINT8 page_scan_rep_mode = 0; UINT8 page_scan_per_mode = 0; UINT8 page_scan_mode = 0; UINT8 rssi = 0; DEV_CLASS dc; UINT16 clock_offset; #if (BTM_EIR_CLIENT_INCLUDED == TRUE) UINT8 *p_eir_data = NULL; #if (BTM_INQ_GET_REMOTE_NAME==TRUE) UINT8 remote_name_len; #endif #endif #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG3 ("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); #endif /* Only process the results if the inquiry is still active */ if (!p_inq->inq_active) return; STREAM_TO_UINT8 (num_resp, p); for (xx = 0; xx < num_resp; xx++) { update = FALSE; /* Extract inquiry results */ STREAM_TO_BDADDR (bda, p); STREAM_TO_UINT8 (page_scan_rep_mode, p); STREAM_TO_UINT8 (page_scan_per_mode, p); if (inq_res_mode == BTM_INQ_RESULT_STANDARD) { STREAM_TO_UINT8(page_scan_mode, p); } STREAM_TO_DEVCLASS (dc, p); STREAM_TO_UINT16 (clock_offset, p); if (inq_res_mode != BTM_INQ_RESULT_STANDARD) { STREAM_TO_UINT8(rssi, p); } p_i = btm_inq_db_find (bda); #if BTM_USE_INQ_RESULTS_FILTER == TRUE /* Only process the num_resp is smaller than max_resps. If results are queued to BTU task while canceling inquiry, or when more than one result is in this response, > max_resp responses could be processed which can confuse some apps */ if (p_inq->inqparms.max_resps && p_inq->inq_cmpl_info.num_resp >= p_inq->inqparms.max_resps #if BLE_INCLUDED == TRUE /* new device response */ && ( p_i == NULL || /* exisiting device with BR/EDR info */ (p_i && (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) != 0) ) #endif ) { /* BTM_TRACE_WARNING0("INQ RES: Extra Response Received...ignoring"); */ return; } #endif /* Check if this address has already been processed for this inquiry */ if (btm_inq_find_bdaddr(bda)) { /* BTM_TRACE_DEBUG6("BDA seen before [%02x%02x %02x%02x %02x%02x]", bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);*/ /* By default suppose no update needed */ i_rssi = (INT8)rssi; /* If this new RSSI is higher than the last one */ if(p_inq->inqparms.report_dup && (rssi != 0) && p_i && (i_rssi > p_i->inq_info.results.rssi || p_i->inq_info.results.rssi == 0 #if BLE_INCLUDED == TRUE /* BR/EDR inquiry information update */ || (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) != 0 #endif )) { p_cur = &p_i->inq_info.results; BTM_TRACE_DEBUG2("update RSSI new:%d, old:%d", i_rssi, p_cur->rssi); p_cur->rssi = i_rssi; update = TRUE; } /* If we received a second Extended Inq Event for an already */ /* discovered device, this is because for the first one EIR was not received */ else if ((inq_res_mode == BTM_INQ_RESULT_EXTENDED) && (p_i)) { p_cur = &p_i->inq_info.results; update = TRUE; } /* If no update needed continue with next response (if any) */ else continue; } /* Host can be registered to verify comming BDA or DC */ if (btm_cb.p_inq_filter_cb) { if (!(* btm_cb.p_inq_filter_cb) (bda, dc)) { continue; } } /* If existing entry, use that, else get a new one (possibly reusing the oldest) */ if (p_i == NULL) { p_i = btm_inq_db_new (bda); is_new = TRUE; } /* If an entry for the device already exists, overwrite it ONLY if it is from a previous inquiry. (Ignore it if it is a duplicate response from the same inquiry. */ else if (p_i->inq_count == p_inq->inq_counter #if (BLE_INCLUDED == TRUE ) && (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) #endif ) is_new = FALSE; /* keep updating RSSI to have latest value */ if( inq_res_mode != BTM_INQ_RESULT_STANDARD ) p_i->inq_info.results.rssi = (INT8)rssi; else p_i->inq_info.results.rssi = BTM_INQ_RES_IGNORE_RSSI; if (is_new == TRUE) { /* Save the info */ p_cur = &p_i->inq_info.results; p_cur->page_scan_rep_mode = page_scan_rep_mode; p_cur->page_scan_per_mode = page_scan_per_mode; p_cur->page_scan_mode = page_scan_mode; p_cur->dev_class[0] = dc[0]; p_cur->dev_class[1] = dc[1]; p_cur->dev_class[2] = dc[2]; p_cur->clock_offset = clock_offset | BTM_CLOCK_OFFSET_VALID; p_i->time_of_resp = GKI_get_tick_count (); if (p_i->inq_count != p_inq->inq_counter) p_inq->inq_cmpl_info.num_resp++; /* A new response was found */ #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE) p_cur->inq_result_type = BTM_INQ_RESULT_BR; if (p_i->inq_count != p_inq->inq_counter) { p_cur->device_type = BT_DEVICE_TYPE_BREDR; p_i->scan_rsp = FALSE; } else p_cur->device_type |= BT_DEVICE_TYPE_BREDR; #endif p_i->inq_count = p_inq->inq_counter; /* Mark entry for current inquiry */ #if BTM_USE_INQ_RESULTS_FILTER == TRUE /* If the number of responses found and not unlimited, issue a cancel inquiry */ if (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) && p_inq->inqparms.max_resps && p_inq->inq_cmpl_info.num_resp == p_inq->inqparms.max_resps #if BLE_INCLUDED == TRUE /* BLE scanning is active and received adv */ && ((((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0) && p_cur->device_type == BT_DEVICE_TYPE_DUMO && p_i->scan_rsp) || (p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) == 0) #endif ) { /* BTM_TRACE_DEBUG0("BTMINQ: Found devices, cancelling inquiry..."); */ btsnd_hcic_inq_cancel(); #if BLE_INCLUDED == TRUE if ((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0) btm_ble_stop_scan(); #endif #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE) btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT); #endif } #endif /* Initialize flag to FALSE. This flag is set/used by application */ p_i->inq_info.appl_knows_rem_name = FALSE; } if (is_new || update) { #if (BTM_INQ_GET_REMOTE_NAME==TRUE) #if (BTM_EIR_CLIENT_INCLUDED == TRUE) if( inq_res_mode == BTM_INQ_RESULT_EXTENDED ) { if((p_eir_data = BTM_CheckEirData( p, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len )) == NULL) { p_eir_data = BTM_CheckEirData( p, BTM_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len ); } if( p_eir_data ) { if( remote_name_len > BTM_MAX_REM_BD_NAME_LEN ) remote_name_len = BTM_MAX_REM_BD_NAME_LEN; p_i->inq_info.remote_name_len = remote_name_len; memcpy( p_i->inq_info.remote_name, p_eir_data, p_i->inq_info.remote_name_len ); p_i->inq_info.remote_name[p_i->inq_info.remote_name_len] = 0; p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_DONE; } else p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY; } else #endif { /* Clear out the device name so that it can be re-read */ p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY; } #endif /*(BTM_INQ_GET_REMOTE_NAME==TRUE)*/ #if (BTM_EIR_CLIENT_INCLUDED == TRUE) if( inq_res_mode == BTM_INQ_RESULT_EXTENDED ) { memset( p_cur->eir_uuid, 0, BTM_EIR_SERVICE_ARRAY_SIZE * (BTM_EIR_ARRAY_BITS/8)); /* set bit map of UUID list from received EIR */ btm_set_eir_uuid( p, p_cur ); p_eir_data = p; } else p_eir_data = NULL; #endif /* If a callback is registered, call it with the results */ if (p_inq_results_cb) #if (BTM_EIR_CLIENT_INCLUDED == TRUE) (p_inq_results_cb)((tBTM_INQ_RESULTS *) p_cur, p_eir_data); #else (p_inq_results_cb)((tBTM_INQ_RESULTS *) p_cur, NULL); #endif /* If anyone is registered for change notifications, then tell him we added an entry. */ if (p_inq->p_inq_change_cb) (*p_inq->p_inq_change_cb) (&p_i->inq_info, TRUE); } } } /******************************************************************************* ** ** Function btm_sort_inq_result ** ** Description This function is called when inquiry complete is received ** from the device to sort inquiry results based on rssi. ** ** Returns void ** *******************************************************************************/ void btm_sort_inq_result(void) { UINT8 xx, yy, num_resp; tINQ_DB_ENT *p_tmp = NULL; tINQ_DB_ENT *p_ent = btm_cb.btm_inq_vars.inq_db; tINQ_DB_ENT *p_next = btm_cb.btm_inq_vars.inq_db+1; int size; num_resp = (btm_cb.btm_inq_vars.inq_cmpl_info.num_respinq_info.results.rssi < p_next->inq_info.results.rssi) { memcpy (p_tmp, p_next, size); memcpy (p_next, p_ent, size); memcpy (p_ent, p_tmp, size); } } } GKI_freebuf(p_tmp); } } /******************************************************************************* ** ** Function btm_process_inq_complete ** ** Description This function is called when inquiry complete is received ** from the device. Call the callback if not in periodic inquiry ** mode AND it is not NULL (The caller wants the event). ** ** The callback pass back the status and the number of responses ** ** Returns void ** *******************************************************************************/ void btm_process_inq_complete (UINT8 status, UINT8 mode) { tBTM_CMPL_CB *p_inq_cb = btm_cb.btm_inq_vars.p_inq_cmpl_cb; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; #if (BTM_INQ_GET_REMOTE_NAME==TRUE) tBTM_INQ_INFO *p_cur; UINT8 tempstate; #endif p_inq->inqparms.mode &= ~(mode); #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG3 ("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); #endif #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE) btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT); #endif /* Ignore any stray or late complete messages if the inquiry is not active */ if (p_inq->inq_active) { p_inq->inq_cmpl_info.status = (tBTM_STATUS)((status == HCI_SUCCESS) ? BTM_SUCCESS : BTM_ERR_PROCESSING); #if (BTM_INQ_GET_REMOTE_NAME==TRUE) if (p_inq->inq_cmpl_info.status == BTM_SUCCESS) { for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur)) { if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_EMPTY) { tempstate = p_cur->remote_name_state; p_cur->remote_name_state = BTM_INQ_RMT_NAME_PENDING; if (btm_initiate_rem_name (p_cur->results.remote_bd_addr, p_cur, BTM_RMT_NAME_INQ, BTM_INQ_RMT_NAME_TIMEOUT, NULL) != BTM_CMD_STARTED) p_cur->remote_name_state = tempstate; else return; } } } #endif /* Notify caller that the inquiry has completed; (periodic inquiries do not send completion events */ if (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) && p_inq->inqparms.mode == 0) { p_inq->state = BTM_INQ_INACTIVE_STATE; /* Increment so the start of a next inquiry has a new count */ p_inq->inq_counter++; btm_clr_inq_result_flt(); if((p_inq->inq_cmpl_info.status == BTM_SUCCESS) && HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_features)) { btm_sort_inq_result(); } /* Clear the results callback if set */ p_inq->p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL; p_inq->inq_active = BTM_INQUIRY_INACTIVE; p_inq->p_inq_cmpl_cb = (tBTM_CMPL_CB *) NULL; /* If we have a callback registered for inquiry complete, call it */ BTM_TRACE_DEBUG2 ("BTM Inq Compl Callback: status 0x%02x, num results %d", p_inq->inq_cmpl_info.status, p_inq->inq_cmpl_info.num_resp); if (p_inq_cb) (p_inq_cb)((tBTM_INQUIRY_CMPL *) &p_inq->inq_cmpl_info); } } #if (BTM_INQ_DEBUG == TRUE) BTM_TRACE_DEBUG3 ("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 } /******************************************************************************* ** ** Function btm_process_cancel_complete ** ** Description This function is called when inquiry cancel complete is received ** from the device.This function will also call the btm_process_inq_complete ** This function is needed to differentiate a cancel_cmpl_evt from the ** inq_cmpl_evt ** ** Returns void ** *******************************************************************************/ void btm_process_cancel_complete(UINT8 status, UINT8 mode) { #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE) btm_acl_update_busy_level (BTM_BLI_INQ_CANCEL_EVT); #endif btm_process_inq_complete(status, mode); } /******************************************************************************* ** ** Function btm_initiate_rem_name ** ** Description This function looks initiates a remote name request. It is called ** either by GAP or by the API call BTM_ReadRemoteDeviceName. ** ** Input Params: p_cur - pointer to an inquiry result structure (NULL if nonexistent) ** p_cb - callback function called when BTM_CMD_STARTED ** is returned. ** A pointer to tBTM_REMOTE_DEV_NAME is passed to the ** callback. ** ** Returns ** BTM_CMD_STARTED is returned if the request was sent to HCI. ** BTM_BUSY if already in progress ** BTM_NO_RESOURCES if could not allocate resources to start the command ** BTM_WRONG_MODE if the device is not up. ** *******************************************************************************/ tBTM_STATUS btm_initiate_rem_name (BD_ADDR remote_bda, tBTM_INQ_INFO *p_cur, UINT8 origin, UINT32 timeout, tBTM_CMPL_CB *p_cb) { tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; BOOLEAN cmd_ok; /*** Make sure the device is ready ***/ if (!BTM_IsDeviceUp()) return (BTM_WRONG_MODE); if (origin == BTM_RMT_NAME_SEC) { cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, HCI_PAGE_SCAN_REP_MODE_R1, HCI_MANDATARY_PAGE_SCAN_MODE, 0); if (cmd_ok) return BTM_CMD_STARTED; else return BTM_NO_RESOURCES; } /* Make sure there are no two remote name requests from external API in progress */ else if (origin == BTM_RMT_NAME_EXT) { if (p_inq->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; memcpy(p_inq->remname_bda, remote_bda, BD_ADDR_LEN); btu_start_timer (&p_inq->rmt_name_timer_ent, BTU_TTYPE_BTM_RMT_NAME, timeout); /* If the database entry exists for the device, use its clock offset */ if (p_cur) { cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, p_cur->results.page_scan_rep_mode, p_cur->results.page_scan_mode, (UINT16)(p_cur->results.clock_offset | BTM_CLOCK_OFFSET_VALID)); } else /* Otherwise use defaults and mark the clock offset as invalid */ { cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, HCI_PAGE_SCAN_REP_MODE_R1, HCI_MANDATARY_PAGE_SCAN_MODE, 0); } if (cmd_ok) { p_inq->remname_active = TRUE; return BTM_CMD_STARTED; } else return BTM_NO_RESOURCES; } } /* If the inquire feature is on */ #if (BTM_INQ_GET_REMOTE_NAME==TRUE) else if (origin == BTM_RMT_NAME_INQ) { /* If the database entry exists for the device, use its clock offset */ if (p_cur) { cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, p_cur->results.page_scan_rep_mode, p_cur->results.page_scan_mode, (UINT16)(p_cur->results.clock_offset | BTM_CLOCK_OFFSET_VALID)); } else { cmd_ok = FALSE } if (cmd_ok) return BTM_CMD_STARTED; else return BTM_NO_RESOURCES; } #endif else { return BTM_ILLEGAL_VALUE; } } /******************************************************************************* ** ** Function btm_process_remote_name ** ** Description This function is called when a remote name is received from ** the device. If remote names are cached, it updates the inquiry ** database. ** ** Returns void ** *******************************************************************************/ void btm_process_remote_name (BD_ADDR bda, BD_NAME bdn, UINT16 evt_len, UINT8 hci_status) { tBTM_REMOTE_DEV_NAME rem_name = {0}; tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars; tBTM_CMPL_CB *p_cb = p_inq->p_remname_cmpl_cb; UINT8 *p_n1; UINT16 temp_evt_len; #if (BTM_INQ_GET_REMOTE_NAME==TRUE) /*** These are only used if part of the Inquiry Process ***/ tBTM_CMPL_CB *p_inq_cb; tINQ_DB_ENT *p_i = NULL; UINT8 *p_n; tBTM_INQ_INFO *p_cur; #endif #if BLE_INCLUDED == TRUE tBT_DEVICE_TYPE dev_type; tBLE_ADDR_TYPE addr_type; #endif if (bda != NULL) { BTM_TRACE_EVENT6("BDA %02x:%02x:%02x:%02x:%02x:%02x",bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]); } BTM_TRACE_EVENT6("Inquire BDA %02x:%02x:%02x:%02x:%02x:%02x",p_inq->remname_bda[0], p_inq->remname_bda[1], p_inq->remname_bda[2], p_inq->remname_bda[3], p_inq->remname_bda[4], p_inq->remname_bda[5]); /* 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 ==TRUE)&& (((bda != NULL) && (memcmp(bda, p_inq->remname_bda,BD_ADDR_LEN)==0)) || bda == NULL)) { #if BLE_INCLUDED == TRUE BTM_ReadDevInfo(p_inq->remname_bda, &dev_type, &addr_type); if (dev_type == BT_DEVICE_TYPE_BLE) { if (hci_status == HCI_ERR_UNSPECIFIED) btm_ble_cancel_remote_name(p_inq->remname_bda); } #endif btu_stop_timer (&p_inq->rmt_name_timer_ent); p_inq->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. */ if ((hci_status == HCI_SUCCESS)) { /* Copy the name from the data stream into the return structure */ /* Note that even if it is not being returned, it is used as a */ /* temporary buffer. */ p_n1 = (UINT8 *)rem_name.remote_bd_name; rem_name.length = (evt_len < BD_NAME_LEN) ? evt_len : BD_NAME_LEN; rem_name.status = BTM_SUCCESS; temp_evt_len = rem_name.length; while (temp_evt_len > 0) { *p_n1++ = *bdn++; temp_evt_len--; } } /* If processing a stand alone remote name then report the error in the callback */ else { rem_name.status = BTM_BAD_VALUE_RET; rem_name.length = 0; rem_name.remote_bd_name[0] = 0; } /* Reset the remote BAD to zero and call callback if possible */ memset(p_inq->remname_bda, 0, BD_ADDR_LEN); p_inq->p_remname_cmpl_cb = NULL; if (p_cb) (p_cb)((tBTM_REMOTE_DEV_NAME *)&rem_name); } #if (BTM_INQ_GET_REMOTE_NAME==TRUE) /* If existing entry, update the name */ if ((bda != NULL) && ((p_i = btm_inq_db_find (bda)) != NULL) && (hci_status == HCI_SUCCESS)) { p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_DONE; p_n = p_i->inq_info.remote_name; memset(p_n, 0, BTM_MAX_REM_BD_NAME_LEN + 1); p_i->inq_info.remote_name_len = (rem_name.length < BTM_MAX_REM_BD_NAME_LEN) ? rem_name.length : BTM_MAX_REM_BD_NAME_LEN; evt_len = p_i->inq_info.remote_name_len; p_n1 = (UINT8 *)rem_name.remote_bd_name; while (evt_len > 0) { *p_n++ = *p_n1++; evt_len--; } if (btm_cb.btm_inq_vars.p_inq_change_cb) (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_i->inq_info, TRUE); } else { if (p_i) p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_FAILED; else { /* Find the entry which is currently doing name request */ for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur)) { if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_PENDING) { /* Should be only one */ p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED; break; } } } } /* If an inquiry is in progress then update other entries */ if (p_inq->inq_active) { /* Check if there are any more entries inquired but not named */ for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur)) { if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_EMPTY) { p_cur->remote_name_state = BTM_INQ_RMT_NAME_PENDING; #if (BLE_INCLUDED == TRUE) BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type); if (dev_type == BT_DEVICE_TYPE_BLE) { if (btm_ble_read_remote_name(remote_bda, p_cur, p_cb) != BTM_CMD_STARTED) p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED; else return; } else #endif { if (btm_initiate_rem_name (p_cur->results.remote_bd_addr, p_cur, BTM_RMT_NAME_INQ, BTM_INQ_RMT_NAME_TIMEOUT, NULL) != BTM_CMD_STARTED) p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED; else return; } } } /* The inquiry has finished so call the callback for the inquiry */ p_inq_cb = p_inq->p_inq_cmpl_cb; p_inq->state = BTM_INQ_INACTIVE_STATE; p_inq->inq_active = BTM_INQUIRY_INACTIVE; p_inq->p_inq_cmpl_cb = NULL; /* If we have a callback registered for inquiry complete, call it */ if (p_inq_cb) (p_inq_cb)((tBTM_INQUIRY_CMPL *) &p_inq->inq_cmpl_info); /* In some cases we can not get name of the device once but will be */ /* able to do it next time. Until we have better solution we will */ /* try to get name every time */ for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur)) { if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_FAILED) p_cur->remote_name_state = BTM_INQ_RMT_NAME_EMPTY; } } #endif /* BTM_INQ_GET_REMOTE_NAME == TRUE */ } /******************************************************************************* ** ** Function btm_inq_rmt_name_failed ** ** Description This function is if timeout expires while getting remote ** name. This is done for devices that incorrectly do not ** report operation failure ** ** Returns void ** *******************************************************************************/ void btm_inq_rmt_name_failed (void) { BTM_TRACE_ERROR1 ("btm_inq_rmt_name_failed() remname_active=%d", btm_cb.btm_inq_vars.remname_active); if (btm_cb.btm_inq_vars.remname_active) btm_process_remote_name (btm_cb.btm_inq_vars.remname_bda, NULL, 0, HCI_ERR_UNSPECIFIED); else btm_process_remote_name (NULL, NULL, 0, HCI_ERR_UNSPECIFIED); btm_sec_rmt_name_request_complete (NULL, NULL, HCI_ERR_UNSPECIFIED); } /******************************************************************************* ** ** Function btm_read_linq_tx_power_complete ** ** Description read inquiry tx power level complete callback function. ** ** Returns void ** *******************************************************************************/ void btm_read_linq_tx_power_complete(UINT8 *p) { tBTM_CMPL_CB *p_cb = btm_cb.devcb.p_txpwer_cmpl_cb; tBTM_INQ_TXPWR_RESULTS results; btu_stop_timer (&btm_cb.devcb.txpwer_timer); /* If there was a callback registered for read inq tx power, call it */ btm_cb.devcb.p_txpwer_cmpl_cb = NULL; if (p_cb) { STREAM_TO_UINT8 (results.hci_status, p); if (results.hci_status == HCI_SUCCESS) { results.status = BTM_SUCCESS; STREAM_TO_UINT8 (results.tx_power, p); BTM_TRACE_EVENT2 ("BTM INQ TX POWER Complete: tx_power %d, hci status 0x%02x", results.tx_power, results.hci_status); } else results.status = BTM_ERR_PROCESSING; (*p_cb)(&results); } } /******************************************************************************* ** ** Function BTM_WriteEIR ** ** Description This function is called to write EIR data to controller. ** ** Parameters p_buff - allocated HCI command buffer including extended ** inquriry response ** ** Returns BTM_SUCCESS - if successful ** BTM_MODE_UNSUPPORTED - if local device cannot support it ** *******************************************************************************/ tBTM_STATUS BTM_WriteEIR( BT_HDR *p_buff ) { #if (BTM_EIR_SERVER_INCLUDED == TRUE) if (HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_features)) { BTM_TRACE_API0("Write Extended Inquiry Response to controller"); btsnd_hcic_write_ext_inquiry_response (p_buff, BTM_EIR_DEFAULT_FEC_REQUIRED); return BTM_SUCCESS; } else { GKI_freebuf(p_buff); return BTM_MODE_UNSUPPORTED; } #else GKI_freebuf(p_buff); return BTM_SUCCESS; #endif } /******************************************************************************* ** ** Function BTM_CheckEirData ** ** Description This function is called to get EIR data from significant part. ** ** Parameters p_eir - pointer of EIR significant part ** type - finding EIR data type ** p_length - return the length of EIR data not including type ** ** Returns pointer of EIR data ** *******************************************************************************/ UINT8 *BTM_CheckEirData( UINT8 *p_eir, UINT8 type, UINT8 *p_length ) { #if (BTM_EIR_CLIENT_INCLUDED == TRUE) UINT8 *p = p_eir; UINT8 length; UINT8 eir_type; BTM_TRACE_API1("BTM_CheckEirData type=0x%02X", type); STREAM_TO_UINT8(length, p); while( length && (p - p_eir <= HCI_EXT_INQ_RESPONSE_LEN)) { STREAM_TO_UINT8(eir_type, p); if( eir_type == type ) { /* length doesn't include itself */ *p_length = length - 1; /* minus the length of type */ return p; } p += length - 1; /* skip the length of data */ STREAM_TO_UINT8(length, p); } *p_length = 0; return NULL; #else return NULL; #endif } /******************************************************************************* ** ** Function btm_convert_uuid_to_eir_service ** ** Description This function is called to get the bit position of UUID. ** ** Parameters uuid16 - UUID 16-bit ** ** Returns BTM EIR service ID if found ** BTM_EIR_MAX_SERVICES - if not found ** *******************************************************************************/ #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE )) static UINT8 btm_convert_uuid_to_eir_service( UINT16 uuid16 ) { UINT8 xx; for( xx = 0; xx < BTM_EIR_MAX_SERVICES; xx++ ) { if( uuid16 == BTM_EIR_UUID_LKUP_TBL[xx]) { return xx; } } return BTM_EIR_MAX_SERVICES; } #endif /******************************************************************************* ** ** Function BTM_HasEirService ** ** Description This function is called to know if UUID in bit map of UUID. ** ** Parameters p_eir_uuid - bit map of UUID list ** uuid16 - UUID 16-bit ** ** Returns TRUE - if found ** FALSE - if not found ** *******************************************************************************/ BOOLEAN BTM_HasEirService( UINT32 *p_eir_uuid, UINT16 uuid16 ) { #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE)) UINT8 service_id; service_id = btm_convert_uuid_to_eir_service(uuid16); if( service_id < BTM_EIR_MAX_SERVICES ) return( BTM_EIR_HAS_SERVICE( p_eir_uuid, service_id )); else return( FALSE ); #else return( FALSE ); #endif } /******************************************************************************* ** ** Function BTM_HasInquiryEirService ** ** Description This function is called to know if UUID in bit map of UUID list. ** ** Parameters p_results - inquiry results ** uuid16 - UUID 16-bit ** ** Returns BTM_EIR_FOUND - if found ** BTM_EIR_NOT_FOUND - if not found and it is complete list ** BTM_EIR_UNKNOWN - if not found and it is not complete list ** *******************************************************************************/ tBTM_EIR_SEARCH_RESULT BTM_HasInquiryEirService( tBTM_INQ_RESULTS *p_results, UINT16 uuid16 ) { #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE)) if( BTM_HasEirService( p_results->eir_uuid, uuid16 )) { return BTM_EIR_FOUND; } else if( p_results->eir_complete_list ) { return BTM_EIR_NOT_FOUND; } else return BTM_EIR_UNKNOWN; #else return BTM_EIR_UNKNOWN; #endif } /******************************************************************************* ** ** Function BTM_AddEirService ** ** Description This function is called to add a service in bit map of UUID list. ** ** Parameters p_eir_uuid - bit mask of UUID list for EIR ** uuid16 - UUID 16-bit ** ** Returns None ** *******************************************************************************/ void BTM_AddEirService( UINT32 *p_eir_uuid, UINT16 uuid16 ) { #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE)) UINT8 service_id; service_id = btm_convert_uuid_to_eir_service(uuid16); if( service_id < BTM_EIR_MAX_SERVICES ) BTM_EIR_SET_SERVICE( p_eir_uuid, service_id ); #endif } /******************************************************************************* ** ** Function BTM_RemoveEirService ** ** Description This function is called to remove a service in bit map of UUID list. ** ** Parameters p_eir_uuid - bit mask of UUID list for EIR ** uuid16 - UUID 16-bit ** ** Returns None ** *******************************************************************************/ void BTM_RemoveEirService( UINT32 *p_eir_uuid, UINT16 uuid16 ) { #if (BTM_EIR_SERVER_INCLUDED == TRUE) UINT8 service_id; service_id = btm_convert_uuid_to_eir_service(uuid16); if( service_id < BTM_EIR_MAX_SERVICES ) BTM_EIR_CLR_SERVICE( p_eir_uuid, service_id ); #endif } /******************************************************************************* ** ** Function BTM_GetEirSupportedServices ** ** Description This function is called to get UUID list from bit map of UUID list. ** ** Parameters p_eir_uuid - bit mask of UUID list for EIR ** p - reference of current pointer of EIR ** max_num_uuid16 - max number of UUID can be written in EIR ** num_uuid16 - number of UUID have been written in EIR ** ** Returns BTM_EIR_MORE_16BITS_UUID_TYPE, if it has more than max ** BTM_EIR_COMPLETE_16BITS_UUID_TYPE, otherwise ** *******************************************************************************/ UINT8 BTM_GetEirSupportedServices( UINT32 *p_eir_uuid, UINT8 **p, UINT8 max_num_uuid16, UINT8 *p_num_uuid16) { #if (BTM_EIR_SERVER_INCLUDED == TRUE) UINT8 service_index; *p_num_uuid16 = 0; for(service_index = 0; service_index < BTM_EIR_MAX_SERVICES; service_index++) { if( BTM_EIR_HAS_SERVICE( p_eir_uuid, service_index )) { if( *p_num_uuid16 < max_num_uuid16 ) { UINT16_TO_STREAM(*p, BTM_EIR_UUID_LKUP_TBL[service_index]); (*p_num_uuid16)++; } /* if max number of UUIDs are stored and found one more */ else { return BTM_EIR_MORE_16BITS_UUID_TYPE; } } } return BTM_EIR_COMPLETE_16BITS_UUID_TYPE; #else return BTM_EIR_COMPLETE_16BITS_UUID_TYPE; #endif } /******************************************************************************* ** ** Function BTM_GetEirUuidList ** ** Description This function parses EIR and returns UUID list. ** ** Parameters p_eir - EIR ** uuid_size - LEN_UUID_16, LEN_UUID_32, LEN_UUID_128 ** p_num_uuid - return number of UUID in found list ** p_uuid_list - return UUID list ** max_num_uuid - maximum number of UUID to be returned ** ** Returns 0 - if not found ** BTM_EIR_COMPLETE_16BITS_UUID_TYPE ** BTM_EIR_MORE_16BITS_UUID_TYPE ** BTM_EIR_COMPLETE_32BITS_UUID_TYPE ** BTM_EIR_MORE_32BITS_UUID_TYPE ** BTM_EIR_COMPLETE_128BITS_UUID_TYPE ** BTM_EIR_MORE_128BITS_UUID_TYPE ** *******************************************************************************/ UINT8 BTM_GetEirUuidList( UINT8 *p_eir, UINT8 uuid_size, UINT8 *p_num_uuid, UINT8 *p_uuid_list, UINT8 max_num_uuid) { #if (BTM_EIR_CLIENT_INCLUDED == TRUE) UINT8 *p_uuid_data; UINT8 type; UINT8 yy, xx; UINT16 *p_uuid16 = (UINT16 *)p_uuid_list; UINT32 *p_uuid32 = (UINT32 *)p_uuid_list; char buff[LEN_UUID_128 * 2 + 1]; p_uuid_data = btm_eir_get_uuid_list( p_eir, uuid_size, p_num_uuid, &type ); if( p_uuid_data == NULL ) { return 0x00; } if( *p_num_uuid > max_num_uuid ) { BTM_TRACE_WARNING2("BTM_GetEirUuidList number of uuid in EIR = %d, size of uuid list = %d", *p_num_uuid, max_num_uuid ); *p_num_uuid = max_num_uuid; } BTM_TRACE_DEBUG2("BTM_GetEirUuidList type = %02X, number of uuid = %d", type, *p_num_uuid ); if( uuid_size == LEN_UUID_16 ) { for( yy = 0; yy < *p_num_uuid; yy++ ) { STREAM_TO_UINT16(*(p_uuid16 + yy), p_uuid_data); BTM_TRACE_DEBUG1(" 0x%04X", *(p_uuid16 + yy)); } } else if( uuid_size == LEN_UUID_32 ) { for( yy = 0; yy < *p_num_uuid; yy++ ) { STREAM_TO_UINT32(*(p_uuid32 + yy), p_uuid_data); BTM_TRACE_DEBUG1(" 0x%08X", *(p_uuid32 + yy)); } } else if( uuid_size == LEN_UUID_128 ) { for( yy = 0; yy < *p_num_uuid; yy++ ) { STREAM_TO_ARRAY16(p_uuid_list + yy * LEN_UUID_128, p_uuid_data); for( xx = 0; xx < LEN_UUID_128; xx++ ) sprintf(buff + xx*2, "%02X", *(p_uuid_list + yy * LEN_UUID_128 + xx)); BTM_TRACE_DEBUG1(" 0x%s", buff); } } return type; #else *p_num_uuid = 0; return 0x00; #endif } #if (BTM_EIR_CLIENT_INCLUDED == TRUE) /******************************************************************************* ** ** Function btm_eir_get_uuid_list ** ** Description This function searches UUID list in EIR. ** ** Parameters p_eir - address of EIR ** uuid_size - size of UUID to find ** p_num_uuid - number of UUIDs found ** p_uuid_list_type - EIR data type ** ** Returns NULL - if UUID list with uuid_size is not found ** beginning of UUID list in EIR - otherwise ** *******************************************************************************/ static UINT8 *btm_eir_get_uuid_list( UINT8 *p_eir, UINT8 uuid_size, UINT8 *p_num_uuid, UINT8 *p_uuid_list_type ) { UINT8 *p_uuid_data; UINT8 complete_type, more_type; UINT8 uuid_len; switch( uuid_size ) { case LEN_UUID_16: complete_type = BTM_EIR_COMPLETE_16BITS_UUID_TYPE; more_type = BTM_EIR_MORE_16BITS_UUID_TYPE; break; case LEN_UUID_32: complete_type = BTM_EIR_COMPLETE_32BITS_UUID_TYPE; more_type = BTM_EIR_MORE_32BITS_UUID_TYPE; break; case LEN_UUID_128: complete_type = BTM_EIR_COMPLETE_128BITS_UUID_TYPE; more_type = BTM_EIR_MORE_128BITS_UUID_TYPE; break; default: *p_num_uuid = 0; return NULL; break; } p_uuid_data = BTM_CheckEirData( p_eir, complete_type, &uuid_len ); if(p_uuid_data == NULL) { p_uuid_data = BTM_CheckEirData( p_eir, more_type, &uuid_len ); *p_uuid_list_type = more_type; } else { *p_uuid_list_type = complete_type; } *p_num_uuid = uuid_len / uuid_size; return p_uuid_data; } /******************************************************************************* ** ** Function btm_convert_uuid_to_uuid16 ** ** Description This function converts UUID to UUID 16-bit. ** ** Parameters p_uuid - address of UUID ** uuid_size - size of UUID ** ** Returns 0 - if UUID cannot be converted to UUID 16-bit ** UUID 16-bit - otherwise ** *******************************************************************************/ static UINT16 btm_convert_uuid_to_uuid16( UINT8 *p_uuid, UINT8 uuid_size ) { static const UINT8 base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; UINT16 uuid16 = 0; UINT32 uuid32; BOOLEAN is_base_uuid; UINT8 xx; switch (uuid_size) { case LEN_UUID_16: STREAM_TO_UINT16 (uuid16, p_uuid); break; case LEN_UUID_32: STREAM_TO_UINT32 (uuid32, p_uuid); if (uuid32 < 0x10000) uuid16 = (UINT16) uuid32; break; case LEN_UUID_128: /* See if we can compress his UUID down to 16 or 32bit UUIDs */ is_base_uuid = TRUE; for (xx = 0; xx < LEN_UUID_128 - 4; xx++) { if (p_uuid[xx] != base_uuid[xx]) { is_base_uuid = FALSE; break; } } if (is_base_uuid) { if ((p_uuid[LEN_UUID_128 - 1] == 0) && (p_uuid[LEN_UUID_128 - 2] == 0)) { p_uuid += (LEN_UUID_128 - 4); STREAM_TO_UINT16(uuid16, p_uuid); } } break; default: BTM_TRACE_WARNING0("btm_convert_uuid_to_uuid16 invalid uuid size"); break; } return( uuid16); } /******************************************************************************* ** ** Function btm_set_eir_uuid ** ** Description This function is called to store received UUID into inquiry result. ** ** Parameters p_eir - pointer of EIR significant part ** p_results - pointer of inquiry result ** ** Returns None ** *******************************************************************************/ void btm_set_eir_uuid( UINT8 *p_eir, tBTM_INQ_RESULTS *p_results ) { UINT8 *p_uuid_data; UINT8 num_uuid; UINT16 uuid16; UINT8 yy; UINT8 type = BTM_EIR_MORE_16BITS_UUID_TYPE; p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_16, &num_uuid, &type ); if(type == BTM_EIR_COMPLETE_16BITS_UUID_TYPE) { p_results->eir_complete_list = TRUE; } else { p_results->eir_complete_list = FALSE; } BTM_TRACE_API1("btm_set_eir_uuid eir_complete_list=0x%02X", p_results->eir_complete_list); if( p_uuid_data ) { for( yy = 0; yy < num_uuid; yy++ ) { STREAM_TO_UINT16(uuid16, p_uuid_data); BTM_AddEirService( p_results->eir_uuid, uuid16 ); } } p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_32, &num_uuid, &type ); if( p_uuid_data ) { for( yy = 0; yy < num_uuid; yy++ ) { uuid16 = btm_convert_uuid_to_uuid16( p_uuid_data, LEN_UUID_32 ); p_uuid_data += LEN_UUID_32; if( uuid16 ) BTM_AddEirService( p_results->eir_uuid, uuid16 ); } } p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_128, &num_uuid, &type ); if( p_uuid_data ) { for( yy = 0; yy < num_uuid; yy++ ) { uuid16 = btm_convert_uuid_to_uuid16( p_uuid_data, LEN_UUID_128 ); p_uuid_data += LEN_UUID_128; if( uuid16 ) BTM_AddEirService( p_results->eir_uuid, uuid16 ); } } BTM_TRACE_DEBUG2("btm_set_eir_uuid eir_uuid=0x%08X %08X", p_results->eir_uuid[1], p_results->eir_uuid[0] ); } #endif