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