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 L2CAP API code 22 * 23 ******************************************************************************/ 24 25 #define LOG_TAG "bt_l2cap" 26 27 #include <assert.h> 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <string.h> 31 32 #include "bt_types.h" 33 #include "btm_api.h" 34 #include "btu.h" 35 #include "bt_common.h" 36 #include "hcidefs.h" 37 #include "hcimsgs.h" 38 #include "l2c_int.h" 39 #include "l2cdefs.h" 40 #include "osi/include/allocator.h" 41 #include "osi/include/log.h" 42 43 44 extern fixed_queue_t *btu_general_alarm_queue; 45 46 /******************************************************************************* 47 ** 48 ** Function L2CA_Register 49 ** 50 ** Description Other layers call this function to register for L2CAP 51 ** services. 52 ** 53 ** Returns PSM to use or zero if error. Typically, the PSM returned 54 ** is the same as was passed in, but for an outgoing-only 55 ** connection to a dynamic PSM, a "virtual" PSM is returned 56 ** and should be used in the calls to L2CA_ConnectReq(), 57 ** L2CA_ErtmConnectReq() and L2CA_Deregister() 58 ** 59 *******************************************************************************/ 60 UINT16 L2CA_Register (UINT16 psm, tL2CAP_APPL_INFO *p_cb_info) 61 { 62 tL2C_RCB *p_rcb; 63 UINT16 vpsm = psm; 64 65 L2CAP_TRACE_API ("L2CAP - L2CA_Register() called for PSM: 0x%04x", psm); 66 67 /* Verify that the required callback info has been filled in 68 ** Note: Connection callbacks are required but not checked 69 ** for here because it is possible to be only a client 70 ** or only a server. 71 */ 72 if ((!p_cb_info->pL2CA_ConfigCfm_Cb) 73 || (!p_cb_info->pL2CA_ConfigInd_Cb) 74 || (!p_cb_info->pL2CA_DataInd_Cb) 75 || (!p_cb_info->pL2CA_DisconnectInd_Cb)) 76 { 77 L2CAP_TRACE_ERROR ("L2CAP - no cb registering PSM: 0x%04x", psm); 78 return (0); 79 } 80 81 /* Verify PSM is valid */ 82 if (L2C_INVALID_PSM(psm)) 83 { 84 L2CAP_TRACE_ERROR ("L2CAP - invalid PSM value, PSM: 0x%04x", psm); 85 return (0); 86 } 87 88 /* Check if this is a registration for an outgoing-only connection to */ 89 /* a dynamic PSM. If so, allocate a "virtual" PSM for the app to use. */ 90 if ( (psm >= 0x1001) && (p_cb_info->pL2CA_ConnectInd_Cb == NULL) ) 91 { 92 for (vpsm = 0x1002; vpsm < 0x8000; vpsm += 2) 93 { 94 if ((p_rcb = l2cu_find_rcb_by_psm (vpsm)) == NULL) 95 break; 96 } 97 98 L2CAP_TRACE_API ("L2CA_Register - Real PSM: 0x%04x Virtual PSM: 0x%04x", psm, vpsm); 99 } 100 101 /* If registration block already there, just overwrite it */ 102 if ((p_rcb = l2cu_find_rcb_by_psm (vpsm)) == NULL) 103 { 104 if ((p_rcb = l2cu_allocate_rcb (vpsm)) == NULL) 105 { 106 L2CAP_TRACE_WARNING ("L2CAP - no RCB available, PSM: 0x%04x vPSM: 0x%04x", psm, vpsm); 107 return (0); 108 } 109 } 110 111 p_rcb->api = *p_cb_info; 112 p_rcb->real_psm = psm; 113 114 return (vpsm); 115 } 116 117 /******************************************************************************* 118 ** 119 ** Function L2CA_Deregister 120 ** 121 ** Description Other layers call this function to de-register for L2CAP 122 ** services. 123 ** 124 ** Returns void 125 ** 126 *******************************************************************************/ 127 void L2CA_Deregister (UINT16 psm) 128 { 129 tL2C_RCB *p_rcb; 130 tL2C_CCB *p_ccb; 131 tL2C_LCB *p_lcb; 132 int ii; 133 134 L2CAP_TRACE_API ("L2CAP - L2CA_Deregister() called for PSM: 0x%04x", psm); 135 136 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) != NULL) 137 { 138 p_lcb = &l2cb.lcb_pool[0]; 139 for (ii = 0; ii < MAX_L2CAP_LINKS; ii++, p_lcb++) 140 { 141 if (p_lcb->in_use) 142 { 143 if (((p_ccb = p_lcb->ccb_queue.p_first_ccb) == NULL) 144 || (p_lcb->link_state == LST_DISCONNECTING)) 145 continue; 146 147 if ((p_ccb->in_use) && 148 ((p_ccb->chnl_state == CST_W4_L2CAP_DISCONNECT_RSP) || 149 (p_ccb->chnl_state == CST_W4_L2CA_DISCONNECT_RSP))) 150 continue; 151 152 if (p_ccb->p_rcb == p_rcb) 153 l2c_csm_execute (p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL); 154 } 155 } 156 l2cu_release_rcb (p_rcb); 157 } 158 else 159 { 160 L2CAP_TRACE_WARNING ("L2CAP - PSM: 0x%04x not found for deregistration", psm); 161 } 162 } 163 164 /******************************************************************************* 165 ** 166 ** Function L2CA_AllocatePSM 167 ** 168 ** Description Other layers call this function to find an unused PSM for L2CAP 169 ** services. 170 ** 171 ** Returns PSM to use. 172 ** 173 *******************************************************************************/ 174 UINT16 L2CA_AllocatePSM(void) 175 { 176 BOOLEAN done = FALSE; 177 UINT16 psm = l2cb.dyn_psm; 178 179 L2CAP_TRACE_API( "L2CA_AllocatePSM"); 180 while (!done) 181 { 182 psm += 2; 183 if (psm > 0xfeff) 184 { 185 psm = 0x1001; 186 } 187 else if (psm & 0x0100) 188 { 189 /* the upper byte must be even */ 190 psm += 0x0100; 191 } 192 193 /* if psm is in range of reserved BRCM Aware features */ 194 if ((BRCM_RESERVED_PSM_START <= psm)&&(psm <= BRCM_RESERVED_PSM_END)) 195 continue; 196 197 /* make sure the newlly allocated psm is not used right now */ 198 if ((l2cu_find_rcb_by_psm (psm)) == NULL) 199 done = TRUE; 200 } 201 l2cb.dyn_psm = psm; 202 203 return(psm); 204 } 205 206 /******************************************************************************* 207 ** 208 ** Function L2CA_ConnectReq 209 ** 210 ** Description Higher layers call this function to create an L2CAP connection. 211 ** Note that the connection is not established at this time, but 212 ** connection establishment gets started. The callback function 213 ** will be invoked when connection establishes or fails. 214 ** 215 ** Returns the CID of the connection, or 0 if it failed to start 216 ** 217 *******************************************************************************/ 218 UINT16 L2CA_ConnectReq (UINT16 psm, BD_ADDR p_bd_addr) 219 { 220 return L2CA_ErtmConnectReq (psm, p_bd_addr, NULL); 221 } 222 223 /******************************************************************************* 224 ** 225 ** Function L2CA_ErtmConnectReq 226 ** 227 ** Description Higher layers call this function to create an L2CAP connection. 228 ** Note that the connection is not established at this time, but 229 ** connection establishment gets started. The callback function 230 ** will be invoked when connection establishes or fails. 231 ** 232 ** Parameters: PSM: L2CAP PSM for the connection 233 ** BD address of the peer 234 ** Enhaced retransmission mode configurations 235 236 ** Returns the CID of the connection, or 0 if it failed to start 237 ** 238 *******************************************************************************/ 239 UINT16 L2CA_ErtmConnectReq (UINT16 psm, BD_ADDR p_bd_addr, tL2CAP_ERTM_INFO *p_ertm_info) 240 { 241 tL2C_LCB *p_lcb; 242 tL2C_CCB *p_ccb; 243 tL2C_RCB *p_rcb; 244 245 L2CAP_TRACE_API ("L2CA_ErtmConnectReq() PSM: 0x%04x BDA: %08x%04x p_ertm_info: 0x%08x allowed:0x%x preferred:%d", psm, 246 (p_bd_addr[0]<<24)+(p_bd_addr[1]<<16)+(p_bd_addr[2]<<8)+p_bd_addr[3], 247 (p_bd_addr[4]<<8)+p_bd_addr[5], p_ertm_info, 248 (p_ertm_info) ? p_ertm_info->allowed_modes : 0, 249 (p_ertm_info) ? p_ertm_info->preferred_mode : 0); 250 251 /* Fail if we have not established communications with the controller */ 252 if (!BTM_IsDeviceUp()) 253 { 254 L2CAP_TRACE_WARNING ("L2CAP connect req - BTU not ready"); 255 return (0); 256 } 257 /* Fail if the PSM is not registered */ 258 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 259 { 260 L2CAP_TRACE_WARNING ("L2CAP - no RCB for L2CA_conn_req, PSM: 0x%04x", psm); 261 return (0); 262 } 263 264 /* First, see if we already have a link to the remote */ 265 /* assume all ERTM l2cap connection is going over BR/EDR for now */ 266 if ((p_lcb = l2cu_find_lcb_by_bd_addr (p_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 267 { 268 /* No link. Get an LCB and start link establishment */ 269 if ( ((p_lcb = l2cu_allocate_lcb (p_bd_addr, FALSE, BT_TRANSPORT_BR_EDR)) == NULL) 270 /* currently use BR/EDR for ERTM mode l2cap connection */ 271 || (l2cu_create_conn(p_lcb, BT_TRANSPORT_BR_EDR) == FALSE) ) 272 { 273 L2CAP_TRACE_WARNING ("L2CAP - conn not started for PSM: 0x%04x p_lcb: 0x%08x", psm, p_lcb); 274 return (0); 275 } 276 } 277 278 /* Allocate a channel control block */ 279 if ((p_ccb = l2cu_allocate_ccb (p_lcb, 0)) == NULL) 280 { 281 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_conn_req, PSM: 0x%04x", psm); 282 return (0); 283 } 284 285 /* Save registration info */ 286 p_ccb->p_rcb = p_rcb; 287 288 if (p_ertm_info) 289 { 290 p_ccb->ertm_info = *p_ertm_info; 291 292 /* Replace default indicators with the actual default pool */ 293 if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 294 p_ccb->ertm_info.fcr_rx_buf_size = L2CAP_FCR_RX_BUF_SIZE; 295 296 if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 297 p_ccb->ertm_info.fcr_tx_buf_size = L2CAP_FCR_TX_BUF_SIZE; 298 299 if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 300 p_ccb->ertm_info.user_rx_buf_size = L2CAP_USER_RX_BUF_SIZE; 301 302 if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 303 p_ccb->ertm_info.user_tx_buf_size = L2CAP_USER_TX_BUF_SIZE; 304 305 p_ccb->max_rx_mtu = p_ertm_info->user_rx_buf_size - 306 (L2CAP_MIN_OFFSET + L2CAP_SDU_LEN_OFFSET + L2CAP_FCS_LEN); 307 } 308 309 /* If link is up, start the L2CAP connection */ 310 if (p_lcb->link_state == LST_CONNECTED) 311 { 312 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_REQ, NULL); 313 } 314 315 /* If link is disconnecting, save link info to retry after disconnect 316 * Possible Race condition when a reconnect occurs 317 * on the channel during a disconnect of link. This 318 * ccb will be automatically retried after link disconnect 319 * arrives 320 */ 321 else if (p_lcb->link_state == LST_DISCONNECTING) 322 { 323 L2CAP_TRACE_DEBUG ("L2CAP API - link disconnecting: RETRY LATER"); 324 325 /* Save ccb so it can be started after disconnect is finished */ 326 p_lcb->p_pending_ccb = p_ccb; 327 } 328 329 L2CAP_TRACE_API ("L2CAP - L2CA_conn_req(psm: 0x%04x) returned CID: 0x%04x", psm, p_ccb->local_cid); 330 331 /* Return the local CID as our handle */ 332 return (p_ccb->local_cid); 333 } 334 335 /******************************************************************************* 336 ** 337 ** Function L2CA_RegisterLECoc 338 ** 339 ** Description Other layers call this function to register for L2CAP 340 ** Connection Oriented Channel. 341 ** 342 ** Returns PSM to use or zero if error. Typically, the PSM returned 343 ** is the same as was passed in, but for an outgoing-only 344 ** connection to a dynamic PSM, a "virtual" PSM is returned 345 ** and should be used in the calls to L2CA_ConnectLECocReq() 346 ** and L2CA_DeregisterLECoc() 347 ** 348 *******************************************************************************/ 349 UINT16 L2CA_RegisterLECoc(UINT16 psm, tL2CAP_APPL_INFO *p_cb_info) 350 { 351 L2CAP_TRACE_API("%s called for LE PSM: 0x%04x", __func__, psm); 352 353 /* Verify that the required callback info has been filled in 354 ** Note: Connection callbacks are required but not checked 355 ** for here because it is possible to be only a client 356 ** or only a server. 357 */ 358 if ((!p_cb_info->pL2CA_DataInd_Cb) 359 || (!p_cb_info->pL2CA_DisconnectInd_Cb)) 360 { 361 L2CAP_TRACE_ERROR("%s No cb registering BLE PSM: 0x%04x", __func__, psm); 362 return 0; 363 } 364 365 /* Verify PSM is valid */ 366 if (!L2C_IS_VALID_LE_PSM(psm)) 367 { 368 L2CAP_TRACE_ERROR("%s Invalid BLE PSM value, PSM: 0x%04x", __func__, psm); 369 return 0; 370 } 371 372 tL2C_RCB *p_rcb; 373 UINT16 vpsm = psm; 374 375 /* Check if this is a registration for an outgoing-only connection to */ 376 /* a dynamic PSM. If so, allocate a "virtual" PSM for the app to use. */ 377 if ((psm >= 0x0080) && (p_cb_info->pL2CA_ConnectInd_Cb == NULL)) 378 { 379 for (vpsm = 0x0080; vpsm < 0x0100; vpsm++) 380 { 381 p_rcb = l2cu_find_ble_rcb_by_psm(vpsm); 382 if (p_rcb == NULL) 383 break; 384 } 385 386 L2CAP_TRACE_API("%s Real PSM: 0x%04x Virtual PSM: 0x%04x", __func__, psm, vpsm); 387 } 388 389 /* If registration block already there, just overwrite it */ 390 p_rcb = l2cu_find_ble_rcb_by_psm(vpsm); 391 if (p_rcb == NULL) 392 { 393 p_rcb = l2cu_allocate_ble_rcb(vpsm); 394 if (p_rcb == NULL) 395 { 396 L2CAP_TRACE_WARNING("%s No BLE RCB available, PSM: 0x%04x vPSM: 0x%04x", 397 __func__, psm, vpsm); 398 return 0; 399 } 400 } 401 402 p_rcb->api = *p_cb_info; 403 p_rcb->real_psm = psm; 404 405 return vpsm; 406 } 407 408 /******************************************************************************* 409 ** 410 ** Function L2CA_DeregisterLECoc 411 ** 412 ** Description Other layers call this function to de-register for L2CAP 413 ** Connection Oriented Channel. 414 ** 415 ** Returns void 416 ** 417 *******************************************************************************/ 418 void L2CA_DeregisterLECoc(UINT16 psm) 419 { 420 L2CAP_TRACE_API("%s called for PSM: 0x%04x", __func__, psm); 421 422 tL2C_RCB *p_rcb = l2cu_find_ble_rcb_by_psm(psm); 423 if (p_rcb == NULL) 424 { 425 L2CAP_TRACE_WARNING("%s PSM: 0x%04x not found for deregistration", psm); 426 return; 427 } 428 429 tL2C_LCB *p_lcb = &l2cb.lcb_pool[0]; 430 for (int i = 0; i < MAX_L2CAP_LINKS; i++, p_lcb++) 431 { 432 if (!p_lcb->in_use || p_lcb->transport != BT_TRANSPORT_LE) 433 continue; 434 435 tL2C_CCB *p_ccb = p_lcb->ccb_queue.p_first_ccb; 436 if ((p_ccb == NULL) || (p_lcb->link_state == LST_DISCONNECTING)) 437 continue; 438 439 if (p_ccb->in_use && 440 (p_ccb->chnl_state == CST_W4_L2CAP_DISCONNECT_RSP || 441 p_ccb->chnl_state == CST_W4_L2CA_DISCONNECT_RSP)) 442 continue; 443 444 if (p_ccb->p_rcb == p_rcb) 445 l2c_csm_execute(p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL); 446 } 447 448 l2cu_release_rcb (p_rcb); 449 } 450 451 /******************************************************************************* 452 ** 453 ** Function L2CA_ConnectLECocReq 454 ** 455 ** Description Higher layers call this function to create an L2CAP connection. 456 ** Note that the connection is not established at this time, but 457 ** connection establishment gets started. The callback function 458 ** will be invoked when connection establishes or fails. 459 ** 460 ** Parameters: PSM: L2CAP PSM for the connection 461 ** BD address of the peer 462 ** Local Coc configurations 463 464 ** Returns the CID of the connection, or 0 if it failed to start 465 ** 466 *******************************************************************************/ 467 UINT16 L2CA_ConnectLECocReq(UINT16 psm, BD_ADDR p_bd_addr, tL2CAP_LE_CFG_INFO *p_cfg) 468 { 469 L2CAP_TRACE_API("%s PSM: 0x%04x BDA: %02x:%02x:%02x:%02x:%02x:%02x", __func__, psm, 470 p_bd_addr[0], p_bd_addr[1], p_bd_addr[2], p_bd_addr[3], p_bd_addr[4], p_bd_addr[5]); 471 472 /* Fail if we have not established communications with the controller */ 473 if (!BTM_IsDeviceUp()) 474 { 475 L2CAP_TRACE_WARNING("%s BTU not ready", __func__); 476 return 0; 477 } 478 479 /* Fail if the PSM is not registered */ 480 tL2C_RCB *p_rcb = l2cu_find_ble_rcb_by_psm(psm); 481 if (p_rcb == NULL) 482 { 483 L2CAP_TRACE_WARNING("%s No BLE RCB, PSM: 0x%04x", __func__, psm); 484 return 0; 485 } 486 487 /* First, see if we already have a le link to the remote */ 488 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_LE); 489 if (p_lcb == NULL) 490 { 491 /* No link. Get an LCB and start link establishment */ 492 p_lcb = l2cu_allocate_lcb(p_bd_addr, FALSE, BT_TRANSPORT_LE); 493 if ((p_lcb == NULL) 494 /* currently use BR/EDR for ERTM mode l2cap connection */ 495 || (l2cu_create_conn(p_lcb, BT_TRANSPORT_LE) == FALSE) ) 496 { 497 L2CAP_TRACE_WARNING("%s conn not started for PSM: 0x%04x p_lcb: 0x%08x", 498 __func__, psm, p_lcb); 499 return 0; 500 } 501 } 502 503 /* Allocate a channel control block */ 504 tL2C_CCB *p_ccb = l2cu_allocate_ccb(p_lcb, 0); 505 if (p_ccb == NULL) 506 { 507 L2CAP_TRACE_WARNING("%s no CCB, PSM: 0x%04x", __func__, psm); 508 return 0; 509 } 510 511 /* Save registration info */ 512 p_ccb->p_rcb = p_rcb; 513 514 /* Save the configuration */ 515 if (p_cfg) 516 memcpy(&p_ccb->local_conn_cfg, p_cfg, sizeof(tL2CAP_LE_CFG_INFO)); 517 518 /* If link is up, start the L2CAP connection */ 519 if (p_lcb->link_state == LST_CONNECTED) 520 { 521 if (p_ccb->p_lcb->transport == BT_TRANSPORT_LE) 522 { 523 L2CAP_TRACE_DEBUG("%s LE Link is up", __func__); 524 l2c_csm_execute(p_ccb, L2CEVT_L2CA_CONNECT_REQ, NULL); 525 } 526 } 527 528 /* If link is disconnecting, save link info to retry after disconnect 529 * Possible Race condition when a reconnect occurs 530 * on the channel during a disconnect of link. This 531 * ccb will be automatically retried after link disconnect 532 * arrives 533 */ 534 else if (p_lcb->link_state == LST_DISCONNECTING) 535 { 536 L2CAP_TRACE_DEBUG("%s link disconnecting: RETRY LATER", __func__); 537 538 /* Save ccb so it can be started after disconnect is finished */ 539 p_lcb->p_pending_ccb = p_ccb; 540 } 541 542 L2CAP_TRACE_API("%s(psm: 0x%04x) returned CID: 0x%04x", __func__, psm, p_ccb->local_cid); 543 544 /* Return the local CID as our handle */ 545 return p_ccb->local_cid; 546 } 547 548 /******************************************************************************* 549 ** 550 ** Function L2CA_ConnectLECocRsp 551 ** 552 ** Description Higher layers call this function to accept an incoming 553 ** L2CAP COC connection, for which they had gotten an connect 554 ** indication callback. 555 ** 556 ** Returns TRUE for success, FALSE for failure 557 ** 558 *******************************************************************************/ 559 BOOLEAN L2CA_ConnectLECocRsp (BD_ADDR p_bd_addr, UINT8 id, UINT16 lcid, UINT16 result, 560 UINT16 status, tL2CAP_LE_CFG_INFO *p_cfg) 561 { 562 L2CAP_TRACE_API("%s CID: 0x%04x Result: %d Status: %d BDA: %02x:%02x:%02x:%02x:%02x:%02x", 563 __func__, lcid, result, status, 564 p_bd_addr[0], p_bd_addr[1], p_bd_addr[2], p_bd_addr[3], p_bd_addr[4], p_bd_addr[5]); 565 566 567 /* First, find the link control block */ 568 tL2C_LCB *p_lcb = l2cu_find_lcb_by_bd_addr(p_bd_addr, BT_TRANSPORT_LE); 569 if (p_lcb == NULL) 570 { 571 /* No link. Get an LCB and start link establishment */ 572 L2CAP_TRACE_WARNING("%s no LCB", __func__); 573 return FALSE; 574 } 575 576 /* Now, find the channel control block */ 577 tL2C_CCB *p_ccb = l2cu_find_ccb_by_cid(p_lcb, lcid); 578 if (p_ccb == NULL) 579 { 580 L2CAP_TRACE_WARNING("%s no CCB", __func__); 581 return FALSE; 582 } 583 584 /* The IDs must match */ 585 if (p_ccb->remote_id != id) 586 { 587 L2CAP_TRACE_WARNING("%s bad id. Expected: %d Got: %d", __func__, p_ccb->remote_id, id); 588 return FALSE; 589 } 590 591 if (p_cfg) 592 memcpy(&p_ccb->local_conn_cfg, p_cfg, sizeof(tL2CAP_LE_CFG_INFO)); 593 594 if (result == L2CAP_CONN_OK) 595 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_RSP, NULL); 596 else 597 { 598 tL2C_CONN_INFO conn_info; 599 memcpy(conn_info.bd_addr, p_bd_addr, BD_ADDR_LEN); 600 conn_info.l2cap_result = result; 601 conn_info.l2cap_status = status; 602 l2c_csm_execute(p_ccb, L2CEVT_L2CA_CONNECT_RSP_NEG, &conn_info); 603 } 604 605 return TRUE; 606 } 607 608 /******************************************************************************* 609 ** 610 ** Function L2CA_GetPeerLECocConfig 611 ** 612 ** Description Get a peers configuration for LE Connection Oriented Channel. 613 ** 614 ** Parameters: local channel id 615 ** Pointers to peers configuration storage area 616 ** 617 ** Return value: TRUE if peer is connected 618 ** 619 *******************************************************************************/ 620 BOOLEAN L2CA_GetPeerLECocConfig (UINT16 lcid, tL2CAP_LE_CFG_INFO* peer_cfg) 621 { 622 L2CAP_TRACE_API ("%s CID: 0x%04x", __func__, lcid); 623 624 tL2C_CCB *p_ccb = l2cu_find_ccb_by_cid(NULL, lcid); 625 if (p_ccb == NULL) 626 { 627 L2CAP_TRACE_ERROR("%s No CCB for CID:0x%04x", __func__, lcid); 628 return FALSE; 629 } 630 631 if (peer_cfg != NULL) 632 memcpy(peer_cfg, &p_ccb->peer_conn_cfg, sizeof(tL2CAP_LE_CFG_INFO)); 633 634 return TRUE; 635 } 636 637 bool L2CA_SetConnectionCallbacks(uint16_t local_cid, const tL2CAP_APPL_INFO *callbacks) { 638 assert(callbacks != NULL); 639 assert(callbacks->pL2CA_ConnectInd_Cb == NULL); 640 assert(callbacks->pL2CA_ConnectCfm_Cb != NULL); 641 assert(callbacks->pL2CA_ConfigInd_Cb != NULL); 642 assert(callbacks->pL2CA_ConfigCfm_Cb != NULL); 643 assert(callbacks->pL2CA_DisconnectInd_Cb != NULL); 644 assert(callbacks->pL2CA_DisconnectCfm_Cb != NULL); 645 assert(callbacks->pL2CA_CongestionStatus_Cb != NULL); 646 assert(callbacks->pL2CA_DataInd_Cb != NULL); 647 assert(callbacks->pL2CA_TxComplete_Cb != NULL); 648 649 tL2C_CCB *channel_control_block = l2cu_find_ccb_by_cid(NULL, local_cid); 650 if (!channel_control_block) { 651 LOG_ERROR(LOG_TAG, "%s no channel control block found for L2CAP LCID=0x%04x.", __func__, local_cid); 652 return false; 653 } 654 655 // We're making a connection-specific registration control block so we check if 656 // we already have a private one allocated to us on the heap. If not, we make a 657 // new allocation, mark it as heap-allocated, and inherit the fields from the old 658 // control block. 659 tL2C_RCB *registration_control_block = channel_control_block->p_rcb; 660 if (!channel_control_block->should_free_rcb) { 661 registration_control_block = (tL2C_RCB *)osi_calloc(sizeof(tL2C_RCB)); 662 663 *registration_control_block = *channel_control_block->p_rcb; 664 channel_control_block->p_rcb = registration_control_block; 665 channel_control_block->should_free_rcb = true; 666 } 667 668 registration_control_block->api = *callbacks; 669 return true; 670 } 671 672 /******************************************************************************* 673 ** 674 ** Function L2CA_ConnectRsp 675 ** 676 ** Description Higher layers call this function to accept an incoming 677 ** L2CAP connection, for which they had gotten an connect 678 ** indication callback. 679 ** 680 ** Returns TRUE for success, FALSE for failure 681 ** 682 *******************************************************************************/ 683 BOOLEAN L2CA_ConnectRsp (BD_ADDR p_bd_addr, UINT8 id, UINT16 lcid, 684 UINT16 result, UINT16 status) 685 { 686 return L2CA_ErtmConnectRsp (p_bd_addr, id, lcid, result, status, NULL); 687 } 688 689 /******************************************************************************* 690 ** 691 ** Function L2CA_ErtmConnectRsp 692 ** 693 ** Description Higher layers call this function to accept an incoming 694 ** L2CAP connection, for which they had gotten an connect 695 ** indication callback. 696 ** 697 ** Returns TRUE for success, FALSE for failure 698 ** 699 *******************************************************************************/ 700 BOOLEAN L2CA_ErtmConnectRsp (BD_ADDR p_bd_addr, UINT8 id, UINT16 lcid, UINT16 result, 701 UINT16 status, tL2CAP_ERTM_INFO *p_ertm_info) 702 { 703 tL2C_LCB *p_lcb; 704 tL2C_CCB *p_ccb; 705 706 L2CAP_TRACE_API ("L2CA_ErtmConnectRsp() CID: 0x%04x Result: %d Status: %d BDA: %08x%04x p_ertm_info:0x%08x", 707 lcid, result, status, 708 (p_bd_addr[0]<<24)+(p_bd_addr[1]<<16)+(p_bd_addr[2]<<8)+p_bd_addr[3], 709 (p_bd_addr[4]<<8)+p_bd_addr[5], p_ertm_info); 710 711 /* First, find the link control block */ 712 if ((p_lcb = l2cu_find_lcb_by_bd_addr (p_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 713 { 714 /* No link. Get an LCB and start link establishment */ 715 L2CAP_TRACE_WARNING ("L2CAP - no LCB for L2CA_conn_rsp"); 716 return (FALSE); 717 } 718 719 /* Now, find the channel control block */ 720 if ((p_ccb = l2cu_find_ccb_by_cid (p_lcb, lcid)) == NULL) 721 { 722 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_conn_rsp"); 723 return (FALSE); 724 } 725 726 /* The IDs must match */ 727 if (p_ccb->remote_id != id) 728 { 729 L2CAP_TRACE_WARNING ("L2CAP - bad id in L2CA_conn_rsp. Exp: %d Got: %d", p_ccb->remote_id, id); 730 return (FALSE); 731 } 732 733 if (p_ertm_info) 734 { 735 p_ccb->ertm_info = *p_ertm_info; 736 737 /* Replace default indicators with the actual default pool */ 738 if (p_ccb->ertm_info.fcr_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 739 p_ccb->ertm_info.fcr_rx_buf_size = L2CAP_FCR_RX_BUF_SIZE; 740 741 if (p_ccb->ertm_info.fcr_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 742 p_ccb->ertm_info.fcr_tx_buf_size = L2CAP_FCR_TX_BUF_SIZE; 743 744 if (p_ccb->ertm_info.user_rx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 745 p_ccb->ertm_info.user_rx_buf_size = L2CAP_USER_RX_BUF_SIZE; 746 747 if (p_ccb->ertm_info.user_tx_buf_size == L2CAP_INVALID_ERM_BUF_SIZE) 748 p_ccb->ertm_info.user_tx_buf_size = L2CAP_USER_TX_BUF_SIZE; 749 750 p_ccb->max_rx_mtu = p_ertm_info->user_rx_buf_size - 751 (L2CAP_MIN_OFFSET + L2CAP_SDU_LEN_OFFSET + L2CAP_FCS_LEN); 752 } 753 754 if (result == L2CAP_CONN_OK) 755 { 756 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_RSP, NULL); 757 } 758 else 759 { 760 tL2C_CONN_INFO conn_info; 761 762 conn_info.l2cap_result = result; 763 conn_info.l2cap_status = status; 764 765 if (result == L2CAP_CONN_PENDING) 766 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_RSP, &conn_info); 767 else 768 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONNECT_RSP_NEG, &conn_info); 769 } 770 771 return (TRUE); 772 } 773 774 /******************************************************************************* 775 ** 776 ** Function L2CA_ConfigReq 777 ** 778 ** Description Higher layers call this function to send configuration. 779 ** 780 ** Note: The FCR options of p_cfg are not used. 781 ** 782 ** Returns TRUE if configuration sent, else FALSE 783 ** 784 *******************************************************************************/ 785 BOOLEAN L2CA_ConfigReq (UINT16 cid, tL2CAP_CFG_INFO *p_cfg) 786 { 787 tL2C_CCB *p_ccb; 788 789 L2CAP_TRACE_API ("L2CA_ConfigReq() CID 0x%04x: fcr_present:%d (mode %d) mtu_present:%d (%d)", 790 cid, p_cfg->fcr_present, p_cfg->fcr.mode, p_cfg->mtu_present, p_cfg->mtu); 791 792 /* Find the channel control block. We don't know the link it is on. */ 793 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 794 { 795 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_cfg_req, CID: %d", cid); 796 return (FALSE); 797 } 798 799 /* We need to have at least one mode type common with the peer */ 800 if (!l2c_fcr_adj_our_req_options(p_ccb, p_cfg)) 801 return (FALSE); 802 803 /* Don't adjust FCR options if not used */ 804 if ((!p_cfg->fcr_present)||(p_cfg->fcr.mode == L2CAP_FCR_BASIC_MODE)) 805 { 806 /* FCR and FCS options are not used in basic mode */ 807 p_cfg->fcs_present = FALSE; 808 p_cfg->ext_flow_spec_present = FALSE; 809 810 if ( (p_cfg->mtu_present) && (p_cfg->mtu > L2CAP_MTU_SIZE) ) 811 { 812 L2CAP_TRACE_WARNING ("L2CAP - adjust MTU: %u too large", p_cfg->mtu); 813 p_cfg->mtu = L2CAP_MTU_SIZE; 814 } 815 } 816 817 /* Save the adjusted configuration in case it needs to be used for renegotiation */ 818 p_ccb->our_cfg = *p_cfg; 819 820 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONFIG_REQ, p_cfg); 821 822 return (TRUE); 823 } 824 825 /******************************************************************************* 826 ** 827 ** Function L2CA_ConfigRsp 828 ** 829 ** Description Higher layers call this function to send a configuration 830 ** response. 831 ** 832 ** Returns TRUE if configuration response sent, else FALSE 833 ** 834 *******************************************************************************/ 835 BOOLEAN L2CA_ConfigRsp (UINT16 cid, tL2CAP_CFG_INFO *p_cfg) 836 { 837 tL2C_CCB *p_ccb; 838 839 L2CAP_TRACE_API ("L2CA_ConfigRsp() CID: 0x%04x Result: %d MTU present:%d Flush TO:%d FCR:%d FCS:%d", 840 cid, p_cfg->result, p_cfg->mtu_present, p_cfg->flush_to_present, p_cfg->fcr_present, p_cfg->fcs_present); 841 842 /* Find the channel control block. We don't know the link it is on. */ 843 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 844 { 845 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_cfg_rsp, CID: %d", cid); 846 return (FALSE); 847 } 848 849 if ( (p_cfg->result == L2CAP_CFG_OK) || (p_cfg->result == L2CAP_CFG_PENDING) ) 850 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONFIG_RSP, p_cfg); 851 else 852 { 853 p_cfg->fcr_present = FALSE; /* FCR options already negotiated before this point */ 854 855 /* Clear out any cached options that are being returned as an error (excluding FCR) */ 856 if (p_cfg->mtu_present) 857 p_ccb->peer_cfg.mtu_present = FALSE; 858 if (p_cfg->flush_to_present) 859 p_ccb->peer_cfg.flush_to_present = FALSE; 860 if (p_cfg->qos_present) 861 p_ccb->peer_cfg.qos_present = FALSE; 862 863 l2c_csm_execute (p_ccb, L2CEVT_L2CA_CONFIG_RSP_NEG, p_cfg); 864 } 865 866 return (TRUE); 867 } 868 869 /******************************************************************************* 870 ** 871 ** Function L2CA_DisconnectReq 872 ** 873 ** Description Higher layers call this function to disconnect a channel. 874 ** 875 ** Returns TRUE if disconnect sent, else FALSE 876 ** 877 *******************************************************************************/ 878 BOOLEAN L2CA_DisconnectReq (UINT16 cid) 879 { 880 tL2C_CCB *p_ccb; 881 882 L2CAP_TRACE_API ("L2CA_DisconnectReq() CID: 0x%04x", cid); 883 884 /* Find the channel control block. We don't know the link it is on. */ 885 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 886 { 887 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_disc_req, CID: %d", cid); 888 return (FALSE); 889 } 890 891 l2c_csm_execute (p_ccb, L2CEVT_L2CA_DISCONNECT_REQ, NULL); 892 893 return (TRUE); 894 } 895 896 /******************************************************************************* 897 ** 898 ** Function L2CA_DisconnectRsp 899 ** 900 ** Description Higher layers call this function to acknowledge the 901 ** disconnection of a channel. 902 ** 903 ** Returns void 904 ** 905 *******************************************************************************/ 906 BOOLEAN L2CA_DisconnectRsp (UINT16 cid) 907 { 908 tL2C_CCB *p_ccb; 909 910 L2CAP_TRACE_API ("L2CA_DisconnectRsp() CID: 0x%04x", cid); 911 912 /* Find the channel control block. We don't know the link it is on. */ 913 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 914 { 915 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_disc_rsp, CID: %d", cid); 916 return (FALSE); 917 } 918 919 l2c_csm_execute (p_ccb, L2CEVT_L2CA_DISCONNECT_RSP, NULL); 920 921 return (TRUE); 922 } 923 924 /******************************************************************************* 925 ** 926 ** Function L2CA_Ping 927 ** 928 ** Description Higher layers call this function to send an echo request. 929 ** 930 ** Returns TRUE if echo request sent, else FALSE. 931 ** 932 *******************************************************************************/ 933 BOOLEAN L2CA_Ping (BD_ADDR p_bd_addr, tL2CA_ECHO_RSP_CB *p_callback) 934 { 935 tL2C_LCB *p_lcb; 936 937 L2CAP_TRACE_API ("L2CA_Ping() BDA: %02x-%02x-%02x-%02x-%02x-%02x", 938 p_bd_addr[0], p_bd_addr[1], p_bd_addr[2], p_bd_addr[3], p_bd_addr[4], p_bd_addr[5]); 939 940 /* Fail if we have not established communications with the controller */ 941 if (!BTM_IsDeviceUp()) 942 return (FALSE); 943 944 /* First, see if we already have a link to the remote */ 945 if ((p_lcb = l2cu_find_lcb_by_bd_addr (p_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 946 { 947 /* No link. Get an LCB and start link establishment */ 948 if ((p_lcb = l2cu_allocate_lcb (p_bd_addr, FALSE, BT_TRANSPORT_BR_EDR)) == NULL) 949 { 950 L2CAP_TRACE_WARNING ("L2CAP - no LCB for L2CA_ping"); 951 return (FALSE); 952 } 953 if (l2cu_create_conn(p_lcb, BT_TRANSPORT_BR_EDR) == FALSE) 954 { 955 return (FALSE); 956 } 957 958 p_lcb->p_echo_rsp_cb = p_callback; 959 960 return (TRUE); 961 } 962 963 /* We only allow 1 ping outstanding at a time */ 964 if (p_lcb->p_echo_rsp_cb != NULL) 965 { 966 L2CAP_TRACE_WARNING ("L2CAP - rejected second L2CA_ping"); 967 return (FALSE); 968 } 969 970 /* Have a link control block. If link is disconnecting, tell user to retry later */ 971 if (p_lcb->link_state == LST_DISCONNECTING) 972 { 973 L2CAP_TRACE_WARNING ("L2CAP - L2CA_ping rejected - link disconnecting"); 974 return (FALSE); 975 } 976 977 /* Save address of callback */ 978 p_lcb->p_echo_rsp_cb = p_callback; 979 980 if (p_lcb->link_state == LST_CONNECTED) 981 { 982 l2cu_adj_id(p_lcb, L2CAP_ADJ_BRCM_ID); /* Make sure not using Broadcom ID */ 983 l2cu_send_peer_echo_req (p_lcb, NULL, 0); 984 alarm_set_on_queue(p_lcb->l2c_lcb_timer, 985 L2CAP_ECHO_RSP_TIMEOUT_MS, 986 l2c_lcb_timer_timeout, p_lcb, 987 btu_general_alarm_queue); 988 } 989 990 return (TRUE); 991 } 992 993 /******************************************************************************* 994 ** 995 ** Function L2CA_Echo 996 ** 997 ** Description Higher layers call this function to send an echo request 998 ** with application-specific data. 999 ** 1000 ** Returns TRUE if echo request sent, else FALSE. 1001 ** 1002 *******************************************************************************/ 1003 BOOLEAN L2CA_Echo (BD_ADDR p_bd_addr, BT_HDR *p_data, tL2CA_ECHO_DATA_CB *p_callback) 1004 { 1005 tL2C_LCB *p_lcb; 1006 UINT8 *pp; 1007 1008 L2CAP_TRACE_API ("L2CA_Echo() BDA: %08X%04X", 1009 ((p_bd_addr[0] << 24) + (p_bd_addr[1] << 16) + (p_bd_addr[2] << 8) + (p_bd_addr[3])), 1010 ((p_bd_addr[4] << 8) + (p_bd_addr[5]))); 1011 1012 /* Fail if we have not established communications with the controller */ 1013 if (!BTM_IsDeviceUp()) 1014 return (FALSE); 1015 1016 if ((memcmp(BT_BD_ANY, p_bd_addr, BD_ADDR_LEN) == 0) && (p_data == NULL)) 1017 { 1018 /* Only register callback without sending message. */ 1019 l2cb.p_echo_data_cb = p_callback; 1020 return TRUE; 1021 } 1022 1023 /* We assume the upper layer will call this function only when the link is established. */ 1024 if ((p_lcb = l2cu_find_lcb_by_bd_addr (p_bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 1025 { 1026 L2CAP_TRACE_ERROR ("L2CA_Echo ERROR : link not established"); 1027 return FALSE; 1028 } 1029 1030 if (p_lcb->link_state != LST_CONNECTED) 1031 { 1032 L2CAP_TRACE_ERROR ("L2CA_Echo ERROR : link is not connected"); 1033 return FALSE; 1034 } 1035 1036 /* Save address of callback */ 1037 l2cb.p_echo_data_cb = p_callback; 1038 1039 /* Set the pointer to the beginning of the data */ 1040 pp = (UINT8 *)(p_data + 1) + p_data->offset; 1041 l2cu_adj_id(p_lcb, L2CAP_ADJ_BRCM_ID); /* Make sure not using Broadcom ID */ 1042 l2cu_send_peer_echo_req (p_lcb, pp, p_data->len); 1043 1044 return (TRUE); 1045 1046 } 1047 1048 bool L2CA_GetIdentifiers(uint16_t lcid, uint16_t *rcid, uint16_t *handle) { 1049 tL2C_CCB *control_block = l2cu_find_ccb_by_cid(NULL, lcid); 1050 if (!control_block) 1051 return false; 1052 1053 if (rcid) 1054 *rcid = control_block->remote_cid; 1055 if (handle) 1056 *handle = control_block->p_lcb->handle; 1057 1058 return true; 1059 } 1060 1061 /******************************************************************************* 1062 ** 1063 ** Function L2CA_SetIdleTimeout 1064 ** 1065 ** Description Higher layers call this function to set the idle timeout for 1066 ** a connection, or for all future connections. The "idle timeout" 1067 ** is the amount of time that a connection can remain up with 1068 ** no L2CAP channels on it. A timeout of zero means that the 1069 ** connection will be torn down immediately when the last channel 1070 ** is removed. A timeout of 0xFFFF means no timeout. Values are 1071 ** in seconds. 1072 ** 1073 ** Returns TRUE if command succeeded, FALSE if failed 1074 ** 1075 ** NOTE This timeout takes effect after at least 1 channel has been 1076 ** established and removed. L2CAP maintains its own timer from 1077 ** whan a connection is established till the first channel is 1078 ** set up. 1079 *******************************************************************************/ 1080 BOOLEAN L2CA_SetIdleTimeout (UINT16 cid, UINT16 timeout, BOOLEAN is_global) 1081 { 1082 tL2C_CCB *p_ccb; 1083 tL2C_LCB *p_lcb; 1084 1085 if (is_global) 1086 { 1087 l2cb.idle_timeout = timeout; 1088 } 1089 else 1090 { 1091 /* Find the channel control block. We don't know the link it is on. */ 1092 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 1093 { 1094 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_SetIdleTimeout, CID: %d", cid); 1095 return (FALSE); 1096 } 1097 1098 p_lcb = p_ccb->p_lcb; 1099 1100 if ((p_lcb) && (p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) 1101 p_lcb->idle_timeout = timeout; 1102 else 1103 return (FALSE); 1104 } 1105 1106 return (TRUE); 1107 } 1108 1109 /******************************************************************************* 1110 ** 1111 ** Function L2CA_SetIdleTimeoutByBdAddr 1112 ** 1113 ** Description Higher layers call this function to set the idle timeout for 1114 ** a connection. The "idle timeout" is the amount of time that 1115 ** a connection can remain up with no L2CAP channels on it. 1116 ** A timeout of zero means that the connection will be torn 1117 ** down immediately when the last channel is removed. 1118 ** A timeout of 0xFFFF means no timeout. Values are in seconds. 1119 ** A bd_addr is the remote BD address. If bd_addr = BT_BD_ANY, 1120 ** then the idle timeouts for all active l2cap links will be 1121 ** changed. 1122 ** 1123 ** Returns TRUE if command succeeded, FALSE if failed 1124 ** 1125 ** NOTE This timeout applies to all logical channels active on the 1126 ** ACL link. 1127 *******************************************************************************/ 1128 BOOLEAN L2CA_SetIdleTimeoutByBdAddr(BD_ADDR bd_addr, UINT16 timeout, tBT_TRANSPORT transport) 1129 { 1130 tL2C_LCB *p_lcb; 1131 1132 if (memcmp (BT_BD_ANY, bd_addr, BD_ADDR_LEN)) 1133 { 1134 p_lcb = l2cu_find_lcb_by_bd_addr( bd_addr, transport); 1135 if ((p_lcb) && (p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) 1136 { 1137 p_lcb->idle_timeout = timeout; 1138 1139 if (!p_lcb->ccb_queue.p_first_ccb) 1140 l2cu_no_dynamic_ccbs (p_lcb); 1141 } 1142 else 1143 return FALSE; 1144 } 1145 else 1146 { 1147 int xx; 1148 tL2C_LCB *p_lcb = &l2cb.lcb_pool[0]; 1149 1150 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_lcb++) 1151 { 1152 if ((p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) 1153 { 1154 p_lcb->idle_timeout = timeout; 1155 1156 if (!p_lcb->ccb_queue.p_first_ccb) 1157 l2cu_no_dynamic_ccbs (p_lcb); 1158 } 1159 } 1160 } 1161 1162 return TRUE; 1163 } 1164 1165 /******************************************************************************* 1166 ** 1167 ** Function L2CA_SetTraceLevel 1168 ** 1169 ** Description This function sets the trace level for L2CAP. If called with 1170 ** a value of 0xFF, it simply reads the current trace level. 1171 ** 1172 ** Returns the new (current) trace level 1173 ** 1174 *******************************************************************************/ 1175 UINT8 L2CA_SetTraceLevel (UINT8 new_level) 1176 { 1177 if (new_level != 0xFF) 1178 l2cb.l2cap_trace_level = new_level; 1179 1180 return (l2cb.l2cap_trace_level); 1181 } 1182 1183 /******************************************************************************* 1184 ** 1185 ** Function L2CA_SetDesireRole 1186 ** 1187 ** Description This function sets the desire role for L2CAP. 1188 ** If the new role is L2CAP_ROLE_ALLOW_SWITCH, allow switch on 1189 ** HciCreateConnection. 1190 ** If the new role is L2CAP_ROLE_DISALLOW_SWITCH, do not allow switch on 1191 ** HciCreateConnection. 1192 ** 1193 ** If the new role is a valid role (HCI_ROLE_MASTER or HCI_ROLE_SLAVE), 1194 ** the desire role is set to the new value. Otherwise, it is not changed. 1195 ** 1196 ** Returns the new (current) role 1197 ** 1198 *******************************************************************************/ 1199 UINT8 L2CA_SetDesireRole (UINT8 new_role) 1200 { 1201 L2CAP_TRACE_API ("L2CA_SetDesireRole() new:x%x, disallow_switch:%d", 1202 new_role, l2cb.disallow_switch); 1203 1204 if (L2CAP_ROLE_CHECK_SWITCH != (L2CAP_ROLE_CHECK_SWITCH & new_role)) 1205 { 1206 /* do not process the allow_switch when both bits are set */ 1207 if (new_role & L2CAP_ROLE_ALLOW_SWITCH) 1208 { 1209 l2cb.disallow_switch = FALSE; 1210 } 1211 if (new_role & L2CAP_ROLE_DISALLOW_SWITCH) 1212 { 1213 l2cb.disallow_switch = TRUE; 1214 } 1215 } 1216 1217 if (new_role == HCI_ROLE_MASTER || new_role == HCI_ROLE_SLAVE) 1218 l2cb.desire_role = new_role; 1219 1220 return (l2cb.desire_role); 1221 } 1222 1223 /******************************************************************************* 1224 ** 1225 ** Function L2CA_LocalLoopbackReq 1226 ** 1227 ** Description This function sets up a CID for local loopback 1228 ** 1229 ** Returns CID of 0 if none. 1230 ** 1231 *******************************************************************************/ 1232 UINT16 L2CA_LocalLoopbackReq (UINT16 psm, UINT16 handle, BD_ADDR p_bd_addr) 1233 { 1234 tL2C_LCB *p_lcb; 1235 tL2C_CCB *p_ccb; 1236 tL2C_RCB *p_rcb; 1237 1238 L2CAP_TRACE_API ("L2CA_LocalLoopbackReq() PSM: %d Handle: 0x%04x", psm, handle); 1239 1240 /* Fail if we have not established communications with the controller */ 1241 if (!BTM_IsDeviceUp()) 1242 { 1243 L2CAP_TRACE_WARNING ("L2CAP loop req - BTU not ready"); 1244 return (0); 1245 } 1246 1247 /* Fail if the PSM is not registered */ 1248 if ((p_rcb = l2cu_find_rcb_by_psm (psm)) == NULL) 1249 { 1250 L2CAP_TRACE_WARNING ("L2CAP - no RCB for L2CA_conn_req, PSM: %d", psm); 1251 return (0); 1252 } 1253 1254 if ((p_lcb = l2cu_allocate_lcb (p_bd_addr, FALSE, BT_TRANSPORT_BR_EDR)) == NULL) 1255 { 1256 L2CAP_TRACE_WARNING ("L2CAP - no LCB for L2CA_conn_req"); 1257 return (0); 1258 } 1259 1260 p_lcb->link_state = LST_CONNECTED; 1261 p_lcb->handle = handle; 1262 1263 /* Allocate a channel control block */ 1264 if ((p_ccb = l2cu_allocate_ccb (p_lcb, 0)) == NULL) 1265 { 1266 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_conn_req"); 1267 return (0); 1268 } 1269 1270 /* Save registration info */ 1271 p_ccb->p_rcb = p_rcb; 1272 p_ccb->chnl_state = CST_OPEN; 1273 p_ccb->remote_cid = p_ccb->local_cid; 1274 p_ccb->config_done = CFG_DONE_MASK; 1275 1276 /* Return the local CID as our handle */ 1277 return (p_ccb->local_cid); 1278 } 1279 1280 /******************************************************************************* 1281 ** 1282 ** Function L2CA_SetAclPriority 1283 ** 1284 ** Description Sets the transmission priority for a channel. 1285 ** (For initial implementation only two values are valid. 1286 ** L2CAP_PRIORITY_NORMAL and L2CAP_PRIORITY_HIGH). 1287 ** 1288 ** Returns TRUE if a valid channel, else FALSE 1289 ** 1290 *******************************************************************************/ 1291 BOOLEAN L2CA_SetAclPriority (BD_ADDR bd_addr, UINT8 priority) 1292 { 1293 L2CAP_TRACE_API ("L2CA_SetAclPriority() bdaddr: %02x%02x%02x%02x%04x, priority:%d", 1294 bd_addr[0], bd_addr[1], bd_addr[2], 1295 bd_addr[3], (bd_addr[4] << 8) + bd_addr[5], priority); 1296 1297 return (l2cu_set_acl_priority(bd_addr, priority, FALSE)); 1298 } 1299 1300 /******************************************************************************* 1301 ** 1302 ** Function L2CA_FlowControl 1303 ** 1304 ** Description Higher layers call this function to flow control a channel. 1305 ** 1306 ** data_enabled - TRUE data flows, FALSE data is stopped 1307 ** 1308 ** Returns TRUE if valid channel, else FALSE 1309 ** 1310 *******************************************************************************/ 1311 BOOLEAN L2CA_FlowControl (UINT16 cid, BOOLEAN data_enabled) 1312 { 1313 tL2C_CCB *p_ccb; 1314 BOOLEAN on_off = !data_enabled; 1315 1316 L2CAP_TRACE_API ("L2CA_FlowControl(%d) CID: 0x%04x", on_off, cid); 1317 1318 /* Find the channel control block. We don't know the link it is on. */ 1319 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 1320 { 1321 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_FlowControl, CID: 0x%04x data_enabled: %d", cid, data_enabled); 1322 return (FALSE); 1323 } 1324 1325 if (p_ccb->peer_cfg.fcr.mode != L2CAP_FCR_ERTM_MODE) 1326 { 1327 L2CAP_TRACE_EVENT ("L2CA_FlowControl() invalid mode:%d", p_ccb->peer_cfg.fcr.mode); 1328 return (FALSE); 1329 } 1330 if (p_ccb->fcrb.local_busy != on_off) 1331 { 1332 p_ccb->fcrb.local_busy = on_off; 1333 1334 if ( (p_ccb->chnl_state == CST_OPEN) && (!p_ccb->fcrb.wait_ack) ) 1335 { 1336 if (on_off) 1337 l2c_fcr_send_S_frame (p_ccb, L2CAP_FCR_SUP_RNR, 0); 1338 else 1339 l2c_fcr_send_S_frame (p_ccb, L2CAP_FCR_SUP_RR, L2CAP_FCR_P_BIT); 1340 } 1341 } 1342 1343 return (TRUE); 1344 } 1345 1346 /******************************************************************************* 1347 ** 1348 ** Function L2CA_SendTestSFrame 1349 ** 1350 ** Description Higher layers call this function to send a test S-frame. 1351 ** 1352 ** Returns TRUE if valid Channel, else FALSE 1353 ** 1354 *******************************************************************************/ 1355 BOOLEAN L2CA_SendTestSFrame (UINT16 cid, UINT8 sup_type, UINT8 back_track) 1356 { 1357 tL2C_CCB *p_ccb; 1358 1359 L2CAP_TRACE_API ("L2CA_SendTestSFrame() CID: 0x%04x Type: 0x%02x back_track: %u", cid, sup_type, back_track); 1360 1361 /* Find the channel control block. We don't know the link it is on. */ 1362 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 1363 { 1364 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_SendTestSFrame, CID: %d", cid); 1365 return (FALSE); 1366 } 1367 1368 if ( (p_ccb->chnl_state != CST_OPEN) || (p_ccb->peer_cfg.fcr.mode != L2CAP_FCR_ERTM_MODE) ) 1369 return (FALSE); 1370 1371 p_ccb->fcrb.next_seq_expected -= back_track; 1372 1373 l2c_fcr_send_S_frame (p_ccb, (UINT16)(sup_type & 3), (UINT16)(sup_type & (L2CAP_FCR_P_BIT | L2CAP_FCR_F_BIT))); 1374 1375 return (TRUE); 1376 } 1377 1378 /******************************************************************************* 1379 ** 1380 ** Function L2CA_SetTxPriority 1381 ** 1382 ** Description Sets the transmission priority for a channel. 1383 ** 1384 ** Returns TRUE if a valid channel, else FALSE 1385 ** 1386 *******************************************************************************/ 1387 BOOLEAN L2CA_SetTxPriority (UINT16 cid, tL2CAP_CHNL_PRIORITY priority) 1388 { 1389 tL2C_CCB *p_ccb; 1390 1391 L2CAP_TRACE_API ("L2CA_SetTxPriority() CID: 0x%04x, priority:%d", cid, priority); 1392 1393 /* Find the channel control block. We don't know the link it is on. */ 1394 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 1395 { 1396 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_SetTxPriority, CID: %d", cid); 1397 return (FALSE); 1398 } 1399 1400 /* it will update the order of CCB in LCB by priority and update round robin service variables */ 1401 l2cu_change_pri_ccb (p_ccb, priority); 1402 1403 return (TRUE); 1404 } 1405 1406 /******************************************************************************* 1407 ** 1408 ** Function L2CA_SetChnlDataRate 1409 ** 1410 ** Description Sets the tx/rx data rate for a channel. 1411 ** 1412 ** Returns TRUE if a valid channel, else FALSE 1413 ** 1414 *******************************************************************************/ 1415 BOOLEAN L2CA_SetChnlDataRate (UINT16 cid, tL2CAP_CHNL_DATA_RATE tx, tL2CAP_CHNL_DATA_RATE rx) 1416 { 1417 tL2C_CCB *p_ccb; 1418 1419 L2CAP_TRACE_API ("L2CA_SetChnlDataRate() CID: 0x%04x, tx:%d, rx:%d", cid, tx, rx); 1420 1421 /* Find the channel control block. We don't know the link it is on. */ 1422 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 1423 { 1424 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_SetChnlDataRate, CID: %d", cid); 1425 return (FALSE); 1426 } 1427 1428 p_ccb->tx_data_rate = tx; 1429 p_ccb->rx_data_rate = rx; 1430 1431 /* Adjust channel buffer allocation */ 1432 l2c_link_adjust_chnl_allocation (); 1433 1434 return(TRUE); 1435 } 1436 1437 /******************************************************************************* 1438 ** 1439 ** Function L2CA_SetFlushTimeout 1440 ** 1441 ** Description This function set the automatic flush time out in Baseband 1442 ** for ACL-U packets. 1443 ** BdAddr : the remote BD address of ACL link. If it is BT_DB_ANY 1444 ** then the flush time out will be applied to all ACL link. 1445 ** FlushTimeout: flush time out in ms 1446 ** 0x0000 : No automatic flush 1447 ** L2CAP_NO_RETRANSMISSION : No retransmission 1448 ** 0x0002 - 0xFFFE : flush time out, if (flush_tout*8)+3/5) 1449 ** <= HCI_MAX_AUTO_FLUSH_TOUT (in 625us slot). 1450 ** Otherwise, return FALSE. 1451 ** L2CAP_NO_AUTOMATIC_FLUSH : No automatic flush 1452 ** 1453 ** Returns TRUE if command succeeded, FALSE if failed 1454 ** 1455 ** NOTE This flush timeout applies to all logical channels active on the 1456 ** ACL link. 1457 *******************************************************************************/ 1458 BOOLEAN L2CA_SetFlushTimeout (BD_ADDR bd_addr, UINT16 flush_tout) 1459 { 1460 tL2C_LCB *p_lcb; 1461 UINT16 hci_flush_to; 1462 UINT32 temp; 1463 1464 /* no automatic flush (infinite timeout) */ 1465 if (flush_tout == 0x0000) 1466 { 1467 hci_flush_to = flush_tout; 1468 flush_tout = L2CAP_NO_AUTOMATIC_FLUSH; 1469 } 1470 /* no retransmission */ 1471 else if (flush_tout == L2CAP_NO_RETRANSMISSION) 1472 { 1473 /* not mandatory range for controller */ 1474 /* Packet is flushed before getting any ACK/NACK */ 1475 /* To do this, flush timeout should be 1 baseband slot */ 1476 hci_flush_to = flush_tout; 1477 } 1478 /* no automatic flush (infinite timeout) */ 1479 else if (flush_tout == L2CAP_NO_AUTOMATIC_FLUSH) 1480 { 1481 hci_flush_to = 0x0000; 1482 } 1483 else 1484 { 1485 /* convert L2CAP flush_to to 0.625 ms units, with round */ 1486 temp = (((UINT32)flush_tout * 8) + 3) / 5; 1487 1488 /* if L2CAP flush_to within range of HCI, set HCI flush timeout */ 1489 if (temp > HCI_MAX_AUTO_FLUSH_TOUT) 1490 { 1491 L2CAP_TRACE_WARNING("WARNING L2CA_SetFlushTimeout timeout(0x%x) is out of range", flush_tout); 1492 return FALSE; 1493 } 1494 else 1495 { 1496 hci_flush_to = (UINT16)temp; 1497 } 1498 } 1499 1500 if (memcmp (BT_BD_ANY, bd_addr, BD_ADDR_LEN)) 1501 { 1502 p_lcb = l2cu_find_lcb_by_bd_addr (bd_addr, BT_TRANSPORT_BR_EDR); 1503 1504 if ((p_lcb) && (p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) 1505 { 1506 if (p_lcb->link_flush_tout != flush_tout) 1507 { 1508 p_lcb->link_flush_tout = flush_tout; 1509 1510 L2CAP_TRACE_API ("L2CA_SetFlushTimeout 0x%04x ms for bd_addr [...;%02x%02x%02x]", 1511 flush_tout, bd_addr[3], bd_addr[4], bd_addr[5]); 1512 1513 if (!btsnd_hcic_write_auto_flush_tout (p_lcb->handle, hci_flush_to)) 1514 return (FALSE); 1515 } 1516 } 1517 else 1518 { 1519 L2CAP_TRACE_WARNING ("WARNING L2CA_SetFlushTimeout No lcb for bd_addr [...;%02x%02x%02x]", 1520 bd_addr[3], bd_addr[4], bd_addr[5]); 1521 return (FALSE); 1522 } 1523 } 1524 else 1525 { 1526 int xx; 1527 p_lcb = &l2cb.lcb_pool[0]; 1528 1529 for (xx = 0; xx < MAX_L2CAP_LINKS; xx++, p_lcb++) 1530 { 1531 if ((p_lcb->in_use) && (p_lcb->link_state == LST_CONNECTED)) 1532 { 1533 if (p_lcb->link_flush_tout != flush_tout) 1534 { 1535 p_lcb->link_flush_tout = flush_tout; 1536 1537 L2CAP_TRACE_API ("L2CA_SetFlushTimeout 0x%04x ms for bd_addr [...;%02x%02x%02x]", 1538 flush_tout, p_lcb->remote_bd_addr[3], 1539 p_lcb->remote_bd_addr[4], p_lcb->remote_bd_addr[5]); 1540 1541 if (!btsnd_hcic_write_auto_flush_tout(p_lcb->handle, hci_flush_to)) 1542 return (FALSE); 1543 } 1544 } 1545 } 1546 } 1547 1548 return (TRUE); 1549 } 1550 1551 /******************************************************************************* 1552 ** 1553 ** Function L2CA_GetPeerFeatures 1554 ** 1555 ** Description Get a peers features and fixed channel map 1556 ** 1557 ** Parameters: BD address of the peer 1558 ** Pointers to features and channel mask storage area 1559 ** 1560 ** Return value: TRUE if peer is connected 1561 ** 1562 *******************************************************************************/ 1563 BOOLEAN L2CA_GetPeerFeatures (BD_ADDR bd_addr, UINT32 *p_ext_feat, UINT8 *p_chnl_mask) 1564 { 1565 tL2C_LCB *p_lcb; 1566 1567 /* We must already have a link to the remote */ 1568 if ((p_lcb = l2cu_find_lcb_by_bd_addr (bd_addr, BT_TRANSPORT_BR_EDR)) == NULL) 1569 { 1570 L2CAP_TRACE_WARNING ("L2CA_GetPeerFeatures() No BDA: %08x%04x", 1571 (bd_addr[0]<<24)+(bd_addr[1]<<16)+(bd_addr[2]<<8)+bd_addr[3], 1572 (bd_addr[4]<<8)+bd_addr[5]); 1573 return (FALSE); 1574 } 1575 1576 L2CAP_TRACE_API ("L2CA_GetPeerFeatures() BDA: %08x%04x ExtFea: 0x%08x Chnl_Mask[0]: 0x%02x", 1577 (bd_addr[0]<<24)+(bd_addr[1]<<16)+(bd_addr[2]<<8)+bd_addr[3], 1578 (bd_addr[4]<<8)+bd_addr[5], p_lcb->peer_ext_fea, p_lcb->peer_chnl_mask[0]); 1579 1580 *p_ext_feat = p_lcb->peer_ext_fea; 1581 1582 memcpy (p_chnl_mask, p_lcb->peer_chnl_mask, L2CAP_FIXED_CHNL_ARRAY_SIZE); 1583 1584 return (TRUE); 1585 } 1586 1587 /******************************************************************************* 1588 ** 1589 ** Function L2CA_GetBDAddrbyHandle 1590 ** 1591 ** Description Get BD address for the given HCI handle 1592 ** 1593 ** Parameters: HCI handle 1594 ** BD address of the peer 1595 ** 1596 ** Return value: TRUE if found lcb for the given handle, FALSE otherwise 1597 ** 1598 *******************************************************************************/ 1599 BOOLEAN L2CA_GetBDAddrbyHandle (UINT16 handle, BD_ADDR bd_addr) 1600 { 1601 tL2C_LCB *p_lcb = NULL; 1602 BOOLEAN found_dev = FALSE; 1603 1604 p_lcb = l2cu_find_lcb_by_handle (handle); 1605 if (p_lcb) 1606 { 1607 found_dev = TRUE; 1608 memcpy (bd_addr, p_lcb->remote_bd_addr, BD_ADDR_LEN); 1609 } 1610 1611 return found_dev; 1612 } 1613 1614 /******************************************************************************* 1615 ** 1616 ** Function L2CA_GetChnlFcrMode 1617 ** 1618 ** Description Get the channel FCR mode 1619 ** 1620 ** Parameters: Local CID 1621 ** 1622 ** Return value: Channel mode 1623 ** 1624 *******************************************************************************/ 1625 UINT8 L2CA_GetChnlFcrMode (UINT16 lcid) 1626 { 1627 tL2C_CCB *p_ccb = l2cu_find_ccb_by_cid (NULL, lcid); 1628 1629 if (p_ccb) 1630 { 1631 L2CAP_TRACE_API ("L2CA_GetChnlFcrMode() returns mode %d", p_ccb->peer_cfg.fcr.mode); 1632 return (p_ccb->peer_cfg.fcr.mode); 1633 } 1634 1635 L2CAP_TRACE_API ("L2CA_GetChnlFcrMode() returns mode L2CAP_FCR_BASIC_MODE"); 1636 return (L2CAP_FCR_BASIC_MODE); 1637 } 1638 1639 #if (L2CAP_NUM_FIXED_CHNLS > 0) 1640 /******************************************************************************* 1641 ** 1642 ** Function L2CA_RegisterFixedChannel 1643 ** 1644 ** Description Register a fixed channel. 1645 ** 1646 ** Parameters: Fixed Channel # 1647 ** Channel Callbacks and config 1648 ** 1649 ** Return value: - 1650 ** 1651 *******************************************************************************/ 1652 BOOLEAN L2CA_RegisterFixedChannel (UINT16 fixed_cid, tL2CAP_FIXED_CHNL_REG *p_freg) 1653 { 1654 if ( (fixed_cid < L2CAP_FIRST_FIXED_CHNL) || (fixed_cid > L2CAP_LAST_FIXED_CHNL) ) 1655 { 1656 L2CAP_TRACE_ERROR ("L2CA_RegisterFixedChannel() Invalid CID: 0x%04x", fixed_cid); 1657 1658 return (FALSE); 1659 } 1660 1661 l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL] = *p_freg; 1662 return (TRUE); 1663 } 1664 1665 /******************************************************************************* 1666 ** 1667 ** Function L2CA_ConnectFixedChnl 1668 ** 1669 ** Description Connect an fixed signalling channel to a remote device. 1670 ** 1671 ** Parameters: Fixed CID 1672 ** BD Address of remote 1673 ** 1674 ** Return value: TRUE if connection started 1675 ** 1676 *******************************************************************************/ 1677 BOOLEAN L2CA_ConnectFixedChnl (UINT16 fixed_cid, BD_ADDR rem_bda) 1678 { 1679 tL2C_LCB *p_lcb; 1680 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 1681 1682 L2CAP_TRACE_API ("%s() CID: 0x%04x BDA: %08x%04x", __func__, fixed_cid, 1683 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], (rem_bda[4]<<8)+rem_bda[5]); 1684 1685 // Check CID is valid and registered 1686 if ( (fixed_cid < L2CAP_FIRST_FIXED_CHNL) || (fixed_cid > L2CAP_LAST_FIXED_CHNL) 1687 || (l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb == NULL) ) 1688 { 1689 L2CAP_TRACE_ERROR ("%s() Invalid CID: 0x%04x", __func__, fixed_cid); 1690 return (FALSE); 1691 } 1692 1693 // Fail if BT is not yet up 1694 if (!BTM_IsDeviceUp()) 1695 { 1696 L2CAP_TRACE_WARNING ("%s(0x%04x) - BTU not ready", __func__, fixed_cid); 1697 return (FALSE); 1698 } 1699 1700 #if BLE_INCLUDED == TRUE 1701 if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID) 1702 transport = BT_TRANSPORT_LE; 1703 #endif 1704 1705 tL2C_BLE_FIXED_CHNLS_MASK peer_channel_mask; 1706 1707 // If we already have a link to the remote, check if it supports that CID 1708 if ((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda, transport)) != NULL) 1709 { 1710 // Fixed channels are mandatory on LE transports so ignore the received 1711 // channel mask and use the locally cached LE channel mask. 1712 1713 #if BLE_INCLUDED == TRUE 1714 if (transport == BT_TRANSPORT_LE) 1715 peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask; 1716 else 1717 #endif 1718 peer_channel_mask = p_lcb->peer_chnl_mask[0]; 1719 1720 // Check for supported channel 1721 if (!(peer_channel_mask & (1 << fixed_cid))) 1722 { 1723 L2CAP_TRACE_EVENT ("%s() CID:0x%04x BDA: %08x%04x not supported", __func__, 1724 fixed_cid,(rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], 1725 (rem_bda[4]<<8)+rem_bda[5]); 1726 return FALSE; 1727 } 1728 1729 // Get a CCB and link the lcb to it 1730 if (!l2cu_initialize_fixed_ccb (p_lcb, fixed_cid, 1731 &l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].fixed_chnl_opts)) 1732 { 1733 L2CAP_TRACE_WARNING ("%s(0x%04x) - LCB but no CCB", __func__, fixed_cid); 1734 return FALSE; 1735 } 1736 1737 // racing with disconnecting, queue the connection request 1738 if (p_lcb->link_state == LST_DISCONNECTING) 1739 { 1740 L2CAP_TRACE_DEBUG ("$s() - link disconnecting: RETRY LATER", __func__); 1741 /* Save ccb so it can be started after disconnect is finished */ 1742 p_lcb->p_pending_ccb = p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]; 1743 return TRUE; 1744 } 1745 1746 #if BLE_INCLUDED == TRUE 1747 (*l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedConn_Cb) 1748 (fixed_cid,p_lcb->remote_bd_addr, TRUE, 0, p_lcb->transport); 1749 #else 1750 (*l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedConn_Cb) 1751 (fixed_cid, p_lcb->remote_bd_addr, TRUE, 0, BT_TRANSPORT_BR_EDR); 1752 #endif 1753 return TRUE; 1754 } 1755 1756 // No link. Get an LCB and start link establishment 1757 if ((p_lcb = l2cu_allocate_lcb (rem_bda, FALSE, transport)) == NULL) 1758 { 1759 L2CAP_TRACE_WARNING ("%s(0x%04x) - no LCB", __func__, fixed_cid); 1760 return FALSE; 1761 } 1762 1763 // Get a CCB and link the lcb to it 1764 if (!l2cu_initialize_fixed_ccb (p_lcb, fixed_cid, 1765 &l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].fixed_chnl_opts)) 1766 { 1767 p_lcb->disc_reason = L2CAP_CONN_NO_RESOURCES; 1768 L2CAP_TRACE_WARNING ("%s(0x%04x) - no CCB", __func__, fixed_cid); 1769 l2cu_release_lcb (p_lcb); 1770 return FALSE; 1771 } 1772 1773 if (!l2cu_create_conn(p_lcb, transport)) 1774 { 1775 L2CAP_TRACE_WARNING ("%s() - create_conn failed", __func__); 1776 l2cu_release_lcb (p_lcb); 1777 return FALSE; 1778 } 1779 return TRUE; 1780 } 1781 1782 /******************************************************************************* 1783 ** 1784 ** Function L2CA_SendFixedChnlData 1785 ** 1786 ** Description Write data on a fixed channel. 1787 ** 1788 ** Parameters: Fixed CID 1789 ** BD Address of remote 1790 ** Pointer to buffer of type BT_HDR 1791 ** 1792 ** Return value L2CAP_DW_SUCCESS, if data accepted 1793 ** L2CAP_DW_FAILED, if error 1794 ** 1795 *******************************************************************************/ 1796 UINT16 L2CA_SendFixedChnlData (UINT16 fixed_cid, BD_ADDR rem_bda, BT_HDR *p_buf) 1797 { 1798 tL2C_LCB *p_lcb; 1799 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 1800 1801 L2CAP_TRACE_API ("L2CA_SendFixedChnlData() CID: 0x%04x BDA: %08x%04x", fixed_cid, 1802 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], (rem_bda[4]<<8)+rem_bda[5]); 1803 1804 #if BLE_INCLUDED == TRUE 1805 if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID) 1806 transport = BT_TRANSPORT_LE; 1807 #endif 1808 1809 // Check CID is valid and registered 1810 if ( (fixed_cid < L2CAP_FIRST_FIXED_CHNL) || (fixed_cid > L2CAP_LAST_FIXED_CHNL) 1811 || (l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb == NULL) ) 1812 { 1813 L2CAP_TRACE_ERROR ("L2CA_SendFixedChnlData() Invalid CID: 0x%04x", fixed_cid); 1814 osi_free(p_buf); 1815 return (L2CAP_DW_FAILED); 1816 } 1817 1818 // Fail if BT is not yet up 1819 if (!BTM_IsDeviceUp()) 1820 { 1821 L2CAP_TRACE_WARNING ("L2CA_SendFixedChnlData(0x%04x) - BTU not ready", fixed_cid); 1822 osi_free(p_buf); 1823 return (L2CAP_DW_FAILED); 1824 } 1825 1826 // We need to have a link up 1827 if ((p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda, transport)) == NULL || 1828 /* if link is disconnecting, also report data sending failure */ 1829 p_lcb->link_state == LST_DISCONNECTING) 1830 { 1831 L2CAP_TRACE_WARNING ("L2CA_SendFixedChnlData(0x%04x) - no LCB", fixed_cid); 1832 osi_free(p_buf); 1833 return (L2CAP_DW_FAILED); 1834 } 1835 1836 tL2C_BLE_FIXED_CHNLS_MASK peer_channel_mask; 1837 1838 // Select peer channels mask to use depending on transport 1839 #if BLE_INCLUDED == TRUE 1840 if (transport == BT_TRANSPORT_LE) 1841 peer_channel_mask = l2cb.l2c_ble_fixed_chnls_mask; 1842 else 1843 #endif 1844 peer_channel_mask = p_lcb->peer_chnl_mask[0]; 1845 1846 if ((peer_channel_mask & (1 << fixed_cid)) == 0) 1847 { 1848 L2CAP_TRACE_WARNING ("L2CA_SendFixedChnlData() - peer does not support fixed chnl: 0x%04x", fixed_cid); 1849 osi_free(p_buf); 1850 return (L2CAP_DW_FAILED); 1851 } 1852 1853 p_buf->event = 0; 1854 p_buf->layer_specific = L2CAP_FLUSHABLE_CH_BASED; 1855 1856 if (!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]) 1857 { 1858 if (!l2cu_initialize_fixed_ccb (p_lcb, fixed_cid, &l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].fixed_chnl_opts)) 1859 { 1860 L2CAP_TRACE_WARNING ("L2CA_SendFixedChnlData() - no CCB for chnl: 0x%4x", fixed_cid); 1861 osi_free(p_buf); 1862 return (L2CAP_DW_FAILED); 1863 } 1864 } 1865 1866 // If already congested, do not accept any more packets 1867 if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) 1868 { 1869 L2CAP_TRACE_ERROR ("L2CAP - CID: 0x%04x cannot send, already congested \ 1870 xmit_hold_q.count: %u buff_quota: %u", fixed_cid, 1871 fixed_queue_length(p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->xmit_hold_q), 1872 p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->buff_quota); 1873 osi_free(p_buf); 1874 return (L2CAP_DW_FAILED); 1875 } 1876 1877 l2c_enqueue_peer_data (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL], p_buf); 1878 1879 l2c_link_check_send_pkts (p_lcb, NULL, NULL); 1880 1881 // If there is no dynamic CCB on the link, restart the idle timer each time something is sent 1882 if (p_lcb->in_use && p_lcb->link_state == LST_CONNECTED && !p_lcb->ccb_queue.p_first_ccb) 1883 { 1884 l2cu_no_dynamic_ccbs (p_lcb); 1885 } 1886 1887 if (p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->cong_sent) 1888 return (L2CAP_DW_CONGESTED); 1889 1890 return (L2CAP_DW_SUCCESS); 1891 } 1892 1893 /******************************************************************************* 1894 ** 1895 ** Function L2CA_RemoveFixedChnl 1896 ** 1897 ** Description Remove a fixed channel to a remote device. 1898 ** 1899 ** Parameters: Fixed CID 1900 ** BD Address of remote 1901 ** Idle timeout to use (or 0xFFFF if don't care) 1902 ** 1903 ** Return value: TRUE if channel removed 1904 ** 1905 *******************************************************************************/ 1906 BOOLEAN L2CA_RemoveFixedChnl (UINT16 fixed_cid, BD_ADDR rem_bda) 1907 { 1908 tL2C_LCB *p_lcb; 1909 tL2C_CCB *p_ccb; 1910 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 1911 1912 /* Check CID is valid and registered */ 1913 if ( (fixed_cid < L2CAP_FIRST_FIXED_CHNL) || (fixed_cid > L2CAP_LAST_FIXED_CHNL) 1914 || (l2cb.fixed_reg[fixed_cid - L2CAP_FIRST_FIXED_CHNL].pL2CA_FixedData_Cb == NULL) ) 1915 { 1916 L2CAP_TRACE_ERROR ("L2CA_RemoveFixedChnl() Invalid CID: 0x%04x", fixed_cid); 1917 return (FALSE); 1918 } 1919 1920 #if BLE_INCLUDED == TRUE 1921 if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID) 1922 transport = BT_TRANSPORT_LE; 1923 #endif 1924 1925 /* Is a fixed channel connected to the remote BDA ?*/ 1926 p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda, transport); 1927 1928 if ( ((p_lcb) == NULL) || (!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]) ) 1929 { 1930 L2CAP_TRACE_WARNING ("L2CA_RemoveFixedChnl() CID: 0x%04x BDA: %08x%04x not connected", fixed_cid, 1931 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], (rem_bda[4]<<8)+rem_bda[5]); 1932 return (FALSE); 1933 } 1934 1935 L2CAP_TRACE_API ("L2CA_RemoveFixedChnl() CID: 0x%04x BDA: %08x%04x", fixed_cid, 1936 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], (rem_bda[4]<<8)+rem_bda[5]); 1937 1938 /* Release the CCB, starting an inactivity timeout on the LCB if no other CCBs exist */ 1939 p_ccb = p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]; 1940 1941 p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL] = NULL; 1942 p_lcb->disc_reason = HCI_ERR_CONN_CAUSE_LOCAL_HOST; 1943 1944 #if BLE_INCLUDED == TRUE 1945 // Retain the link for a few more seconds after SMP pairing is done, since the Android 1946 // platform always does service discovery after pairing is complete. This will avoid 1947 // the link down (pairing is complete) and an immediate re-connection for service 1948 // discovery. 1949 // Some devices do not do auto advertising when link is dropped, thus fail the second 1950 // connection and service discovery. 1951 if ((fixed_cid == L2CAP_ATT_CID ) && !p_lcb->ccb_queue.p_first_ccb) 1952 p_lcb->idle_timeout = 0; 1953 #endif 1954 1955 l2cu_release_ccb (p_ccb); 1956 1957 return (TRUE); 1958 } 1959 1960 /******************************************************************************* 1961 ** 1962 ** Function L2CA_SetFixedChannelTout 1963 ** 1964 ** Description Higher layers call this function to set the idle timeout for 1965 ** a fixed channel. The "idle timeout" is the amount of time that 1966 ** a connection can remain up with no L2CAP channels on it. 1967 ** A timeout of zero means that the connection will be torn 1968 ** down immediately when the last channel is removed. 1969 ** A timeout of 0xFFFF means no timeout. Values are in seconds. 1970 ** A bd_addr is the remote BD address. If bd_addr = BT_BD_ANY, 1971 ** then the idle timeouts for all active l2cap links will be 1972 ** changed. 1973 ** 1974 ** Returns TRUE if command succeeded, FALSE if failed 1975 ** 1976 *******************************************************************************/ 1977 BOOLEAN L2CA_SetFixedChannelTout (BD_ADDR rem_bda, UINT16 fixed_cid, UINT16 idle_tout) 1978 { 1979 tL2C_LCB *p_lcb; 1980 tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR; 1981 1982 #if BLE_INCLUDED == TRUE 1983 if (fixed_cid >= L2CAP_ATT_CID && fixed_cid <= L2CAP_SMP_CID) 1984 transport = BT_TRANSPORT_LE; 1985 #endif 1986 1987 /* Is a fixed channel connected to the remote BDA ?*/ 1988 p_lcb = l2cu_find_lcb_by_bd_addr (rem_bda, transport); 1989 if ( ((p_lcb) == NULL) || (!p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]) ) 1990 { 1991 L2CAP_TRACE_WARNING ("L2CA_SetFixedChannelTout() CID: 0x%04x BDA: %08x%04x not connected", fixed_cid, 1992 (rem_bda[0]<<24)+(rem_bda[1]<<16)+(rem_bda[2]<<8)+rem_bda[3], (rem_bda[4]<<8)+rem_bda[5]); 1993 return (FALSE); 1994 } 1995 1996 p_lcb->p_fixed_ccbs[fixed_cid - L2CAP_FIRST_FIXED_CHNL]->fixed_chnl_idle_tout = idle_tout; 1997 1998 if (p_lcb->in_use && p_lcb->link_state == LST_CONNECTED && !p_lcb->ccb_queue.p_first_ccb) 1999 { 2000 /* If there are no dynamic CCBs, (re)start the idle timer in case we changed it */ 2001 l2cu_no_dynamic_ccbs (p_lcb); 2002 } 2003 2004 return TRUE; 2005 } 2006 2007 #endif /* #if (L2CAP_NUM_FIXED_CHNLS > 0) */ 2008 2009 /******************************************************************************* 2010 ** 2011 ** Function L2CA_GetCurrentConfig 2012 ** 2013 ** Description This function returns configurations of L2CAP channel 2014 ** pp_our_cfg : pointer of our saved configuration options 2015 ** p_our_cfg_bits : valid config in bitmap 2016 ** pp_peer_cfg: pointer of peer's saved configuration options 2017 ** p_peer_cfg_bits : valid config in bitmap 2018 ** 2019 ** Returns TRUE if successful 2020 ** 2021 *******************************************************************************/ 2022 BOOLEAN L2CA_GetCurrentConfig (UINT16 lcid, 2023 tL2CAP_CFG_INFO **pp_our_cfg, tL2CAP_CH_CFG_BITS *p_our_cfg_bits, 2024 tL2CAP_CFG_INFO **pp_peer_cfg, tL2CAP_CH_CFG_BITS *p_peer_cfg_bits) 2025 { 2026 tL2C_CCB *p_ccb; 2027 2028 L2CAP_TRACE_API ("L2CA_GetCurrentConfig() CID: 0x%04x", lcid); 2029 2030 p_ccb = l2cu_find_ccb_by_cid(NULL, lcid); 2031 2032 if (p_ccb) 2033 { 2034 *pp_our_cfg = &(p_ccb->our_cfg); 2035 2036 /* convert valid config items into bitmap */ 2037 *p_our_cfg_bits = 0; 2038 if (p_ccb->our_cfg.mtu_present) 2039 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_MTU; 2040 if (p_ccb->our_cfg.qos_present) 2041 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_QOS; 2042 if (p_ccb->our_cfg.flush_to_present) 2043 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_FLUSH_TO; 2044 if (p_ccb->our_cfg.fcr_present) 2045 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_FCR; 2046 if (p_ccb->our_cfg.fcs_present) 2047 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_FCS; 2048 if (p_ccb->our_cfg.ext_flow_spec_present) 2049 *p_our_cfg_bits |= L2CAP_CH_CFG_MASK_EXT_FLOW_SPEC; 2050 2051 *pp_peer_cfg = &(p_ccb->peer_cfg); 2052 *p_peer_cfg_bits = p_ccb->peer_cfg_bits; 2053 2054 return TRUE; 2055 } 2056 else 2057 { 2058 L2CAP_TRACE_ERROR ("No CCB for CID:0x%04x", lcid); 2059 return FALSE; 2060 } 2061 } 2062 2063 /******************************************************************************* 2064 ** 2065 ** Function L2CA_GetConnectionConfig 2066 ** 2067 ** Description This function returns configurations of L2CAP channel 2068 ** pp_l2c_ccb : pointer to this channels L2CAP ccb data. 2069 ** 2070 ** Returns TRUE if successful 2071 ** 2072 *******************************************************************************/ 2073 BOOLEAN L2CA_GetConnectionConfig(UINT16 lcid, UINT16 *mtu, UINT16 *rcid, UINT16 *handle) 2074 { 2075 tL2C_CCB *p_ccb = l2cu_find_ccb_by_cid(NULL, lcid);; 2076 2077 L2CAP_TRACE_API ("%s CID: 0x%04x", __func__, lcid); 2078 2079 if (p_ccb) 2080 { 2081 *mtu = L2CAP_MTU_SIZE; 2082 if (p_ccb->our_cfg.mtu_present) 2083 *mtu = p_ccb->our_cfg.mtu; 2084 2085 *rcid = p_ccb->remote_cid; 2086 *handle= p_ccb->p_lcb->handle; 2087 return TRUE; 2088 } 2089 2090 L2CAP_TRACE_ERROR ("%s No CCB for CID:0x%04x", __func__, lcid); 2091 return FALSE; 2092 } 2093 2094 /******************************************************************************* 2095 ** 2096 ** Function L2CA_RegForNoCPEvt 2097 ** 2098 ** Description Register callback for Number of Completed Packets event. 2099 ** 2100 ** Input Param p_cb - callback for Number of completed packets event 2101 ** p_bda - BT address of remote device 2102 ** 2103 ** Returns TRUE if registered OK, else FALSE 2104 ** 2105 *******************************************************************************/ 2106 BOOLEAN L2CA_RegForNoCPEvt(tL2CA_NOCP_CB *p_cb, BD_ADDR p_bda) 2107 { 2108 tL2C_LCB *p_lcb; 2109 2110 /* Find the link that is associated with this remote bdaddr */ 2111 p_lcb = l2cu_find_lcb_by_bd_addr (p_bda, BT_TRANSPORT_BR_EDR); 2112 2113 /* If no link for this handle, nothing to do. */ 2114 if (!p_lcb) 2115 return FALSE; 2116 2117 p_lcb->p_nocp_cb = p_cb; 2118 2119 return TRUE; 2120 } 2121 2122 /******************************************************************************* 2123 ** 2124 ** Function L2CA_DataWrite 2125 ** 2126 ** Description Higher layers call this function to write data. 2127 ** 2128 ** Returns L2CAP_DW_SUCCESS, if data accepted, else FALSE 2129 ** L2CAP_DW_CONGESTED, if data accepted and the channel is congested 2130 ** L2CAP_DW_FAILED, if error 2131 ** 2132 *******************************************************************************/ 2133 UINT8 L2CA_DataWrite (UINT16 cid, BT_HDR *p_data) 2134 { 2135 L2CAP_TRACE_API ("L2CA_DataWrite() CID: 0x%04x Len: %d", cid, p_data->len); 2136 return l2c_data_write (cid, p_data, L2CAP_FLUSHABLE_CH_BASED); 2137 } 2138 2139 /******************************************************************************* 2140 ** 2141 ** Function L2CA_SetChnlFlushability 2142 ** 2143 ** Description Higher layers call this function to set a channels 2144 ** flushability flags 2145 ** 2146 ** Returns TRUE if CID found, else FALSE 2147 ** 2148 *******************************************************************************/ 2149 BOOLEAN L2CA_SetChnlFlushability (UINT16 cid, BOOLEAN is_flushable) 2150 { 2151 #if (L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE) 2152 2153 tL2C_CCB *p_ccb; 2154 2155 /* Find the channel control block. We don't know the link it is on. */ 2156 if ((p_ccb = l2cu_find_ccb_by_cid (NULL, cid)) == NULL) 2157 { 2158 L2CAP_TRACE_WARNING ("L2CAP - no CCB for L2CA_SetChnlFlushability, CID: %d", cid); 2159 return (FALSE); 2160 } 2161 2162 p_ccb->is_flushable = is_flushable; 2163 2164 L2CAP_TRACE_API ("L2CA_SetChnlFlushability() CID: 0x%04x is_flushable: %d", cid, is_flushable); 2165 2166 #endif 2167 2168 return (TRUE); 2169 } 2170 2171 /******************************************************************************* 2172 ** 2173 ** Function L2CA_DataWriteEx 2174 ** 2175 ** Description Higher layers call this function to write data with extended 2176 ** flags. 2177 ** flags : L2CAP_FLUSHABLE_CH_BASED 2178 ** L2CAP_FLUSHABLE_PKT 2179 ** L2CAP_NON_FLUSHABLE_PKT 2180 ** 2181 ** Returns L2CAP_DW_SUCCESS, if data accepted, else FALSE 2182 ** L2CAP_DW_CONGESTED, if data accepted and the channel is congested 2183 ** L2CAP_DW_FAILED, if error 2184 ** 2185 *******************************************************************************/ 2186 UINT8 L2CA_DataWriteEx (UINT16 cid, BT_HDR *p_data, UINT16 flags) 2187 { 2188 L2CAP_TRACE_API ("L2CA_DataWriteEx() CID: 0x%04x Len: %d Flags:0x%04X", 2189 cid, p_data->len, flags); 2190 return l2c_data_write (cid, p_data, flags); 2191 } 2192 2193 /******************************************************************************* 2194 ** 2195 ** Function L2CA_FlushChannel 2196 ** 2197 ** Description This function flushes none, some or all buffers queued up 2198 ** for xmission for a particular CID. If called with 2199 ** L2CAP_FLUSH_CHANS_GET (0), it simply returns the number 2200 ** of buffers queued for that CID L2CAP_FLUSH_CHANS_ALL (0xffff) 2201 ** flushes all buffers. All other values specifies the maximum 2202 ** buffers to flush. 2203 ** 2204 ** Returns Number of buffers left queued for that CID 2205 ** 2206 *******************************************************************************/ 2207 UINT16 L2CA_FlushChannel (UINT16 lcid, UINT16 num_to_flush) 2208 { 2209 tL2C_CCB *p_ccb; 2210 tL2C_LCB *p_lcb; 2211 UINT16 num_left = 0, 2212 num_flushed1 = 0, 2213 num_flushed2 = 0; 2214 2215 p_ccb = l2cu_find_ccb_by_cid(NULL, lcid); 2216 2217 if ( !p_ccb || ((p_lcb = p_ccb->p_lcb) == NULL) ) 2218 { 2219 L2CAP_TRACE_WARNING ("L2CA_FlushChannel() abnormally returning 0 CID: 0x%04x", lcid); 2220 return (0); 2221 } 2222 2223 if (num_to_flush != L2CAP_FLUSH_CHANS_GET) 2224 { 2225 L2CAP_TRACE_API ("L2CA_FlushChannel (FLUSH) CID: 0x%04x NumToFlush: %d QC: %u pFirst: 0x%08x", 2226 lcid, num_to_flush, 2227 fixed_queue_length(p_ccb->xmit_hold_q), 2228 fixed_queue_try_peek_first(p_ccb->xmit_hold_q)); 2229 } 2230 else 2231 { 2232 L2CAP_TRACE_API ("L2CA_FlushChannel (QUERY) CID: 0x%04x", lcid); 2233 } 2234 2235 /* Cannot flush eRTM buffers once they have a sequence number */ 2236 if (p_ccb->peer_cfg.fcr.mode != L2CAP_FCR_ERTM_MODE) 2237 { 2238 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE 2239 if (num_to_flush != L2CAP_FLUSH_CHANS_GET) 2240 { 2241 /* If the controller supports enhanced flush, flush the data queued at the controller */ 2242 if ( (HCI_NON_FLUSHABLE_PB_SUPPORTED(BTM_ReadLocalFeatures ())) 2243 && (BTM_GetNumScoLinks() == 0) ) 2244 { 2245 if ( l2cb.is_flush_active == FALSE ) 2246 { 2247 l2cb.is_flush_active = TRUE; 2248 2249 /* The only packet type defined - 0 - Automatically-Flushable Only */ 2250 btsnd_hcic_enhanced_flush (p_lcb->handle, 0); 2251 } 2252 } 2253 } 2254 #endif 2255 2256 // Iterate though list and flush the amount requested from 2257 // the transmit data queue that satisfy the layer and event conditions. 2258 for (const list_node_t *node = list_begin(p_lcb->link_xmit_data_q); 2259 (num_to_flush > 0) && node != list_end(p_lcb->link_xmit_data_q);) { 2260 BT_HDR *p_buf = (BT_HDR *)list_node(node); 2261 node = list_next(node); 2262 if ((p_buf->layer_specific == 0) && (p_buf->event == lcid)) { 2263 num_to_flush--; 2264 num_flushed1++; 2265 2266 list_remove(p_lcb->link_xmit_data_q, p_buf); 2267 osi_free(p_buf); 2268 } 2269 } 2270 } 2271 2272 /* If needed, flush buffers in the CCB xmit hold queue */ 2273 while ( (num_to_flush != 0) && (!fixed_queue_is_empty(p_ccb->xmit_hold_q))) 2274 { 2275 BT_HDR *p_buf = (BT_HDR *)fixed_queue_try_dequeue(p_ccb->xmit_hold_q); 2276 osi_free(p_buf); 2277 num_to_flush--; 2278 num_flushed2++; 2279 } 2280 2281 /* If app needs to track all packets, call him */ 2282 if ( (p_ccb->p_rcb) && (p_ccb->p_rcb->api.pL2CA_TxComplete_Cb) && (num_flushed2) ) 2283 (*p_ccb->p_rcb->api.pL2CA_TxComplete_Cb)(p_ccb->local_cid, num_flushed2); 2284 2285 /* Now count how many are left */ 2286 for (const list_node_t *node = list_begin(p_lcb->link_xmit_data_q); 2287 node != list_end(p_lcb->link_xmit_data_q); 2288 node = list_next(node)) { 2289 2290 BT_HDR *p_buf = (BT_HDR *)list_node(node); 2291 if (p_buf->event == lcid) 2292 num_left++; 2293 } 2294 2295 /* Add in the number in the CCB xmit queue */ 2296 num_left += fixed_queue_length(p_ccb->xmit_hold_q); 2297 2298 /* Return the local number of buffers left for the CID */ 2299 L2CAP_TRACE_DEBUG ("L2CA_FlushChannel() flushed: %u + %u, num_left: %u", num_flushed1, num_flushed2, num_left); 2300 2301 /* If we were congested, and now we are not, tell the app */ 2302 l2cu_check_channel_congestion (p_ccb); 2303 2304 return (num_left); 2305 } 2306 2307
