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 *******************************************************************************/
L2CA_Register(UINT16 psm,tL2CAP_APPL_INFO * p_cb_info)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 *******************************************************************************/
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 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 *******************************************************************************/
L2CA_RegisterLECoc(UINT16 psm,tL2CAP_APPL_INFO * p_cb_info)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 *******************************************************************************/
L2CA_DeregisterLECoc(UINT16 psm)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 *******************************************************************************/
L2CA_ConnectLECocReq(UINT16 psm,BD_ADDR p_bd_addr,tL2CAP_LE_CFG_INFO * p_cfg)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 *******************************************************************************/
L2CA_ConnectLECocRsp(BD_ADDR p_bd_addr,UINT8 id,UINT16 lcid,UINT16 result,UINT16 status,tL2CAP_LE_CFG_INFO * p_cfg)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 *******************************************************************************/
L2CA_GetPeerLECocConfig(UINT16 lcid,tL2CAP_LE_CFG_INFO * peer_cfg)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
L2CA_SetConnectionCallbacks(uint16_t local_cid,const tL2CAP_APPL_INFO * callbacks)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 *******************************************************************************/
L2CA_ConnectRsp(BD_ADDR p_bd_addr,UINT8 id,UINT16 lcid,UINT16 result,UINT16 status)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 *******************************************************************************/
L2CA_ErtmConnectRsp(BD_ADDR p_bd_addr,UINT8 id,UINT16 lcid,UINT16 result,UINT16 status,tL2CAP_ERTM_INFO * p_ertm_info)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 *******************************************************************************/
L2CA_ConfigReq(UINT16 cid,tL2CAP_CFG_INFO * p_cfg)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 *******************************************************************************/
L2CA_ConfigRsp(UINT16 cid,tL2CAP_CFG_INFO * p_cfg)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 *******************************************************************************/
L2CA_DisconnectReq(UINT16 cid)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 *******************************************************************************/
L2CA_DisconnectRsp(UINT16 cid)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 *******************************************************************************/
L2CA_Ping(BD_ADDR p_bd_addr,tL2CA_ECHO_RSP_CB * p_callback)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 *******************************************************************************/
L2CA_Echo(BD_ADDR p_bd_addr,BT_HDR * p_data,tL2CA_ECHO_DATA_CB * p_callback)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
L2CA_GetIdentifiers(uint16_t lcid,uint16_t * rcid,uint16_t * handle)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 *******************************************************************************/
L2CA_SetIdleTimeout(UINT16 cid,UINT16 timeout,BOOLEAN is_global)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 *******************************************************************************/
L2CA_SetIdleTimeoutByBdAddr(BD_ADDR bd_addr,UINT16 timeout,tBT_TRANSPORT transport)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 *******************************************************************************/
L2CA_SetTraceLevel(UINT8 new_level)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 *******************************************************************************/
L2CA_SetDesireRole(UINT8 new_role)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 *******************************************************************************/
L2CA_LocalLoopbackReq(UINT16 psm,UINT16 handle,BD_ADDR p_bd_addr)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 *******************************************************************************/
L2CA_SetAclPriority(BD_ADDR bd_addr,UINT8 priority)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 *******************************************************************************/
L2CA_FlowControl(UINT16 cid,BOOLEAN data_enabled)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 *******************************************************************************/
L2CA_SendTestSFrame(UINT16 cid,UINT8 sup_type,UINT8 back_track)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 *******************************************************************************/
L2CA_SetTxPriority(UINT16 cid,tL2CAP_CHNL_PRIORITY priority)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 *******************************************************************************/
L2CA_SetChnlDataRate(UINT16 cid,tL2CAP_CHNL_DATA_RATE tx,tL2CAP_CHNL_DATA_RATE rx)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 *******************************************************************************/
L2CA_SetFlushTimeout(BD_ADDR bd_addr,UINT16 flush_tout)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 *******************************************************************************/
L2CA_GetPeerFeatures(BD_ADDR bd_addr,UINT32 * p_ext_feat,UINT8 * p_chnl_mask)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 *******************************************************************************/
L2CA_GetBDAddrbyHandle(UINT16 handle,BD_ADDR bd_addr)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 *******************************************************************************/
L2CA_GetChnlFcrMode(UINT16 lcid)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 *******************************************************************************/
L2CA_RegisterFixedChannel(UINT16 fixed_cid,tL2CAP_FIXED_CHNL_REG * p_freg)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 *******************************************************************************/
L2CA_ConnectFixedChnl(UINT16 fixed_cid,BD_ADDR rem_bda)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 *******************************************************************************/
L2CA_SendFixedChnlData(UINT16 fixed_cid,BD_ADDR rem_bda,BT_HDR * p_buf)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 *******************************************************************************/
L2CA_RemoveFixedChnl(UINT16 fixed_cid,BD_ADDR rem_bda)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 *******************************************************************************/
L2CA_SetFixedChannelTout(BD_ADDR rem_bda,UINT16 fixed_cid,UINT16 idle_tout)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 *******************************************************************************/
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)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 *******************************************************************************/
L2CA_GetConnectionConfig(UINT16 lcid,UINT16 * mtu,UINT16 * rcid,UINT16 * handle)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 *******************************************************************************/
L2CA_RegForNoCPEvt(tL2CA_NOCP_CB * p_cb,BD_ADDR p_bda)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 *******************************************************************************/
L2CA_DataWrite(UINT16 cid,BT_HDR * p_data)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 *******************************************************************************/
L2CA_SetChnlFlushability(UINT16 cid,BOOLEAN is_flushable)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 *******************************************************************************/
L2CA_DataWriteEx(UINT16 cid,BT_HDR * p_data,UINT16 flags)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 *******************************************************************************/
L2CA_FlushChannel(UINT16 lcid,UINT16 num_to_flush)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