1 /******************************************************************************
2 *
3 * Copyright (C) 2004-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 1.2 Flow Control and retransmissions
22 * functions
23 *
24 ******************************************************************************/
25
26 #include <base/logging.h>
27 #include <log/log.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "bt_common.h"
33 #include "bt_types.h"
34 #include "btm_api.h"
35 #include "btm_int.h"
36 #include "btu.h"
37 #include "hcimsgs.h"
38 #include "l2c_api.h"
39 #include "l2c_int.h"
40 #include "l2cdefs.h"
41
42 /* Flag passed to retransmit_i_frames() when all packets should be retransmitted
43 */
44 #define L2C_FCR_RETX_ALL_PKTS 0xFF
45
46 /* this is the minimal offset required by OBX to process incoming packets */
47 static const uint16_t OBX_BUF_MIN_OFFSET = 4;
48
49 static const char* SAR_types[] = {"Unsegmented", "Start", "End",
50 "Continuation"};
51 static const char* SUP_types[] = {"RR", "REJ", "RNR", "SREJ"};
52
53 /* Look-up table for the CRC calculation */
54 static const unsigned short crctab[256] = {
55 0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601,
56 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0,
57 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81,
58 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941,
59 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01,
60 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0,
61 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081,
62 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
63 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00,
64 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0,
65 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981,
66 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41,
67 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700,
68 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0,
69 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281,
70 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
71 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01,
72 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1,
73 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80,
74 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541,
75 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101,
76 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0,
77 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481,
78 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
79 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801,
80 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1,
81 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581,
82 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341,
83 0x4100, 0x81c1, 0x8081, 0x4040,
84 };
85
86 /*******************************************************************************
87 * Static local functions
88 */
89 static bool process_reqseq(tL2C_CCB* p_ccb, uint16_t ctrl_word);
90 static void process_s_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf, uint16_t ctrl_word);
91 static void process_i_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf, uint16_t ctrl_word,
92 bool delay_ack);
93 static bool retransmit_i_frames(tL2C_CCB* p_ccb, uint8_t tx_seq);
94 static void prepare_I_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf,
95 bool is_retransmission);
96 static void process_stream_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf);
97 static bool do_sar_reassembly(tL2C_CCB* p_ccb, BT_HDR* p_buf,
98 uint16_t ctrl_word);
99
100 #if (L2CAP_ERTM_STATS == TRUE)
101 static void l2c_fcr_collect_ack_delay(tL2C_CCB* p_ccb, uint8_t num_bufs_acked);
102 #endif
103
104 /*******************************************************************************
105 *
106 * Function l2c_fcr_updcrc
107 *
108 * Description This function computes the CRC using the look-up table.
109 *
110 * Returns CRC
111 *
112 ******************************************************************************/
l2c_fcr_updcrc(unsigned short icrc,unsigned char * icp,int icnt)113 static unsigned short l2c_fcr_updcrc(unsigned short icrc, unsigned char* icp,
114 int icnt) {
115 unsigned short crc = icrc;
116 unsigned char* cp = icp;
117 int cnt = icnt;
118
119 while (cnt--) {
120 crc = ((crc >> 8) & 0xff) ^ crctab[(crc & 0xff) ^ *cp++];
121 }
122
123 return (crc);
124 }
125
126 /*******************************************************************************
127 *
128 * Function l2c_fcr_tx_get_fcs
129 *
130 * Description This function computes the CRC for a frame to be TXed.
131 *
132 * Returns CRC
133 *
134 ******************************************************************************/
l2c_fcr_tx_get_fcs(BT_HDR * p_buf)135 static uint16_t l2c_fcr_tx_get_fcs(BT_HDR* p_buf) {
136 uint8_t* p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
137
138 return (l2c_fcr_updcrc(L2CAP_FCR_INIT_CRC, p, p_buf->len));
139 }
140
141 /*******************************************************************************
142 *
143 * Function l2c_fcr_rx_get_fcs
144 *
145 * Description This function computes the CRC for a received frame.
146 *
147 * Returns CRC
148 *
149 ******************************************************************************/
l2c_fcr_rx_get_fcs(BT_HDR * p_buf)150 static uint16_t l2c_fcr_rx_get_fcs(BT_HDR* p_buf) {
151 uint8_t* p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
152
153 /* offset points past the L2CAP header, but the CRC check includes it */
154 p -= L2CAP_PKT_OVERHEAD;
155
156 return (
157 l2c_fcr_updcrc(L2CAP_FCR_INIT_CRC, p, p_buf->len + L2CAP_PKT_OVERHEAD));
158 }
159
160 /*******************************************************************************
161 *
162 * Function l2c_fcr_start_timer
163 *
164 * Description This function starts the (monitor or retransmission) timer.
165 *
166 * Returns -
167 *
168 ******************************************************************************/
l2c_fcr_start_timer(tL2C_CCB * p_ccb)169 void l2c_fcr_start_timer(tL2C_CCB* p_ccb) {
170 CHECK(p_ccb != NULL);
171 uint32_t tout;
172
173 /* The timers which are in milliseconds */
174 if (p_ccb->fcrb.wait_ack) {
175 tout = (uint32_t)p_ccb->our_cfg.fcr.mon_tout;
176 } else {
177 tout = (uint32_t)p_ccb->our_cfg.fcr.rtrans_tout;
178 }
179
180 /* Only start a timer that was not started */
181 if (!alarm_is_scheduled(p_ccb->fcrb.mon_retrans_timer)) {
182 alarm_set_on_mloop(p_ccb->fcrb.mon_retrans_timer, tout,
183 l2c_ccb_timer_timeout, p_ccb);
184 }
185 }
186
187 /*******************************************************************************
188 *
189 * Function l2c_fcr_stop_timer
190 *
191 * Description This function stops the (monitor or transmission) timer.
192 *
193 * Returns -
194 *
195 ******************************************************************************/
l2c_fcr_stop_timer(tL2C_CCB * p_ccb)196 void l2c_fcr_stop_timer(tL2C_CCB* p_ccb) {
197 CHECK(p_ccb != NULL);
198 alarm_cancel(p_ccb->fcrb.mon_retrans_timer);
199 }
200
201 /*******************************************************************************
202 *
203 * Function l2c_fcr_cleanup
204 *
205 * Description This function cleans up the variable used for
206 * flow-control/retrans.
207 *
208 * Returns -
209 *
210 ******************************************************************************/
l2c_fcr_cleanup(tL2C_CCB * p_ccb)211 void l2c_fcr_cleanup(tL2C_CCB* p_ccb) {
212 CHECK(p_ccb != NULL);
213 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
214
215 alarm_free(p_fcrb->mon_retrans_timer);
216 p_fcrb->mon_retrans_timer = NULL;
217 alarm_free(p_fcrb->ack_timer);
218 p_fcrb->ack_timer = NULL;
219
220 osi_free_and_reset((void**)&p_fcrb->p_rx_sdu);
221
222 fixed_queue_free(p_fcrb->waiting_for_ack_q, osi_free);
223 p_fcrb->waiting_for_ack_q = NULL;
224
225 fixed_queue_free(p_fcrb->srej_rcv_hold_q, osi_free);
226 p_fcrb->srej_rcv_hold_q = NULL;
227
228 fixed_queue_free(p_fcrb->retrans_q, osi_free);
229 p_fcrb->retrans_q = NULL;
230
231 #if (L2CAP_ERTM_STATS == TRUE)
232 if ((p_ccb->local_cid >= L2CAP_BASE_APPL_CID) &&
233 (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE)) {
234 uint32_t dur = time_get_os_boottime_ms() - p_ccb->fcrb.connect_tick_count;
235 size_t p_str_size = 120;
236 char* p_str = (char*)osi_malloc(p_str_size);
237 uint16_t i;
238 uint32_t throughput_avg, ack_delay_avg, ack_q_count_avg;
239
240 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
241 TRACE_TYPE_GENERIC,
242 "--- L2CAP ERTM Stats for CID: 0x%04x Duration: %08ums",
243 p_ccb->local_cid, dur);
244 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
245 TRACE_TYPE_GENERIC,
246 "Retransmissions:%08u Times Flow Controlled:%08u Retrans "
247 "Touts:%08u Ack Touts:%08u",
248 p_ccb->fcrb.pkts_retransmitted, p_ccb->fcrb.xmit_window_closed,
249 p_ccb->fcrb.retrans_touts, p_ccb->fcrb.xmit_ack_touts);
250 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
251 TRACE_TYPE_GENERIC,
252 "Times there is less than 2 packets in controller when flow "
253 "controlled:%08u",
254 p_ccb->fcrb.controller_idle);
255 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
256 TRACE_TYPE_GENERIC,
257 "max_held_acks:%08u, in_cfg.fcr.tx_win_sz:%08u",
258 p_ccb->fcrb.max_held_acks, p_ccb->peer_cfg.fcr.tx_win_sz);
259
260 snprintf(
261 p_str, p_str_size,
262 "Sent Pkts:%08u Bytes:%10u(%06u/sec) RR:%08u REJ:%08u RNR:%08u "
263 "SREJ:%08u",
264 p_ccb->fcrb.ertm_pkt_counts[0], p_ccb->fcrb.ertm_byte_counts[0],
265 (dur >= 10 ? (p_ccb->fcrb.ertm_byte_counts[0] * 100) / (dur / 10) : 0),
266 p_ccb->fcrb.s_frames_sent[0], p_ccb->fcrb.s_frames_sent[1],
267 p_ccb->fcrb.s_frames_sent[2], p_ccb->fcrb.s_frames_sent[3]);
268
269 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
270 TRACE_TYPE_GENERIC, "%s", p_str);
271
272 snprintf(
273 p_str, p_str_size,
274 "Rcvd Pkts:%08u Bytes:%10u(%06u/sec) RR:%08u REJ:%08u RNR:%08u "
275 "SREJ:%08u",
276 p_ccb->fcrb.ertm_pkt_counts[1], p_ccb->fcrb.ertm_byte_counts[1],
277 (dur >= 10 ? (p_ccb->fcrb.ertm_byte_counts[1] * 100) / (dur / 10) : 0),
278 p_ccb->fcrb.s_frames_rcvd[0], p_ccb->fcrb.s_frames_rcvd[1],
279 p_ccb->fcrb.s_frames_rcvd[2], p_ccb->fcrb.s_frames_rcvd[3]);
280
281 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
282 TRACE_TYPE_GENERIC, "%s", p_str);
283
284 throughput_avg = 0;
285 ack_delay_avg = 0;
286 ack_q_count_avg = 0;
287
288 for (i = 0; i < L2CAP_ERTM_STATS_NUM_AVG; i++) {
289 if (i == p_ccb->fcrb.ack_delay_avg_index) {
290 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
291 TRACE_TYPE_GENERIC, "[%02u] collecting data ...", i);
292 continue;
293 }
294
295 snprintf(p_str, p_str_size,
296 "[%02u] throughput: %5u, ack_delay avg:%3u, min:%3u, max:%3u, "
297 "ack_q_count avg:%3u, min:%3u, max:%3u",
298 i, p_ccb->fcrb.throughput[i], p_ccb->fcrb.ack_delay_avg[i],
299 p_ccb->fcrb.ack_delay_min[i], p_ccb->fcrb.ack_delay_max[i],
300 p_ccb->fcrb.ack_q_count_avg[i], p_ccb->fcrb.ack_q_count_min[i],
301 p_ccb->fcrb.ack_q_count_max[i]);
302
303 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
304 TRACE_TYPE_GENERIC, "%s", p_str);
305
306 throughput_avg += p_ccb->fcrb.throughput[i];
307 ack_delay_avg += p_ccb->fcrb.ack_delay_avg[i];
308 ack_q_count_avg += p_ccb->fcrb.ack_q_count_avg[i];
309 }
310
311 throughput_avg /= (L2CAP_ERTM_STATS_NUM_AVG - 1);
312 ack_delay_avg /= (L2CAP_ERTM_STATS_NUM_AVG - 1);
313 ack_q_count_avg /= (L2CAP_ERTM_STATS_NUM_AVG - 1);
314
315 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
316 TRACE_TYPE_GENERIC,
317 "throughput_avg: %8u (kbytes/sec), ack_delay_avg: %8u ms, "
318 "ack_q_count_avg: %8u",
319 throughput_avg, ack_delay_avg, ack_q_count_avg);
320
321 osi_free(p_str);
322
323 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
324 TRACE_TYPE_GENERIC, "---");
325 }
326 #endif
327
328 memset(p_fcrb, 0, sizeof(tL2C_FCRB));
329 }
330
331 /*******************************************************************************
332 *
333 * Function l2c_fcr_clone_buf
334 *
335 * Description This function allocates and copies requested part of a
336 * buffer at a new-offset.
337 *
338 * Returns pointer to new buffer
339 *
340 ******************************************************************************/
l2c_fcr_clone_buf(BT_HDR * p_buf,uint16_t new_offset,uint16_t no_of_bytes)341 BT_HDR* l2c_fcr_clone_buf(BT_HDR* p_buf, uint16_t new_offset,
342 uint16_t no_of_bytes) {
343 CHECK(p_buf != NULL);
344 /*
345 * NOTE: We allocate extra L2CAP_FCS_LEN octets, in case we need to put
346 * the FCS (Frame Check Sequence) at the end of the buffer.
347 */
348 uint16_t buf_size = no_of_bytes + sizeof(BT_HDR) + new_offset + L2CAP_FCS_LEN;
349 #if (L2CAP_ERTM_STATS == TRUE)
350 /*
351 * NOTE: If L2CAP_ERTM_STATS is enabled, we need 4 extra octets at the
352 * end for a timestamp at the end of an I-frame.
353 */
354 buf_size += sizeof(uint32_t);
355 #endif
356 BT_HDR* p_buf2 = (BT_HDR*)osi_malloc(buf_size);
357
358 p_buf2->offset = new_offset;
359 p_buf2->len = no_of_bytes;
360 memcpy(((uint8_t*)(p_buf2 + 1)) + p_buf2->offset,
361 ((uint8_t*)(p_buf + 1)) + p_buf->offset, no_of_bytes);
362
363 return (p_buf2);
364 }
365
366 /*******************************************************************************
367 *
368 * Function l2c_fcr_is_flow_controlled
369 *
370 * Description This function checks if the CCB is flow controlled by peer.
371 *
372 * Returns The control word
373 *
374 ******************************************************************************/
l2c_fcr_is_flow_controlled(tL2C_CCB * p_ccb)375 bool l2c_fcr_is_flow_controlled(tL2C_CCB* p_ccb) {
376 CHECK(p_ccb != NULL);
377 if (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE) {
378 /* Check if remote side flowed us off or the transmit window is full */
379 if ((p_ccb->fcrb.remote_busy == true) ||
380 (fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q) >=
381 p_ccb->peer_cfg.fcr.tx_win_sz)) {
382 #if (L2CAP_ERTM_STATS == TRUE)
383 if (!fixed_queue_is_empty(p_ccb->xmit_hold_q)) {
384 p_ccb->fcrb.xmit_window_closed++;
385
386 if ((p_ccb->p_lcb->sent_not_acked < 2) &&
387 (l2cb.controller_xmit_window > 0))
388 p_ccb->fcrb.controller_idle++;
389 }
390 #endif
391 return (true);
392 }
393 }
394 return (false);
395 }
396
397 /*******************************************************************************
398 *
399 * Function prepare_I_frame
400 *
401 * Description This function sets the FCR variables in an I-frame that is
402 * about to be sent to HCI for transmission. This may be the
403 * first time the I-frame is sent, or a retransmission
404 *
405 * Returns -
406 *
407 ******************************************************************************/
prepare_I_frame(tL2C_CCB * p_ccb,BT_HDR * p_buf,bool is_retransmission)408 static void prepare_I_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf,
409 bool is_retransmission) {
410 CHECK(p_ccb != NULL);
411 CHECK(p_buf != NULL);
412 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
413 uint8_t* p;
414 uint16_t fcs;
415 uint16_t ctrl_word;
416 bool set_f_bit = p_fcrb->send_f_rsp;
417
418 p_fcrb->send_f_rsp = false;
419
420 if (is_retransmission) {
421 /* Get the old control word and clear out the old req_seq and F bits */
422 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + L2CAP_PKT_OVERHEAD;
423
424 STREAM_TO_UINT16(ctrl_word, p);
425
426 ctrl_word &= ~(L2CAP_FCR_REQ_SEQ_BITS + L2CAP_FCR_F_BIT);
427 } else {
428 ctrl_word = p_buf->layer_specific & L2CAP_FCR_SEG_BITS; /* SAR bits */
429 ctrl_word |=
430 (p_fcrb->next_tx_seq << L2CAP_FCR_TX_SEQ_BITS_SHIFT); /* Tx Seq */
431
432 p_fcrb->next_tx_seq = (p_fcrb->next_tx_seq + 1) & L2CAP_FCR_SEQ_MODULO;
433 }
434
435 /* Set the F-bit and reqseq only if using re-transmission mode */
436 if (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE) {
437 if (set_f_bit) ctrl_word |= L2CAP_FCR_F_BIT;
438
439 ctrl_word |= (p_fcrb->next_seq_expected) << L2CAP_FCR_REQ_SEQ_BITS_SHIFT;
440
441 p_fcrb->last_ack_sent = p_ccb->fcrb.next_seq_expected;
442
443 alarm_cancel(p_ccb->fcrb.ack_timer);
444 }
445
446 /* Set the control word */
447 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + L2CAP_PKT_OVERHEAD;
448
449 UINT16_TO_STREAM(p, ctrl_word);
450
451 /* Compute the FCS and add to the end of the buffer if not bypassed */
452 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) {
453 /* length field in l2cap header has to include FCS length */
454 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
455 UINT16_TO_STREAM(p, p_buf->len + L2CAP_FCS_LEN - L2CAP_PKT_OVERHEAD);
456
457 /* Calculate the FCS */
458 fcs = l2c_fcr_tx_get_fcs(p_buf);
459
460 /* Point to the end of the buffer and put the FCS there */
461 /*
462 * NOTE: Here we assume the allocated buffer is large enough
463 * to include extra L2CAP_FCS_LEN octets at the end.
464 */
465 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + p_buf->len;
466
467 UINT16_TO_STREAM(p, fcs);
468
469 p_buf->len += L2CAP_FCS_LEN;
470 }
471
472 if (is_retransmission) {
473 L2CAP_TRACE_EVENT(
474 "L2CAP eRTM ReTx I-frame CID: 0x%04x Len: %u SAR: %s TxSeq: %u "
475 "ReqSeq: %u F: %u",
476 p_ccb->local_cid, p_buf->len,
477 SAR_types[(ctrl_word & L2CAP_FCR_SAR_BITS) >> L2CAP_FCR_SAR_BITS_SHIFT],
478 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT,
479 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
480 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
481 } else {
482 L2CAP_TRACE_EVENT(
483 "L2CAP eRTM Tx I-frame CID: 0x%04x Len: %u SAR: %-12s TxSeq: %u "
484 "ReqSeq: %u F: %u",
485 p_ccb->local_cid, p_buf->len,
486 SAR_types[(ctrl_word & L2CAP_FCR_SAR_BITS) >> L2CAP_FCR_SAR_BITS_SHIFT],
487 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT,
488 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
489 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
490 }
491
492 /* Start the retransmission timer if not already running */
493 if (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE)
494 l2c_fcr_start_timer(p_ccb);
495 }
496
497 /*******************************************************************************
498 *
499 * Function l2c_fcr_send_S_frame
500 *
501 * Description This function formats and sends an S-frame for transmission.
502 *
503 * Returns -
504 *
505 ******************************************************************************/
l2c_fcr_send_S_frame(tL2C_CCB * p_ccb,uint16_t function_code,uint16_t pf_bit)506 void l2c_fcr_send_S_frame(tL2C_CCB* p_ccb, uint16_t function_code,
507 uint16_t pf_bit) {
508 CHECK(p_ccb != NULL);
509 uint8_t* p;
510 uint16_t ctrl_word;
511 uint16_t fcs;
512
513 if ((!p_ccb->in_use) || (p_ccb->chnl_state != CST_OPEN)) return;
514
515 #if (L2CAP_ERTM_STATS == TRUE)
516 p_ccb->fcrb.s_frames_sent[function_code]++;
517 #endif
518
519 if (pf_bit == L2CAP_FCR_P_BIT) {
520 p_ccb->fcrb.wait_ack = true;
521
522 l2c_fcr_stop_timer(p_ccb); /* Restart the monitor timer */
523 l2c_fcr_start_timer(p_ccb);
524 }
525
526 /* Create the control word to use */
527 ctrl_word = (function_code << L2CAP_FCR_SUP_SHIFT) | L2CAP_FCR_S_FRAME_BIT;
528 ctrl_word |= (p_ccb->fcrb.next_seq_expected << L2CAP_FCR_REQ_SEQ_BITS_SHIFT);
529 ctrl_word |= pf_bit;
530
531 BT_HDR* p_buf = (BT_HDR*)osi_malloc(L2CAP_CMD_BUF_SIZE);
532 p_buf->offset = HCI_DATA_PREAMBLE_SIZE;
533 p_buf->len = L2CAP_PKT_OVERHEAD + L2CAP_FCR_OVERHEAD;
534
535 /* Set the pointer to the beginning of the data */
536 p = (uint8_t*)(p_buf + 1) + p_buf->offset;
537
538 /* Put in the L2CAP header */
539 UINT16_TO_STREAM(p, L2CAP_FCR_OVERHEAD + L2CAP_FCS_LEN);
540 UINT16_TO_STREAM(p, p_ccb->remote_cid);
541 UINT16_TO_STREAM(p, ctrl_word);
542
543 /* Compute the FCS and add to the end of the buffer if not bypassed */
544 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) {
545 fcs = l2c_fcr_tx_get_fcs(p_buf);
546
547 UINT16_TO_STREAM(p, fcs);
548 p_buf->len += L2CAP_FCS_LEN;
549 } else {
550 /* rewrite the length without FCS length */
551 p -= 6;
552 UINT16_TO_STREAM(p, L2CAP_FCR_OVERHEAD);
553 }
554
555 /* Now, the HCI transport header */
556 p_buf->layer_specific = L2CAP_NON_FLUSHABLE_PKT;
557 l2cu_set_acl_hci_header(p_buf, p_ccb);
558
559 if ((((ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT) == 1) ||
560 (((ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT) == 3)) {
561 L2CAP_TRACE_WARNING(
562 "L2CAP eRTM Tx S-frame CID: 0x%04x ctrlword: 0x%04x Type: %s "
563 "ReqSeq: %u P: %u F: %u",
564 p_ccb->local_cid, ctrl_word,
565 SUP_types[(ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT],
566 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
567 (ctrl_word & L2CAP_FCR_P_BIT) >> L2CAP_FCR_P_BIT_SHIFT,
568 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
569 L2CAP_TRACE_WARNING(" Buf Len: %u", p_buf->len);
570 } else {
571 L2CAP_TRACE_EVENT(
572 "L2CAP eRTM Tx S-frame CID: 0x%04x ctrlword: 0x%04x Type: %s "
573 "ReqSeq: %u P: %u F: %u",
574 p_ccb->local_cid, ctrl_word,
575 SUP_types[(ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT],
576 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
577 (ctrl_word & L2CAP_FCR_P_BIT) >> L2CAP_FCR_P_BIT_SHIFT,
578 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
579 L2CAP_TRACE_EVENT(" Buf Len: %u", p_buf->len);
580 }
581
582 l2c_link_check_send_pkts(p_ccb->p_lcb, NULL, p_buf);
583
584 p_ccb->fcrb.last_ack_sent = p_ccb->fcrb.next_seq_expected;
585
586 alarm_cancel(p_ccb->fcrb.ack_timer);
587 }
588
589 /*******************************************************************************
590 *
591 * Function l2c_fcr_proc_pdu
592 *
593 * Description This function is the entry point for processing of a
594 * received PDU when in flow control and/or retransmission
595 * modes.
596 *
597 * Returns -
598 *
599 ******************************************************************************/
l2c_fcr_proc_pdu(tL2C_CCB * p_ccb,BT_HDR * p_buf)600 void l2c_fcr_proc_pdu(tL2C_CCB* p_ccb, BT_HDR* p_buf) {
601 CHECK(p_ccb != NULL);
602 CHECK(p_buf != NULL);
603 uint8_t* p;
604 uint16_t fcs;
605 uint16_t min_pdu_len;
606 uint16_t ctrl_word;
607
608 /* Check the length */
609 min_pdu_len = (p_ccb->bypass_fcs == L2CAP_BYPASS_FCS)
610 ? (uint16_t)L2CAP_FCR_OVERHEAD
611 : (uint16_t)(L2CAP_FCS_LEN + L2CAP_FCR_OVERHEAD);
612
613 if (p_buf->len < min_pdu_len) {
614 L2CAP_TRACE_WARNING("Rx L2CAP PDU: CID: 0x%04x Len too short: %u",
615 p_ccb->local_cid, p_buf->len);
616 osi_free(p_buf);
617 return;
618 }
619
620 if (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_STREAM_MODE) {
621 process_stream_frame(p_ccb, p_buf);
622 return;
623 }
624
625 /* Get the control word */
626 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
627 STREAM_TO_UINT16(ctrl_word, p);
628
629 if (ctrl_word & L2CAP_FCR_S_FRAME_BIT) {
630 if ((((ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT) == 1) ||
631 (((ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT) == 3)) {
632 /* REJ or SREJ */
633 L2CAP_TRACE_WARNING(
634 "L2CAP eRTM Rx S-frame: cid: 0x%04x Len: %u Type: %s ReqSeq: %u "
635 "P: %u F: %u",
636 p_ccb->local_cid, p_buf->len,
637 SUP_types[(ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT],
638 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
639 (ctrl_word & L2CAP_FCR_P_BIT) >> L2CAP_FCR_P_BIT_SHIFT,
640 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
641 } else {
642 L2CAP_TRACE_EVENT(
643 "L2CAP eRTM Rx S-frame: cid: 0x%04x Len: %u Type: %s ReqSeq: %u "
644 "P: %u F: %u",
645 p_ccb->local_cid, p_buf->len,
646 SUP_types[(ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT],
647 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
648 (ctrl_word & L2CAP_FCR_P_BIT) >> L2CAP_FCR_P_BIT_SHIFT,
649 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
650 }
651 } else {
652 L2CAP_TRACE_EVENT(
653 "L2CAP eRTM Rx I-frame: cid: 0x%04x Len: %u SAR: %-12s TxSeq: %u "
654 "ReqSeq: %u F: %u",
655 p_ccb->local_cid, p_buf->len,
656 SAR_types[(ctrl_word & L2CAP_FCR_SAR_BITS) >> L2CAP_FCR_SAR_BITS_SHIFT],
657 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT,
658 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
659 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
660 }
661
662 L2CAP_TRACE_EVENT(
663 " eRTM Rx Nxt_tx_seq %u, Lst_rx_ack %u, Nxt_seq_exp %u, Lst_ack_snt "
664 "%u, wt_q.cnt %u, tries %u",
665 p_ccb->fcrb.next_tx_seq, p_ccb->fcrb.last_rx_ack,
666 p_ccb->fcrb.next_seq_expected, p_ccb->fcrb.last_ack_sent,
667 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q), p_ccb->fcrb.num_tries);
668
669 /* Verify FCS if using */
670 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) {
671 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + p_buf->len - L2CAP_FCS_LEN;
672
673 /* Extract and drop the FCS from the packet */
674 STREAM_TO_UINT16(fcs, p);
675 p_buf->len -= L2CAP_FCS_LEN;
676
677 if (l2c_fcr_rx_get_fcs(p_buf) != fcs) {
678 L2CAP_TRACE_WARNING("Rx L2CAP PDU: CID: 0x%04x BAD FCS",
679 p_ccb->local_cid);
680 osi_free(p_buf);
681 return;
682 }
683 }
684
685 /* Get the control word */
686 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
687
688 STREAM_TO_UINT16(ctrl_word, p);
689
690 p_buf->len -= L2CAP_FCR_OVERHEAD;
691 p_buf->offset += L2CAP_FCR_OVERHEAD;
692
693 /* If we had a poll bit outstanding, check if we got a final response */
694 if (p_ccb->fcrb.wait_ack) {
695 /* If final bit not set, ignore the frame unless it is a polled S-frame */
696 if (!(ctrl_word & L2CAP_FCR_F_BIT)) {
697 if ((ctrl_word & L2CAP_FCR_P_BIT) &&
698 (ctrl_word & L2CAP_FCR_S_FRAME_BIT)) {
699 if (p_ccb->fcrb.srej_sent)
700 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_SREJ, L2CAP_FCR_F_BIT);
701 else if (p_ccb->fcrb.local_busy)
702 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, L2CAP_FCR_F_BIT);
703 else
704 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, L2CAP_FCR_F_BIT);
705
706 /* Got a poll while in wait_ack state, so re-start our timer with
707 * 1-second */
708 /* This is a small optimization... the monitor timer is 12 secs, but we
709 * saw */
710 /* that if the other side sends us a poll when we are waiting for a
711 * final, */
712 /* then it speeds up recovery significantly if we poll him back soon
713 * after his poll. */
714 alarm_set_on_mloop(p_ccb->fcrb.mon_retrans_timer, BT_1SEC_TIMEOUT_MS,
715 l2c_ccb_timer_timeout, p_ccb);
716 }
717 osi_free(p_buf);
718 return;
719 }
720
721 p_ccb->fcrb.wait_ack = false;
722
723 /* P and F are mutually exclusive */
724 if (ctrl_word & L2CAP_FCR_S_FRAME_BIT) ctrl_word &= ~L2CAP_FCR_P_BIT;
725
726 if (fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q))
727 p_ccb->fcrb.num_tries = 0;
728
729 l2c_fcr_stop_timer(p_ccb);
730 } else {
731 /* Otherwise, ensure the final bit is ignored */
732 ctrl_word &= ~L2CAP_FCR_F_BIT;
733 }
734
735 /* Process receive sequence number */
736 if (!process_reqseq(p_ccb, ctrl_word)) {
737 osi_free(p_buf);
738 return;
739 }
740
741 /* Process based on whether it is an S-frame or an I-frame */
742 if (ctrl_word & L2CAP_FCR_S_FRAME_BIT)
743 process_s_frame(p_ccb, p_buf, ctrl_word);
744 else
745 process_i_frame(p_ccb, p_buf, ctrl_word, false);
746
747 /* Return if the channel got disconnected by a bad packet or max
748 * retransmissions */
749 if ((!p_ccb->in_use) || (p_ccb->chnl_state != CST_OPEN)) return;
750
751 /* If we have some buffers held while doing SREJ, and SREJ has cleared,
752 * process them now */
753 if ((!p_ccb->fcrb.local_busy) && (!p_ccb->fcrb.srej_sent) &&
754 (!fixed_queue_is_empty(p_ccb->fcrb.srej_rcv_hold_q))) {
755 fixed_queue_t* temp_q = p_ccb->fcrb.srej_rcv_hold_q;
756 p_ccb->fcrb.srej_rcv_hold_q = fixed_queue_new(SIZE_MAX);
757
758 while ((p_buf = (BT_HDR*)fixed_queue_try_dequeue(temp_q)) != NULL) {
759 if (p_ccb->in_use && (p_ccb->chnl_state == CST_OPEN)) {
760 /* Get the control word */
761 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset - L2CAP_FCR_OVERHEAD;
762
763 STREAM_TO_UINT16(ctrl_word, p);
764
765 L2CAP_TRACE_DEBUG(
766 "l2c_fcr_proc_pdu() CID: 0x%04x Process Buffer from SREJ_Hold_Q "
767 "TxSeq: %u Expected_Seq: %u",
768 p_ccb->local_cid,
769 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT,
770 p_ccb->fcrb.next_seq_expected);
771
772 /* Process the SREJ held I-frame, but do not send an RR for each
773 * individual frame */
774 process_i_frame(p_ccb, p_buf, ctrl_word, true);
775 } else
776 osi_free(p_buf);
777
778 /* If more frames were lost during SREJ, send a REJ */
779 if (p_ccb->fcrb.rej_after_srej) {
780 p_ccb->fcrb.rej_after_srej = false;
781 p_ccb->fcrb.rej_sent = true;
782
783 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_REJ, 0);
784 }
785 }
786 fixed_queue_free(temp_q, NULL);
787
788 /* Now, if needed, send one RR for the whole held queue */
789 if ((!p_ccb->fcrb.local_busy) && (!p_ccb->fcrb.rej_sent) &&
790 (!p_ccb->fcrb.srej_sent) &&
791 (p_ccb->fcrb.next_seq_expected != p_ccb->fcrb.last_ack_sent))
792 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, 0);
793 else {
794 L2CAP_TRACE_DEBUG(
795 "l2c_fcr_proc_pdu() not sending RR CID: 0x%04x local_busy:%d "
796 "rej_sent:%d srej_sent:%d Expected_Seq:%u Last_Ack:%u",
797 p_ccb->local_cid, p_ccb->fcrb.local_busy, p_ccb->fcrb.rej_sent,
798 p_ccb->fcrb.srej_sent, p_ccb->fcrb.next_seq_expected,
799 p_ccb->fcrb.last_ack_sent);
800 }
801 }
802
803 /* If a window has opened, check if we can send any more packets */
804 if ((!fixed_queue_is_empty(p_ccb->fcrb.retrans_q) ||
805 !fixed_queue_is_empty(p_ccb->xmit_hold_q)) &&
806 (p_ccb->fcrb.wait_ack == false) &&
807 (l2c_fcr_is_flow_controlled(p_ccb) == false)) {
808 l2c_link_check_send_pkts(p_ccb->p_lcb, NULL, NULL);
809 }
810 }
811
812 /*******************************************************************************
813 *
814 * Function l2c_lcc_proc_pdu
815 *
816 * Description This function is the entry point for processing of a
817 * received PDU when in LE Coc flow control modes.
818 *
819 * Returns -
820 *
821 ******************************************************************************/
l2c_lcc_proc_pdu(tL2C_CCB * p_ccb,BT_HDR * p_buf)822 void l2c_lcc_proc_pdu(tL2C_CCB* p_ccb, BT_HDR* p_buf) {
823 CHECK(p_ccb != NULL);
824 CHECK(p_buf != NULL);
825 uint8_t* p = (uint8_t*)(p_buf + 1) + p_buf->offset;
826 uint16_t sdu_length;
827 BT_HDR* p_data = NULL;
828
829 /* Buffer length should not exceed local mps */
830 if (p_buf->len > p_ccb->local_conn_cfg.mps) {
831 /* Discard the buffer */
832 osi_free(p_buf);
833 return;
834 }
835
836 if (p_ccb->is_first_seg) {
837 if (p_buf->len < sizeof(sdu_length)) {
838 L2CAP_TRACE_ERROR("%s: buffer length=%d too small. Need at least 2.",
839 __func__, p_buf->len);
840 android_errorWriteWithInfoLog(0x534e4554, "120665616", -1, NULL, 0);
841 /* Discard the buffer */
842 osi_free(p_buf);
843 return;
844 }
845 STREAM_TO_UINT16(sdu_length, p);
846
847 /* Check the SDU Length with local MTU size */
848 if (sdu_length > p_ccb->local_conn_cfg.mtu) {
849 /* Discard the buffer */
850 osi_free(p_buf);
851 return;
852 }
853
854 p_buf->len -= sizeof(sdu_length);
855 p_buf->offset += sizeof(sdu_length);
856
857 if (sdu_length < p_buf->len) {
858 L2CAP_TRACE_ERROR("%s: Invalid sdu_length: %d", __func__, sdu_length);
859 android_errorWriteWithInfoLog(0x534e4554, "112321180", -1, NULL, 0);
860 /* Discard the buffer */
861 osi_free(p_buf);
862 return;
863 }
864
865 p_data = (BT_HDR*)osi_malloc(L2CAP_MAX_BUF_SIZE);
866 if (p_data == NULL) {
867 osi_free(p_buf);
868 return;
869 }
870
871 p_ccb->ble_sdu = p_data;
872 p_data->len = 0;
873 p_ccb->ble_sdu_length = sdu_length;
874 L2CAP_TRACE_DEBUG("%s SDU Length = %d", __func__, sdu_length);
875 p_data->offset = 0;
876
877 } else {
878 p_data = p_ccb->ble_sdu;
879 if (p_buf->len > (p_ccb->ble_sdu_length - p_data->len)) {
880 L2CAP_TRACE_ERROR("%s: buffer length=%d too big. max=%d. Dropped",
881 __func__, p_data->len,
882 (p_ccb->ble_sdu_length - p_data->len));
883 android_errorWriteWithInfoLog(0x534e4554, "75298652", -1, NULL, 0);
884 osi_free(p_buf);
885
886 /* Throw away all pending fragments and disconnects */
887 p_ccb->is_first_seg = true;
888 osi_free(p_ccb->ble_sdu);
889 p_ccb->ble_sdu = NULL;
890 p_ccb->ble_sdu_length = 0;
891 l2cu_disconnect_chnl(p_ccb);
892 return;
893 }
894 }
895
896 memcpy((uint8_t*)(p_data + 1) + p_data->offset + p_data->len,
897 (uint8_t*)(p_buf + 1) + p_buf->offset, p_buf->len);
898 p_data->len += p_buf->len;
899 p = (uint8_t*)(p_data + 1) + p_data->offset;
900 if (p_data->len == p_ccb->ble_sdu_length) {
901 l2c_csm_execute(p_ccb, L2CEVT_L2CAP_DATA, p_data);
902 p_ccb->is_first_seg = true;
903 p_ccb->ble_sdu = NULL;
904 p_ccb->ble_sdu_length = 0;
905 } else if (p_data->len < p_ccb->ble_sdu_length) {
906 p_ccb->is_first_seg = false;
907 }
908
909 osi_free(p_buf);
910 return;
911 }
912
913 /*******************************************************************************
914 *
915 * Function l2c_fcr_proc_tout
916 *
917 * Description Handle a timeout. We should be in error recovery state.
918 *
919 * Returns -
920 *
921 ******************************************************************************/
l2c_fcr_proc_tout(tL2C_CCB * p_ccb)922 void l2c_fcr_proc_tout(tL2C_CCB* p_ccb) {
923 CHECK(p_ccb != NULL);
924 L2CAP_TRACE_DEBUG(
925 "l2c_fcr_proc_tout: CID: 0x%04x num_tries: %u (max: %u) wait_ack: %u "
926 "ack_q_count: %u",
927 p_ccb->local_cid, p_ccb->fcrb.num_tries, p_ccb->peer_cfg.fcr.max_transmit,
928 p_ccb->fcrb.wait_ack, fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q));
929
930 #if (L2CAP_ERTM_STATS == TRUE)
931 p_ccb->fcrb.retrans_touts++;
932 #endif
933
934 if ((p_ccb->peer_cfg.fcr.max_transmit != 0) &&
935 (++p_ccb->fcrb.num_tries > p_ccb->peer_cfg.fcr.max_transmit)) {
936 l2cu_disconnect_chnl(p_ccb);
937 } else {
938 if (!p_ccb->fcrb.srej_sent && !p_ccb->fcrb.rej_sent) {
939 if (p_ccb->fcrb.local_busy)
940 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, L2CAP_FCR_P_BIT);
941 else
942 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, L2CAP_FCR_P_BIT);
943 }
944 }
945 }
946
947 /*******************************************************************************
948 *
949 * Function l2c_fcr_proc_ack_tout
950 *
951 * Description Send RR/RNR if we have not acked I frame
952 *
953 * Returns -
954 *
955 ******************************************************************************/
l2c_fcr_proc_ack_tout(tL2C_CCB * p_ccb)956 void l2c_fcr_proc_ack_tout(tL2C_CCB* p_ccb) {
957 CHECK(p_ccb != NULL);
958 L2CAP_TRACE_DEBUG(
959 "l2c_fcr_proc_ack_tout: CID: 0x%04x State: %u Wack:%u Rq:%d Acked:%d",
960 p_ccb->local_cid, p_ccb->chnl_state, p_ccb->fcrb.wait_ack,
961 p_ccb->fcrb.next_seq_expected, p_ccb->fcrb.last_ack_sent);
962
963 if ((p_ccb->chnl_state == CST_OPEN) && (!p_ccb->fcrb.wait_ack) &&
964 (p_ccb->fcrb.last_ack_sent != p_ccb->fcrb.next_seq_expected)) {
965 #if (L2CAP_ERTM_STATS == TRUE)
966 p_ccb->fcrb.xmit_ack_touts++;
967 #endif
968 if (p_ccb->fcrb.local_busy)
969 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, 0);
970 else
971 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, 0);
972 }
973 }
974
975 /*******************************************************************************
976 *
977 * Function process_reqseq
978 *
979 * Description Handle receive sequence number
980 *
981 * Returns -
982 *
983 ******************************************************************************/
process_reqseq(tL2C_CCB * p_ccb,uint16_t ctrl_word)984 static bool process_reqseq(tL2C_CCB* p_ccb, uint16_t ctrl_word) {
985 CHECK(p_ccb != NULL);
986 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
987 uint8_t req_seq, num_bufs_acked, xx;
988 uint16_t ls;
989 uint16_t full_sdus_xmitted;
990
991 /* Receive sequence number does not ack anything for SREJ with P-bit set to
992 * zero */
993 if ((ctrl_word & L2CAP_FCR_S_FRAME_BIT) &&
994 ((ctrl_word & L2CAP_FCR_SUP_BITS) ==
995 (L2CAP_FCR_SUP_SREJ << L2CAP_FCR_SUP_SHIFT)) &&
996 ((ctrl_word & L2CAP_FCR_P_BIT) == 0)) {
997 /* If anything still waiting for ack, restart the timer if it was stopped */
998 if (!fixed_queue_is_empty(p_fcrb->waiting_for_ack_q))
999 l2c_fcr_start_timer(p_ccb);
1000
1001 return (true);
1002 }
1003
1004 /* Extract the receive sequence number from the control word */
1005 req_seq =
1006 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT;
1007
1008 num_bufs_acked = (req_seq - p_fcrb->last_rx_ack) & L2CAP_FCR_SEQ_MODULO;
1009
1010 /* Verify the request sequence is in range before proceeding */
1011 if (num_bufs_acked > fixed_queue_length(p_fcrb->waiting_for_ack_q)) {
1012 /* The channel is closed if ReqSeq is not in range */
1013 L2CAP_TRACE_WARNING(
1014 "L2CAP eRTM Frame BAD Req_Seq - ctrl_word: 0x%04x req_seq 0x%02x "
1015 "last_rx_ack: 0x%02x QCount: %u",
1016 ctrl_word, req_seq, p_fcrb->last_rx_ack,
1017 fixed_queue_length(p_fcrb->waiting_for_ack_q));
1018
1019 l2cu_disconnect_chnl(p_ccb);
1020 return (false);
1021 }
1022
1023 p_fcrb->last_rx_ack = req_seq;
1024
1025 /* Now we can release all acknowledged frames, and restart the retransmission
1026 * timer if needed */
1027 if (num_bufs_acked != 0) {
1028 p_fcrb->num_tries = 0;
1029 full_sdus_xmitted = 0;
1030
1031 #if (L2CAP_ERTM_STATS == TRUE)
1032 l2c_fcr_collect_ack_delay(p_ccb, num_bufs_acked);
1033 #endif
1034
1035 for (xx = 0; xx < num_bufs_acked; xx++) {
1036 BT_HDR* p_tmp =
1037 (BT_HDR*)fixed_queue_try_dequeue(p_fcrb->waiting_for_ack_q);
1038 ls = p_tmp->layer_specific & L2CAP_FCR_SAR_BITS;
1039
1040 if ((ls == L2CAP_FCR_UNSEG_SDU) || (ls == L2CAP_FCR_END_SDU))
1041 full_sdus_xmitted++;
1042
1043 osi_free(p_tmp);
1044 }
1045
1046 /* If we are still in a wait_ack state, do not mess with the timer */
1047 if (!p_ccb->fcrb.wait_ack) l2c_fcr_stop_timer(p_ccb);
1048
1049 /* Check if we need to call the "packet_sent" callback */
1050 if ((p_ccb->p_rcb) && (p_ccb->p_rcb->api.pL2CA_TxComplete_Cb) &&
1051 (full_sdus_xmitted)) {
1052 /* Special case for eRTM, if all packets sent, send 0xFFFF */
1053 if (fixed_queue_is_empty(p_fcrb->waiting_for_ack_q) &&
1054 fixed_queue_is_empty(p_ccb->xmit_hold_q)) {
1055 full_sdus_xmitted = 0xFFFF;
1056 }
1057
1058 (*p_ccb->p_rcb->api.pL2CA_TxComplete_Cb)(p_ccb->local_cid,
1059 full_sdus_xmitted);
1060 }
1061 }
1062
1063 /* If anything still waiting for ack, restart the timer if it was stopped */
1064 if (!fixed_queue_is_empty(p_fcrb->waiting_for_ack_q))
1065 l2c_fcr_start_timer(p_ccb);
1066 return (true);
1067 }
1068
1069 /*******************************************************************************
1070 *
1071 * Function process_s_frame
1072 *
1073 * Description Process an S frame
1074 *
1075 * Returns -
1076 *
1077 ******************************************************************************/
process_s_frame(tL2C_CCB * p_ccb,BT_HDR * p_buf,uint16_t ctrl_word)1078 static void process_s_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf,
1079 uint16_t ctrl_word) {
1080 CHECK(p_ccb != NULL);
1081 CHECK(p_buf != NULL);
1082
1083 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
1084 uint16_t s_frame_type =
1085 (ctrl_word & L2CAP_FCR_SUP_BITS) >> L2CAP_FCR_SUP_SHIFT;
1086 bool remote_was_busy;
1087 bool all_ok = true;
1088
1089 if (p_buf->len != 0) {
1090 L2CAP_TRACE_WARNING("Incorrect S-frame Length (%d)", p_buf->len);
1091 }
1092
1093 L2CAP_TRACE_DEBUG("process_s_frame ctrl_word 0x%04x fcrb_remote_busy:%d",
1094 ctrl_word, p_fcrb->remote_busy);
1095
1096 #if (L2CAP_ERTM_STATS == TRUE)
1097 p_ccb->fcrb.s_frames_rcvd[s_frame_type]++;
1098 #endif
1099
1100 if (ctrl_word & L2CAP_FCR_P_BIT) {
1101 p_fcrb->rej_sent = false; /* After checkpoint, we can send anoher REJ */
1102 p_fcrb->send_f_rsp = true; /* Set a flag in case an I-frame is pending */
1103 }
1104
1105 switch (s_frame_type) {
1106 case L2CAP_FCR_SUP_RR:
1107 remote_was_busy = p_fcrb->remote_busy;
1108 p_fcrb->remote_busy = false;
1109
1110 if ((ctrl_word & L2CAP_FCR_F_BIT) || (remote_was_busy))
1111 all_ok = retransmit_i_frames(p_ccb, L2C_FCR_RETX_ALL_PKTS);
1112 break;
1113
1114 case L2CAP_FCR_SUP_REJ:
1115 p_fcrb->remote_busy = false;
1116 all_ok = retransmit_i_frames(p_ccb, L2C_FCR_RETX_ALL_PKTS);
1117 break;
1118
1119 case L2CAP_FCR_SUP_RNR:
1120 p_fcrb->remote_busy = true;
1121 l2c_fcr_stop_timer(p_ccb);
1122 break;
1123
1124 case L2CAP_FCR_SUP_SREJ:
1125 p_fcrb->remote_busy = false;
1126 all_ok = retransmit_i_frames(
1127 p_ccb, (uint8_t)((ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >>
1128 L2CAP_FCR_REQ_SEQ_BITS_SHIFT));
1129 break;
1130 }
1131
1132 if (all_ok) {
1133 /* If polled, we need to respond with F-bit. Note, we may have sent a
1134 * I-frame with the F-bit */
1135 if (p_fcrb->send_f_rsp) {
1136 if (p_fcrb->srej_sent)
1137 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_SREJ, L2CAP_FCR_F_BIT);
1138 else if (p_fcrb->local_busy)
1139 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, L2CAP_FCR_F_BIT);
1140 else
1141 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, L2CAP_FCR_F_BIT);
1142
1143 p_fcrb->send_f_rsp = false;
1144 }
1145 } else {
1146 L2CAP_TRACE_DEBUG("process_s_frame hit_max_retries");
1147 }
1148
1149 osi_free(p_buf);
1150 }
1151
1152 /*******************************************************************************
1153 *
1154 * Function process_i_frame
1155 *
1156 * Description Process an I frame
1157 *
1158 * Returns -
1159 *
1160 ******************************************************************************/
process_i_frame(tL2C_CCB * p_ccb,BT_HDR * p_buf,uint16_t ctrl_word,bool delay_ack)1161 static void process_i_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf, uint16_t ctrl_word,
1162 bool delay_ack) {
1163 CHECK(p_ccb != NULL);
1164 CHECK(p_buf != NULL);
1165
1166 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
1167 uint8_t tx_seq, num_lost, num_to_ack, next_srej;
1168
1169 /* If we were doing checkpoint recovery, first retransmit all unacked I-frames
1170 */
1171 if (ctrl_word & L2CAP_FCR_F_BIT) {
1172 if (!retransmit_i_frames(p_ccb, L2C_FCR_RETX_ALL_PKTS)) {
1173 osi_free(p_buf);
1174 return;
1175 }
1176 }
1177
1178 #if (L2CAP_ERTM_STATS == TRUE)
1179 p_ccb->fcrb.ertm_pkt_counts[1]++;
1180 p_ccb->fcrb.ertm_byte_counts[1] += p_buf->len;
1181 #endif
1182
1183 /* Extract the sequence number */
1184 tx_seq = (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT;
1185
1186 /* If we have flow controlled the peer, ignore any bad I-frames from him */
1187 if ((tx_seq != p_fcrb->next_seq_expected) && (p_fcrb->local_busy)) {
1188 L2CAP_TRACE_WARNING("Dropping bad I-Frame since we flowed off, tx_seq:%u",
1189 tx_seq);
1190 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, 0);
1191 osi_free(p_buf);
1192 return;
1193 }
1194
1195 /* Check if tx-sequence is the expected one */
1196 if (tx_seq != p_fcrb->next_seq_expected) {
1197 num_lost = (tx_seq - p_fcrb->next_seq_expected) & L2CAP_FCR_SEQ_MODULO;
1198
1199 /* Is the frame a duplicate ? If so, just drop it */
1200 if (num_lost >= p_ccb->our_cfg.fcr.tx_win_sz) {
1201 /* Duplicate - simply drop it */
1202 L2CAP_TRACE_WARNING(
1203 "process_i_frame() Dropping Duplicate Frame tx_seq:%u ExpectedTxSeq "
1204 "%u",
1205 tx_seq, p_fcrb->next_seq_expected);
1206 osi_free(p_buf);
1207 } else {
1208 L2CAP_TRACE_WARNING(
1209 "process_i_frame() CID: 0x%04x Lost: %u tx_seq:%u ExpTxSeq %u "
1210 "Rej: %u SRej: %u",
1211 p_ccb->local_cid, num_lost, tx_seq, p_fcrb->next_seq_expected,
1212 p_fcrb->rej_sent, p_fcrb->srej_sent);
1213
1214 if (p_fcrb->srej_sent) {
1215 /* If SREJ sent, save the frame for later processing as long as it is in
1216 * sequence */
1217 next_srej =
1218 (((BT_HDR*)fixed_queue_try_peek_last(p_fcrb->srej_rcv_hold_q))
1219 ->layer_specific +
1220 1) &
1221 L2CAP_FCR_SEQ_MODULO;
1222
1223 if ((tx_seq == next_srej) &&
1224 (fixed_queue_length(p_fcrb->srej_rcv_hold_q) <
1225 p_ccb->our_cfg.fcr.tx_win_sz)) {
1226 /* If user gave us a pool for held rx buffers, use that */
1227 /* TODO: Could that happen? Get rid of this code. */
1228 if (p_ccb->ertm_info.fcr_rx_buf_size != L2CAP_FCR_RX_BUF_SIZE) {
1229 BT_HDR* p_buf2;
1230
1231 /* Adjust offset and len so that control word is copied */
1232 p_buf->offset -= L2CAP_FCR_OVERHEAD;
1233 p_buf->len += L2CAP_FCR_OVERHEAD;
1234
1235 p_buf2 = l2c_fcr_clone_buf(p_buf, p_buf->offset, p_buf->len);
1236
1237 if (p_buf2) {
1238 osi_free(p_buf);
1239 p_buf = p_buf2;
1240 }
1241 p_buf->offset += L2CAP_FCR_OVERHEAD;
1242 p_buf->len -= L2CAP_FCR_OVERHEAD;
1243 }
1244 L2CAP_TRACE_DEBUG(
1245 "process_i_frame() Lost: %u tx_seq:%u ExpTxSeq %u Rej: %u "
1246 "SRej1",
1247 num_lost, tx_seq, p_fcrb->next_seq_expected, p_fcrb->rej_sent);
1248
1249 p_buf->layer_specific = tx_seq;
1250 fixed_queue_enqueue(p_fcrb->srej_rcv_hold_q, p_buf);
1251 } else {
1252 L2CAP_TRACE_WARNING(
1253 "process_i_frame() CID: 0x%04x frame dropped in Srej Sent "
1254 "next_srej:%u hold_q.count:%u win_sz:%u",
1255 p_ccb->local_cid, next_srej,
1256 fixed_queue_length(p_fcrb->srej_rcv_hold_q),
1257 p_ccb->our_cfg.fcr.tx_win_sz);
1258
1259 p_fcrb->rej_after_srej = true;
1260 osi_free(p_buf);
1261 }
1262 } else if (p_fcrb->rej_sent) {
1263 L2CAP_TRACE_WARNING(
1264 "process_i_frame() CID: 0x%04x Lost: %u tx_seq:%u ExpTxSeq %u "
1265 "Rej: 1 SRej: %u",
1266 p_ccb->local_cid, num_lost, tx_seq, p_fcrb->next_seq_expected,
1267 p_fcrb->srej_sent);
1268
1269 /* If REJ sent, just drop the frame */
1270 osi_free(p_buf);
1271 } else {
1272 L2CAP_TRACE_DEBUG(
1273 "process_i_frame() CID: 0x%04x tx_seq:%u ExpTxSeq %u Rej: %u",
1274 p_ccb->local_cid, tx_seq, p_fcrb->next_seq_expected,
1275 p_fcrb->rej_sent);
1276
1277 /* If only one lost, we will send SREJ, otherwise we will send REJ */
1278 if (num_lost > 1) {
1279 osi_free(p_buf);
1280 p_fcrb->rej_sent = true;
1281 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_REJ, 0);
1282 } else {
1283 if (!fixed_queue_is_empty(p_fcrb->srej_rcv_hold_q)) {
1284 L2CAP_TRACE_ERROR(
1285 "process_i_frame() CID: 0x%04x sending SREJ tx_seq:%d "
1286 "hold_q.count:%u",
1287 p_ccb->local_cid, tx_seq,
1288 fixed_queue_length(p_fcrb->srej_rcv_hold_q));
1289 }
1290 p_buf->layer_specific = tx_seq;
1291 fixed_queue_enqueue(p_fcrb->srej_rcv_hold_q, p_buf);
1292 p_fcrb->srej_sent = true;
1293 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_SREJ, 0);
1294 }
1295 alarm_cancel(p_ccb->fcrb.ack_timer);
1296 }
1297 }
1298 return;
1299 }
1300
1301 /* Seq number is the next expected. Clear possible reject exception in case it
1302 * occured */
1303 p_fcrb->rej_sent = p_fcrb->srej_sent = false;
1304
1305 /* Adjust the next_seq, so that if the upper layer sends more data in the
1306 callback
1307 context, the received frame is acked by an I-frame. */
1308 p_fcrb->next_seq_expected = (tx_seq + 1) & L2CAP_FCR_SEQ_MODULO;
1309
1310 /* If any SAR problem in eRTM mode, spec says disconnect. */
1311 if (!do_sar_reassembly(p_ccb, p_buf, ctrl_word)) {
1312 L2CAP_TRACE_WARNING("process_i_frame() CID: 0x%04x reassembly failed",
1313 p_ccb->local_cid);
1314 l2cu_disconnect_chnl(p_ccb);
1315 return;
1316 }
1317
1318 /* RR optimization - if peer can still send us more, then start an ACK timer
1319 */
1320 num_to_ack = (p_fcrb->next_seq_expected - p_fcrb->last_ack_sent) &
1321 L2CAP_FCR_SEQ_MODULO;
1322
1323 if ((num_to_ack < p_ccb->fcrb.max_held_acks) && (!p_fcrb->local_busy))
1324 delay_ack = true;
1325
1326 /* We should neve never ack frame if we are not in OPEN state */
1327 if ((num_to_ack != 0) && p_ccb->in_use && (p_ccb->chnl_state == CST_OPEN)) {
1328 /* If no frames are awaiting transmission or are held, send an RR or RNR
1329 * S-frame for ack */
1330 if (delay_ack) {
1331 /* If it is the first I frame we did not ack, start ack timer */
1332 if (!alarm_is_scheduled(p_ccb->fcrb.ack_timer)) {
1333 alarm_set_on_mloop(p_ccb->fcrb.ack_timer, L2CAP_FCR_ACK_TIMEOUT_MS,
1334 l2c_fcrb_ack_timer_timeout, p_ccb);
1335 }
1336 } else if ((fixed_queue_is_empty(p_ccb->xmit_hold_q) ||
1337 l2c_fcr_is_flow_controlled(p_ccb)) &&
1338 fixed_queue_is_empty(p_ccb->fcrb.srej_rcv_hold_q)) {
1339 if (p_fcrb->local_busy)
1340 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RNR, 0);
1341 else
1342 l2c_fcr_send_S_frame(p_ccb, L2CAP_FCR_SUP_RR, 0);
1343 }
1344 }
1345 }
1346
1347 /*******************************************************************************
1348 *
1349 * Function process_stream_frame
1350 *
1351 * Description This function processes frames in streaming mode
1352 *
1353 * Returns -
1354 *
1355 ******************************************************************************/
process_stream_frame(tL2C_CCB * p_ccb,BT_HDR * p_buf)1356 static void process_stream_frame(tL2C_CCB* p_ccb, BT_HDR* p_buf) {
1357 CHECK(p_ccb != NULL);
1358 CHECK(p_buf != NULL);
1359
1360 uint16_t ctrl_word;
1361 uint16_t fcs;
1362 uint8_t* p;
1363 uint8_t tx_seq;
1364
1365 /* Verify FCS if using */
1366 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) {
1367 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + p_buf->len - L2CAP_FCS_LEN;
1368
1369 /* Extract and drop the FCS from the packet */
1370 STREAM_TO_UINT16(fcs, p);
1371 p_buf->len -= L2CAP_FCS_LEN;
1372
1373 if (l2c_fcr_rx_get_fcs(p_buf) != fcs) {
1374 L2CAP_TRACE_WARNING("Rx L2CAP PDU: CID: 0x%04x BAD FCS",
1375 p_ccb->local_cid);
1376 osi_free(p_buf);
1377 return;
1378 }
1379 }
1380
1381 /* Get the control word */
1382 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
1383
1384 STREAM_TO_UINT16(ctrl_word, p);
1385
1386 p_buf->len -= L2CAP_FCR_OVERHEAD;
1387 p_buf->offset += L2CAP_FCR_OVERHEAD;
1388
1389 /* Make sure it is an I-frame */
1390 if (ctrl_word & L2CAP_FCR_S_FRAME_BIT) {
1391 L2CAP_TRACE_WARNING(
1392 "Rx L2CAP PDU: CID: 0x%04x BAD S-frame in streaming mode ctrl_word: "
1393 "0x%04x",
1394 p_ccb->local_cid, ctrl_word);
1395 osi_free(p_buf);
1396 return;
1397 }
1398
1399 L2CAP_TRACE_EVENT(
1400 "L2CAP eRTM Rx I-frame: cid: 0x%04x Len: %u SAR: %-12s TxSeq: %u "
1401 "ReqSeq: %u F: %u",
1402 p_ccb->local_cid, p_buf->len,
1403 SAR_types[(ctrl_word & L2CAP_FCR_SAR_BITS) >> L2CAP_FCR_SAR_BITS_SHIFT],
1404 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT,
1405 (ctrl_word & L2CAP_FCR_REQ_SEQ_BITS) >> L2CAP_FCR_REQ_SEQ_BITS_SHIFT,
1406 (ctrl_word & L2CAP_FCR_F_BIT) >> L2CAP_FCR_F_BIT_SHIFT);
1407
1408 /* Extract the sequence number */
1409 tx_seq = (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT;
1410
1411 /* Check if tx-sequence is the expected one */
1412 if (tx_seq != p_ccb->fcrb.next_seq_expected) {
1413 L2CAP_TRACE_WARNING(
1414 "Rx L2CAP PDU: CID: 0x%04x Lost frames Exp: %u Got: %u p_rx_sdu: "
1415 "0x%08x",
1416 p_ccb->local_cid, p_ccb->fcrb.next_seq_expected, tx_seq,
1417 p_ccb->fcrb.p_rx_sdu);
1418
1419 /* Lost one or more packets, so flush the SAR queue */
1420 osi_free_and_reset((void**)&p_ccb->fcrb.p_rx_sdu);
1421 }
1422
1423 p_ccb->fcrb.next_seq_expected = (tx_seq + 1) & L2CAP_FCR_SEQ_MODULO;
1424
1425 if (!do_sar_reassembly(p_ccb, p_buf, ctrl_word)) {
1426 /* Some sort of SAR error, so flush the SAR queue */
1427 osi_free_and_reset((void**)&p_ccb->fcrb.p_rx_sdu);
1428 }
1429 }
1430
1431 /*******************************************************************************
1432 *
1433 * Function do_sar_reassembly
1434 *
1435 * Description Process SAR bits and re-assemble frame
1436 *
1437 * Returns true if all OK, else false
1438 *
1439 ******************************************************************************/
do_sar_reassembly(tL2C_CCB * p_ccb,BT_HDR * p_buf,uint16_t ctrl_word)1440 static bool do_sar_reassembly(tL2C_CCB* p_ccb, BT_HDR* p_buf,
1441 uint16_t ctrl_word) {
1442 CHECK(p_ccb != NULL);
1443 CHECK(p_buf != NULL);
1444
1445 tL2C_FCRB* p_fcrb = &p_ccb->fcrb;
1446 uint16_t sar_type = ctrl_word & L2CAP_FCR_SEG_BITS;
1447 bool packet_ok = true;
1448 uint8_t* p;
1449
1450 /* Check if the SAR state is correct */
1451 if ((sar_type == L2CAP_FCR_UNSEG_SDU) || (sar_type == L2CAP_FCR_START_SDU)) {
1452 if (p_fcrb->p_rx_sdu != NULL) {
1453 L2CAP_TRACE_WARNING(
1454 "SAR - got unexpected unsegmented or start SDU Expected len: %u "
1455 "Got so far: %u",
1456 p_fcrb->rx_sdu_len, p_fcrb->p_rx_sdu->len);
1457
1458 packet_ok = false;
1459 }
1460 /* Check the length of the packet */
1461 if ((sar_type == L2CAP_FCR_START_SDU) &&
1462 (p_buf->len < L2CAP_SDU_LEN_OVERHEAD)) {
1463 L2CAP_TRACE_WARNING("SAR start packet too short: %u", p_buf->len);
1464 packet_ok = false;
1465 }
1466 } else {
1467 if (p_fcrb->p_rx_sdu == NULL) {
1468 L2CAP_TRACE_WARNING("SAR - got unexpected cont or end SDU");
1469 packet_ok = false;
1470 }
1471 }
1472
1473 if ((packet_ok) && (sar_type != L2CAP_FCR_UNSEG_SDU)) {
1474 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset;
1475
1476 /* For start SDU packet, extract the SDU length */
1477 if (sar_type == L2CAP_FCR_START_SDU) {
1478 /* Get the SDU length */
1479 STREAM_TO_UINT16(p_fcrb->rx_sdu_len, p);
1480 p_buf->offset += 2;
1481 p_buf->len -= 2;
1482
1483 if (p_fcrb->rx_sdu_len > p_ccb->max_rx_mtu) {
1484 L2CAP_TRACE_WARNING("SAR - SDU len: %u larger than MTU: %u",
1485 p_fcrb->rx_sdu_len, p_fcrb->rx_sdu_len);
1486 packet_ok = false;
1487 } else {
1488 p_fcrb->p_rx_sdu = (BT_HDR*)osi_malloc(L2CAP_MAX_BUF_SIZE);
1489 p_fcrb->p_rx_sdu->offset = OBX_BUF_MIN_OFFSET;
1490 p_fcrb->p_rx_sdu->len = 0;
1491 }
1492 }
1493
1494 if (packet_ok) {
1495 if ((p_fcrb->p_rx_sdu->len + p_buf->len) > p_fcrb->rx_sdu_len) {
1496 L2CAP_TRACE_ERROR(
1497 "SAR - SDU len exceeded Type: %u Lengths: %u %u %u", sar_type,
1498 p_fcrb->p_rx_sdu->len, p_buf->len, p_fcrb->rx_sdu_len);
1499 packet_ok = false;
1500 } else if ((sar_type == L2CAP_FCR_END_SDU) &&
1501 ((p_fcrb->p_rx_sdu->len + p_buf->len) != p_fcrb->rx_sdu_len)) {
1502 L2CAP_TRACE_WARNING("SAR - SDU end rcvd but SDU incomplete: %u %u %u",
1503 p_fcrb->p_rx_sdu->len, p_buf->len,
1504 p_fcrb->rx_sdu_len);
1505 packet_ok = false;
1506 } else {
1507 memcpy(((uint8_t*)(p_fcrb->p_rx_sdu + 1)) + p_fcrb->p_rx_sdu->offset +
1508 p_fcrb->p_rx_sdu->len,
1509 p, p_buf->len);
1510
1511 p_fcrb->p_rx_sdu->len += p_buf->len;
1512
1513 osi_free(p_buf);
1514 p_buf = NULL;
1515
1516 if (sar_type == L2CAP_FCR_END_SDU) {
1517 p_buf = p_fcrb->p_rx_sdu;
1518 p_fcrb->p_rx_sdu = NULL;
1519 }
1520 }
1521 }
1522 }
1523
1524 if (packet_ok == false) {
1525 osi_free(p_buf);
1526 } else if (p_buf != NULL) {
1527 #if (L2CAP_NUM_FIXED_CHNLS > 0)
1528 if (p_ccb->local_cid < L2CAP_BASE_APPL_CID &&
1529 (p_ccb->local_cid >= L2CAP_FIRST_FIXED_CHNL &&
1530 p_ccb->local_cid <= L2CAP_LAST_FIXED_CHNL)) {
1531 if (l2cb.fixed_reg[p_ccb->local_cid - L2CAP_FIRST_FIXED_CHNL]
1532 .pL2CA_FixedData_Cb)
1533 (*l2cb.fixed_reg[p_ccb->local_cid - L2CAP_FIRST_FIXED_CHNL]
1534 .pL2CA_FixedData_Cb)(p_ccb->local_cid,
1535 p_ccb->p_lcb->remote_bd_addr, p_buf);
1536 } else
1537 #endif
1538 l2c_csm_execute(p_ccb, L2CEVT_L2CAP_DATA, p_buf);
1539 }
1540
1541 return (packet_ok);
1542 }
1543
1544 /*******************************************************************************
1545 *
1546 * Function retransmit_i_frames
1547 *
1548 * Description This function retransmits i-frames awaiting acks.
1549 *
1550 * Returns bool - true if retransmitted
1551 *
1552 ******************************************************************************/
retransmit_i_frames(tL2C_CCB * p_ccb,uint8_t tx_seq)1553 static bool retransmit_i_frames(tL2C_CCB* p_ccb, uint8_t tx_seq) {
1554 CHECK(p_ccb != NULL);
1555
1556 BT_HDR* p_buf = NULL;
1557 uint8_t* p;
1558 uint8_t buf_seq;
1559 uint16_t ctrl_word;
1560
1561 if ((!fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q)) &&
1562 (p_ccb->peer_cfg.fcr.max_transmit != 0) &&
1563 (p_ccb->fcrb.num_tries >= p_ccb->peer_cfg.fcr.max_transmit)) {
1564 L2CAP_TRACE_EVENT(
1565 "Max Tries Exceeded: (last_acq: %d CID: 0x%04x num_tries: %u (max: "
1566 "%u) ack_q_count: %u",
1567 p_ccb->fcrb.last_rx_ack, p_ccb->local_cid, p_ccb->fcrb.num_tries,
1568 p_ccb->peer_cfg.fcr.max_transmit,
1569 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q));
1570
1571 l2cu_disconnect_chnl(p_ccb);
1572 return (false);
1573 }
1574
1575 /* tx_seq indicates whether to retransmit a specific sequence or all (if ==
1576 * L2C_FCR_RETX_ALL_PKTS) */
1577 list_t* list_ack = NULL;
1578 const list_node_t* node_ack = NULL;
1579 if (!fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q)) {
1580 list_ack = fixed_queue_get_list(p_ccb->fcrb.waiting_for_ack_q);
1581 node_ack = list_begin(list_ack);
1582 }
1583 if (tx_seq != L2C_FCR_RETX_ALL_PKTS) {
1584 /* If sending only one, the sequence number tells us which one. Look for it.
1585 */
1586 if (list_ack != NULL) {
1587 for (; node_ack != list_end(list_ack); node_ack = list_next(node_ack)) {
1588 p_buf = (BT_HDR*)list_node(node_ack);
1589 /* Get the old control word */
1590 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + L2CAP_PKT_OVERHEAD;
1591
1592 STREAM_TO_UINT16(ctrl_word, p);
1593
1594 buf_seq =
1595 (ctrl_word & L2CAP_FCR_TX_SEQ_BITS) >> L2CAP_FCR_TX_SEQ_BITS_SHIFT;
1596
1597 L2CAP_TRACE_DEBUG(
1598 "retransmit_i_frames() cur seq: %u looking for: %u", buf_seq,
1599 tx_seq);
1600
1601 if (tx_seq == buf_seq) break;
1602 }
1603 }
1604
1605 if (!p_buf) {
1606 L2CAP_TRACE_ERROR("retransmit_i_frames() UNKNOWN seq: %u q_count: %u",
1607 tx_seq,
1608 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q));
1609 return (true);
1610 }
1611 } else {
1612 // Iterate though list and flush the amount requested from
1613 // the transmit data queue that satisfy the layer and event conditions.
1614 for (list_node_t* node_tmp = list_begin(p_ccb->p_lcb->link_xmit_data_q);
1615 node_tmp != list_end(p_ccb->p_lcb->link_xmit_data_q);) {
1616 BT_HDR* p_tmp = (BT_HDR*)list_node(node_tmp);
1617 node_tmp = list_next(node_tmp);
1618
1619 /* Do not flush other CIDs or partial segments */
1620 if ((p_tmp->layer_specific == 0) && (p_tmp->event == p_ccb->local_cid)) {
1621 list_remove(p_ccb->p_lcb->link_xmit_data_q, p_tmp);
1622 osi_free(p_tmp);
1623 }
1624 }
1625
1626 /* Also flush our retransmission queue */
1627 while (!fixed_queue_is_empty(p_ccb->fcrb.retrans_q))
1628 osi_free(fixed_queue_try_dequeue(p_ccb->fcrb.retrans_q));
1629
1630 if (list_ack != NULL) node_ack = list_begin(list_ack);
1631 }
1632
1633 if (list_ack != NULL) {
1634 while (node_ack != list_end(list_ack)) {
1635 p_buf = (BT_HDR*)list_node(node_ack);
1636 node_ack = list_next(node_ack);
1637
1638 BT_HDR* p_buf2 = l2c_fcr_clone_buf(p_buf, p_buf->offset, p_buf->len);
1639 if (p_buf2) {
1640 p_buf2->layer_specific = p_buf->layer_specific;
1641
1642 fixed_queue_enqueue(p_ccb->fcrb.retrans_q, p_buf2);
1643 }
1644
1645 if ((tx_seq != L2C_FCR_RETX_ALL_PKTS) || (p_buf2 == NULL)) break;
1646 }
1647 }
1648
1649 l2c_link_check_send_pkts(p_ccb->p_lcb, NULL, NULL);
1650
1651 if (fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q)) {
1652 p_ccb->fcrb.num_tries++;
1653 l2c_fcr_start_timer(p_ccb);
1654 }
1655
1656 return (true);
1657 }
1658
1659 /*******************************************************************************
1660 *
1661 * Function l2c_fcr_get_next_xmit_sdu_seg
1662 *
1663 * Description Get the next SDU segment to transmit.
1664 *
1665 * Returns pointer to buffer with segment or NULL
1666 *
1667 ******************************************************************************/
l2c_fcr_get_next_xmit_sdu_seg(tL2C_CCB * p_ccb,uint16_t max_packet_length)1668 BT_HDR* l2c_fcr_get_next_xmit_sdu_seg(tL2C_CCB* p_ccb,
1669 uint16_t max_packet_length) {
1670 CHECK(p_ccb != NULL);
1671
1672 bool first_seg = false, /* The segment is the first part of data */
1673 mid_seg = false, /* The segment is the middle part of data */
1674 last_seg = false; /* The segment is the last part of data */
1675 uint16_t sdu_len = 0;
1676 BT_HDR *p_buf, *p_xmit;
1677 uint8_t* p;
1678 uint16_t max_pdu = p_ccb->tx_mps /* Needed? - L2CAP_MAX_HEADER_FCS*/;
1679
1680 /* If there is anything in the retransmit queue, that goes first
1681 */
1682 p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->fcrb.retrans_q);
1683 if (p_buf != NULL) {
1684 /* Update Rx Seq and FCS if we acked some packets while this one was queued
1685 */
1686 prepare_I_frame(p_ccb, p_buf, true);
1687
1688 p_buf->event = p_ccb->local_cid;
1689
1690 #if (L2CAP_ERTM_STATS == TRUE)
1691 p_ccb->fcrb.pkts_retransmitted++;
1692 p_ccb->fcrb.ertm_pkt_counts[0]++;
1693 p_ccb->fcrb.ertm_byte_counts[0] += (p_buf->len - 8);
1694 #endif
1695 return (p_buf);
1696 }
1697
1698 /* For BD/EDR controller, max_packet_length is set to 0 */
1699 /* For AMP controller, max_packet_length is set by available blocks */
1700 if ((max_packet_length > L2CAP_MAX_HEADER_FCS) &&
1701 (max_pdu + L2CAP_MAX_HEADER_FCS > max_packet_length)) {
1702 max_pdu = max_packet_length - L2CAP_MAX_HEADER_FCS;
1703 }
1704
1705 p_buf = (BT_HDR*)fixed_queue_try_peek_first(p_ccb->xmit_hold_q);
1706
1707 /* If there is more data than the MPS, it requires segmentation */
1708 if (p_buf->len > max_pdu) {
1709 /* We are using the "event" field to tell is if we already started
1710 * segmentation */
1711 if (p_buf->event == 0) {
1712 first_seg = true;
1713 sdu_len = p_buf->len;
1714 } else
1715 mid_seg = true;
1716
1717 /* Get a new buffer and copy the data that can be sent in a PDU */
1718 p_xmit = l2c_fcr_clone_buf(p_buf, L2CAP_MIN_OFFSET + L2CAP_SDU_LEN_OFFSET,
1719 max_pdu);
1720
1721 if (p_xmit != NULL) {
1722 p_buf->event = p_ccb->local_cid;
1723 p_xmit->event = p_ccb->local_cid;
1724
1725 p_buf->len -= max_pdu;
1726 p_buf->offset += max_pdu;
1727
1728 /* copy PBF setting */
1729 p_xmit->layer_specific = p_buf->layer_specific;
1730 } else /* Should never happen if the application has configured buffers
1731 correctly */
1732 {
1733 L2CAP_TRACE_ERROR(
1734 "L2CAP - cannot get buffer for segmentation, max_pdu: %u", max_pdu);
1735 return (NULL);
1736 }
1737 } else /* Use the original buffer if no segmentation, or the last segment */
1738 {
1739 p_xmit = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->xmit_hold_q);
1740
1741 if (p_xmit->event != 0) last_seg = true;
1742
1743 p_xmit->event = p_ccb->local_cid;
1744 }
1745
1746 /* Step back to add the L2CAP headers */
1747 p_xmit->offset -= (L2CAP_PKT_OVERHEAD + L2CAP_FCR_OVERHEAD);
1748 p_xmit->len += L2CAP_PKT_OVERHEAD + L2CAP_FCR_OVERHEAD;
1749
1750 if (first_seg) {
1751 p_xmit->offset -= L2CAP_SDU_LEN_OVERHEAD;
1752 p_xmit->len += L2CAP_SDU_LEN_OVERHEAD;
1753 }
1754
1755 /* Set the pointer to the beginning of the data */
1756 p = (uint8_t*)(p_xmit + 1) + p_xmit->offset;
1757
1758 /* Now the L2CAP header */
1759
1760 /* Note: if FCS has to be included then the length is recalculated later */
1761 UINT16_TO_STREAM(p, p_xmit->len - L2CAP_PKT_OVERHEAD);
1762
1763 UINT16_TO_STREAM(p, p_ccb->remote_cid);
1764
1765 if (first_seg) {
1766 /* Skip control word and add SDU length */
1767 p += 2;
1768 UINT16_TO_STREAM(p, sdu_len);
1769
1770 /* We will store the SAR type in layer-specific */
1771 /* layer_specific is shared with flushable flag(bits 0-1), don't clear it */
1772 p_xmit->layer_specific |= L2CAP_FCR_START_SDU;
1773
1774 first_seg = false;
1775 } else if (mid_seg)
1776 p_xmit->layer_specific |= L2CAP_FCR_CONT_SDU;
1777 else if (last_seg)
1778 p_xmit->layer_specific |= L2CAP_FCR_END_SDU;
1779 else
1780 p_xmit->layer_specific |= L2CAP_FCR_UNSEG_SDU;
1781
1782 prepare_I_frame(p_ccb, p_xmit, false);
1783
1784 if (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE) {
1785 BT_HDR* p_wack =
1786 l2c_fcr_clone_buf(p_xmit, HCI_DATA_PREAMBLE_SIZE, p_xmit->len);
1787
1788 if (!p_wack) {
1789 L2CAP_TRACE_ERROR(
1790 "L2CAP - no buffer for xmit cloning, CID: 0x%04x Length: %u",
1791 p_ccb->local_cid, p_xmit->len);
1792
1793 /* We will not save the FCS in case we reconfigure and change options */
1794 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) p_xmit->len -= L2CAP_FCS_LEN;
1795
1796 /* Pretend we sent it and it got lost */
1797 fixed_queue_enqueue(p_ccb->fcrb.waiting_for_ack_q, p_xmit);
1798 return (NULL);
1799 } else {
1800 #if (L2CAP_ERTM_STATS == TRUE)
1801 /* set timestamp at the end of tx I-frame to get acking delay */
1802 /*
1803 * NOTE: Here we assume the allocate buffer is large enough
1804 * to include extra 4 octets at the end.
1805 */
1806 p = ((uint8_t*)(p_wack + 1)) + p_wack->offset + p_wack->len;
1807 UINT32_TO_STREAM(p, time_get_os_boottime_ms());
1808 #endif
1809 /* We will not save the FCS in case we reconfigure and change options */
1810 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) p_wack->len -= L2CAP_FCS_LEN;
1811
1812 p_wack->layer_specific = p_xmit->layer_specific;
1813 fixed_queue_enqueue(p_ccb->fcrb.waiting_for_ack_q, p_wack);
1814 }
1815
1816 #if (L2CAP_ERTM_STATS == TRUE)
1817 p_ccb->fcrb.ertm_pkt_counts[0]++;
1818 p_ccb->fcrb.ertm_byte_counts[0] += (p_xmit->len - 8);
1819 #endif
1820 }
1821
1822 return (p_xmit);
1823 }
1824
1825 /*******************************************************************************
1826 *
1827 * Function l2c_lcc_get_next_xmit_sdu_seg
1828 *
1829 * Description Get the next SDU segment to transmit for LE connection
1830 * oriented channel
1831 *
1832 * Returns pointer to buffer with segment or NULL
1833 *
1834 ******************************************************************************/
l2c_lcc_get_next_xmit_sdu_seg(tL2C_CCB * p_ccb,uint16_t max_packet_length)1835 BT_HDR* l2c_lcc_get_next_xmit_sdu_seg(tL2C_CCB* p_ccb,
1836 uint16_t max_packet_length) {
1837 bool first_seg = false; /* The segment is the first part of data */
1838 bool last_seg = false; /* The segment is the last part of data */
1839 uint16_t no_of_bytes_to_send = 0;
1840 uint16_t sdu_len = 0;
1841 BT_HDR *p_buf, *p_xmit;
1842 uint8_t* p;
1843 uint16_t max_pdu = p_ccb->peer_conn_cfg.mps;
1844
1845 p_buf = (BT_HDR*)fixed_queue_try_peek_first(p_ccb->xmit_hold_q);
1846
1847 /* We are using the "event" field to tell is if we already started
1848 * segmentation */
1849 if (p_buf->event == 0) {
1850 first_seg = true;
1851 sdu_len = p_buf->len;
1852 if (p_buf->len <= (max_pdu - L2CAP_LCC_SDU_LENGTH)) {
1853 last_seg = true;
1854 no_of_bytes_to_send = p_buf->len;
1855 } else
1856 no_of_bytes_to_send = max_pdu - L2CAP_LCC_SDU_LENGTH;
1857 } else if (p_buf->len <= max_pdu) {
1858 last_seg = true;
1859 no_of_bytes_to_send = p_buf->len;
1860 } else {
1861 /* Middle Packet */
1862 no_of_bytes_to_send = max_pdu;
1863 }
1864
1865 /* Get a new buffer and copy the data that can be sent in a PDU */
1866 if (first_seg == true)
1867 p_xmit = l2c_fcr_clone_buf(p_buf, L2CAP_LCC_OFFSET, no_of_bytes_to_send);
1868 else
1869 p_xmit = l2c_fcr_clone_buf(p_buf, L2CAP_MIN_OFFSET, no_of_bytes_to_send);
1870
1871 if (p_xmit != NULL) {
1872 p_buf->event = p_ccb->local_cid;
1873 p_xmit->event = p_ccb->local_cid;
1874
1875 if (first_seg == true) {
1876 p_xmit->offset -= L2CAP_LCC_SDU_LENGTH; /* for writing the SDU length. */
1877 p = (uint8_t*)(p_xmit + 1) + p_xmit->offset;
1878 UINT16_TO_STREAM(p, sdu_len);
1879 p_xmit->len += L2CAP_LCC_SDU_LENGTH;
1880 }
1881
1882 p_buf->len -= no_of_bytes_to_send;
1883 p_buf->offset += no_of_bytes_to_send;
1884
1885 /* copy PBF setting */
1886 p_xmit->layer_specific = p_buf->layer_specific;
1887
1888 } else /* Should never happen if the application has configured buffers
1889 correctly */
1890 {
1891 L2CAP_TRACE_ERROR("L2CAP - cannot get buffer, for segmentation");
1892 return (NULL);
1893 }
1894
1895 if (last_seg == true) {
1896 p_buf = (BT_HDR*)fixed_queue_try_dequeue(p_ccb->xmit_hold_q);
1897 osi_free(p_buf);
1898 }
1899
1900 /* Step back to add the L2CAP headers */
1901 p_xmit->offset -= L2CAP_PKT_OVERHEAD;
1902 p_xmit->len += L2CAP_PKT_OVERHEAD;
1903
1904 /* Set the pointer to the beginning of the data */
1905 p = (uint8_t*)(p_xmit + 1) + p_xmit->offset;
1906
1907 /* Note: if FCS has to be included then the length is recalculated later */
1908 UINT16_TO_STREAM(p, p_xmit->len - L2CAP_PKT_OVERHEAD);
1909 UINT16_TO_STREAM(p, p_ccb->remote_cid);
1910 return (p_xmit);
1911 }
1912
1913 /*******************************************************************************
1914 * Configuration negotiation functions
1915 *
1916 * The following functions are used in negotiating channel modes during
1917 * configuration
1918 ******************************************************************************/
1919
1920 /*******************************************************************************
1921 *
1922 * Function l2c_fcr_chk_chan_modes
1923 *
1924 * Description Validates and adjusts if necessary, the FCR options
1925 * based on remote EXT features.
1926 *
1927 * Note: This assumes peer EXT Features have been received.
1928 * Basic mode is used if FCR Options have not been received
1929 *
1930 * Returns uint8_t - nonzero if can continue, '0' if no compatible
1931 * channels
1932 *
1933 ******************************************************************************/
l2c_fcr_chk_chan_modes(tL2C_CCB * p_ccb)1934 uint8_t l2c_fcr_chk_chan_modes(tL2C_CCB* p_ccb) {
1935 CHECK(p_ccb != NULL);
1936
1937 /* Remove nonbasic options that the peer does not support */
1938 if (!(p_ccb->p_lcb->peer_ext_fea & L2CAP_EXTFEA_ENH_RETRANS))
1939 p_ccb->ertm_info.allowed_modes &= ~L2CAP_FCR_CHAN_OPT_ERTM;
1940
1941 if (!(p_ccb->p_lcb->peer_ext_fea & L2CAP_EXTFEA_STREAM_MODE))
1942 p_ccb->ertm_info.allowed_modes &= ~L2CAP_FCR_CHAN_OPT_STREAM;
1943
1944 /* At least one type needs to be set (Basic, ERTM, STM) to continue */
1945 if (!p_ccb->ertm_info.allowed_modes) {
1946 L2CAP_TRACE_WARNING(
1947 "L2CAP - Peer does not support our desired channel types");
1948 }
1949
1950 return (p_ccb->ertm_info.allowed_modes);
1951 }
1952
1953 /*******************************************************************************
1954 *
1955 * Function l2c_fcr_adj_our_req_options
1956 *
1957 * Description Validates and sets up the FCR options passed in from
1958 * L2CA_ConfigReq based on remote device's features.
1959 *
1960 * Returns true if no errors, Otherwise false
1961 *
1962 ******************************************************************************/
l2c_fcr_adj_our_req_options(tL2C_CCB * p_ccb,tL2CAP_CFG_INFO * p_cfg)1963 bool l2c_fcr_adj_our_req_options(tL2C_CCB* p_ccb, tL2CAP_CFG_INFO* p_cfg) {
1964 CHECK(p_ccb != NULL);
1965 CHECK(p_cfg != NULL);
1966
1967 tL2CAP_FCR_OPTS* p_fcr = &p_cfg->fcr;
1968
1969 if (p_fcr->mode != p_ccb->ertm_info.preferred_mode) {
1970 L2CAP_TRACE_WARNING(
1971 "l2c_fcr_adj_our_req_options - preferred_mode (%d), does not match "
1972 "mode (%d)",
1973 p_ccb->ertm_info.preferred_mode, p_fcr->mode);
1974
1975 /* The preferred mode is passed in through tL2CAP_ERTM_INFO, so override
1976 * this one */
1977 p_fcr->mode = p_ccb->ertm_info.preferred_mode;
1978 }
1979
1980 /* If upper layer did not request eRTM mode, BASIC must be used */
1981 if (p_ccb->ertm_info.allowed_modes == L2CAP_FCR_CHAN_OPT_BASIC) {
1982 if (p_cfg->fcr_present && p_fcr->mode != L2CAP_FCR_BASIC_MODE) {
1983 L2CAP_TRACE_WARNING(
1984 "l2c_fcr_adj_our_req_options (mode %d): ERROR: No FCR options set "
1985 "using BASIC mode",
1986 p_fcr->mode);
1987 }
1988 p_fcr->mode = L2CAP_FCR_BASIC_MODE;
1989 }
1990
1991 /* Process the FCR options if initial channel bring-up (not a reconfig
1992 *request)
1993 ** Determine initial channel mode to try based on our options and remote's
1994 *features
1995 */
1996 if (p_cfg->fcr_present && !(p_ccb->config_done & RECONFIG_FLAG)) {
1997 /* We need to have at least one mode type common with the peer */
1998 if (!l2c_fcr_chk_chan_modes(p_ccb)) {
1999 /* Two channels have incompatible supported types */
2000 l2cu_disconnect_chnl(p_ccb);
2001 return (false);
2002 }
2003
2004 /* Basic is the only common channel mode between the two devices */
2005 else if (p_ccb->ertm_info.allowed_modes == L2CAP_FCR_CHAN_OPT_BASIC) {
2006 /* We only want to try Basic, so bypass sending the FCR options entirely
2007 */
2008 p_cfg->fcr_present = false;
2009 p_cfg->fcs_present = false; /* Illegal to use FCS option in basic mode */
2010 p_cfg->ext_flow_spec_present =
2011 false; /* Illegal to use extended flow spec in basic mode */
2012 }
2013
2014 /* We have at least one non-basic mode available
2015 * Override mode from available mode options based on preference, if needed
2016 */
2017 else {
2018 /* If peer does not support STREAMING, try ERTM */
2019 if (p_fcr->mode == L2CAP_FCR_STREAM_MODE &&
2020 !(p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_STREAM)) {
2021 L2CAP_TRACE_DEBUG(
2022 "L2C CFG: mode is STREAM, but peer does not support; Try ERTM");
2023 p_fcr->mode = L2CAP_FCR_ERTM_MODE;
2024 }
2025
2026 /* If peer does not support ERTM, try BASIC (will support this if made it
2027 * here in the code) */
2028 if (p_fcr->mode == L2CAP_FCR_ERTM_MODE &&
2029 !(p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_ERTM)) {
2030 L2CAP_TRACE_DEBUG(
2031 "L2C CFG: mode is ERTM, but peer does not support; Try BASIC");
2032 p_fcr->mode = L2CAP_FCR_BASIC_MODE;
2033 }
2034 }
2035
2036 if (p_fcr->mode != L2CAP_FCR_BASIC_MODE) {
2037 /* MTU must be smaller than buffer size */
2038 if ((p_cfg->mtu_present) && (p_cfg->mtu > p_ccb->max_rx_mtu)) {
2039 L2CAP_TRACE_WARNING("L2CAP - MTU: %u larger than buf size: %u",
2040 p_cfg->mtu, p_ccb->max_rx_mtu);
2041 return (false);
2042 }
2043
2044 /* application want to use the default MPS */
2045 if (p_fcr->mps == L2CAP_DEFAULT_ERM_MPS) {
2046 p_fcr->mps = L2CAP_MPS_OVER_BR_EDR;
2047 }
2048 /* MPS must be less than MTU */
2049 else if (p_fcr->mps > p_ccb->max_rx_mtu) {
2050 L2CAP_TRACE_WARNING("L2CAP - MPS %u invalid MTU: %u", p_fcr->mps,
2051 p_ccb->max_rx_mtu);
2052 return (false);
2053 }
2054
2055 /* We always initially read into the HCI buffer pool, so make sure it fits
2056 */
2057 if (p_fcr->mps > (L2CAP_MTU_SIZE - L2CAP_MAX_HEADER_FCS))
2058 p_fcr->mps = L2CAP_MTU_SIZE - L2CAP_MAX_HEADER_FCS;
2059 } else {
2060 p_cfg->fcs_present = false; /* Illegal to use FCS option in basic mode */
2061 p_cfg->ext_flow_spec_present =
2062 false; /* Illegal to use extended flow spec in basic mode */
2063 }
2064
2065 p_ccb->our_cfg.fcr = *p_fcr;
2066 } else /* Not sure how to send a reconfiguration(??) should fcr be included?
2067 */
2068 {
2069 p_ccb->our_cfg.fcr_present = false;
2070 }
2071
2072 return (true);
2073 }
2074
2075 /*******************************************************************************
2076 *
2077 * Function l2c_fcr_adj_monitor_retran_timeout
2078 *
2079 * Description Overrides monitor/retrans timer value based on controller
2080 *
2081 * Returns None
2082 *
2083 ******************************************************************************/
l2c_fcr_adj_monitor_retran_timeout(tL2C_CCB * p_ccb)2084 void l2c_fcr_adj_monitor_retran_timeout(tL2C_CCB* p_ccb) {
2085 CHECK(p_ccb != NULL);
2086
2087 /* adjust our monitor/retran timeout */
2088 if (p_ccb->out_cfg_fcr_present) {
2089 /*
2090 ** if we requestd ERTM or accepted ERTM
2091 ** We may accept ERTM even if we didn't request ERTM, in case of requesting
2092 *STREAM
2093 */
2094 if ((p_ccb->our_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE) ||
2095 (p_ccb->peer_cfg.fcr.mode == L2CAP_FCR_ERTM_MODE)) {
2096 /* upper layer setting is ignored */
2097 p_ccb->our_cfg.fcr.mon_tout = L2CAP_MIN_MONITOR_TOUT;
2098 p_ccb->our_cfg.fcr.rtrans_tout = L2CAP_MIN_RETRANS_TOUT;
2099 } else {
2100 p_ccb->our_cfg.fcr.mon_tout = 0;
2101 p_ccb->our_cfg.fcr.rtrans_tout = 0;
2102 }
2103
2104 L2CAP_TRACE_DEBUG(
2105 "l2c_fcr_adj_monitor_retran_timeout: mon_tout:%d, rtrans_tout:%d",
2106 p_ccb->our_cfg.fcr.mon_tout, p_ccb->our_cfg.fcr.rtrans_tout);
2107 }
2108 }
2109 /*******************************************************************************
2110 *
2111 * Function l2c_fcr_adj_our_rsp_options
2112 *
2113 * Description Overrides any neccesary FCR options passed in from
2114 * L2CA_ConfigRsp based on our FCR options.
2115 * Only makes adjustments if channel is in ERTM mode.
2116 *
2117 * Returns None
2118 *
2119 ******************************************************************************/
l2c_fcr_adj_our_rsp_options(tL2C_CCB * p_ccb,tL2CAP_CFG_INFO * p_cfg)2120 void l2c_fcr_adj_our_rsp_options(tL2C_CCB* p_ccb, tL2CAP_CFG_INFO* p_cfg) {
2121 CHECK(p_ccb != NULL);
2122 CHECK(p_cfg != NULL);
2123
2124 /* adjust our monitor/retran timeout */
2125 l2c_fcr_adj_monitor_retran_timeout(p_ccb);
2126
2127 p_cfg->fcr_present = p_ccb->out_cfg_fcr_present;
2128
2129 if (p_cfg->fcr_present) {
2130 /* Temporary - until a better algorithm is implemented */
2131 /* If peer's tx_wnd_sz requires too many buffers for us to support, then
2132 * adjust it. For now, respond with our own tx_wnd_sz. */
2133 /* Note: peer is not guaranteed to obey our adjustment */
2134 if (p_ccb->peer_cfg.fcr.tx_win_sz > p_ccb->our_cfg.fcr.tx_win_sz) {
2135 L2CAP_TRACE_DEBUG("%s: adjusting requested tx_win_sz from %i to %i",
2136 __func__, p_ccb->peer_cfg.fcr.tx_win_sz,
2137 p_ccb->our_cfg.fcr.tx_win_sz);
2138 p_ccb->peer_cfg.fcr.tx_win_sz = p_ccb->our_cfg.fcr.tx_win_sz;
2139 }
2140
2141 p_cfg->fcr.mode = p_ccb->peer_cfg.fcr.mode;
2142 p_cfg->fcr.tx_win_sz = p_ccb->peer_cfg.fcr.tx_win_sz;
2143 p_cfg->fcr.max_transmit = p_ccb->peer_cfg.fcr.max_transmit;
2144 p_cfg->fcr.mps = p_ccb->peer_cfg.fcr.mps;
2145 p_cfg->fcr.rtrans_tout = p_ccb->our_cfg.fcr.rtrans_tout;
2146 p_cfg->fcr.mon_tout = p_ccb->our_cfg.fcr.mon_tout;
2147 }
2148 }
2149
2150 /*******************************************************************************
2151 *
2152 * Function l2c_fcr_renegotiate_chan
2153 *
2154 * Description Called upon unsuccessful peer response to config request.
2155 * If the error is because of the channel mode, it will try
2156 * to resend using another supported optional channel.
2157 *
2158 * Returns true if resent configuration, False if channel matches or
2159 * cannot match.
2160 *
2161 ******************************************************************************/
l2c_fcr_renegotiate_chan(tL2C_CCB * p_ccb,tL2CAP_CFG_INFO * p_cfg)2162 bool l2c_fcr_renegotiate_chan(tL2C_CCB* p_ccb, tL2CAP_CFG_INFO* p_cfg) {
2163 CHECK(p_ccb != NULL);
2164 CHECK(p_cfg != NULL);
2165
2166 uint8_t peer_mode = p_ccb->our_cfg.fcr.mode;
2167 bool can_renegotiate;
2168
2169 /* Skip if this is a reconfiguration from OPEN STATE or if FCR is not returned
2170 */
2171 if (!p_cfg->fcr_present || (p_ccb->config_done & RECONFIG_FLAG))
2172 return (false);
2173
2174 /* Only retry if there are more channel options to try */
2175 if (p_cfg->result == L2CAP_CFG_UNACCEPTABLE_PARAMS) {
2176 peer_mode = (p_cfg->fcr_present) ? p_cfg->fcr.mode : L2CAP_FCR_BASIC_MODE;
2177
2178 if (p_ccb->our_cfg.fcr.mode != peer_mode) {
2179 if ((--p_ccb->fcr_cfg_tries) == 0) {
2180 p_cfg->result = L2CAP_CFG_FAILED_NO_REASON;
2181 L2CAP_TRACE_WARNING("l2c_fcr_renegotiate_chan (Max retries exceeded)");
2182 }
2183
2184 can_renegotiate = false;
2185
2186 /* Try another supported mode if available based on our last attempted
2187 * channel */
2188 switch (p_ccb->our_cfg.fcr.mode) {
2189 /* Our Streaming mode request was unnacceptable; try ERTM or Basic */
2190 case L2CAP_FCR_STREAM_MODE:
2191 /* Peer wants ERTM and we support it */
2192 if ((peer_mode == L2CAP_FCR_ERTM_MODE) &&
2193 (p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_ERTM)) {
2194 L2CAP_TRACE_DEBUG("l2c_fcr_renegotiate_chan(Trying ERTM)");
2195 p_ccb->our_cfg.fcr.mode = L2CAP_FCR_ERTM_MODE;
2196 can_renegotiate = true;
2197 } else /* Falls through */
2198
2199 case L2CAP_FCR_ERTM_MODE: {
2200 /* We can try basic for any other peer mode if we support it */
2201 if (p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_BASIC) {
2202 L2CAP_TRACE_DEBUG("l2c_fcr_renegotiate_chan(Trying Basic)");
2203 can_renegotiate = true;
2204 p_ccb->our_cfg.fcr.mode = L2CAP_FCR_BASIC_MODE;
2205 }
2206 } break;
2207
2208 default:
2209 /* All other scenarios cannot be renegotiated */
2210 break;
2211 }
2212
2213 if (can_renegotiate) {
2214 p_ccb->our_cfg.fcr_present = true;
2215
2216 if (p_ccb->our_cfg.fcr.mode == L2CAP_FCR_BASIC_MODE) {
2217 p_ccb->our_cfg.fcs_present = false;
2218 p_ccb->our_cfg.ext_flow_spec_present = false;
2219
2220 /* Basic Mode uses ACL Data Pool, make sure the MTU fits */
2221 if ((p_cfg->mtu_present) && (p_cfg->mtu > L2CAP_MTU_SIZE)) {
2222 L2CAP_TRACE_WARNING("L2CAP - adjust MTU: %u too large", p_cfg->mtu);
2223 p_cfg->mtu = L2CAP_MTU_SIZE;
2224 }
2225 }
2226
2227 l2cu_process_our_cfg_req(p_ccb, &p_ccb->our_cfg);
2228 l2cu_send_peer_config_req(p_ccb, &p_ccb->our_cfg);
2229 alarm_set_on_mloop(p_ccb->l2c_ccb_timer, L2CAP_CHNL_CFG_TIMEOUT_MS,
2230 l2c_ccb_timer_timeout, p_ccb);
2231 return (true);
2232 }
2233 }
2234 }
2235
2236 /* Disconnect if the channels do not match */
2237 if (p_ccb->our_cfg.fcr.mode != peer_mode) {
2238 L2CAP_TRACE_WARNING("L2C CFG: Channels incompatible (local %d, peer %d)",
2239 p_ccb->our_cfg.fcr.mode, peer_mode);
2240 l2cu_disconnect_chnl(p_ccb);
2241 }
2242
2243 return (false);
2244 }
2245
2246 /*******************************************************************************
2247 *
2248 * Function l2c_fcr_process_peer_cfg_req
2249 *
2250 * Description This function is called to process the FCR options passed
2251 * in the peer's configuration request.
2252 *
2253 * Returns uint8_t - L2CAP_PEER_CFG_OK, L2CAP_PEER_CFG_UNACCEPTABLE,
2254 * or L2CAP_PEER_CFG_DISCONNECT.
2255 *
2256 ******************************************************************************/
l2c_fcr_process_peer_cfg_req(tL2C_CCB * p_ccb,tL2CAP_CFG_INFO * p_cfg)2257 uint8_t l2c_fcr_process_peer_cfg_req(tL2C_CCB* p_ccb, tL2CAP_CFG_INFO* p_cfg) {
2258 CHECK(p_ccb != NULL);
2259 CHECK(p_cfg != NULL);
2260
2261 uint16_t max_retrans_size;
2262 uint8_t fcr_ok = L2CAP_PEER_CFG_OK;
2263
2264 p_ccb->p_lcb->w4_info_rsp =
2265 false; /* Handles T61x SonyEricsson Bug in Info Request */
2266
2267 L2CAP_TRACE_EVENT(
2268 "l2c_fcr_process_peer_cfg_req() CFG fcr_present:%d fcr.mode:%d CCB FCR "
2269 "mode:%d preferred: %u allowed:%u",
2270 p_cfg->fcr_present, p_cfg->fcr.mode, p_ccb->our_cfg.fcr.mode,
2271 p_ccb->ertm_info.preferred_mode, p_ccb->ertm_info.allowed_modes);
2272
2273 /* If Peer wants basic, we are done (accept it or disconnect) */
2274 if (p_cfg->fcr.mode == L2CAP_FCR_BASIC_MODE) {
2275 /* If we do not allow basic, disconnect */
2276 if (!(p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_BASIC))
2277 fcr_ok = L2CAP_PEER_CFG_DISCONNECT;
2278 }
2279
2280 /* Need to negotiate if our modes are not the same */
2281 else if (p_cfg->fcr.mode != p_ccb->ertm_info.preferred_mode) {
2282 /* If peer wants a mode that we don't support then retry our mode (ex.
2283 *rtx/flc), OR
2284 ** If we want ERTM and they wanted streaming retry our mode.
2285 ** Note: If we have already determined they support our mode previously
2286 ** from their EXF mask.
2287 */
2288 if ((((1 << p_cfg->fcr.mode) & L2CAP_FCR_CHAN_OPT_ALL_MASK) == 0) ||
2289 (p_ccb->ertm_info.preferred_mode == L2CAP_FCR_ERTM_MODE)) {
2290 p_cfg->fcr.mode = p_ccb->our_cfg.fcr.mode;
2291 p_cfg->fcr.tx_win_sz = p_ccb->our_cfg.fcr.tx_win_sz;
2292 p_cfg->fcr.max_transmit = p_ccb->our_cfg.fcr.max_transmit;
2293 fcr_ok = L2CAP_PEER_CFG_UNACCEPTABLE;
2294 }
2295
2296 /* If we wanted basic, then try to renegotiate it */
2297 else if (p_ccb->ertm_info.preferred_mode == L2CAP_FCR_BASIC_MODE) {
2298 p_cfg->fcr.mode = L2CAP_FCR_BASIC_MODE;
2299 p_cfg->fcr.max_transmit = p_cfg->fcr.tx_win_sz = 0;
2300 p_cfg->fcr.rtrans_tout = p_cfg->fcr.mon_tout = p_cfg->fcr.mps = 0;
2301 p_ccb->our_cfg.fcr.rtrans_tout = p_ccb->our_cfg.fcr.mon_tout =
2302 p_ccb->our_cfg.fcr.mps = 0;
2303 fcr_ok = L2CAP_PEER_CFG_UNACCEPTABLE;
2304 }
2305
2306 /* Only other valid case is if they want ERTM and we wanted STM which should
2307 be
2308 accepted if we support it; otherwise the channel should be disconnected
2309 */
2310 else if ((p_cfg->fcr.mode != L2CAP_FCR_ERTM_MODE) ||
2311 !(p_ccb->ertm_info.allowed_modes & L2CAP_FCR_CHAN_OPT_ERTM)) {
2312 fcr_ok = L2CAP_PEER_CFG_DISCONNECT;
2313 }
2314 }
2315
2316 /* Configuration for FCR channels so make any adjustments and fwd to upper
2317 * layer */
2318 if (fcr_ok == L2CAP_PEER_CFG_OK) {
2319 /* by default don't need to send params in the response */
2320 p_ccb->out_cfg_fcr_present = false;
2321
2322 /* Make any needed adjustments for the response to the peer */
2323 if (p_cfg->fcr_present && p_cfg->fcr.mode != L2CAP_FCR_BASIC_MODE) {
2324 /* Peer desires to bypass FCS check, and streaming or ERTM mode */
2325 if (p_cfg->fcs_present) {
2326 p_ccb->peer_cfg.fcs = p_cfg->fcs;
2327 p_ccb->peer_cfg_bits |= L2CAP_CH_CFG_MASK_FCS;
2328 if (p_cfg->fcs == L2CAP_CFG_FCS_BYPASS)
2329 p_ccb->bypass_fcs |= L2CAP_CFG_FCS_PEER;
2330 }
2331
2332 max_retrans_size = p_ccb->ertm_info.fcr_tx_buf_size - sizeof(BT_HDR) -
2333 L2CAP_MIN_OFFSET - L2CAP_SDU_LEN_OFFSET -
2334 L2CAP_FCS_LEN;
2335
2336 /* Ensure the MPS is not bigger than the MTU */
2337 if ((p_cfg->fcr.mps == 0) || (p_cfg->fcr.mps > p_ccb->peer_cfg.mtu)) {
2338 p_cfg->fcr.mps = p_ccb->peer_cfg.mtu;
2339 p_ccb->out_cfg_fcr_present = true;
2340 }
2341
2342 /* Ensure the MPS is not bigger than our retransmission buffer */
2343 if (p_cfg->fcr.mps > max_retrans_size) {
2344 L2CAP_TRACE_DEBUG("CFG: Overriding MPS to %d (orig %d)",
2345 max_retrans_size, p_cfg->fcr.mps);
2346
2347 p_cfg->fcr.mps = max_retrans_size;
2348 p_ccb->out_cfg_fcr_present = true;
2349 }
2350
2351 if (p_cfg->fcr.mode == L2CAP_FCR_ERTM_MODE ||
2352 p_cfg->fcr.mode == L2CAP_FCR_STREAM_MODE) {
2353 /* Always respond with FCR ERTM parameters */
2354 p_ccb->out_cfg_fcr_present = true;
2355 }
2356 }
2357
2358 /* Everything ok, so save the peer's adjusted fcr options */
2359 p_ccb->peer_cfg.fcr = p_cfg->fcr;
2360
2361 if (p_cfg->fcr_present) p_ccb->peer_cfg_bits |= L2CAP_CH_CFG_MASK_FCR;
2362 } else if (fcr_ok == L2CAP_PEER_CFG_UNACCEPTABLE) {
2363 /* Allow peer only one retry for mode */
2364 if (p_ccb->peer_cfg_already_rejected)
2365 fcr_ok = L2CAP_PEER_CFG_DISCONNECT;
2366 else
2367 p_ccb->peer_cfg_already_rejected = true;
2368 }
2369
2370 return (fcr_ok);
2371 }
2372
2373 #if (L2CAP_ERTM_STATS == TRUE)
2374 /*******************************************************************************
2375 *
2376 * Function l2c_fcr_collect_ack_delay
2377 *
2378 * Description collect throughput, delay, queue size of waiting ack
2379 *
2380 * Parameters
2381 * tL2C_CCB
2382 *
2383 * Returns void
2384 *
2385 ******************************************************************************/
l2c_fcr_collect_ack_delay(tL2C_CCB * p_ccb,uint8_t num_bufs_acked)2386 static void l2c_fcr_collect_ack_delay(tL2C_CCB* p_ccb, uint8_t num_bufs_acked) {
2387 uint32_t index;
2388 BT_HDR* p_buf;
2389 uint8_t* p;
2390 uint32_t timestamp, delay;
2391 uint8_t xx;
2392 uint8_t str[120];
2393
2394 index = p_ccb->fcrb.ack_delay_avg_index;
2395
2396 /* update sum, max and min of waiting for ack queue size */
2397 p_ccb->fcrb.ack_q_count_avg[index] +=
2398 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q);
2399
2400 if (fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q) >
2401 p_ccb->fcrb.ack_q_count_max[index])
2402 p_ccb->fcrb.ack_q_count_max[index] =
2403 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q);
2404
2405 if (fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q) <
2406 p_ccb->fcrb.ack_q_count_min[index])
2407 p_ccb->fcrb.ack_q_count_min[index] =
2408 fixed_queue_length(p_ccb->fcrb.waiting_for_ack_q);
2409
2410 /* update sum, max and min of round trip delay of acking */
2411 list_t* list = NULL;
2412 if (!fixed_queue_is_empty(p_ccb->fcrb.waiting_for_ack_q))
2413 list = fixed_queue_get_list(p_ccb->fcrb.waiting_for_ack_q);
2414 if (list != NULL) {
2415 for (const list_node_t *node = list_begin(list), xx = 0;
2416 (node != list_end(list)) && (xx < num_bufs_acked);
2417 node = list_next(node), xx++) {
2418 p_buf = list_node(node);
2419 /* adding up length of acked I-frames to get throughput */
2420 p_ccb->fcrb.throughput[index] += p_buf->len - 8;
2421
2422 if (xx == num_bufs_acked - 1) {
2423 /* get timestamp from tx I-frame that receiver is acking */
2424 p = ((uint8_t*)(p_buf + 1)) + p_buf->offset + p_buf->len;
2425 if (p_ccb->bypass_fcs != L2CAP_BYPASS_FCS) {
2426 p += L2CAP_FCS_LEN;
2427 }
2428
2429 STREAM_TO_UINT32(timestamp, p);
2430 delay = time_get_os_boottime_ms() - timestamp;
2431
2432 p_ccb->fcrb.ack_delay_avg[index] += delay;
2433 if (delay > p_ccb->fcrb.ack_delay_max[index])
2434 p_ccb->fcrb.ack_delay_max[index] = delay;
2435 if (delay < p_ccb->fcrb.ack_delay_min[index])
2436 p_ccb->fcrb.ack_delay_min[index] = delay;
2437 }
2438 }
2439 }
2440
2441 p_ccb->fcrb.ack_delay_avg_count++;
2442
2443 /* calculate average and initialize next avg, min and max */
2444 if (p_ccb->fcrb.ack_delay_avg_count > L2CAP_ERTM_STATS_AVG_NUM_SAMPLES) {
2445 p_ccb->fcrb.ack_delay_avg_count = 0;
2446
2447 p_ccb->fcrb.ack_q_count_avg[index] /= L2CAP_ERTM_STATS_AVG_NUM_SAMPLES;
2448 p_ccb->fcrb.ack_delay_avg[index] /= L2CAP_ERTM_STATS_AVG_NUM_SAMPLES;
2449
2450 /* calculate throughput */
2451 timestamp = time_get_os_boottime_ms();
2452 if (timestamp - p_ccb->fcrb.throughput_start > 0)
2453 p_ccb->fcrb.throughput[index] /=
2454 (timestamp - p_ccb->fcrb.throughput_start);
2455
2456 p_ccb->fcrb.throughput_start = timestamp;
2457
2458 snprintf(
2459 str, sizeof(str),
2460 "[%02u] throughput: %5u, ack_delay avg:%3u, min:%3u, max:%3u, "
2461 "ack_q_count avg:%3u, min:%3u, max:%3u",
2462 index, p_ccb->fcrb.throughput[index], p_ccb->fcrb.ack_delay_avg[index],
2463 p_ccb->fcrb.ack_delay_min[index], p_ccb->fcrb.ack_delay_max[index],
2464 p_ccb->fcrb.ack_q_count_avg[index], p_ccb->fcrb.ack_q_count_min[index],
2465 p_ccb->fcrb.ack_q_count_max[index]);
2466
2467 BT_TRACE(TRACE_CTRL_GENERAL | TRACE_LAYER_GKI | TRACE_ORG_GKI,
2468 TRACE_TYPE_GENERIC, "%s", str);
2469
2470 index = (index + 1) % L2CAP_ERTM_STATS_NUM_AVG;
2471 p_ccb->fcrb.ack_delay_avg_index = index;
2472
2473 p_ccb->fcrb.ack_q_count_max[index] = 0;
2474 p_ccb->fcrb.ack_q_count_min[index] = 0xFFFFFFFF;
2475 p_ccb->fcrb.ack_q_count_avg[index] = 0;
2476
2477 p_ccb->fcrb.ack_delay_max[index] = 0;
2478 p_ccb->fcrb.ack_delay_min[index] = 0xFFFFFFFF;
2479 p_ccb->fcrb.ack_delay_avg[index] = 0;
2480
2481 p_ccb->fcrb.throughput[index] = 0;
2482 }
2483 }
2484 #endif
2485