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