stack/btm/btm_acl.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2000-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /*****************************************************************************
  20 **
  21 **  Name:          btm_acl.c
  22 **
  23 **  Description:   This file contains functions that handle ACL connections.
  24 **                 This includes operations such as hold and sniff modes,
  25 **                 supported packet types.
  26 **
  27 **                 This module contains both internal and external (API)
  28 **                 functions. External (API) functions are distinguishable
  29 **                 by their names beginning with uppercase BTM.
  30 **
  31 **
  32 ******************************************************************************/
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <stdio.h>
  37 #include <stddef.h>
  38
  39 #include "bt_types.h"
  40 #include "bt_target.h"
  41 #include "device/include/controller.h"
  42 #include "gki.h"
  43 #include "hcimsgs.h"
  44 #include "btu.h"
  45 #include "btm_api.h"
  46 #include "btm_int.h"
  47 #include "l2c_int.h"
  48 #include "hcidefs.h"
  49 #include "bt_utils.h"
  50
  51 static void btm_read_remote_features (UINT16 handle);
  52 static void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number);
  53 static void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages);
  54
  55 #define BTM_DEV_REPLY_TIMEOUT   3       /* 3 second timeout waiting for responses */
  56
  57 /*******************************************************************************
  58 **
  59 ** Function         btm_acl_init
  60 **
  61 ** Description      This function is called at BTM startup to initialize
  62 **
  63 ** Returns          void
  64 **
  65 *******************************************************************************/
  66 void btm_acl_init (void)
  67 {
  68     BTM_TRACE_DEBUG ("btm_acl_init");
  69 #if 0  /* cleared in btm_init; put back in if called from anywhere else! */
  70     memset (&btm_cb.acl_db, 0, sizeof (btm_cb.acl_db));
  71     memset (btm_cb.btm_scn, 0, BTM_MAX_SCN);          /* Initialize the SCN usage to FALSE */
  72     btm_cb.btm_def_link_policy     = 0;
  73     btm_cb.p_bl_changed_cb         = NULL;
  74 #endif
  75
  76     /* Initialize nonzero defaults */
  77     btm_cb.btm_def_link_super_tout = HCI_DEFAULT_INACT_TOUT;
  78     btm_cb.acl_disc_reason         = 0xff ;
  79 }
  80
  81 /*******************************************************************************
  82 **
  83 ** Function         btm_bda_to_acl
  84 **
  85 ** Description      This function returns the FIRST acl_db entry for the passed BDA.
  86 **
  87 ** Parameters      bda : BD address of the remote device
  88 **                 transport : Physical transport used for ACL connection (BR/EDR or LE)
  89 **
  90 ** Returns          Returns pointer to the ACL DB for the requested BDA if found.
  91 **                  NULL if not found.
  92 **
  93 *******************************************************************************/
  94 tACL_CONN *btm_bda_to_acl (BD_ADDR bda, tBT_TRANSPORT transport)
  95 {
  96     tACL_CONN   *p = &btm_cb.acl_db[0];
  97     UINT16       xx;
  98     if (bda)
  99     {
 100         for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
 101         {
 102             if ((p->in_use) && (!memcmp (p->remote_addr, bda, BD_ADDR_LEN))
 103 #if BLE_INCLUDED == TRUE
 104                 && p->transport == transport
 105 #endif
 106                 )
 107             {
 108                 BTM_TRACE_DEBUG ("btm_bda_to_acl found");
 109                 return(p);
 110             }
 111         }
 112     }
 113
 114     /* If here, no BD Addr found */
 115     return((tACL_CONN *)NULL);
 116 }
 117
 118 /*******************************************************************************
 119 **
 120 ** Function         btm_handle_to_acl_index
 121 **
 122 ** Description      This function returns the FIRST acl_db entry for the passed hci_handle.
 123 **
 124 ** Returns          index to the acl_db or MAX_L2CAP_LINKS.
 125 **
 126 *******************************************************************************/
 127 UINT8 btm_handle_to_acl_index (UINT16 hci_handle)
 128 {
 129     tACL_CONN   *p = &btm_cb.acl_db[0];
 130     UINT8       xx;
 131     BTM_TRACE_DEBUG ("btm_handle_to_acl_index");
 132     for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
 133     {
 134         if ((p->in_use) && (p->hci_handle == hci_handle))
 135         {
 136             break;
 137         }
 138     }
 139
 140     /* If here, no BD Addr found */
 141     return(xx);
 142 }
 143
 144 #if BLE_PRIVACY_SPT == TRUE
 145 /*******************************************************************************
 146 **
 147 ** Function         btm_ble_get_acl_remote_addr
 148 **
 149 ** Description      This function reads the active remote address used for the
 150 **                  connection.
 151 **
 152 ** Returns          success return TRUE, otherwise FALSE.
 153 **
 154 *******************************************************************************/
 155 BOOLEAN btm_ble_get_acl_remote_addr(tBTM_SEC_DEV_REC *p_dev_rec, BD_ADDR conn_addr,
 156                                     tBLE_ADDR_TYPE *p_addr_type)
 157 {
 158 #if BLE_INCLUDED == TRUE
 159     BOOLEAN         st = TRUE;
 160
 161     if (p_dev_rec == NULL)
 162     {
 163         BTM_TRACE_ERROR("btm_ble_get_acl_remote_addr can not find device with matching address");
 164         return FALSE;
 165     }
 166
 167     switch (p_dev_rec->ble.active_addr_type)
 168     {
 169     case BTM_BLE_ADDR_PSEUDO:
 170         memcpy(conn_addr, p_dev_rec->bd_addr, BD_ADDR_LEN);
 171         * p_addr_type = p_dev_rec->ble.ble_addr_type;
 172         break;
 173
 174     case BTM_BLE_ADDR_RRA:
 175         memcpy(conn_addr, p_dev_rec->ble.cur_rand_addr, BD_ADDR_LEN);
 176         * p_addr_type = BLE_ADDR_RANDOM;
 177         break;
 178
 179     case BTM_BLE_ADDR_STATIC:
 180         memcpy(conn_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
 181         * p_addr_type = p_dev_rec->ble.static_addr_type;
 182         break;
 183
 184     default:
 185         BTM_TRACE_ERROR("Unknown active address: %d", p_dev_rec->ble.active_addr_type);
 186         st = FALSE;
 187         break;
 188     }
 189
 190     return st;
 191 #else
 192     UNUSED(p_dev_rec);
 193     UNUSED(conn_addr);
 194     UNUSED(p_addr_type);
 195     return FALSE;
 196 #endif
 197 }
 198 #endif
 199 /*******************************************************************************
 200 **
 201 ** Function         btm_acl_created
 202 **
 203 ** Description      This function is called by L2CAP when an ACL connection
 204 **                  is created.
 205 **
 206 ** Returns          void
 207 **
 208 *******************************************************************************/
 209 void btm_acl_created (BD_ADDR bda, DEV_CLASS dc, BD_NAME bdn,
 210                       UINT16 hci_handle, UINT8 link_role, tBT_TRANSPORT transport)
 211 {
 212     tBTM_SEC_DEV_REC *p_dev_rec = NULL;
 213     tACL_CONN        *p;
 214     UINT8             xx;
 215
 216     BTM_TRACE_DEBUG ("btm_acl_created hci_handle=%d link_role=%d  transport=%d",
 217                       hci_handle,link_role, transport);
 218     /* Ensure we don't have duplicates */
 219     p = btm_bda_to_acl(bda, transport);
 220     if (p != (tACL_CONN *)NULL)
 221     {
 222         p->hci_handle = hci_handle;
 223         p->link_role  = link_role;
 224 #if BLE_INCLUDED == TRUE
 225         p->transport = transport;
 226 #endif
 227         BTM_TRACE_DEBUG ("Duplicate btm_acl_created: RemBdAddr: %02x%02x%02x%02x%02x%02x",
 228                           bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
 229         BTM_SetLinkPolicy(p->remote_addr, &btm_cb.btm_def_link_policy);
 230         return;
 231     }
 232
 233     /* Allocate acl_db entry */
 234     for (xx = 0, p = &btm_cb.acl_db[0]; xx < MAX_L2CAP_LINKS; xx++, p++)
 235     {
 236         if (!p->in_use)
 237         {
 238             p->in_use            = TRUE;
 239             p->hci_handle        = hci_handle;
 240             p->link_role         = link_role;
 241             p->link_up_issued    = FALSE;
 242             memcpy (p->remote_addr, bda, BD_ADDR_LEN);
 243
 244 #if BLE_INCLUDED == TRUE
 245             p->transport = transport;
 246 #if BLE_PRIVACY_SPT == TRUE
 247             if (transport == BT_TRANSPORT_LE)
 248                 btm_ble_refresh_local_resolvable_private_addr(bda,
 249                                                     btm_cb.ble_ctr_cb.addr_mgnt_cb.private_addr);
 250 #endif
 251 #endif
 252             p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
 253
 254             btm_pm_sm_alloc(xx);
 255
 256
 257             if (dc)
 258                 memcpy (p->remote_dc, dc, DEV_CLASS_LEN);
 259
 260             if (bdn)
 261                 memcpy (p->remote_name, bdn, BTM_MAX_REM_BD_NAME_LEN);
 262
 263             /* if BR/EDR do something more */
 264             if (transport == BT_TRANSPORT_BR_EDR)
 265             {
 266                 btsnd_hcic_read_rmt_clk_offset (p->hci_handle);
 267                 btsnd_hcic_rmt_ver_req (p->hci_handle);
 268             }
 269             p_dev_rec = btm_find_dev_by_handle (hci_handle);
 270
 271 #if (BLE_INCLUDED == TRUE)
 272             if (p_dev_rec )
 273             {
 274                 BTM_TRACE_DEBUG ("device_type=0x%x", p_dev_rec->device_type);
 275             }
 276 #endif
 277
 278             if (p_dev_rec && !(transport == BT_TRANSPORT_LE))
 279             {
 280                 /* If remote features already known, copy them and continue connection setup */
 281                 if ((p_dev_rec->num_read_pages) &&
 282                     (p_dev_rec->num_read_pages <= (HCI_EXT_FEATURES_PAGE_MAX + 1)))
 283                 {
 284                     memcpy (p->peer_lmp_features, p_dev_rec->features,
 285                         (HCI_FEATURE_BYTES_PER_PAGE * p_dev_rec->num_read_pages));
 286                     p->num_read_pages = p_dev_rec->num_read_pages;
 287
 288                     const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
 289
 290                     /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */
 291                     btm_sec_set_peer_sec_caps(p, p_dev_rec);
 292
 293                     BTM_TRACE_API("%s: pend:%d", __FUNCTION__, req_pend);
 294                     if (req_pend)
 295                     {
 296                         /* Request for remaining Security Features (if any) */
 297                         l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
 298                     }
 299                     btm_establish_continue (p);
 300                     return;
 301                 }
 302             }
 303
 304 #if (BLE_INCLUDED == TRUE)
 305             /* If here, features are not known yet */
 306             if (p_dev_rec && transport == BT_TRANSPORT_LE)
 307             {
 308 #if BLE_PRIVACY_SPT == TRUE
 309                 btm_ble_get_acl_remote_addr (p_dev_rec, p->active_remote_addr,
 310                     &p->active_remote_addr_type);
 311 #endif
 312
 313                 if (HCI_LE_SLAVE_INIT_FEAT_EXC_SUPPORTED(controller_get_interface()->get_features_ble()->as_array)
 314                     || link_role == HCI_ROLE_MASTER)
 315                 {
 316                     btsnd_hcic_ble_read_remote_feat(p->hci_handle);
 317                 }
 318                 else
 319                 {
 320                     btm_establish_continue(p);
 321                 }
 322             }
 323             else
 324 #endif
 325             {
 326                 btm_read_remote_features (p->hci_handle);
 327             }
 328
 329             /* read page 1 - on rmt feature event for buffer reasons */
 330             return;
 331         }
 332     }
 333 }
 334
 335
 336 /*******************************************************************************
 337 **
 338 ** Function         btm_acl_report_role_change
 339 **
 340 ** Description      This function is called when the local device is deemed
 341 **                  to be down. It notifies L2CAP of the failure.
 342 **
 343 ** Returns          void
 344 **
 345 *******************************************************************************/
 346 void btm_acl_report_role_change (UINT8 hci_status, BD_ADDR bda)
 347 {
 348     tBTM_ROLE_SWITCH_CMPL   ref_data;
 349     BTM_TRACE_DEBUG ("btm_acl_report_role_change");
 350     if (btm_cb.devcb.p_switch_role_cb
 351         && (bda && (0 == memcmp(btm_cb.devcb.switch_role_ref_data.remote_bd_addr, bda, BD_ADDR_LEN))))
 352     {
 353         memcpy (&ref_data, &btm_cb.devcb.switch_role_ref_data, sizeof(tBTM_ROLE_SWITCH_CMPL));
 354         ref_data.hci_status = hci_status;
 355         (*btm_cb.devcb.p_switch_role_cb)(&ref_data);
 356         memset (&btm_cb.devcb.switch_role_ref_data, 0, sizeof(tBTM_ROLE_SWITCH_CMPL));
 357         btm_cb.devcb.p_switch_role_cb = NULL;
 358     }
 359 }
 360
 361 /*******************************************************************************
 362 **
 363 ** Function         btm_acl_removed
 364 **
 365 ** Description      This function is called by L2CAP when an ACL connection
 366 **                  is removed. Since only L2CAP creates ACL links, we use
 367 **                  the L2CAP link index as our index into the control blocks.
 368 **
 369 ** Returns          void
 370 **
 371 *******************************************************************************/
 372 void btm_acl_removed (BD_ADDR bda, tBT_TRANSPORT transport)
 373 {
 374     tACL_CONN   *p;
 375     tBTM_BL_EVENT_DATA  evt_data;
 376 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
 377     tBTM_SEC_DEV_REC *p_dev_rec=NULL;
 378 #endif
 379     BTM_TRACE_DEBUG ("btm_acl_removed");
 380     p = btm_bda_to_acl(bda, transport);
 381     if (p != (tACL_CONN *)NULL)
 382     {
 383         p->in_use = FALSE;
 384
 385         /* if the disconnected channel has a pending role switch, clear it now */
 386         btm_acl_report_role_change(HCI_ERR_NO_CONNECTION, bda);
 387
 388         /* Only notify if link up has had a chance to be issued */
 389         if (p->link_up_issued)
 390         {
 391             p->link_up_issued = FALSE;
 392
 393             /* If anyone cares, tell him database changed */
 394             if (btm_cb.p_bl_changed_cb)
 395             {
 396                 evt_data.event = BTM_BL_DISCN_EVT;
 397                 evt_data.discn.p_bda = bda;
 398 #if BLE_INCLUDED == TRUE
 399                 evt_data.discn.handle = p->hci_handle;
 400                 evt_data.discn.transport = p->transport;
 401 #endif
 402                 (*btm_cb.p_bl_changed_cb)(&evt_data);
 403             }
 404
 405             btm_acl_update_busy_level (BTM_BLI_ACL_DOWN_EVT);
 406         }
 407
 408 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
 409
 410         BTM_TRACE_DEBUG ("acl hci_handle=%d transport=%d connectable_mode=0x%0x link_role=%d",
 411                           p->hci_handle,
 412                           p->transport,
 413                           btm_cb.ble_ctr_cb.inq_var.connectable_mode,
 414                           p->link_role);
 415
 416         p_dev_rec = btm_find_dev(bda);
 417         if ( p_dev_rec)
 418         {
 419             BTM_TRACE_DEBUG("before update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags);
 420             if (p->transport == BT_TRANSPORT_LE)
 421             {
 422                 BTM_TRACE_DEBUG("LE link down");
 423                 p_dev_rec->sec_flags &= ~(BTM_SEC_LE_ENCRYPTED | BTM_SEC_ROLE_SWITCHED);
 424                 if ( (p_dev_rec->sec_flags & BTM_SEC_LE_LINK_KEY_KNOWN) == 0)
 425                 {
 426                     BTM_TRACE_DEBUG("Not Bonded");
 427                     p_dev_rec->sec_flags &= ~(BTM_SEC_LE_LINK_KEY_AUTHED | BTM_SEC_LE_AUTHENTICATED);
 428                 }
 429                 else
 430                 {
 431                     BTM_TRACE_DEBUG("Bonded");
 432                 }
 433             }
 434             else
 435             {
 436                 BTM_TRACE_DEBUG("Bletooth link down");
 437                 p_dev_rec->sec_flags &= ~(BTM_SEC_AUTHORIZED | BTM_SEC_AUTHENTICATED
 438                                         | BTM_SEC_ENCRYPTED | BTM_SEC_ROLE_SWITCHED);
 439             }
 440             BTM_TRACE_DEBUG("after update p_dev_rec->sec_flags=0x%x", p_dev_rec->sec_flags);
 441         }
 442         else
 443         {
 444             BTM_TRACE_ERROR("Device not found");
 445
 446         }
 447 #endif
 448
 449         return;
 450     }
 451 }
 452
 453
 454 /*******************************************************************************
 455 **
 456 ** Function         btm_acl_device_down
 457 **
 458 ** Description      This function is called when the local device is deemed
 459 **                  to be down. It notifies L2CAP of the failure.
 460 **
 461 ** Returns          void
 462 **
 463 *******************************************************************************/
 464 void btm_acl_device_down (void)
 465 {
 466     tACL_CONN   *p = &btm_cb.acl_db[0];
 467     UINT16      xx;
 468     BTM_TRACE_DEBUG ("btm_acl_device_down");
 469     for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p++)
 470     {
 471         if (p->in_use)
 472         {
 473             BTM_TRACE_DEBUG ("hci_handle=%d HCI_ERR_HW_FAILURE ",p->hci_handle );
 474             l2c_link_hci_disc_comp (p->hci_handle, HCI_ERR_HW_FAILURE);
 475         }
 476     }
 477 }
 478
 479 /*******************************************************************************
 480 **
 481 ** Function         btm_acl_update_busy_level
 482 **
 483 ** Description      This function is called to update the busy level of the system
 484 **                  .
 485 **
 486 ** Returns          void
 487 **
 488 *******************************************************************************/
 489 void btm_acl_update_busy_level (tBTM_BLI_EVENT event)
 490 {
 491     tBTM_BL_UPDATE_DATA  evt;
 492     UINT8 busy_level;
 493     BTM_TRACE_DEBUG ("btm_acl_update_busy_level");
 494     BOOLEAN old_inquiry_state = btm_cb.is_inquiry;
 495     switch (event)
 496     {
 497         case BTM_BLI_ACL_UP_EVT:
 498             BTM_TRACE_DEBUG ("BTM_BLI_ACL_UP_EVT");
 499             break;
 500         case BTM_BLI_ACL_DOWN_EVT:
 501             BTM_TRACE_DEBUG ("BTM_BLI_ACL_DOWN_EVT");
 502             break;
 503         case BTM_BLI_PAGE_EVT:
 504             BTM_TRACE_DEBUG ("BTM_BLI_PAGE_EVT");
 505             btm_cb.is_paging = TRUE;
 506             evt.busy_level_flags= BTM_BL_PAGING_STARTED;
 507             break;
 508         case BTM_BLI_PAGE_DONE_EVT:
 509             BTM_TRACE_DEBUG ("BTM_BLI_PAGE_DONE_EVT");
 510             btm_cb.is_paging = FALSE;
 511             evt.busy_level_flags = BTM_BL_PAGING_COMPLETE;
 512             break;
 513         case BTM_BLI_INQ_EVT:
 514             BTM_TRACE_DEBUG ("BTM_BLI_INQ_EVT");
 515             btm_cb.is_inquiry = TRUE;
 516             evt.busy_level_flags = BTM_BL_INQUIRY_STARTED;
 517             break;
 518         case BTM_BLI_INQ_CANCEL_EVT:
 519             BTM_TRACE_DEBUG ("BTM_BLI_INQ_CANCEL_EVT");
 520             btm_cb.is_inquiry = FALSE;
 521             evt.busy_level_flags = BTM_BL_INQUIRY_CANCELLED;
 522             break;
 523         case BTM_BLI_INQ_DONE_EVT:
 524             BTM_TRACE_DEBUG ("BTM_BLI_INQ_DONE_EVT");
 525             btm_cb.is_inquiry = FALSE;
 526             evt.busy_level_flags = BTM_BL_INQUIRY_COMPLETE;
 527             break;
 528     }
 529
 530     if (btm_cb.is_paging || btm_cb.is_inquiry)
 531         busy_level = 10;
 532     else
 533         busy_level = BTM_GetNumAclLinks();
 534
 535     if ((busy_level != btm_cb.busy_level) ||(old_inquiry_state != btm_cb.is_inquiry))
 536     {
 537         evt.event         = BTM_BL_UPDATE_EVT;
 538         evt.busy_level    = busy_level;
 539         btm_cb.busy_level = busy_level;
 540         if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_UPDATE_MASK))
 541         {
 542             (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
 543         }
 544     }
 545 }
 546
 547 /*******************************************************************************
 548 **
 549 ** Function         BTM_GetRole
 550 **
 551 ** Description      This function is called to get the role of the local device
 552 **                  for the ACL connection with the specified remote device
 553 **
 554 ** Returns          BTM_SUCCESS if connection exists.
 555 **                  BTM_UNKNOWN_ADDR if no active link with bd addr specified
 556 **
 557 *******************************************************************************/
 558 tBTM_STATUS BTM_GetRole (BD_ADDR remote_bd_addr, UINT8 *p_role)
 559 {
 560     tACL_CONN   *p;
 561     BTM_TRACE_DEBUG ("BTM_GetRole");
 562     if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
 563     {
 564         *p_role = BTM_ROLE_UNDEFINED;
 565         return(BTM_UNKNOWN_ADDR);
 566     }
 567
 568     /* Get the current role */
 569     *p_role = p->link_role;
 570     return(BTM_SUCCESS);
 571 }
 572
 573
 574 /*******************************************************************************
 575 **
 576 ** Function         BTM_SwitchRole
 577 **
 578 ** Description      This function is called to switch role between master and
 579 **                  slave.  If role is already set it will do nothing.  If the
 580 **                  command was initiated, the callback function is called upon
 581 **                  completion.
 582 **
 583 ** Returns          BTM_SUCCESS if already in specified role.
 584 **                  BTM_CMD_STARTED if command issued to controller.
 585 **                  BTM_NO_RESOURCES if couldn't allocate memory to issue command
 586 **                  BTM_UNKNOWN_ADDR if no active link with bd addr specified
 587 **                  BTM_MODE_UNSUPPORTED if local device does not support role switching
 588 **                  BTM_BUSY if the previous command is not completed
 589 **
 590 *******************************************************************************/
 591 tBTM_STATUS BTM_SwitchRole (BD_ADDR remote_bd_addr, UINT8 new_role, tBTM_CMPL_CB *p_cb)
 592 {
 593     tACL_CONN   *p;
 594     tBTM_SEC_DEV_REC  *p_dev_rec = NULL;
 595 #if BTM_SCO_INCLUDED == TRUE
 596     BOOLEAN    is_sco_active;
 597 #endif
 598     tBTM_STATUS  status;
 599     tBTM_PM_MODE pwr_mode;
 600     tBTM_PM_PWR_MD settings;
 601 #if (BT_USE_TRACES == TRUE)
 602     BD_ADDR_PTR  p_bda;
 603 #endif
 604     BTM_TRACE_API ("BTM_SwitchRole BDA: %02x-%02x-%02x-%02x-%02x-%02x",
 605                     remote_bd_addr[0], remote_bd_addr[1], remote_bd_addr[2],
 606                     remote_bd_addr[3], remote_bd_addr[4], remote_bd_addr[5]);
 607
 608     /* Make sure the local device supports switching */
 609     if (!controller_get_interface()->supports_master_slave_role_switch())
 610         return(BTM_MODE_UNSUPPORTED);
 611
 612     if (btm_cb.devcb.p_switch_role_cb && p_cb)
 613     {
 614 #if (BT_USE_TRACES == TRUE)
 615         p_bda = btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
 616         BTM_TRACE_DEBUG ("Role switch on other device is in progress 0x%02x%02x%02x%02x%02x%02x",
 617                           p_bda[0], p_bda[1], p_bda[2],
 618                           p_bda[3], p_bda[4], p_bda[5]);
 619 #endif
 620         return(BTM_BUSY);
 621     }
 622
 623     if ((p = btm_bda_to_acl(remote_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL)
 624         return(BTM_UNKNOWN_ADDR);
 625
 626     /* Finished if already in desired role */
 627     if (p->link_role == new_role)
 628         return(BTM_SUCCESS);
 629
 630 #if BTM_SCO_INCLUDED == TRUE
 631     /* Check if there is any SCO Active on this BD Address */
 632     is_sco_active = btm_is_sco_active_by_bdaddr(remote_bd_addr);
 633
 634     if (is_sco_active == TRUE)
 635         return(BTM_NO_RESOURCES);
 636 #endif
 637
 638     /* Ignore role switch request if the previous request was not completed */
 639     if (p->switch_role_state != BTM_ACL_SWKEY_STATE_IDLE)
 640     {
 641         BTM_TRACE_DEBUG ("BTM_SwitchRole busy: %d",
 642                           p->switch_role_state);
 643         return(BTM_BUSY);
 644     }
 645
 646     if ((status = BTM_ReadPowerMode(p->remote_addr, &pwr_mode)) != BTM_SUCCESS)
 647         return(status);
 648
 649     /* Wake up the link if in sniff or park before attempting switch */
 650     if (pwr_mode == BTM_PM_MD_PARK || pwr_mode == BTM_PM_MD_SNIFF)
 651     {
 652         memset( (void*)&settings, 0, sizeof(settings));
 653         settings.mode = BTM_PM_MD_ACTIVE;
 654         status = BTM_SetPowerMode (BTM_PM_SET_ONLY_ID, p->remote_addr, &settings);
 655         if (status != BTM_CMD_STARTED)
 656             return(BTM_WRONG_MODE);
 657
 658         p->switch_role_state = BTM_ACL_SWKEY_STATE_MODE_CHANGE;
 659     }
 660     /* some devices do not support switch while encryption is on */
 661     else
 662     {
 663         p_dev_rec = btm_find_dev (remote_bd_addr);
 664         if ((p_dev_rec != NULL)
 665             && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0)
 666             && !BTM_EPR_AVAILABLE(p))
 667         {
 668             /* bypass turning off encryption if change link key is already doing it */
 669             if (p->encrypt_state != BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF)
 670             {
 671                 if (!btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE))
 672                     return(BTM_NO_RESOURCES);
 673                 else
 674                     p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
 675             }
 676
 677             p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
 678         }
 679         else
 680         {
 681             if (!btsnd_hcic_switch_role (remote_bd_addr, new_role))
 682                 return(BTM_NO_RESOURCES);
 683
 684             p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
 685
 686 #if BTM_DISC_DURING_RS == TRUE
 687             if (p_dev_rec)
 688                 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
 689 #endif
 690         }
 691     }
 692
 693     /* Initialize return structure in case request fails */
 694     if (p_cb)
 695     {
 696         memcpy (btm_cb.devcb.switch_role_ref_data.remote_bd_addr, remote_bd_addr,
 697                 BD_ADDR_LEN);
 698         btm_cb.devcb.switch_role_ref_data.role = new_role;
 699         /* initialized to an error code */
 700         btm_cb.devcb.switch_role_ref_data.hci_status = HCI_ERR_UNSUPPORTED_VALUE;
 701         btm_cb.devcb.p_switch_role_cb = p_cb;
 702     }
 703     return(BTM_CMD_STARTED);
 704 }
 705
 706 /*******************************************************************************
 707 **
 708 ** Function         btm_acl_encrypt_change
 709 **
 710 ** Description      This function is when encryption of the connection is
 711 **                  completed by the LM.  Checks to see if a role switch or
 712 **                  change of link key was active and initiates or continues
 713 **                  process if needed.
 714 **
 715 ** Returns          void
 716 **
 717 *******************************************************************************/
 718 void btm_acl_encrypt_change (UINT16 handle, UINT8 status, UINT8 encr_enable)
 719 {
 720     tACL_CONN *p;
 721     UINT8     xx;
 722     tBTM_SEC_DEV_REC  *p_dev_rec;
 723     tBTM_BL_ROLE_CHG_DATA   evt;
 724
 725     BTM_TRACE_DEBUG ("btm_acl_encrypt_change handle=%d status=%d encr_enabl=%d",
 726                       handle, status, encr_enable);
 727     xx = btm_handle_to_acl_index(handle);
 728     /* don't assume that we can never get a bad hci_handle */
 729     if (xx < MAX_L2CAP_LINKS)
 730         p = &btm_cb.acl_db[xx];
 731     else
 732         return;
 733
 734     /* Process Role Switch if active */
 735     if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF)
 736     {
 737         /* if encryption turn off failed we still will try to switch role */
 738         if (encr_enable)
 739         {
 740             p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
 741             p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
 742         }
 743         else
 744         {
 745             p->switch_role_state = BTM_ACL_SWKEY_STATE_SWITCHING;
 746             p->encrypt_state = BTM_ACL_ENCRYPT_STATE_TEMP_FUNC;
 747         }
 748
 749         if (!btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role))
 750         {
 751             p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
 752             p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
 753             btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr);
 754         }
 755 #if BTM_DISC_DURING_RS == TRUE
 756         else
 757         {
 758             if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL)
 759                 p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
 760         }
 761 #endif
 762
 763     }
 764     /* Finished enabling Encryption after role switch */
 765     else if (p->switch_role_state == BTM_ACL_SWKEY_STATE_ENCRYPTION_ON)
 766     {
 767         p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
 768         p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
 769         btm_acl_report_role_change(btm_cb.devcb.switch_role_ref_data.hci_status, p->remote_addr);
 770
 771         /* if role change event is registered, report it now */
 772         if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK))
 773         {
 774             evt.event       = BTM_BL_ROLE_CHG_EVT;
 775             evt.new_role    = btm_cb.devcb.switch_role_ref_data.role;
 776             evt.p_bda       = btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
 777             evt.hci_status  = btm_cb.devcb.switch_role_ref_data.hci_status;
 778             (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
 779
 780             BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
 781                              evt.new_role, evt.hci_status, p->switch_role_state);
 782         }
 783
 784 #if BTM_DISC_DURING_RS == TRUE
 785         /* If a disconnect is pending, issue it now that role switch has completed */
 786         if ((p_dev_rec = btm_find_dev (p->remote_addr)) != NULL)
 787         {
 788             if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING)
 789             {
 790                 BTM_TRACE_WARNING("btm_acl_encrypt_change -> Issuing delayed HCI_Disconnect!!!");
 791                 btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER);
 792             }
 793             BTM_TRACE_ERROR("btm_acl_encrypt_change: tBTM_SEC_DEV:0x%x rs_disc_pending=%d",
 794                 (UINT32)p_dev_rec, p_dev_rec->rs_disc_pending);
 795             p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING;     /* reset flag */
 796         }
 797 #endif
 798     }
 799 }
 800 /*******************************************************************************
 801 **
 802 ** Function         BTM_SetLinkPolicy
 803 **
 804 ** Description      Create and send HCI "Write Policy Set" command
 805 **
 806 ** Returns          status of the operation
 807 **
 808 *******************************************************************************/
 809 tBTM_STATUS BTM_SetLinkPolicy (BD_ADDR remote_bda, UINT16 *settings)
 810 {
 811     tACL_CONN   *p;
 812     UINT8       *localFeatures = BTM_ReadLocalFeatures();
 813     BTM_TRACE_DEBUG ("BTM_SetLinkPolicy");
 814 /*    BTM_TRACE_API ("BTM_SetLinkPolicy: requested settings: 0x%04x", *settings ); */
 815
 816     /* First, check if hold mode is supported */
 817     if (*settings != HCI_DISABLE_ALL_LM_MODES)
 818     {
 819         if ( (*settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures)) )
 820         {
 821             *settings &= (~HCI_ENABLE_MASTER_SLAVE_SWITCH);
 822             BTM_TRACE_API ("BTM_SetLinkPolicy switch not supported (settings: 0x%04x)", *settings );
 823         }
 824         if ( (*settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures)) )
 825         {
 826             *settings &= (~HCI_ENABLE_HOLD_MODE);
 827             BTM_TRACE_API ("BTM_SetLinkPolicy hold not supported (settings: 0x%04x)", *settings );
 828         }
 829         if ( (*settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures)) )
 830         {
 831             *settings &= (~HCI_ENABLE_SNIFF_MODE);
 832             BTM_TRACE_API ("BTM_SetLinkPolicy sniff not supported (settings: 0x%04x)", *settings );
 833         }
 834         if ( (*settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures)) )
 835         {
 836             *settings &= (~HCI_ENABLE_PARK_MODE);
 837             BTM_TRACE_API ("BTM_SetLinkPolicy park not supported (settings: 0x%04x)", *settings );
 838         }
 839     }
 840
 841     if ((p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR)) != NULL)
 842         return(btsnd_hcic_write_policy_set (p->hci_handle, *settings) ? BTM_CMD_STARTED : BTM_NO_RESOURCES);
 843
 844     /* If here, no BD Addr found */
 845     return(BTM_UNKNOWN_ADDR);
 846 }
 847
 848 /*******************************************************************************
 849 **
 850 ** Function         BTM_SetDefaultLinkPolicy
 851 **
 852 ** Description      Set the default value for HCI "Write Policy Set" command
 853 **                  to use when an ACL link is created.
 854 **
 855 ** Returns          void
 856 **
 857 *******************************************************************************/
 858 void BTM_SetDefaultLinkPolicy (UINT16 settings)
 859 {
 860     UINT8 *localFeatures = BTM_ReadLocalFeatures();
 861
 862     BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy setting:0x%04x", settings);
 863
 864     if((settings & HCI_ENABLE_MASTER_SLAVE_SWITCH) && (!HCI_SWITCH_SUPPORTED(localFeatures)))
 865     {
 866         settings &= ~HCI_ENABLE_MASTER_SLAVE_SWITCH;
 867         BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy switch not supported (settings: 0x%04x)", settings);
 868     }
 869     if ((settings & HCI_ENABLE_HOLD_MODE) && (!HCI_HOLD_MODE_SUPPORTED(localFeatures)))
 870     {
 871         settings &= ~HCI_ENABLE_HOLD_MODE;
 872         BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy hold not supported (settings: 0x%04x)", settings);
 873     }
 874     if ((settings & HCI_ENABLE_SNIFF_MODE) && (!HCI_SNIFF_MODE_SUPPORTED(localFeatures)))
 875     {
 876         settings &= ~HCI_ENABLE_SNIFF_MODE;
 877         BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy sniff not supported (settings: 0x%04x)", settings);
 878     }
 879     if ((settings & HCI_ENABLE_PARK_MODE) && (!HCI_PARK_MODE_SUPPORTED(localFeatures)))
 880     {
 881         settings &= ~HCI_ENABLE_PARK_MODE;
 882         BTM_TRACE_DEBUG("BTM_SetDefaultLinkPolicy park not supported (settings: 0x%04x)", settings);
 883     }
 884     BTM_TRACE_DEBUG("Set DefaultLinkPolicy:0x%04x", settings);
 885
 886     btm_cb.btm_def_link_policy = settings;
 887
 888     /* Set the default Link Policy of the controller */
 889     btsnd_hcic_write_def_policy_set(settings);
 890 }
 891
 892 /*******************************************************************************
 893 **
 894 ** Function         btm_read_remote_version_complete
 895 **
 896 ** Description      This function is called when the command complete message
 897 **                  is received from the HCI for the remote version info.
 898 **
 899 ** Returns          void
 900 **
 901 *******************************************************************************/
 902 void btm_read_remote_version_complete (UINT8 *p)
 903 {
 904     tACL_CONN        *p_acl_cb = &btm_cb.acl_db[0];
 905     UINT8             status;
 906     UINT16            handle;
 907     int               xx;
 908     BTM_TRACE_DEBUG ("btm_read_remote_version_complete");
 909     STREAM_TO_UINT8  (status, p);
 910     if (status == HCI_SUCCESS)
 911     {
 912         STREAM_TO_UINT16 (handle, p);
 913
 914         /* Look up the connection by handle and copy features */
 915         for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_acl_cb++)
 916         {
 917             if ((p_acl_cb->in_use) && (p_acl_cb->hci_handle == handle))
 918             {
 919                 STREAM_TO_UINT8  (p_acl_cb->lmp_version, p);
 920                 STREAM_TO_UINT16 (p_acl_cb->manufacturer, p);
 921                 STREAM_TO_UINT16 (p_acl_cb->lmp_subversion, p);
 922                 break;
 923             }
 924         }
 925     }
 926 }
 927
 928
 929 /*******************************************************************************
 930 **
 931 ** Function         btm_process_remote_ext_features
 932 **
 933 ** Description      Local function called to process all extended features pages
 934 **                  read from a remote device.
 935 **
 936 ** Returns          void
 937 **
 938 *******************************************************************************/
 939 void btm_process_remote_ext_features (tACL_CONN *p_acl_cb, UINT8 num_read_pages)
 940 {
 941     UINT16              handle = p_acl_cb->hci_handle;
 942     tBTM_SEC_DEV_REC    *p_dev_rec = btm_find_dev_by_handle (handle);
 943     UINT8               page_idx;
 944
 945     BTM_TRACE_DEBUG ("btm_process_remote_ext_features");
 946
 947     /* Make sure we have the record to save remote features information */
 948     if (p_dev_rec == NULL)
 949     {
 950         /* Get a new device; might be doing dedicated bonding */
 951         p_dev_rec = btm_find_or_alloc_dev (p_acl_cb->remote_addr);
 952     }
 953
 954     p_acl_cb->num_read_pages = num_read_pages;
 955     p_dev_rec->num_read_pages = num_read_pages;
 956
 957     /* Move the pages to placeholder */
 958     for (page_idx = 0; page_idx < num_read_pages; page_idx++)
 959     {
 960         if (page_idx > HCI_EXT_FEATURES_PAGE_MAX)
 961         {
 962             BTM_TRACE_ERROR("%s: page=%d unexpected", __FUNCTION__, page_idx);
 963             break;
 964         }
 965         memcpy (p_dev_rec->features[page_idx], p_acl_cb->peer_lmp_features[page_idx],
 966                 HCI_FEATURE_BYTES_PER_PAGE);
 967     }
 968
 969     const UINT8 req_pend = (p_dev_rec->sm4 & BTM_SM4_REQ_PEND);
 970
 971     /* Store the Peer Security Capabilites (in SM4 and rmt_sec_caps) */
 972     btm_sec_set_peer_sec_caps(p_acl_cb, p_dev_rec);
 973
 974     BTM_TRACE_API("%s: pend:%d", __FUNCTION__, req_pend);
 975     if (req_pend)
 976     {
 977         /* Request for remaining Security Features (if any) */
 978         l2cu_resubmit_pending_sec_req (p_dev_rec->bd_addr);
 979     }
 980 }
 981
 982
 983 /*******************************************************************************
 984 **
 985 ** Function         btm_read_remote_features
 986 **
 987 ** Description      Local function called to send a read remote supported features/
 988 **                  remote extended features page[0].
 989 **
 990 ** Returns          void
 991 **
 992 *******************************************************************************/
 993 void btm_read_remote_features (UINT16 handle)
 994 {
 995     UINT8       acl_idx;
 996     tACL_CONN   *p_acl_cb;
 997
 998     BTM_TRACE_DEBUG("btm_read_remote_features() handle: %d", handle);
 999
1000     if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1001     {
1002         BTM_TRACE_ERROR("btm_read_remote_features handle=%d invalid", handle);
1003         return;
1004     }
1005
1006     p_acl_cb = &btm_cb.acl_db[acl_idx];
1007     p_acl_cb->num_read_pages = 0;
1008     memset (p_acl_cb->peer_lmp_features, 0, sizeof(p_acl_cb->peer_lmp_features));
1009
1010     /* first send read remote supported features HCI command */
1011     /* because we don't know whether the remote support extended feature command */
1012     btsnd_hcic_rmt_features_req (handle);
1013 }
1014
1015
1016 /*******************************************************************************
1017 **
1018 ** Function         btm_read_remote_ext_features
1019 **
1020 ** Description      Local function called to send a read remote extended features
1021 **
1022 ** Returns          void
1023 **
1024 *******************************************************************************/
1025 void btm_read_remote_ext_features (UINT16 handle, UINT8 page_number)
1026 {
1027     BTM_TRACE_DEBUG("btm_read_remote_ext_features() handle: %d page: %d", handle, page_number);
1028
1029     btsnd_hcic_rmt_ext_features(handle, page_number);
1030 }
1031
1032
1033 /*******************************************************************************
1034 **
1035 ** Function         btm_read_remote_features_complete
1036 **
1037 ** Description      This function is called when the remote supported features
1038 **                  complete event is received from the HCI.
1039 **
1040 ** Returns          void
1041 **
1042 *******************************************************************************/
1043 void btm_read_remote_features_complete (UINT8 *p)
1044 {
1045     tACL_CONN        *p_acl_cb;
1046     UINT8             status;
1047     UINT16            handle;
1048     UINT8            acl_idx;
1049
1050     BTM_TRACE_DEBUG ("btm_read_remote_features_complete");
1051     STREAM_TO_UINT8  (status, p);
1052
1053     if (status != HCI_SUCCESS)
1054     {
1055         BTM_TRACE_ERROR ("btm_read_remote_features_complete failed (status 0x%02x)", status);
1056         return;
1057     }
1058
1059         STREAM_TO_UINT16 (handle, p);
1060
1061     if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1062         {
1063         BTM_TRACE_ERROR("btm_read_remote_features_complete handle=%d invalid", handle);
1064         return;
1065                 }
1066
1067     p_acl_cb = &btm_cb.acl_db[acl_idx];
1068
1069     /* Copy the received features page */
1070     STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0], p,
1071                     HCI_FEATURE_BYTES_PER_PAGE);
1072
1073     if ((HCI_LMP_EXTENDED_SUPPORTED(p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])) &&
1074         (controller_get_interface()->supports_reading_remote_extended_features()))
1075     {
1076         /* if the remote controller has extended features and local controller supports
1077         ** HCI_Read_Remote_Extended_Features command then start reading these feature starting
1078         ** with extended features page 1 */
1079         BTM_TRACE_DEBUG ("Start reading remote extended features");
1080         btm_read_remote_ext_features(handle, HCI_EXT_FEATURES_PAGE_1);
1081         return;
1082     }
1083
1084     /* Remote controller has no extended features. Process remote controller supported features
1085        (features page HCI_EXT_FEATURES_PAGE_0). */
1086     btm_process_remote_ext_features (p_acl_cb, 1);
1087
1088     /* Continue with HCI connection establishment */
1089     btm_establish_continue (p_acl_cb);
1090 }
1091
1092 /*******************************************************************************
1093 **
1094 ** Function         btm_read_remote_ext_features_complete
1095 **
1096 ** Description      This function is called when the remote extended features
1097 **                  complete event is received from the HCI.
1098 **
1099 ** Returns          void
1100 **
1101 *******************************************************************************/
1102 void btm_read_remote_ext_features_complete (UINT8 *p)
1103 {
1104     tACL_CONN   *p_acl_cb;
1105     UINT8       page_num, max_page;
1106     UINT16      handle;
1107     UINT8       acl_idx;
1108
1109     BTM_TRACE_DEBUG ("btm_read_remote_ext_features_complete");
1110
1111     ++p;
1112     STREAM_TO_UINT16 (handle, p);
1113     STREAM_TO_UINT8  (page_num, p);
1114     STREAM_TO_UINT8  (max_page, p);
1115
1116     /* Validate parameters */
1117     if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1118     {
1119         BTM_TRACE_ERROR("btm_read_remote_ext_features_complete handle=%d invalid", handle);
1120         return;
1121     }
1122
1123     if (max_page > HCI_EXT_FEATURES_PAGE_MAX)
1124     {
1125         BTM_TRACE_ERROR("btm_read_remote_ext_features_complete page=%d unknown", max_page);
1126         return;
1127     }
1128
1129     p_acl_cb = &btm_cb.acl_db[acl_idx];
1130
1131     /* Copy the received features page */
1132     STREAM_TO_ARRAY(p_acl_cb->peer_lmp_features[page_num], p, HCI_FEATURE_BYTES_PER_PAGE);
1133
1134     /* If there is the next remote features page and
1135      * we have space to keep this page data - read this page */
1136     if ((page_num < max_page) && (page_num < HCI_EXT_FEATURES_PAGE_MAX))
1137     {
1138         page_num++;
1139         BTM_TRACE_DEBUG("BTM reads next remote extended features page (%d)", page_num);
1140         btm_read_remote_ext_features (handle, page_num);
1141         return;
1142     }
1143
1144     /* Reading of remote feature pages is complete */
1145     BTM_TRACE_DEBUG("BTM reached last remote extended features page (%d)", page_num);
1146
1147     /* Process the pages */
1148     btm_process_remote_ext_features (p_acl_cb, (UINT8) (page_num + 1));
1149
1150     /* Continue with HCI connection establishment */
1151     btm_establish_continue (p_acl_cb);
1152 }
1153
1154 /*******************************************************************************
1155 **
1156 ** Function         btm_read_remote_ext_features_failed
1157 **
1158 ** Description      This function is called when the remote extended features
1159 **                  complete event returns a failed status.
1160 **
1161 ** Returns          void
1162 **
1163 *******************************************************************************/
1164 void btm_read_remote_ext_features_failed (UINT8 status, UINT16 handle)
1165 {
1166     tACL_CONN   *p_acl_cb;
1167     UINT8       acl_idx;
1168
1169     BTM_TRACE_WARNING ("btm_read_remote_ext_features_failed (status 0x%02x) for handle %d",
1170                          status, handle);
1171
1172     if ((acl_idx = btm_handle_to_acl_index(handle)) >= MAX_L2CAP_LINKS)
1173     {
1174         BTM_TRACE_ERROR("btm_read_remote_ext_features_failed handle=%d invalid", handle);
1175         return;
1176     }
1177
1178     p_acl_cb = &btm_cb.acl_db[acl_idx];
1179
1180     /* Process supported features only */
1181     btm_process_remote_ext_features (p_acl_cb, 1);
1182
1183     /* Continue HCI connection establishment */
1184     btm_establish_continue (p_acl_cb);
1185 }
1186
1187 /*******************************************************************************
1188 **
1189 ** Function         btm_establish_continue
1190 **
1191 ** Description      This function is called when the command complete message
1192 **                  is received from the HCI for the read local link policy request.
1193 **
1194 ** Returns          void
1195 **
1196 *******************************************************************************/
1197 void btm_establish_continue (tACL_CONN *p_acl_cb)
1198 {
1199         tBTM_BL_EVENT_DATA  evt_data;
1200         BTM_TRACE_DEBUG ("btm_establish_continue");
1201 #if (!defined(BTM_BYPASS_EXTRA_ACL_SETUP) || BTM_BYPASS_EXTRA_ACL_SETUP == FALSE)
1202 #if (defined BLE_INCLUDED && BLE_INCLUDED == TRUE)
1203         if (p_acl_cb->transport == BT_TRANSPORT_BR_EDR)
1204 #endif
1205         {
1206             /* For now there are a some devices that do not like sending */
1207             /* commands events and data at the same time. */
1208             /* Set the packet types to the default allowed by the device */
1209             btm_set_packet_types (p_acl_cb, btm_cb.btm_acl_pkt_types_supported);
1210
1211             if (btm_cb.btm_def_link_policy)
1212                 BTM_SetLinkPolicy (p_acl_cb->remote_addr, &btm_cb.btm_def_link_policy);
1213         }
1214 #endif
1215         p_acl_cb->link_up_issued = TRUE;
1216
1217         /* If anyone cares, tell him database changed */
1218         if (btm_cb.p_bl_changed_cb)
1219         {
1220             evt_data.event = BTM_BL_CONN_EVT;
1221             evt_data.conn.p_bda = p_acl_cb->remote_addr;
1222             evt_data.conn.p_bdn = p_acl_cb->remote_name;
1223             evt_data.conn.p_dc  = p_acl_cb->remote_dc;
1224             evt_data.conn.p_features = p_acl_cb->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0];
1225 #if BLE_INCLUDED == TRUE
1226             evt_data.conn.handle = p_acl_cb->hci_handle;
1227             evt_data.conn.transport = p_acl_cb->transport;
1228 #endif
1229
1230             (*btm_cb.p_bl_changed_cb)(&evt_data);
1231         }
1232         btm_acl_update_busy_level (BTM_BLI_ACL_UP_EVT);
1233 }
1234
1235
1236 /*******************************************************************************
1237 **
1238 ** Function         BTM_SetDefaultLinkSuperTout
1239 **
1240 ** Description      Set the default value for HCI "Write Link Supervision Timeout"
1241 **                  command to use when an ACL link is created.
1242 **
1243 ** Returns          void
1244 **
1245 *******************************************************************************/
1246 void BTM_SetDefaultLinkSuperTout (UINT16 timeout)
1247 {
1248     BTM_TRACE_DEBUG ("BTM_SetDefaultLinkSuperTout");
1249     btm_cb.btm_def_link_super_tout = timeout;
1250 }
1251
1252 /*******************************************************************************
1253 **
1254 ** Function         BTM_GetLinkSuperTout
1255 **
1256 ** Description      Read the link supervision timeout value of the connection
1257 **
1258 ** Returns          status of the operation
1259 **
1260 *******************************************************************************/
1261 tBTM_STATUS BTM_GetLinkSuperTout (BD_ADDR remote_bda, UINT16 *p_timeout)
1262 {
1263     tACL_CONN   *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1264
1265     BTM_TRACE_DEBUG ("BTM_GetLinkSuperTout");
1266     if (p != (tACL_CONN *)NULL)
1267     {
1268         *p_timeout = p->link_super_tout;
1269         return(BTM_SUCCESS);
1270     }
1271     /* If here, no BD Addr found */
1272     return(BTM_UNKNOWN_ADDR);
1273 }
1274
1275
1276 /*******************************************************************************
1277 **
1278 ** Function         BTM_SetLinkSuperTout
1279 **
1280 ** Description      Create and send HCI "Write Link Supervision Timeout" command
1281 **
1282 ** Returns          status of the operation
1283 **
1284 *******************************************************************************/
1285 tBTM_STATUS BTM_SetLinkSuperTout (BD_ADDR remote_bda, UINT16 timeout)
1286 {
1287     tACL_CONN   *p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
1288
1289     BTM_TRACE_DEBUG ("BTM_SetLinkSuperTout");
1290     if (p != (tACL_CONN *)NULL)
1291     {
1292         p->link_super_tout = timeout;
1293
1294         /* Only send if current role is Master; 2.0 spec requires this */
1295         if (p->link_role == BTM_ROLE_MASTER)
1296         {
1297             if (!btsnd_hcic_write_link_super_tout (LOCAL_BR_EDR_CONTROLLER_ID,
1298                                                    p->hci_handle, timeout))
1299                 return(BTM_NO_RESOURCES);
1300
1301             return(BTM_CMD_STARTED);
1302         }
1303         else
1304             return(BTM_SUCCESS);
1305     }
1306
1307     /* If here, no BD Addr found */
1308     return(BTM_UNKNOWN_ADDR);
1309 }
1310
1311 /*******************************************************************************
1312 **
1313 ** Function         BTM_IsAclConnectionUp
1314 **
1315 ** Description      This function is called to check if an ACL connection exists
1316 **                  to a specific remote BD Address.
1317 **
1318 ** Returns          TRUE if connection is up, else FALSE.
1319 **
1320 *******************************************************************************/
1321 BOOLEAN BTM_IsAclConnectionUp (BD_ADDR remote_bda, tBT_TRANSPORT transport)
1322 {
1323     tACL_CONN   *p;
1324
1325     BTM_TRACE_API ("BTM_IsAclConnectionUp: RemBdAddr: %02x%02x%02x%02x%02x%02x",
1326                     remote_bda[0], remote_bda[1], remote_bda[2],
1327                     remote_bda[3], remote_bda[4], remote_bda[5]);
1328
1329     p = btm_bda_to_acl(remote_bda, transport);
1330     if (p != (tACL_CONN *)NULL)
1331     {
1332         return(TRUE);
1333     }
1334
1335     /* If here, no BD Addr found */
1336     return(FALSE);
1337 }
1338
1339 /*******************************************************************************
1340 **
1341 ** Function         BTM_GetNumAclLinks
1342 **
1343 ** Description      This function is called to count the number of
1344 **                  ACL links that are active.
1345 **
1346 ** Returns          UINT16  Number of active ACL links
1347 **
1348 *******************************************************************************/
1349 UINT16 BTM_GetNumAclLinks (void)
1350 {
1351     uint16_t num_acl = 0;
1352
1353     for (uint16_t i = 0; i < MAX_L2CAP_LINKS; ++i)
1354     {
1355         if (btm_cb.acl_db[i].in_use)
1356             ++num_acl;
1357     }
1358
1359     return num_acl;
1360 }
1361
1362 /*******************************************************************************
1363 **
1364 ** Function         btm_get_acl_disc_reason_code
1365 **
1366 ** Description      This function is called to get the disconnection reason code
1367 **                  returned by the HCI at disconnection complete event.
1368 **
1369 ** Returns          TRUE if connection is up, else FALSE.
1370 **
1371 *******************************************************************************/
1372 UINT16 btm_get_acl_disc_reason_code (void)
1373 {
1374     UINT8 res = btm_cb.acl_disc_reason;
1375     BTM_TRACE_DEBUG ("btm_get_acl_disc_reason_code");
1376     return(res);
1377 }
1378
1379
1380 /*******************************************************************************
1381 **
1382 ** Function         BTM_GetHCIConnHandle
1383 **
1384 ** Description      This function is called to get the handle for an ACL connection
1385 **                  to a specific remote BD Address.
1386 **
1387 ** Returns          the handle of the connection, or 0xFFFF if none.
1388 **
1389 *******************************************************************************/
1390 UINT16 BTM_GetHCIConnHandle (BD_ADDR remote_bda, tBT_TRANSPORT transport)
1391 {
1392     tACL_CONN   *p;
1393     BTM_TRACE_DEBUG ("BTM_GetHCIConnHandle");
1394     p = btm_bda_to_acl(remote_bda, transport);
1395     if (p != (tACL_CONN *)NULL)
1396     {
1397         return(p->hci_handle);
1398     }
1399
1400     /* If here, no BD Addr found */
1401     return(0xFFFF);
1402 }
1403
1404 /*******************************************************************************
1405 **
1406 ** Function         btm_process_clk_off_comp_evt
1407 **
1408 ** Description      This function is called when clock offset command completes.
1409 **
1410 ** Input Parms      hci_handle - connection handle associated with the change
1411 **                  clock offset
1412 **
1413 ** Returns          void
1414 **
1415 *******************************************************************************/
1416 void btm_process_clk_off_comp_evt (UINT16 hci_handle, UINT16 clock_offset)
1417 {
1418     UINT8      xx;
1419     BTM_TRACE_DEBUG ("btm_process_clk_off_comp_evt");
1420     /* Look up the connection by handle and set the current mode */
1421     if ((xx = btm_handle_to_acl_index(hci_handle)) < MAX_L2CAP_LINKS)
1422         btm_cb.acl_db[xx].clock_offset = clock_offset;
1423 }
1424
1425 /*******************************************************************************
1426 **
1427 ** Function         btm_acl_role_changed
1428 **
1429 ** Description      This function is called whan a link's master/slave role change
1430 **                  event or command status event (with error) is received.
1431 **                  It updates the link control block, and calls
1432 **                  the registered callback with status and role (if registered).
1433 **
1434 ** Returns          void
1435 **
1436 *******************************************************************************/
1437 void btm_acl_role_changed (UINT8 hci_status, BD_ADDR bd_addr, UINT8 new_role)
1438 {
1439     UINT8                   *p_bda = (bd_addr) ? bd_addr :
1440                                         btm_cb.devcb.switch_role_ref_data.remote_bd_addr;
1441     tACL_CONN               *p = btm_bda_to_acl(p_bda, BT_TRANSPORT_BR_EDR);
1442     tBTM_ROLE_SWITCH_CMPL   *p_data = &btm_cb.devcb.switch_role_ref_data;
1443     tBTM_SEC_DEV_REC        *p_dev_rec;
1444     tBTM_BL_ROLE_CHG_DATA   evt;
1445
1446     BTM_TRACE_DEBUG ("btm_acl_role_changed");
1447     /* Ignore any stray events */
1448     if (p == NULL)
1449     {
1450         /* it could be a failure */
1451         if (hci_status != HCI_SUCCESS)
1452             btm_acl_report_role_change(hci_status, bd_addr);
1453         return;
1454     }
1455
1456     p_data->hci_status = hci_status;
1457
1458     if (hci_status == HCI_SUCCESS)
1459     {
1460         p_data->role = new_role;
1461         memcpy(p_data->remote_bd_addr, p_bda, BD_ADDR_LEN);
1462
1463         /* Update cached value */
1464         p->link_role = new_role;
1465
1466         /* Reload LSTO: link supervision timeout is reset in the LM after a role switch */
1467         if (new_role == BTM_ROLE_MASTER)
1468         {
1469             BTM_SetLinkSuperTout (p->remote_addr, p->link_super_tout);
1470         }
1471     }
1472     else
1473     {
1474         /* so the BTM_BL_ROLE_CHG_EVT uses the old role */
1475         new_role = p->link_role;
1476     }
1477
1478     /* Check if any SCO req is pending for role change */
1479     btm_sco_chk_pend_rolechange (p->hci_handle);
1480
1481     /* if switching state is switching we need to turn encryption on */
1482     /* if idle, we did not change encryption */
1483     if (p->switch_role_state == BTM_ACL_SWKEY_STATE_SWITCHING)
1484     {
1485         if (btsnd_hcic_set_conn_encrypt (p->hci_handle, TRUE))
1486         {
1487             p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_ON;
1488             p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_ON;
1489             return;
1490         }
1491     }
1492
1493     /* Set the switch_role_state to IDLE since the reply received from HCI */
1494     /* regardless of its result either success or failed. */
1495     if (p->switch_role_state == BTM_ACL_SWKEY_STATE_IN_PROGRESS)
1496     {
1497         p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
1498         p->encrypt_state = BTM_ACL_ENCRYPT_STATE_IDLE;
1499     }
1500
1501     /* if role switch complete is needed, report it now */
1502     btm_acl_report_role_change(hci_status, bd_addr);
1503
1504     /* if role change event is registered, report it now */
1505     if (btm_cb.p_bl_changed_cb && (btm_cb.bl_evt_mask & BTM_BL_ROLE_CHG_MASK))
1506     {
1507         evt.event       = BTM_BL_ROLE_CHG_EVT;
1508         evt.new_role    = new_role;
1509         evt.p_bda       = p_bda;
1510         evt.hci_status  = hci_status;
1511         (*btm_cb.p_bl_changed_cb)((tBTM_BL_EVENT_DATA *)&evt);
1512     }
1513
1514     BTM_TRACE_DEBUG("Role Switch Event: new_role 0x%02x, HCI Status 0x%02x, rs_st:%d",
1515                      p_data->role, p_data->hci_status, p->switch_role_state);
1516
1517 #if BTM_DISC_DURING_RS == TRUE
1518     /* If a disconnect is pending, issue it now that role switch has completed */
1519     if ((p_dev_rec = btm_find_dev (p_bda)) != NULL)
1520     {
1521         if (p_dev_rec->rs_disc_pending == BTM_SEC_DISC_PENDING)
1522         {
1523             BTM_TRACE_WARNING("btm_acl_role_changed -> Issuing delayed HCI_Disconnect!!!");
1524             btsnd_hcic_disconnect(p_dev_rec->hci_handle, HCI_ERR_PEER_USER);
1525         }
1526         BTM_TRACE_ERROR("tBTM_SEC_DEV:0x%x rs_disc_pending=%d",
1527                          (UINT32)p_dev_rec, p_dev_rec->rs_disc_pending);
1528         p_dev_rec->rs_disc_pending = BTM_SEC_RS_NOT_PENDING;     /* reset flag */
1529     }
1530
1531 #endif
1532
1533 }
1534
1535 /*******************************************************************************
1536 **
1537 ** Function         BTM_AllocateSCN
1538 **
1539 ** Description      Look through the Server Channel Numbers for a free one.
1540 **
1541 ** Returns          Allocated SCN number or 0 if none.
1542 **
1543 *******************************************************************************/
1544
1545 UINT8 BTM_AllocateSCN(void)
1546 {
1547     UINT8   x;
1548     BTM_TRACE_DEBUG ("BTM_AllocateSCN");
1549
1550     // stack reserves scn 1 for HFP, HSP we still do the correct way
1551     for (x = 1; x < BTM_MAX_SCN; x++)
1552     {
1553         if (!btm_cb.btm_scn[x])
1554         {
1555             btm_cb.btm_scn[x] = TRUE;
1556             return(x+1);
1557         }
1558     }
1559
1560     return(0);     /* No free ports */
1561 }
1562
1563 /*******************************************************************************
1564 **
1565 ** Function         BTM_TryAllocateSCN
1566 **
1567 ** Description      Try to allocate a fixed server channel
1568 **
1569 ** Returns          Returns TRUE if server channel was available
1570 **
1571 *******************************************************************************/
1572
1573 BOOLEAN BTM_TryAllocateSCN(UINT8 scn)
1574 {
1575     /* Make sure we don't exceed max port range.
1576      * Stack reserves scn 1 for HFP, HSP we still do the correct way.
1577      */
1578     if ( (scn>=BTM_MAX_SCN) || (scn == 1) )
1579         return FALSE;
1580
1581     /* check if this port is available */
1582     if (!btm_cb.btm_scn[scn-1])
1583     {
1584         btm_cb.btm_scn[scn-1] = TRUE;
1585         return TRUE;
1586     }
1587
1588     return (FALSE);     /* Port was busy */
1589 }
1590
1591 /*******************************************************************************
1592 **
1593 ** Function         BTM_FreeSCN
1594 **
1595 ** Description      Free the specified SCN.
1596 **
1597 ** Returns          TRUE or FALSE
1598 **
1599 *******************************************************************************/
1600 BOOLEAN BTM_FreeSCN(UINT8 scn)
1601 {
1602     BTM_TRACE_DEBUG ("BTM_FreeSCN ");
1603     if (scn <= BTM_MAX_SCN)
1604     {
1605         btm_cb.btm_scn[scn-1] = FALSE;
1606         return(TRUE);
1607     }
1608     else
1609         return(FALSE);      /* Illegal SCN passed in */
1610 }
1611
1612 /*******************************************************************************
1613 **
1614 ** Function         btm_set_packet_types
1615 **
1616 ** Description      This function sets the packet types used for a specific
1617 **                  ACL connection. It is called internally by btm_acl_created
1618 **                  or by an application/profile by BTM_SetPacketTypes.
1619 **
1620 ** Returns          status of the operation
1621 **
1622 *******************************************************************************/
1623 tBTM_STATUS btm_set_packet_types (tACL_CONN *p, UINT16 pkt_types)
1624 {
1625     UINT16 temp_pkt_types;
1626     BTM_TRACE_DEBUG ("btm_set_packet_types");
1627     /* Save in the ACL control blocks, types that we support */
1628     temp_pkt_types = (pkt_types & BTM_ACL_SUPPORTED_PKTS_MASK &
1629                       btm_cb.btm_acl_pkt_types_supported);
1630
1631     /* OR in any exception packet types if at least 2.0 version of spec */
1632     temp_pkt_types |= ((pkt_types & BTM_ACL_EXCEPTION_PKTS_MASK) |
1633                        (btm_cb.btm_acl_pkt_types_supported & BTM_ACL_EXCEPTION_PKTS_MASK));
1634
1635     /* Exclude packet types not supported by the peer */
1636     btm_acl_chk_peer_pkt_type_support (p, &temp_pkt_types);
1637
1638     BTM_TRACE_DEBUG ("SetPacketType Mask -> 0x%04x", temp_pkt_types);
1639
1640     if (!btsnd_hcic_change_conn_type (p->hci_handle, temp_pkt_types))
1641     {
1642         return(BTM_NO_RESOURCES);
1643     }
1644
1645     p->pkt_types_mask = temp_pkt_types;
1646
1647     return(BTM_CMD_STARTED);
1648 }
1649
1650 /*******************************************************************************
1651 **
1652 ** Function         btm_get_max_packet_size
1653 **
1654 ** Returns          Returns maximum packet size that can be used for current
1655 **                  connection, 0 if connection is not established
1656 **
1657 *******************************************************************************/
1658 UINT16 btm_get_max_packet_size (BD_ADDR addr)
1659 {
1660     tACL_CONN   *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1661     UINT16      pkt_types = 0;
1662     UINT16      pkt_size = 0;
1663     BTM_TRACE_DEBUG ("btm_get_max_packet_size");
1664     if (p != NULL)
1665     {
1666         pkt_types = p->pkt_types_mask;
1667     }
1668     else
1669     {
1670         /* Special case for when info for the local device is requested */
1671         if (memcmp (controller_get_interface()->get_address(), addr, BD_ADDR_LEN) == 0)
1672         {
1673             pkt_types = btm_cb.btm_acl_pkt_types_supported;
1674         }
1675     }
1676
1677     if (pkt_types)
1678     {
1679         if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH5))
1680             pkt_size = HCI_EDR3_DH5_PACKET_SIZE;
1681         else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH5))
1682             pkt_size = HCI_EDR2_DH5_PACKET_SIZE;
1683         else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH3))
1684             pkt_size = HCI_EDR3_DH3_PACKET_SIZE;
1685         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH5)
1686             pkt_size = HCI_DH5_PACKET_SIZE;
1687         else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH3))
1688             pkt_size = HCI_EDR2_DH3_PACKET_SIZE;
1689         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM5)
1690             pkt_size = HCI_DM5_PACKET_SIZE;
1691         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH3)
1692             pkt_size = HCI_DH3_PACKET_SIZE;
1693         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM3)
1694             pkt_size = HCI_DM3_PACKET_SIZE;
1695         else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_3_DH1))
1696             pkt_size = HCI_EDR3_DH1_PACKET_SIZE;
1697         else if (!(pkt_types & BTM_ACL_PKT_TYPES_MASK_NO_2_DH1))
1698             pkt_size = HCI_EDR2_DH1_PACKET_SIZE;
1699         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DH1)
1700             pkt_size = HCI_DH1_PACKET_SIZE;
1701         else if (pkt_types & BTM_ACL_PKT_TYPES_MASK_DM1)
1702             pkt_size = HCI_DM1_PACKET_SIZE;
1703     }
1704
1705    return(pkt_size);
1706 }
1707
1708 /*******************************************************************************
1709 **
1710 ** Function         BTM_ReadRemoteVersion
1711 **
1712 ** Returns          If connected report peer device info
1713 **
1714 *******************************************************************************/
1715 tBTM_STATUS BTM_ReadRemoteVersion (BD_ADDR addr, UINT8 *lmp_version,
1716                                    UINT16 *manufacturer, UINT16 *lmp_sub_version)
1717 {
1718     tACL_CONN        *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1719     BTM_TRACE_DEBUG ("BTM_ReadRemoteVersion");
1720     if (p == NULL)
1721         return(BTM_UNKNOWN_ADDR);
1722
1723     if (lmp_version)
1724         *lmp_version = p->lmp_version;
1725
1726     if (manufacturer)
1727         *manufacturer = p->manufacturer;
1728
1729     if (lmp_sub_version)
1730         *lmp_sub_version = p->lmp_subversion;
1731
1732     return(BTM_SUCCESS);
1733 }
1734
1735 /*******************************************************************************
1736 **
1737 ** Function         BTM_ReadRemoteFeatures
1738 **
1739 ** Returns          pointer to the remote supported features mask (8 bytes)
1740 **
1741 *******************************************************************************/
1742 UINT8 *BTM_ReadRemoteFeatures (BD_ADDR addr)
1743 {
1744     tACL_CONN        *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1745     BTM_TRACE_DEBUG ("BTM_ReadRemoteFeatures");
1746     if (p == NULL)
1747     {
1748         return(NULL);
1749     }
1750
1751     return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]);
1752 }
1753
1754 /*******************************************************************************
1755 **
1756 ** Function         BTM_ReadRemoteExtendedFeatures
1757 **
1758 ** Returns          pointer to the remote extended features mask (8 bytes)
1759 **                  or NULL if bad page
1760 **
1761 *******************************************************************************/
1762 UINT8 *BTM_ReadRemoteExtendedFeatures (BD_ADDR addr, UINT8 page_number)
1763 {
1764     tACL_CONN        *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1765     BTM_TRACE_DEBUG ("BTM_ReadRemoteExtendedFeatures");
1766     if (p == NULL)
1767     {
1768         return(NULL);
1769     }
1770
1771     if (page_number > HCI_EXT_FEATURES_PAGE_MAX)
1772     {
1773         BTM_TRACE_ERROR("Warning: BTM_ReadRemoteExtendedFeatures page %d unknown", page_number);
1774         return NULL;
1775     }
1776
1777     return(p->peer_lmp_features[page_number]);
1778 }
1779
1780 /*******************************************************************************
1781 **
1782 ** Function         BTM_ReadNumberRemoteFeaturesPages
1783 **
1784 ** Returns          number of features pages read from the remote device.
1785 **
1786 *******************************************************************************/
1787 UINT8 BTM_ReadNumberRemoteFeaturesPages (BD_ADDR addr)
1788 {
1789     tACL_CONN        *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1790     BTM_TRACE_DEBUG ("BTM_ReadNumberRemoteFeaturesPages");
1791     if (p == NULL)
1792     {
1793         return(0);
1794     }
1795
1796     return(p->num_read_pages);
1797 }
1798
1799 /*******************************************************************************
1800 **
1801 ** Function         BTM_ReadAllRemoteFeatures
1802 **
1803 ** Returns          pointer to all features of the remote (24 bytes).
1804 **
1805 *******************************************************************************/
1806 UINT8 *BTM_ReadAllRemoteFeatures (BD_ADDR addr)
1807 {
1808     tACL_CONN        *p = btm_bda_to_acl(addr, BT_TRANSPORT_BR_EDR);
1809     BTM_TRACE_DEBUG ("BTM_ReadAllRemoteFeatures");
1810     if (p == NULL)
1811     {
1812         return(NULL);
1813     }
1814
1815     return(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]);
1816 }
1817
1818 /*******************************************************************************
1819 **
1820 ** Function         BTM_RegBusyLevelNotif
1821 **
1822 ** Description      This function is called to register a callback to receive
1823 **                  busy level change events.
1824 **
1825 ** Returns          BTM_SUCCESS if successfully registered, otherwise error
1826 **
1827 *******************************************************************************/
1828 tBTM_STATUS BTM_RegBusyLevelNotif (tBTM_BL_CHANGE_CB *p_cb, UINT8 *p_level,
1829                                    tBTM_BL_EVENT_MASK evt_mask)
1830 {
1831     BTM_TRACE_DEBUG ("BTM_RegBusyLevelNotif");
1832     if (p_level)
1833         *p_level = btm_cb.busy_level;
1834
1835     btm_cb.bl_evt_mask = evt_mask;
1836
1837     if (!p_cb)
1838         btm_cb.p_bl_changed_cb = NULL;
1839     else if (btm_cb.p_bl_changed_cb)
1840         return(BTM_BUSY);
1841     else
1842         btm_cb.p_bl_changed_cb = p_cb;
1843
1844     return(BTM_SUCCESS);
1845 }
1846
1847 /*******************************************************************************
1848 **
1849 ** Function         BTM_SetQoS
1850 **
1851 ** Description      This function is called to setup QoS
1852 **
1853 ** Returns          status of the operation
1854 **
1855 *******************************************************************************/
1856 tBTM_STATUS BTM_SetQoS (BD_ADDR bd, FLOW_SPEC *p_flow, tBTM_CMPL_CB *p_cb)
1857 {
1858     tACL_CONN   *p = &btm_cb.acl_db[0];
1859
1860     BTM_TRACE_API ("BTM_SetQoS: BdAddr: %02x%02x%02x%02x%02x%02x",
1861                     bd[0], bd[1], bd[2],
1862                     bd[3], bd[4], bd[5]);
1863
1864     /* If someone already waiting on the version, do not allow another */
1865     if (btm_cb.devcb.p_qossu_cmpl_cb)
1866         return(BTM_BUSY);
1867
1868     if ( (p = btm_bda_to_acl(bd, BT_TRANSPORT_BR_EDR)) != NULL)
1869     {
1870         btu_start_timer (&btm_cb.devcb.qossu_timer, BTU_TTYPE_BTM_ACL, BTM_DEV_REPLY_TIMEOUT);
1871         btm_cb.devcb.p_qossu_cmpl_cb = p_cb;
1872
1873         if (!btsnd_hcic_qos_setup (p->hci_handle, p_flow->qos_flags, p_flow->service_type,
1874                                    p_flow->token_rate, p_flow->peak_bandwidth,
1875                                    p_flow->latency,p_flow->delay_variation))
1876         {
1877             btm_cb.devcb.p_qossu_cmpl_cb = NULL;
1878             btu_stop_timer(&btm_cb.devcb.qossu_timer);
1879             return(BTM_NO_RESOURCES);
1880         }
1881         else
1882             return(BTM_CMD_STARTED);
1883     }
1884
1885     /* If here, no BD Addr found */
1886     return(BTM_UNKNOWN_ADDR);
1887 }
1888
1889 /*******************************************************************************
1890 **
1891 ** Function         btm_qos_setup_complete
1892 **
1893 ** Description      This function is called when the command complete message
1894 **                  is received from the HCI for the qos setup request.
1895 **
1896 ** Returns          void
1897 **
1898 *******************************************************************************/
1899 void btm_qos_setup_complete (UINT8 status, UINT16 handle, FLOW_SPEC *p_flow)
1900 {
1901     tBTM_CMPL_CB            *p_cb = btm_cb.devcb.p_qossu_cmpl_cb;
1902     tBTM_QOS_SETUP_CMPL     qossu;
1903     BTM_TRACE_DEBUG ("btm_qos_setup_complete");
1904     btu_stop_timer (&btm_cb.devcb.qossu_timer);
1905
1906     btm_cb.devcb.p_qossu_cmpl_cb = NULL;
1907
1908     if (p_cb)
1909     {
1910         memset(&qossu, 0, sizeof(tBTM_QOS_SETUP_CMPL));
1911         qossu.status = status;
1912         qossu.handle = handle;
1913         if (p_flow != NULL)
1914         {
1915             qossu.flow.qos_flags = p_flow->qos_flags;
1916             qossu.flow.service_type = p_flow->service_type;
1917             qossu.flow.token_rate = p_flow->token_rate;
1918             qossu.flow.peak_bandwidth = p_flow->peak_bandwidth;
1919             qossu.flow.latency = p_flow->latency;
1920             qossu.flow.delay_variation = p_flow->delay_variation;
1921         }
1922         BTM_TRACE_DEBUG ("BTM: p_flow->delay_variation: 0x%02x",
1923                           qossu.flow.delay_variation);
1924         (*p_cb)(&qossu);
1925     }
1926 }
1927
1928
1929 /*******************************************************************************
1930 **
1931 ** Function         BTM_ReadRSSI
1932 **
1933 ** Description      This function is called to read the link policy settings.
1934 **                  The address of link policy results are returned in the callback.
1935 **                  (tBTM_RSSI_RESULTS)
1936 **
1937 ** Returns          BTM_CMD_STARTED if successfully initiated or error code
1938 **
1939 *******************************************************************************/
1940 tBTM_STATUS BTM_ReadRSSI (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
1941 {
1942     tACL_CONN   *p;
1943     tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
1944 #if BLE_INCLUDED == TRUE
1945     tBT_DEVICE_TYPE dev_type;
1946     tBLE_ADDR_TYPE  addr_type;
1947 #endif
1948     BTM_TRACE_API ("BTM_ReadRSSI: RemBdAddr: %02x%02x%02x%02x%02x%02x",
1949                     remote_bda[0], remote_bda[1], remote_bda[2],
1950                     remote_bda[3], remote_bda[4], remote_bda[5]);
1951
1952     /* If someone already waiting on the version, do not allow another */
1953     if (btm_cb.devcb.p_rssi_cmpl_cb)
1954         return(BTM_BUSY);
1955
1956 #if BLE_INCLUDED == TRUE
1957     BTM_ReadDevInfo(remote_bda, &dev_type, &addr_type);
1958     if (dev_type == BT_DEVICE_TYPE_BLE)
1959         transport = BT_TRANSPORT_LE;
1960 #endif
1961
1962     p = btm_bda_to_acl(remote_bda, transport);
1963     if (p != (tACL_CONN *)NULL)
1964     {
1965         btu_start_timer (&btm_cb.devcb.rssi_timer, BTU_TTYPE_BTM_ACL,
1966                          BTM_DEV_REPLY_TIMEOUT);
1967
1968         btm_cb.devcb.p_rssi_cmpl_cb = p_cb;
1969
1970         if (!btsnd_hcic_read_rssi (p->hci_handle))
1971         {
1972             btm_cb.devcb.p_rssi_cmpl_cb = NULL;
1973             btu_stop_timer (&btm_cb.devcb.rssi_timer);
1974             return(BTM_NO_RESOURCES);
1975         }
1976         else
1977             return(BTM_CMD_STARTED);
1978     }
1979
1980     /* If here, no BD Addr found */
1981     return(BTM_UNKNOWN_ADDR);
1982 }
1983
1984 /*******************************************************************************
1985 **
1986 ** Function         BTM_ReadLinkQuality
1987 **
1988 ** Description      This function is called to read the link qulaity.
1989 **                  The value of the link quality is returned in the callback.
1990 **                  (tBTM_LINK_QUALITY_RESULTS)
1991 **
1992 ** Returns          BTM_CMD_STARTED if successfully initiated or error code
1993 **
1994 *******************************************************************************/
1995 tBTM_STATUS BTM_ReadLinkQuality (BD_ADDR remote_bda, tBTM_CMPL_CB *p_cb)
1996 {
1997     tACL_CONN   *p;
1998
1999     BTM_TRACE_API ("BTM_ReadLinkQuality: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2000                     remote_bda[0], remote_bda[1], remote_bda[2],
2001                     remote_bda[3], remote_bda[4], remote_bda[5]);
2002
2003     /* If someone already waiting on the version, do not allow another */
2004     if (btm_cb.devcb.p_lnk_qual_cmpl_cb)
2005         return(BTM_BUSY);
2006
2007     p = btm_bda_to_acl(remote_bda, BT_TRANSPORT_BR_EDR);
2008     if (p != (tACL_CONN *)NULL)
2009     {
2010         btu_start_timer (&btm_cb.devcb.lnk_quality_timer, BTU_TTYPE_BTM_ACL,
2011                          BTM_DEV_REPLY_TIMEOUT);
2012         btm_cb.devcb.p_lnk_qual_cmpl_cb = p_cb;
2013
2014         if (!btsnd_hcic_get_link_quality (p->hci_handle))
2015         {
2016             btu_stop_timer (&btm_cb.devcb.lnk_quality_timer);
2017             btm_cb.devcb.p_lnk_qual_cmpl_cb = NULL;
2018             return(BTM_NO_RESOURCES);
2019         }
2020         else
2021             return(BTM_CMD_STARTED);
2022     }
2023
2024     /* If here, no BD Addr found */
2025     return(BTM_UNKNOWN_ADDR);
2026 }
2027
2028 /*******************************************************************************
2029 **
2030 ** Function         BTM_ReadTxPower
2031 **
2032 ** Description      This function is called to read the current
2033 **                  TX power of the connection. The tx power level results
2034 **                  are returned in the callback.
2035 **                  (tBTM_RSSI_RESULTS)
2036 **
2037 ** Returns          BTM_CMD_STARTED if successfully initiated or error code
2038 **
2039 *******************************************************************************/
2040 tBTM_STATUS BTM_ReadTxPower (BD_ADDR remote_bda, tBT_TRANSPORT transport, tBTM_CMPL_CB *p_cb)
2041 {
2042     tACL_CONN   *p;
2043     BOOLEAN     ret;
2044 #define BTM_READ_RSSI_TYPE_CUR  0x00
2045 #define BTM_READ_RSSI_TYPE_MAX  0X01
2046
2047     BTM_TRACE_API ("BTM_ReadTxPower: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2048                     remote_bda[0], remote_bda[1], remote_bda[2],
2049                     remote_bda[3], remote_bda[4], remote_bda[5]);
2050
2051     /* If someone already waiting on the version, do not allow another */
2052     if (btm_cb.devcb.p_tx_power_cmpl_cb)
2053         return(BTM_BUSY);
2054
2055     p = btm_bda_to_acl(remote_bda, transport);
2056     if (p != (tACL_CONN *)NULL)
2057     {
2058         btu_start_timer (&btm_cb.devcb.tx_power_timer, BTU_TTYPE_BTM_ACL,
2059                          BTM_DEV_REPLY_TIMEOUT);
2060
2061         btm_cb.devcb.p_tx_power_cmpl_cb = p_cb;
2062
2063 #if BLE_INCLUDED == TRUE
2064         if (p->transport == BT_TRANSPORT_LE)
2065         {
2066             memcpy(btm_cb.devcb.read_tx_pwr_addr, remote_bda, BD_ADDR_LEN);
2067             ret = btsnd_hcic_ble_read_adv_chnl_tx_power();
2068         }
2069         else
2070 #endif
2071         {
2072             ret = btsnd_hcic_read_tx_power (p->hci_handle, BTM_READ_RSSI_TYPE_CUR);
2073         }
2074         if (!ret)
2075         {
2076             btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
2077             btu_stop_timer (&btm_cb.devcb.tx_power_timer);
2078             return(BTM_NO_RESOURCES);
2079         }
2080         else
2081             return(BTM_CMD_STARTED);
2082     }
2083
2084     /* If here, no BD Addr found */
2085     return (BTM_UNKNOWN_ADDR);
2086 }
2087 /*******************************************************************************
2088 **
2089 ** Function         btm_read_tx_power_complete
2090 **
2091 ** Description      This function is called when the command complete message
2092 **                  is received from the HCI for the read tx power request.
2093 **
2094 ** Returns          void
2095 **
2096 *******************************************************************************/
2097 void btm_read_tx_power_complete (UINT8 *p, BOOLEAN is_ble)
2098 {
2099     tBTM_CMPL_CB            *p_cb = btm_cb.devcb.p_tx_power_cmpl_cb;
2100     tBTM_TX_POWER_RESULTS   results;
2101     UINT16                   handle;
2102     tACL_CONN               *p_acl_cb = &btm_cb.acl_db[0];
2103     UINT16                   index;
2104     BTM_TRACE_DEBUG ("btm_read_tx_power_complete");
2105     btu_stop_timer (&btm_cb.devcb.tx_power_timer);
2106
2107     /* If there was a callback registered for read rssi, call it */
2108     btm_cb.devcb.p_tx_power_cmpl_cb = NULL;
2109
2110     if (p_cb)
2111     {
2112         STREAM_TO_UINT8  (results.hci_status, p);
2113
2114         if (results.hci_status == HCI_SUCCESS)
2115         {
2116             results.status = BTM_SUCCESS;
2117
2118             if (!is_ble)
2119             {
2120                 STREAM_TO_UINT16 (handle, p);
2121                 STREAM_TO_UINT8 (results.tx_power, p);
2122
2123                 /* Search through the list of active channels for the correct BD Addr */
2124                 for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
2125                 {
2126                     if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
2127                     {
2128                         memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
2129                         break;
2130                     }
2131                 }
2132             }
2133 #if BLE_INCLUDED == TRUE
2134             else
2135             {
2136                 STREAM_TO_UINT8 (results.tx_power, p);
2137                 memcpy(results.rem_bda, btm_cb.devcb.read_tx_pwr_addr, BD_ADDR_LEN);
2138             }
2139 #endif
2140             BTM_TRACE_DEBUG ("BTM TX power Complete: tx_power %d, hci status 0x%02x",
2141                                   results.tx_power, results.hci_status);
2142         }
2143         else
2144             results.status = BTM_ERR_PROCESSING;
2145
2146         (*p_cb)(&results);
2147     }
2148 }
2149
2150 /*******************************************************************************
2151 **
2152 ** Function         btm_read_rssi_complete
2153 **
2154 ** Description      This function is called when the command complete message
2155 **                  is received from the HCI for the read rssi request.
2156 **
2157 ** Returns          void
2158 **
2159 *******************************************************************************/
2160 void btm_read_rssi_complete (UINT8 *p)
2161 {
2162     tBTM_CMPL_CB            *p_cb = btm_cb.devcb.p_rssi_cmpl_cb;
2163     tBTM_RSSI_RESULTS        results;
2164     UINT16                   handle;
2165     tACL_CONN               *p_acl_cb = &btm_cb.acl_db[0];
2166     UINT16                   index;
2167     BTM_TRACE_DEBUG ("btm_read_rssi_complete");
2168     btu_stop_timer (&btm_cb.devcb.rssi_timer);
2169
2170     /* If there was a callback registered for read rssi, call it */
2171     btm_cb.devcb.p_rssi_cmpl_cb = NULL;
2172
2173     if (p_cb)
2174     {
2175         STREAM_TO_UINT8  (results.hci_status, p);
2176
2177         if (results.hci_status == HCI_SUCCESS)
2178         {
2179             results.status = BTM_SUCCESS;
2180
2181             STREAM_TO_UINT16 (handle, p);
2182
2183             STREAM_TO_UINT8 (results.rssi, p);
2184             BTM_TRACE_DEBUG ("BTM RSSI Complete: rssi %d, hci status 0x%02x",
2185                               results.rssi, results.hci_status);
2186
2187             /* Search through the list of active channels for the correct BD Addr */
2188             for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
2189             {
2190                 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
2191                 {
2192                     memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
2193                     break;
2194                 }
2195             }
2196         }
2197         else
2198             results.status = BTM_ERR_PROCESSING;
2199
2200         (*p_cb)(&results);
2201     }
2202 }
2203
2204 /*******************************************************************************
2205 **
2206 ** Function         btm_read_link_quality_complete
2207 **
2208 ** Description      This function is called when the command complete message
2209 **                  is received from the HCI for the read link quality.
2210 **
2211 ** Returns          void
2212 **
2213 *******************************************************************************/
2214 void btm_read_link_quality_complete (UINT8 *p)
2215 {
2216     tBTM_CMPL_CB            *p_cb = btm_cb.devcb.p_lnk_qual_cmpl_cb;
2217     tBTM_LINK_QUALITY_RESULTS results;
2218     UINT16                   handle;
2219     tACL_CONN               *p_acl_cb = &btm_cb.acl_db[0];
2220     UINT16                   index;
2221     BTM_TRACE_DEBUG ("btm_read_link_quality_complete");
2222     btu_stop_timer (&btm_cb.devcb.lnk_quality_timer);
2223
2224     /* If there was a callback registered for read rssi, call it */
2225     btm_cb.devcb.p_lnk_qual_cmpl_cb = NULL;
2226
2227     if (p_cb)
2228     {
2229         STREAM_TO_UINT8  (results.hci_status, p);
2230
2231         if (results.hci_status == HCI_SUCCESS)
2232         {
2233             results.status = BTM_SUCCESS;
2234
2235             STREAM_TO_UINT16 (handle, p);
2236
2237             STREAM_TO_UINT8 (results.link_quality, p);
2238             BTM_TRACE_DEBUG ("BTM Link Quality Complete: Link Quality %d, hci status 0x%02x",
2239                               results.link_quality, results.hci_status);
2240
2241             /* Search through the list of active channels for the correct BD Addr */
2242             for (index = 0; index < MAX_L2CAP_LINKS; index++, p_acl_cb++)
2243             {
2244                 if ((p_acl_cb->in_use) && (handle == p_acl_cb->hci_handle))
2245                 {
2246                     memcpy (results.rem_bda, p_acl_cb->remote_addr, BD_ADDR_LEN);
2247                     break;
2248                 }
2249             }
2250         }
2251         else
2252             results.status = BTM_ERR_PROCESSING;
2253
2254         (*p_cb)(&results);
2255     }
2256 }
2257
2258 /*******************************************************************************
2259 **
2260 ** Function         btm_remove_acl
2261 **
2262 ** Description      This function is called to disconnect an ACL connection
2263 **
2264 ** Returns          BTM_SUCCESS if successfully initiated, otherwise BTM_NO_RESOURCES.
2265 **
2266 *******************************************************************************/
2267 tBTM_STATUS btm_remove_acl (BD_ADDR bd_addr, tBT_TRANSPORT transport)
2268 {
2269     UINT16  hci_handle = BTM_GetHCIConnHandle(bd_addr, transport);
2270     tBTM_STATUS status = BTM_SUCCESS;
2271
2272     BTM_TRACE_DEBUG ("btm_remove_acl");
2273 #if BTM_DISC_DURING_RS == TRUE
2274     tBTM_SEC_DEV_REC  *p_dev_rec = btm_find_dev (bd_addr);
2275
2276     /* Role Switch is pending, postpone until completed */
2277     if (p_dev_rec && (p_dev_rec->rs_disc_pending == BTM_SEC_RS_PENDING))
2278     {
2279         p_dev_rec->rs_disc_pending = BTM_SEC_DISC_PENDING;
2280     }
2281     else    /* otherwise can disconnect right away */
2282 #endif
2283     {
2284         if (hci_handle != 0xFFFF && p_dev_rec &&
2285              p_dev_rec->sec_state!= BTM_SEC_STATE_DISCONNECTING)
2286         {
2287             if (!btsnd_hcic_disconnect (hci_handle, HCI_ERR_PEER_USER))
2288                 status = BTM_NO_RESOURCES;
2289         }
2290         else
2291             status = BTM_UNKNOWN_ADDR;
2292     }
2293
2294     return status;
2295 }
2296
2297
2298 /*******************************************************************************
2299 **
2300 ** Function         BTM_SetTraceLevel
2301 **
2302 ** Description      This function sets the trace level for BTM.  If called with
2303 **                  a value of 0xFF, it simply returns the current trace level.
2304 **
2305 ** Returns          The new or current trace level
2306 **
2307 *******************************************************************************/
2308 UINT8 BTM_SetTraceLevel (UINT8 new_level)
2309 {
2310     BTM_TRACE_DEBUG ("BTM_SetTraceLevel");
2311     if (new_level != 0xFF)
2312         btm_cb.trace_level = new_level;
2313
2314     return(btm_cb.trace_level);
2315 }
2316
2317 /*******************************************************************************
2318 **
2319 ** Function         btm_cont_rswitch
2320 **
2321 ** Description      This function is called to continue processing an active
2322 **                  role switch. It first disables encryption if enabled and
2323 **                  EPR is not supported
2324 **
2325 ** Returns          void
2326 **
2327 *******************************************************************************/
2328 void btm_cont_rswitch (tACL_CONN *p, tBTM_SEC_DEV_REC *p_dev_rec,
2329                                      UINT8 hci_status)
2330 {
2331     BOOLEAN sw_ok = TRUE;
2332     BTM_TRACE_DEBUG ("btm_cont_rswitch");
2333     /* Check to see if encryption needs to be turned off if pending
2334        change of link key or role switch */
2335     if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
2336     {
2337         /* Must turn off Encryption first if necessary */
2338         /* Some devices do not support switch or change of link key while encryption is on */
2339         if (p_dev_rec != NULL && ((p_dev_rec->sec_flags & BTM_SEC_ENCRYPTED) != 0)
2340             && !BTM_EPR_AVAILABLE(p))
2341         {
2342             if (btsnd_hcic_set_conn_encrypt (p->hci_handle, FALSE))
2343             {
2344                 p->encrypt_state = BTM_ACL_ENCRYPT_STATE_ENCRYPT_OFF;
2345                 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
2346                     p->switch_role_state = BTM_ACL_SWKEY_STATE_ENCRYPTION_OFF;
2347             }
2348             else
2349             {
2350                 /* Error occurred; set states back to Idle */
2351                 if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
2352                     sw_ok = FALSE;
2353             }
2354         }
2355         else    /* Encryption not used or EPR supported, continue with switch
2356                    and/or change of link key */
2357         {
2358             if (p->switch_role_state == BTM_ACL_SWKEY_STATE_MODE_CHANGE)
2359             {
2360                 p->switch_role_state = BTM_ACL_SWKEY_STATE_IN_PROGRESS;
2361 #if BTM_DISC_DURING_RS == TRUE
2362                 if (p_dev_rec)
2363                     p_dev_rec->rs_disc_pending = BTM_SEC_RS_PENDING;
2364 #endif
2365                 sw_ok = btsnd_hcic_switch_role (p->remote_addr, (UINT8)!p->link_role);
2366             }
2367         }
2368
2369         if (!sw_ok)
2370         {
2371             p->switch_role_state = BTM_ACL_SWKEY_STATE_IDLE;
2372             btm_acl_report_role_change(hci_status, p->remote_addr);
2373         }
2374     }
2375 }
2376
2377 /*******************************************************************************
2378 **
2379 ** Function         btm_acl_resubmit_page
2380 **
2381 ** Description      send pending page request
2382 **
2383 *******************************************************************************/
2384 void btm_acl_resubmit_page (void)
2385 {
2386     tBTM_SEC_DEV_REC *p_dev_rec;
2387     BT_HDR  *p_buf;
2388     UINT8   *pp;
2389     BD_ADDR bda;
2390     BTM_TRACE_DEBUG ("btm_acl_resubmit_page");
2391     /* If there were other page request schedule can start the next one */
2392     if ((p_buf = (BT_HDR *)GKI_dequeue (&btm_cb.page_queue)) != NULL)
2393     {
2394         /* skip 3 (2 bytes opcode and 1 byte len) to get to the bd_addr
2395          * for both create_conn and rmt_name */
2396         pp = (UINT8 *)(p_buf + 1) + p_buf->offset + 3;
2397
2398         STREAM_TO_BDADDR (bda, pp);
2399
2400         p_dev_rec = btm_find_or_alloc_dev (bda);
2401
2402         memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr,   BD_ADDR_LEN);
2403         memcpy (btm_cb.connecting_dc,  p_dev_rec->dev_class, DEV_CLASS_LEN);
2404
2405         btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p_buf);
2406     }
2407     else
2408         btm_cb.paging = FALSE;
2409 }
2410
2411 /*******************************************************************************
2412 **
2413 ** Function         btm_acl_reset_paging
2414 **
2415 ** Description      set paging to FALSE and free the page queue - called at hci_reset
2416 **
2417 *******************************************************************************/
2418 void  btm_acl_reset_paging (void)
2419 {
2420     BT_HDR *p;
2421     BTM_TRACE_DEBUG ("btm_acl_reset_paging");
2422     /* If we sent reset we are definitely not paging any more */
2423     while ((p = (BT_HDR *)GKI_dequeue(&btm_cb.page_queue)) != NULL)
2424         GKI_freebuf (p);
2425
2426     btm_cb.paging = FALSE;
2427 }
2428
2429 /*******************************************************************************
2430 **
2431 ** Function         btm_acl_paging
2432 **
2433 ** Description      send a paging command or queue it in btm_cb
2434 **
2435 *******************************************************************************/
2436 void  btm_acl_paging (BT_HDR *p, BD_ADDR bda)
2437 {
2438     tBTM_SEC_DEV_REC *p_dev_rec;
2439
2440     BTM_TRACE_DEBUG ("btm_acl_paging discing:%d, paging:%d BDA: %06x%06x",
2441                       btm_cb.discing, btm_cb.paging,
2442                       (bda[0]<<16) + (bda[1]<<8) + bda[2], (bda[3]<<16) + (bda[4] << 8) + bda[5]);
2443     if (btm_cb.discing)
2444     {
2445         btm_cb.paging = TRUE;
2446         GKI_enqueue (&btm_cb.page_queue, p);
2447     }
2448     else
2449     {
2450         if (!BTM_ACL_IS_CONNECTED (bda))
2451         {
2452             BTM_TRACE_DEBUG ("connecting_bda: %06x%06x",
2453                               (btm_cb.connecting_bda[0]<<16) + (btm_cb.connecting_bda[1]<<8) +
2454                                btm_cb.connecting_bda[2],
2455                               (btm_cb.connecting_bda[3]<<16) + (btm_cb.connecting_bda[4] << 8) +
2456                                btm_cb.connecting_bda[5]);
2457             if (btm_cb.paging &&
2458                 memcmp (bda, btm_cb.connecting_bda, BD_ADDR_LEN) != 0)
2459             {
2460                 GKI_enqueue (&btm_cb.page_queue, p);
2461             }
2462             else
2463             {
2464                 p_dev_rec = btm_find_or_alloc_dev (bda);
2465                 memcpy (btm_cb.connecting_bda, p_dev_rec->bd_addr,   BD_ADDR_LEN);
2466                 memcpy (btm_cb.connecting_dc,  p_dev_rec->dev_class, DEV_CLASS_LEN);
2467
2468                 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2469             }
2470
2471             btm_cb.paging = TRUE;
2472         }
2473         else /* ACL is already up */
2474         {
2475             btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2476         }
2477     }
2478 }
2479
2480 /*******************************************************************************
2481 **
2482 ** Function         btm_acl_notif_conn_collision
2483 **
2484 ** Description      Send connection collision event to upper layer if registered
2485 **
2486 ** Returns          TRUE if sent out to upper layer,
2487 **                  FALSE if no one needs the notification.
2488 **
2489 *******************************************************************************/
2490 BOOLEAN  btm_acl_notif_conn_collision (BD_ADDR bda)
2491 {
2492     tBTM_BL_EVENT_DATA  evt_data;
2493
2494     /* Report possible collision to the upper layer. */
2495     if (btm_cb.p_bl_changed_cb)
2496     {
2497         BTM_TRACE_DEBUG ("btm_acl_notif_conn_collision: RemBdAddr: %02x%02x%02x%02x%02x%02x",
2498                           bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
2499
2500         evt_data.event = BTM_BL_COLLISION_EVT;
2501         evt_data.conn.p_bda = bda;
2502
2503 #if BLE_INCLUDED == TRUE
2504         evt_data.conn.transport = BT_TRANSPORT_BR_EDR;
2505         evt_data.conn.handle = BTM_INVALID_HCI_HANDLE;
2506 #endif
2507         (*btm_cb.p_bl_changed_cb)(&evt_data);
2508         return TRUE;
2509     }
2510     else
2511         return FALSE;
2512 }
2513
2514
2515 /*******************************************************************************
2516 **
2517 ** Function         btm_acl_chk_peer_pkt_type_support
2518 **
2519 ** Description      Check if peer supports requested packets
2520 **
2521 *******************************************************************************/
2522 void btm_acl_chk_peer_pkt_type_support (tACL_CONN *p, UINT16 *p_pkt_type)
2523 {
2524     /* 3 and 5 slot packets? */
2525     if (!HCI_3_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2526         *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH3 +BTM_ACL_PKT_TYPES_MASK_DM3);
2527
2528     if (!HCI_5_SLOT_PACKETS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2529         *p_pkt_type &= ~(BTM_ACL_PKT_TYPES_MASK_DH5 + BTM_ACL_PKT_TYPES_MASK_DM5);
2530
2531     /* 2 and 3 MPS support? */
2532     if (!HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2533         /* Not supported. Add 'not_supported' mask for all 2MPS packet types */
2534         *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 +
2535                             BTM_ACL_PKT_TYPES_MASK_NO_2_DH5);
2536
2537     if (!HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2538         /* Not supported. Add 'not_supported' mask for all 3MPS packet types */
2539         *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_3_DH1 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3 +
2540                             BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
2541
2542     /* EDR 3 and 5 slot support? */
2543     if (HCI_EDR_ACL_2MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0])
2544      || HCI_EDR_ACL_3MPS_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2545     {
2546         if (!HCI_3_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2547             /* Not supported. Add 'not_supported' mask for all 3-slot EDR packet types */
2548             *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH3 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH3);
2549
2550         if (!HCI_5_SLOT_EDR_ACL_SUPPORTED(p->peer_lmp_features[HCI_EXT_FEATURES_PAGE_0]))
2551             /* Not supported. Add 'not_supported' mask for all 5-slot EDR packet types */
2552             *p_pkt_type |= (BTM_ACL_PKT_TYPES_MASK_NO_2_DH5 + BTM_ACL_PKT_TYPES_MASK_NO_3_DH5);
2553     }
2554 }