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