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