Home | History | Annotate | Download | only in btm
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 1999-2014 Broadcom Corporation
      4  *
      5  *  Licensed under the Apache License, Version 2.0 (the "License");
      6  *  you may not use this file except in compliance with the License.
      7  *  You may obtain a copy of the License at:
      8  *
      9  *  http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  ******************************************************************************/
     18 
     19 /******************************************************************************
     20  *
     21  *  This file contains functions that handle inquiries. These include
     22  *  setting discoverable mode, controlling the mode of the Baseband, and
     23  *  maintaining a small database of inquiry responses, with API for people
     24  *  to browse it.
     25  *
     26  ******************************************************************************/
     27 
     28 #include <stdlib.h>
     29 #include <string.h>
     30 #include <stdio.h>
     31 #include <stddef.h>
     32 
     33 #include "bt_types.h"
     34 #include "gki.h"
     35 #include "hcimsgs.h"
     36 #include "btu.h"
     37 #include "btm_api.h"
     38 #include "btm_int.h"
     39 #include "hcidefs.h"
     40 
     41 #define BTM_INQ_REPLY_TIMEOUT   3       /* 3 second timeout waiting for responses */
     42 
     43 /* TRUE to enable DEBUG traces for btm_inq */
     44 #ifndef BTM_INQ_DEBUG
     45 #define BTM_INQ_DEBUG   FALSE
     46 #endif
     47 /********************************************************************************/
     48 /*                 L O C A L    D A T A    D E F I N I T I O N S                */
     49 /********************************************************************************/
     50 static const LAP general_inq_lap = {0x9e,0x8b,0x33};
     51 static const LAP limited_inq_lap = {0x9e,0x8b,0x00};
     52 
     53 #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE ))
     54 #ifndef BTM_EIR_UUID_LKUP_TBL
     55 const UINT16 BTM_EIR_UUID_LKUP_TBL[BTM_EIR_MAX_SERVICES] =
     56 {
     57     UUID_SERVCLASS_SERVICE_DISCOVERY_SERVER,
     58 /*    UUID_SERVCLASS_BROWSE_GROUP_DESCRIPTOR,   */
     59 /*    UUID_SERVCLASS_PUBLIC_BROWSE_GROUP,       */
     60     UUID_SERVCLASS_SERIAL_PORT,
     61     UUID_SERVCLASS_LAN_ACCESS_USING_PPP,
     62     UUID_SERVCLASS_DIALUP_NETWORKING,
     63     UUID_SERVCLASS_IRMC_SYNC,
     64     UUID_SERVCLASS_OBEX_OBJECT_PUSH,
     65     UUID_SERVCLASS_OBEX_FILE_TRANSFER,
     66     UUID_SERVCLASS_IRMC_SYNC_COMMAND,
     67     UUID_SERVCLASS_HEADSET,
     68     UUID_SERVCLASS_CORDLESS_TELEPHONY,
     69     UUID_SERVCLASS_AUDIO_SOURCE,
     70     UUID_SERVCLASS_AUDIO_SINK,
     71     UUID_SERVCLASS_AV_REM_CTRL_TARGET,
     72 /*    UUID_SERVCLASS_ADV_AUDIO_DISTRIBUTION,    */
     73     UUID_SERVCLASS_AV_REMOTE_CONTROL,
     74 /*    UUID_SERVCLASS_VIDEO_CONFERENCING,        */
     75     UUID_SERVCLASS_INTERCOM,
     76     UUID_SERVCLASS_FAX,
     77     UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY,
     78 /*    UUID_SERVCLASS_WAP,                       */
     79 /*    UUID_SERVCLASS_WAP_CLIENT,                */
     80     UUID_SERVCLASS_PANU,
     81     UUID_SERVCLASS_NAP,
     82     UUID_SERVCLASS_GN,
     83     UUID_SERVCLASS_DIRECT_PRINTING,
     84 /*    UUID_SERVCLASS_REFERENCE_PRINTING,        */
     85     UUID_SERVCLASS_IMAGING,
     86     UUID_SERVCLASS_IMAGING_RESPONDER,
     87     UUID_SERVCLASS_IMAGING_AUTO_ARCHIVE,
     88     UUID_SERVCLASS_IMAGING_REF_OBJECTS,
     89     UUID_SERVCLASS_HF_HANDSFREE,
     90     UUID_SERVCLASS_AG_HANDSFREE,
     91     UUID_SERVCLASS_DIR_PRT_REF_OBJ_SERVICE,
     92 /*    UUID_SERVCLASS_REFLECTED_UI,              */
     93     UUID_SERVCLASS_BASIC_PRINTING,
     94     UUID_SERVCLASS_PRINTING_STATUS,
     95     UUID_SERVCLASS_HUMAN_INTERFACE,
     96     UUID_SERVCLASS_CABLE_REPLACEMENT,
     97     UUID_SERVCLASS_HCRP_PRINT,
     98     UUID_SERVCLASS_HCRP_SCAN,
     99 /*    UUID_SERVCLASS_COMMON_ISDN_ACCESS,        */
    100 /*    UUID_SERVCLASS_VIDEO_CONFERENCING_GW,     */
    101 /*    UUID_SERVCLASS_UDI_MT,                    */
    102 /*    UUID_SERVCLASS_UDI_TA,                    */
    103 /*    UUID_SERVCLASS_VCP,                       */
    104     UUID_SERVCLASS_SAP,
    105     UUID_SERVCLASS_PBAP_PCE,
    106     UUID_SERVCLASS_PBAP_PSE,
    107     UUID_SERVCLASS_PHONE_ACCESS,
    108     UUID_SERVCLASS_HEADSET_HS,
    109     UUID_SERVCLASS_PNP_INFORMATION,
    110 /*    UUID_SERVCLASS_GENERIC_NETWORKING,        */
    111 /*    UUID_SERVCLASS_GENERIC_FILETRANSFER,      */
    112 /*    UUID_SERVCLASS_GENERIC_AUDIO,             */
    113 /*    UUID_SERVCLASS_GENERIC_TELEPHONY,         */
    114 /*    UUID_SERVCLASS_UPNP_SERVICE,              */
    115 /*    UUID_SERVCLASS_UPNP_IP_SERVICE,           */
    116 /*    UUID_SERVCLASS_ESDP_UPNP_IP_PAN,          */
    117 /*    UUID_SERVCLASS_ESDP_UPNP_IP_LAP,          */
    118 /*    UUID_SERVCLASS_ESDP_UPNP_IP_L2CAP,        */
    119     UUID_SERVCLASS_VIDEO_SOURCE,
    120     UUID_SERVCLASS_VIDEO_SINK,
    121 /*    UUID_SERVCLASS_VIDEO_DISTRIBUTION         */
    122     UUID_SERVCLASS_MESSAGE_ACCESS,
    123     UUID_SERVCLASS_MESSAGE_NOTIFICATION,
    124     UUID_SERVCLASS_HDP_SOURCE,
    125     UUID_SERVCLASS_HDP_SINK
    126 };
    127 #else
    128 /*
    129 If customized UUID look-up table needs to be used,
    130 the followings should be defined in bdroid_buildcfg.h.
    131 BTM_EIR_UUID_LKUP_TBL = <customized UUID list>
    132 BTM_EIR_MAX_SERVICES = <number of UUID in list>
    133 */
    134 #if (BTM_EIR_MAX_SERVICES == 0)
    135 const UINT16 BTM_EIR_UUID_LKUP_TBL[];
    136 #else
    137 extern UINT16 BTM_EIR_UUID_LKUP_TBL[BTM_EIR_MAX_SERVICES];
    138 #endif
    139 #endif
    140 #endif /* BTM_EIR_UUID_LKUP_TBL*/
    141 
    142 /********************************************************************************/
    143 /*              L O C A L    F U N C T I O N     P R O T O T Y P E S            */
    144 /********************************************************************************/
    145 static void         btm_initiate_inquiry (tBTM_INQUIRY_VAR_ST *p_inq);
    146 static tBTM_STATUS  btm_set_inq_event_filter (UINT8 filter_cond_type, tBTM_INQ_FILT_COND *p_filt_cond);
    147 static void         btm_clr_inq_result_flt (void);
    148 
    149 #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
    150 static UINT8        btm_convert_uuid_to_eir_service( UINT16 uuid16 );
    151 #endif
    152 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
    153 static void         btm_set_eir_uuid( UINT8 *p_eir, tBTM_INQ_RESULTS *p_results );
    154 static UINT8       *btm_eir_get_uuid_list( UINT8 *p_eir, UINT8 uuid_size,
    155                                            UINT8 *p_num_uuid, UINT8 *p_uuid_list_type );
    156 static UINT16       btm_convert_uuid_to_uuid16( UINT8 *p_uuid, UINT8 uuid_size );
    157 #endif
    158 
    159 /*******************************************************************************
    160 **
    161 ** Function         BTM_SetDiscoverability
    162 **
    163 ** Description      This function is called to set the device into or out of
    164 **                  discoverable mode. Discoverable mode means inquiry
    165 **                  scans are enabled.  If a value of '0' is entered for window or
    166 **                  interval, the default values are used.
    167 **
    168 ** Returns          BTM_SUCCESS if successful
    169 **                  BTM_BUSY if a setting of the filter is already in progress
    170 **                  BTM_NO_RESOURCES if couldn't get a memory pool buffer
    171 **                  BTM_ILLEGAL_VALUE if a bad parameter was detected
    172 **                  BTM_WRONG_MODE if the device is not up.
    173 **
    174 *******************************************************************************/
    175 tBTM_STATUS BTM_SetDiscoverability (UINT16 inq_mode, UINT16 window, UINT16 interval)
    176 {
    177     UINT8        scan_mode = 0;
    178     UINT16       service_class;
    179     UINT8       *p_cod;
    180     UINT8        major, minor;
    181     DEV_CLASS    cod;
    182     LAP          temp_lap[2];
    183     BOOLEAN      is_limited;
    184     BOOLEAN      cod_limited;
    185 
    186     BTM_TRACE_API ("BTM_SetDiscoverability");
    187 #if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
    188     if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
    189     {
    190         if (btm_ble_set_discoverability((UINT16)(inq_mode))
    191                             == BTM_SUCCESS)
    192         {
    193             btm_cb.btm_inq_vars.discoverable_mode &= (~BTM_BLE_DISCOVERABLE_MASK);
    194             btm_cb.btm_inq_vars.discoverable_mode |= (inq_mode & BTM_BLE_DISCOVERABLE_MASK);
    195         }
    196     }
    197     inq_mode &= ~BTM_BLE_DISCOVERABLE_MASK;
    198 #endif
    199 
    200     /*** Check mode parameter ***/
    201     if (inq_mode > BTM_MAX_DISCOVERABLE)
    202         return (BTM_ILLEGAL_VALUE);
    203 
    204     /* Make sure the controller is active */
    205     if (btm_cb.devcb.state < BTM_DEV_STATE_READY)
    206         return (BTM_DEV_RESET);
    207 
    208     /* If the window and/or interval is '0', set to default values */
    209     if (!window)
    210         window = BTM_DEFAULT_DISC_WINDOW;
    211 
    212     if (!interval)
    213         interval = BTM_DEFAULT_DISC_INTERVAL;
    214 
    215     BTM_TRACE_API ("BTM_SetDiscoverability: mode %d [NonDisc-0, Lim-1, Gen-2], window 0x%04x, interval 0x%04x",
    216                         inq_mode, window, interval);
    217 
    218     /*** Check for valid window and interval parameters ***/
    219     /*** Only check window and duration if mode is connectable ***/
    220     if (inq_mode != BTM_NON_DISCOVERABLE)
    221     {
    222         /* window must be less than or equal to interval */
    223         if (window < HCI_MIN_INQUIRYSCAN_WINDOW     ||
    224             window > HCI_MAX_INQUIRYSCAN_WINDOW     ||
    225             interval < HCI_MIN_INQUIRYSCAN_INTERVAL ||
    226             interval > HCI_MAX_INQUIRYSCAN_INTERVAL ||
    227             window > interval)
    228         {
    229             return (BTM_ILLEGAL_VALUE);
    230         }
    231     }
    232 
    233     /* Set the IAC if needed */
    234     if (inq_mode != BTM_NON_DISCOVERABLE)
    235     {
    236         if (inq_mode & BTM_LIMITED_DISCOVERABLE)
    237         {
    238             /* Use the GIAC and LIAC codes for limited discoverable mode */
    239             memcpy (temp_lap[0], limited_inq_lap, LAP_LEN);
    240             memcpy (temp_lap[1], general_inq_lap, LAP_LEN);
    241 
    242             if (!btsnd_hcic_write_cur_iac_lap (2, (LAP * const) temp_lap))
    243                 return (BTM_NO_RESOURCES);  /* Cannot continue */
    244         }
    245         else
    246         {
    247             if (!btsnd_hcic_write_cur_iac_lap (1, (LAP * const) &general_inq_lap))
    248                 return (BTM_NO_RESOURCES);  /* Cannot continue */
    249         }
    250 
    251         scan_mode |= HCI_INQUIRY_SCAN_ENABLED;
    252     }
    253 
    254     /* Send down the inquiry scan window and period if changed */
    255     if ((window != btm_cb.btm_inq_vars.inq_scan_window) ||
    256         (interval != btm_cb.btm_inq_vars.inq_scan_period))
    257     {
    258         if (btsnd_hcic_write_inqscan_cfg (interval, window))
    259         {
    260             btm_cb.btm_inq_vars.inq_scan_window = window;
    261             btm_cb.btm_inq_vars.inq_scan_period = interval;
    262         }
    263         else
    264             return (BTM_NO_RESOURCES);
    265     }
    266 
    267     if (btm_cb.btm_inq_vars.connectable_mode & BTM_CONNECTABLE_MASK)
    268         scan_mode |= HCI_PAGE_SCAN_ENABLED;
    269 
    270     if (btsnd_hcic_write_scan_enable (scan_mode))
    271     {
    272         btm_cb.btm_inq_vars.discoverable_mode &= (~BTM_DISCOVERABLE_MASK);
    273         btm_cb.btm_inq_vars.discoverable_mode |= inq_mode;
    274     }
    275     else
    276         return (BTM_NO_RESOURCES);
    277 
    278     /* Change the service class bit if mode has changed */
    279     p_cod = BTM_ReadDeviceClass();
    280     BTM_COD_SERVICE_CLASS(service_class, p_cod);
    281     is_limited = (inq_mode & BTM_LIMITED_DISCOVERABLE) ? TRUE : FALSE;
    282     cod_limited = (service_class & BTM_COD_SERVICE_LMTD_DISCOVER) ? TRUE : FALSE;
    283     if (is_limited ^ cod_limited)
    284     {
    285         BTM_COD_MINOR_CLASS(minor, p_cod );
    286         BTM_COD_MAJOR_CLASS(major, p_cod );
    287         if (is_limited)
    288             service_class |= BTM_COD_SERVICE_LMTD_DISCOVER;
    289         else
    290             service_class &= ~BTM_COD_SERVICE_LMTD_DISCOVER;
    291 
    292         FIELDS_TO_COD(cod, minor, major, service_class);
    293         (void) BTM_SetDeviceClass (cod);
    294     }
    295 
    296     return (BTM_SUCCESS);
    297 }
    298 
    299 /*******************************************************************************
    300 **
    301 ** Function         BTM_SetInquiryScanType
    302 **
    303 ** Description      This function is called to set the iquiry scan-type to
    304 **                  standard or interlaced.
    305 **
    306 ** Returns          BTM_SUCCESS if successful
    307 **                  BTM_MODE_UNSUPPORTED if not a 1.2 device
    308 **                  BTM_WRONG_MODE if the device is not up.
    309 **
    310 *******************************************************************************/
    311 tBTM_STATUS BTM_SetInquiryScanType (UINT16 scan_type)
    312 {
    313 
    314     BTM_TRACE_API ("BTM_SetInquiryScanType");
    315     if (scan_type != BTM_SCAN_TYPE_STANDARD && scan_type != BTM_SCAN_TYPE_INTERLACED)
    316         return (BTM_ILLEGAL_VALUE);
    317 
    318     /* whatever app wants if device is not 1.2 scan type should be STANDARD */
    319     if (!HCI_LMP_INTERLACED_INQ_SCAN_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
    320      return (BTM_MODE_UNSUPPORTED);
    321 
    322     /* Check for scan type if configuration has been changed */
    323     if (scan_type != btm_cb.btm_inq_vars.inq_scan_type)
    324     {
    325         if (BTM_IsDeviceUp())
    326         {
    327             if (btsnd_hcic_write_inqscan_type ((UINT8)scan_type))
    328                 btm_cb.btm_inq_vars.inq_scan_type = scan_type;
    329             else
    330                 return (BTM_NO_RESOURCES);
    331         }
    332         else return (BTM_WRONG_MODE);
    333     }
    334     return (BTM_SUCCESS);
    335 }
    336 
    337 /*******************************************************************************
    338 **
    339 ** Function         BTM_SetPageScanType
    340 **
    341 ** Description      This function is called to set the page scan-type to
    342 **                  standard or interlaced.
    343 **
    344 ** Returns          BTM_SUCCESS if successful
    345 **                  BTM_MODE_UNSUPPORTED if not a 1.2 device
    346 **                  BTM_WRONG_MODE if the device is not up.
    347 **
    348 *******************************************************************************/
    349 tBTM_STATUS BTM_SetPageScanType (UINT16 scan_type)
    350 {
    351     BTM_TRACE_API ("BTM_SetPageScanType");
    352     if (scan_type != BTM_SCAN_TYPE_STANDARD && scan_type != BTM_SCAN_TYPE_INTERLACED)
    353         return (BTM_ILLEGAL_VALUE);
    354 
    355     /* whatever app wants if device is not 1.2 scan type should be STANDARD */
    356     if (!HCI_LMP_INTERLACED_PAGE_SCAN_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
    357      return (BTM_MODE_UNSUPPORTED);
    358 
    359     /* Check for scan type if configuration has been changed */
    360     if (scan_type != btm_cb.btm_inq_vars.page_scan_type)
    361     {
    362         if (BTM_IsDeviceUp())
    363         {
    364             if (btsnd_hcic_write_pagescan_type ((UINT8)scan_type))
    365                 btm_cb.btm_inq_vars.page_scan_type  = scan_type;
    366             else
    367                 return (BTM_NO_RESOURCES);
    368         }
    369         else return (BTM_WRONG_MODE);
    370     }
    371     return (BTM_SUCCESS);
    372 }
    373 
    374 
    375 /*******************************************************************************
    376 **
    377 ** Function         BTM_SetInquiryMode
    378 **
    379 ** Description      This function is called to set standard or with RSSI
    380 **                  mode of the inquiry for local device.
    381 **
    382 ** Output Params:   mode - standard, with RSSI, extended
    383 **
    384 ** Returns          BTM_SUCCESS if successful
    385 **                  BTM_NO_RESOURCES if couldn't get a memory pool buffer
    386 **                  BTM_ILLEGAL_VALUE if a bad parameter was detected
    387 **                  BTM_WRONG_MODE if the device is not up.
    388 **
    389 *******************************************************************************/
    390 tBTM_STATUS BTM_SetInquiryMode (UINT8 mode)
    391 {
    392     BTM_TRACE_API ("BTM_SetInquiryMode");
    393     if (mode == BTM_INQ_RESULT_STANDARD)
    394     {
    395         /* mandatory mode */
    396     }
    397     else if (mode == BTM_INQ_RESULT_WITH_RSSI)
    398     {
    399     if (!HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
    400         return (BTM_MODE_UNSUPPORTED);
    401     }
    402 #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE ))
    403     else if (mode == BTM_INQ_RESULT_EXTENDED)
    404     {
    405         if (!HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
    406             return (BTM_MODE_UNSUPPORTED);
    407     }
    408 #endif
    409     else
    410         return (BTM_ILLEGAL_VALUE);
    411 
    412     if (!BTM_IsDeviceUp())
    413         return (BTM_WRONG_MODE);
    414 
    415     if (!btsnd_hcic_write_inquiry_mode (mode))
    416         return (BTM_NO_RESOURCES);
    417 
    418     return (BTM_SUCCESS);
    419 }
    420 
    421 /*******************************************************************************
    422 **
    423 ** Function         BTM_ReadDiscoverability
    424 **
    425 ** Description      This function is called to read the current discoverability
    426 **                  mode of the device.
    427 **
    428 ** Output Params:   p_window - current inquiry scan duration
    429 **                  p_interval - current inquiry scan interval
    430 **
    431 ** Returns          BTM_NON_DISCOVERABLE, BTM_LIMITED_DISCOVERABLE, or
    432 **                  BTM_GENERAL_DISCOVERABLE
    433 **
    434 *******************************************************************************/
    435 UINT16 BTM_ReadDiscoverability (UINT16 *p_window, UINT16 *p_interval)
    436 {
    437     BTM_TRACE_API ("BTM_ReadDiscoverability");
    438     if (p_window)
    439         *p_window = btm_cb.btm_inq_vars.inq_scan_window;
    440 
    441     if (p_interval)
    442         *p_interval = btm_cb.btm_inq_vars.inq_scan_period;
    443 
    444     return (btm_cb.btm_inq_vars.discoverable_mode);
    445 }
    446 
    447 
    448 /*******************************************************************************
    449 **
    450 ** Function         BTM_SetPeriodicInquiryMode
    451 **
    452 ** Description      This function is called to set the device periodic inquiry mode.
    453 **                  If the duration is zero, the periodic inquiry mode is cancelled.
    454 **
    455 **                  Note: We currently do not allow concurrent inquiry and periodic inquiry.
    456 **
    457 ** Parameters:      p_inqparms - pointer to the inquiry information
    458 **                      mode - GENERAL or LIMITED inquiry
    459 **                      duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED)
    460 **                      max_resps - maximum amount of devices to search for before ending the inquiry
    461 **                      filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or
    462 **                                         BTM_FILTER_COND_BD_ADDR
    463 **                      filter_cond - value for the filter (based on filter_cond_type)
    464 **
    465 **                  max_delay - maximum amount of time between successive inquiries
    466 **                  min_delay - minimum amount of time between successive inquiries
    467 **                  p_results_cb - callback returning pointer to results (tBTM_INQ_RESULTS)
    468 **
    469 ** Returns          BTM_CMD_STARTED if successfully started
    470 **                  BTM_ILLEGAL_VALUE if a bad parameter is detected
    471 **                  BTM_NO_RESOURCES if could not allocate a message buffer
    472 **                  BTM_SUCCESS - if cancelling the periodic inquiry
    473 **                  BTM_BUSY - if an inquiry is already active
    474 **                  BTM_WRONG_MODE if the device is not up.
    475 **
    476 *******************************************************************************/
    477 tBTM_STATUS BTM_SetPeriodicInquiryMode (tBTM_INQ_PARMS *p_inqparms, UINT16 max_delay,
    478                                         UINT16 min_delay, tBTM_INQ_RESULTS_CB *p_results_cb)
    479 {
    480     tBTM_STATUS  status;
    481     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
    482 
    483     BTM_TRACE_API ("BTM_SetPeriodicInquiryMode: mode: %d, dur: %d, rsps: %d, flt: %d, min: %d, max: %d",
    484         p_inqparms->mode, p_inqparms->duration, p_inqparms->max_resps,
    485         p_inqparms->filter_cond_type, min_delay, max_delay);
    486 
    487     /*** Make sure the device is ready ***/
    488     if (!BTM_IsDeviceUp())
    489         return (BTM_WRONG_MODE);
    490 
    491     /* Only one active inquiry is allowed in this implementation.
    492        Also do not allow an inquiry if the inquiry filter is being updated */
    493     if (p_inq->inq_active || p_inq->inqfilt_active)
    494         return (BTM_BUSY);
    495 
    496     /* If illegal parameters return FALSE */
    497     if (p_inqparms->mode != BTM_GENERAL_INQUIRY &&
    498         p_inqparms->mode != BTM_LIMITED_INQUIRY)
    499         return (BTM_ILLEGAL_VALUE);
    500 
    501     /* Verify the parameters for this command */
    502     if (p_inqparms->duration < BTM_MIN_INQUIRY_LEN     ||
    503         p_inqparms->duration > BTM_MAX_INQUIRY_LENGTH  ||
    504         min_delay <= p_inqparms->duration              ||
    505         min_delay < BTM_PER_INQ_MIN_MIN_PERIOD         ||
    506         min_delay > BTM_PER_INQ_MAX_MIN_PERIOD         ||
    507         max_delay <= min_delay                         ||
    508         max_delay < BTM_PER_INQ_MIN_MAX_PERIOD)
    509  /*       max_delay > BTM_PER_INQ_MAX_MAX_PERIOD)*/
    510  /*  BTM_PER_INQ_MAX_MAX_PERIOD set to 1's in all bits. Condition resulting in false always*/
    511     {
    512         return (BTM_ILLEGAL_VALUE);
    513     }
    514 
    515     /* Save the inquiry parameters to be used upon the completion of setting/clearing the inquiry filter */
    516     p_inq->inqparms = *p_inqparms;
    517     p_inq->per_min_delay = min_delay;
    518     p_inq->per_max_delay = max_delay;
    519     p_inq->inq_cmpl_info.num_resp = 0;         /* Clear the results counter */
    520     p_inq->p_inq_results_cb = p_results_cb;
    521 
    522     p_inq->inq_active = (UINT8)((p_inqparms->mode == BTM_LIMITED_INQUIRY) ?
    523                             (BTM_LIMITED_INQUIRY_ACTIVE | BTM_PERIODIC_INQUIRY_ACTIVE) :
    524                             (BTM_GENERAL_INQUIRY_ACTIVE | BTM_PERIODIC_INQUIRY_ACTIVE));
    525 
    526 #if (defined(BTM_BYPASS_EVENT_FILTERING) && BTM_BYPASS_EVENT_FILTERING == TRUE)
    527     BTM_TRACE_WARNING("BTM: Bypassing event filtering...");
    528 
    529     p_inq->state = BTM_INQ_ACTIVE_STATE;
    530     p_inq->inqfilt_active = FALSE;
    531     btm_initiate_inquiry (p_inq);
    532     status = BTM_CMD_STARTED;
    533 #else
    534     /* If a filter is specified, then save it for later and clear the current filter.
    535        The setting of the filter is done upon completion of clearing of the previous
    536        filter.
    537     */
    538     if (p_inqparms->filter_cond_type != BTM_CLR_INQUIRY_FILTER)
    539     {
    540         p_inq->state = BTM_INQ_CLR_FILT_STATE;
    541         p_inqparms->filter_cond_type = BTM_CLR_INQUIRY_FILTER;
    542     }
    543     else    /* The filter is not being used so simply clear it; the inquiry can start after this operation */
    544         p_inq->state = BTM_INQ_SET_FILT_STATE;
    545 
    546     /* Before beginning the inquiry the current filter must be cleared, so initiate the command */
    547     if ((status = btm_set_inq_event_filter (p_inqparms->filter_cond_type, &p_inqparms->filter_cond)) != BTM_CMD_STARTED)
    548     {
    549         /* If set filter command is not succesful reset the state */
    550         p_inq->p_inq_results_cb = NULL;
    551         p_inq->state = BTM_INQ_INACTIVE_STATE;
    552 
    553     }
    554 
    555 #endif
    556     return (status);
    557 }
    558 
    559 
    560 /*******************************************************************************
    561 **
    562 ** Function         BTM_CancelPeriodicInquiry
    563 **
    564 ** Description      This function cancels a periodic inquiry
    565 **
    566 ** Returns
    567 **                  BTM_NO_RESOURCES if could not allocate a message buffer
    568 **                  BTM_SUCCESS - if cancelling the periodic inquiry
    569 **                  BTM_WRONG_MODE if the device is not up.
    570 **
    571 *******************************************************************************/
    572 tBTM_STATUS BTM_CancelPeriodicInquiry(void)
    573 {
    574     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
    575     tBTM_STATUS          status = BTM_SUCCESS;
    576     BTM_TRACE_API ("BTM_CancelPeriodicInquiry called");
    577 
    578     /*** Make sure the device is ready ***/
    579     if (!BTM_IsDeviceUp())
    580         return (BTM_WRONG_MODE);
    581 
    582     /* Only cancel if one is active */
    583     if (btm_cb.btm_inq_vars.inq_active & BTM_PERIODIC_INQUIRY_ACTIVE)
    584     {
    585         btm_cb.btm_inq_vars.inq_active = BTM_INQUIRY_INACTIVE;
    586         btm_cb.btm_inq_vars.p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL;
    587 
    588         if (!btsnd_hcic_exit_per_inq ())
    589             status = BTM_NO_RESOURCES;
    590 
    591         /* If the event filter is in progress, mark it so that the processing of the return
    592            event will be ignored */
    593         if(p_inq->inqfilt_active)
    594             p_inq->pending_filt_complete_event++;
    595 
    596         p_inq->inqfilt_active = FALSE;
    597         p_inq->inq_counter++;
    598     }
    599 
    600     return (status);
    601 }
    602 
    603 
    604 /*******************************************************************************
    605 **
    606 ** Function         BTM_SetConnectability
    607 **
    608 ** Description      This function is called to set the device into or out of
    609 **                  connectable mode. Discoverable mode means page scans enabled.
    610 **
    611 ** Returns          BTM_SUCCESS if successful
    612 **                  BTM_ILLEGAL_VALUE if a bad parameter is detected
    613 **                  BTM_NO_RESOURCES if could not allocate a message buffer
    614 **                  BTM_WRONG_MODE if the device is not up.
    615 **
    616 *******************************************************************************/
    617 tBTM_STATUS BTM_SetConnectability (UINT16 page_mode, UINT16 window, UINT16 interval)
    618 {
    619     UINT8    scan_mode = 0;
    620     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
    621 
    622     BTM_TRACE_API ("BTM_SetConnectability");
    623 
    624 #if (BLE_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
    625     if (HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
    626     {
    627         if (btm_ble_set_connectability(page_mode) != BTM_SUCCESS)
    628         {
    629             return BTM_NO_RESOURCES;
    630         }
    631         p_inq->connectable_mode &= (~BTM_BLE_CONNECTABLE_MASK);
    632         p_inq->connectable_mode |= (page_mode & BTM_BLE_CONNECTABLE_MASK);
    633     }
    634     page_mode &= ~BTM_BLE_CONNECTABLE_MASK;
    635 #endif
    636 
    637     /*** Check mode parameter ***/
    638     if (page_mode != BTM_NON_CONNECTABLE && page_mode != BTM_CONNECTABLE)
    639         return (BTM_ILLEGAL_VALUE);
    640 
    641     /* Make sure the controller is active */
    642     if (btm_cb.devcb.state < BTM_DEV_STATE_READY)
    643         return (BTM_DEV_RESET);
    644 
    645     /* If the window and/or interval is '0', set to default values */
    646     if (!window)
    647         window = BTM_DEFAULT_CONN_WINDOW;
    648 
    649     if (!interval)
    650         interval = BTM_DEFAULT_CONN_INTERVAL;
    651 
    652     BTM_TRACE_API ("BTM_SetConnectability: mode %d [NonConn-0, Conn-1], window 0x%04x, interval 0x%04x",
    653                         page_mode, window, interval);
    654 
    655     /*** Check for valid window and interval parameters ***/
    656     /*** Only check window and duration if mode is connectable ***/
    657     if (page_mode == BTM_CONNECTABLE)
    658     {
    659         /* window must be less than or equal to interval */
    660         if (window < HCI_MIN_PAGESCAN_WINDOW     ||
    661             window > HCI_MAX_PAGESCAN_WINDOW     ||
    662             interval < HCI_MIN_PAGESCAN_INTERVAL ||
    663             interval > HCI_MAX_PAGESCAN_INTERVAL ||
    664             window > interval)
    665         {
    666             return (BTM_ILLEGAL_VALUE);
    667         }
    668 
    669         scan_mode |= HCI_PAGE_SCAN_ENABLED;
    670     }
    671 
    672     if ((window != p_inq->page_scan_window) ||
    673         (interval != p_inq->page_scan_period))
    674     {
    675         p_inq->page_scan_window = window;
    676         p_inq->page_scan_period = interval;
    677         if (!btsnd_hcic_write_pagescan_cfg (interval, window))
    678             return (BTM_NO_RESOURCES);
    679     }
    680 
    681     /* Keep the inquiry scan as previouosly set */
    682     if (p_inq->discoverable_mode & BTM_DISCOVERABLE_MASK)
    683         scan_mode |= HCI_INQUIRY_SCAN_ENABLED;
    684 
    685     if (btsnd_hcic_write_scan_enable (scan_mode))
    686     {
    687         p_inq->connectable_mode &= (~BTM_CONNECTABLE_MASK);
    688         p_inq->connectable_mode |= page_mode;
    689 
    690         return (BTM_SUCCESS);
    691     }
    692 
    693     return (BTM_NO_RESOURCES);
    694 }
    695 
    696 
    697 /*******************************************************************************
    698 **
    699 ** Function         BTM_ReadConnectability
    700 **
    701 ** Description      This function is called to read the current discoverability
    702 **                  mode of the device.
    703 ** Output Params    p_window - current page scan duration
    704 **                  p_interval - current time between page scans
    705 **
    706 ** Returns          BTM_NON_CONNECTABLE or BTM_CONNECTABLE
    707 **
    708 *******************************************************************************/
    709 UINT16 BTM_ReadConnectability (UINT16 *p_window, UINT16 *p_interval)
    710 {
    711     BTM_TRACE_API ("BTM_ReadConnectability");
    712     if (p_window)
    713         *p_window = btm_cb.btm_inq_vars.page_scan_window;
    714 
    715     if (p_interval)
    716         *p_interval = btm_cb.btm_inq_vars.page_scan_period;
    717 
    718     return (btm_cb.btm_inq_vars.connectable_mode);
    719 }
    720 
    721 
    722 
    723 /*******************************************************************************
    724 **
    725 ** Function         BTM_IsInquiryActive
    726 **
    727 ** Description      This function returns a bit mask of the current inquiry state
    728 **
    729 ** Returns          BTM_INQUIRY_INACTIVE if inactive (0)
    730 **                  BTM_LIMITED_INQUIRY_ACTIVE if a limted inquiry is active
    731 **                  BTM_GENERAL_INQUIRY_ACTIVE if a general inquiry is active
    732 **                  BTM_PERIODIC_INQUIRY_ACTIVE if a periodic inquiry is active
    733 **
    734 *******************************************************************************/
    735 UINT16 BTM_IsInquiryActive (void)
    736 {
    737     BTM_TRACE_API ("BTM_IsInquiryActive");
    738 
    739     return(btm_cb.btm_inq_vars.inq_active);
    740 }
    741 
    742 
    743 
    744 /*******************************************************************************
    745 **
    746 ** Function         BTM_CancelInquiry
    747 **
    748 ** Description      This function cancels an inquiry if active
    749 **
    750 ** Returns          BTM_SUCCESS if successful
    751 **                  BTM_NO_RESOURCES if could not allocate a message buffer
    752 **                  BTM_WRONG_MODE if the device is not up.
    753 **
    754 *******************************************************************************/
    755 tBTM_STATUS BTM_CancelInquiry(void)
    756 {
    757     tBTM_STATUS           status = BTM_SUCCESS;
    758     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
    759 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    760     UINT8 active_mode=p_inq->inq_active;
    761 #endif
    762     BTM_TRACE_API ("BTM_CancelInquiry called");
    763 
    764     /*** Make sure the device is ready ***/
    765     if (!BTM_IsDeviceUp())
    766         return (BTM_WRONG_MODE);
    767 
    768     /* Only cancel if not in periodic mode, otherwise the caller should call BTM_CancelPeriodicMode */
    769     if ((p_inq->inq_active &BTM_INQUIRY_ACTIVE_MASK) != 0 &&
    770         (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE)))
    771     {
    772         p_inq->inq_active = BTM_INQUIRY_INACTIVE;
    773         p_inq->state = BTM_INQ_INACTIVE_STATE;
    774         p_inq->p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL; /* Do not notify caller anymore */
    775         p_inq->p_inq_cmpl_cb = (tBTM_CMPL_CB *) NULL;    /* Do not notify caller anymore */
    776 
    777         /* If the event filter is in progress, mark it so that the processing of the return
    778             event will be ignored */
    779         if (p_inq->inqfilt_active)
    780         {
    781             p_inq->inqfilt_active = FALSE;
    782             p_inq->pending_filt_complete_event++;
    783         }
    784          /* Initiate the cancel inquiry */
    785         else
    786         {
    787             if (((p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK) != 0)
    788 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    789             &&(active_mode & BTM_BR_INQUIRY_MASK)
    790 #endif
    791             )
    792             {
    793                 if (!btsnd_hcic_inq_cancel())
    794                     status = BTM_NO_RESOURCES;
    795             }
    796 #if BLE_INCLUDED == TRUE
    797             if (((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0)
    798 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    799             &&(active_mode & BTM_BLE_INQ_ACTIVE_MASK)
    800 #endif
    801             )
    802                 btm_ble_stop_inquiry();
    803 #endif
    804         }
    805 
    806 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
    807         /* Do not send the BUSY_LEVEL event yet. Wait for the cancel_complete event
    808          * and then send the BUSY_LEVEL event
    809          * btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT);
    810          */
    811 #endif
    812 
    813          p_inq->inq_counter++;
    814          btm_clr_inq_result_flt();
    815     }
    816 
    817     return (status);
    818 }
    819 
    820 
    821 /*******************************************************************************
    822 **
    823 ** Function         BTM_StartInquiry
    824 **
    825 ** Description      This function is called to start an inquiry.
    826 **
    827 ** Parameters:      p_inqparms - pointer to the inquiry information
    828 **                      mode - GENERAL or LIMITED inquiry, BR/LE bit mask seperately
    829 **                      duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED)
    830 **                      max_resps - maximum amount of devices to search for before ending the inquiry
    831 **                      filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or
    832 **                                         BTM_FILTER_COND_BD_ADDR
    833 **                      filter_cond - value for the filter (based on filter_cond_type)
    834 **
    835 **                  p_results_cb   - Pointer to the callback routine which gets called
    836 **                                upon receipt of an inquiry result. If this field is
    837 **                                NULL, the application is not notified.
    838 **
    839 **                  p_cmpl_cb   - Pointer to the callback routine which gets called
    840 **                                upon completion.  If this field is NULL, the
    841 **                                application is not notified when completed.
    842 ** Returns          tBTM_STATUS
    843 **                  BTM_CMD_STARTED if successfully initiated
    844 **                  BTM_BUSY if already in progress
    845 **                  BTM_ILLEGAL_VALUE if parameter(s) are out of range
    846 **                  BTM_NO_RESOURCES if could not allocate resources to start the command
    847 **                  BTM_WRONG_MODE if the device is not up.
    848 **
    849 *******************************************************************************/
    850 tBTM_STATUS BTM_StartInquiry (tBTM_INQ_PARMS *p_inqparms, tBTM_INQ_RESULTS_CB *p_results_cb,
    851                               tBTM_CMPL_CB *p_cmpl_cb)
    852 {
    853     tBTM_STATUS  status = BTM_CMD_STARTED;
    854     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
    855 
    856     BTM_TRACE_API ("BTM_StartInquiry: mode: %d, dur: %d, rsps: %d, flt: %d",
    857                         p_inqparms->mode, p_inqparms->duration, p_inqparms->max_resps,
    858                         p_inqparms->filter_cond_type);
    859 
    860     /* Only one active inquiry is allowed in this implementation.
    861        Also do not allow an inquiry if the inquiry filter is being updated */
    862     if (p_inq->inq_active || p_inq->inqfilt_active)
    863     {
    864 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
    865         /*check if LE observe is already running*/
    866         if(p_inq->scan_type==INQ_LE_OBSERVE && p_inq->p_inq_ble_results_cb!=NULL)
    867         {
    868             BTM_TRACE_API("BTM_StartInquiry: LE observe in progress");
    869             p_inq->scan_type = INQ_GENERAL;
    870             p_inq->inq_active = BTM_INQUIRY_INACTIVE;
    871             btm_cb.ble_ctr_cb.inq_var.scan_type = BTM_BLE_SCAN_MODE_NONE;
    872             btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_DISABLE, BTM_BLE_DUPLICATE_ENABLE);
    873         }
    874         else
    875 #endif
    876         {
    877             return (BTM_BUSY);
    878             BTM_TRACE_API("BTM_StartInquiry: return BUSY");
    879         }
    880     }
    881     else
    882         p_inq->scan_type = INQ_GENERAL;
    883 
    884         /*** Make sure the device is ready ***/
    885     if (!BTM_IsDeviceUp())
    886         return (BTM_WRONG_MODE);
    887 
    888     if ((p_inqparms->mode & BTM_BR_INQUIRY_MASK)!= BTM_GENERAL_INQUIRY &&
    889         (p_inqparms->mode & BTM_BR_INQUIRY_MASK)!= BTM_LIMITED_INQUIRY
    890 #if (BLE_INCLUDED == TRUE)
    891         && (p_inqparms->mode & BTM_BLE_INQUIRY_MASK)!= BTM_BLE_GENERAL_INQUIRY
    892         && (p_inqparms->mode & BTM_BLE_INQUIRY_MASK)!= BTM_BLE_LIMITED_INQUIRY
    893 #endif
    894         )
    895         return (BTM_ILLEGAL_VALUE);
    896 
    897 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    898         if(p_inq->next_state==BTM_FINISH)
    899             return BTM_ILLEGAL_VALUE;
    900 #endif
    901 
    902 
    903     /* Save the inquiry parameters to be used upon the completion of setting/clearing the inquiry filter */
    904     p_inq->inqparms = *p_inqparms;
    905 
    906     /* Initialize the inquiry variables */
    907     p_inq->state = BTM_INQ_ACTIVE_STATE;
    908     p_inq->p_inq_cmpl_cb = p_cmpl_cb;
    909     p_inq->p_inq_results_cb = p_results_cb;
    910     p_inq->inq_cmpl_info.num_resp = 0;         /* Clear the results counter */
    911     p_inq->inq_active = p_inqparms->mode;
    912 
    913     BTM_TRACE_DEBUG("BTM_StartInquiry: p_inq->inq_active = 0x%02x", p_inq->inq_active);
    914 
    915 /* interleave scan minimal conditions */
    916 #if (BLE_INCLUDED==TRUE && (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE))
    917 
    918     /* check if both modes are present */
    919     if((p_inqparms->mode & BTM_BLE_INQUIRY_MASK) && (p_inqparms->mode & BTM_BR_INQUIRY_MASK))
    920     {
    921         BTM_TRACE_API("BTM:Interleave Inquiry Mode Set");
    922         p_inqparms->duration=p_inqparms->intl_duration[p_inq->next_state];
    923         p_inq->inqparms.duration=p_inqparms->duration;
    924     }
    925     else
    926     {
    927         BTM_TRACE_API("BTM:Single Mode: No interleaving, Mode:0x%02x", p_inqparms->mode);
    928         p_inq->next_state=BTM_NO_INTERLEAVING;
    929     }
    930 #endif
    931 
    932 
    933 
    934 /* start LE inquiry here if requested */
    935 #if BLE_INCLUDED == TRUE
    936     if ((p_inqparms->mode & BTM_BLE_INQUIRY_MASK)
    937 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    938         &&(p_inq->next_state==BTM_BLE_ONE || p_inq->next_state==BTM_BLE_TWO ||
    939            p_inq->next_state==BTM_NO_INTERLEAVING)
    940 #endif
    941         )
    942 
    943     {
    944 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    945         p_inq->inq_active = (p_inqparms->mode & BTM_BLE_INQUIRY_MASK);
    946         BTM_TRACE_API("BTM:Starting LE Scan with duration %d and activeMode:0x%02x",
    947                        p_inqparms->duration, (p_inqparms->mode & BTM_BLE_INQUIRY_MASK));
    948 #endif
    949         if (!HCI_LE_HOST_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_1]))
    950         {
    951             p_inq->inqparms.mode &= ~ BTM_BLE_INQUIRY_MASK;
    952             status = BTM_ILLEGAL_VALUE;
    953         }
    954         /* BLE for now does not support filter condition for inquiry */
    955         else if ((status = btm_ble_start_inquiry((UINT8)(p_inqparms->mode & BTM_BLE_INQUIRY_MASK),
    956                                             p_inqparms->duration)) != BTM_CMD_STARTED)
    957         {
    958             BTM_TRACE_ERROR("Err Starting LE Inquiry.");
    959             p_inq->inqparms.mode &= ~ BTM_BLE_INQUIRY_MASK;
    960         }
    961 #if (!defined(BTA_HOST_INTERLEAVE_SEARCH) || BTA_HOST_INTERLEAVE_SEARCH == FALSE)
    962         p_inqparms->mode &= ~BTM_BLE_INQUIRY_MASK;
    963 #endif
    964 
    965 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    966         if(p_inq->next_state==BTM_NO_INTERLEAVING)
    967         {
    968             p_inq->next_state=BTM_FINISH;
    969         }
    970         else
    971         {
    972             BTM_TRACE_API("BTM:Interleaving: started LE scan, Advancing to next state: %d",
    973                            p_inq->next_state+1);
    974             p_inq->next_state+=1;
    975         }
    976         /* reset next_state if status <> BTM_Started */
    977         if(status!=BTM_CMD_STARTED)
    978             p_inq->next_state=BTM_BR_ONE;
    979 
    980         /* if interleave scan..return here */
    981         return status;
    982 #endif
    983 
    984 
    985         BTM_TRACE_DEBUG("BTM_StartInquiry: mode = %02x", p_inqparms->mode);
    986     }
    987 #endif /* end of BLE_INCLUDED */
    988 
    989     /* we're done with this routine if BR/EDR inquiry is not desired. */
    990     if ((p_inqparms->mode & BTM_BR_INQUIRY_MASK) == BTM_INQUIRY_NONE)
    991         return status;
    992 
    993     /* BR/EDR inquiry portion */
    994 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
    995     if((p_inq->next_state==BTM_BR_ONE || p_inq->next_state==BTM_BR_TWO ||
    996         p_inq->next_state==BTM_NO_INTERLEAVING ))
    997     {
    998         p_inq->inq_active = (p_inqparms->mode & BTM_BR_INQUIRY_MASK);
    999 #endif
   1000 #if (defined(BTM_BYPASS_EVENT_FILTERING) && BTM_BYPASS_EVENT_FILTERING == TRUE)
   1001     BTM_TRACE_WARNING("BTM: Bypassing event filtering...");
   1002     p_inq->inqfilt_active = FALSE;
   1003     btm_initiate_inquiry (p_inq);
   1004     status = BTM_CMD_STARTED;
   1005 #else
   1006     /* If a filter is specified, then save it for later and clear the current filter.
   1007        The setting of the filter is done upon completion of clearing of the previous
   1008        filter.
   1009     */
   1010     switch (p_inqparms->filter_cond_type)
   1011     {
   1012     case BTM_CLR_INQUIRY_FILTER:
   1013         p_inq->state = BTM_INQ_SET_FILT_STATE;
   1014         break;
   1015 
   1016     case BTM_FILTER_COND_DEVICE_CLASS:
   1017     case BTM_FILTER_COND_BD_ADDR:
   1018         /* The filter is not being used so simply clear it;
   1019             the inquiry can start after this operation */
   1020         p_inq->state = BTM_INQ_CLR_FILT_STATE;
   1021         p_inqparms->filter_cond_type = BTM_CLR_INQUIRY_FILTER;
   1022         /* =============>>>> adding LE filtering here ????? */
   1023         break;
   1024 
   1025     default:
   1026         return (BTM_ILLEGAL_VALUE);
   1027     }
   1028 
   1029     /* Before beginning the inquiry the current filter must be cleared, so initiate the command */
   1030     if ((status = btm_set_inq_event_filter (p_inqparms->filter_cond_type,
   1031                                             &p_inqparms->filter_cond)) != BTM_CMD_STARTED)
   1032         p_inq->state = BTM_INQ_INACTIVE_STATE;
   1033 #endif
   1034 
   1035 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
   1036         if (p_inq->next_state==BTM_NO_INTERLEAVING)
   1037             p_inq->next_state=BTM_FINISH;
   1038         else
   1039         {
   1040             BTM_TRACE_API("BTM:Interleaving: Started BTM inq, Advancing to next state: %d",
   1041                            p_inq->next_state+1);
   1042             p_inq->next_state+=1;
   1043         }
   1044      }
   1045      if (status!=BTM_CMD_STARTED)
   1046      {
   1047          /* Some error beginning the scan process.
   1048             Reset the next_state parameter.. Do we need to reset the inq_active also?
   1049          */
   1050         BTM_TRACE_API("BTM:Interleaving: Error in Starting inquiry, status: 0x%02x", status);
   1051         p_inq->next_state=BTM_BR_ONE;
   1052      }
   1053 #endif
   1054 
   1055 
   1056     return (status);
   1057 }
   1058 
   1059 
   1060 /*******************************************************************************
   1061 **
   1062 ** Function         BTM_ReadRemoteDeviceName
   1063 **
   1064 ** Description      This function initiates a remote device HCI command to the
   1065 **                  controller and calls the callback when the process has completed.
   1066 **
   1067 ** Input Params:    remote_bda      - device address of name to retrieve
   1068 **                  p_cb            - callback function called when BTM_CMD_STARTED
   1069 **                                    is returned.
   1070 **                                    A pointer to tBTM_REMOTE_DEV_NAME is passed to the
   1071 **                                    callback.
   1072 **
   1073 ** Returns
   1074 **                  BTM_CMD_STARTED is returned if the request was successfully sent
   1075 **                                  to HCI.
   1076 **                  BTM_BUSY if already in progress
   1077 **                  BTM_UNKNOWN_ADDR if device address is bad
   1078 **                  BTM_NO_RESOURCES if could not allocate resources to start the command
   1079 **                  BTM_WRONG_MODE if the device is not up.
   1080 **
   1081 *******************************************************************************/
   1082 tBTM_STATUS  BTM_ReadRemoteDeviceName (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb
   1083                                                 ,tBT_TRANSPORT transport)
   1084 {
   1085     tBTM_INQ_INFO   *p_cur = NULL;
   1086     tINQ_DB_ENT     *p_i;
   1087 
   1088     BTM_TRACE_API ("BTM_ReadRemoteDeviceName: bd addr [%02x%02x%02x%02x%02x%02x]",
   1089                remote_bda[0], remote_bda[1], remote_bda[2],
   1090                remote_bda[3], remote_bda[4], remote_bda[5]);
   1091 
   1092     /* Use the remote device's clock offset if it is in the local inquiry database */
   1093     if ((p_i = btm_inq_db_find (remote_bda)) != NULL)
   1094     {
   1095         p_cur = &p_i->inq_info;
   1096 
   1097 #if (BTM_INQ_GET_REMOTE_NAME == TRUE)
   1098         p_cur->remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   1099 #endif
   1100     }
   1101     BTM_TRACE_API ("no device found in inquiry db");
   1102 
   1103 #if (BLE_INCLUDED == TRUE)
   1104     if (transport == BT_TRANSPORT_LE)
   1105     {
   1106         return btm_ble_read_remote_name(remote_bda, p_cur, p_cb);
   1107     }
   1108     else
   1109 #endif
   1110 
   1111     return (btm_initiate_rem_name (remote_bda, p_cur, BTM_RMT_NAME_EXT,
   1112                                    BTM_EXT_RMT_NAME_TIMEOUT, p_cb));
   1113 }
   1114 
   1115 /*******************************************************************************
   1116 **
   1117 ** Function         BTM_CancelRemoteDeviceName
   1118 **
   1119 ** Description      This function initiates the cancel request for the specified
   1120 **                  remote device.
   1121 **
   1122 ** Input Params:    None
   1123 **
   1124 ** Returns
   1125 **                  BTM_CMD_STARTED is returned if the request was successfully sent
   1126 **                                  to HCI.
   1127 **                  BTM_NO_RESOURCES if could not allocate resources to start the command
   1128 **                  BTM_WRONG_MODE if there is not an active remote name request.
   1129 **
   1130 *******************************************************************************/
   1131 tBTM_STATUS  BTM_CancelRemoteDeviceName (void)
   1132 {
   1133     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   1134 
   1135     BTM_TRACE_API ("BTM_CancelRemoteDeviceName()");
   1136 
   1137     /* Make sure there is not already one in progress */
   1138     if (p_inq->remname_active)
   1139     {
   1140 #if BLE_INCLUDED == TRUE
   1141         if (BTM_UseLeLink(p_inq->remname_bda))
   1142         {
   1143             if (btm_ble_cancel_remote_name(p_inq->remname_bda))
   1144                 return (BTM_CMD_STARTED);
   1145             else
   1146                 return (BTM_UNKNOWN_ADDR);
   1147         }
   1148         else
   1149 #endif
   1150         if (btsnd_hcic_rmt_name_req_cancel (p_inq->remname_bda))
   1151             return (BTM_CMD_STARTED);
   1152         else
   1153             return (BTM_NO_RESOURCES);
   1154     }
   1155     else
   1156         return (BTM_WRONG_MODE);
   1157 }
   1158 
   1159 /*******************************************************************************
   1160 **
   1161 ** Function         BTM_InqFirstResult
   1162 **
   1163 ** Description      This function looks through the inquiry database for the first
   1164 **                  used entrysince the LAST inquiry. This is used in conjunction
   1165 **                  with BTM_InqNext by applications as a way to walk through the
   1166 **                  inquiry results database.
   1167 **
   1168 ** Returns          pointer to first in-use entry, or NULL if DB is empty
   1169 **
   1170 *******************************************************************************/
   1171 tBTM_INQ_INFO *BTM_InqFirstResult (void)
   1172 {
   1173     UINT16       xx;
   1174     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1175     UINT32       cur_inq_count = btm_cb.btm_inq_vars.inq_counter - 1;
   1176 
   1177     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1178     {
   1179         if (p_ent->in_use && p_ent->inq_count == cur_inq_count)
   1180             return (&p_ent->inq_info);
   1181     }
   1182 
   1183     /* If here, no used entry found */
   1184     return ((tBTM_INQ_INFO *)NULL);
   1185 }
   1186 
   1187 
   1188 /*******************************************************************************
   1189 **
   1190 ** Function         BTM_InqNextResult
   1191 **
   1192 ** Description      This function looks through the inquiry database for the next
   1193 **                  used entrysince the LAST inquiry. If the input parameter is NULL,
   1194 **                  the first entry is returned.
   1195 **
   1196 ** Returns          pointer to next in-use entry, or NULL if no more found.
   1197 **
   1198 *******************************************************************************/
   1199 tBTM_INQ_INFO *BTM_InqNextResult (tBTM_INQ_INFO *p_cur)
   1200 {
   1201     tINQ_DB_ENT  *p_ent;
   1202     UINT16        inx;
   1203     UINT32        cur_inq_count = btm_cb.btm_inq_vars.inq_counter - 1;
   1204 
   1205     if (p_cur)
   1206     {
   1207         p_ent = (tINQ_DB_ENT *) ((UINT8 *)p_cur - offsetof (tINQ_DB_ENT, inq_info));
   1208         inx = (UINT16)((p_ent - btm_cb.btm_inq_vars.inq_db) + 1);
   1209 
   1210         for (p_ent = &btm_cb.btm_inq_vars.inq_db[inx]; inx < BTM_INQ_DB_SIZE; inx++, p_ent++)
   1211         {
   1212             if (p_ent->in_use && p_ent->inq_count == cur_inq_count)
   1213                 return (&p_ent->inq_info);
   1214         }
   1215 
   1216         /* If here, more entries found */
   1217         return ((tBTM_INQ_INFO *)NULL);
   1218     }
   1219     else
   1220         return (BTM_InqDbFirst());
   1221 }
   1222 
   1223 
   1224 /*******************************************************************************
   1225 **
   1226 ** Function         BTM_InqDbRead
   1227 **
   1228 ** Description      This function looks through the inquiry database for a match
   1229 **                  based on Bluetooth Device Address. This is the application's
   1230 **                  interface to get the inquiry details of a specific BD address.
   1231 **
   1232 ** Returns          pointer to entry, or NULL if not found
   1233 **
   1234 *******************************************************************************/
   1235 tBTM_INQ_INFO *BTM_InqDbRead (BD_ADDR p_bda)
   1236 {
   1237     UINT16       xx;
   1238     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1239 
   1240     BTM_TRACE_API ("BTM_InqDbRead: bd addr [%02x%02x%02x%02x%02x%02x]",
   1241                p_bda[0], p_bda[1], p_bda[2], p_bda[3], p_bda[4], p_bda[5]);
   1242 
   1243     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1244     {
   1245         if ((p_ent->in_use) && (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN)))
   1246             return (&p_ent->inq_info);
   1247     }
   1248 
   1249     /* If here, not found */
   1250     return ((tBTM_INQ_INFO *)NULL);
   1251 }
   1252 
   1253 
   1254 /*******************************************************************************
   1255 **
   1256 ** Function         BTM_InqDbFirst
   1257 **
   1258 ** Description      This function looks through the inquiry database for the first
   1259 **                  used entry, and returns that. This is used in conjunction with
   1260 **                  BTM_InqDbNext by applications as a way to walk through the
   1261 **                  inquiry database.
   1262 **
   1263 ** Returns          pointer to first in-use entry, or NULL if DB is empty
   1264 **
   1265 *******************************************************************************/
   1266 tBTM_INQ_INFO *BTM_InqDbFirst (void)
   1267 {
   1268     UINT16       xx;
   1269     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1270 
   1271     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1272     {
   1273         if (p_ent->in_use)
   1274             return (&p_ent->inq_info);
   1275     }
   1276 
   1277     /* If here, no used entry found */
   1278     return ((tBTM_INQ_INFO *)NULL);
   1279 }
   1280 
   1281 
   1282 /*******************************************************************************
   1283 **
   1284 ** Function         BTM_InqDbNext
   1285 **
   1286 ** Description      This function looks through the inquiry database for the next
   1287 **                  used entry, and returns that.  If the input parameter is NULL,
   1288 **                  the first entry is returned.
   1289 **
   1290 ** Returns          pointer to next in-use entry, or NULL if no more found.
   1291 **
   1292 *******************************************************************************/
   1293 tBTM_INQ_INFO *BTM_InqDbNext (tBTM_INQ_INFO *p_cur)
   1294 {
   1295     tINQ_DB_ENT  *p_ent;
   1296     UINT16        inx;
   1297 
   1298     if (p_cur)
   1299     {
   1300         p_ent = (tINQ_DB_ENT *) ((UINT8 *)p_cur - offsetof (tINQ_DB_ENT, inq_info));
   1301         inx = (UINT16)((p_ent - btm_cb.btm_inq_vars.inq_db) + 1);
   1302 
   1303         for (p_ent = &btm_cb.btm_inq_vars.inq_db[inx]; inx < BTM_INQ_DB_SIZE; inx++, p_ent++)
   1304         {
   1305             if (p_ent->in_use)
   1306                 return (&p_ent->inq_info);
   1307         }
   1308 
   1309         /* If here, more entries found */
   1310         return ((tBTM_INQ_INFO *)NULL);
   1311     }
   1312     else
   1313         return (BTM_InqDbFirst());
   1314 }
   1315 
   1316 
   1317 /*******************************************************************************
   1318 **
   1319 ** Function         BTM_ClearInqDb
   1320 **
   1321 ** Description      This function is called to clear out a device or all devices
   1322 **                  from the inquiry database.
   1323 **
   1324 ** Parameter        p_bda - (input) BD_ADDR ->  Address of device to clear
   1325 **                                              (NULL clears all entries)
   1326 **
   1327 ** Returns          BTM_BUSY if an inquiry, get remote name, or event filter
   1328 **                          is active, otherwise BTM_SUCCESS
   1329 **
   1330 *******************************************************************************/
   1331 tBTM_STATUS BTM_ClearInqDb (BD_ADDR p_bda)
   1332 {
   1333     tBTM_INQUIRY_VAR_ST     *p_inq = &btm_cb.btm_inq_vars;
   1334 
   1335     /* If an inquiry or remote name is in progress return busy */
   1336     if (p_inq->inq_active != BTM_INQUIRY_INACTIVE ||
   1337         p_inq->inqfilt_active)
   1338         return (BTM_BUSY);
   1339 
   1340     btm_clr_inq_db(p_bda);
   1341 
   1342     return (BTM_SUCCESS);
   1343 }
   1344 
   1345 
   1346 /*******************************************************************************
   1347 **
   1348 ** Function         BTM_ReadNumInqDbEntries
   1349 **
   1350 ** Returns          This function returns the number of entries in the inquiry database.
   1351 **
   1352 *******************************************************************************/
   1353 UINT8 BTM_ReadNumInqDbEntries (void)
   1354 {
   1355     UINT8         num_entries;
   1356     UINT8         num_results;
   1357     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1358 
   1359     for (num_entries = 0, num_results = 0; num_entries < BTM_INQ_DB_SIZE; num_entries++, p_ent++)
   1360     {
   1361         if (p_ent->in_use)
   1362             num_results++;
   1363     }
   1364 
   1365     return (num_results);
   1366 }
   1367 
   1368 
   1369 /*******************************************************************************
   1370 **
   1371 ** Function         BTM_InquiryRegisterForChanges
   1372 **
   1373 ** Returns          This function is called to register a callback for when the
   1374 **                  inquiry database changes, i.e. new entry or entry deleted.
   1375 **
   1376 *******************************************************************************/
   1377 tBTM_STATUS  BTM_InquiryRegisterForChanges (tBTM_INQ_DB_CHANGE_CB *p_cb)
   1378 {
   1379     if (!p_cb)
   1380         btm_cb.btm_inq_vars.p_inq_change_cb = NULL;
   1381     else if (btm_cb.btm_inq_vars.p_inq_change_cb)
   1382         return (BTM_BUSY);
   1383     else
   1384         btm_cb.btm_inq_vars.p_inq_change_cb = p_cb;
   1385 
   1386     return (BTM_SUCCESS);
   1387 }
   1388 
   1389 
   1390 /*******************************************************************************
   1391 **
   1392 ** Function         BTM_SetInquiryFilterCallback
   1393 **
   1394 ** Description      Host can register to be asked whenever an inquiry result
   1395 **                  is received.  If host does not like the device no name
   1396 **                  request is issued for the device
   1397 **
   1398 ** Returns          void
   1399 **
   1400 *******************************************************************************/
   1401 void BTM_SetInquiryFilterCallback (tBTM_FILTER_CB *p_callback)
   1402 {
   1403     btm_cb.p_inq_filter_cb = p_callback;
   1404 }
   1405 
   1406 /*******************************************************************************
   1407 **
   1408 ** Function         BTM_ReadInquiryRspTxPower
   1409 **
   1410 ** Description      This command will read the inquiry Transmit Power level used
   1411 **                  to transmit the FHS and EIR data packets.
   1412 **                  This can be used directly in the Tx Power Level EIR data type.
   1413 **
   1414 ** Returns          BTM_SUCCESS if successful
   1415 **
   1416 *******************************************************************************/
   1417 tBTM_STATUS BTM_ReadInquiryRspTxPower (tBTM_CMPL_CB *p_cb)
   1418 {
   1419     if (btm_cb.devcb.p_txpwer_cmpl_cb)
   1420         return (BTM_BUSY);
   1421 
   1422      btu_start_timer (&btm_cb.devcb.txpwer_timer, BTU_TTYPE_BTM_ACL, BTM_INQ_REPLY_TIMEOUT );
   1423 
   1424 
   1425     btm_cb.devcb.p_txpwer_cmpl_cb = p_cb;
   1426 
   1427     if (!btsnd_hcic_read_inq_tx_power ())
   1428     {
   1429         btm_cb.devcb.p_txpwer_cmpl_cb = NULL;
   1430         btu_stop_timer (&btm_cb.devcb.txpwer_timer);
   1431         return (BTM_NO_RESOURCES);
   1432     }
   1433     else
   1434         return (BTM_CMD_STARTED);
   1435 }
   1436 /*******************************************************************************
   1437 **
   1438 ** Function         BTM_WriteInquiryTxPower
   1439 **
   1440 ** Description      This command is used to write the inquiry transmit power level
   1441 **                  used to transmit the inquiry (ID) data packets. The Controller
   1442 **                  should use the supported TX power level closest to the Tx_Power
   1443 **                  parameter.
   1444 **
   1445 ** Returns          BTM_SUCCESS if successful
   1446 **
   1447 *******************************************************************************/
   1448 tBTM_STATUS  BTM_WriteInquiryTxPower (INT8 tx_power)
   1449 {
   1450     tBTM_STATUS status = BTM_SUCCESS;
   1451 
   1452     if (tx_power < BTM_MIN_INQ_TX_POWER || tx_power > BTM_MAX_INQ_TX_POWER)
   1453     {
   1454         status = BTM_ILLEGAL_VALUE;
   1455     }
   1456     else if (!btsnd_hcic_write_inq_tx_power(tx_power))
   1457         status = BTM_NO_RESOURCES;
   1458 
   1459     return status;
   1460 }
   1461 /*********************************************************************************
   1462 **********************************************************************************
   1463 **                                                                              **
   1464 **                      BTM Internal Inquiry Functions                          **
   1465 **                                                                              **
   1466 **********************************************************************************
   1467 *********************************************************************************/
   1468 /*******************************************************************************
   1469 **
   1470 ** Function         btm_inq_db_reset
   1471 **
   1472 ** Description      This function is called at at reset to clear the inquiry
   1473 **                  database & pending callback.
   1474 **
   1475 ** Returns          void
   1476 **
   1477 *******************************************************************************/
   1478 void btm_inq_db_reset (void)
   1479 {
   1480     tBTM_REMOTE_DEV_NAME     rem_name;
   1481     tBTM_INQUIRY_VAR_ST     *p_inq = &btm_cb.btm_inq_vars;
   1482     UINT8                    num_responses;
   1483     UINT8                    temp_inq_active;
   1484     tBTM_STATUS              status;
   1485 
   1486     btu_stop_timer (&p_inq->inq_timer_ent);
   1487 
   1488     /* If an inquiry or periodic inquiry is active, reset the mode to inactive */
   1489     if (p_inq->inq_active != BTM_INQUIRY_INACTIVE)
   1490     {
   1491         temp_inq_active = p_inq->inq_active;    /* Save so state can change BEFORE
   1492                                                        callback is called */
   1493         p_inq->inq_active = BTM_INQUIRY_INACTIVE;
   1494 
   1495         /* If not a periodic inquiry, the complete callback must be called to notify caller */
   1496         if (temp_inq_active == BTM_LIMITED_INQUIRY_ACTIVE ||
   1497             temp_inq_active == BTM_GENERAL_INQUIRY_ACTIVE)
   1498         {
   1499             if (p_inq->p_inq_cmpl_cb)
   1500             {
   1501                 num_responses = 0;
   1502                 (*p_inq->p_inq_cmpl_cb)(&num_responses);
   1503             }
   1504         }
   1505     }
   1506 
   1507     /* Cancel a remote name request if active, and notify the caller (if waiting) */
   1508     if (p_inq->remname_active )
   1509     {
   1510         btu_stop_timer (&p_inq->rmt_name_timer_ent);
   1511         p_inq->remname_active = FALSE;
   1512         memset(p_inq->remname_bda, 0, BD_ADDR_LEN);
   1513 
   1514         if (p_inq->p_remname_cmpl_cb)
   1515         {
   1516             rem_name.status = BTM_DEV_RESET;
   1517 
   1518             (*p_inq->p_remname_cmpl_cb)(&rem_name);
   1519             p_inq->p_remname_cmpl_cb = NULL;
   1520         }
   1521     }
   1522 
   1523     /* Cancel an inquiry filter request if active, and notify the caller (if waiting) */
   1524     if (p_inq->inqfilt_active)
   1525     {
   1526         p_inq->inqfilt_active = FALSE;
   1527 
   1528         if (p_inq->p_inqfilter_cmpl_cb)
   1529         {
   1530             status = BTM_DEV_RESET;
   1531             (*p_inq->p_inqfilter_cmpl_cb)(&status);
   1532         }
   1533     }
   1534 
   1535     p_inq->state = BTM_INQ_INACTIVE_STATE;
   1536     p_inq->pending_filt_complete_event = 0;
   1537     p_inq->p_inq_results_cb = NULL;
   1538     btm_clr_inq_db(NULL);   /* Clear out all the entries in the database */
   1539     btm_clr_inq_result_flt();
   1540 
   1541     p_inq->discoverable_mode = BTM_NON_DISCOVERABLE;
   1542     p_inq->connectable_mode  = BTM_NON_CONNECTABLE;
   1543     p_inq->page_scan_type    = BTM_SCAN_TYPE_STANDARD;
   1544     p_inq->inq_scan_type     = BTM_SCAN_TYPE_STANDARD;
   1545 
   1546 #if BLE_INCLUDED == TRUE
   1547     p_inq->discoverable_mode |= BTM_BLE_NON_DISCOVERABLE;
   1548     p_inq->connectable_mode  |= BTM_BLE_NON_CONNECTABLE;
   1549 #endif
   1550     return;
   1551 }
   1552 
   1553 
   1554 /*********************************************************************************
   1555 **
   1556 ** Function         btm_inq_db_init
   1557 **
   1558 ** Description      This function is called at startup to initialize the inquiry
   1559 **                  database.
   1560 **
   1561 ** Returns          void
   1562 **
   1563 *******************************************************************************/
   1564 void btm_inq_db_init (void)
   1565 {
   1566 #if 0  /* cleared in btm_init; put back in if called from anywhere else! */
   1567     memset (&btm_cb.btm_inq_vars, 0, sizeof (tBTM_INQUIRY_VAR_ST));
   1568 #endif
   1569     btm_cb.btm_inq_vars.no_inc_ssp = BTM_NO_SSP_ON_INQUIRY;
   1570 }
   1571 
   1572 /*********************************************************************************
   1573 **
   1574 ** Function         btm_inq_stop_on_ssp
   1575 **
   1576 ** Description      This function is called on incoming SSP
   1577 **
   1578 ** Returns          void
   1579 **
   1580 *******************************************************************************/
   1581 void btm_inq_stop_on_ssp(void)
   1582 {
   1583     UINT8 normal_active = (BTM_GENERAL_INQUIRY_ACTIVE|BTM_LIMITED_INQUIRY_ACTIVE);
   1584 
   1585 #if (BTM_INQ_DEBUG == TRUE)
   1586     BTM_TRACE_DEBUG ("btm_inq_stop_on_ssp: no_inc_ssp=%d inq_active:0x%x state:%d inqfilt_active:%d",
   1587         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);
   1588 #endif
   1589     if (btm_cb.btm_inq_vars.no_inc_ssp)
   1590     {
   1591         if (btm_cb.btm_inq_vars.state == BTM_INQ_ACTIVE_STATE)
   1592         {
   1593             if (btm_cb.btm_inq_vars.inq_active & BTM_PERIODIC_INQUIRY_ACTIVE)
   1594             {
   1595                 BTM_CancelPeriodicInquiry();
   1596             }
   1597             else if (btm_cb.btm_inq_vars.inq_active & normal_active)
   1598             {
   1599                 /* can not call BTM_CancelInquiry() here. We need to report inquiry complete evt */
   1600                 btsnd_hcic_inq_cancel();
   1601             }
   1602         }
   1603         /* do not allow inquiry to start */
   1604         btm_cb.btm_inq_vars.inq_active |= BTM_SSP_INQUIRY_ACTIVE;
   1605     }
   1606 }
   1607 
   1608 /*********************************************************************************
   1609 **
   1610 ** Function         btm_inq_clear_ssp
   1611 **
   1612 ** Description      This function is called when pairing_state becomes idle
   1613 **
   1614 ** Returns          void
   1615 **
   1616 *******************************************************************************/
   1617 void btm_inq_clear_ssp(void)
   1618 {
   1619     btm_cb.btm_inq_vars.inq_active &= ~BTM_SSP_INQUIRY_ACTIVE;
   1620 }
   1621 
   1622 /*********************************************************************************
   1623 **
   1624 ** Function         btm_clr_inq_db
   1625 **
   1626 ** Description      This function is called to clear out a device or all devices
   1627 **                  from the inquiry database.
   1628 **
   1629 ** Parameter        p_bda - (input) BD_ADDR ->  Address of device to clear
   1630 **                                              (NULL clears all entries)
   1631 **
   1632 ** Returns          void
   1633 **
   1634 *******************************************************************************/
   1635 void btm_clr_inq_db (BD_ADDR p_bda)
   1636 {
   1637     tBTM_INQUIRY_VAR_ST     *p_inq = &btm_cb.btm_inq_vars;
   1638     tINQ_DB_ENT             *p_ent = p_inq->inq_db;
   1639     UINT16                   xx;
   1640 
   1641 #if (BTM_INQ_DEBUG == TRUE)
   1642     BTM_TRACE_DEBUG ("btm_clr_inq_db: inq_active:0x%x state:%d",
   1643         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);
   1644 #endif
   1645     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1646     {
   1647         if (p_ent->in_use)
   1648         {
   1649             /* If this is the specified BD_ADDR or clearing all devices */
   1650             if (p_bda == NULL ||
   1651                 (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN)))
   1652             {
   1653                 p_ent->in_use = FALSE;
   1654 #if (BTM_INQ_GET_REMOTE_NAME == TRUE)
   1655                 p_ent->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   1656 #endif
   1657 
   1658                 if (btm_cb.btm_inq_vars.p_inq_change_cb)
   1659                     (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_ent->inq_info, FALSE);
   1660             }
   1661         }
   1662     }
   1663 #if (BTM_INQ_DEBUG == TRUE)
   1664     BTM_TRACE_DEBUG ("inq_active:0x%x state:%d",
   1665         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state);
   1666 #endif
   1667 }
   1668 
   1669 
   1670 /*******************************************************************************
   1671 **
   1672 ** Function         btm_clr_inq_result_flt
   1673 **
   1674 ** Description      This function looks through the bdaddr database for a match
   1675 **                  based on Bluetooth Device Address
   1676 **
   1677 ** Returns          TRUE if found, else FALSE (new entry)
   1678 **
   1679 *******************************************************************************/
   1680 static void btm_clr_inq_result_flt (void)
   1681 {
   1682 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
   1683     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   1684 
   1685     if (p_inq->p_bd_db)
   1686     {
   1687         GKI_freebuf(p_inq->p_bd_db);
   1688         p_inq->p_bd_db = NULL;
   1689     }
   1690     p_inq->num_bd_entries = 0;
   1691     p_inq->max_bd_entries = 0;
   1692 #endif
   1693 }
   1694 
   1695 /*******************************************************************************
   1696 **
   1697 ** Function         btm_inq_find_bdaddr
   1698 **
   1699 ** Description      This function looks through the bdaddr database for a match
   1700 **                  based on Bluetooth Device Address
   1701 **
   1702 ** Returns          TRUE if found, else FALSE (new entry)
   1703 **
   1704 *******************************************************************************/
   1705 BOOLEAN btm_inq_find_bdaddr (BD_ADDR p_bda)
   1706 {
   1707 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
   1708     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   1709     tINQ_BDADDR         *p_db = &p_inq->p_bd_db[0];
   1710     UINT16       xx;
   1711 
   1712     /* Don't bother searching, database doesn't exist or periodic mode */
   1713     if ((p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) || !p_db)
   1714         return (FALSE);
   1715 
   1716     for (xx = 0; xx < p_inq->num_bd_entries; xx++, p_db++)
   1717     {
   1718         if (!memcmp(p_db->bd_addr, p_bda, BD_ADDR_LEN)
   1719             && p_db->inq_count == p_inq->inq_counter)
   1720             return (TRUE);
   1721     }
   1722 
   1723     if (xx < p_inq->max_bd_entries)
   1724     {
   1725         p_db->inq_count = p_inq->inq_counter;
   1726         memcpy(p_db->bd_addr, p_bda, BD_ADDR_LEN);
   1727         p_inq->num_bd_entries++;
   1728     }
   1729 
   1730 #endif
   1731     /* If here, New Entry */
   1732     return (FALSE);
   1733 }
   1734 
   1735 /*******************************************************************************
   1736 **
   1737 ** Function         btm_inq_db_find
   1738 **
   1739 ** Description      This function looks through the inquiry database for a match
   1740 **                  based on Bluetooth Device Address
   1741 **
   1742 ** Returns          pointer to entry, or NULL if not found
   1743 **
   1744 *******************************************************************************/
   1745 tINQ_DB_ENT *btm_inq_db_find (BD_ADDR p_bda)
   1746 {
   1747     UINT16       xx;
   1748     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1749 
   1750     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1751     {
   1752         if ((p_ent->in_use) && (!memcmp (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN)))
   1753             return (p_ent);
   1754     }
   1755 
   1756     /* If here, not found */
   1757     return (NULL);
   1758 }
   1759 
   1760 
   1761 /*******************************************************************************
   1762 **
   1763 ** Function         btm_inq_db_new
   1764 **
   1765 ** Description      This function looks through the inquiry database for an unused
   1766 **                  entry. If no entry is free, it allocates the oldest entry.
   1767 **
   1768 ** Returns          pointer to entry
   1769 **
   1770 *******************************************************************************/
   1771 tINQ_DB_ENT *btm_inq_db_new (BD_ADDR p_bda)
   1772 {
   1773     UINT16       xx;
   1774     tINQ_DB_ENT  *p_ent = btm_cb.btm_inq_vars.inq_db;
   1775     tINQ_DB_ENT  *p_old = btm_cb.btm_inq_vars.inq_db;
   1776     UINT32       ot = 0xFFFFFFFF;
   1777 
   1778     for (xx = 0; xx < BTM_INQ_DB_SIZE; xx++, p_ent++)
   1779     {
   1780         if (!p_ent->in_use)
   1781         {
   1782             memset (p_ent, 0, sizeof (tINQ_DB_ENT));
   1783             memcpy (p_ent->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN);
   1784             p_ent->in_use = TRUE;
   1785 
   1786 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   1787             p_ent->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   1788 #endif
   1789 
   1790             return (p_ent);
   1791         }
   1792 
   1793         if (p_ent->time_of_resp < ot)
   1794         {
   1795             p_old = p_ent;
   1796             ot    = p_ent->time_of_resp;
   1797         }
   1798     }
   1799 
   1800     /* If here, no free entry found. Return the oldest. */
   1801 
   1802     /* Before deleting the oldest, if anyone is registered for change */
   1803     /* notifications, then tell him we are deleting an entry.         */
   1804     if (btm_cb.btm_inq_vars.p_inq_change_cb)
   1805         (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_old->inq_info, FALSE);
   1806 
   1807     memset (p_old, 0, sizeof (tINQ_DB_ENT));
   1808     memcpy (p_old->inq_info.results.remote_bd_addr, p_bda, BD_ADDR_LEN);
   1809     p_old->in_use = TRUE;
   1810 
   1811 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   1812     p_old->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   1813 #endif
   1814 
   1815     return (p_old);
   1816 }
   1817 
   1818 
   1819 /*******************************************************************************
   1820 **
   1821 ** Function         btm_set_inq_event_filter
   1822 **
   1823 ** Description      This function is called to set the inquiry event filter.
   1824 **                  It is called by either internally, or by the external API function
   1825 **                  (BTM_SetInqEventFilter).  It is used internally as part of the
   1826 **                  inquiry processing.
   1827 **
   1828 ** Input Params:
   1829 **                  filter_cond_type - this is the type of inquiry filter to apply:
   1830 **                          BTM_FILTER_COND_DEVICE_CLASS,
   1831 **                          BTM_FILTER_COND_BD_ADDR, or
   1832 **                          BTM_CLR_INQUIRY_FILTER
   1833 **
   1834 **                  p_filt_cond - this is either a BD_ADDR or DEV_CLASS depending on the
   1835 **                          filter_cond_type  (See section 4.7.3 of Core Spec 1.0b).
   1836 **
   1837 ** Returns          BTM_CMD_STARTED if successfully initiated
   1838 **                  BTM_NO_RESOURCES if couldn't get a memory pool buffer
   1839 **                  BTM_ILLEGAL_VALUE if a bad parameter was detected
   1840 **
   1841 *******************************************************************************/
   1842 static tBTM_STATUS btm_set_inq_event_filter (UINT8 filter_cond_type,
   1843                                              tBTM_INQ_FILT_COND *p_filt_cond)
   1844 {
   1845     UINT8    condition_length = DEV_CLASS_LEN * 2;
   1846     UINT8    condition_buf[DEV_CLASS_LEN * 2];
   1847     UINT8   *p_cond = condition_buf;                    /* points to the condition to pass to HCI */
   1848 
   1849 #if (BTM_INQ_DEBUG == TRUE)
   1850     BTM_TRACE_DEBUG ("btm_set_inq_event_filter: filter type %d [Clear-0, COD-1, BDADDR-2]",
   1851         filter_cond_type);
   1852     BTM_TRACE_DEBUG ("                       condition [%02x%02x%02x %02x%02x%02x]",
   1853                p_filt_cond->bdaddr_cond[0], p_filt_cond->bdaddr_cond[1], p_filt_cond->bdaddr_cond[2],
   1854                p_filt_cond->bdaddr_cond[3], p_filt_cond->bdaddr_cond[4], p_filt_cond->bdaddr_cond[5]);
   1855 #endif
   1856 
   1857     /* Load the correct filter condition to pass to the lower layer */
   1858     switch (filter_cond_type)
   1859     {
   1860     case BTM_FILTER_COND_DEVICE_CLASS:
   1861         /* copy the device class and device class fields into contiguous memory to send to HCI */
   1862         memcpy (condition_buf, p_filt_cond->cod_cond.dev_class, DEV_CLASS_LEN);
   1863         memcpy (&condition_buf[DEV_CLASS_LEN],
   1864                 p_filt_cond->cod_cond.dev_class_mask, DEV_CLASS_LEN);
   1865 
   1866         /* condition length should already be set as the default */
   1867         break;
   1868 
   1869     case BTM_FILTER_COND_BD_ADDR:
   1870         p_cond = p_filt_cond->bdaddr_cond;
   1871 
   1872         /* condition length should already be set as the default */
   1873         break;
   1874 
   1875     case BTM_CLR_INQUIRY_FILTER:
   1876         condition_length = 0;
   1877         break;
   1878 
   1879     default:
   1880         return (BTM_ILLEGAL_VALUE);     /* Bad parameter was passed in */
   1881     }
   1882 
   1883     btm_cb.btm_inq_vars.inqfilt_active = TRUE;
   1884 
   1885     /* Filter the inquiry results for the specified condition type and value */
   1886     if (btsnd_hcic_set_event_filter(HCI_FILTER_INQUIRY_RESULT, filter_cond_type,
   1887                                     p_cond, condition_length))
   1888 
   1889         return (BTM_CMD_STARTED);
   1890     else
   1891         return (BTM_NO_RESOURCES);
   1892 }
   1893 
   1894 
   1895 /*******************************************************************************
   1896 **
   1897 ** Function         btm_event_filter_complete
   1898 **
   1899 ** Description      This function is called when a set event filter has completed.
   1900 **                  Note: This routine currently only handles inquiry filters.
   1901 **                      Connection filters are ignored for now.
   1902 **
   1903 ** Returns          void
   1904 **
   1905 *******************************************************************************/
   1906 void btm_event_filter_complete (UINT8 *p)
   1907 {
   1908     UINT8            hci_status;
   1909     tBTM_STATUS      status;
   1910     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   1911     tBTM_CMPL_CB   *p_cb = p_inq->p_inqfilter_cmpl_cb;
   1912 
   1913 #if (BTM_INQ_DEBUG == TRUE)
   1914     BTM_TRACE_DEBUG ("btm_event_filter_complete: inq_active:0x%x state:%d inqfilt_active:%d",
   1915         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
   1916 #endif
   1917     /* If the filter complete event is from an old or cancelled request, ignore it */
   1918     if(p_inq->pending_filt_complete_event)
   1919     {
   1920         p_inq->pending_filt_complete_event--;
   1921         return;
   1922     }
   1923 
   1924     /* Only process the inquiry filter; Ignore the connection filter until it
   1925        is used by the upper layers */
   1926     if (p_inq->inqfilt_active == TRUE )
   1927     {
   1928         /* Extract the returned status from the buffer */
   1929         STREAM_TO_UINT8 (hci_status, p);
   1930         if (hci_status != HCI_SUCCESS)
   1931         {
   1932             /* If standalone operation, return the error status; if embedded in the inquiry, continue the inquiry */
   1933             BTM_TRACE_WARNING ("BTM Warning: Set Event Filter Failed (HCI returned 0x%x)", hci_status);
   1934             status = BTM_ERR_PROCESSING;
   1935         }
   1936         else
   1937             status = BTM_SUCCESS;
   1938 
   1939         /* If the set filter was initiated externally (via BTM_SetInqEventFilter), call the
   1940            callback function to notify the initiator that it has completed */
   1941         if (p_inq->state == BTM_INQ_INACTIVE_STATE)
   1942         {
   1943             p_inq->inqfilt_active = FALSE;
   1944             if (p_cb)
   1945                 (*p_cb) (&status);
   1946         }
   1947         else    /* An inquiry is active (the set filter command was internally generated),
   1948                    process the next state of the process (Set a new filter or start the inquiry). */
   1949         {
   1950             if(status != BTM_SUCCESS)
   1951             {
   1952                 /* Process the inquiry complete (Error Status) */
   1953                 btm_process_inq_complete (BTM_ERR_PROCESSING, (UINT8)(p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK));
   1954 
   1955                 /* btm_process_inq_complete() does not restore the following settings on periodic inquiry */
   1956                 p_inq->inqfilt_active = FALSE;
   1957                 p_inq->inq_active = BTM_INQUIRY_INACTIVE;
   1958                 p_inq->state = BTM_INQ_INACTIVE_STATE;
   1959 
   1960                 return;
   1961             }
   1962 
   1963             /* Check to see if a new filter needs to be set up */
   1964             if (p_inq->state == BTM_INQ_CLR_FILT_STATE)
   1965             {
   1966                 if ((status = btm_set_inq_event_filter (p_inq->inqparms.filter_cond_type, &p_inq->inqparms.filter_cond)) == BTM_CMD_STARTED)
   1967                 {
   1968                     p_inq->state = BTM_INQ_SET_FILT_STATE;
   1969                 }
   1970                 else    /* Error setting the filter: Call the initiator's callback function to indicate a failure */
   1971                 {
   1972                     p_inq->inqfilt_active = FALSE;
   1973 
   1974                     /* Process the inquiry complete (Error Status) */
   1975                     btm_process_inq_complete (BTM_ERR_PROCESSING, (UINT8)(p_inq->inqparms.mode & BTM_BR_INQUIRY_MASK));
   1976                 }
   1977             }
   1978             else    /* Initiate the Inquiry or Periodic Inquiry */
   1979             {
   1980                 p_inq->state = BTM_INQ_ACTIVE_STATE;
   1981                 p_inq->inqfilt_active = FALSE;
   1982                 btm_initiate_inquiry (p_inq);
   1983             }
   1984         }
   1985     }
   1986 }
   1987 
   1988 
   1989 /*******************************************************************************
   1990 **
   1991 ** Function         btm_initiate_inquiry
   1992 **
   1993 ** Description      This function is called to start an inquiry or periodic inquiry
   1994 **                  upon completion of the setting and/or clearing of the inquiry filter.
   1995 **
   1996 ** Inputs:          p_inq (btm_cb.btm_inq_vars) - pointer to saved inquiry information
   1997 **                      mode - GENERAL or LIMITED inquiry
   1998 **                      duration - length in 1.28 sec intervals (If '0', the inquiry is CANCELLED)
   1999 **                      max_resps - maximum amount of devices to search for before ending the inquiry
   2000 **                      filter_cond_type - BTM_CLR_INQUIRY_FILTER, BTM_FILTER_COND_DEVICE_CLASS, or
   2001 **                                         BTM_FILTER_COND_BD_ADDR
   2002 **                      filter_cond - value for the filter (based on filter_cond_type)
   2003 **
   2004 ** Returns          If an error occurs the initiator's callback is called with the error status.
   2005 **
   2006 *******************************************************************************/
   2007 static void btm_initiate_inquiry (tBTM_INQUIRY_VAR_ST *p_inq)
   2008 {
   2009     const LAP       *lap;
   2010     tBTM_INQ_PARMS  *p_inqparms = &p_inq->inqparms;
   2011 
   2012 #if (BTM_INQ_DEBUG == TRUE)
   2013     BTM_TRACE_DEBUG ("btm_initiate_inquiry: inq_active:0x%x state:%d inqfilt_active:%d",
   2014         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
   2015 #endif
   2016 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
   2017     btm_acl_update_busy_level (BTM_BLI_INQ_EVT);
   2018 #endif
   2019 
   2020     if (p_inq->inq_active & BTM_SSP_INQUIRY_ACTIVE)
   2021     {
   2022         btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK));
   2023         return;
   2024     }
   2025 
   2026     /* Make sure the number of responses doesn't overflow the database configuration */
   2027     p_inqparms->max_resps = (UINT8)((p_inqparms->max_resps <= BTM_INQ_DB_SIZE) ? p_inqparms->max_resps : BTM_INQ_DB_SIZE);
   2028 
   2029     lap = (p_inq->inq_active & BTM_LIMITED_INQUIRY_ACTIVE) ? &limited_inq_lap : &general_inq_lap;
   2030 
   2031     if (p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE)
   2032     {
   2033         if (!btsnd_hcic_per_inq_mode (p_inq->per_max_delay,
   2034                                       p_inq->per_min_delay,
   2035                                       *lap, p_inqparms->duration,
   2036                                       p_inqparms->max_resps))
   2037             btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK));
   2038     }
   2039     else
   2040     {
   2041 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
   2042         btm_clr_inq_result_flt();
   2043 
   2044         /* Allocate memory to hold bd_addrs responding */
   2045         if ((p_inq->p_bd_db = (tINQ_BDADDR *)GKI_getbuf(GKI_MAX_BUF_SIZE)) != NULL)
   2046         {
   2047             p_inq->max_bd_entries = (UINT16)(GKI_MAX_BUF_SIZE / sizeof(tINQ_BDADDR));
   2048             memset(p_inq->p_bd_db, 0, GKI_MAX_BUF_SIZE);
   2049 /*            BTM_TRACE_DEBUG("btm_initiate_inquiry: memory allocated for %d bdaddrs",
   2050                               p_inq->max_bd_entries); */
   2051         }
   2052 
   2053         if (!btsnd_hcic_inquiry(*lap, p_inqparms->duration, 0))
   2054 #else
   2055         if (!btsnd_hcic_inquiry(*lap, p_inqparms->duration, p_inqparms->max_resps))
   2056 #endif /* BTM_USE_INQ_RESULTS_FILTER */
   2057             btm_process_inq_complete (BTM_NO_RESOURCES, (UINT8)(p_inqparms->mode & BTM_BR_INQUIRY_MASK));
   2058     }
   2059 }
   2060 
   2061 /*******************************************************************************
   2062 **
   2063 ** Function         btm_process_inq_results
   2064 **
   2065 ** Description      This function is called when inquiry results are received from
   2066 **                  the device. It updates the inquiry database. If the inquiry
   2067 **                  database is full, the oldest entry is discarded.
   2068 **
   2069 ** Parameters       inq_res_mode - BTM_INQ_RESULT_STANDARD
   2070 **                                 BTM_INQ_RESULT_WITH_RSSI
   2071 **                                 BTM_INQ_RESULT_EXTENDED
   2072 **
   2073 ** Returns          void
   2074 **
   2075 *******************************************************************************/
   2076 void btm_process_inq_results (UINT8 *p, UINT8 inq_res_mode)
   2077 {
   2078     UINT8            num_resp, xx;
   2079     BD_ADDR          bda;
   2080     tINQ_DB_ENT     *p_i;
   2081     tBTM_INQ_RESULTS *p_cur=NULL;
   2082     BOOLEAN          is_new = TRUE;
   2083     BOOLEAN          update = FALSE;
   2084     INT8             i_rssi;
   2085     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   2086     tBTM_INQ_RESULTS_CB *p_inq_results_cb = p_inq->p_inq_results_cb;
   2087     UINT8            page_scan_rep_mode = 0;
   2088     UINT8            page_scan_per_mode = 0;
   2089     UINT8            page_scan_mode = 0;
   2090     UINT8            rssi = 0;
   2091     DEV_CLASS        dc;
   2092     UINT16           clock_offset;
   2093 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   2094     UINT8            *p_eir_data = NULL;
   2095 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2096     UINT8            remote_name_len;
   2097 #endif
   2098 #endif
   2099 
   2100 #if (BTM_INQ_DEBUG == TRUE)
   2101     BTM_TRACE_DEBUG ("btm_process_inq_results inq_active:0x%x state:%d inqfilt_active:%d",
   2102         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
   2103 #endif
   2104     /* Only process the results if the BR inquiry is still active */
   2105     if (!(p_inq->inq_active & BTM_BR_INQ_ACTIVE_MASK))
   2106         return;
   2107 
   2108     STREAM_TO_UINT8 (num_resp, p);
   2109 
   2110     for (xx = 0; xx < num_resp; xx++)
   2111     {
   2112         update = FALSE;
   2113         /* Extract inquiry results */
   2114         STREAM_TO_BDADDR   (bda, p);
   2115         STREAM_TO_UINT8    (page_scan_rep_mode, p);
   2116         STREAM_TO_UINT8    (page_scan_per_mode, p);
   2117 
   2118         if (inq_res_mode == BTM_INQ_RESULT_STANDARD)
   2119         {
   2120             STREAM_TO_UINT8(page_scan_mode, p);
   2121         }
   2122 
   2123         STREAM_TO_DEVCLASS (dc, p);
   2124         STREAM_TO_UINT16   (clock_offset, p);
   2125         if (inq_res_mode != BTM_INQ_RESULT_STANDARD)
   2126         {
   2127             STREAM_TO_UINT8(rssi, p);
   2128         }
   2129 
   2130         p_i = btm_inq_db_find (bda);
   2131 
   2132 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
   2133         /* Only process the num_resp is smaller than max_resps.
   2134            If results are queued to BTU task while canceling inquiry,
   2135            or when more than one result is in this response, > max_resp
   2136            responses could be processed which can confuse some apps
   2137         */
   2138         if (p_inq->inqparms.max_resps &&
   2139             p_inq->inq_cmpl_info.num_resp >= p_inq->inqparms.max_resps
   2140 #if BLE_INCLUDED == TRUE
   2141             /* new device response */
   2142             && ( p_i == NULL ||
   2143                 /* exisiting device with BR/EDR info */
   2144                 (p_i && (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) != 0)
   2145                )
   2146 #endif
   2147 
   2148             )
   2149         {
   2150 /*            BTM_TRACE_WARNING("INQ RES: Extra Response Received...ignoring"); */
   2151             return;
   2152         }
   2153 #endif
   2154 
   2155         /* Check if this address has already been processed for this inquiry */
   2156         if (btm_inq_find_bdaddr(bda))
   2157         {
   2158 /*             BTM_TRACE_DEBUG("BDA seen before [%02x%02x %02x%02x %02x%02x]",
   2159                              bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);*/
   2160              /* By default suppose no update needed */
   2161             i_rssi = (INT8)rssi;
   2162 
   2163             /* If this new RSSI is higher than the last one */
   2164             if(p_inq->inqparms.report_dup && (rssi != 0) &&
   2165                p_i && (i_rssi > p_i->inq_info.results.rssi || p_i->inq_info.results.rssi == 0
   2166 #if BLE_INCLUDED == TRUE
   2167                /* BR/EDR inquiry information update */
   2168                        || (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR) != 0
   2169 #endif
   2170                        ))
   2171             {
   2172                 p_cur = &p_i->inq_info.results;
   2173                 BTM_TRACE_DEBUG("update RSSI new:%d, old:%d", i_rssi, p_cur->rssi);
   2174                 p_cur->rssi = i_rssi;
   2175                 update = TRUE;
   2176             }
   2177             /* If we received a second Extended Inq Event for an already */
   2178             /* discovered device, this is because for the first one EIR was not received */
   2179             else if ((inq_res_mode == BTM_INQ_RESULT_EXTENDED) && (p_i))
   2180             {
   2181                 p_cur = &p_i->inq_info.results;
   2182                 update = TRUE;
   2183             }
   2184             /* If no update needed continue with next response (if any) */
   2185             else
   2186                 continue;
   2187         }
   2188 
   2189         /* Host can be registered to verify comming BDA or DC */
   2190         if (btm_cb.p_inq_filter_cb)
   2191         {
   2192             if (!(* btm_cb.p_inq_filter_cb) (bda, dc))
   2193             {
   2194                 continue;
   2195             }
   2196         }
   2197 
   2198         /* If existing entry, use that, else get a new one (possibly reusing the oldest) */
   2199         if (p_i == NULL)
   2200         {
   2201             p_i = btm_inq_db_new (bda);
   2202             is_new = TRUE;
   2203         }
   2204 
   2205         /* If an entry for the device already exists, overwrite it ONLY if it is from
   2206            a previous inquiry. (Ignore it if it is a duplicate response from the same
   2207            inquiry.
   2208         */
   2209         else if (p_i->inq_count == p_inq->inq_counter
   2210 #if (BLE_INCLUDED == TRUE )
   2211             && (p_i->inq_info.results.device_type & BT_DEVICE_TYPE_BREDR)
   2212 #endif
   2213             )
   2214             is_new = FALSE;
   2215 
   2216         /* keep updating RSSI to have latest value */
   2217         if( inq_res_mode != BTM_INQ_RESULT_STANDARD )
   2218             p_i->inq_info.results.rssi = (INT8)rssi;
   2219         else
   2220             p_i->inq_info.results.rssi = BTM_INQ_RES_IGNORE_RSSI;
   2221 
   2222         if (is_new == TRUE)
   2223         {
   2224             /* Save the info */
   2225             p_cur = &p_i->inq_info.results;
   2226             p_cur->page_scan_rep_mode = page_scan_rep_mode;
   2227             p_cur->page_scan_per_mode = page_scan_per_mode;
   2228             p_cur->page_scan_mode     = page_scan_mode;
   2229             p_cur->dev_class[0]       = dc[0];
   2230             p_cur->dev_class[1]       = dc[1];
   2231             p_cur->dev_class[2]       = dc[2];
   2232             p_cur->clock_offset       = clock_offset  | BTM_CLOCK_OFFSET_VALID;
   2233 
   2234             p_i->time_of_resp = GKI_get_tick_count ();
   2235 
   2236             if (p_i->inq_count != p_inq->inq_counter)
   2237                 p_inq->inq_cmpl_info.num_resp++;       /* A new response was found */
   2238 
   2239 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
   2240             p_cur->inq_result_type    = BTM_INQ_RESULT_BR;
   2241             if (p_i->inq_count != p_inq->inq_counter)
   2242             {
   2243                 p_cur->device_type  = BT_DEVICE_TYPE_BREDR;
   2244                 p_i->scan_rsp       = FALSE;
   2245             }
   2246             else
   2247                 p_cur->device_type    |= BT_DEVICE_TYPE_BREDR;
   2248 #endif
   2249                 p_i->inq_count = p_inq->inq_counter;   /* Mark entry for current inquiry */
   2250 
   2251 #if BTM_USE_INQ_RESULTS_FILTER == TRUE
   2252             /* If the number of responses found and not unlimited, issue a cancel inquiry */
   2253             if (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) &&
   2254                 p_inq->inqparms.max_resps &&
   2255                 p_inq->inq_cmpl_info.num_resp == p_inq->inqparms.max_resps
   2256 #if BLE_INCLUDED == TRUE
   2257                 /* BLE scanning is active and received adv */
   2258                 && ((((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0) &&
   2259                      p_cur->device_type == BT_DEVICE_TYPE_DUMO && p_i->scan_rsp) ||
   2260                     (p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) == 0)
   2261 #endif
   2262                 )
   2263             {
   2264 /*                BTM_TRACE_DEBUG("BTMINQ: Found devices, cancelling inquiry..."); */
   2265                 btsnd_hcic_inq_cancel();
   2266 
   2267 #if BLE_INCLUDED == TRUE
   2268                 if ((p_inq->inqparms.mode & BTM_BLE_INQUIRY_MASK) != 0)
   2269                     btm_ble_stop_inquiry();
   2270 #endif
   2271 
   2272 
   2273 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
   2274                 btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT);
   2275 #endif
   2276             }
   2277 #endif
   2278             /* Initialize flag to FALSE. This flag is set/used by application */
   2279             p_i->inq_info.appl_knows_rem_name = FALSE;
   2280         }
   2281 
   2282         if (is_new || update)
   2283         {
   2284 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2285 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   2286             if( inq_res_mode == BTM_INQ_RESULT_EXTENDED )
   2287             {
   2288                 if((p_eir_data = BTM_CheckEirData( p, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE,
   2289                                                    &remote_name_len )) == NULL)
   2290                 {
   2291                     p_eir_data = BTM_CheckEirData( p, BTM_EIR_SHORTENED_LOCAL_NAME_TYPE,
   2292                                                    &remote_name_len );
   2293                 }
   2294 
   2295                 if( p_eir_data )
   2296                 {
   2297                     if( remote_name_len > BTM_MAX_REM_BD_NAME_LEN )
   2298                         remote_name_len = BTM_MAX_REM_BD_NAME_LEN;
   2299 
   2300                     p_i->inq_info.remote_name_len = remote_name_len;
   2301                     memcpy( p_i->inq_info.remote_name, p_eir_data, p_i->inq_info.remote_name_len );
   2302                     p_i->inq_info.remote_name[p_i->inq_info.remote_name_len] = 0;
   2303                     p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_DONE;
   2304                 }
   2305                 else
   2306                     p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   2307             }
   2308             else
   2309 #endif
   2310             {
   2311             /* Clear out the device name so that it can be re-read */
   2312             p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   2313             }
   2314 #endif /*(BTM_INQ_GET_REMOTE_NAME==TRUE)*/
   2315 
   2316 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   2317             if( inq_res_mode == BTM_INQ_RESULT_EXTENDED )
   2318             {
   2319                 memset( p_cur->eir_uuid, 0,
   2320                         BTM_EIR_SERVICE_ARRAY_SIZE * (BTM_EIR_ARRAY_BITS/8));
   2321                 /* set bit map of UUID list from received EIR */
   2322                 btm_set_eir_uuid( p, p_cur );
   2323                 p_eir_data = p;
   2324             }
   2325             else
   2326                 p_eir_data = NULL;
   2327 #endif
   2328 
   2329             /* If a callback is registered, call it with the results */
   2330             if (p_inq_results_cb)
   2331 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   2332                 (p_inq_results_cb)((tBTM_INQ_RESULTS *) p_cur, p_eir_data);
   2333 #else
   2334                 (p_inq_results_cb)((tBTM_INQ_RESULTS *) p_cur, NULL);
   2335 #endif
   2336 
   2337             /* If anyone is registered for change notifications, then tell him we added an entry.  */
   2338             if (p_inq->p_inq_change_cb)
   2339                 (*p_inq->p_inq_change_cb) (&p_i->inq_info, TRUE);
   2340         }
   2341     }
   2342 }
   2343 
   2344 /*******************************************************************************
   2345 **
   2346 ** Function         btm_sort_inq_result
   2347 **
   2348 ** Description      This function is called when inquiry complete is received
   2349 **                  from the device to sort inquiry results based on rssi.
   2350 **
   2351 ** Returns          void
   2352 **
   2353 *******************************************************************************/
   2354 void btm_sort_inq_result(void)
   2355 {
   2356     UINT8               xx, yy, num_resp;
   2357     tINQ_DB_ENT         *p_tmp  = NULL;
   2358     tINQ_DB_ENT         *p_ent  = btm_cb.btm_inq_vars.inq_db;
   2359     tINQ_DB_ENT         *p_next = btm_cb.btm_inq_vars.inq_db+1;
   2360     int                 size;
   2361 
   2362     num_resp = (btm_cb.btm_inq_vars.inq_cmpl_info.num_resp<BTM_INQ_DB_SIZE)?
   2363                 btm_cb.btm_inq_vars.inq_cmpl_info.num_resp: BTM_INQ_DB_SIZE;
   2364 
   2365     if((p_tmp = (tINQ_DB_ENT *)GKI_getbuf(sizeof(tINQ_DB_ENT))) != NULL)
   2366     {
   2367         size = sizeof(tINQ_DB_ENT);
   2368         for(xx = 0; xx < num_resp-1; xx++, p_ent++)
   2369         {
   2370             for(yy = xx+1, p_next = p_ent+1; yy < num_resp; yy++, p_next++)
   2371             {
   2372                 if(p_ent->inq_info.results.rssi < p_next->inq_info.results.rssi)
   2373                 {
   2374                     memcpy (p_tmp,  p_next, size);
   2375                     memcpy (p_next, p_ent,  size);
   2376                     memcpy (p_ent,  p_tmp,  size);
   2377                 }
   2378             }
   2379         }
   2380 
   2381         GKI_freebuf(p_tmp);
   2382     }
   2383 }
   2384 
   2385 /*******************************************************************************
   2386 **
   2387 ** Function         btm_process_inq_complete
   2388 **
   2389 ** Description      This function is called when inquiry complete is received
   2390 **                  from the device.  Call the callback if not in periodic inquiry
   2391 **                  mode AND it is not NULL (The caller wants the event).
   2392 **
   2393 **                  The callback pass back the status and the number of responses
   2394 **
   2395 ** Returns          void
   2396 **
   2397 *******************************************************************************/
   2398 void btm_process_inq_complete (UINT8 status, UINT8 mode)
   2399 {
   2400     tBTM_CMPL_CB        *p_inq_cb = btm_cb.btm_inq_vars.p_inq_cmpl_cb;
   2401     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   2402 
   2403 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2404     tBTM_INQ_INFO  *p_cur;
   2405     UINT8           tempstate;
   2406 #endif
   2407 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
   2408     /* inquiry inactive case happens when inquiry is cancelled.
   2409        Make mode 0 for no further inquiries from the current inquiry process
   2410     */
   2411     if(status!=HCI_SUCCESS || p_inq->next_state==BTM_FINISH || !p_inq->inq_active)
   2412     {
   2413         /* re-initialize for next inquiry request */
   2414         p_inq->next_state=BTM_BR_ONE;
   2415         /* make the mode 0 here */
   2416         p_inq->inqparms.mode &= ~(p_inq->inqparms.mode);
   2417 
   2418     }
   2419 #endif
   2420 
   2421 #if (!defined(BTA_HOST_INTERLEAVE_SEARCH) || BTA_HOST_INTERLEAVE_SEARCH == FALSE)
   2422     p_inq->inqparms.mode &= ~(mode);
   2423 #endif
   2424 
   2425     if(p_inq->scan_type == INQ_LE_OBSERVE && !p_inq->inq_active)
   2426     {
   2427         /*end of LE observe*/
   2428         p_inq->p_inq_ble_results_cb = (tBTM_INQ_RESULTS_CB *) NULL;
   2429         p_inq->p_inq_ble_cmpl_cb = (tBTM_CMPL_CB *) NULL;
   2430         p_inq->scan_type=INQ_NONE;
   2431     }
   2432 
   2433 
   2434 #if (BTM_INQ_DEBUG == TRUE)
   2435     BTM_TRACE_DEBUG ("btm_process_inq_complete inq_active:0x%x state:%d inqfilt_active:%d",
   2436         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
   2437 #endif
   2438 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
   2439     btm_acl_update_busy_level (BTM_BLI_INQ_DONE_EVT);
   2440 #endif
   2441     /* Ignore any stray or late complete messages if the inquiry is not active */
   2442     if (p_inq->inq_active)
   2443     {
   2444         p_inq->inq_cmpl_info.status = (tBTM_STATUS)((status == HCI_SUCCESS) ? BTM_SUCCESS : BTM_ERR_PROCESSING);
   2445 
   2446 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2447         if (p_inq->inq_cmpl_info.status == BTM_SUCCESS)
   2448         {
   2449             for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur))
   2450             {
   2451                 if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_EMPTY)
   2452                 {
   2453                     tempstate = p_cur->remote_name_state;
   2454                     p_cur->remote_name_state = BTM_INQ_RMT_NAME_PENDING;
   2455 
   2456                     if (btm_initiate_rem_name (p_cur->results.remote_bd_addr,
   2457                                                p_cur, BTM_RMT_NAME_INQ,
   2458                                                BTM_INQ_RMT_NAME_TIMEOUT, NULL) != BTM_CMD_STARTED)
   2459                         p_cur->remote_name_state = tempstate;
   2460                     else
   2461                         return;
   2462                 }
   2463             }
   2464         }
   2465 #endif
   2466 
   2467         /* Notify caller that the inquiry has completed; (periodic inquiries do not send completion events */
   2468         if (!(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE) && p_inq->inqparms.mode == 0)
   2469         {
   2470             p_inq->state = BTM_INQ_INACTIVE_STATE;
   2471 
   2472             /* Increment so the start of a next inquiry has a new count */
   2473             p_inq->inq_counter++;
   2474 
   2475             btm_clr_inq_result_flt();
   2476 
   2477             if((p_inq->inq_cmpl_info.status == BTM_SUCCESS) &&
   2478                 HCI_LMP_INQ_RSSI_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
   2479             {
   2480                 btm_sort_inq_result();
   2481             }
   2482 
   2483             /* Clear the results callback if set */
   2484             p_inq->p_inq_results_cb = (tBTM_INQ_RESULTS_CB *) NULL;
   2485             p_inq->inq_active = BTM_INQUIRY_INACTIVE;
   2486             p_inq->p_inq_cmpl_cb = (tBTM_CMPL_CB *) NULL;
   2487 
   2488             /* If we have a callback registered for inquiry complete, call it */
   2489             BTM_TRACE_DEBUG ("BTM Inq Compl Callback: status 0x%02x, num results %d",
   2490                         p_inq->inq_cmpl_info.status, p_inq->inq_cmpl_info.num_resp);
   2491 
   2492             if (p_inq_cb)
   2493                 (p_inq_cb)((tBTM_INQUIRY_CMPL *) &p_inq->inq_cmpl_info);
   2494         }
   2495 #if (defined(BTA_HOST_INTERLEAVE_SEARCH) && BTA_HOST_INTERLEAVE_SEARCH == TRUE)
   2496         if(p_inq->inqparms.mode != 0 && !(p_inq->inq_active & BTM_PERIODIC_INQUIRY_ACTIVE))
   2497         {
   2498             /* make inquiry inactive for next iteration */
   2499             p_inq->inq_active = BTM_INQUIRY_INACTIVE;
   2500             /* call the inquiry again */
   2501             BTM_StartInquiry(&p_inq->inqparms,p_inq->p_inq_results_cb,p_inq->p_inq_cmpl_cb);
   2502         }
   2503 #endif
   2504     }
   2505     if(p_inq->inqparms.mode == 0 && p_inq->scan_type == INQ_GENERAL)//this inquiry is complete
   2506     {
   2507         p_inq->scan_type = INQ_NONE;
   2508 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
   2509         /* check if the LE observe is pending */
   2510         if(p_inq->p_inq_ble_results_cb != NULL)
   2511         {
   2512             BTM_TRACE_DEBUG("BTM Inq Compl: resuming a pending LE scan");
   2513             BTM_BleObserve(1,0, p_inq->p_inq_ble_results_cb, p_inq->p_inq_ble_cmpl_cb);
   2514         }
   2515 #endif
   2516     }
   2517 #if (BTM_INQ_DEBUG == TRUE)
   2518     BTM_TRACE_DEBUG ("inq_active:0x%x state:%d inqfilt_active:%d",
   2519         btm_cb.btm_inq_vars.inq_active, btm_cb.btm_inq_vars.state, btm_cb.btm_inq_vars.inqfilt_active);
   2520 #endif
   2521 }
   2522 
   2523 /*******************************************************************************
   2524 **
   2525 ** Function         btm_process_cancel_complete
   2526 **
   2527 ** Description      This function is called when inquiry cancel complete is received
   2528 **                  from the device.This function will also call the btm_process_inq_complete
   2529 **                  This function is needed to differentiate a cancel_cmpl_evt from the
   2530 **                  inq_cmpl_evt
   2531 **
   2532 ** Returns          void
   2533 **
   2534 *******************************************************************************/
   2535 void btm_process_cancel_complete(UINT8 status, UINT8 mode)
   2536 {
   2537 #if (defined(BTM_BUSY_LEVEL_CHANGE_INCLUDED) && BTM_BUSY_LEVEL_CHANGE_INCLUDED == TRUE)
   2538      btm_acl_update_busy_level (BTM_BLI_INQ_CANCEL_EVT);
   2539 #endif
   2540      btm_process_inq_complete(status, mode);
   2541 }
   2542 /*******************************************************************************
   2543 **
   2544 ** Function         btm_initiate_rem_name
   2545 **
   2546 ** Description      This function looks initiates a remote name request.  It is called
   2547 **                  either by GAP or by the API call BTM_ReadRemoteDeviceName.
   2548 **
   2549 ** Input Params:    p_cur         - pointer to an inquiry result structure (NULL if nonexistent)
   2550 **                  p_cb            - callback function called when BTM_CMD_STARTED
   2551 **                                    is returned.
   2552 **                                    A pointer to tBTM_REMOTE_DEV_NAME is passed to the
   2553 **                                    callback.
   2554 **
   2555 ** Returns
   2556 **                  BTM_CMD_STARTED is returned if the request was sent to HCI.
   2557 **                  BTM_BUSY if already in progress
   2558 **                  BTM_NO_RESOURCES if could not allocate resources to start the command
   2559 **                  BTM_WRONG_MODE if the device is not up.
   2560 **
   2561 *******************************************************************************/
   2562 tBTM_STATUS  btm_initiate_rem_name (BD_ADDR remote_bda, tBTM_INQ_INFO *p_cur,
   2563                                     UINT8 origin, UINT32 timeout, tBTM_CMPL_CB *p_cb)
   2564 {
   2565     tBTM_INQUIRY_VAR_ST *p_inq = &btm_cb.btm_inq_vars;
   2566     BOOLEAN              cmd_ok;
   2567 
   2568 
   2569     /*** Make sure the device is ready ***/
   2570     if (!BTM_IsDeviceUp())
   2571         return (BTM_WRONG_MODE);
   2572 
   2573 
   2574     if (origin == BTM_RMT_NAME_SEC)
   2575     {
   2576         cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, HCI_PAGE_SCAN_REP_MODE_R1,
   2577                                          HCI_MANDATARY_PAGE_SCAN_MODE, 0);
   2578         if (cmd_ok)
   2579             return BTM_CMD_STARTED;
   2580         else
   2581             return BTM_NO_RESOURCES;
   2582     }
   2583     /* Make sure there are no two remote name requests from external API in progress */
   2584     else if (origin == BTM_RMT_NAME_EXT)
   2585     {
   2586         if (p_inq->remname_active)
   2587         {
   2588             return (BTM_BUSY);
   2589         }
   2590         else
   2591         {
   2592             /* If there is no remote name request running,call the callback function and start timer */
   2593             p_inq->p_remname_cmpl_cb = p_cb;
   2594             memcpy(p_inq->remname_bda, remote_bda, BD_ADDR_LEN);
   2595             btu_start_timer (&p_inq->rmt_name_timer_ent,
   2596                              BTU_TTYPE_BTM_RMT_NAME,
   2597                              timeout);
   2598 
   2599             /* If the database entry exists for the device, use its clock offset */
   2600             if (p_cur)
   2601             {
   2602                 cmd_ok = btsnd_hcic_rmt_name_req (remote_bda,
   2603                                          p_cur->results.page_scan_rep_mode,
   2604                                          p_cur->results.page_scan_mode,
   2605                                          (UINT16)(p_cur->results.clock_offset |
   2606                                                   BTM_CLOCK_OFFSET_VALID));
   2607             }
   2608             else /* Otherwise use defaults and mark the clock offset as invalid */
   2609             {
   2610                 cmd_ok = btsnd_hcic_rmt_name_req (remote_bda, HCI_PAGE_SCAN_REP_MODE_R1,
   2611                                          HCI_MANDATARY_PAGE_SCAN_MODE, 0);
   2612             }
   2613             if (cmd_ok)
   2614             {
   2615                 p_inq->remname_active = TRUE;
   2616                 return BTM_CMD_STARTED;
   2617             }
   2618             else
   2619                 return BTM_NO_RESOURCES;
   2620         }
   2621     }
   2622     /* If the inquire feature is on */
   2623 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2624 
   2625     else if (origin == BTM_RMT_NAME_INQ)
   2626     {
   2627         /* If the database entry exists for the device, use its clock offset */
   2628         if (p_cur)
   2629         {
   2630             cmd_ok = btsnd_hcic_rmt_name_req (remote_bda,
   2631                                      p_cur->results.page_scan_rep_mode,
   2632                                      p_cur->results.page_scan_mode,
   2633                                      (UINT16)(p_cur->results.clock_offset |
   2634                                               BTM_CLOCK_OFFSET_VALID));
   2635         }
   2636         else
   2637         {
   2638             cmd_ok = FALSE
   2639         }
   2640 
   2641         if (cmd_ok)
   2642             return BTM_CMD_STARTED;
   2643         else
   2644             return BTM_NO_RESOURCES;
   2645     }
   2646 #endif
   2647     else
   2648     {
   2649 
   2650         return BTM_ILLEGAL_VALUE;
   2651 
   2652 
   2653     }
   2654 
   2655 
   2656 }
   2657 
   2658 /*******************************************************************************
   2659 **
   2660 ** Function         btm_process_remote_name
   2661 **
   2662 ** Description      This function is called when a remote name is received from
   2663 **                  the device. If remote names are cached, it updates the inquiry
   2664 **                  database.
   2665 **
   2666 ** Returns          void
   2667 **
   2668 *******************************************************************************/
   2669 void btm_process_remote_name (BD_ADDR bda, BD_NAME bdn, UINT16 evt_len, UINT8 hci_status)
   2670 {
   2671     tBTM_REMOTE_DEV_NAME    rem_name;
   2672     tBTM_INQUIRY_VAR_ST    *p_inq = &btm_cb.btm_inq_vars;
   2673     tBTM_CMPL_CB           *p_cb = p_inq->p_remname_cmpl_cb;
   2674     UINT8                  *p_n1;
   2675 
   2676     UINT16                 temp_evt_len;
   2677 
   2678 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2679     /*** These are only used if part of the Inquiry Process ***/
   2680     tBTM_CMPL_CB           *p_inq_cb;
   2681     tINQ_DB_ENT            *p_i = NULL;
   2682     UINT8                  *p_n;
   2683     tBTM_INQ_INFO          *p_cur;
   2684 #endif
   2685 
   2686     if (bda != NULL)
   2687     {
   2688         BTM_TRACE_EVENT("BDA %02x:%02x:%02x:%02x:%02x:%02x",bda[0], bda[1],
   2689                  bda[2], bda[3],
   2690                  bda[4], bda[5]);
   2691     }
   2692 
   2693 	BTM_TRACE_EVENT("Inquire BDA %02x:%02x:%02x:%02x:%02x:%02x",p_inq->remname_bda[0], p_inq->remname_bda[1],
   2694              p_inq->remname_bda[2], p_inq->remname_bda[3],
   2695              p_inq->remname_bda[4], p_inq->remname_bda[5]);
   2696 
   2697 
   2698 
   2699     /* If the inquire BDA and remote DBA are the same, then stop the timer and set the active to false */
   2700     if ((p_inq->remname_active ==TRUE)&&
   2701         (((bda != NULL) &&
   2702         (memcmp(bda, p_inq->remname_bda,BD_ADDR_LEN)==0)) || bda == NULL))
   2703 
   2704 	{
   2705 #if BLE_INCLUDED == TRUE
   2706         if (BTM_UseLeLink(p_inq->remname_bda))
   2707         {
   2708             if (hci_status == HCI_ERR_UNSPECIFIED)
   2709                 btm_ble_cancel_remote_name(p_inq->remname_bda);
   2710         }
   2711 #endif
   2712         btu_stop_timer (&p_inq->rmt_name_timer_ent);
   2713         p_inq->remname_active = FALSE;
   2714          /* Clean up and return the status if the command was not successful */
   2715          /* Note: If part of the inquiry, the name is not stored, and the    */
   2716          /*       inquiry complete callback is called.                       */
   2717 
   2718         if ((hci_status == HCI_SUCCESS))
   2719         {
   2720             /* Copy the name from the data stream into the return structure */
   2721             /* Note that even if it is not being returned, it is used as a  */
   2722             /*      temporary buffer.                                       */
   2723             p_n1 = (UINT8 *)rem_name.remote_bd_name;
   2724             rem_name.length = (evt_len < BD_NAME_LEN) ? evt_len : BD_NAME_LEN;
   2725             rem_name.remote_bd_name[rem_name.length] = 0;
   2726             rem_name.status = BTM_SUCCESS;
   2727             temp_evt_len = rem_name.length;
   2728 
   2729             while (temp_evt_len > 0)
   2730             {
   2731                 *p_n1++ = *bdn++;
   2732                 temp_evt_len--;
   2733             }
   2734             rem_name.remote_bd_name[rem_name.length] = 0;
   2735         }
   2736 
   2737 
   2738         /* If processing a stand alone remote name then report the error in the callback */
   2739         else
   2740         {
   2741             rem_name.status = BTM_BAD_VALUE_RET;
   2742             rem_name.length = 0;
   2743             rem_name.remote_bd_name[0] = 0;
   2744         }
   2745         /* Reset the remote BAD to zero and call callback if possible */
   2746         memset(p_inq->remname_bda, 0, BD_ADDR_LEN);
   2747 
   2748         p_inq->p_remname_cmpl_cb = NULL;
   2749         if (p_cb)
   2750             (p_cb)((tBTM_REMOTE_DEV_NAME *)&rem_name);
   2751     }
   2752 
   2753 
   2754 #if (BTM_INQ_GET_REMOTE_NAME==TRUE)
   2755     /* If existing entry, update the name */
   2756     if ((bda != NULL) && ((p_i = btm_inq_db_find (bda)) != NULL)
   2757      && (hci_status == HCI_SUCCESS))
   2758     {
   2759         p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_DONE;
   2760         p_n = p_i->inq_info.remote_name;
   2761         memset(p_n, 0, BTM_MAX_REM_BD_NAME_LEN + 1);
   2762         p_i->inq_info.remote_name_len = (rem_name.length < BTM_MAX_REM_BD_NAME_LEN) ?
   2763                                          rem_name.length : BTM_MAX_REM_BD_NAME_LEN;
   2764         evt_len = p_i->inq_info.remote_name_len;
   2765         p_n1 = (UINT8 *)rem_name.remote_bd_name;
   2766         while (evt_len > 0)
   2767         {
   2768             *p_n++ = *p_n1++;
   2769             evt_len--;
   2770         }
   2771 
   2772         if (btm_cb.btm_inq_vars.p_inq_change_cb)
   2773             (*btm_cb.btm_inq_vars.p_inq_change_cb) (&p_i->inq_info, TRUE);
   2774     }
   2775     else
   2776     {
   2777         if (p_i)
   2778             p_i->inq_info.remote_name_state = BTM_INQ_RMT_NAME_FAILED;
   2779         else
   2780         {
   2781             /* Find the entry which is currently doing name request */
   2782             for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur))
   2783             {
   2784                 if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_PENDING)
   2785                 {
   2786                     /* Should be only one */
   2787                     p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED;
   2788                     break;
   2789                 }
   2790             }
   2791         }
   2792     }
   2793 
   2794     /* If an inquiry is in progress then update other entries */
   2795     if (p_inq->inq_active)
   2796     {
   2797         /* Check if there are any more entries inquired but not named */
   2798         for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur))
   2799         {
   2800             if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_EMPTY)
   2801             {
   2802                 p_cur->remote_name_state = BTM_INQ_RMT_NAME_PENDING;
   2803 #if (BLE_INCLUDED == TRUE)
   2804                 if (BTM_UseLeLink(remote_bda))
   2805                 {
   2806                     if (btm_ble_read_remote_name(remote_bda, p_cur, p_cb) != BTM_CMD_STARTED)
   2807                         p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED;
   2808                     else
   2809                         return;
   2810                 }
   2811                 else
   2812 #endif
   2813                 {
   2814                     if (btm_initiate_rem_name (p_cur->results.remote_bd_addr,
   2815                                                p_cur, BTM_RMT_NAME_INQ,
   2816                                                BTM_INQ_RMT_NAME_TIMEOUT, NULL) != BTM_CMD_STARTED)
   2817                         p_cur->remote_name_state = BTM_INQ_RMT_NAME_FAILED;
   2818                     else
   2819                         return;
   2820                 }
   2821             }
   2822         }
   2823 
   2824         /* The inquiry has finished so call the callback for the inquiry */
   2825         p_inq_cb = p_inq->p_inq_cmpl_cb;
   2826         p_inq->state = BTM_INQ_INACTIVE_STATE;
   2827         p_inq->inq_active = BTM_INQUIRY_INACTIVE;
   2828         p_inq->p_inq_cmpl_cb = NULL;
   2829 
   2830         /* If we have a callback registered for inquiry complete, call it */
   2831         if (p_inq_cb)
   2832             (p_inq_cb)((tBTM_INQUIRY_CMPL *) &p_inq->inq_cmpl_info);
   2833 
   2834         /* In some cases we can not get name of the device once but will be */
   2835         /* able to do it next time.  Until we have better solution we will  */
   2836         /* try to get name every time */
   2837         for (p_cur = BTM_InqDbFirst(); p_cur; p_cur = BTM_InqDbNext (p_cur))
   2838         {
   2839             if (p_cur->remote_name_state == BTM_INQ_RMT_NAME_FAILED)
   2840                 p_cur->remote_name_state = BTM_INQ_RMT_NAME_EMPTY;
   2841         }
   2842     }
   2843 #endif  /* BTM_INQ_GET_REMOTE_NAME == TRUE */
   2844 }
   2845 
   2846 /*******************************************************************************
   2847 **
   2848 ** Function         btm_inq_rmt_name_failed
   2849 **
   2850 ** Description      This function is if timeout expires while getting remote
   2851 **                  name.  This is done for devices that incorrectly do not
   2852 **                  report operation failure
   2853 **
   2854 ** Returns          void
   2855 **
   2856 *******************************************************************************/
   2857 void btm_inq_rmt_name_failed (void)
   2858 {
   2859     BTM_TRACE_ERROR ("btm_inq_rmt_name_failed()  remname_active=%d", btm_cb.btm_inq_vars.remname_active);
   2860 
   2861     if (btm_cb.btm_inq_vars.remname_active)
   2862         btm_process_remote_name (btm_cb.btm_inq_vars.remname_bda, NULL, 0, HCI_ERR_UNSPECIFIED);
   2863     else
   2864         btm_process_remote_name (NULL, NULL, 0, HCI_ERR_UNSPECIFIED);
   2865 
   2866     btm_sec_rmt_name_request_complete (NULL, NULL, HCI_ERR_UNSPECIFIED);
   2867 }
   2868 /*******************************************************************************
   2869 **
   2870 ** Function         btm_read_linq_tx_power_complete
   2871 **
   2872 ** Description      read inquiry tx power level complete callback function.
   2873 **
   2874 ** Returns          void
   2875 **
   2876 *******************************************************************************/
   2877 void btm_read_linq_tx_power_complete(UINT8 *p)
   2878 {
   2879     tBTM_CMPL_CB                *p_cb = btm_cb.devcb.p_txpwer_cmpl_cb;
   2880     tBTM_INQ_TXPWR_RESULTS        results;
   2881 
   2882     btu_stop_timer (&btm_cb.devcb.txpwer_timer);
   2883     /* If there was a callback registered for read inq tx power, call it */
   2884     btm_cb.devcb.p_txpwer_cmpl_cb = NULL;
   2885 
   2886     if (p_cb)
   2887     {
   2888         STREAM_TO_UINT8  (results.hci_status, p);
   2889 
   2890         if (results.hci_status == HCI_SUCCESS)
   2891         {
   2892             results.status = BTM_SUCCESS;
   2893 
   2894             STREAM_TO_UINT8 (results.tx_power, p);
   2895             BTM_TRACE_EVENT ("BTM INQ TX POWER Complete: tx_power %d, hci status 0x%02x",
   2896                               results.tx_power, results.hci_status);
   2897         }
   2898         else
   2899             results.status = BTM_ERR_PROCESSING;
   2900 
   2901         (*p_cb)(&results);
   2902     }
   2903 
   2904 }
   2905 /*******************************************************************************
   2906 **
   2907 ** Function         BTM_WriteEIR
   2908 **
   2909 ** Description      This function is called to write EIR data to controller.
   2910 **
   2911 ** Parameters       p_buff - allocated HCI command buffer including extended
   2912 **                           inquriry response
   2913 **
   2914 ** Returns          BTM_SUCCESS  - if successful
   2915 **                  BTM_MODE_UNSUPPORTED - if local device cannot support it
   2916 **
   2917 *******************************************************************************/
   2918 tBTM_STATUS BTM_WriteEIR( BT_HDR *p_buff )
   2919 {
   2920 #if (BTM_EIR_SERVER_INCLUDED == TRUE)
   2921     if (HCI_EXT_INQ_RSP_SUPPORTED(btm_cb.devcb.local_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
   2922     {
   2923         BTM_TRACE_API("Write Extended Inquiry Response to controller");
   2924         btsnd_hcic_write_ext_inquiry_response (p_buff, BTM_EIR_DEFAULT_FEC_REQUIRED);
   2925         return BTM_SUCCESS;
   2926     }
   2927     else
   2928     {
   2929         GKI_freebuf(p_buff);
   2930         return BTM_MODE_UNSUPPORTED;
   2931     }
   2932 #else
   2933     GKI_freebuf(p_buff);
   2934     return BTM_SUCCESS;
   2935 #endif
   2936 }
   2937 
   2938 /*******************************************************************************
   2939 **
   2940 ** Function         BTM_CheckEirData
   2941 **
   2942 ** Description      This function is called to get EIR data from significant part.
   2943 **
   2944 ** Parameters       p_eir - pointer of EIR significant part
   2945 **                  type   - finding EIR data type
   2946 **                  p_length - return the length of EIR data not including type
   2947 **
   2948 ** Returns          pointer of EIR data
   2949 **
   2950 *******************************************************************************/
   2951 UINT8 *BTM_CheckEirData( UINT8 *p_eir, UINT8 type, UINT8 *p_length )
   2952 {
   2953 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   2954     UINT8 *p = p_eir;
   2955     UINT8 length;
   2956     UINT8 eir_type;
   2957     BTM_TRACE_API("BTM_CheckEirData type=0x%02X", type);
   2958 
   2959     STREAM_TO_UINT8(length, p);
   2960     while( length && (p - p_eir <= HCI_EXT_INQ_RESPONSE_LEN))
   2961     {
   2962         STREAM_TO_UINT8(eir_type, p);
   2963         if( eir_type == type )
   2964         {
   2965             /* length doesn't include itself */
   2966             *p_length = length - 1; /* minus the length of type */
   2967             return p;
   2968         }
   2969         p += length - 1; /* skip the length of data */
   2970         STREAM_TO_UINT8(length, p);
   2971     }
   2972 
   2973     *p_length = 0;
   2974     return NULL;
   2975 #else
   2976     return NULL;
   2977 #endif
   2978 }
   2979 
   2980 /*******************************************************************************
   2981 **
   2982 ** Function         btm_convert_uuid_to_eir_service
   2983 **
   2984 ** Description      This function is called to get the bit position of UUID.
   2985 **
   2986 ** Parameters       uuid16 - UUID 16-bit
   2987 **
   2988 ** Returns          BTM EIR service ID if found
   2989 **                  BTM_EIR_MAX_SERVICES - if not found
   2990 **
   2991 *******************************************************************************/
   2992 #if (( BTM_EIR_CLIENT_INCLUDED == TRUE )||( BTM_EIR_SERVER_INCLUDED == TRUE ))
   2993 static UINT8 btm_convert_uuid_to_eir_service( UINT16 uuid16 )
   2994 {
   2995     UINT8 xx;
   2996 
   2997     for( xx = 0; xx < BTM_EIR_MAX_SERVICES; xx++ )
   2998     {
   2999         if( uuid16 == BTM_EIR_UUID_LKUP_TBL[xx])
   3000         {
   3001             return xx;
   3002         }
   3003     }
   3004     return BTM_EIR_MAX_SERVICES;
   3005 }
   3006 #endif
   3007 
   3008 /*******************************************************************************
   3009 **
   3010 ** Function         BTM_HasEirService
   3011 **
   3012 ** Description      This function is called to know if UUID in bit map of UUID.
   3013 **
   3014 ** Parameters       p_eir_uuid - bit map of UUID list
   3015 **                  uuid16 - UUID 16-bit
   3016 **
   3017 ** Returns          TRUE - if found
   3018 **                  FALSE - if not found
   3019 **
   3020 *******************************************************************************/
   3021 BOOLEAN BTM_HasEirService( UINT32 *p_eir_uuid, UINT16 uuid16 )
   3022 {
   3023 #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
   3024     UINT8 service_id;
   3025 
   3026     service_id = btm_convert_uuid_to_eir_service(uuid16);
   3027     if( service_id < BTM_EIR_MAX_SERVICES )
   3028         return( BTM_EIR_HAS_SERVICE( p_eir_uuid, service_id ));
   3029     else
   3030         return( FALSE );
   3031 #else
   3032     return( FALSE );
   3033 #endif
   3034 }
   3035 
   3036 /*******************************************************************************
   3037 **
   3038 ** Function         BTM_HasInquiryEirService
   3039 **
   3040 ** Description      This function is called to know if UUID in bit map of UUID list.
   3041 **
   3042 ** Parameters       p_results - inquiry results
   3043 **                  uuid16 - UUID 16-bit
   3044 **
   3045 ** Returns          BTM_EIR_FOUND - if found
   3046 **                  BTM_EIR_NOT_FOUND - if not found and it is complete list
   3047 **                  BTM_EIR_UNKNOWN - if not found and it is not complete list
   3048 **
   3049 *******************************************************************************/
   3050 tBTM_EIR_SEARCH_RESULT BTM_HasInquiryEirService( tBTM_INQ_RESULTS *p_results, UINT16 uuid16 )
   3051 {
   3052 #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
   3053     if( BTM_HasEirService( p_results->eir_uuid, uuid16 ))
   3054     {
   3055         return BTM_EIR_FOUND;
   3056     }
   3057     else if( p_results->eir_complete_list )
   3058     {
   3059         return BTM_EIR_NOT_FOUND;
   3060     }
   3061     else
   3062         return BTM_EIR_UNKNOWN;
   3063 #else
   3064     return BTM_EIR_UNKNOWN;
   3065 #endif
   3066 }
   3067 
   3068 /*******************************************************************************
   3069 **
   3070 ** Function         BTM_AddEirService
   3071 **
   3072 ** Description      This function is called to add a service in bit map of UUID list.
   3073 **
   3074 ** Parameters       p_eir_uuid - bit mask of UUID list for EIR
   3075 **                  uuid16 - UUID 16-bit
   3076 **
   3077 ** Returns          None
   3078 **
   3079 *******************************************************************************/
   3080 void BTM_AddEirService( UINT32 *p_eir_uuid, UINT16 uuid16 )
   3081 {
   3082 #if ((BTM_EIR_SERVER_INCLUDED == TRUE)||(BTM_EIR_CLIENT_INCLUDED == TRUE))
   3083     UINT8 service_id;
   3084 
   3085     service_id = btm_convert_uuid_to_eir_service(uuid16);
   3086     if( service_id < BTM_EIR_MAX_SERVICES )
   3087         BTM_EIR_SET_SERVICE( p_eir_uuid, service_id );
   3088 #endif
   3089 }
   3090 
   3091 /*******************************************************************************
   3092 **
   3093 ** Function         BTM_RemoveEirService
   3094 **
   3095 ** Description      This function is called to remove a service in bit map of UUID list.
   3096 **
   3097 ** Parameters       p_eir_uuid - bit mask of UUID list for EIR
   3098 **                  uuid16 - UUID 16-bit
   3099 **
   3100 ** Returns          None
   3101 **
   3102 *******************************************************************************/
   3103 void BTM_RemoveEirService( UINT32 *p_eir_uuid, UINT16 uuid16 )
   3104 {
   3105 #if (BTM_EIR_SERVER_INCLUDED == TRUE)
   3106     UINT8 service_id;
   3107 
   3108     service_id = btm_convert_uuid_to_eir_service(uuid16);
   3109     if( service_id < BTM_EIR_MAX_SERVICES )
   3110         BTM_EIR_CLR_SERVICE( p_eir_uuid, service_id );
   3111 #endif
   3112 }
   3113 
   3114 /*******************************************************************************
   3115 **
   3116 ** Function         BTM_GetEirSupportedServices
   3117 **
   3118 ** Description      This function is called to get UUID list from bit map of UUID list.
   3119 **
   3120 ** Parameters       p_eir_uuid - bit mask of UUID list for EIR
   3121 **                  p - reference of current pointer of EIR
   3122 **                  max_num_uuid16 - max number of UUID can be written in EIR
   3123 **                  num_uuid16 - number of UUID have been written in EIR
   3124 **
   3125 ** Returns          BTM_EIR_MORE_16BITS_UUID_TYPE, if it has more than max
   3126 **                  BTM_EIR_COMPLETE_16BITS_UUID_TYPE, otherwise
   3127 **
   3128 *******************************************************************************/
   3129 UINT8 BTM_GetEirSupportedServices( UINT32 *p_eir_uuid,    UINT8 **p,
   3130                                    UINT8  max_num_uuid16, UINT8 *p_num_uuid16)
   3131 {
   3132 #if (BTM_EIR_SERVER_INCLUDED == TRUE)
   3133     UINT8 service_index;
   3134 
   3135     *p_num_uuid16 = 0;
   3136 
   3137     for(service_index = 0; service_index < BTM_EIR_MAX_SERVICES; service_index++)
   3138     {
   3139         if( BTM_EIR_HAS_SERVICE( p_eir_uuid, service_index ))
   3140         {
   3141             if( *p_num_uuid16 < max_num_uuid16 )
   3142             {
   3143                 UINT16_TO_STREAM(*p, BTM_EIR_UUID_LKUP_TBL[service_index]);
   3144                 (*p_num_uuid16)++;
   3145             }
   3146             /* if max number of UUIDs are stored and found one more */
   3147             else
   3148             {
   3149                 return BTM_EIR_MORE_16BITS_UUID_TYPE;
   3150             }
   3151         }
   3152     }
   3153     return BTM_EIR_COMPLETE_16BITS_UUID_TYPE;
   3154 #else
   3155     return BTM_EIR_COMPLETE_16BITS_UUID_TYPE;
   3156 #endif
   3157 }
   3158 
   3159 /*******************************************************************************
   3160 **
   3161 ** Function         BTM_GetEirUuidList
   3162 **
   3163 ** Description      This function parses EIR and returns UUID list.
   3164 **
   3165 ** Parameters       p_eir - EIR
   3166 **                  uuid_size - LEN_UUID_16, LEN_UUID_32, LEN_UUID_128
   3167 **                  p_num_uuid - return number of UUID in found list
   3168 **                  p_uuid_list - return UUID list
   3169 **                  max_num_uuid - maximum number of UUID to be returned
   3170 **
   3171 ** Returns          0 - if not found
   3172 **                  BTM_EIR_COMPLETE_16BITS_UUID_TYPE
   3173 **                  BTM_EIR_MORE_16BITS_UUID_TYPE
   3174 **                  BTM_EIR_COMPLETE_32BITS_UUID_TYPE
   3175 **                  BTM_EIR_MORE_32BITS_UUID_TYPE
   3176 **                  BTM_EIR_COMPLETE_128BITS_UUID_TYPE
   3177 **                  BTM_EIR_MORE_128BITS_UUID_TYPE
   3178 **
   3179 *******************************************************************************/
   3180 UINT8 BTM_GetEirUuidList( UINT8 *p_eir, UINT8 uuid_size, UINT8 *p_num_uuid,
   3181                             UINT8 *p_uuid_list, UINT8 max_num_uuid)
   3182 {
   3183 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   3184     UINT8   *p_uuid_data;
   3185     UINT8   type;
   3186     UINT8   yy, xx;
   3187     UINT16  *p_uuid16 = (UINT16 *)p_uuid_list;
   3188     UINT32  *p_uuid32 = (UINT32 *)p_uuid_list;
   3189     char    buff[LEN_UUID_128 * 2 + 1];
   3190 
   3191     p_uuid_data = btm_eir_get_uuid_list( p_eir, uuid_size, p_num_uuid, &type );
   3192     if( p_uuid_data == NULL )
   3193     {
   3194         return 0x00;
   3195     }
   3196 
   3197     if( *p_num_uuid > max_num_uuid )
   3198     {
   3199         BTM_TRACE_WARNING("BTM_GetEirUuidList number of uuid in EIR = %d, size of uuid list = %d",
   3200                            *p_num_uuid, max_num_uuid );
   3201         *p_num_uuid = max_num_uuid;
   3202     }
   3203 
   3204     BTM_TRACE_DEBUG("BTM_GetEirUuidList type = %02X, number of uuid = %d", type, *p_num_uuid );
   3205 
   3206     if( uuid_size == LEN_UUID_16 )
   3207     {
   3208         for( yy = 0; yy < *p_num_uuid; yy++ )
   3209         {
   3210             STREAM_TO_UINT16(*(p_uuid16 + yy), p_uuid_data);
   3211             BTM_TRACE_DEBUG("                     0x%04X", *(p_uuid16 + yy));
   3212         }
   3213     }
   3214     else if( uuid_size == LEN_UUID_32 )
   3215     {
   3216         for( yy = 0; yy < *p_num_uuid; yy++ )
   3217         {
   3218             STREAM_TO_UINT32(*(p_uuid32 + yy), p_uuid_data);
   3219             BTM_TRACE_DEBUG("                     0x%08X", *(p_uuid32 + yy));
   3220         }
   3221     }
   3222     else if( uuid_size == LEN_UUID_128 )
   3223     {
   3224         for( yy = 0; yy < *p_num_uuid; yy++ )
   3225         {
   3226             STREAM_TO_ARRAY16(p_uuid_list + yy * LEN_UUID_128, p_uuid_data);
   3227             for( xx = 0; xx < LEN_UUID_128; xx++ )
   3228                 sprintf(buff + xx*2, "%02X", *(p_uuid_list + yy * LEN_UUID_128 + xx));
   3229             BTM_TRACE_DEBUG("                     0x%s", buff);
   3230         }
   3231     }
   3232 
   3233     return type;
   3234 #else
   3235     *p_num_uuid = 0;
   3236     return 0x00;
   3237 #endif
   3238 }
   3239 
   3240 
   3241 #if (BTM_EIR_CLIENT_INCLUDED == TRUE)
   3242 /*******************************************************************************
   3243 **
   3244 ** Function         btm_eir_get_uuid_list
   3245 **
   3246 ** Description      This function searches UUID list in EIR.
   3247 **
   3248 ** Parameters       p_eir - address of EIR
   3249 **                  uuid_size - size of UUID to find
   3250 **                  p_num_uuid - number of UUIDs found
   3251 **                  p_uuid_list_type - EIR data type
   3252 **
   3253 ** Returns          NULL - if UUID list with uuid_size is not found
   3254 **                  beginning of UUID list in EIR - otherwise
   3255 **
   3256 *******************************************************************************/
   3257 static UINT8 *btm_eir_get_uuid_list( UINT8 *p_eir, UINT8 uuid_size,
   3258                                      UINT8 *p_num_uuid, UINT8 *p_uuid_list_type )
   3259 {
   3260     UINT8   *p_uuid_data;
   3261     UINT8   complete_type, more_type;
   3262     UINT8   uuid_len;
   3263 
   3264     switch( uuid_size )
   3265     {
   3266     case LEN_UUID_16:
   3267         complete_type = BTM_EIR_COMPLETE_16BITS_UUID_TYPE;
   3268         more_type     = BTM_EIR_MORE_16BITS_UUID_TYPE;
   3269         break;
   3270     case LEN_UUID_32:
   3271         complete_type = BTM_EIR_COMPLETE_32BITS_UUID_TYPE;
   3272         more_type     = BTM_EIR_MORE_32BITS_UUID_TYPE;
   3273         break;
   3274     case LEN_UUID_128:
   3275         complete_type = BTM_EIR_COMPLETE_128BITS_UUID_TYPE;
   3276         more_type     = BTM_EIR_MORE_128BITS_UUID_TYPE;
   3277         break;
   3278     default:
   3279         *p_num_uuid = 0;
   3280         return NULL;
   3281         break;
   3282     }
   3283 
   3284     p_uuid_data = BTM_CheckEirData( p_eir, complete_type, &uuid_len );
   3285     if(p_uuid_data == NULL)
   3286     {
   3287         p_uuid_data = BTM_CheckEirData( p_eir, more_type, &uuid_len );
   3288         *p_uuid_list_type = more_type;
   3289     }
   3290     else
   3291     {
   3292         *p_uuid_list_type = complete_type;
   3293     }
   3294 
   3295     *p_num_uuid = uuid_len / uuid_size;
   3296     return p_uuid_data;
   3297 }
   3298 
   3299 /*******************************************************************************
   3300 **
   3301 ** Function         btm_convert_uuid_to_uuid16
   3302 **
   3303 ** Description      This function converts UUID to UUID 16-bit.
   3304 **
   3305 ** Parameters       p_uuid - address of UUID
   3306 **                  uuid_size - size of UUID
   3307 **
   3308 ** Returns          0 - if UUID cannot be converted to UUID 16-bit
   3309 **                  UUID 16-bit - otherwise
   3310 **
   3311 *******************************************************************************/
   3312 static UINT16 btm_convert_uuid_to_uuid16( UINT8 *p_uuid, UINT8 uuid_size )
   3313 {
   3314     static const UINT8  base_uuid[LEN_UUID_128] = {0xFB, 0x34, 0x9B, 0x5F, 0x80, 0x00, 0x00, 0x80,
   3315                                                    0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
   3316     UINT16 uuid16 = 0;
   3317     UINT32 uuid32;
   3318     BOOLEAN is_base_uuid;
   3319     UINT8  xx;
   3320 
   3321     switch (uuid_size)
   3322     {
   3323     case LEN_UUID_16:
   3324         STREAM_TO_UINT16 (uuid16, p_uuid);
   3325         break;
   3326     case LEN_UUID_32:
   3327         STREAM_TO_UINT32 (uuid32, p_uuid);
   3328         if (uuid32 < 0x10000)
   3329             uuid16 = (UINT16) uuid32;
   3330         break;
   3331     case LEN_UUID_128:
   3332         /* See if we can compress his UUID down to 16 or 32bit UUIDs */
   3333         is_base_uuid = TRUE;
   3334         for (xx = 0; xx < LEN_UUID_128 - 4; xx++)
   3335         {
   3336             if (p_uuid[xx] != base_uuid[xx])
   3337             {
   3338                 is_base_uuid = FALSE;
   3339                 break;
   3340             }
   3341         }
   3342         if (is_base_uuid)
   3343         {
   3344             if ((p_uuid[LEN_UUID_128 - 1] == 0) && (p_uuid[LEN_UUID_128 - 2] == 0))
   3345             {
   3346                 p_uuid += (LEN_UUID_128 - 4);
   3347                 STREAM_TO_UINT16(uuid16, p_uuid);
   3348             }
   3349         }
   3350         break;
   3351     default:
   3352         BTM_TRACE_WARNING("btm_convert_uuid_to_uuid16 invalid uuid size");
   3353         break;
   3354     }
   3355 
   3356     return( uuid16);
   3357 }
   3358 
   3359 /*******************************************************************************
   3360 **
   3361 ** Function         btm_set_eir_uuid
   3362 **
   3363 ** Description      This function is called to store received UUID into inquiry result.
   3364 **
   3365 ** Parameters       p_eir - pointer of EIR significant part
   3366 **                  p_results - pointer of inquiry result
   3367 **
   3368 ** Returns          None
   3369 **
   3370 *******************************************************************************/
   3371 void btm_set_eir_uuid( UINT8 *p_eir, tBTM_INQ_RESULTS *p_results )
   3372 {
   3373     UINT8   *p_uuid_data;
   3374     UINT8   num_uuid;
   3375     UINT16  uuid16;
   3376     UINT8   yy;
   3377     UINT8   type = BTM_EIR_MORE_16BITS_UUID_TYPE;
   3378 
   3379     p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_16, &num_uuid, &type );
   3380 
   3381     if(type == BTM_EIR_COMPLETE_16BITS_UUID_TYPE)
   3382     {
   3383         p_results->eir_complete_list = TRUE;
   3384     }
   3385     else
   3386     {
   3387         p_results->eir_complete_list = FALSE;
   3388     }
   3389 
   3390     BTM_TRACE_API("btm_set_eir_uuid eir_complete_list=0x%02X", p_results->eir_complete_list);
   3391 
   3392     if( p_uuid_data )
   3393     {
   3394         for( yy = 0; yy < num_uuid; yy++ )
   3395         {
   3396             STREAM_TO_UINT16(uuid16, p_uuid_data);
   3397             BTM_AddEirService( p_results->eir_uuid, uuid16 );
   3398         }
   3399     }
   3400 
   3401     p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_32, &num_uuid, &type );
   3402     if( p_uuid_data )
   3403     {
   3404         for( yy = 0; yy < num_uuid; yy++ )
   3405         {
   3406             uuid16 = btm_convert_uuid_to_uuid16( p_uuid_data, LEN_UUID_32 );
   3407             p_uuid_data += LEN_UUID_32;
   3408             if( uuid16 )
   3409                 BTM_AddEirService( p_results->eir_uuid, uuid16 );
   3410         }
   3411     }
   3412 
   3413     p_uuid_data = btm_eir_get_uuid_list( p_eir, LEN_UUID_128, &num_uuid, &type );
   3414     if( p_uuid_data )
   3415     {
   3416         for( yy = 0; yy < num_uuid; yy++ )
   3417         {
   3418             uuid16 = btm_convert_uuid_to_uuid16( p_uuid_data, LEN_UUID_128 );
   3419             p_uuid_data += LEN_UUID_128;
   3420             if( uuid16 )
   3421                 BTM_AddEirService( p_results->eir_uuid, uuid16 );
   3422         }
   3423     }
   3424 }
   3425 #endif
   3426 
   3427