1 /****************************************************************************** 2 * 3 * Copyright (C) 1999-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 * this file contains the functions relating to link management. A "link" 22 * is a connection between this device and another device. Only ACL links 23 * are managed. 24 * 25 ******************************************************************************/ 26 27 #include <assert.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <stdio.h> 31 32 #include "device/include/controller.h" 33 #include "bt_common.h" 34 #include "bt_types.h" 35 #include "bt_utils.h" 36 #include "hcimsgs.h" 37 #include "l2cdefs.h" 38 #include "l2c_int.h" 39 #include "l2c_api.h" 40 #include "btu.h" 41 #include "btm_api.h" 42 #include "btm_int.h" 43 #include "btcore/include/bdaddr.h" 44 45 46 extern fixed_queue_t *btu_general_alarm_queue; 47 48 static BOOLEAN l2c_link_send_to_lower (tL2C_LCB *p_lcb, BT_HDR *p_buf); 49 50 /******************************************************************************* 51 ** 52 ** Function l2c_link_hci_conn_req 53 ** 54 ** Description This function is called when an HCI Connection Request 55 ** event is received. 56 ** 57 ** Returns TRUE, if accept conn 58 ** 59 *******************************************************************************/ 60 BOOLEAN l2c_link_hci_conn_req (BD_ADDR bd_addr) 61 { 62 tL2C_LCB *p_lcb; 63 tL2C_LCB *p_lcb_cur; 64 int xx; 65 BOOLEAN no_links; 66 67 /* See if we have a link control block for the remote device */ 68 p_lcb = l2cu_find_lcb_by_bd_addr (bd_addr, BT_TRANSPORT_BR_EDR); 69 70 /* If we don't have one, create one and accept the connection. */ 71 if (!p_lcb) 72 { 73 p_lcb = l2cu_allocate_lcb (bd_addr, FALSE, BT_TRANSPORT_BR_EDR); 74 if (!p_lcb) 75 { 76 btsnd_hcic_reject_conn (bd_addr, HCI_ERR_HOST_REJECT_RESOURCES); 77 L2CAP_TRACE_ERROR ("L2CAP failed to allocate LCB"); 78 return FALSE; 79 } 80 81 no_links = TRUE; 82 83 /* If we already have connection, accept as a master */ 84 for (xx = 0, p_lcb_cur = &l2cb.lcb_pool[0]; xx < MAX_L2CAP_LINKS; xx++, p_lcb_cur++) 85 { 86 if (p_lcb_cur == p_lcb) 87 continue; 88 89 if (p_lcb_cur->in_use) 90 { 91 no_links = FALSE; 92 p_lcb->link_role = HCI_ROLE_MASTER; 93 break; 94 } 95 } 96 97 if (no_links) 98 { 99 if (!btm_dev_support_switch (bd_addr)) 100 p_lcb->link_role = HCI_ROLE_SLAVE; 101 else 102 p_lcb->link_role = l2cu_get_conn_role(p_lcb); 103 } 104 105 106 /* Tell the other side we accept the connection */ 107 btsnd_hcic_accept_conn (bd_addr, p_lcb->link_role); 108 109 p_lcb->link_state = LST_CONNECTING; 110 111 /* Start a timer waiting for connect complete */ 112 alarm_set_on_queue(p_lcb->l2c_lcb_timer, L2CAP_LINK_CONNECT_TIMEOUT_MS, 113 l2c_lcb_timer_timeout, p_lcb, 114 btu_general_alarm_queue); 115 return (TRUE); 116 } 117 118 /* We already had a link control block to the guy. Check what state it is in */ 119 if ((p_lcb->link_state == LST_CONNECTING) || (p_lcb->link_state == LST_CONNECT_HOLDING)) 120 { 121 /* Connection collision. Accept the connection anyways. */ 122 123 if (!btm_dev_support_switch (bd_addr)) 124 p_lcb->link_role = HCI_ROLE_SLAVE; 125 else 126 p_lcb->link_role = l2cu_get_conn_role(p_lcb); 127 128 btsnd_hcic_accept_conn (bd_addr, p_lcb->link_role); 129 130 p_lcb->link_state = LST_CONNECTING; 131 return (TRUE); 132 } 133 else if (p_lcb->link_state == LST_DISCONNECTING) 134 { 135 /* In disconnecting state, reject the connection. */ 136 btsnd_hcic_reject_conn (bd_addr, HCI_ERR_HOST_REJECT_DEVICE); 137 } 138 else 139 { 140 L2CAP_TRACE_ERROR("L2CAP got conn_req while connected (state:%d). Reject it", 141 p_lcb->link_state); 142 /* Reject the connection with ACL Connection Already exist reason */ 143 btsnd_hcic_reject_conn (bd_addr, HCI_ERR_CONNECTION_EXISTS); 144 } 145 return (FALSE); 146 } 147 148 /******************************************************************************* 149 ** 150 ** Function l2c_link_hci_conn_comp 151 ** 152 ** Description This function is called when an HCI Connection Complete 153 ** event is received. 154 ** 155 ** Returns void 156 ** 157 *******************************************************************************/ 158 BOOLEAN l2c_link_hci_conn_comp (UINT8 status, UINT16 handle, BD_ADDR p_bda) 159 { 160 tL2C_CONN_INFO ci; 161 tL2C_LCB *p_lcb; 162 tL2C_CCB *p_ccb; 163 tBTM_SEC_DEV_REC *p_dev_info = NULL; 164 165 btm_acl_update_busy_level (BTM_BLI_PAGE_DONE_EVT); 166 167 /* Save the parameters */ 168 ci.status = status; 169 memcpy (ci.bd_addr, p_bda, BD_ADDR_LEN); 170 171 /* See if we have a link control block for the remote device */ 172 p_lcb = l2cu_find_lcb_by_bd_addr (ci.bd_addr, BT_TRANSPORT_BR_EDR); 173 174 /* If we don't have one, this is an error */ 175 if (!p_lcb) 176 { 177 L2CAP_TRACE_WARNING ("L2CAP got conn_comp for unknown BD_ADDR"); 178 return (FALSE); 179 } 180 181 if (p_lcb->link_state != LST_CONNECTING) 182 { 183 L2CAP_TRACE_ERROR ("L2CAP got conn_comp in bad state: %d status: 0x%d", p_lcb->link_state, status); 184 185 if (status != HCI_SUCCESS) 186 l2c_link_hci_disc_comp (p_lcb->handle, status); 187 188 return (FALSE); 189 } 190 191 /* Save the handle */ 192 p_lcb->handle = handle; 193 194 if (ci.status == HCI_SUCCESS) 195 { 196 /* Connected OK. Change state to connected */ 197 p_lcb->link_state = LST_CONNECTED; 198 199 /* Get the peer information if the l2cap flow-control/rtrans is supported */ 200 l2cu_send_peer_info_req (p_lcb, L2CAP_EXTENDED_FEATURES_INFO_TYPE); 201 202 /* Tell BTM Acl management about the link */ 203 if ((p_dev_info = btm_find_dev (p_bda)) != NULL) 204 btm_acl_created (ci.bd_addr, p_dev_info->dev_class, 205 p_dev_info->sec_bd_name, handle, 206 p_lcb->link_role, BT_TRANSPORT_BR_EDR); 207 else 208 btm_acl_created (ci.bd_addr, NULL, NULL, handle, p_lcb->link_role, BT_TRANSPORT_BR_EDR); 209 210 BTM_SetLinkSuperTout (ci.bd_addr, btm_cb.btm_def_link_super_tout); 211 212 /* If dedicated bonding do not process any further */ 213 if (p_lcb->is_bonding) 214 { 215 if (l2cu_start_post_bond_timer(handle)) 216 return (TRUE); 217 } 218 219 /* Update the timeouts in the hold queue */ 220 l2c_process_held_packets(FALSE); 221 222 alarm_cancel(p_lcb->l2c_lcb_timer); 223 224 /* For all channels, send the event through their FSMs */ 225 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb) 226 { 227 l2c_csm_execute (p_ccb, L2CEVT_LP_CONNECT_CFM, &ci); 228 } 229 230 if (p_lcb->p_echo_rsp_cb) 231 { 232 l2cu_send_peer_echo_req (p_lcb, NULL, 0); 233 alarm_set_on_queue(p_lcb->l2c_lcb_timer, 234 L2CAP_ECHO_RSP_TIMEOUT_MS, 235 l2c_lcb_timer_timeout, p_lcb, 236 btu_general_alarm_queue); 237 } 238 else if (!p_lcb->ccb_queue.p_first_ccb) 239 { 240 period_ms_t timeout_ms = L2CAP_LINK_STARTUP_TOUT * 1000; 241 alarm_set_on_queue(p_lcb->l2c_lcb_timer, timeout_ms, 242 l2c_lcb_timer_timeout, p_lcb, 243 btu_general_alarm_queue); 244 } 245 } 246 /* Max number of acl connections. */ 247 /* If there's an lcb disconnecting set this one to holding */ 248 else if ((ci.status == HCI_ERR_MAX_NUM_OF_CONNECTIONS) && l2cu_lcb_disconnecting()) 249 { 250 p_lcb->link_state = LST_CONNECT_HOLDING; 251 p_lcb->handle = HCI_INVALID_HANDLE; 252 } 253 else 254 { 255 /* Just in case app decides to try again in the callback context */ 256 p_lcb->link_state = LST_DISCONNECTING; 257 258 /* Connection failed. For all channels, send the event through */ 259 /* their FSMs. The CCBs should remove themselves from the LCB */ 260 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; ) 261 { 262 tL2C_CCB *pn = p_ccb->p_next_ccb; 263 264 l2c_csm_execute (p_ccb, L2CEVT_LP_CONNECT_CFM_NEG, &ci); 265 266 p_ccb = pn; 267 } 268 269 p_lcb->disc_reason = status; 270 /* Release the LCB */ 271 if (p_lcb->ccb_queue.p_first_ccb == NULL) 272 l2cu_release_lcb (p_lcb); 273 else /* there are any CCBs remaining */ 274 { 275 if (ci.status == HCI_ERR_CONNECTION_EXISTS) 276 { 277 /* we are in collision situation, wait for connecttion request from controller */ 278 p_lcb->link_state = LST_CONNECTING; 279 } 280 else 281 { 282 l2cu_create_conn(p_lcb, BT_TRANSPORT_BR_EDR); 283 } 284 } 285 } 286 return (TRUE); 287 } 288 289 290 /******************************************************************************* 291 ** 292 ** Function l2c_link_sec_comp 293 ** 294 ** Description This function is called when required security procedures 295 ** are completed. 296 ** 297 ** Returns void 298 ** 299 *******************************************************************************/ 300 void l2c_link_sec_comp (BD_ADDR p_bda, tBT_TRANSPORT transport, void *p_ref_data, UINT8 status) 301 { 302 tL2C_CONN_INFO ci; 303 tL2C_LCB *p_lcb; 304 tL2C_CCB *p_ccb; 305 tL2C_CCB *p_next_ccb; 306 UINT8 event; 307 308 UNUSED(transport); 309 310 L2CAP_TRACE_DEBUG ("l2c_link_sec_comp: %d, 0x%x", status, p_ref_data); 311 312 if (status == BTM_SUCCESS_NO_SECURITY) 313 status = BTM_SUCCESS; 314 315 /* Save the parameters */ 316 ci.status = status; 317 memcpy (ci.bd_addr, p_bda, BD_ADDR_LEN); 318 319 p_lcb = l2cu_find_lcb_by_bd_addr (p_bda, transport); 320 321 /* If we don't have one, this is an error */ 322 if (!p_lcb) 323 { 324 L2CAP_TRACE_WARNING ("L2CAP got sec_comp for unknown BD_ADDR"); 325 return; 326 } 327 328 /* Match p_ccb with p_ref_data returned by sec manager */ 329 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_next_ccb) 330 { 331 p_next_ccb = p_ccb->p_next_ccb; 332 333 if (p_ccb == p_ref_data) 334 { 335 switch(status) 336 { 337 case BTM_SUCCESS: 338 event = L2CEVT_SEC_COMP; 339 break; 340 341 case BTM_DELAY_CHECK: 342 /* start a timer - encryption change not received before L2CAP connect req */ 343 alarm_set_on_queue(p_ccb->l2c_ccb_timer, 344 L2CAP_DELAY_CHECK_SM4_TIMEOUT_MS, 345 l2c_ccb_timer_timeout, p_ccb, 346 btu_general_alarm_queue); 347 return; 348 349 default: 350 event = L2CEVT_SEC_COMP_NEG; 351 } 352 l2c_csm_execute (p_ccb, event, &ci); 353 break; 354 } 355 } 356 } 357 358 359 /******************************************************************************* 360 ** 361 ** Function l2c_link_hci_disc_comp 362 ** 363 ** Description This function is called when an HCI Disconnect Complete 364 ** event is received. 365 ** 366 ** Returns TRUE if the link is known about, else FALSE 367 ** 368 *******************************************************************************/ 369 BOOLEAN l2c_link_hci_disc_comp (UINT16 handle, UINT8 reason) 370 { 371 tL2C_LCB *p_lcb; 372 tL2C_CCB *p_ccb; 373 BOOLEAN status = TRUE; 374 BOOLEAN lcb_is_free = TRUE; 375 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 376 377 /* See if we have a link control block for the connection */ 378 p_lcb = l2cu_find_lcb_by_handle (handle); 379 380 /* If we don't have one, maybe an SCO link. Send to MM */ 381 if (!p_lcb) 382 { 383 status = FALSE; 384 } 385 else 386 { 387 /* There can be a case when we rejected PIN code authentication */ 388 /* otherwise save a new reason */ 389 if (btm_cb.acl_disc_reason != HCI_ERR_HOST_REJECT_SECURITY) 390 btm_cb.acl_disc_reason = reason; 391 392 p_lcb->disc_reason = btm_cb.acl_disc_reason; 393 394 /* Just in case app decides to try again in the callback context */ 395 p_lcb->link_state = LST_DISCONNECTING; 396 397 #if (BLE_INCLUDED == TRUE) 398 /* Check for BLE and handle that differently */ 399 if (p_lcb->transport == BT_TRANSPORT_LE) 400 btm_ble_update_link_topology_mask(p_lcb->link_role, FALSE); 401 #endif 402 /* Link is disconnected. For all channels, send the event through */ 403 /* their FSMs. The CCBs should remove themselves from the LCB */ 404 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; ) 405 { 406 tL2C_CCB *pn = p_ccb->p_next_ccb; 407 408 /* Keep connect pending control block (if exists) 409 * Possible Race condition when a reconnect occurs 410 * on the channel during a disconnect of link. This 411 * ccb will be automatically retried after link disconnect 412 * arrives 413 */ 414 if (p_ccb != p_lcb->p_pending_ccb) 415 { 416 l2c_csm_execute (p_ccb, L2CEVT_LP_DISCONNECT_IND, &reason); 417 } 418 p_ccb = pn; 419 } 420 421 #if (BTM_SCO_INCLUDED == TRUE) 422 #if (BLE_INCLUDED == TRUE) 423 if (p_lcb->transport == BT_TRANSPORT_BR_EDR) 424 #endif 425 /* Tell SCO management to drop any SCOs on this ACL */ 426 btm_sco_acl_removed (p_lcb->remote_bd_addr); 427 #endif 428 429 /* If waiting for disconnect and reconnect is pending start the reconnect now 430 race condition where layer above issued connect request on link that was 431 disconnecting 432 */ 433 if (p_lcb->ccb_queue.p_first_ccb != NULL || p_lcb->p_pending_ccb) 434 { 435 L2CAP_TRACE_DEBUG("l2c_link_hci_disc_comp: Restarting pending ACL request"); 436 transport = p_lcb->transport; 437 #if BLE_INCLUDED == TRUE 438 /* for LE link, always drop and re-open to ensure to get LE remote feature */ 439 if (p_lcb->transport == BT_TRANSPORT_LE) 440 { 441 l2cb.is_ble_connecting = FALSE; 442 btm_acl_removed (p_lcb->remote_bd_addr, p_lcb->transport); 443 /* Release any held buffers */ 444 BT_HDR *p_buf; 445 while (!list_is_empty(p_lcb->link_xmit_data_q)) 446 { 447 p_buf = list_front(p_lcb->link_xmit_data_q); 448 list_remove(p_lcb->link_xmit_data_q, p_buf); 449 osi_free(p_buf); 450 } 451 } 452 else 453 #endif 454 { 455 #if (L2CAP_NUM_FIXED_CHNLS > 0) 456 /* If we are going to re-use the LCB without dropping it, release all fixed channels 457 here */ 458 int xx; 459 for (xx = 0; xx < L2CAP_NUM_FIXED_CHNLS; xx++) 460 { 461 if (p_lcb->p_fixed_ccbs[xx] && p_lcb->p_fixed_ccbs[xx] != p_lcb->p_pending_ccb) 462 { 463 #if BLE_INCLUDED == TRUE 464 (*l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb)(xx + L2CAP_FIRST_FIXED_CHNL, 465 p_lcb->remote_bd_addr, FALSE, p_lcb->disc_reason, p_lcb->transport); 466 #else 467 (*l2cb.fixed_reg[xx].pL2CA_FixedConn_Cb)(xx + L2CAP_FIRST_FIXED_CHNL, 468 p_lcb->remote_bd_addr, FALSE, p_lcb->disc_reason, BT_TRANSPORT_BR_EDR); 469 #endif 470 if (p_lcb->p_fixed_ccbs[xx] == NULL) { 471 bdstr_t bd_addr_str = {0}; 472 L2CAP_TRACE_ERROR("%s: unexpected p_fixed_ccbs[%d] is NULL remote_bd_addr = %s p_lcb = %p in_use = %d link_state = %d handle = %d link_role = %d is_bonding = %d disc_reason = %d transport = %d", 473 __func__, xx, 474 bdaddr_to_string((bt_bdaddr_t *)&p_lcb->remote_bd_addr, 475 bd_addr_str, 476 sizeof(bd_addr_str)), 477 p_lcb, p_lcb->in_use, 478 p_lcb->link_state, p_lcb->handle, 479 p_lcb->link_role, p_lcb->is_bonding, 480 p_lcb->disc_reason, p_lcb->transport); 481 } 482 assert(p_lcb->p_fixed_ccbs[xx] != NULL); 483 l2cu_release_ccb (p_lcb->p_fixed_ccbs[xx]); 484 485 p_lcb->p_fixed_ccbs[xx] = NULL; 486 } 487 } 488 #endif 489 } 490 if (l2cu_create_conn(p_lcb, transport)) 491 lcb_is_free = FALSE; /* still using this lcb */ 492 } 493 494 p_lcb->p_pending_ccb = NULL; 495 496 /* Release the LCB */ 497 if (lcb_is_free) 498 l2cu_release_lcb (p_lcb); 499 } 500 501 /* Now that we have a free acl connection, see if any lcbs are pending */ 502 if (lcb_is_free && ((p_lcb = l2cu_find_lcb_by_state(LST_CONNECT_HOLDING)) != NULL)) 503 { 504 /* we found one-- create a connection */ 505 l2cu_create_conn(p_lcb, BT_TRANSPORT_BR_EDR); 506 } 507 508 return status; 509 } 510 511 512 /******************************************************************************* 513 ** 514 ** Function l2c_link_hci_qos_violation 515 ** 516 ** Description This function is called when an HCI QOS Violation 517 ** event is received. 518 ** 519 ** Returns TRUE if the link is known about, else FALSE 520 ** 521 *******************************************************************************/ 522 BOOLEAN l2c_link_hci_qos_violation (UINT16 handle) 523 { 524 tL2C_LCB *p_lcb; 525 tL2C_CCB *p_ccb; 526 527 /* See if we have a link control block for the connection */ 528 p_lcb = l2cu_find_lcb_by_handle (handle); 529 530 /* If we don't have one, maybe an SCO link. */ 531 if (!p_lcb) 532 return (FALSE); 533 534 /* For all channels, tell the upper layer about it */ 535 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb) 536 { 537 if (p_ccb->p_rcb->api.pL2CA_QoSViolationInd_Cb) 538 l2c_csm_execute (p_ccb, L2CEVT_LP_QOS_VIOLATION_IND, NULL); 539 } 540 541 return (TRUE); 542 } 543 544 545 546 /******************************************************************************* 547 ** 548 ** Function l2c_link_timeout 549 ** 550 ** Description This function is called when a link timer expires 551 ** 552 ** Returns void 553 ** 554 *******************************************************************************/ 555 void l2c_link_timeout (tL2C_LCB *p_lcb) 556 { 557 tL2C_CCB *p_ccb; 558 tBTM_STATUS rc; 559 560 L2CAP_TRACE_EVENT ("L2CAP - l2c_link_timeout() link state %d first CCB %p is_bonding:%d", 561 p_lcb->link_state, p_lcb->ccb_queue.p_first_ccb, p_lcb->is_bonding); 562 563 /* If link was connecting or disconnecting, clear all channels and drop the LCB */ 564 if ((p_lcb->link_state == LST_CONNECTING_WAIT_SWITCH) || 565 (p_lcb->link_state == LST_CONNECTING) || 566 (p_lcb->link_state == LST_CONNECT_HOLDING) || 567 (p_lcb->link_state == LST_DISCONNECTING)) 568 { 569 p_lcb->p_pending_ccb = NULL; 570 571 /* For all channels, send a disconnect indication event through */ 572 /* their FSMs. The CCBs should remove themselves from the LCB */ 573 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; ) 574 { 575 tL2C_CCB *pn = p_ccb->p_next_ccb; 576 577 l2c_csm_execute (p_ccb, L2CEVT_LP_DISCONNECT_IND, NULL); 578 579 p_ccb = pn; 580 } 581 #if (BLE_INCLUDED == TRUE) 582 if (p_lcb->link_state == LST_CONNECTING && 583 l2cb.is_ble_connecting == TRUE) 584 { 585 L2CA_CancelBleConnectReq(l2cb.ble_connecting_bda); 586 } 587 #endif 588 /* Release the LCB */ 589 l2cu_release_lcb (p_lcb); 590 } 591 592 /* If link is connected, check for inactivity timeout */ 593 if (p_lcb->link_state == LST_CONNECTED) 594 { 595 /* Check for ping outstanding */ 596 if (p_lcb->p_echo_rsp_cb) 597 { 598 tL2CA_ECHO_RSP_CB *p_cb = p_lcb->p_echo_rsp_cb; 599 600 /* Zero out the callback in case app immediately calls us again */ 601 p_lcb->p_echo_rsp_cb = NULL; 602 603 (*p_cb) (L2CAP_PING_RESULT_NO_RESP); 604 605 L2CAP_TRACE_WARNING ("L2CAP - ping timeout"); 606 607 /* For all channels, send a disconnect indication event through */ 608 /* their FSMs. The CCBs should remove themselves from the LCB */ 609 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; ) 610 { 611 tL2C_CCB *pn = p_ccb->p_next_ccb; 612 613 l2c_csm_execute (p_ccb, L2CEVT_LP_DISCONNECT_IND, NULL); 614 615 p_ccb = pn; 616 } 617 } 618 619 /* If no channels in use, drop the link. */ 620 if (!p_lcb->ccb_queue.p_first_ccb) 621 { 622 period_ms_t timeout_ms; 623 bool start_timeout = true; 624 625 rc = btm_sec_disconnect (p_lcb->handle, HCI_ERR_PEER_USER); 626 627 if (rc == BTM_CMD_STORED) 628 { 629 /* Security Manager will take care of disconnecting, state will be updated at that time */ 630 start_timeout = false; 631 } 632 else if (rc == BTM_CMD_STARTED) 633 { 634 p_lcb->link_state = LST_DISCONNECTING; 635 timeout_ms = L2CAP_LINK_DISCONNECT_TIMEOUT_MS; 636 } 637 else if (rc == BTM_SUCCESS) 638 { 639 l2cu_process_fixed_disc_cback(p_lcb); 640 /* BTM SEC will make sure that link is release (probably after pairing is done) */ 641 p_lcb->link_state = LST_DISCONNECTING; 642 start_timeout = false; 643 } 644 else if (rc == BTM_BUSY) 645 { 646 /* BTM is still executing security process. Let lcb stay as connected */ 647 start_timeout = false; 648 } 649 else if ((p_lcb->is_bonding) 650 && (btsnd_hcic_disconnect (p_lcb->handle, HCI_ERR_PEER_USER))) 651 { 652 l2cu_process_fixed_disc_cback(p_lcb); 653 p_lcb->link_state = LST_DISCONNECTING; 654 timeout_ms = L2CAP_LINK_DISCONNECT_TIMEOUT_MS; 655 } 656 else 657 { 658 /* probably no buffer to send disconnect */ 659 timeout_ms = BT_1SEC_TIMEOUT_MS; 660 } 661 662 if (start_timeout) { 663 alarm_set_on_queue(p_lcb->l2c_lcb_timer, timeout_ms, 664 l2c_lcb_timer_timeout, p_lcb, 665 btu_general_alarm_queue); 666 } 667 } 668 else 669 { 670 /* Check in case we were flow controlled */ 671 l2c_link_check_send_pkts (p_lcb, NULL, NULL); 672 } 673 } 674 } 675 676 /******************************************************************************* 677 ** 678 ** Function l2c_info_resp_timer_timeout 679 ** 680 ** Description This function is called when an info request times out 681 ** 682 ** Returns void 683 ** 684 *******************************************************************************/ 685 void l2c_info_resp_timer_timeout(void *data) 686 { 687 tL2C_LCB *p_lcb = (tL2C_LCB *)data; 688 tL2C_CCB *p_ccb; 689 tL2C_CONN_INFO ci; 690 691 /* If we timed out waiting for info response, just continue using basic if allowed */ 692 if (p_lcb->w4_info_rsp) 693 { 694 /* If waiting for security complete, restart the info response timer */ 695 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb) 696 { 697 if ( (p_ccb->chnl_state == CST_ORIG_W4_SEC_COMP) || (p_ccb->chnl_state == CST_TERM_W4_SEC_COMP) ) 698 { 699 alarm_set_on_queue(p_lcb->info_resp_timer, 700 L2CAP_WAIT_INFO_RSP_TIMEOUT_MS, 701 l2c_info_resp_timer_timeout, p_lcb, 702 btu_general_alarm_queue); 703 return; 704 } 705 } 706 707 p_lcb->w4_info_rsp = FALSE; 708 709 /* If link is in process of being brought up */ 710 if ((p_lcb->link_state != LST_DISCONNECTED) && 711 (p_lcb->link_state != LST_DISCONNECTING)) 712 { 713 /* Notify active channels that peer info is finished */ 714 if (p_lcb->ccb_queue.p_first_ccb) 715 { 716 ci.status = HCI_SUCCESS; 717 memcpy (ci.bd_addr, p_lcb->remote_bd_addr, sizeof(BD_ADDR)); 718 719 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb) 720 { 721 l2c_csm_execute (p_ccb, L2CEVT_L2CAP_INFO_RSP, &ci); 722 } 723 } 724 } 725 } 726 } 727 728 /******************************************************************************* 729 ** 730 ** Function l2c_link_adjust_allocation 731 ** 732 ** Description This function is called when a link is created or removed 733 ** to calculate the amount of packets each link may send to 734 ** the HCI without an ack coming back. 735 ** 736 ** Currently, this is a simple allocation, dividing the 737 ** number of Controller Packets by the number of links. In 738 ** the future, QOS configuration should be examined. 739 ** 740 ** Returns void 741 ** 742 *******************************************************************************/ 743 void l2c_link_adjust_allocation (void) 744 { 745 UINT16 qq, yy, qq_remainder; 746 tL2C_LCB *p_lcb; 747 UINT16 hi_quota, low_quota; 748 UINT16 num_lowpri_links = 0; 749 UINT16 num_hipri_links = 0; 750 UINT16 controller_xmit_quota = l2cb.num_lm_acl_bufs; 751 UINT16 high_pri_link_quota = L2CAP_HIGH_PRI_MIN_XMIT_QUOTA_A; 752 753 /* If no links active, reset buffer quotas and controller buffers */ 754 if (l2cb.num_links_active == 0) 755 { 756 l2cb.controller_xmit_window = l2cb.num_lm_acl_bufs; 757 l2cb.round_robin_quota = l2cb.round_robin_unacked = 0; 758 return; 759 } 760 761 /* First, count the links */ 762 for (yy = 0, p_lcb = &l2cb.lcb_pool[0]; yy < MAX_L2CAP_LINKS; yy++, p_lcb++) 763 { 764 if (p_lcb->in_use) 765 { 766 if (p_lcb->acl_priority == L2CAP_PRIORITY_HIGH) 767 num_hipri_links++; 768 else 769 num_lowpri_links++; 770 } 771 } 772 773 /* now adjust high priority link quota */ 774 low_quota = num_lowpri_links ? 1 : 0; 775 while ( (num_hipri_links * high_pri_link_quota + low_quota) > controller_xmit_quota ) 776 high_pri_link_quota--; 777 778 /* Work out the xmit quota and buffer quota high and low priorities */ 779 hi_quota = num_hipri_links * high_pri_link_quota; 780 low_quota = (hi_quota < controller_xmit_quota) ? controller_xmit_quota - hi_quota : 1; 781 782 /* Work out and save the HCI xmit quota for each low priority link */ 783 784 /* If each low priority link cannot have at least one buffer */ 785 if (num_lowpri_links > low_quota) 786 { 787 l2cb.round_robin_quota = low_quota; 788 qq = qq_remainder = 1; 789 } 790 /* If each low priority link can have at least one buffer */ 791 else if (num_lowpri_links > 0) 792 { 793 l2cb.round_robin_quota = 0; 794 l2cb.round_robin_unacked = 0; 795 qq = low_quota / num_lowpri_links; 796 qq_remainder = low_quota % num_lowpri_links; 797 } 798 /* If no low priority link */ 799 else 800 { 801 l2cb.round_robin_quota = 0; 802 l2cb.round_robin_unacked = 0; 803 qq = qq_remainder = 1; 804 } 805 806 L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation num_hipri: %u num_lowpri: %u low_quota: %u round_robin_quota: %u qq: %u", 807 num_hipri_links, num_lowpri_links, low_quota, 808 l2cb.round_robin_quota, qq); 809 810 /* Now, assign the quotas to each link */ 811 for (yy = 0, p_lcb = &l2cb.lcb_pool[0]; yy < MAX_L2CAP_LINKS; yy++, p_lcb++) 812 { 813 if (p_lcb->in_use) 814 { 815 if (p_lcb->acl_priority == L2CAP_PRIORITY_HIGH) 816 { 817 p_lcb->link_xmit_quota = high_pri_link_quota; 818 } 819 else 820 { 821 /* Safety check in case we switched to round-robin with something outstanding */ 822 /* if sent_not_acked is added into round_robin_unacked then don't add it again */ 823 /* l2cap keeps updating sent_not_acked for exiting from round robin */ 824 if (( p_lcb->link_xmit_quota > 0 )&&( qq == 0 )) 825 l2cb.round_robin_unacked += p_lcb->sent_not_acked; 826 827 p_lcb->link_xmit_quota = qq; 828 if (qq_remainder > 0) 829 { 830 p_lcb->link_xmit_quota++; 831 qq_remainder--; 832 } 833 } 834 835 L2CAP_TRACE_EVENT ("l2c_link_adjust_allocation LCB %d Priority: %d XmitQuota: %d", 836 yy, p_lcb->acl_priority, p_lcb->link_xmit_quota); 837 838 L2CAP_TRACE_EVENT (" SentNotAcked: %d RRUnacked: %d", 839 p_lcb->sent_not_acked, l2cb.round_robin_unacked); 840 841 /* There is a special case where we have readjusted the link quotas and */ 842 /* this link may have sent anything but some other link sent packets so */ 843 /* so we may need a timer to kick off this link's transmissions. */ 844 if ( (p_lcb->link_state == LST_CONNECTED) 845 && (!list_is_empty(p_lcb->link_xmit_data_q)) 846 && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota) ) { 847 alarm_set_on_queue(p_lcb->l2c_lcb_timer, 848 L2CAP_LINK_FLOW_CONTROL_TIMEOUT_MS, 849 l2c_lcb_timer_timeout, p_lcb, 850 btu_general_alarm_queue); 851 } 852 } 853 } 854 } 855 856 /******************************************************************************* 857 ** 858 ** Function l2c_link_adjust_chnl_allocation 859 ** 860 ** Description This function is called to calculate the amount of packets each 861 ** non-F&EC channel may have outstanding. 862 ** 863 ** Currently, this is a simple allocation, dividing the number 864 ** of packets allocated to the link by the number of channels. In 865 ** the future, QOS configuration should be examined. 866 ** 867 ** Returns void 868 ** 869 *******************************************************************************/ 870 void l2c_link_adjust_chnl_allocation (void) 871 { 872 UINT8 xx; 873 874 L2CAP_TRACE_DEBUG("%s", __func__); 875 876 /* assign buffer quota to each channel based on its data rate requirement */ 877 for (xx = 0; xx < MAX_L2CAP_CHANNELS; xx++) 878 { 879 tL2C_CCB *p_ccb = l2cb.ccb_pool + xx; 880 881 if (!p_ccb->in_use) 882 continue; 883 884 tL2CAP_CHNL_DATA_RATE data_rate = p_ccb->tx_data_rate + p_ccb->rx_data_rate; 885 p_ccb->buff_quota = L2CAP_CBB_DEFAULT_DATA_RATE_BUFF_QUOTA * data_rate; 886 L2CAP_TRACE_EVENT("CID:0x%04x FCR Mode:%u Priority:%u TxDataRate:%u RxDataRate:%u Quota:%u", 887 p_ccb->local_cid, p_ccb->peer_cfg.fcr.mode, 888 p_ccb->ccb_priority, p_ccb->tx_data_rate, 889 p_ccb->rx_data_rate, p_ccb->buff_quota); 890 891 /* quota may be change so check congestion */ 892 l2cu_check_channel_congestion(p_ccb); 893 } 894 } 895 896 /******************************************************************************* 897 ** 898 ** Function l2c_link_processs_num_bufs 899 ** 900 ** Description This function is called when a "controller buffer size" 901 ** event is first received from the controller. It updates 902 ** the L2CAP values. 903 ** 904 ** Returns void 905 ** 906 *******************************************************************************/ 907 void l2c_link_processs_num_bufs (UINT16 num_lm_acl_bufs) 908 { 909 l2cb.num_lm_acl_bufs = l2cb.controller_xmit_window = num_lm_acl_bufs; 910 911 } 912 913 /******************************************************************************* 914 ** 915 ** Function l2c_link_pkts_rcvd 916 ** 917 ** Description This function is called from the HCI transport when it is time 918 ** tto send a "Host ready for packets" command. This is only when 919 ** host to controller flow control is used. If fills in the arrays 920 ** of numbers of packets and handles. 921 ** 922 ** Returns count of number of entries filled in 923 ** 924 *******************************************************************************/ 925 UINT8 l2c_link_pkts_rcvd (UINT16 *num_pkts, UINT16 *handles) 926 { 927 UINT8 num_found = 0; 928 929 UNUSED(num_pkts); 930 UNUSED(handles); 931 932 return (num_found); 933 } 934 935 /******************************************************************************* 936 ** 937 ** Function l2c_link_role_changed 938 ** 939 ** Description This function is called whan a link's master/slave role change 940 ** event is received. It simply updates the link control block. 941 ** 942 ** Returns void 943 ** 944 *******************************************************************************/ 945 void l2c_link_role_changed (BD_ADDR bd_addr, UINT8 new_role, UINT8 hci_status) 946 { 947 tL2C_LCB *p_lcb; 948 int xx; 949 950 /* Make sure not called from HCI Command Status (bd_addr and new_role are invalid) */ 951 if (bd_addr) 952 { 953 /* If here came form hci role change event */ 954 p_lcb = l2cu_find_lcb_by_bd_addr (bd_addr, BT_TRANSPORT_BR_EDR); 955 if (p_lcb) 956 { 957 p_lcb->link_role = new_role; 958 959 /* Reset high priority link if needed */ 960 if (hci_status == HCI_SUCCESS) 961 l2cu_set_acl_priority(bd_addr, p_lcb->acl_priority, TRUE); 962 } 963 } 964 965 /* Check if any LCB was waiting for switch to be completed */ 966 for (xx = 0, p_lcb = &l2cb.lcb_pool[0]; xx < MAX_L2CAP_LINKS; xx++, p_lcb++) 967 { 968 if ((p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTING_WAIT_SWITCH)) 969 { 970 l2cu_create_conn_after_switch (p_lcb); 971 } 972 } 973 } 974 975 /******************************************************************************* 976 ** 977 ** Function l2c_pin_code_request 978 ** 979 ** Description This function is called whan a pin-code request is received 980 ** on a connection. If there are no channels active yet on the 981 ** link, it extends the link first connection timer. Make sure 982 ** that inactivity timer is not extended if PIN code happens 983 ** to be after last ccb released. 984 ** 985 ** Returns void 986 ** 987 *******************************************************************************/ 988 void l2c_pin_code_request (BD_ADDR bd_addr) 989 { 990 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr (bd_addr, BT_TRANSPORT_BR_EDR); 991 992 if ( (p_lcb) && (!p_lcb->ccb_queue.p_first_ccb) ) 993 { 994 alarm_set_on_queue(p_lcb->l2c_lcb_timer, 995 L2CAP_LINK_CONNECT_EXT_TIMEOUT_MS, 996 l2c_lcb_timer_timeout, p_lcb, 997 btu_general_alarm_queue); 998 } 999 } 1000 1001 #if L2CAP_WAKE_PARKED_LINK == TRUE 1002 /******************************************************************************* 1003 ** 1004 ** Function l2c_link_check_power_mode 1005 ** 1006 ** Description This function is called to check power mode. 1007 ** 1008 ** Returns TRUE if link is going to be active from park 1009 ** FALSE if nothing to send or not in park mode 1010 ** 1011 *******************************************************************************/ 1012 BOOLEAN l2c_link_check_power_mode (tL2C_LCB *p_lcb) 1013 { 1014 tBTM_PM_MODE mode; 1015 tL2C_CCB *p_ccb; 1016 BOOLEAN need_to_active = FALSE; 1017 1018 /* 1019 * We only switch park to active only if we have unsent packets 1020 */ 1021 if (list_is_empty(p_lcb->link_xmit_data_q)) 1022 { 1023 for (p_ccb = p_lcb->ccb_queue.p_first_ccb; p_ccb; p_ccb = p_ccb->p_next_ccb) 1024 { 1025 if (!fixed_queue_is_empty(p_ccb->xmit_hold_q)) 1026 { 1027 need_to_active = TRUE; 1028 break; 1029 } 1030 } 1031 } 1032 else 1033 need_to_active = TRUE; 1034 1035 /* if we have packets to send */ 1036 if ( need_to_active ) 1037 { 1038 /* check power mode */ 1039 if (BTM_ReadPowerMode(p_lcb->remote_bd_addr, &mode) == BTM_SUCCESS) 1040 { 1041 if ( mode == BTM_PM_STS_PENDING ) 1042 { 1043 L2CAP_TRACE_DEBUG ("LCB(0x%x) is in PM pending state", p_lcb->handle); 1044 1045 return TRUE; 1046 } 1047 } 1048 } 1049 return FALSE; 1050 } 1051 #endif /* L2CAP_WAKE_PARKED_LINK == TRUE) */ 1052 1053 /******************************************************************************* 1054 ** 1055 ** Function l2c_link_check_send_pkts 1056 ** 1057 ** Description This function is called to check if it can send packets 1058 ** to the Host Controller. It may be passed the address of 1059 ** a packet to send. 1060 ** 1061 ** Returns void 1062 ** 1063 *******************************************************************************/ 1064 void l2c_link_check_send_pkts (tL2C_LCB *p_lcb, tL2C_CCB *p_ccb, BT_HDR *p_buf) 1065 { 1066 int xx; 1067 BOOLEAN single_write = FALSE; 1068 1069 /* Save the channel ID for faster counting */ 1070 if (p_buf) 1071 { 1072 if (p_ccb != NULL) 1073 { 1074 p_buf->event = p_ccb->local_cid; 1075 single_write = TRUE; 1076 } 1077 else 1078 p_buf->event = 0; 1079 1080 p_buf->layer_specific = 0; 1081 list_append(p_lcb->link_xmit_data_q, p_buf); 1082 1083 if (p_lcb->link_xmit_quota == 0) 1084 { 1085 #if BLE_INCLUDED == TRUE 1086 if (p_lcb->transport == BT_TRANSPORT_LE) 1087 l2cb.ble_check_round_robin = TRUE; 1088 else 1089 #endif 1090 l2cb.check_round_robin = TRUE; 1091 } 1092 } 1093 1094 /* If this is called from uncongested callback context break recursive calling. 1095 ** This LCB will be served when receiving number of completed packet event. 1096 */ 1097 if (l2cb.is_cong_cback_context) 1098 return; 1099 1100 /* If we are in a scenario where there are not enough buffers for each link to 1101 ** have at least 1, then do a round-robin for all the LCBs 1102 */ 1103 if ( (p_lcb == NULL) || (p_lcb->link_xmit_quota == 0) ) 1104 { 1105 if (p_lcb == NULL) 1106 p_lcb = l2cb.lcb_pool; 1107 else if (!single_write) 1108 p_lcb++; 1109 1110 /* Loop through, starting at the next */ 1111 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_lcb++) 1112 { 1113 /* If controller window is full, nothing to do */ 1114 if (((l2cb.controller_xmit_window == 0 || 1115 (l2cb.round_robin_unacked >= l2cb.round_robin_quota)) 1116 #if (BLE_INCLUDED == TRUE) 1117 && (p_lcb->transport == BT_TRANSPORT_BR_EDR) 1118 ) 1119 || (p_lcb->transport == BT_TRANSPORT_LE && 1120 (l2cb.ble_round_robin_unacked >= l2cb.ble_round_robin_quota || 1121 l2cb.controller_le_xmit_window == 0 ))) 1122 #else 1123 )) 1124 #endif 1125 break; 1126 1127 1128 /* Check for wraparound */ 1129 if (p_lcb == &l2cb.lcb_pool[MAX_L2CAP_LINKS]) 1130 p_lcb = &l2cb.lcb_pool[0]; 1131 1132 if ( (!p_lcb->in_use) 1133 || (p_lcb->partial_segment_being_sent) 1134 || (p_lcb->link_state != LST_CONNECTED) 1135 || (p_lcb->link_xmit_quota != 0) 1136 || (L2C_LINK_CHECK_POWER_MODE (p_lcb)) ) 1137 continue; 1138 1139 /* See if we can send anything from the Link Queue */ 1140 if (!list_is_empty(p_lcb->link_xmit_data_q)) { 1141 p_buf = (BT_HDR *)list_front(p_lcb->link_xmit_data_q); 1142 list_remove(p_lcb->link_xmit_data_q, p_buf); 1143 l2c_link_send_to_lower (p_lcb, p_buf); 1144 } 1145 else if (single_write) 1146 { 1147 /* If only doing one write, break out */ 1148 break; 1149 } 1150 /* If nothing on the link queue, check the channel queue */ 1151 else if ((p_buf = l2cu_get_next_buffer_to_send (p_lcb)) != NULL) 1152 { 1153 l2c_link_send_to_lower (p_lcb, p_buf); 1154 } 1155 } 1156 1157 /* If we finished without using up our quota, no need for a safety check */ 1158 if ( (l2cb.controller_xmit_window > 0) 1159 && (l2cb.round_robin_unacked < l2cb.round_robin_quota) 1160 #if (BLE_INCLUDED == TRUE) 1161 && (p_lcb->transport == BT_TRANSPORT_BR_EDR) 1162 #endif 1163 ) 1164 l2cb.check_round_robin = FALSE; 1165 1166 #if (BLE_INCLUDED == TRUE) 1167 if ( (l2cb.controller_le_xmit_window > 0) 1168 && (l2cb.ble_round_robin_unacked < l2cb.ble_round_robin_quota) 1169 && (p_lcb->transport == BT_TRANSPORT_LE)) 1170 l2cb.ble_check_round_robin = FALSE; 1171 #endif 1172 } 1173 else /* if this is not round-robin service */ 1174 { 1175 /* If a partial segment is being sent, can't send anything else */ 1176 if ( (p_lcb->partial_segment_being_sent) 1177 || (p_lcb->link_state != LST_CONNECTED) 1178 || (L2C_LINK_CHECK_POWER_MODE (p_lcb)) ) 1179 return; 1180 1181 /* See if we can send anything from the link queue */ 1182 #if (BLE_INCLUDED == TRUE) 1183 while ( ((l2cb.controller_xmit_window != 0 && (p_lcb->transport == BT_TRANSPORT_BR_EDR)) || 1184 (l2cb.controller_le_xmit_window != 0 && (p_lcb->transport == BT_TRANSPORT_LE))) 1185 && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota)) 1186 #else 1187 while ( (l2cb.controller_xmit_window != 0) 1188 && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota)) 1189 #endif 1190 { 1191 if (list_is_empty(p_lcb->link_xmit_data_q)) 1192 break; 1193 1194 p_buf = (BT_HDR *)list_front(p_lcb->link_xmit_data_q); 1195 list_remove(p_lcb->link_xmit_data_q, p_buf); 1196 if (!l2c_link_send_to_lower (p_lcb, p_buf)) 1197 break; 1198 } 1199 1200 if (!single_write) 1201 { 1202 /* See if we can send anything for any channel */ 1203 #if (BLE_INCLUDED == TRUE) 1204 while ( ((l2cb.controller_xmit_window != 0 && (p_lcb->transport == BT_TRANSPORT_BR_EDR)) || 1205 (l2cb.controller_le_xmit_window != 0 && (p_lcb->transport == BT_TRANSPORT_LE))) 1206 && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota)) 1207 #else 1208 while ((l2cb.controller_xmit_window != 0) && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota)) 1209 #endif 1210 { 1211 if ((p_buf = l2cu_get_next_buffer_to_send (p_lcb)) == NULL) 1212 break; 1213 1214 if (!l2c_link_send_to_lower (p_lcb, p_buf)) 1215 break; 1216 } 1217 } 1218 1219 /* There is a special case where we have readjusted the link quotas and */ 1220 /* this link may have sent anything but some other link sent packets so */ 1221 /* so we may need a timer to kick off this link's transmissions. */ 1222 if ( (!list_is_empty(p_lcb->link_xmit_data_q)) && (p_lcb->sent_not_acked < p_lcb->link_xmit_quota) ) { 1223 alarm_set_on_queue(p_lcb->l2c_lcb_timer, 1224 L2CAP_LINK_FLOW_CONTROL_TIMEOUT_MS, 1225 l2c_lcb_timer_timeout, p_lcb, 1226 btu_general_alarm_queue); 1227 } 1228 } 1229 } 1230 1231 /******************************************************************************* 1232 ** 1233 ** Function l2c_link_send_to_lower 1234 ** 1235 ** Description This function queues the buffer for HCI transmission 1236 ** 1237 ** Returns TRUE for success, FALSE for fail 1238 ** 1239 *******************************************************************************/ 1240 static BOOLEAN l2c_link_send_to_lower (tL2C_LCB *p_lcb, BT_HDR *p_buf) 1241 { 1242 UINT16 num_segs; 1243 UINT16 xmit_window, acl_data_size; 1244 const controller_t *controller = controller_get_interface(); 1245 1246 if ((p_buf->len <= controller->get_acl_packet_size_classic() 1247 #if (BLE_INCLUDED == TRUE) 1248 && (p_lcb->transport == BT_TRANSPORT_BR_EDR)) || 1249 ((p_lcb->transport == BT_TRANSPORT_LE) && (p_buf->len <= controller->get_acl_packet_size_ble())) 1250 #else 1251 ) 1252 #endif 1253 ) 1254 { 1255 if (p_lcb->link_xmit_quota == 0) 1256 { 1257 #if (BLE_INCLUDED == TRUE) 1258 if (p_lcb->transport == BT_TRANSPORT_LE) 1259 l2cb.ble_round_robin_unacked++; 1260 else 1261 #endif 1262 l2cb.round_robin_unacked++; 1263 } 1264 p_lcb->sent_not_acked++; 1265 p_buf->layer_specific = 0; 1266 1267 #if (BLE_INCLUDED == TRUE) 1268 if (p_lcb->transport == BT_TRANSPORT_LE) 1269 { 1270 l2cb.controller_le_xmit_window--; 1271 bte_main_hci_send(p_buf, (UINT16)(BT_EVT_TO_LM_HCI_ACL|LOCAL_BLE_CONTROLLER_ID)); 1272 } 1273 else 1274 #endif 1275 { 1276 l2cb.controller_xmit_window--; 1277 bte_main_hci_send(p_buf, BT_EVT_TO_LM_HCI_ACL); 1278 } 1279 } 1280 else 1281 { 1282 #if BLE_INCLUDED == TRUE 1283 if (p_lcb->transport == BT_TRANSPORT_LE) 1284 { 1285 acl_data_size = controller->get_acl_data_size_ble(); 1286 xmit_window = l2cb.controller_le_xmit_window; 1287 1288 } 1289 else 1290 #endif 1291 { 1292 acl_data_size = controller->get_acl_data_size_classic(); 1293 xmit_window = l2cb.controller_xmit_window; 1294 } 1295 num_segs = (p_buf->len - HCI_DATA_PREAMBLE_SIZE + acl_data_size - 1) / acl_data_size; 1296 1297 1298 /* If doing round-robin, then only 1 segment each time */ 1299 if (p_lcb->link_xmit_quota == 0) 1300 { 1301 num_segs = 1; 1302 p_lcb->partial_segment_being_sent = TRUE; 1303 } 1304 else 1305 { 1306 /* Multi-segment packet. Make sure it can fit */ 1307 if (num_segs > xmit_window) 1308 { 1309 num_segs = xmit_window; 1310 p_lcb->partial_segment_being_sent = TRUE; 1311 } 1312 1313 if (num_segs > (p_lcb->link_xmit_quota - p_lcb->sent_not_acked)) 1314 { 1315 num_segs = (p_lcb->link_xmit_quota - p_lcb->sent_not_acked); 1316 p_lcb->partial_segment_being_sent = TRUE; 1317 } 1318 } 1319 1320 p_buf->layer_specific = num_segs; 1321 #if BLE_INCLUDED == TRUE 1322 if (p_lcb->transport == BT_TRANSPORT_LE) 1323 { 1324 l2cb.controller_le_xmit_window -= num_segs; 1325 if (p_lcb->link_xmit_quota == 0) 1326 l2cb.ble_round_robin_unacked += num_segs; 1327 } 1328 else 1329 #endif 1330 { 1331 l2cb.controller_xmit_window -= num_segs; 1332 1333 if (p_lcb->link_xmit_quota == 0) 1334 l2cb.round_robin_unacked += num_segs; 1335 } 1336 1337 p_lcb->sent_not_acked += num_segs; 1338 #if BLE_INCLUDED == TRUE 1339 if (p_lcb->transport == BT_TRANSPORT_LE) 1340 { 1341 bte_main_hci_send(p_buf, (UINT16)(BT_EVT_TO_LM_HCI_ACL|LOCAL_BLE_CONTROLLER_ID)); 1342 } 1343 else 1344 #endif 1345 { 1346 bte_main_hci_send(p_buf, BT_EVT_TO_LM_HCI_ACL); 1347 } 1348 } 1349 1350 #if (L2CAP_HCI_FLOW_CONTROL_DEBUG == TRUE) 1351 #if (BLE_INCLUDED == TRUE) 1352 if (p_lcb->transport == BT_TRANSPORT_LE) 1353 { 1354 L2CAP_TRACE_DEBUG ("TotalWin=%d,Hndl=0x%x,Quota=%d,Unack=%d,RRQuota=%d,RRUnack=%d", 1355 l2cb.controller_le_xmit_window, 1356 p_lcb->handle, 1357 p_lcb->link_xmit_quota, p_lcb->sent_not_acked, 1358 l2cb.ble_round_robin_quota, l2cb.ble_round_robin_unacked); 1359 } 1360 else 1361 #endif 1362 { 1363 L2CAP_TRACE_DEBUG ("TotalWin=%d,Hndl=0x%x,Quota=%d,Unack=%d,RRQuota=%d,RRUnack=%d", 1364 l2cb.controller_xmit_window, 1365 p_lcb->handle, 1366 p_lcb->link_xmit_quota, p_lcb->sent_not_acked, 1367 l2cb.round_robin_quota, l2cb.round_robin_unacked); 1368 } 1369 #endif 1370 1371 return TRUE; 1372 } 1373 1374 /******************************************************************************* 1375 ** 1376 ** Function l2c_link_process_num_completed_pkts 1377 ** 1378 ** Description This function is called when a "number-of-completed-packets" 1379 ** event is received from the controller. It updates all the 1380 ** LCB transmit counts. 1381 ** 1382 ** Returns void 1383 ** 1384 *******************************************************************************/ 1385 void l2c_link_process_num_completed_pkts (UINT8 *p) 1386 { 1387 UINT8 num_handles, xx; 1388 UINT16 handle; 1389 UINT16 num_sent; 1390 tL2C_LCB *p_lcb; 1391 1392 STREAM_TO_UINT8 (num_handles, p); 1393 1394 for (xx = 0; xx < num_handles; xx++) 1395 { 1396 STREAM_TO_UINT16 (handle, p); 1397 STREAM_TO_UINT16 (num_sent, p); 1398 1399 p_lcb = l2cu_find_lcb_by_handle (handle); 1400 1401 /* Callback for number of completed packet event */ 1402 /* Originally designed for [3DSG] */ 1403 if((p_lcb != NULL) && (p_lcb->p_nocp_cb)) 1404 { 1405 L2CAP_TRACE_DEBUG ("L2CAP - calling NoCP callback"); 1406 (*p_lcb->p_nocp_cb)(p_lcb->remote_bd_addr); 1407 } 1408 1409 if (p_lcb) 1410 { 1411 #if (BLE_INCLUDED == TRUE) 1412 if (p_lcb && (p_lcb->transport == BT_TRANSPORT_LE)) 1413 l2cb.controller_le_xmit_window += num_sent; 1414 else 1415 #endif 1416 { 1417 /* Maintain the total window to the controller */ 1418 l2cb.controller_xmit_window += num_sent; 1419 } 1420 /* If doing round-robin, adjust communal counts */ 1421 if (p_lcb->link_xmit_quota == 0) 1422 { 1423 #if BLE_INCLUDED == TRUE 1424 if (p_lcb->transport == BT_TRANSPORT_LE) 1425 { 1426 /* Don't go negative */ 1427 if (l2cb.ble_round_robin_unacked > num_sent) 1428 l2cb.ble_round_robin_unacked -= num_sent; 1429 else 1430 l2cb.ble_round_robin_unacked = 0; 1431 } 1432 else 1433 #endif 1434 { 1435 /* Don't go negative */ 1436 if (l2cb.round_robin_unacked > num_sent) 1437 l2cb.round_robin_unacked -= num_sent; 1438 else 1439 l2cb.round_robin_unacked = 0; 1440 } 1441 } 1442 1443 /* Don't go negative */ 1444 if (p_lcb->sent_not_acked > num_sent) 1445 p_lcb->sent_not_acked -= num_sent; 1446 else 1447 p_lcb->sent_not_acked = 0; 1448 1449 l2c_link_check_send_pkts (p_lcb, NULL, NULL); 1450 1451 /* If we were doing round-robin for low priority links, check 'em */ 1452 if ( (p_lcb->acl_priority == L2CAP_PRIORITY_HIGH) 1453 && (l2cb.check_round_robin) 1454 && (l2cb.round_robin_unacked < l2cb.round_robin_quota) ) 1455 { 1456 l2c_link_check_send_pkts (NULL, NULL, NULL); 1457 } 1458 #if BLE_INCLUDED == TRUE 1459 if ((p_lcb->transport == BT_TRANSPORT_LE) 1460 && (p_lcb->acl_priority == L2CAP_PRIORITY_HIGH) 1461 && ((l2cb.ble_check_round_robin) 1462 && (l2cb.ble_round_robin_unacked < l2cb.ble_round_robin_quota))) 1463 { 1464 l2c_link_check_send_pkts (NULL, NULL, NULL); 1465 } 1466 #endif 1467 } 1468 1469 #if (L2CAP_HCI_FLOW_CONTROL_DEBUG == TRUE) 1470 if (p_lcb) 1471 { 1472 #if (BLE_INCLUDED == TRUE) 1473 if (p_lcb->transport == BT_TRANSPORT_LE) 1474 { 1475 L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d", 1476 l2cb.controller_le_xmit_window, 1477 p_lcb->handle, p_lcb->sent_not_acked, 1478 l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked); 1479 } 1480 else 1481 #endif 1482 { 1483 L2CAP_TRACE_DEBUG ("TotalWin=%d,LinkUnack(0x%x)=%d,RRCheck=%d,RRUnack=%d", 1484 l2cb.controller_xmit_window, 1485 p_lcb->handle, p_lcb->sent_not_acked, 1486 l2cb.check_round_robin, l2cb.round_robin_unacked); 1487 1488 } 1489 } 1490 else 1491 { 1492 #if (BLE_INCLUDED == TRUE) 1493 L2CAP_TRACE_DEBUG ("TotalWin=%d LE_Win: %d, Handle=0x%x, RRCheck=%d, RRUnack=%d", 1494 l2cb.controller_xmit_window, 1495 l2cb.controller_le_xmit_window, 1496 handle, 1497 l2cb.ble_check_round_robin, l2cb.ble_round_robin_unacked); 1498 #else 1499 L2CAP_TRACE_DEBUG ("TotalWin=%d Handle=0x%x RRCheck=%d RRUnack=%d", 1500 l2cb.controller_xmit_window, 1501 handle, 1502 l2cb.check_round_robin, l2cb.round_robin_unacked); 1503 #endif 1504 } 1505 #endif 1506 } 1507 1508 #if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE) 1509 /* only full stack can enable sleep mode */ 1510 btu_check_bt_sleep (); 1511 #endif 1512 } 1513 1514 /******************************************************************************* 1515 ** 1516 ** Function l2c_link_segments_xmitted 1517 ** 1518 ** Description This function is called from the HCI Interface when an ACL 1519 ** data packet segment is transmitted. 1520 ** 1521 ** Returns void 1522 ** 1523 *******************************************************************************/ 1524 void l2c_link_segments_xmitted (BT_HDR *p_msg) 1525 { 1526 UINT8 *p = (UINT8 *)(p_msg + 1) + p_msg->offset; 1527 UINT16 handle; 1528 tL2C_LCB *p_lcb; 1529 1530 /* Extract the handle */ 1531 STREAM_TO_UINT16 (handle, p); 1532 handle = HCID_GET_HANDLE (handle); 1533 1534 /* Find the LCB based on the handle */ 1535 if ((p_lcb = l2cu_find_lcb_by_handle (handle)) == NULL) 1536 { 1537 L2CAP_TRACE_WARNING ("L2CAP - rcvd segment complete, unknown handle: %d", handle); 1538 osi_free(p_msg); 1539 return; 1540 } 1541 1542 if (p_lcb->link_state == LST_CONNECTED) 1543 { 1544 /* Enqueue the buffer to the head of the transmit queue, and see */ 1545 /* if we can transmit anything more. */ 1546 list_prepend(p_lcb->link_xmit_data_q, p_msg); 1547 1548 p_lcb->partial_segment_being_sent = FALSE; 1549 1550 l2c_link_check_send_pkts (p_lcb, NULL, NULL); 1551 } 1552 else 1553 osi_free(p_msg); 1554 } 1555
