Remove unused code in GAP

Left the BLE stuff for now, since some of it appears to
be used at least right now.

9 files changed, 3 insertions, 3314 deletions

diff --git a/include/bt_target.h b/include/bt_target.h
index 6bfcdbaa7..139059ce6 100644
--- a/include/bt_target.h
+++ b/include/bt_target.h
@@ -1520,21 +1520,6 @@ Note:  This pool needs to have enough buffers to hold two times the window size
 #define GAP_INCLUDED                TRUE
 #endif
 
-/* This is set to enable use of GAP L2CAP connections. */
-#ifndef GAP_CONN_INCLUDED
-#define GAP_CONN_INCLUDED           TRUE
-#endif
-
-/* This is set to enable posting event for data write */
-#ifndef GAP_CONN_POST_EVT_INCLUDED
-#define GAP_CONN_POST_EVT_INCLUDED  FALSE
-#endif
-
-/* The maximum number of simultaneous GAP L2CAP connections. */
-#ifndef GAP_MAX_CONNECTIONS
-#define GAP_MAX_CONNECTIONS         8
-#endif
-
 /******************************************************************************
 **
 ** CTP
diff --git a/stack/Android.mk b/stack/Android.mk
index ad41b762a..e011201b0 100644
--- a/stack/Android.mk
+++ b/stack/Android.mk
@@ -151,8 +151,6 @@ LOCAL_SRC_FILES:= \
     ./l2cap/l2c_ble.c \
     ./gap/gap_api.c \
     ./gap/gap_ble.c \
-    ./gap/gap_conn.c \
-    ./gap/gap_utils.c \
     ../vnd/ble/vendor_ble.c
 
 LOCAL_MODULE := libbt-brcm_stack
diff --git a/stack/btu/btu_task.c b/stack/btu/btu_task.c
index 78492fbef..745136ee7 100644
--- a/stack/btu/btu_task.c
+++ b/stack/btu/btu_task.c
@@ -311,12 +311,6 @@ static void btu_hci_msg_process(BT_HDR *p_msg) {
             GKI_freebuf (p_msg);
             break;
 #endif /* SAP */
-#if (defined(GAP_CONN_INCLUDED) && GAP_CONN_INCLUDED == TRUE && GAP_CONN_POST_EVT_INCLUDED == TRUE)
-        case BT_EVT_TO_GAP_MSG :
-            gap_proc_btu_event(p_msg);
-            GKI_freebuf (p_msg);
-            break;
-#endif
             // NOTE: The timer calls below may not be sent by HCI.
         case BT_EVT_TO_START_TIMER :
             /* Start free running 1 second timer for list management */
diff --git a/stack/gap/gap_api.c b/stack/gap/gap_api.c
index 450118aca..a81efdca5 100644
--- a/stack/gap/gap_api.c
+++ b/stack/gap/gap_api.c
@@ -21,815 +21,8 @@
 #include "bt_target.h"
 #include "bt_utils.h"
 #include "gap_int.h"
-#include "btm_int.h"
-#include "gki.h"
-#include "btu.h"
-
-/*******************************************************************************
-**
-** Function         GAP_SetDiscoverableMode
-**
-** Description      This function is called to allow or disallow a service to
-**                  discovered (Inquiry Scans).
-**
-** Parameters:      mode        - GAP_NON_DISCOVERABLE, GAP_LIMITED_DISCOVERABLE,
-**                                  or GAP_GENERAL_DISCOVERABLE
-**
-**                  duration    - Amount of time for the duration of an inquiry scan.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**                                If a value of '0' is entered the default of
-**                                0x0012 (11.25 msecs) will be used.
-**                                Note: The duration must be less than or equal to
-**                                the interval.
-**
-**                  interval    - Amount of time between the start of two inquiry scans.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**                                If a value of '0' is entered the default of
-**                                0x800 (1.28 secs) will be used.
-**
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_PARM if a bad parameter is detected,
-**                  GAP_DEVICE_NOT_UP if the device is not active,
-**                  GAP_ERR_PROCESSING if not enough resources to carry out request
-**
-*******************************************************************************/
-UINT16 GAP_SetDiscoverableMode (UINT16 mode, UINT16 duration, UINT16 interval)
-{
-    tBTM_STATUS status;
-
-    status = BTM_SetDiscoverability(mode, duration, interval);
-
-    return (gap_convert_btm_status (status));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ReadDiscoverableMode
-**
-** Description      This function is called to retrieve the current discoverable mode
-**                  for the local device.
-**
-** Parameters:      duration    - pointer to the amount of time of an inquiry scan.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**                  interval    - pointer to the amount of time between the start of
-**                                two inquiry scans.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**
-** Returns          GAP_NON_DISCOVERABLE, GAP_LIMITED_DISCOVERABLE, or
-**                  GAP_GENERAL_DISCOVERABLE
-**
-*******************************************************************************/
-UINT16 GAP_ReadDiscoverableMode (UINT16 *duration, UINT16 *interval)
-{
-    return (BTM_ReadDiscoverability(duration, interval));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_SetConnectableMode
-**
-** Description      This function is called to allow or disallow a
-**                  connections on the local device.
-**
-** Parameters:      mode        - GAP_NON_CONNECTABLE, GAP_CONNECTABLE,
-**
-**                  duration    - Amount of time for the duration of a page scan.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**                                If a value of '0' is entered the default of
-**                                0x0012 (11.25 msecs) will be used.
-**                                Note: The duration must be less than or equal to
-**                                the interval.
-**
-**                  interval    - Amount of time between the start of two page scans.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**                                If a value of '0' is entered the default of
-**                                0x800 (1.28 secs) will be used.
-**
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_PARM if a bad parameter is detected,
-**                  GAP_DEVICE_NOT_UP if the device is not active,
-**                  GAP_ERR_PROCESSING if not enough resources to carry out request
-**
-*******************************************************************************/
-UINT16 GAP_SetConnectableMode (UINT16 mode, UINT16 duration, UINT16 interval)
-{
-    tBTM_STATUS status;
-
-    status = BTM_SetConnectability(mode, duration, interval);
-
-    return (gap_convert_btm_status (status));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_FindAddrByName
-**
-** Description      This function is called to retrieve a device address given
-**                  a device name.  It first looks in the current local inquiry
-**                  database for the device with the specified name.  If not found
-**                  it initiates a general inquiry.  Upon completion, it retrieves
-**                  the name for each device until a match is found or all devices
-**                  have been checked.  Note:  This process can take a while to
-**                  complete.
-**
-** Parameters:      devname -
-**
-**                  inqparms - pointer to the inquiry information
-**                      mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry
-**                      duration - length in 1.28 sec intervals
-**                      max_resps - maximum amount of devices to search for before ending the inquiry
-**                      filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or
-**                                         GAP_FILTER_COND_BD_ADDR
-**                      filter_cond - value for the filter (based on filter_cond_type)
-**
-**
-** Returns          BT_PASS if the name was immediately available.  (BD_ADDR is returned)
-**                  GAP_CMD_INITIATED if an inquiry has been initiated
-**
-*******************************************************************************/
-UINT16 GAP_FindAddrByName (BD_NAME devname, tGAP_INQ_PARMS *p_inq_parms, tGAP_CALLBACK *p_addr_cb,
-                           BD_ADDR bd_addr)
-{
-    UINT16           status;
-    tBTM_STATUS      btm_status;
-
-
-    /* If the remote name is retrieved automatically during an inquiry search the local db first */
-    if ((status = gap_find_local_addr_by_name (devname, bd_addr)) != BT_PASS)
-    {
-        /* If this code is used, the name wasn't in the current inquiry database */
-        /* A general inquiry must now be initiated */
-        if (gap_cb.findaddr_cb.in_use == FALSE)
-        {
-            gap_cb.findaddr_cb.p_cback = p_addr_cb;
-            gap_cb.findaddr_cb.p_cur_inq = (tBTM_INQ_INFO *) NULL;     /* Reset to the beginning of the database */
-            BCM_STRNCPY_S ((char *)gap_cb.findaddr_cb.results.devname, sizeof(gap_cb.findaddr_cb.results.devname), (char *)devname, BTM_MAX_REM_BD_NAME_LEN);
-
-            /* make sure we have an end of string char */
-            gap_cb.findaddr_cb.results.devname[BTM_MAX_REM_BD_NAME_LEN] = 0;
-
-            btm_status = BTM_StartInquiry (p_inq_parms, (tBTM_INQ_RESULTS_CB *) NULL,
-                    (tBTM_CMPL_CB *) gap_find_addr_inq_cb);
-                gap_cb.findaddr_cb.in_use = TRUE;
-
-            /* convert the error code into a GAP code and check the results for any errors */
-            if ((status = gap_convert_btm_status (btm_status)) == GAP_CMD_INITIATED)
-                gap_cb.findaddr_cb.in_use = TRUE;
-        }
-        else
-            status = GAP_ERR_BUSY;
-    }
-
-    return (status);
-}
 
-
-/*******************************************************************************
-**
-** Function         GAP_ReadConnectableMode
-**
-** Description      This function is called to retrieve the current connectability
-**                  mode for the local device.
-**
-** Parameters:      duration    - pointer to the amount of time of an page scan.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**                  interval    - pointer to the amount of time between the start of
-**                                two page scans.
-**                                The step size is in 0.625 msec intervals.
-**                                Range: 0x0012 - 0x1000 (11.25 - 2560 msecs)
-**
-**
-** Returns          GAP_NON_CONNECTABLE, GAP_CONNECTABLE
-**
-*******************************************************************************/
-
-UINT16 GAP_ReadConnectableMode (UINT16 *duration, UINT16 *interval)
-{
-    return (BTM_ReadConnectability(duration, interval));
-}
-
-/*******************************************************************************
-**
-** Function         GAP_Bond
-**
-** Description      This function is called to perform bonding with peer device
-**
-** Parameters:      bd_addr      - Address of the device to bond
-**                  pin_len      - length in bytes of the PIN Code
-**                  p_pin        - pointer to array with the PIN Code
-**                  trusted_mask - bitwise OR of trusted services (array of UINT32)
-**
-*******************************************************************************/
-UINT8 GAP_Bond (BD_ADDR bd_addr, UINT8 pin_len, UINT8 *p_pin, UINT32 trusted_mask[])
-{
-    return ((UINT8) BTM_SecBond (bd_addr, pin_len, p_pin, trusted_mask));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_SecRegister
-**
-** Description      Application manager calls this function to register for
-**                  security services.  There can be one and only one application
-**                  saving link keys.  BTM allows only first registration.
-**
-** Returns          TRUE if registered OK, else FALSE
-**
-*******************************************************************************/
-BOOLEAN  GAP_SecRegister (tBTM_APPL_INFO *p_cb_info)
-{
-    return (BTM_SecRegister (p_cb_info));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_PinRsp
-**
-** Description      This function is called from UI after Security Manager submitted
-**                  PIN code request.
-**
-** Parameters:      bd_addr      - Address of the device for which PIN was requested
-**                  res          - result of the operation BTM_SUCCESS if success
-**                  pin_len      - length in bytes of the PIN Code
-**                  p_pin        - pointer to array with the PIN Code
-**                  trusted_mask - bitwise OR of trusted services (array of UINT32)
-**
-*******************************************************************************/
-void GAP_PinRsp (BD_ADDR bd_addr, UINT8 res, UINT8 pin_len, UINT8 *p_pin, UINT32 trusted_mask[])
-{
-    BTM_PINCodeReply (bd_addr, res, pin_len, p_pin, trusted_mask);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_AuthorizeRsp
-**
-** Description      This function is called from UI after Security Manager submitted
-**                  authorization request
-**
-** Parameters:      bd_addr      - Address of the device for which PIN was requested
-**                  res          - result of the operation BTM_SUCCESS if success
-**                  trusted_mask - bitwise OR of trusted services (array of UINT32)
-**
-*******************************************************************************/
-void GAP_AuthorizeRsp (BD_ADDR bd_addr, UINT8 res, UINT32 trusted_mask[])
-{
-    BTM_DeviceAuthorized (bd_addr, res, trusted_mask);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_SetPairableMode
-**
-** Description      This function is called to allow or disallow pairing
-**                  on the local device.
-**
-** Parameters:      mode        - GAP_ALLOW_PAIRING, GAP_DISALLOW_PAIRING
-**                  connect_only_pairable - TRUE or FALSE connect only to paired devices
-**
-**                  callback    - The callback is called when a pin number is requested.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**
-*******************************************************************************/
-
-UINT16 GAP_SetPairableMode (UINT16 mode, BOOLEAN connect_only_paired)
-{
-    tBTM_STATUS btm_status;
-    UINT16      status = BT_PASS;
-
-    if (mode == GAP_ALLOW_PAIRING)
-    {
-        btm_status = BTM_SetConnectability(BTM_CONNECTABLE, 0, 0);
-
-        if ((status = gap_convert_btm_status (btm_status)) == BT_PASS)
-            BTM_SetPairableMode (TRUE, connect_only_paired);
-    }
-    else if (mode == GAP_DISALLOW_PAIRING)
-    {
-        BTM_SetPairableMode (FALSE, connect_only_paired);
-    }
-    else
-    {
-        GAP_TRACE_ERROR ("GAP_SetPairableMode: illegal mode %d", mode);
-        status = GAP_ERR_ILL_MODE;
-    }
-    return (status);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_StartInquiry
-**
-** Description      This function initiates a single inquiry.
-**
-** Parameters:      p_inqparms - pointer to the inquiry information
-**                      mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry
-**                      duration - length in 1.28 sec intervals
-**                      max_resps - maximum amount of devices to search for before ending the inquiry
-**                      filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or
-**                                         GAP_FILTER_COND_BD_ADDR
-**                      filter_cond - value for the filter (based on filter_cond_type)
-**
-**                  p_results_cb - Pointer to the callback routine which gets called
-**                                 upon receipt of an inquiry result. If this field is
-**                                 NULL, the application is not notified.
-**
-**                  p_cmpl_cb   - Pointer to the callback routine which gets called
-**                                upon completion.  If this field is NULL, the
-**                                application is not notified when completed.
-**
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_MODE if a bad mode parameter was passed
-**                  GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks
-**                  GAP_ERR_ILL_PARM if a bad parameter was detected in BTM
-**                  GAP_ERR_BUSY if the device already has an iquiry active
-**                  GAP_DEVICE_NOT_UP if the device is not initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error was returned
-**
-*******************************************************************************/
-UINT16 GAP_StartInquiry (tGAP_INQ_PARMS *p_inq_parms, tGAP_CALLBACK *p_results_cb, tGAP_CALLBACK *p_cmpl_cb)
-{
-    tGAP_INFO   *p_cb;
-    tBTM_STATUS  btm_status;
-    UINT16       retval;
-
-    /*** Make sure the parameters are valid before continuing ***/
-    if (p_inq_parms->mode != GAP_GENERAL_INQUIRY && p_inq_parms->mode != GAP_LIMITED_INQUIRY)
-        return (GAP_ERR_ILL_MODE);
-
-    if (p_inq_parms->duration < GAP_MIN_INQUIRY_LEN   ||
-        p_inq_parms->duration > GAP_MAX_INQUIRY_LENGTH)
-        return (GAP_ERR_ILL_INQ_TIME);
-
-    /*** get a control block for this operation ***/
-    if ((p_cb = gap_allocate_cb()) != NULL)
-    {
-        p_cb->gap_cback = p_cmpl_cb;
-        p_cb->gap_inq_rslt_cback = p_results_cb;
-        p_cb->event = GAP_EVT_INQUIRY_COMPLETE; /* Return event expected */
-
-        btm_status = BTM_StartInquiry(p_inq_parms, gap_inq_results_cb,
-                        (tBTM_CMPL_CB *) gap_cb.btm_cback[p_cb->index]);
-
-        /* convert the error code into a GAP code and check the results for any errors */
-        if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED)
-            gap_free_cb(p_cb);      /* Error starting the inquiry */
-    }
-    else
-        retval = GAP_ERR_NO_CTRL_BLK;
-
-    return (retval);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_StartPeriodicInquiry
-**
-** Description      This function initiates a periodic inquiry.
-**
-** Parameters:      p_inqparms - pointer to the inquiry information
-**                      mode - GAP_GENERAL_INQUIRY or GAP_LIMITED_INQUIRY inquiry
-**                      duration - length in 1.28 sec intervals
-**                      max_resps - maximum amount of devices to search for before ending the inquiry
-**                      filter_cond_type - GAP_CLR_INQUIRY_FILTER, GAP_FILTER_COND_DEVICE_CLASS, or
-**                                         GAP_FILTER_COND_BD_ADDR
-**                      filter_cond - value for the filter (based on filter_cond_type)
-**
-**                  min_time    - Minimum amount of time between consecutive inquiries.
-**                                The value is in 1.28 second intervals.
-**                                Range: 0x0002 - 0xFFFE (2.56 - 83883.52 seconds)
-**
-**                  max_time    - Maximum amount of time between consecutive inquiries.
-**                                The value is in 1.28 sec intervals.
-**                                Range: 0x0003 - 0xFFFF (3.84 - 83884.8 seconds)
-**
-**                  p_results_cb - Pointer to the callback routine which gets called
-**                                 upon receipt of an inquiry result. If this field is
-**                                 NULL, the application is not notified.
-**
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_MODE if a bad mode parameter was passed
-**                  GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks
-**                  GAP_ERR_ILL_PARM if a bad parameter was detected in BTM
-**                  GAP_ERR_BUSY if the device already has an iquiry active
-**                  GAP_DEVICE_NOT_UP if the device is not initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error was returned
-**
-*******************************************************************************/
-
-UINT16 GAP_StartPeriodicInquiry (tGAP_INQ_PARMS *p_inq_parms, UINT16 min_time,
-                                 UINT16 max_time, tGAP_CALLBACK *p_results_cb)
-{
-    tGAP_INFO   *p_cb;
-    tBTM_STATUS  btm_status;
-    UINT16       retval = BT_PASS;
-
-    /*** Make sure the parameters are valid before continuing ***/
-    if (p_inq_parms->mode != GAP_GENERAL_INQUIRY && p_inq_parms->mode != GAP_LIMITED_INQUIRY)
-        return (GAP_ERR_ILL_MODE);
-
-    if (p_inq_parms->duration < GAP_MIN_INQUIRY_LEN     ||
-        p_inq_parms->duration > GAP_MAX_INQUIRY_LENGTH  ||
-        min_time <= p_inq_parms->duration               ||
-        min_time < GAP_PER_INQ_MIN_MIN_PERIOD           ||
-        min_time > GAP_PER_INQ_MAX_MIN_PERIOD           ||
-        max_time <= min_time                            ||
-        max_time < GAP_PER_INQ_MIN_MAX_PERIOD)
-    {
-        return (GAP_ERR_ILL_INQ_TIME);
-    }
-
-    /*** get a control block for this operation ***/
-    if ((p_cb = gap_allocate_cb()) != NULL)
-    {
-        p_cb->gap_inq_rslt_cback = p_results_cb;
-        p_cb->event = GAP_EVT_INQUIRY_COMPLETE; /* mark the inquiry event active */
-
-        btm_status = BTM_SetPeriodicInquiryMode(p_inq_parms, max_time, min_time,
-                                                gap_inq_results_cb);
-
-        /* convert the error code into a GAP code and check the results for any errors */
-        if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED)
-            gap_free_cb(p_cb);      /* Error starting the inquiry */
-    }
-    else
-        retval = GAP_ERR_NO_CTRL_BLK;
-
-    return (retval);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_CancelInquiry
-**
-** Description      This function cancels a single inquiry (if in progress)
-**
-** Parameters:      None
-**
-** Returns          BOOLEAN (TRUE if successful, otherwise FALSE)
-**
-*******************************************************************************/
-UINT16 GAP_CancelInquiry(void)
-{
-    tGAP_INFO   *p_cb = &gap_cb.blk[0];
-    UINT8        x;
-    tBTM_STATUS  btm_status;
-    UINT16       status;
-
-    btm_status = BTM_CancelInquiry();
-    if ((status = gap_convert_btm_status (btm_status)) == BT_PASS)
-    {
-        /* Free the control block that is waiting for the inquiry complete event */
-        for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++)
-        {
-            if (p_cb->in_use && p_cb->event == GAP_EVT_INQUIRY_COMPLETE)
-            {
-                gap_free_cb(p_cb);
-                return (BT_PASS);
-            }
-        }
-
-        /* If here the control block was not found */
-        status = GAP_ERR_NO_CTRL_BLK;
-    }
-
-    return (status);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_CancelPeriodicInquiry
-**
-** Description      This function cancels a periodic inquiry (if in progress)
-**
-** Parameters:      None
-**
-** Returns          BOOLEAN: (TRUE if successful, otherwise FALSE)
-**
-*******************************************************************************/
-UINT16 GAP_CancelPeriodicInquiry(void)
-{
-    tGAP_INFO   *p_cb = &gap_cb.blk[0];
-    UINT8        x;
-    tBTM_STATUS  btm_status;
-    UINT16       status;
-
-    btm_status = BTM_CancelPeriodicInquiry();
-    if ((status = gap_convert_btm_status (btm_status)) == BT_PASS)
-    {
-        /* Free the control block that is waiting for the inquiry complete event */
-        for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++)
-        {
-            if (p_cb->in_use && p_cb->event == GAP_EVT_INQUIRY_COMPLETE)
-            {
-                gap_free_cb(p_cb);
-                return (BT_PASS);
-            }
-        }
-
-        /* If here the control block was not found */
-        status = GAP_ERR_NO_CTRL_BLK;
-    }
-
-    return (status);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_GetFirstInquiryResult
-**
-** Description      This function retrieves the first valid inquiry result.
-**
-** Parameters:      p_results - pointer to the inquiry results
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**                  GAP_EOINQDB if no more entries in the database.
-**
-*******************************************************************************/
-UINT16 GAP_GetFirstInquiryResult(tGAP_INQ_RESULTS *p_results)
-{
-    UINT8 *ptr;
-
-    gap_cb.cur_inqptr = BTM_InqFirstResult();
-
-    if (gap_cb.cur_inqptr != NULL)
-    {
-        memcpy(p_results, &gap_cb.cur_inqptr->results, sizeof(tBTM_INQ_RESULTS));
-
-        ptr = (UINT8 *)gap_cb.cur_inqptr->results.remote_bd_addr;
-        GAP_TRACE_EVENT("GAP_GetFirstInqResult %02x%02x%02x%02x%02x%02x",
-                    ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5]);
-        return(BT_PASS);
-    }
-    else
-    {
-        GAP_TRACE_EVENT("GAP_FirstInqResults:  No BD_ADDRs Found");
-        memset(p_results, 0, sizeof(tBTM_INQ_RESULTS));
-        return(GAP_EOINQDB);
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_GetNextInquiryResult
-**
-** Description      This function retrieves the next valid inquiry result.
-**
-** Parameters:      p_results  - pointer to the inquiry results
-**
-** Returns          BT_PASS (0) if successful, or a non-zero status code
-**                  GAP_EOINQDB if no more entries in the database.
-**
-*******************************************************************************/
-UINT16 GAP_GetNextInquiryResult(tGAP_INQ_RESULTS *p_results)
-{
-    UINT8 *ptr;
-
-    /*** if the current inquiry db pointer is NULL then call the first entry ***/
-    if (gap_cb.cur_inqptr)
-    {
-        gap_cb.cur_inqptr = BTM_InqNextResult(gap_cb.cur_inqptr);
-        if (gap_cb.cur_inqptr != NULL)
-        {
-            memcpy(p_results, &gap_cb.cur_inqptr->results,
-                   sizeof(tGAP_INQ_RESULTS));
-
-            ptr = (UINT8 *)gap_cb.cur_inqptr->results.remote_bd_addr;
-            GAP_TRACE_EVENT("GAP_GetNextInqResult %02x%02x%02x%02x%02x%02x",
-                        ptr[0],ptr[1],ptr[2],ptr[3],ptr[4],ptr[5]);
-
-            return(BT_PASS);
-        }
-        else
-        {
-            GAP_TRACE_EVENT("GAP_NextInqResults:  No BD_ADDRs Found");
-            memset(p_results, 0, sizeof(tBTM_INQ_RESULTS));
-            return(GAP_EOINQDB);
-        }
-    }
-    else
-        return (GAP_GetFirstInquiryResult(p_results));
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ReadLocalDeviceInfo
-**
-** Description      This function retrieves local device information to the caller.
-**
-** Parameters:      name        - (output) pointer to the UTF-8 encoded string representing
-**                                the device name.
-**
-**                  addr        - (output) pointer to the Bluetooth device address (BD_ADDR).
-**
-**                  verinfo     - (output) pointer to the LMP version information.
-**
-**                  features    - (output) pointer to the LMP features for the device.
-**
-**                  NOTE:  Return parameters that are set to NULL are not retrieved.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**
-*******************************************************************************/
-
-UINT16 GAP_ReadLocalDeviceInfo(UINT8 *name, BD_ADDR *addr, tGAP_LMP_VERSION *verinfo,
-                               tGAP_LMP_FEATURES *features)
-{
-    UNUSED(name);
-    UNUSED(addr);
-    UNUSED(verinfo);
-    UNUSED(features);
-    return (GAP_UNSUPPORTED);
-}
-
-
-
-/*******************************************************************************
-**
-** Function         GAP_GetRemoteDeviceName
-**
-** Description      The remote name is retrieved from the specified remote device.  If
-**                  GAP_CMD_INITIATED is returned by the function, the command was
-**                  successfully sent to the controller.  The GAP_EVT_NAME_RESP event
-**                  is passed in the callback when the remote device name has been retrieved.
-**
-** Parameters:      addr        - The Bluetooth device address (BD_ADDR) of the remote
-**                                device.
-**
-**                  callback    - pointer to the callback which is called after the
-**                                remote device has been retrieved.
-**                                p_data in the callback points to the structure containing the
-**                                status, device name length, and the UTF-8 encoded
-**                                device name. (type tBTM_REMOTE_DEV_NAME)
-**                                The event field in the callback is set to GAP_EVT_REM_NAME_COMPLETE.
-**  The callback is not called unless (GAP_CMD_INITIATED) is returned.
-**
-**
-** Returns
-**                  GAP_CMD_INITIATED if remote search successfully initiated
-**                  GAP_ERR_BUSY if a remote name request is already in progress,
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks (too many commands pending)
-**                  GAP_BAD_BD_ADDR if the device address is bad,
-**                  GAP_DEVICE_NOT_UP if the device has not been initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error has been returned
-**
-*******************************************************************************/
-UINT16 GAP_GetRemoteDeviceName (BD_ADDR addr, tGAP_CALLBACK *callback)
-{
-    tGAP_INFO   *p_cb;
-    UINT16       retval;
-    tBTM_STATUS  btm_status;
-
-    if ((p_cb = gap_allocate_cb()) != NULL)
-    {
-        p_cb->gap_cback = callback;
-        p_cb->event = GAP_EVT_REM_NAME_COMPLETE;     /* Return event expected */
-
-        btm_status = BTM_ReadRemoteDeviceName (addr, gap_cb.btm_cback[p_cb->index], BT_TRANSPORT_BR_EDR);
-
-        /* If the name was not returned immediately, or if an error occurred, release the control block */
-        if ((retval = gap_convert_btm_status (btm_status)) != GAP_CMD_INITIATED)
-            gap_free_cb (p_cb);
-    }
-    else
-        retval = GAP_ERR_NO_CTRL_BLK;
-
-    return (retval);
-}
-
-/*******************************************************************************
-**
-** Function         GAP_SetDeviceClass
-**
-** Description      This function updates the local Device Class.
-**
-** Parameters:
-**                  p_cod   - Pointer to the device class to set to
-**
-**                  cmd     - the fields of the device class to update.
-**                            GAP_SET_COD_MAJOR_MINOR, - overwrite major, minor class
-**                            GAP_SET_COD_SERVICE_CLASS - set the bits in the input
-**                            GAP_CLR_COD_SERVICE_CLASS - clear the bits in the input
-**                            GAP_SET_COD_ALL - overwrite major, minor, set the bits in service class
-**                            GAP_INIT_COD - overwrite major, minor, and service class
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_BUSY if a discovery is already in progress
-**                  GAP_ERR_ILL_PARM if an illegal parameter was detected
-**                  GAP_ERR_PROCESSING if any other BTM error has been returned
-**
-*******************************************************************************/
-UINT16 GAP_SetDeviceClass(tGAP_COD *p_cod, UINT8 cmd)
-{
-    tBTM_STATUS btm_status;
-    UINT8 *dev;
-    UINT16 service;
-    UINT8  minor, major;
-    DEV_CLASS dev_class;
-
-    dev = BTM_ReadDeviceClass();
-    BTM_COD_SERVICE_CLASS( service, dev );
-    BTM_COD_MINOR_CLASS(minor, dev );
-    BTM_COD_MAJOR_CLASS(major, dev );
-
-    switch(cmd)
-    {
-    case GAP_SET_COD_MAJOR_MINOR:
-        minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK;
-        major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK;
-        break;
-
-    case GAP_SET_COD_SERVICE_CLASS:
-        /* clear out the bits that is not SERVICE_CLASS bits */
-        p_cod->service &= BTM_COD_SERVICE_CLASS_MASK;
-        service = service | p_cod->service;
-        break;
-
-    case GAP_CLR_COD_SERVICE_CLASS:
-        p_cod->service &= BTM_COD_SERVICE_CLASS_MASK;
-        service = service & (~p_cod->service);
-        break;
-
-    case GAP_SET_COD_ALL:
-        minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK;
-        major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK;
-        p_cod->service &= BTM_COD_SERVICE_CLASS_MASK;
-        service = service | p_cod->service;
-        break;
-
-    case GAP_INIT_COD:
-        minor = p_cod->minor & BTM_COD_MINOR_CLASS_MASK;
-        major = p_cod->major & BTM_COD_MAJOR_CLASS_MASK;
-        service = p_cod->service & BTM_COD_SERVICE_CLASS_MASK;
-        break;
-
-    default:
-        return GAP_ERR_ILL_PARM;
-    }
-
-    /* convert the fields into the device class type */
-    FIELDS_TO_COD(dev_class, minor, major, service);
-
-    btm_status = BTM_SetDeviceClass(dev_class);
-    return (gap_convert_btm_status (btm_status));
-}
-
-/*******************************************************************************
-**
-** Function         GAP_ReadDeviceClass
-**
-** Description      This function reads the local Device Class.
-**
-** Parameters:
-**
-** Returns          PASS
-**
-*******************************************************************************/
-UINT16   GAP_ReadDeviceClass(tGAP_COD *p_cod)
-{
-    UINT8 *dev;
-
-    dev = BTM_ReadDeviceClass();
-
-    BTM_COD_SERVICE_CLASS( p_cod->service, dev );
-    BTM_COD_MINOR_CLASS( p_cod->minor, dev );
-    BTM_COD_MAJOR_CLASS( p_cod->major, dev );
-
-    return (BT_PASS);
-}
+tGAP_CB  gap_cb;
 
 /*******************************************************************************
 **
@@ -865,26 +58,12 @@ void GAP_Init(void)
 {
     memset (&gap_cb, 0, sizeof (tGAP_CB));
 
-    /*** Initialize the callbacks for BTM; Needs to be one per GAP_MAX_BLOCKS ***/
-    gap_cb.btm_cback[0] = gap_btm_cback0;
-#if GAP_MAX_BLOCKS > 1
-    gap_cb.btm_cback[1] = gap_btm_cback1;
-#endif
-#if GAP_MAX_BLOCKS > 2
-    gap_cb.btm_cback[2] = gap_btm_cback2;
-#endif
-
 #if defined(GAP_INITIAL_TRACE_LEVEL)
     gap_cb.trace_level = GAP_INITIAL_TRACE_LEVEL;
 #else
     gap_cb.trace_level = BT_TRACE_LEVEL_NONE;    /* No traces */
 #endif
 
-    /* Initialize the connection control block if included in build */
-#if GAP_CONN_INCLUDED == TRUE
-    gap_conn_init();
-#endif  /* GAP_CONN_INCLUDED */
-
 #if BLE_INCLUDED == TRUE
     gap_attr_db_init();
 #endif
diff --git a/stack/gap/gap_conn.c b/stack/gap/gap_conn.c
deleted file mode 100644
index d546d7778..000000000
--- a/stack/gap/gap_conn.c
+++ /dev/null
@@ -1,1278 +0,0 @@
-/******************************************************************************
- *
- *  Copyright (C) 2009-2013 Broadcom Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at:
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- ******************************************************************************/
-
-
-#include "bt_target.h"
-#include "bt_utils.h"
-#include "btu.h"
-#include "fixed_queue.h"
-#include "gap_int.h"
-#include "l2cdefs.h"
-#include "l2c_int.h"
-#include <string.h>
-#if GAP_CONN_INCLUDED == TRUE
-#include "btm_int.h"
-
-extern fixed_queue_t *btu_hci_msg_queue;
-/********************************************************************************/
-/*              L O C A L    F U N C T I O N     P R O T O T Y P E S            */
-/********************************************************************************/
-static void gap_connect_ind (BD_ADDR  bd_addr, UINT16 l2cap_cid, UINT16 psm, UINT8 l2cap_id);
-static void gap_connect_cfm (UINT16 l2cap_cid, UINT16 result);
-static void gap_config_ind (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
-static void gap_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg);
-static void gap_disconnect_ind (UINT16 l2cap_cid, BOOLEAN ack_needed);
-static void gap_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg);
-static void gap_congestion_ind (UINT16 lcid, BOOLEAN is_congested);
-
-static tGAP_CCB *gap_find_ccb_by_cid (UINT16 cid);
-static tGAP_CCB *gap_find_ccb_by_handle (UINT16 handle);
-static tGAP_CCB *gap_allocate_ccb (void);
-static void      gap_release_ccb (tGAP_CCB *p_ccb);
-
-/*******************************************************************************
-**
-** Function         gap_conn_init
-**
-** Description      This function is called to initialize GAP connection management
-**
-** Returns          void
-**
-*******************************************************************************/
-void gap_conn_init (void)
-{
-#if AMP_INCLUDED == TRUE
-    gap_cb.conn.reg_info.pAMP_ConnectInd_Cb         = gap_connect_ind;
-    gap_cb.conn.reg_info.pAMP_ConnectCfm_Cb         = gap_connect_cfm;
-    gap_cb.conn.reg_info.pAMP_ConnectPnd_Cb         = NULL;
-    gap_cb.conn.reg_info.pAMP_ConfigInd_Cb          = gap_config_ind;
-    gap_cb.conn.reg_info.pAMP_ConfigCfm_Cb          = gap_config_cfm;
-    gap_cb.conn.reg_info.pAMP_DisconnectInd_Cb      = gap_disconnect_ind;
-    gap_cb.conn.reg_info.pAMP_DisconnectCfm_Cb      = NULL;
-    gap_cb.conn.reg_info.pAMP_QoSViolationInd_Cb    = NULL;
-    gap_cb.conn.reg_info.pAMP_DataInd_Cb            = gap_data_ind;
-    gap_cb.conn.reg_info.pAMP_CongestionStatus_Cb   = gap_congestion_ind;
-    gap_cb.conn.reg_info.pAMP_TxComplete_Cb         = NULL;
-    gap_cb.conn.reg_info.pAMP_MoveInd_Cb            = NULL;
-    gap_cb.conn.reg_info.pAMP_MoveRsp_Cb            = NULL;
-    gap_cb.conn.reg_info.pAMP_MoveCfm_Cb            = NULL; //gap_move_cfm
-    gap_cb.conn.reg_info.pAMP_MoveCfmRsp_Cb         = NULL; //gap_move_cfm_rsp
-
-#else
-    gap_cb.conn.reg_info.pL2CA_ConnectInd_Cb       = gap_connect_ind;
-    gap_cb.conn.reg_info.pL2CA_ConnectCfm_Cb       = gap_connect_cfm;
-    gap_cb.conn.reg_info.pL2CA_ConnectPnd_Cb       = NULL;
-    gap_cb.conn.reg_info.pL2CA_ConfigInd_Cb        = gap_config_ind;
-    gap_cb.conn.reg_info.pL2CA_ConfigCfm_Cb        = gap_config_cfm;
-    gap_cb.conn.reg_info.pL2CA_DisconnectInd_Cb    = gap_disconnect_ind;
-    gap_cb.conn.reg_info.pL2CA_DisconnectCfm_Cb    = NULL;
-    gap_cb.conn.reg_info.pL2CA_QoSViolationInd_Cb  = NULL;
-    gap_cb.conn.reg_info.pL2CA_DataInd_Cb          = gap_data_ind;
-    gap_cb.conn.reg_info.pL2CA_CongestionStatus_Cb = gap_congestion_ind;
-    gap_cb.conn.reg_info.pL2CA_TxComplete_Cb       = NULL;
-#endif
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnOpen
-**
-** Description      This function is called to open an L2CAP connection.
-**
-** Parameters:      is_server   - If TRUE, the connection is not created
-**                                but put into a "listen" mode waiting for
-**                                the remote side to connect.
-**
-**                  service_id  - Unique service ID from
-**                                BTM_SEC_SERVICE_FIRST_EMPTY (6)
-**                                to BTM_SEC_MAX_SERVICE_RECORDS (32)
-**
-**                  p_rem_bda   - Pointer to remote BD Address.
-**                                If a server, and we don't care about the
-**                                remote BD Address, then NULL should be passed.
-**
-**                  psm         - the PSM used for the connection
-**
-**                  p_config    - Optional pointer to configuration structure.
-**                                If NULL, the default GAP configuration will
-**                                be used.
-**
-**                  security    - security flags
-**                  chan_mode_mask - (GAP_FCR_CHAN_OPT_BASIC, GAP_FCR_CHAN_OPT_ERTM, GAP_FCR_CHAN_OPT_STREAM)
-**
-**                  p_cb        - Pointer to callback function for events.
-**
-** Returns          handle of the connection if successful, else GAP_INVALID_HANDLE
-**
-*******************************************************************************/
-UINT16 GAP_ConnOpen (char *p_serv_name, UINT8 service_id, BOOLEAN is_server,
-                     BD_ADDR p_rem_bda, UINT16 psm, tL2CAP_CFG_INFO *p_cfg,
-                     UINT16 security, UINT8 chan_mode_mask, tGAP_CONN_CALLBACK *p_cb)
-{
-    tGAP_CCB    *p_ccb;
-    UINT16       cid;
-    tBT_UUID    bt_uuid = {2, {GAP_PROTOCOL_ID}};
-
-    GAP_TRACE_EVENT ("GAP_CONN - Open Request");
-
-    /* Allocate a new CCB. Return if none available. */
-    if ((p_ccb = gap_allocate_ccb()) == NULL)
-        return (GAP_INVALID_HANDLE);
-
-    /* If caller specified a BD address, save it */
-    if (p_rem_bda)
-    {
-        /* the bd addr is not BT_BD_ANY, then a bd address was specified */
-        if (memcmp (p_rem_bda, BT_BD_ANY, BD_ADDR_LEN))
-            p_ccb->rem_addr_specified = TRUE;
-
-        memcpy (&p_ccb->rem_dev_address[0], p_rem_bda, BD_ADDR_LEN);
-    }
-    else if (!is_server)
-    {
-        /* remore addr is not specified and is not a server -> bad */
-        return (GAP_INVALID_HANDLE);
-    }
-
-    /* A client MUST have specified a bd addr to connect with */
-    if (!p_ccb->rem_addr_specified && !is_server)
-    {
-        gap_release_ccb (p_ccb);
-        GAP_TRACE_ERROR ("GAP ERROR: Client must specify a remote BD ADDR to connect to!");
-        return (GAP_INVALID_HANDLE);
-    }
-
-    /* Check if configuration was specified */
-    if (p_cfg)
-        p_ccb->cfg = *p_cfg;
-
-    p_ccb->p_callback     = p_cb;
-
-    /* If originator, use a dynamic PSM */
-#if AMP_INCLUDED == TRUE
-    if (!is_server)
-        gap_cb.conn.reg_info.pAMP_ConnectInd_Cb  = NULL;
-    else
-        gap_cb.conn.reg_info.pAMP_ConnectInd_Cb  = gap_connect_ind;
-#else
-    if (!is_server)
-        gap_cb.conn.reg_info.pL2CA_ConnectInd_Cb = NULL;
-    else
-        gap_cb.conn.reg_info.pL2CA_ConnectInd_Cb = gap_connect_ind;
-#endif
-
-    /* Register the PSM with L2CAP */
-    if ((p_ccb->psm = L2CA_REGISTER (psm, &gap_cb.conn.reg_info, AMP_AUTOSWITCH_ALLOWED|AMP_USE_AMP_IF_POSSIBLE)) == 0)
-    {
-        GAP_TRACE_ERROR ("GAP_ConnOpen: Failure registering PSM 0x%04x", psm);
-        gap_release_ccb (p_ccb);
-        return (GAP_INVALID_HANDLE);
-    }
-
-    /* Register with Security Manager for the specific security level */
-    p_ccb->service_id = service_id;
-    if (!BTM_SetSecurityLevel ((UINT8)!is_server, p_serv_name, p_ccb->service_id, security, p_ccb->psm, 0, 0))
-    {
-        GAP_TRACE_ERROR ("GAP_CONN - Security Error");
-        gap_release_ccb (p_ccb);
-        return (GAP_INVALID_HANDLE);
-    }
-
-    /* Fill in eL2CAP parameter data */
-    if( p_ccb->cfg.fcr_present )
-    {
-        p_ccb->ertm_info.preferred_mode = p_ccb->cfg.fcr.mode;
-        p_ccb->ertm_info.user_rx_pool_id = GAP_DATA_POOL_ID;
-        p_ccb->ertm_info.user_tx_pool_id = GAP_DATA_POOL_ID;
-        p_ccb->ertm_info.fcr_rx_pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
-        p_ccb->ertm_info.fcr_tx_pool_id = L2CAP_DEFAULT_ERM_POOL_ID;
-    }
-
-    /* optional FCR channel modes */
-    p_ccb->ertm_info.allowed_modes = (chan_mode_mask) ? chan_mode_mask : (UINT8)L2CAP_FCR_CHAN_OPT_BASIC;
-
-    if (is_server)
-    {
-        p_ccb->con_flags |= GAP_CCB_FLAGS_SEC_DONE; /* assume btm/l2cap would handle it */
-        p_ccb->con_state = GAP_CCB_STATE_LISTENING;
-        return (p_ccb->gap_handle);
-    }
-    else
-    {
-        /* We are the originator of this connection */
-        p_ccb->con_flags = GAP_CCB_FLAGS_IS_ORIG;
-
-        /* Transition to the next appropriate state, waiting for connection confirm. */
-        p_ccb->con_state = GAP_CCB_STATE_CONN_SETUP;
-
-        /* mark security done flag, when security is not required */
-        if ((security & (BTM_SEC_OUT_AUTHORIZE | BTM_SEC_OUT_AUTHENTICATE | BTM_SEC_OUT_ENCRYPT) ) == 0)
-            p_ccb->con_flags |= GAP_CCB_FLAGS_SEC_DONE;
-
-        /* Check if L2CAP started the connection process */
-        if (p_rem_bda && ((cid = L2CA_CONNECT_REQ (p_ccb->psm, p_rem_bda, &p_ccb->ertm_info, &bt_uuid)) != 0))
-        {
-            p_ccb->connection_id = cid;
-            return (p_ccb->gap_handle);
-        }
-        else
-        {
-            gap_release_ccb (p_ccb);
-            return (GAP_INVALID_HANDLE);
-        }
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnClose
-**
-** Description      This function is called to close a connection.
-**
-** Parameters:      handle      - Handle of the connection returned by GAP_ConnOpen
-**
-** Returns          BT_PASS             - closed OK
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**
-*******************************************************************************/
-UINT16 GAP_ConnClose (UINT16 gap_handle)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-
-    GAP_TRACE_EVENT ("GAP_CONN - close  handle: 0x%x", gap_handle);
-
-    if (p_ccb)
-    {
-        /* Check if we have a connection ID */
-        if (p_ccb->con_state != GAP_CCB_STATE_LISTENING)
-            L2CA_DISCONNECT_REQ (p_ccb->connection_id);
-
-        gap_release_ccb (p_ccb);
-
-        return (BT_PASS);
-    }
-
-    return (GAP_ERR_BAD_HANDLE);
-}
-
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnReadData
-**
-** Description      Normally not GKI aware application will call this function
-**                  after receiving GAP_EVT_RXDATA event.
-**
-** Parameters:      handle      - Handle of the connection returned in the Open
-**                  p_data      - Data area
-**                  max_len     - Byte count requested
-**                  p_len       - Byte count received
-**
-** Returns          BT_PASS             - data read
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**                  GAP_NO_DATA_AVAIL   - no data available
-**
-*******************************************************************************/
-UINT16 GAP_ConnReadData (UINT16 gap_handle, UINT8 *p_data, UINT16 max_len, UINT16 *p_len)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-    BT_HDR     *p_buf;
-    UINT16      copy_len;
-
-    if (!p_ccb)
-        return (GAP_ERR_BAD_HANDLE);
-
-    *p_len = 0;
-
-    p_buf = (BT_HDR *)GKI_getfirst (&p_ccb->rx_queue);
-    if (!p_buf)
-        return (GAP_NO_DATA_AVAIL);
-
-    GKI_disable();
-
-    while (max_len && p_buf)
-    {
-        copy_len = (p_buf->len > max_len)?max_len:p_buf->len;
-        max_len -= copy_len;
-        *p_len  += copy_len;
-        if (p_data)
-        {
-            memcpy (p_data, (UINT8 *)(p_buf + 1) + p_buf->offset, copy_len);
-            p_data += copy_len;
-        }
-
-        if (p_buf->len > copy_len)
-        {
-            p_buf->offset += copy_len;
-            p_buf->len    -= copy_len;
-            break;
-        }
-        else
-        {
-            if (max_len)
-            {
-                p_buf = (BT_HDR *)GKI_getnext (p_buf);
-            }
-            GKI_freebuf (GKI_dequeue (&p_ccb->rx_queue));
-        }
-    }
-
-    p_ccb->rx_queue_size -= *p_len;
-
-    GKI_enable();
-
-    GAP_TRACE_EVENT ("GAP_ConnReadData - rx_queue_size left=%d, *p_len=%d",
-                                       p_ccb->rx_queue_size, *p_len);
-
-    return (BT_PASS);
-}
-
-/*******************************************************************************
-**
-** Function         GAP_GetRxQueueCnt
-**
-** Description      This function return number of bytes on the rx queue.
-**
-** Parameters:      handle     - Handle returned in the GAP_ConnOpen
-**                  p_rx_queue_count - Pointer to return queue count in.
-**
-**
-*******************************************************************************/
-int GAP_GetRxQueueCnt (UINT16 handle, UINT32 *p_rx_queue_count)
-{
-    tGAP_CCB    *p_ccb;
-    int         rc = BT_PASS;
-
-    /* Check that handle is valid */
-    if (handle < GAP_MAX_CONNECTIONS)
-    {
-        p_ccb = &gap_cb.conn.ccb_pool[handle];
-
-        if (p_ccb->con_state == GAP_CCB_STATE_CONNECTED)
-        {
-            *p_rx_queue_count = p_ccb->rx_queue_size;
-        }
-        else
-            rc = GAP_INVALID_HANDLE;
-    }
-    else
-        rc = GAP_INVALID_HANDLE;
-
-    GAP_TRACE_EVENT ("GAP_GetRxQueueCnt - rc = 0x%04x, rx_queue_count=%d",
-                                       rc , *p_rx_queue_count);
-
-    return (rc);
-}
-
-/*******************************************************************************
-**
-** Function         GAP_ConnBTRead
-**
-** Description      Bluetooth aware applications will call this function after receiving
-**                  GAP_EVT_RXDATA event.
-**
-** Parameters:      handle      - Handle of the connection returned in the Open
-**                  pp_buf      - pointer to address of buffer with data,
-**
-** Returns          BT_PASS             - data read
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**                  GAP_NO_DATA_AVAIL   - no data available
-**
-*******************************************************************************/
-UINT16 GAP_ConnBTRead (UINT16 gap_handle, BT_HDR **pp_buf)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-    BT_HDR      *p_buf;
-
-    if (!p_ccb)
-        return (GAP_ERR_BAD_HANDLE);
-
-    p_buf = (BT_HDR *)GKI_dequeue (&p_ccb->rx_queue);
-
-    if (p_buf)
-    {
-        *pp_buf = p_buf;
-
-        p_ccb->rx_queue_size -= p_buf->len;
-        return (BT_PASS);
-    }
-    else
-    {
-        *pp_buf = NULL;
-        return (GAP_NO_DATA_AVAIL);
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnBTWrite
-**
-** Description      Bluetooth Aware applications can call this function to write data.
-**
-** Parameters:      handle      - Handle of the connection returned in the Open
-**                  p_buf      - pointer to address of buffer with data,
-**
-** Returns          BT_PASS                 - data read
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**                  GAP_ERR_BAD_STATE       - connection not established
-**                  GAP_INVALID_BUF_OFFSET  - buffer offset is invalid
-*******************************************************************************/
-UINT16 GAP_ConnBTWrite (UINT16 gap_handle, BT_HDR *p_buf)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-
-    if (!p_ccb)
-    {
-        GKI_freebuf (p_buf);
-        return (GAP_ERR_BAD_HANDLE);
-    }
-
-    if (p_ccb->con_state != GAP_CCB_STATE_CONNECTED)
-    {
-        GKI_freebuf (p_buf);
-        return (GAP_ERR_BAD_STATE);
-    }
-
-    if (p_buf->offset < L2CAP_MIN_OFFSET)
-    {
-        GKI_freebuf (p_buf);
-        return (GAP_ERR_BUF_OFFSET);
-    }
-
-    GKI_enqueue (&p_ccb->tx_queue, p_buf);
-
-    if (p_ccb->is_congested)
-    {
-        return (BT_PASS);
-    }
-
-    /* Send the buffer through L2CAP */
-#if (GAP_CONN_POST_EVT_INCLUDED == TRUE)
-    gap_send_event (gap_handle);
-#else
-    while ((p_buf = (BT_HDR *)GKI_dequeue (&p_ccb->tx_queue)) != NULL)
-    {
-        UINT8 status = L2CA_DATA_WRITE (p_ccb->connection_id, p_buf);
-
-        if (status == L2CAP_DW_CONGESTED)
-        {
-            p_ccb->is_congested = TRUE;
-            break;
-        }
-        else if (status != L2CAP_DW_SUCCESS)
-            return (GAP_ERR_BAD_STATE);
-    }
-#endif
-    return (BT_PASS);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnWriteData
-**
-** Description      Normally not GKI aware application will call this function
-**                  to send data to the connection.
-**
-** Parameters:      handle      - Handle of the connection returned in the Open
-**                  p_data      - Data area
-**                  max_len     - Byte count requested
-**                  p_len       - Byte count received
-**
-** Returns          BT_PASS                 - data read
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**                  GAP_ERR_BAD_STATE       - connection not established
-**                  GAP_CONGESTION          - system is congested
-**
-*******************************************************************************/
-UINT16 GAP_ConnWriteData (UINT16 gap_handle, UINT8 *p_data, UINT16 max_len, UINT16 *p_len)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-    BT_HDR     *p_buf;
-
-    *p_len = 0;
-
-    if (!p_ccb)
-        return (GAP_ERR_BAD_HANDLE);
-
-    if (p_ccb->con_state != GAP_CCB_STATE_CONNECTED)
-        return (GAP_ERR_BAD_STATE);
-
-    while (max_len)
-    {
-        if (p_ccb->cfg.fcr.mode == L2CAP_FCR_ERTM_MODE)
-        {
-            if ((p_buf = (BT_HDR *)GKI_getpoolbuf (p_ccb->ertm_info.user_tx_pool_id)) == NULL)
-                return (GAP_ERR_CONGESTED);
-        }
-        else
-        {
-            if ((p_buf = (BT_HDR *)GKI_getpoolbuf (GAP_DATA_POOL_ID)) == NULL)
-                return (GAP_ERR_CONGESTED);
-        }
-
-        p_buf->offset = L2CAP_MIN_OFFSET;
-        p_buf->len = (p_ccb->rem_mtu_size < max_len) ? p_ccb->rem_mtu_size : max_len;
-        p_buf->event = BT_EVT_TO_BTU_SP_DATA;
-
-        memcpy ((UINT8 *)(p_buf + 1) + p_buf->offset, p_data, p_buf->len);
-
-        *p_len  += p_buf->len;
-        max_len -= p_buf->len;
-        p_data  += p_buf->len;
-
-        GAP_TRACE_EVENT ("GAP_WriteData %d bytes", p_buf->len);
-
-        GKI_enqueue (&p_ccb->tx_queue, p_buf);
-    }
-
-    if (p_ccb->is_congested)
-    {
-        return (BT_PASS);
-    }
-
-    /* Send the buffer through L2CAP */
-#if (GAP_CONN_POST_EVT_INCLUDED == TRUE)
-    gap_send_event (gap_handle);
-#else
-    while ((p_buf = (BT_HDR *)GKI_dequeue (&p_ccb->tx_queue)) != NULL)
-    {
-        UINT8 status = L2CA_DATA_WRITE (p_ccb->connection_id, p_buf);
-
-        if (status == L2CAP_DW_CONGESTED)
-        {
-            p_ccb->is_congested = TRUE;
-            break;
-        }
-        else if (status != L2CAP_DW_SUCCESS)
-            return (GAP_ERR_BAD_STATE);
-    }
-#endif
-    return (BT_PASS);
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnReconfig
-**
-** Description      Applications can call this function to reconfigure the connection.
-**
-** Parameters:      handle      - Handle of the connection
-**                  p_cfg       - Pointer to new configuration
-**
-** Returns          BT_PASS                 - config process started
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**
-*******************************************************************************/
-UINT16 GAP_ConnReconfig (UINT16 gap_handle, tL2CAP_CFG_INFO *p_cfg)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-
-    if (!p_ccb)
-        return (GAP_ERR_BAD_HANDLE);
-
-    p_ccb->cfg = *p_cfg;
-
-    if (p_ccb->con_state == GAP_CCB_STATE_CONNECTED)
-        L2CA_CONFIG_REQ (p_ccb->connection_id, p_cfg);
-
-    return (BT_PASS);
-}
-
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnSetIdleTimeout
-**
-** Description      Higher layers call this function to set the idle timeout for
-**                  a connection, or for all future connections. The "idle timeout"
-**                  is the amount of time that a connection can remain up with
-**                  no L2CAP channels on it. A timeout of zero means that the
-**                  connection will be torn down immediately when the last channel
-**                  is removed. A timeout of 0xFFFF means no timeout. Values are
-**                  in seconds.
-**
-** Parameters:      handle      - Handle of the connection
-**                  timeout     - in secs
-**                                0 = immediate disconnect when last channel is removed
-**                                0xFFFF = no idle timeout
-**
-** Returns          BT_PASS                 - config process started
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**
-*******************************************************************************/
-UINT16 GAP_ConnSetIdleTimeout (UINT16 gap_handle, UINT16 timeout)
-{
-    tGAP_CCB    *p_ccb;
-
-    if ((p_ccb = gap_find_ccb_by_handle (gap_handle)) == NULL)
-        return (GAP_ERR_BAD_HANDLE);
-
-    if (L2CA_SetIdleTimeout (p_ccb->connection_id, timeout, FALSE))
-        return (BT_PASS);
-    else
-        return (GAP_ERR_BAD_HANDLE);
-}
-
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetRemoteAddr
-**
-** Description      This function is called to get the remote BD address
-**                  of a connection.
-**
-** Parameters:      handle      - Handle of the connection returned by GAP_ConnOpen
-**
-** Returns          BT_PASS             - closed OK
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**
-*******************************************************************************/
-UINT8 *GAP_ConnGetRemoteAddr (UINT16 gap_handle)
-{
-    tGAP_CCB    *p_ccb = gap_find_ccb_by_handle (gap_handle);
-
-    GAP_TRACE_EVENT ("GAP_ConnGetRemoteAddr gap_handle = %d", gap_handle);
-
-    if ((p_ccb) && (p_ccb->con_state > GAP_CCB_STATE_LISTENING))
-    {
-        GAP_TRACE_EVENT("GAP_ConnGetRemoteAddr bda :0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x\n", \
-                         p_ccb->rem_dev_address[0],p_ccb->rem_dev_address[1],p_ccb->rem_dev_address[2],
-                         p_ccb->rem_dev_address[3],p_ccb->rem_dev_address[4],p_ccb->rem_dev_address[5]);
-        return (p_ccb->rem_dev_address);
-    }
-    else
-    {
-        GAP_TRACE_EVENT ("GAP_ConnGetRemoteAddr return Error ");
-        return (NULL);
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetRemMtuSize
-**
-** Description      Returns the remote device's MTU size
-**
-** Parameters:      handle      - Handle of the connection
-**
-** Returns          UINT16      - maximum size buffer that can be transmitted to the peer
-**
-*******************************************************************************/
-UINT16 GAP_ConnGetRemMtuSize (UINT16 gap_handle)
-{
-    tGAP_CCB    *p_ccb;
-
-    if ((p_ccb = gap_find_ccb_by_handle (gap_handle)) == NULL)
-        return (0);
-
-    return (p_ccb->rem_mtu_size);
-}
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetL2CAPCid
-**
-** Description      Returns the L2CAP channel id
-**
-** Parameters:      handle      - Handle of the connection
-**
-** Returns          UINT16      - The L2CAP channel id
-**                  0, if error
-**
-*******************************************************************************/
-UINT16 GAP_ConnGetL2CAPCid (UINT16 gap_handle)
-{
-    tGAP_CCB    *p_ccb;
-
-    if ((p_ccb = gap_find_ccb_by_handle (gap_handle)) == NULL)
-        return (0);
-
-    return (p_ccb->connection_id);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_connect_ind
-**
-** Description      This function handles an inbound connection indication
-**                  from L2CAP. This is the case where we are acting as a
-**                  server.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_connect_ind (BD_ADDR  bd_addr, UINT16 l2cap_cid, UINT16 psm, UINT8 l2cap_id)
-{
-    UINT16       xx;
-    tGAP_CCB     *p_ccb;
-    tBT_UUID    bt_uuid = {2, {GAP_PROTOCOL_ID}};
-
-    /* See if we have a CCB listening for the connection */
-    for (xx = 0, p_ccb = gap_cb.conn.ccb_pool; xx < GAP_MAX_CONNECTIONS; xx++, p_ccb++)
-    {
-        if ((p_ccb->con_state == GAP_CCB_STATE_LISTENING)
-         && (p_ccb->psm == psm)
-         && ((p_ccb->rem_addr_specified == FALSE)
-           || (!memcmp (bd_addr, p_ccb->rem_dev_address, BD_ADDR_LEN))))
-            break;
-    }
-
-    if (xx == GAP_MAX_CONNECTIONS)
-    {
-        GAP_TRACE_WARNING("*******");
-        GAP_TRACE_WARNING("WARNING: GAP Conn Indication for Unexpected Bd Addr...Disconnecting");
-        GAP_TRACE_WARNING("*******");
-
-        /* Disconnect because it is an unexpected connection */
-        L2CA_DISCONNECT_REQ (l2cap_cid);
-        return;
-    }
-
-    /* Transition to the next appropriate state, waiting for config setup. */
-    p_ccb->con_state = GAP_CCB_STATE_CFG_SETUP;
-
-    /* Save the BD Address and Channel ID. */
-    memcpy (&p_ccb->rem_dev_address[0], bd_addr, BD_ADDR_LEN);
-    p_ccb->connection_id = l2cap_cid;
-
-    /* Send response to the L2CAP layer. */
-    L2CA_CONNECT_RSP (bd_addr, l2cap_id, l2cap_cid, L2CAP_CONN_OK, L2CAP_CONN_OK, &p_ccb->ertm_info, &bt_uuid);
-
-    GAP_TRACE_EVENT("GAP_CONN - Rcvd L2CAP conn ind, CID: 0x%x", p_ccb->connection_id);
-
-    /* Send a Configuration Request. */
-    L2CA_CONFIG_REQ (l2cap_cid, &p_ccb->cfg);
-}
-
-/*******************************************************************************
-**
-** Function         gap_checks_con_flags
-**
-** Description      This function processes the L2CAP configuration indication
-**                  event.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_checks_con_flags (tGAP_CCB    *p_ccb)
-{
-    GAP_TRACE_EVENT ("gap_checks_con_flags conn_flags:0x%x, ", p_ccb->con_flags);
-    /* if all the required con_flags are set, report the OPEN event now */
-    if ((p_ccb->con_flags & GAP_CCB_FLAGS_CONN_DONE) == GAP_CCB_FLAGS_CONN_DONE)
-    {
-        p_ccb->con_state = GAP_CCB_STATE_CONNECTED;
-
-        p_ccb->p_callback (p_ccb->gap_handle, GAP_EVT_CONN_OPENED);
-    }
-}
-
-/*******************************************************************************
-**
-** Function         gap_sec_check_complete
-**
-** Description      The function called when Security Manager finishes
-**                  verification of the service side connection
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_sec_check_complete (BD_ADDR bd_addr, tBT_TRANSPORT transport, void *p_ref_data, UINT8 res)
-{
-    tGAP_CCB *p_ccb = (tGAP_CCB *)p_ref_data;
-    UNUSED(bd_addr);
-    UNUSED (transport);
-
-    GAP_TRACE_EVENT ("gap_sec_check_complete conn_state:%d, conn_flags:0x%x, status:%d",
-        p_ccb->con_state, p_ccb->con_flags, res);
-    if (p_ccb->con_state == GAP_CCB_STATE_IDLE)
-        return;
-
-    if (res == BTM_SUCCESS)
-    {
-        p_ccb->con_flags |= GAP_CCB_FLAGS_SEC_DONE;
-        gap_checks_con_flags (p_ccb);
-    }
-    else
-    {
-        /* security failed - disconnect the channel */
-        L2CA_DISCONNECT_REQ (p_ccb->connection_id);
-    }
-}
-
-/*******************************************************************************
-**
-** Function         gap_connect_cfm
-**
-** Description      This function handles the connect confirm events
-**                  from L2CAP. This is the case when we are acting as a
-**                  client and have sent a connect request.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_connect_cfm (UINT16 l2cap_cid, UINT16 result)
-{
-    tGAP_CCB    *p_ccb;
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (l2cap_cid)) == NULL)
-        return;
-
-    /* initiate security process, if needed */
-    if ( (p_ccb->con_flags & GAP_CCB_FLAGS_SEC_DONE) == 0)
-    {
-        btm_sec_mx_access_request (p_ccb->rem_dev_address, p_ccb->psm, TRUE,
-                                   0, 0, &gap_sec_check_complete, p_ccb);
-    }
-
-    /* If the connection response contains success status, then */
-    /* Transition to the next state and startup the timer.      */
-    if ((result == L2CAP_CONN_OK) && (p_ccb->con_state == GAP_CCB_STATE_CONN_SETUP))
-    {
-        p_ccb->con_state = GAP_CCB_STATE_CFG_SETUP;
-
-        /* Send a Configuration Request. */
-        L2CA_CONFIG_REQ (l2cap_cid, &p_ccb->cfg);
-    }
-    else
-    {
-        /* Tell the user if he has a callback */
-        if (p_ccb->p_callback)
-            (*p_ccb->p_callback) (p_ccb->gap_handle, GAP_EVT_CONN_CLOSED);
-
-        gap_release_ccb (p_ccb);
-    }
-}
-
-/*******************************************************************************
-**
-** Function         gap_config_ind
-**
-** Description      This function processes the L2CAP configuration indication
-**                  event.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_config_ind (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
-{
-    tGAP_CCB    *p_ccb;
-    UINT16      local_mtu_size;
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (l2cap_cid)) == NULL)
-        return;
-
-    /* Remember the remote MTU size */
-
-    if (p_ccb->cfg.fcr.mode == L2CAP_FCR_ERTM_MODE)
-    {
-        local_mtu_size = GKI_get_pool_bufsize (p_ccb->ertm_info.user_tx_pool_id)
-                       - sizeof(BT_HDR) - L2CAP_MIN_OFFSET;
-    }
-    else
-        local_mtu_size = L2CAP_MTU_SIZE;
-
-    if ((!p_cfg->mtu_present)||(p_cfg->mtu > local_mtu_size))
-    {
-        p_ccb->rem_mtu_size = local_mtu_size;
-    }
-    else
-        p_ccb->rem_mtu_size = p_cfg->mtu;
-
-    /* For now, always accept configuration from the other side */
-    p_cfg->flush_to_present = FALSE;
-    p_cfg->mtu_present      = FALSE;
-    p_cfg->result           = L2CAP_CFG_OK;
-    p_cfg->fcs_present      = FALSE;
-
-    L2CA_CONFIG_RSP (l2cap_cid, p_cfg);
-
-    p_ccb->con_flags |= GAP_CCB_FLAGS_HIS_CFG_DONE;
-
-    gap_checks_con_flags (p_ccb);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_config_cfm
-**
-** Description      This function processes the L2CAP configuration confirmation
-**                  event.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_config_cfm (UINT16 l2cap_cid, tL2CAP_CFG_INFO *p_cfg)
-{
-    tGAP_CCB    *p_ccb;
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (l2cap_cid)) == NULL)
-        return;
-
-    if (p_cfg->result == L2CAP_CFG_OK)
-    {
-        p_ccb->con_flags |= GAP_CCB_FLAGS_MY_CFG_DONE;
-
-
-        if (p_ccb->cfg.fcr_present)
-            p_ccb->cfg.fcr.mode = p_cfg->fcr.mode;
-        else
-            p_ccb->cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
-
-        gap_checks_con_flags (p_ccb);
-    }
-    else
-    {
-        p_ccb->p_callback (p_ccb->gap_handle, GAP_EVT_CONN_CLOSED);
-        gap_release_ccb (p_ccb);
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_disconnect_ind
-**
-** Description      This function handles a disconnect event from L2CAP. If
-**                  requested to, we ack the disconnect before dropping the CCB
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_disconnect_ind (UINT16 l2cap_cid, BOOLEAN ack_needed)
-{
-    tGAP_CCB    *p_ccb;
-
-    GAP_TRACE_EVENT ("GAP_CONN - Rcvd L2CAP disc, CID: 0x%x", l2cap_cid);
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (l2cap_cid)) == NULL)
-        return;
-
-    if (ack_needed)
-        L2CA_DISCONNECT_RSP (l2cap_cid);
-
-    p_ccb->p_callback (p_ccb->gap_handle, GAP_EVT_CONN_CLOSED);
-    gap_release_ccb (p_ccb);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_data_ind
-**
-** Description      This function is called when data is received from L2CAP.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_data_ind (UINT16 l2cap_cid, BT_HDR *p_msg)
-{
-    tGAP_CCB    *p_ccb;
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (l2cap_cid)) == NULL)
-    {
-        GKI_freebuf (p_msg);
-        return;
-    }
-
-    if (p_ccb->con_state == GAP_CCB_STATE_CONNECTED)
-    {
-        GKI_enqueue (&p_ccb->rx_queue, p_msg);
-
-        p_ccb->rx_queue_size += p_msg->len;
-        /*
-        GAP_TRACE_EVENT ("gap_data_ind - rx_queue_size=%d, msg len=%d",
-                                       p_ccb->rx_queue_size, p_msg->len);
-         */
-
-        p_ccb->p_callback (p_ccb->gap_handle, GAP_EVT_CONN_DATA_AVAIL);
-    }
-    else
-    {
-        GKI_freebuf (p_msg);
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_congestion_ind
-**
-** Description      This is a callback function called by L2CAP when
-**                  data L2CAP congestion status changes
-**
-*******************************************************************************/
-static void gap_congestion_ind (UINT16 lcid, BOOLEAN is_congested)
-{
-    tGAP_CCB    *p_ccb;
-    UINT16       event;
-    BT_HDR      *p_buf;
-    UINT8        status;
-
-    GAP_TRACE_EVENT ("GAP_CONN - Rcvd L2CAP Is Congested (%d), CID: 0x%x",
-                      is_congested, lcid);
-
-    /* Find CCB based on CID */
-    if ((p_ccb = gap_find_ccb_by_cid (lcid)) == NULL)
-        return;
-
-    p_ccb->is_congested = is_congested;
-
-    event = (is_congested) ? GAP_EVT_CONN_CONGESTED : GAP_EVT_CONN_UNCONGESTED;
-    p_ccb->p_callback (p_ccb->gap_handle, event);
-
-    if (!is_congested)
-    {
-        while ((p_buf = (BT_HDR *)GKI_dequeue (&p_ccb->tx_queue)) != NULL)
-        {
-            status = L2CA_DATA_WRITE (p_ccb->connection_id, p_buf);
-
-            if (status == L2CAP_DW_CONGESTED)
-            {
-                p_ccb->is_congested = TRUE;
-                break;
-            }
-            else if (status != L2CAP_DW_SUCCESS)
-                break;
-        }
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_find_ccb_by_cid
-**
-** Description      This function searches the CCB table for an entry with the
-**                  passed CID.
-**
-** Returns          the CCB address, or NULL if not found.
-**
-*******************************************************************************/
-static tGAP_CCB *gap_find_ccb_by_cid (UINT16 cid)
-{
-    UINT16       xx;
-    tGAP_CCB     *p_ccb;
-
-    /* Look through each connection control block */
-    for (xx = 0, p_ccb = gap_cb.conn.ccb_pool; xx < GAP_MAX_CONNECTIONS; xx++, p_ccb++)
-    {
-        if ((p_ccb->con_state != GAP_CCB_STATE_IDLE) && (p_ccb->connection_id == cid))
-            return (p_ccb);
-    }
-
-    /* If here, not found */
-    return (NULL);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_find_ccb_by_handle
-**
-** Description      This function searches the CCB table for an entry with the
-**                  passed handle.
-**
-** Returns          the CCB address, or NULL if not found.
-**
-*******************************************************************************/
-static tGAP_CCB *gap_find_ccb_by_handle (UINT16 handle)
-{
-    tGAP_CCB     *p_ccb;
-
-    /* Check that handle is valid */
-    if (handle < GAP_MAX_CONNECTIONS)
-    {
-        p_ccb = &gap_cb.conn.ccb_pool[handle];
-
-        if (p_ccb->con_state != GAP_CCB_STATE_IDLE)
-            return (p_ccb);
-    }
-
-    /* If here, handle points to invalid connection */
-    return (NULL);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_allocate_ccb
-**
-** Description      This function allocates a new CCB.
-**
-** Returns          CCB address, or NULL if none available.
-**
-*******************************************************************************/
-static tGAP_CCB *gap_allocate_ccb (void)
-{
-    UINT16       xx;
-    tGAP_CCB     *p_ccb;
-
-    /* Look through each connection control block for a free one */
-    for (xx = 0, p_ccb = gap_cb.conn.ccb_pool; xx < GAP_MAX_CONNECTIONS; xx++, p_ccb++)
-    {
-        if (p_ccb->con_state == GAP_CCB_STATE_IDLE)
-        {
-            memset (p_ccb, 0, sizeof (tGAP_CCB));
-
-            p_ccb->gap_handle   = xx;
-            p_ccb->rem_mtu_size = L2CAP_MTU_SIZE;
-
-            return (p_ccb);
-        }
-    }
-
-    /* If here, no free CCB found */
-    return (NULL);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_release_ccb
-**
-** Description      This function releases a CCB.
-**
-** Returns          void
-**
-*******************************************************************************/
-static void gap_release_ccb (tGAP_CCB *p_ccb)
-{
-    UINT16       xx;
-    UINT16      psm = p_ccb->psm;
-    UINT8       service_id = p_ccb->service_id;
-
-    /* Drop any buffers we may be holding */
-    p_ccb->rx_queue_size = 0;
-
-    while (!GKI_queue_is_empty(&p_ccb->rx_queue))
-        GKI_freebuf (GKI_dequeue (&p_ccb->rx_queue));
-
-    while (!GKI_queue_is_empty(&p_ccb->tx_queue))
-        GKI_freebuf (GKI_dequeue (&p_ccb->tx_queue));
-
-    p_ccb->con_state = GAP_CCB_STATE_IDLE;
-
-    /* If no-one else is using the PSM, deregister from L2CAP */
-    for (xx = 0, p_ccb = gap_cb.conn.ccb_pool; xx < GAP_MAX_CONNECTIONS; xx++, p_ccb++)
-    {
-        if ((p_ccb->con_state != GAP_CCB_STATE_IDLE) && (p_ccb->psm == psm))
-            return;
-    }
-
-    /* Free the security record for this PSM */
-    BTM_SecClrService(service_id);
-    L2CA_DEREGISTER (psm);
-}
-
-#if (GAP_CONN_POST_EVT_INCLUDED == TRUE)
-
-/*******************************************************************************
-**
-** Function     gap_send_event
-**
-** Description  Send BT_EVT_TO_GAP_MSG event to BTU task
-**
-** Returns      None
-**
-*******************************************************************************/
-void gap_send_event (UINT16 gap_handle)
-{
-    BT_HDR  *p_msg;
-
-    if ((p_msg = (BT_HDR*)GKI_getbuf(BT_HDR_SIZE)) != NULL)
-    {
-        p_msg->event  = BT_EVT_TO_GAP_MSG;
-        p_msg->len    = 0;
-        p_msg->offset = 0;
-        p_msg->layer_specific = gap_handle;
-
-        fixed_queue_enqueue(btu_hci_msg_queue, p_msg);
-        // Signal the target thread work is ready.
-        GKI_send_event(BTU_TASK, (UINT16)EVENT_MASK(BTU_HCI_RCV_MBOX));
-
-    }
-    else
-    {
-        GAP_TRACE_ERROR("Unable to allocate message buffer for event.");
-    }
-}
-
-/*******************************************************************************
-**
-** Function     gap_proc_btu_event
-**
-** Description  Event handler for BT_EVT_TO_GAP_MSG event from BTU task
-**
-** Returns      None
-**
-*******************************************************************************/
-void gap_proc_btu_event(BT_HDR *p_msg)
-{
-    tGAP_CCB   *p_ccb = gap_find_ccb_by_handle (p_msg->layer_specific);
-    UINT8       status;
-    BT_HDR     *p_buf;
-
-    if (!p_ccb)
-    {
-        return;
-    }
-
-    if (p_ccb->con_state != GAP_CCB_STATE_CONNECTED)
-    {
-        return;
-    }
-
-    if (p_ccb->is_congested)
-    {
-        return;
-    }
-
-    /* Send the buffer through L2CAP */
-
-    while ((p_buf = (BT_HDR *)GKI_dequeue (&p_ccb->tx_queue)) != NULL)
-    {
-        status = L2CA_DATA_WRITE (p_ccb->connection_id, p_buf);
-
-        if (status == L2CAP_DW_CONGESTED)
-        {
-            p_ccb->is_congested = TRUE;
-            break;
-        }
-        else if (status != L2CAP_DW_SUCCESS)
-            break;
-    }
-
-}
-#endif /* (GAP_CONN_POST_EVT_INCLUDED == TRUE) */
-#endif  /* GAP_CONN_INCLUDED */
diff --git a/stack/gap/gap_int.h b/stack/gap/gap_int.h
index c12108271..40fe96a08 100644
--- a/stack/gap/gap_int.h
+++ b/stack/gap/gap_int.h
@@ -22,104 +22,11 @@
 
 #include "bt_target.h"
 #include "gap_api.h"
-#include "btm_api.h"
 #include "gki.h"
 #include "gatt_api.h"
-#if AMP_INCLUDED == TRUE
-    #include "amp_api.h"
-#endif
-
-#if defined BLE_INCLUDED && BLE_INCLUDED == TRUE
-    #include "gatt_api.h"
-#endif
-
-#define GAP_MAX_BLOCKS 2        /* Concurrent GAP commands pending at a time*/
-/* There must be a different btm callback for*/
-/* each control block.*/
-
-
-/* Definitions of limits for inquiries */
-#define GAP_PER_INQ_MIN_MAX_PERIOD      BTM_PER_INQ_MIN_MAX_PERIOD
-#define GAP_PER_INQ_MAX_MAX_PERIOD      BTM_PER_INQ_MAX_MAX_PERIOD
-#define GAP_PER_INQ_MIN_MIN_PERIOD      BTM_PER_INQ_MIN_MIN_PERIOD
-#define GAP_PER_INQ_MAX_MIN_PERIOD      BTM_PER_INQ_MAX_MIN_PERIOD
-#define GAP_MAX_INQUIRY_LENGTH          BTM_MAX_INQUIRY_LENGTH
-#define GAP_MIN_INQUIRY_LEN             BTM_MIN_INQUIRY_LEN
-
-/* Define the Generic Access Profile control structure */
-typedef struct
-{
-    void          *p_data;      /* Pointer to any data returned in callback */
-    tGAP_CALLBACK *gap_cback;   /* Pointer to users callback function */
-    tGAP_CALLBACK *gap_inq_rslt_cback; /* Used for inquiry results */
-    UINT16         event;       /* Passed back in the callback */
-    UINT8          index;       /* Index of this control block and callback */
-    BOOLEAN        in_use;      /* True when structure is allocated */
-} tGAP_INFO;
-
-/* Define the control block for the FindAddrByName operation (Only 1 active at a time) */
-typedef struct
-{
-    tGAP_CALLBACK           *p_cback;
-    tBTM_INQ_INFO           *p_cur_inq; /* Pointer to the current inquiry database entry */
-    tGAP_FINDADDR_RESULTS    results;
-    BOOLEAN                  in_use;
-} tGAP_FINDADDR_CB;
-
-
-/* Define the GAP Connection Control Block.
-*/
-typedef struct
-{
-#define GAP_CCB_STATE_IDLE              0
-#define GAP_CCB_STATE_LISTENING         1
-#define GAP_CCB_STATE_CONN_SETUP        2
-#define GAP_CCB_STATE_CFG_SETUP         3
-#define GAP_CCB_STATE_WAIT_SEC          4
-#define GAP_CCB_STATE_CONNECTED         5
-    UINT8             con_state;
-
-#define GAP_CCB_FLAGS_IS_ORIG           0x01
-#define GAP_CCB_FLAGS_HIS_CFG_DONE      0x02
-#define GAP_CCB_FLAGS_MY_CFG_DONE       0x04
-#define GAP_CCB_FLAGS_SEC_DONE          0x08
-#define GAP_CCB_FLAGS_CONN_DONE         0x0E
-    UINT8             con_flags;
-
-    UINT8             service_id;           /* Used by BTM                          */
-    UINT16            gap_handle;           /* GAP handle                           */
-    UINT16            connection_id;        /* L2CAP CID                            */
-    BOOLEAN           rem_addr_specified;
-    UINT8             chan_mode_mask;       /* Supported channel modes (FCR)        */
-    BD_ADDR           rem_dev_address;
-    UINT16            psm;
-    UINT16            rem_mtu_size;
-
-    BOOLEAN           is_congested;
-    BUFFER_Q          tx_queue;             /* Queue of buffers waiting to be sent  */
-    BUFFER_Q          rx_queue;             /* Queue of buffers waiting to be read  */
-
-    UINT32            rx_queue_size;        /* Total data count in rx_queue         */
-
-    tGAP_CONN_CALLBACK *p_callback;         /* Users callback function              */
-
-    tL2CAP_CFG_INFO   cfg;                  /* Configuration                        */
-    tL2CAP_ERTM_INFO  ertm_info;            /* Pools and modes for ertm */
-} tGAP_CCB;
-
-typedef struct
-{
-#if AMP_INCLUDED == TRUE
-    tAMP_APPL_INFO    reg_info;
-#else
-    tL2CAP_APPL_INFO  reg_info;                     /* L2CAP Registration info */
-#endif
-    tGAP_CCB    ccb_pool[GAP_MAX_CONNECTIONS];
-} tGAP_CONN;
-
 
 #if BLE_INCLUDED == TRUE
-    #define GAP_MAX_CHAR_NUM          5
+#define GAP_MAX_CHAR_NUM          5
 
 typedef struct
 {
@@ -161,15 +68,7 @@ typedef struct
 
 typedef struct
 {
-    tGAP_INFO        blk[GAP_MAX_BLOCKS];
-    tBTM_CMPL_CB    *btm_cback[GAP_MAX_BLOCKS];
     UINT8            trace_level;
-    tGAP_FINDADDR_CB findaddr_cb;   /* Contains the control block for finding a device addr */
-    tBTM_INQ_INFO   *cur_inqptr;
-
-#if GAP_CONN_INCLUDED == TRUE
-    tGAP_CONN        conn;
-#endif
 
     /* LE GAP attribute database */
 #if BLE_INCLUDED == TRUE
@@ -182,50 +81,10 @@ typedef struct
 } tGAP_CB;
 
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if GAP_DYNAMIC_MEMORY == FALSE
-    extern tGAP_CB  gap_cb;
-#else
-    extern tGAP_CB *gap_cb_ptr;
-#define gap_cb (*gap_cb_ptr)
-#endif
-
-    extern tGAP_INFO        *gap_allocate_cb(void);
-    extern void              gap_free_cb(tGAP_INFO *p_cb);
-
-    /* GAP inquiry functions */
-    extern void              gap_inq_results_cb(tGAP_INQ_RESULTS *p_results, UINT8 *p_eir);
-    extern UINT16            gap_find_local_addr_by_name (const BD_NAME devname, BD_ADDR bd_addr);
-    extern void              gap_find_addr_inq_cb (tBTM_INQUIRY_CMPL *p);
-
-    extern BOOLEAN           gap_is_service_busy (UINT16 request);
-    extern UINT16            gap_convert_btm_status (tBTM_STATUS btm_status);
-
-    extern void gap_btm_cback0(void *p1);
-#if GAP_MAX_BLOCKS > 1
-    extern void gap_btm_cback1(void *p1);
-#endif
-#if GAP_MAX_BLOCKS > 2
-    extern void gap_btm_cback2(void *p1);
-#endif
-
-#if (GAP_CONN_INCLUDED == TRUE)
-    extern void gap_conn_init(void);
-#if (GAP_CONN_POST_EVT_INCLUDED == TRUE)
-    void gap_send_event (UINT16 gap_handle);
-    void gap_proc_btu_event(BT_HDR *p_msg);
-#endif
-#endif
+extern tGAP_CB  gap_cb;
 
 #if (BLE_INCLUDED == TRUE)
     extern void gap_attr_db_init(void);
 #endif
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif
diff --git a/stack/gap/gap_utils.c b/stack/gap/gap_utils.c
deleted file mode 100644
index 5082a7f02..000000000
--- a/stack/gap/gap_utils.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/******************************************************************************
- *
- *  Copyright (C) 2009-2013 Broadcom Corporation
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at:
- *
- *  http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- ******************************************************************************/
-
-#include <string.h>
-#include "bt_target.h"
-#include "bt_utils.h"
-#include "gap_int.h"
-
-/*****************************************************************************/
-/*                 G L O B A L      GAP       D A T A                        */
-/*****************************************************************************/
-#if GAP_DYNAMIC_MEMORY == FALSE
-tGAP_CB  gap_cb;
-#endif
-
-/*****************************************************************************
-** Callbacks passed to BTM -
-**      There are different callbacks based on the control block index so that
-**      more than one command can be pending at a time.
-**  NOTE:  There must be 1 callback for each control block defined
-**          GAP_MAX_BLOCKS
-**
-**          Also, the inquiry results event has its own callback; Not handled here!
-******************************************************************************/
-static void btm_cback(UINT16 index, void *p_data)
-{
-    tGAP_INFO       *p_cb;
-    tGAP_INQ_CMPL    inq_cmpl;
-
-    /* Make sure that the index is valid AND it is in use */
-    if (index < GAP_MAX_BLOCKS && gap_cb.blk[index].in_use)
-    {
-        p_cb = &gap_cb.blk[index];
-
-        /* If the callback is non-NULL, call it with the specified event */
-        switch (p_cb->event)
-        {
-        case GAP_EVT_INQUIRY_COMPLETE:
-            /* pass the number of results to caller */
-            inq_cmpl.num_results = ((tBTM_INQUIRY_CMPL *)p_data)->num_resp;
-
-            inq_cmpl.status = (((tBTM_INQUIRY_CMPL *)p_data)->status == BTM_SUCCESS) ? BT_PASS : GAP_ERR_PROCESSING;
-
-            p_data = &inq_cmpl;
-
-            GAP_TRACE_EVENT("   GAP Inquiry Complete Event (Status 0x%04x, Result(s) %d)",
-                            inq_cmpl.status, inq_cmpl.num_results);
-            break;
-
-        case GAP_EVT_DISCOVERY_COMPLETE:
-            if (*((UINT16 *) p_data))
-            {
-                GAP_TRACE_EVENT("   GAP Discovery Complete Event(SDP Result: 0x%04x)", *((UINT16 *) p_data));
-            }
-            else
-            {
-                GAP_TRACE_EVENT("   GAP Discovery Successfully Completed");
-            }
-
-            break;
-
-        case GAP_EVT_REM_NAME_COMPLETE:
-            /* override the BTM error code with a GAP error code */
-            ((tGAP_REMOTE_DEV_NAME *)p_data)->status =
-                    gap_convert_btm_status ((tBTM_STATUS)((tBTM_REMOTE_DEV_NAME *)p_data)->status);
-
-            GAP_TRACE_EVENT("   GAP Remote Name Complete Event (status 0x%04x)", ((tGAP_REMOTE_DEV_NAME *)p_data)->status);
-
-            break;
-        };
-
-        if (p_cb->gap_cback)
-            p_cb->gap_cback(p_cb->event, p_data);
-
-        /* Deallocate the control block */
-        gap_free_cb(p_cb);
-    }
-}
-
-
-/*** Callback functions for BTM_CMPL_CB ***/
-void gap_btm_cback0(void *p1)
-{
-    btm_cback(0, p1);
-}
-
-#if GAP_MAX_BLOCKS > 1
-void gap_btm_cback1(void *p1)
-{
-    btm_cback(1, p1);
-}
-#endif
-#if GAP_MAX_BLOCKS > 2
-void gap_btm_cback2(void *p1)
-{
-    btm_cback(2, p1);
-}
-#endif
-
-/* There is only one instance of this because only 1 inquiry can be active at a time */
-void gap_inq_results_cb(tBTM_INQ_RESULTS *p_results, UINT8 *p_eir)
-{
-    tGAP_INFO   *p_cb;
-    UINT8        index;
-    UNUSED(p_eir);
-
-    GAP_TRACE_EVENT ("GAP Inquiry Results Callback (bdaddr [%02x%02x%02x%02x%02x%02x])",
-                p_results->remote_bd_addr[0], p_results->remote_bd_addr[1],
-                p_results->remote_bd_addr[2], p_results->remote_bd_addr[3],
-                p_results->remote_bd_addr[4], p_results->remote_bd_addr[5]);
-    GAP_TRACE_EVENT ("                             (COD [%02x%02x%02x], clkoff 0x%04x)",
-                p_results->dev_class[0], p_results->dev_class[1], p_results->dev_class[2],
-                p_results->clock_offset);
-
-    /* Find the control block which has an Inquiry Active and call its results callback */
-    for (index = 0, p_cb = &gap_cb.blk[0]; index < GAP_MAX_BLOCKS; index++, p_cb++)
-    {
-        /* Look for the control block that is using inquiry */
-        if (p_cb->in_use && (p_cb->event == GAP_EVT_INQUIRY_COMPLETE))
-        {
-            /* Notify the higher layer if they care */
-            if (p_cb->gap_inq_rslt_cback)
-                p_cb->gap_inq_rslt_cback (GAP_EVT_INQUIRY_RESULTS, (tGAP_INQ_RESULTS *)p_results);
-        }
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_find_addr_name_cb
-**
-** Description      Processes the remote name request event when the Find Addr by Name
-**                  request is active.  The following procedure takes place:
-**                  1. Check the resulting name (If return status is ok)
-**                  2. If name matches requested name, we're done, call the appl's callback
-**                          with the BD ADDR.
-**                  3. Otherwise get the next BD ADDR out of the inquiry database and intiate
-**                          another remote name request.
-**                  4. If there are no more BD ADDRs, then call the appl's callback with a FAIL
-**                          status.
-**
-** Returns          void
-**
-*******************************************************************************/
-void gap_find_addr_name_cb (tBTM_REMOTE_DEV_NAME *p)
-{
-    tGAP_FINDADDR_CB        *p_cb = &gap_cb.findaddr_cb;
-    tGAP_FINDADDR_RESULTS   *p_result = &p_cb->results;
-
-    if (p_cb->in_use)
-    {
-        if (p->status == BTM_SUCCESS)
-        {
-            GAP_TRACE_EVENT("   GAP: FindAddrByName Rem Name Cmpl Evt (Status 0x%04x, Name [%s])",
-                                p->status, p->remote_bd_name);
-
-            /* See if the returned name matches the desired name; if not initiate another search */
-            if (!strncmp ((char *)p_result->devname, (char *) p->remote_bd_name, strlen ((char *) p_result->devname)))
-            {
-                /* We found the device!  Copy it into the return structure */
-                memcpy (p_result->bd_addr, p_cb->p_cur_inq->results.remote_bd_addr, BD_ADDR_LEN);
-                p_result->status = BT_PASS;
-            }
-            else    /* The name doesn't match so initiate another search */
-            {
-                /* Get the device address of the next database entry */
-                if ((p_cb->p_cur_inq = BTM_InqDbNext(p_cb->p_cur_inq)) != NULL)
-                {
-                    if ((BTM_ReadRemoteDeviceName (p_cb->p_cur_inq->results.remote_bd_addr,
-                        (tBTM_CMPL_CB *) gap_find_addr_name_cb, BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)
-                        return;     /* This routine will get called again with the next results */
-                    else
-                        p_result->status = gap_convert_btm_status ((tBTM_STATUS) p->status);
-                }
-                else
-                    p_result->status = GAP_EOINQDB;     /* No inquiry results; we're done! */
-            }
-        }
-        else
-        {
-            GAP_TRACE_EVENT("   GAP: FindAddrByName Rem Name Cmpl Evt (Status 0x%04x)", p->status);
-            p_result->status = gap_convert_btm_status ((tBTM_STATUS) p->status);
-        }
-
-        /* If this code is reached, the process has completed so call the appl's callback with results */
-        if (p_cb->p_cback)
-            p_cb->p_cback (GAP_EVT_FIND_ADDR_COMPLETE, (tGAP_FINDADDR_RESULTS *) p_result);
-
-        /* Clear out the control block */
-        p_cb->in_use = FALSE;
-        p_cb->p_cback = (tGAP_CALLBACK *) NULL;
-    }
-}
-
-/*******************************************************************************
-**
-** Function         gap_find_addr_inq_cb
-**
-** Description      Processes the inquiry complete event when the Find Addr by Name
-**                  request is active.  This callback performs one of the two following
-**                  steps:
-**                      1. If the remote name is retrieved automatically, the DB is searched
-**                          immediately, and the results are returned in the appls callback.
-**
-**                      2. If remote name is not automatic, retrieve the first BTM INQ
-**                         database entry and initiate a remote name request.
-**
-** Returns          void
-**
-*******************************************************************************/
-void gap_find_addr_inq_cb (tBTM_INQUIRY_CMPL *p)
-{
-    tGAP_FINDADDR_CB        *p_cb = &gap_cb.findaddr_cb;
-    tGAP_FINDADDR_RESULTS   *p_result = &p_cb->results;
-
-    if (p_cb->in_use)
-    {
-
-        GAP_TRACE_EVENT("   GAP: FindAddrByName Inq Cmpl Evt (Status 0x%04x, Result(s) %d)",
-            p->status, p->num_resp);
-
-        if (p->status == BTM_SUCCESS)
-        {
-            /* Step 1: If automatically retrieving remote names then search the local database */
-            if ((p_result->status = gap_find_local_addr_by_name (p_result->devname, p_result->bd_addr)) == GAP_NO_DATA_AVAIL)
-            {
-                /* Step 2:  The name is not stored automatically, so a search of all devices needs to
-                 *          be initiated.
-                 */
-                if ((p_cb->p_cur_inq = BTM_InqDbFirst()) != NULL)
-                {
-                    if ((BTM_ReadRemoteDeviceName (p_cb->p_cur_inq->results.remote_bd_addr,
-                        (tBTM_CMPL_CB *) gap_find_addr_name_cb, BT_TRANSPORT_BR_EDR)) == BTM_CMD_STARTED)
-                        return;     /* Wait for the response in gap_find_addr_name_cb() */
-                    else
-                        p_result->status = gap_convert_btm_status (p->status);
-                }
-                else
-                    p_result->status = GAP_EOINQDB;     /* No inquiry results; we're done! */
-            }
-        }
-        else
-            p_result->status = gap_convert_btm_status (p->status);
-
-        /* If this code is reached, the process has completed so call the appl's callback with results */
-        if (p_cb->p_cback)
-            p_cb->p_cback (GAP_EVT_FIND_ADDR_COMPLETE, (tGAP_FINDADDR_RESULTS *) p_result);
-
-        /* Clear out the control block */
-        p_cb->in_use = FALSE;
-        p_cb->p_cback = (tGAP_CALLBACK *) NULL;
-    }
-}
-
-/*******************************************************************************
-**
-** Function         gap_find_local_addr_by_name
-**
-** Description      Searches through the internal inquiry database for a device
-**                  that has the same name as the one passed in.  If found, the
-**                  device address is filled in.
-**
-**                  NOTE:  It only searches up to the first BTM_MAX_REM_BD_NAME_LEN
-**                          bytes because the inquiry database uses tBTM_BD_NAME.
-**
-** Returns          BT_PASS if the name was found and the device address is filled in
-**                  GAP_EOINQDB if the name was not found in the database
-**                  GAP_NO_DATA_AVAIL if the name is not saved with the inquiry
-**
-*******************************************************************************/
-UINT16 gap_find_local_addr_by_name (const tBTM_BD_NAME devname, BD_ADDR bd_addr)
-{
-    UNUSED(devname);
-    UNUSED(bd_addr);
-    /* No data available because we are not automatically saving the data */
-    return (GAP_NO_DATA_AVAIL);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_allocate_cb
-**
-** Description      Look through the GAP Control Blocks for a free one.
-**
-** Returns          Pointer to the control block or NULL if not found
-**
-*******************************************************************************/
-tGAP_INFO *gap_allocate_cb (void)
-{
-    tGAP_INFO     *p_cb = &gap_cb.blk[0];
-    UINT8        x;
-
-    for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++)
-    {
-        if (!p_cb->in_use)
-        {
-            memset (p_cb, 0, sizeof (tGAP_INFO));
-
-            p_cb->in_use = TRUE;
-            p_cb->index = x;
-            p_cb->p_data = (void *)NULL;
-            return (p_cb);
-        }
-    }
-
-    /* If here, no free control blocks found */
-    return (NULL);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_free_cb
-**
-** Description      Release GAP control block.
-**
-** Returns          Pointer to the control block or NULL if not found
-**
-*******************************************************************************/
-void gap_free_cb (tGAP_INFO *p_cb)
-{
-    if (p_cb)
-    {
-        p_cb->gap_cback = NULL;
-        p_cb->in_use = FALSE;
-    }
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_is_service_busy
-**
-** Description      Look through the GAP Control Blocks that are in use
-**                  and check to see if the event waiting for is the command
-**                  requested.
-**
-** Returns          TRUE if already in use
-**                  FALSE if not busy
-**
-*******************************************************************************/
-BOOLEAN gap_is_service_busy (UINT16 request)
-{
-    tGAP_INFO   *p_cb = &gap_cb.blk[0];
-    UINT8        x;
-
-    for (x = 0; x < GAP_MAX_BLOCKS; x++, p_cb++)
-    {
-        if (p_cb->in_use && p_cb->event == request)
-            return (TRUE);
-    }
-
-    /* If here, service is not busy */
-    return (FALSE);
-}
-
-
-/*******************************************************************************
-**
-** Function         gap_convert_btm_status
-**
-** Description      Converts a BTM error status into a GAP error status
-**
-**
-** Returns          GAP_UNKNOWN_BTM_STATUS is returned if not recognized
-**
-*******************************************************************************/
-UINT16 gap_convert_btm_status (tBTM_STATUS btm_status)
-{
-    switch (btm_status)
-    {
-    case BTM_SUCCESS:
-        return (BT_PASS);
-
-    case BTM_CMD_STARTED:
-        return (GAP_CMD_INITIATED);
-
-    case BTM_BUSY:
-        return (GAP_ERR_BUSY);
-
-    case BTM_MODE_UNSUPPORTED:
-    case BTM_ILLEGAL_VALUE:
-        return (GAP_ERR_ILL_PARM);
-
-    case BTM_WRONG_MODE:
-        return (GAP_DEVICE_NOT_UP);
-
-    case BTM_UNKNOWN_ADDR:
-        return (GAP_BAD_BD_ADDR);
-
-    case BTM_DEVICE_TIMEOUT:
-        return (GAP_ERR_TIMEOUT);
-
-    default:
-        return (GAP_ERR_PROCESSING);
-    }
-}
diff --git a/stack/include/dyn_mem.h b/stack/include/dyn_mem.h
index e0521343e..a58d60ef4 100644
--- a/stack/include/dyn_mem.h
+++ b/stack/include/dyn_mem.h
@@ -119,10 +119,6 @@
 #define FTP_DYNAMIC_MEMORY  FALSE
 #endif
 
-#ifndef GAP_DYNAMIC_MEMORY
-#define GAP_DYNAMIC_MEMORY  FALSE
-#endif
-
 #ifndef GOEP_DYNAMIC_MEMORY
 #define GOEP_DYNAMIC_MEMORY FALSE
 #endif
diff --git a/stack/include/gap_api.h b/stack/include/gap_api.h
index 6e2ad43a7..0d86d0723 100644
--- a/stack/include/gap_api.h
+++ b/stack/include/gap_api.h
@@ -19,117 +19,10 @@
 #ifndef GAP_API_H
 #define GAP_API_H
 
-#include "profiles_api.h"
-#include "btm_api.h"
-#include "l2c_api.h"
-
 /*****************************************************************************
 **  Constants
 *****************************************************************************/
 
-/*** GAP Error and Status Codes ***/
-#define GAP_UNSUPPORTED     (GAP_ERR_GRP + 0x01)    /* Unsupported call */
-#define GAP_EOINQDB         (GAP_ERR_GRP + 0x02)    /* End of inquiry database marker */
-#define GAP_ERR_BUSY        (GAP_ERR_GRP + 0x03)    /* The requested function was busy */
-#define GAP_ERR_NO_CTRL_BLK (GAP_ERR_GRP + 0x04)    /* No control blocks available */
-#define GAP_ERR_STARTING_CMD (GAP_ERR_GRP + 0x05)   /* Error occurred while initiating the command */
-#define GAP_NO_BDADDR_REC   (GAP_ERR_GRP + 0x06)    /* No Inquiry DB record for BD_ADDR */
-#define GAP_ERR_ILL_MODE    (GAP_ERR_GRP + 0x07)    /* An illegal mode parameter was detected */
-#define GAP_ERR_ILL_INQ_TIME (GAP_ERR_GRP + 0x08)   /* An illegal time parameter was detected */
-#define GAP_ERR_ILL_PARM     (GAP_ERR_GRP + 0x09)   /* An illegal parameter was detected */
-#define GAP_ERR_REM_NAME    (GAP_ERR_GRP + 0x0a)    /* Error starting the remote device name request */
-#define GAP_CMD_INITIATED   (GAP_ERR_GRP + 0x0b)    /* The GAP command was started (result pending) */
-#define GAP_DEVICE_NOT_UP   (GAP_ERR_GRP + 0x0c)    /* The device was not up; the request was not executed */
-#define GAP_BAD_BD_ADDR     (GAP_ERR_GRP + 0x0d)    /* The bd addr passed in was not found or invalid */
-
-#define GAP_ERR_BAD_HANDLE  (GAP_ERR_GRP + 0x0e)    /* Bad GAP handle                       */
-#define GAP_ERR_BUF_OFFSET  (GAP_ERR_GRP + 0x0f)    /* Buffer offset invalid                */
-#define GAP_ERR_BAD_STATE   (GAP_ERR_GRP + 0x10)    /* Connection is in invalid state       */
-#define GAP_NO_DATA_AVAIL   (GAP_ERR_GRP + 0x11)    /* No data available                    */
-#define GAP_ERR_CONGESTED   (GAP_ERR_GRP + 0x12)    /* BT stack is congested                */
-#define GAP_ERR_SECURITY    (GAP_ERR_GRP + 0x13)    /* Security failed                      */
-
-#define GAP_ERR_PROCESSING  (GAP_ERR_GRP + 0x14)    /* General error processing BTM request */
-#define GAP_ERR_TIMEOUT     (GAP_ERR_GRP + 0x15)    /* Timeout occurred while processing cmd */
-
-/** GAP Events - definitions of GAP return events ***/
-#define GAP_EVT_INQUIRY_RESULTS     0x0001
-#define GAP_EVT_INQUIRY_COMPLETE    0x0002
-#define GAP_EVT_DISCOVERY_COMPLETE  0x0003
-#define GAP_EVT_REM_NAME_COMPLETE   0x0004
-#define GAP_EVT_FIND_ADDR_COMPLETE  0x0005
-
-#define GAP_EVT_CONN_OPENED         0x0100
-#define GAP_EVT_CONN_CLOSED         0x0101
-#define GAP_EVT_CONN_DATA_AVAIL     0x0102
-#define GAP_EVT_CONN_CONGESTED      0x0103
-#define GAP_EVT_CONN_UNCONGESTED    0x0104
-
-/* Values for 'chan_mode_mask' field */
-/* GAP_ConnOpen() - optional channels to negotiate */
-#define GAP_FCR_CHAN_OPT_BASIC      L2CAP_FCR_CHAN_OPT_BASIC
-#define GAP_FCR_CHAN_OPT_ERTM       L2CAP_FCR_CHAN_OPT_ERTM
-#define GAP_FCR_CHAN_OPT_STREAM     L2CAP_FCR_CHAN_OPT_STREAM
-
-/*** discovery of devices ***/
-#define GAP_INQUIRY_NONE            BTM_INQUIRY_NONE
-#define GAP_GENERAL_INQUIRY         BTM_GENERAL_INQUIRY
-#define GAP_LIMITED_INQUIRY         BTM_LIMITED_INQUIRY
-
-#if BLE_INCLUDED == TRUE
-#define GAP_BLE_INQUIRY_NONE        BTM_BLE_INQUIRY_NONE
-#define GAP_BLE_GENERAL_INQUIRY     BTM_BLE_GENERAL_INQUIRY
-#define GAP_BLE_LIMITED_INQUIRY     BTM_BLE_LIMITED_INQUIRY
-#endif
-
-/*** discoverable modes ***/
-#define GAP_NON_DISCOVERABLE        BTM_NON_DISCOVERABLE
-#define GAP_LIMITED_DISCOVERABLE    BTM_LIMITED_DISCOVERABLE
-#define GAP_GENERAL_DISCOVERABLE    BTM_GENERAL_DISCOVERABLE
-
-/*** Inquiry Filter Condition types  (The values are defined in btm_api.h) ***/
-#define GAP_CLR_INQUIRY_FILTER      BTM_CLR_INQUIRY_FILTER          /* Inquiry Filtering is turned off */
-#define GAP_FILTER_COND_DEVICE_CLASS BTM_FILTER_COND_DEVICE_CLASS    /* Filter on device class */
-#define GAP_FILTER_COND_BD_ADDR     BTM_FILTER_COND_BD_ADDR         /* Filter on device addr */
-
-/*** connectability ***/
-#define GAP_NON_CONNECTABLE         BTM_NON_CONNECTABLE
-#define GAP_CONNECTABLE             BTM_CONNECTABLE
-
-/*** security features ***/
-#define GAP_DISALLOW_PAIRING        0
-#define GAP_ALLOW_PAIRING           1
-
-/*** class of device settings ***/
-#define GAP_SET_COD_MAJOR_MINOR     0x01
-#define GAP_SET_COD_SERVICE_CLASS   0x02 /* only set the bits in the input */
-#define GAP_CLR_COD_SERVICE_CLASS   0x04
-#define GAP_SET_COD_ALL             0x08 /* take service class as the input (may clear some set bits!!) */
-#define GAP_INIT_COD                0x0a
-
-/*** used in connection variables and functions ***/
-#define GAP_INVALID_HANDLE      0xFFFF
-
-/* This is used to change the criteria for AMP  */
-#define GAP_PROTOCOL_ID         (UUID_PROTOCOL_UDP)
-
-/* slave preferred parameter, minimum connection interval */
-#ifndef GAP_SL_CONN_INT_MIN
-#define GAP_SL_CONN_INT_MIN     6
-#endif
-/* slave preferred parameter, maximum connection interval */
-#ifndef GAP_SL_CONN_INT_MAX
-#define GAP_SL_CONN_INT_MAX     20
-#endif
-/* slave preferred parameter */
-#ifndef GAP_SL_LATENCY
-#define GAP_SL_LATENCY     2
-#endif
-
-#ifndef GAP_BLE_PRIVACY_RECONN_ADDR_PERM
-#define GAP_BLE_PRIVACY_RECONN_ADDR_PERM        (GATT_PERM_READ|GATT_PERM_WRITE)
-#endif
-
 #ifndef  GAP_PREFER_CONN_INT_MAX
 #define  GAP_PREFER_CONN_INT_MAX         BTM_BLE_CONN_INT_MIN
 #endif
@@ -149,60 +42,6 @@
 /*****************************************************************************
 **  Type Definitions
 *****************************************************************************/
-/*
-** Callback function for connection services
-*/
-typedef void (tGAP_CONN_CALLBACK) (UINT16 gap_handle, UINT16 event);
-
-/*
-** Define the callback function prototypes.  Parameters are specific
-** to each event and are described below
-*/
-typedef void (tGAP_CALLBACK) (UINT16 event, void *p_data);
-
-typedef tBTM_REMOTE_DEV_NAME    tGAP_REMOTE_DEV_NAME;   /* see btm_api.h */
-typedef tBTM_INQ_PARMS          tGAP_INQ_PARMS;         /* see btm_api.h */
-typedef tBTM_INQ_RESULTS        tGAP_INQ_RESULTS;       /* see btm_api.h */
-
-/* Inquiry results structure */
-typedef struct
-{
-    UINT16  status;
-    UINT8   num_results;
-} tGAP_INQ_CMPL;
-
-/* Definition of the GAP_FindAddrByName results structure */
-typedef struct
-{
-    UINT16       status;
-    BD_ADDR      bd_addr;
-    tBTM_BD_NAME devname;
-} tGAP_FINDADDR_RESULTS;
-
-/** for GAP_SetDeviceClass() **/
-/* Define Class of Device related values
- *
- * >>> changes to this type need to also be made to tHSP_COD in hsp2_int.h
- */
-typedef struct
-{
-    UINT8       minor;
-    UINT8       major;
-    UINT16      service;
-} tGAP_COD;
-
-/*** Constants and functions for device features ***/
-typedef struct
-{
-    UINT8   lmp_version;
-    UINT16  mfc_name;
-    UINT16  lmp_subversion;
-} tGAP_LMP_VERSION;
-
-typedef struct
-{
-    UINT8   lmp_features[8];
-} tGAP_LMP_FEATURES;
 
 typedef struct
 {
@@ -229,471 +68,6 @@ typedef void (tGAP_BLE_RECONN_ADDR_CBACK)(BOOLEAN status, BD_ADDR addr, BD_ADDR
 /*****************************************************************************
 **  External Function Declarations
 *****************************************************************************/
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/*******************************************************************************
-**
-** Function         GAP_SetDiscoverableMode
-**
-** Description      This function is called to allow or disallow a service to
-**                  discovered (Inquiry Scans).
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_PARM if a bad parameter is detected,
-**                  GAP_DEVICE_NOT_UP if the device is not active,
-**                  GAP_ERR_PROCESSING if not enough resources to carry out request
-**
-*******************************************************************************/
-extern UINT16 GAP_SetDiscoverableMode (UINT16 mode, UINT16 duration,
-                                       UINT16 interval);
-
-/*******************************************************************************
-**
-** Function         GAP_ReadDiscoverableMode
-**
-** Description      This function is called to retrieve the current discoverable
-**                  mode for the local device.
-**
-** Returns          GAP_NON_DISCOVERABLE, GAP_LIMITED_DISCOVERABLE, or
-**                  GAP_GENERAL_DISCOVERABLE
-**
-*******************************************************************************/
-extern UINT16 GAP_ReadDiscoverableMode (UINT16 *duration, UINT16 *interval);
-
-/*******************************************************************************
-**
-** Function         GAP_StartInquiry
-**
-** Description      This function initiates a single inquiry.
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_MODE if a bad mode parameter was passed
-**                  GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks
-**                  GAP_ERR_ILL_PARM if a bad parameter was detected in BTM
-**                  GAP_ERR_BUSY if the device already has an iquiry active
-**                  GAP_DEVICE_NOT_UP if the device is not initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error was returned
-**
-*******************************************************************************/
-extern UINT16 GAP_StartInquiry (tGAP_INQ_PARMS *p_inq_parms,
-                                tGAP_CALLBACK *p_results_cb,
-                                tGAP_CALLBACK *p_cmpl_cb);
-
-/*******************************************************************************
-**
-** Function         GAP_StartPeriodicInquiry
-**
-** Description      This function initiates a periodic inquiry.
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_MODE if a bad mode parameter was passed
-**                  GAP_ERR_ILL_INQ_TIME if a bad interval or duration was passed
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks
-**                  GAP_ERR_ILL_PARM if a bad parameter was detected in BTM
-**                  GAP_ERR_BUSY if the device already has an iquiry active
-**                  GAP_DEVICE_NOT_UP if the device is not initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error was returned
-**
-*******************************************************************************/
-extern UINT16 GAP_StartPeriodicInquiry (tGAP_INQ_PARMS *p_inq_parms,
-                                        UINT16 min_time,
-                                        UINT16 max_time,
-                                        tGAP_CALLBACK *p_results_cb);
-
-/*******************************************************************************
-**
-** Function         GAP_CancelInquiry
-**
-** Description      This function cancels a single inquiry (if in progress)
-**
-** Returns          BOOLEAN (TRUE if successful, otherwise FALSE)
-**
-*******************************************************************************/
-extern UINT16 GAP_CancelInquiry(void);
-
-/*******************************************************************************
-**
-** Function         GAP_CancelPeriodicInquiry
-**
-** Description      This function cancels a periodic inquiry (if in progress)
-**
-** Returns          BOOLEAN: (TRUE if successful, otherwise FALSE)
-**
-*******************************************************************************/
-extern UINT16 GAP_CancelPeriodicInquiry(void);
-
-/*******************************************************************************
-**
-** Function         GAP_GetFirstInquiryResult
-**
-** Description      This function retrieves the first valid inquiry result.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**                  GAP_EOINQDB if no more entries in the database.
-**
-*******************************************************************************/
-extern UINT16 GAP_GetFirstInquiryResult(tGAP_INQ_RESULTS *p_results);
-
-/*******************************************************************************
-**
-** Function         GAP_GetNextInquiryResult
-**
-** Description      This function retrieves the next valid inquiry result.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero status code
-**                  GAP_EOINQDB if no more entries in the database.
-**
-*******************************************************************************/
-extern UINT16 GAP_GetNextInquiryResult(tGAP_INQ_RESULTS *p_results);
-
-/*******************************************************************************
-**
-** Function         GAP_FindAddrByName
-**
-** Description      This function is called to retrieve a device address given
-**                  a device name.  It first looks in the current local inquiry
-**                  database for the device with the specified name.  If not found
-**                  it initiates a general inquiry.  Upon completion, it retrieves
-**                  the name for each device until a match is found or all devices
-**                  have been checked.  Note:  This process can take a while to
-**                  complete.
-**
-** Returns          BT_PASS if the name was immediately available. (BD_ADDR is returned)
-**                  GAP_CMD_INITIATED if an inquiry has been initiated
-**
-*******************************************************************************/
-extern UINT16 GAP_FindAddrByName (BD_NAME devname,
-                                  tGAP_INQ_PARMS *p_inq_parms,
-                                  tGAP_CALLBACK *p_addr_cb,
-                                  BD_ADDR bd_addr);
-
-/*******************************************************************************
-**
-** Function         GAP_SetConnectableMode
-**
-** Description      This function is called to allow or disallow a
-**                  connections on the local device.
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_ILL_PARM if a bad parameter is detected,
-**                  GAP_DEVICE_NOT_UP if the device is not active,
-**                  GAP_ERR_PROCESSING if not enough resources to carry out request
-**
-*******************************************************************************/
-extern UINT16 GAP_SetConnectableMode (UINT16 mode, UINT16 duration,
-                                      UINT16 interval);
-
-/*******************************************************************************
-**
-** Function         GAP_ReadConnectableMode
-**
-** Description      This function is called to retrieve the current connectability
-**                  mode for the local device.
-**
-** Returns          GAP_NON_CONNECTABLE, GAP_CONNECTABLE
-**
-*******************************************************************************/
-extern UINT16 GAP_ReadConnectableMode (UINT16 *duration, UINT16 *interval);
-
-/*******************************************************************************
-**
-** Function         GAP_SecRegister
-**
-** Description      Application calls this function to register for
-**                  security services.
-**
-** Returns          TRUE if registered OK, else FALSE
-**
-*******************************************************************************/
-extern BOOLEAN GAP_SecRegister (tBTM_APPL_INFO *p_cb_info);
-
-/*******************************************************************************
-**
-** Function         GAP_SetPairableMode
-**
-** Description      This function is called to allow or disallow pairing
-**                  on the local device.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**
-*******************************************************************************/
-extern UINT16 GAP_SetPairableMode (UINT16 mode, BOOLEAN connect_only_paired);
-
-/*******************************************************************************
-**
-** Function         GAP_Bond
-**
-** Description      This function is called to initiate bonding with peer device
-**
-** Parameters:      bd_addr      - Address of the device to bond
-**                  pin_len      - length in bytes of the PIN Code
-**                  p_pin        - pointer to array with the PIN Code
-**                  trusted_mask - bitwise OR of trusted services (array of UINT32)
-**
-** Returns          tBTM_STATUS - BTM_CMD_STARTED of successfully initiated
-**
-*******************************************************************************/
-extern UINT8 GAP_Bond (BD_ADDR bd_addr, UINT8 pin_len,
-                       UINT8 *p_pin, UINT32 trusted_mask[]);
-
-/*******************************************************************************
-**
-** Function         GAP_PinRsp
-**
-** Description      This function is called from UI after Security Manager submitted
-**                  PIN code request.
-**
-** Returns          void
-**
-*******************************************************************************/
-extern void GAP_PinRsp (BD_ADDR bd_addr, UINT8 res, UINT8 pin_len,
-                        UINT8 *p_pin, UINT32 trusted_mask[]);
-
-/*******************************************************************************
-**
-** Function         GAP_AuthorizeRsp
-**
-** Description      This function is called from UI after Security Manager submitted
-**                  an authorization request.
-**
-** Returns          void
-**
-*******************************************************************************/
-extern void GAP_AuthorizeRsp (BD_ADDR bd_addr, UINT8 res,
-                              UINT32 trusted_mask[]);
-
-/*******************************************************************************
-**
-** Function         GAP_SetDeviceClass
-**
-** Description      This function updates the local Device Class.
-**
-** Returns          BT_PASS (0) if successful,
-**                  GAP_ERR_BUSY if a discovery is already in progress
-**                  GAP_ERR_ILL_PARM if an illegal parameter was detected
-**                  GAP_ERR_PROCESSING if any other BTM error has been returned
-**
-*******************************************************************************/
-extern UINT16 GAP_SetDeviceClass(tGAP_COD *p_cod, UINT8 cmd);
-
-/*******************************************************************************
-**
-** Function         GAP_ReadDeviceClass
-**
-** Description      This function reads the current local Device Class setting.
-**
-** Returns          BT_PASS
-**
-*******************************************************************************/
-extern UINT16 GAP_ReadDeviceClass(tGAP_COD *p_cod);
-
-/*******************************************************************************
-**
-** Function         GAP_ReadLocalDeviceInfo
-**
-** Description      This function retrieves local device information to the caller.
-**                  NOTE:  Return parameters that are set to NULL are not retrieved.
-**
-** Returns          BT_PASS (0) if successful, or a non-zero error code
-**
-*******************************************************************************/
-extern UINT16 GAP_ReadLocalDeviceInfo(  UINT8 *name, BD_ADDR *addr,
-                                        tGAP_LMP_VERSION *verinfo,
-                                        tGAP_LMP_FEATURES *features);
-
-
-/*******************************************************************************
-**
-** Function         GAP_GetRemoteDeviceName
-**
-** Description      The remote name is retrieved from the specified remote device.  If
-**                  GAP_CMD_INITIATED is returned by the function, the command was
-**                  successfully sent to the controller.  The GAP_EVT_NAME_RESP event
-**                  is passed in the callback when the remote device name has been retrieved.
-**
-** Returns
-**                  GAP_CMD_INITIATED if remote search successfully initiated
-**                  GAP_ERR_BUSY if a remote name request is already in progress,
-**                  GAP_ERR_NO_CTRL_BLK if out of control blocks (too many commands pending)
-**                  GAP_BAD_BD_ADDR if the device address is bad,
-**                  GAP_DEVICE_NOT_UP if the device has not been initialized yet
-**                  GAP_ERR_PROCESSING if any other BTM error has been returned
-**
-*******************************************************************************/
-extern UINT16 GAP_GetRemoteDeviceName (BD_ADDR addr, tGAP_CALLBACK *callback);
-
-/*** Functions for L2CAP connection interface ***/
-/*******************************************************************************
-**
-** Function         GAP_ConnOpen
-**
-** Description      This function is called to open a generic L2CAP connection.
-**
-** Returns          handle of the connection if successful, else GAP_INVALID_HANDLE
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnOpen (char *p_serv_name, UINT8 service_id, BOOLEAN is_server,
-                            BD_ADDR p_rem_bda, UINT16 psm, tL2CAP_CFG_INFO *p_cfg,
-                            UINT16 security, UINT8 chan_mode_mask, tGAP_CONN_CALLBACK *p_cb);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnClose
-**
-** Description      This function is called to close a connection.
-**
-** Returns          BT_PASS             - closed OK
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnClose (UINT16 gap_handle);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnReadData
-**
-** Description      GKI buffer unaware application will call this function
-**                  after receiving GAP_EVT_RXDATA event. A data copy is made
-**                  into the receive buffer parameter.
-**
-** Returns          BT_PASS             - data read
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**                  GAP_NO_DATA_AVAIL   - no data available
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnReadData (UINT16 gap_handle, UINT8 *p_data,
-                                UINT16 max_len, UINT16 *p_len);
-
-/*******************************************************************************
-**
-** Function         GAP_GetRxQueueCnt
-**
-** Description      This function return number of bytes on the rx queue.
-**
-** Parameters:      handle     - Handle returned in the GAP_ConnOpen
-**                  p_rx_queue_count - Pointer to return queue count in.
-**
-**
-*******************************************************************************/
-extern int GAP_GetRxQueueCnt (UINT16 handle, UINT32 *p_rx_queue_count);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnBTRead
-**
-** Description      GKI buffer aware applications will call this function after
-**                  receiving an GAP_EVT_RXDATA event to process the incoming
-**                  data buffer.
-**
-** Returns          BT_PASS             - data read
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**                  GAP_NO_DATA_AVAIL   - no data available
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnBTRead (UINT16 gap_handle, BT_HDR **pp_buf);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnBTWrite
-**
-** Description      GKI buffer aware applications can call this function to write data
-**                  by passing a pointer to the GKI buffer of data.
-**
-** Returns          BT_PASS                 - data read
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**                  GAP_ERR_BAD_STATE       - connection not established
-**                  GAP_INVALID_BUF_OFFSET  - buffer offset is invalid
-*******************************************************************************/
-extern UINT16 GAP_ConnBTWrite (UINT16 gap_handle, BT_HDR *p_buf);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnWriteData
-**
-** Description      GKI buffer unaware application will call this function
-**                  to send data to the connection. A data copy is made into a GKI
-**                  buffer.
-**
-** Returns          BT_PASS                 - data read
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**                  GAP_ERR_BAD_STATE       - connection not established
-**                  GAP_CONGESTION          - system is congested
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnWriteData (UINT16 gap_handle, UINT8 *p_data,
-                                 UINT16 max_len, UINT16 *p_len);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnReconfig
-**
-** Description      Applications can call this function to reconfigure the connection.
-**
-** Returns          BT_PASS                 - config process started
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnReconfig (UINT16 gap_handle, tL2CAP_CFG_INFO *p_cfg);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnSetIdleTimeout
-**
-** Description      Higher layers call this function to set the idle timeout for
-**                  a connection, or for all future connections. The "idle timeout"
-**                  is the amount of time that a connection can remain up with
-**                  no L2CAP channels on it. A timeout of zero means that the
-**                  connection will be torn down immediately when the last channel
-**                  is removed. A timeout of 0xFFFF means no timeout. Values are
-**                  in seconds.
-**
-** Returns          BT_PASS                 - config process started
-**                  GAP_ERR_BAD_HANDLE      - invalid handle
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnSetIdleTimeout (UINT16 gap_handle, UINT16 timeout);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetRemoteAddr
-**
-** Description      This function is called to get the remote BD address
-**                  of a connection.
-**
-** Returns          BT_PASS             - closed OK
-**                  GAP_ERR_BAD_HANDLE  - invalid handle
-**
-*******************************************************************************/
-extern UINT8 *GAP_ConnGetRemoteAddr (UINT16 gap_handle);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetRemMtuSize
-**
-** Description      Returns the remote device's MTU size.
-**
-** Returns          UINT16 - maximum size buffer that can be transmitted to the peer
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnGetRemMtuSize (UINT16 gap_handle);
-
-/*******************************************************************************
-**
-** Function         GAP_ConnGetL2CAPCid
-**
-** Description      Returns the L2CAP channel id
-**
-** Parameters:      handle      - Handle of the connection
-**
-** Returns          UINT16      - The L2CAP channel id
-**                  0, if error
-**
-*******************************************************************************/
-extern UINT16 GAP_ConnGetL2CAPCid (UINT16 gap_handle);
 
 /*******************************************************************************
 **
@@ -784,8 +158,4 @@ extern BOOLEAN GAP_BleUpdateReconnectAddr (BD_ADDR peer_bda,
 
 #endif
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif  /* GAP_API_H */