1 /*
2 * IP Packet Parser Module.
3 *
4 * Copyright (C) 1999-2019, Broadcom.
5 *
6 * Unless you and Broadcom execute a separate written software license
7 * agreement governing use of this software, this software is licensed to you
8 * under the terms of the GNU General Public License version 2 (the "GPL"),
9 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
10 * following added to such license:
11 *
12 * As a special exception, the copyright holders of this software give you
13 * permission to link this software with independent modules, and to copy and
14 * distribute the resulting executable under terms of your choice, provided that
15 * you also meet, for each linked independent module, the terms and conditions
16 * of the license of that module. An independent module is a module which is
17 * not derived from this software. The special exception does not apply to any
18 * modifications of the software.
19 *
20 * Notwithstanding the above, under no circumstances may you combine this
21 * software in any way with any other Broadcom software provided under a license
22 * other than the GPL, without Broadcom's express prior written consent.
23 *
24 *
25 * <<Broadcom-WL-IPTag/Open:>>
26 *
27 * $Id: dhd_ip.c 813282 2019-04-04 09:42:28Z $
28 */
29 #include <typedefs.h>
30 #include <osl.h>
31
32 #include <ethernet.h>
33 #include <vlan.h>
34 #include <802.3.h>
35 #include <bcmip.h>
36 #include <bcmendian.h>
37
38 #include <dhd_dbg.h>
39
40 #include <dhd_ip.h>
41 #include <dhd_config.h>
42
43 #if defined(DHDTCPACK_SUPPRESS) || defined(DHDTCPSYNC_FLOOD_BLK)
44 #include <dhd_bus.h>
45 #include <dhd_proto.h>
46 #include <bcmtcp.h>
47 #endif /* DHDTCPACK_SUPPRESS || DHDTCPSYNC_FLOOD_BLK */
48
49 /* special values */
50 /* 802.3 llc/snap header */
51 static const uint8 llc_snap_hdr[SNAP_HDR_LEN] = {0xaa, 0xaa, 0x03,
52 0x00, 0x00, 0x00};
53
pkt_frag_info(osl_t * osh,void * p)54 pkt_frag_t pkt_frag_info(osl_t *osh, void *p)
55 {
56 uint8 *frame;
57 int length;
58 uint8 *pt; /* Pointer to type field */
59 uint16 ethertype;
60 struct ipv4_hdr *iph; /* IP frame pointer */
61 int ipl; /* IP frame length */
62 uint16 iph_frag;
63
64 ASSERT(osh && p);
65
66 frame = PKTDATA(osh, p);
67 length = PKTLEN(osh, p);
68 /* Process Ethernet II or SNAP-encapsulated 802.3 frames */
69 if (length < ETHER_HDR_LEN) {
70 DHD_INFO(("%s: short eth frame (%d)\n", __FUNCTION__, length));
71 return DHD_PKT_FRAG_NONE;
72 } else if (ntoh16(*(uint16 *)(frame + ETHER_TYPE_OFFSET)) >=
73 ETHER_TYPE_MIN) {
74 /* Frame is Ethernet II */
75 pt = frame + ETHER_TYPE_OFFSET;
76 } else if (length >= ETHER_HDR_LEN + SNAP_HDR_LEN + ETHER_TYPE_LEN &&
77 !bcmp(llc_snap_hdr, frame + ETHER_HDR_LEN, SNAP_HDR_LEN)) {
78 pt = frame + ETHER_HDR_LEN + SNAP_HDR_LEN;
79 } else {
80 DHD_INFO(("%s: non-SNAP 802.3 frame\n", __FUNCTION__));
81 return DHD_PKT_FRAG_NONE;
82 }
83
84 ethertype = ntoh16(*(uint16 *)pt);
85 /* Skip VLAN tag, if any */
86 if (ethertype == ETHER_TYPE_8021Q) {
87 pt += VLAN_TAG_LEN;
88
89 if (pt + ETHER_TYPE_LEN > frame + length) {
90 DHD_INFO(("%s: short VLAN frame (%d)\n", __FUNCTION__, length));
91 return DHD_PKT_FRAG_NONE;
92 }
93
94 ethertype = ntoh16(*(uint16 *)pt);
95 }
96
97 if (ethertype != ETHER_TYPE_IP) {
98 DHD_INFO(("%s: non-IP frame (ethertype 0x%x, length %d)\n",
99 __FUNCTION__, ethertype, length));
100 return DHD_PKT_FRAG_NONE;
101 }
102
103 iph = (struct ipv4_hdr *)(pt + ETHER_TYPE_LEN);
104 ipl = (uint)(length - (pt + ETHER_TYPE_LEN - frame));
105
106 /* We support IPv4 only */
107 if ((ipl < IPV4_OPTIONS_OFFSET) || (IP_VER(iph) != IP_VER_4)) {
108 DHD_INFO(("%s: short frame (%d) or non-IPv4\n", __FUNCTION__, ipl));
109 return DHD_PKT_FRAG_NONE;
110 }
111
112 iph_frag = ntoh16(iph->frag);
113 if (iph_frag & IPV4_FRAG_DONT) {
114 return DHD_PKT_FRAG_NONE;
115 } else if ((iph_frag & IPV4_FRAG_MORE) == 0) {
116 return DHD_PKT_FRAG_LAST;
117 } else {
118 return (iph_frag & IPV4_FRAG_OFFSET_MASK) ? DHD_PKT_FRAG_CONT
119 : DHD_PKT_FRAG_FIRST;
120 }
121 }
122
123 #ifdef DHDTCPACK_SUPPRESS
124
125 typedef struct {
126 void *pkt_in_q; /* TCP ACK packet that is already in txq or DelayQ */
127 void *pkt_ether_hdr; /* Ethernet header pointer of pkt_in_q */
128 int ifidx;
129 uint8 supp_cnt;
130 dhd_pub_t *dhdp;
131 #ifndef TCPACK_SUPPRESS_HOLD_HRT
132 timer_list_compat_t timer;
133 #else
134 struct tasklet_hrtimer timer;
135 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
136 } tcpack_info_t;
137
138 typedef struct _tdata_psh_info_t {
139 uint32 end_seq; /* end seq# of a received TCP PSH DATA pkt */
140 struct _tdata_psh_info_t *next; /* next pointer of the link chain */
141 } tdata_psh_info_t;
142
143 typedef struct {
144 struct {
145 uint8 src[IPV4_ADDR_LEN]; /* SRC ip addrs of this TCP stream */
146 uint8 dst[IPV4_ADDR_LEN]; /* DST ip addrs of this TCP stream */
147 } ip_addr;
148 struct {
149 uint8 src[TCP_PORT_LEN]; /* SRC tcp ports of this TCP stream */
150 uint8 dst[TCP_PORT_LEN]; /* DST tcp ports of this TCP stream */
151 } tcp_port;
152 tdata_psh_info_t
153 *tdata_psh_info_head; /* Head of received TCP PSH DATA chain */
154 tdata_psh_info_t
155 *tdata_psh_info_tail; /* Tail of received TCP PSH DATA chain */
156 uint32 last_used_time; /* The last time this tcpdata_info was used(in ms) */
157 } tcpdata_info_t;
158
159 /* TCPACK SUPPRESS module */
160 typedef struct {
161 int tcpack_info_cnt;
162 tcpack_info_t
163 tcpack_info_tbl[TCPACK_INFO_MAXNUM]; /* Info of TCP ACK to send */
164 int tcpdata_info_cnt;
165 tcpdata_info_t
166 tcpdata_info_tbl[TCPDATA_INFO_MAXNUM]; /* Info of received TCP DATA */
167 tdata_psh_info_t
168 *tdata_psh_info_pool; /* Pointer to tdata_psh_info elements pool */
169 tdata_psh_info_t
170 *tdata_psh_info_free; /* free tdata_psh_info elements chain in pool */
171 #ifdef DHDTCPACK_SUP_DBG
172 int psh_info_enq_num; /* Number of free TCP PSH DATA info elements in pool
173 */
174 #endif /* DHDTCPACK_SUP_DBG */
175 } tcpack_sup_module_t;
176
177 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
178 counter_tbl_t tack_tbl = {"tcpACK",
179 0,
180 1000,
181 10,
182 {
183 0,
184 },
185 1};
186 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
187
_tdata_psh_info_pool_enq(tcpack_sup_module_t * tcpack_sup_mod,tdata_psh_info_t * tdata_psh_info)188 static void _tdata_psh_info_pool_enq(tcpack_sup_module_t *tcpack_sup_mod,
189 tdata_psh_info_t *tdata_psh_info)
190 {
191 if ((tcpack_sup_mod == NULL) || (tdata_psh_info == NULL)) {
192 DHD_ERROR(("%s %d: ERROR %p %p\n", __FUNCTION__, __LINE__,
193 tcpack_sup_mod, tdata_psh_info));
194 return;
195 }
196
197 ASSERT(tdata_psh_info->next == NULL);
198 tdata_psh_info->next = tcpack_sup_mod->tdata_psh_info_free;
199 tcpack_sup_mod->tdata_psh_info_free = tdata_psh_info;
200 #ifdef DHDTCPACK_SUP_DBG
201 tcpack_sup_mod->psh_info_enq_num++;
202 #endif // endif
203 }
204
205 static tdata_psh_info_t *
_tdata_psh_info_pool_deq(tcpack_sup_module_t * tcpack_sup_mod)206 _tdata_psh_info_pool_deq(tcpack_sup_module_t *tcpack_sup_mod)
207 {
208 tdata_psh_info_t *tdata_psh_info = NULL;
209
210 if (tcpack_sup_mod == NULL) {
211 DHD_ERROR(
212 ("%s %d: ERROR %p\n", __FUNCTION__, __LINE__, tcpack_sup_mod));
213 return NULL;
214 }
215
216 tdata_psh_info = tcpack_sup_mod->tdata_psh_info_free;
217 if (tdata_psh_info == NULL) {
218 DHD_ERROR(("%s %d: Out of tdata_disc_grp\n", __FUNCTION__, __LINE__));
219 } else {
220 tcpack_sup_mod->tdata_psh_info_free = tdata_psh_info->next;
221 tdata_psh_info->next = NULL;
222 #ifdef DHDTCPACK_SUP_DBG
223 tcpack_sup_mod->psh_info_enq_num--;
224 #endif /* DHDTCPACK_SUP_DBG */
225 }
226
227 return tdata_psh_info;
228 }
229
230 #ifdef BCMSDIO
_tdata_psh_info_pool_init(dhd_pub_t * dhdp,tcpack_sup_module_t * tcpack_sup_mod)231 static int _tdata_psh_info_pool_init(dhd_pub_t *dhdp,
232 tcpack_sup_module_t *tcpack_sup_mod)
233 {
234 tdata_psh_info_t *tdata_psh_info_pool = NULL;
235 uint i;
236
237 DHD_TRACE(("%s %d: Enter\n", __FUNCTION__, __LINE__));
238
239 if (tcpack_sup_mod == NULL) {
240 return BCME_ERROR;
241 }
242
243 ASSERT(tcpack_sup_mod->tdata_psh_info_pool == NULL);
244 ASSERT(tcpack_sup_mod->tdata_psh_info_free == NULL);
245
246 tdata_psh_info_pool =
247 MALLOC(dhdp->osh, sizeof(tdata_psh_info_t) * TCPDATA_PSH_INFO_MAXNUM);
248 if (tdata_psh_info_pool == NULL) {
249 return BCME_NOMEM;
250 }
251 bzero(tdata_psh_info_pool,
252 sizeof(tdata_psh_info_t) * TCPDATA_PSH_INFO_MAXNUM);
253 #ifdef DHDTCPACK_SUP_DBG
254 tcpack_sup_mod->psh_info_enq_num = 0;
255 #endif /* DHDTCPACK_SUP_DBG */
256
257 /* Enqueue newly allocated tcpdata psh info elements to the pool */
258 for (i = 0; i < TCPDATA_PSH_INFO_MAXNUM; i++) {
259 _tdata_psh_info_pool_enq(tcpack_sup_mod, &tdata_psh_info_pool[i]);
260 }
261
262 ASSERT(tcpack_sup_mod->tdata_psh_info_free != NULL);
263 tcpack_sup_mod->tdata_psh_info_pool = tdata_psh_info_pool;
264
265 return BCME_OK;
266 }
267
_tdata_psh_info_pool_deinit(dhd_pub_t * dhdp,tcpack_sup_module_t * tcpack_sup_mod)268 static void _tdata_psh_info_pool_deinit(dhd_pub_t *dhdp,
269 tcpack_sup_module_t *tcpack_sup_mod)
270 {
271 uint i;
272 tdata_psh_info_t *tdata_psh_info;
273
274 DHD_TRACE(("%s %d: Enter\n", __FUNCTION__, __LINE__));
275
276 if (tcpack_sup_mod == NULL) {
277 DHD_ERROR(
278 ("%s %d: ERROR tcpack_sup_mod NULL!\n", __FUNCTION__, __LINE__));
279 return;
280 }
281
282 for (i = 0; i < tcpack_sup_mod->tcpdata_info_cnt; i++) {
283 tcpdata_info_t *tcpdata_info = &tcpack_sup_mod->tcpdata_info_tbl[i];
284 /* Return tdata_psh_info elements allocated to each tcpdata_info to the
285 * pool */
286 while ((tdata_psh_info = tcpdata_info->tdata_psh_info_head)) {
287 tcpdata_info->tdata_psh_info_head = tdata_psh_info->next;
288 tdata_psh_info->next = NULL;
289 _tdata_psh_info_pool_enq(tcpack_sup_mod, tdata_psh_info);
290 }
291 tcpdata_info->tdata_psh_info_tail = NULL;
292 }
293 #ifdef DHDTCPACK_SUP_DBG
294 DHD_ERROR(("%s %d: PSH INFO ENQ %d\n", __FUNCTION__, __LINE__,
295 tcpack_sup_mod->psh_info_enq_num));
296 #endif /* DHDTCPACK_SUP_DBG */
297
298 i = 0;
299 /* Be sure we recollected all tdata_psh_info elements */
300 while ((tdata_psh_info = tcpack_sup_mod->tdata_psh_info_free)) {
301 tcpack_sup_mod->tdata_psh_info_free = tdata_psh_info->next;
302 tdata_psh_info->next = NULL;
303 i++;
304 }
305 ASSERT(i == TCPDATA_PSH_INFO_MAXNUM);
306 MFREE(dhdp->osh, tcpack_sup_mod->tdata_psh_info_pool,
307 sizeof(tdata_psh_info_t) * TCPDATA_PSH_INFO_MAXNUM);
308 tcpack_sup_mod->tdata_psh_info_pool = NULL;
309
310 return;
311 }
312 #endif /* BCMSDIO */
313
314 #ifdef BCMPCIE
315 #ifndef TCPACK_SUPPRESS_HOLD_HRT
dhd_tcpack_send(ulong data)316 static void dhd_tcpack_send(ulong data)
317 #else
318 static enum hrtimer_restart dhd_tcpack_send(struct hrtimer *timer)
319 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
320 {
321 tcpack_sup_module_t *tcpack_sup_mod;
322 tcpack_info_t *cur_tbl;
323 dhd_pub_t *dhdp;
324 int ifidx;
325 void *pkt;
326 unsigned long flags;
327
328 #ifndef TCPACK_SUPPRESS_HOLD_HRT
329 cur_tbl = (tcpack_info_t *)data;
330 #else
331 cur_tbl = container_of(timer, tcpack_info_t, timer.timer);
332 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
333 if (!cur_tbl) {
334 goto done;
335 }
336
337 dhdp = cur_tbl->dhdp;
338 if (!dhdp) {
339 goto done;
340 }
341
342 flags = dhd_os_tcpacklock(dhdp);
343
344 if (unlikely(dhdp->tcpack_sup_mode != TCPACK_SUP_HOLD)) {
345 dhd_os_tcpackunlock(dhdp, flags);
346 goto done;
347 }
348
349 tcpack_sup_mod = dhdp->tcpack_sup_module;
350 if (!tcpack_sup_mod) {
351 DHD_ERROR(
352 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
353 dhd_os_tcpackunlock(dhdp, flags);
354 goto done;
355 }
356 pkt = cur_tbl->pkt_in_q;
357 ifidx = cur_tbl->ifidx;
358 if (!pkt) {
359 dhd_os_tcpackunlock(dhdp, flags);
360 goto done;
361 }
362 cur_tbl->pkt_in_q = NULL;
363 cur_tbl->pkt_ether_hdr = NULL;
364 cur_tbl->ifidx = 0;
365 cur_tbl->supp_cnt = 0;
366 if (--tcpack_sup_mod->tcpack_info_cnt < 0) {
367 DHD_ERROR(("%s %d: ERROR!!! tcp_ack_info_cnt %d\n", __FUNCTION__,
368 __LINE__, tcpack_sup_mod->tcpack_info_cnt));
369 }
370
371 dhd_os_tcpackunlock(dhdp, flags);
372
373 dhd_sendpkt(dhdp, ifidx, pkt);
374
375 done:
376 #ifndef TCPACK_SUPPRESS_HOLD_HRT
377 return;
378 #else
379 return HRTIMER_NORESTART;
380 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
381 }
382 #endif /* BCMPCIE */
383
dhd_tcpack_suppress_set(dhd_pub_t * dhdp,uint8 mode)384 int dhd_tcpack_suppress_set(dhd_pub_t *dhdp, uint8 mode)
385 {
386 int ret = BCME_OK;
387 unsigned long flags;
388 tcpack_sup_module_t *tcpack_sup_module;
389 uint8 invalid_mode = FALSE;
390 int prev_mode;
391 int i = 0;
392
393 flags = dhd_os_tcpacklock(dhdp);
394 tcpack_sup_module = dhdp->tcpack_sup_module;
395 prev_mode = dhdp->tcpack_sup_mode;
396
397 if (prev_mode == mode) {
398 DHD_ERROR(("%s %d: already set to %d\n", __FUNCTION__, __LINE__, mode));
399 goto exit;
400 }
401
402 invalid_mode |= (mode >= TCPACK_SUP_LAST_MODE);
403 #ifdef BCMSDIO
404 invalid_mode |= (mode == TCPACK_SUP_HOLD);
405 #endif /* BCMSDIO */
406 #ifdef BCMPCIE
407 invalid_mode |=
408 ((mode == TCPACK_SUP_REPLACE) || (mode == TCPACK_SUP_DELAYTX));
409 #endif /* BCMPCIE */
410
411 if (invalid_mode) {
412 DHD_ERROR(("%s %d: Invalid TCP ACK Suppress mode %d\n", __FUNCTION__,
413 __LINE__, mode));
414 ret = BCME_BADARG;
415 goto exit;
416 }
417
418 printf("%s: TCP ACK Suppress mode %d -> mode %d\n", __FUNCTION__,
419 dhdp->tcpack_sup_mode, mode);
420
421 /* Pre-process routines to change a new mode as per previous mode */
422 switch (prev_mode) {
423 case TCPACK_SUP_OFF:
424 if (tcpack_sup_module == NULL) {
425 tcpack_sup_module =
426 MALLOC(dhdp->osh, sizeof(tcpack_sup_module_t));
427 if (tcpack_sup_module == NULL) {
428 DHD_ERROR(("%s[%d]: Failed to allocate the new memory for "
429 "tcpack_sup_module\n",
430 __FUNCTION__, __LINE__));
431 dhdp->tcpack_sup_mode = TCPACK_SUP_OFF;
432 ret = BCME_NOMEM;
433 goto exit;
434 }
435 dhdp->tcpack_sup_module = tcpack_sup_module;
436 }
437 bzero(tcpack_sup_module, sizeof(tcpack_sup_module_t));
438 break;
439 #ifdef BCMSDIO
440 case TCPACK_SUP_DELAYTX:
441 if (tcpack_sup_module) {
442 /* We won't need tdata_psh_info pool and
443 * tcpddata_info_tbl anymore
444 */
445 _tdata_psh_info_pool_deinit(dhdp, tcpack_sup_module);
446 tcpack_sup_module->tcpdata_info_cnt = 0;
447 bzero(tcpack_sup_module->tcpdata_info_tbl,
448 sizeof(tcpdata_info_t) * TCPDATA_INFO_MAXNUM);
449 }
450
451 /* For half duplex bus interface, tx precedes rx by default */
452 if (dhdp->bus) {
453 dhd_bus_set_dotxinrx(dhdp->bus, TRUE);
454 }
455
456 if (tcpack_sup_module == NULL) {
457 DHD_ERROR(("%s[%d]: tcpack_sup_module should not be NULL\n",
458 __FUNCTION__, __LINE__));
459 dhdp->tcpack_sup_mode = TCPACK_SUP_OFF;
460 goto exit;
461 }
462 break;
463 #endif /* BCMSDIO */
464 }
465
466 /* Update a new mode */
467 dhdp->tcpack_sup_mode = mode;
468
469 /* Process for a new mode */
470 switch (mode) {
471 case TCPACK_SUP_OFF:
472 ASSERT(tcpack_sup_module != NULL);
473 /* Clean up timer/data structure for
474 * any remaining/pending packet or timer.
475 */
476 if (tcpack_sup_module) {
477 /* Check if previous mode is TCAPACK_SUP_HOLD */
478 if (prev_mode == TCPACK_SUP_HOLD) {
479 for (i = 0; i < TCPACK_INFO_MAXNUM; i++) {
480 tcpack_info_t *tcpack_info_tbl =
481 &tcpack_sup_module->tcpack_info_tbl[i];
482 #ifndef TCPACK_SUPPRESS_HOLD_HRT
483 del_timer(&tcpack_info_tbl->timer);
484 #else
485 hrtimer_cancel(&tcpack_info_tbl->timer.timer);
486 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
487 if (tcpack_info_tbl->pkt_in_q) {
488 PKTFREE(dhdp->osh, tcpack_info_tbl->pkt_in_q, TRUE);
489 tcpack_info_tbl->pkt_in_q = NULL;
490 }
491 }
492 }
493 MFREE(dhdp->osh, tcpack_sup_module,
494 sizeof(tcpack_sup_module_t));
495 dhdp->tcpack_sup_module = NULL;
496 } else {
497 DHD_ERROR(("%s[%d]: tcpack_sup_module should not be NULL\n",
498 __FUNCTION__, __LINE__));
499 }
500 break;
501 #ifdef BCMSDIO
502 case TCPACK_SUP_REPLACE:
503 /* There is nothing to configure for this mode */
504 break;
505 case TCPACK_SUP_DELAYTX:
506 ret = _tdata_psh_info_pool_init(dhdp, tcpack_sup_module);
507 if (ret != BCME_OK) {
508 DHD_ERROR(("%s %d: pool init fail with %d\n", __FUNCTION__,
509 __LINE__, ret));
510 break;
511 }
512 if (dhdp->bus) {
513 dhd_bus_set_dotxinrx(dhdp->bus, FALSE);
514 }
515 break;
516 #endif /* BCMSDIO */
517 #ifdef BCMPCIE
518 case TCPACK_SUP_HOLD:
519 dhdp->tcpack_sup_ratio = dhdp->conf->tcpack_sup_ratio;
520 dhdp->tcpack_sup_delay = dhdp->conf->tcpack_sup_delay;
521 for (i = 0; i < TCPACK_INFO_MAXNUM; i++) {
522 tcpack_info_t *tcpack_info_tbl =
523 &tcpack_sup_module->tcpack_info_tbl[i];
524 tcpack_info_tbl->dhdp = dhdp;
525 #ifndef TCPACK_SUPPRESS_HOLD_HRT
526 init_timer_compat(&tcpack_info_tbl->timer, dhd_tcpack_send,
527 tcpack_info_tbl);
528 #else
529 tasklet_hrtimer_init(&tcpack_info_tbl->timer, dhd_tcpack_send,
530 CLOCK_MONOTONIC, HRTIMER_MODE_REL);
531 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
532 }
533 break;
534 #endif /* BCMPCIE */
535 }
536
537 exit:
538 dhd_os_tcpackunlock(dhdp, flags);
539 return ret;
540 }
541
dhd_tcpack_info_tbl_clean(dhd_pub_t * dhdp)542 void dhd_tcpack_info_tbl_clean(dhd_pub_t *dhdp)
543 {
544 tcpack_sup_module_t *tcpack_sup_mod = dhdp->tcpack_sup_module;
545 int i;
546 unsigned long flags;
547
548 if (dhdp->tcpack_sup_mode == TCPACK_SUP_OFF) {
549 goto exit;
550 }
551
552 flags = dhd_os_tcpacklock(dhdp);
553
554 if (!tcpack_sup_mod) {
555 DHD_ERROR(
556 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
557 dhd_os_tcpackunlock(dhdp, flags);
558 goto exit;
559 }
560
561 if (dhdp->tcpack_sup_mode == TCPACK_SUP_HOLD) {
562 for (i = 0; i < TCPACK_INFO_MAXNUM; i++) {
563 if (tcpack_sup_mod->tcpack_info_tbl[i].pkt_in_q) {
564 PKTFREE(dhdp->osh, tcpack_sup_mod->tcpack_info_tbl[i].pkt_in_q,
565 TRUE);
566 tcpack_sup_mod->tcpack_info_tbl[i].pkt_in_q = NULL;
567 tcpack_sup_mod->tcpack_info_tbl[i].pkt_ether_hdr = NULL;
568 tcpack_sup_mod->tcpack_info_tbl[i].ifidx = 0;
569 tcpack_sup_mod->tcpack_info_tbl[i].supp_cnt = 0;
570 }
571 }
572 } else {
573 tcpack_sup_mod->tcpack_info_cnt = 0;
574 bzero(tcpack_sup_mod->tcpack_info_tbl,
575 sizeof(tcpack_info_t) * TCPACK_INFO_MAXNUM);
576 }
577
578 dhd_os_tcpackunlock(dhdp, flags);
579
580 if (dhdp->tcpack_sup_mode == TCPACK_SUP_HOLD) {
581 for (i = 0; i < TCPACK_INFO_MAXNUM; i++) {
582 #ifndef TCPACK_SUPPRESS_HOLD_HRT
583 del_timer_sync(&tcpack_sup_mod->tcpack_info_tbl[i].timer);
584 #else
585 hrtimer_cancel(&tcpack_sup_mod->tcpack_info_tbl[i].timer.timer);
586 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
587 }
588 }
589
590 exit:
591 return;
592 }
593
dhd_tcpack_check_xmit(dhd_pub_t * dhdp,void * pkt)594 inline int dhd_tcpack_check_xmit(dhd_pub_t *dhdp, void *pkt)
595 {
596 uint8 i;
597 tcpack_sup_module_t *tcpack_sup_mod;
598 tcpack_info_t *tcpack_info_tbl;
599 int tbl_cnt;
600 int ret = BCME_OK;
601 void *pdata;
602 uint32 pktlen;
603 unsigned long flags;
604
605 if (dhdp->tcpack_sup_mode == TCPACK_SUP_OFF) {
606 goto exit;
607 }
608
609 pdata = PKTDATA(dhdp->osh, pkt);
610 pktlen = PKTLEN(dhdp->osh, pkt) - dhd_prot_hdrlen(dhdp, pdata);
611 if (pktlen < TCPACKSZMIN || pktlen > TCPACKSZMAX) {
612 DHD_TRACE(("%s %d: Too short or long length %d to be TCP ACK\n",
613 __FUNCTION__, __LINE__, pktlen));
614 goto exit;
615 }
616
617 flags = dhd_os_tcpacklock(dhdp);
618 tcpack_sup_mod = dhdp->tcpack_sup_module;
619
620 if (!tcpack_sup_mod) {
621 DHD_ERROR(
622 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
623 ret = BCME_ERROR;
624 dhd_os_tcpackunlock(dhdp, flags);
625 goto exit;
626 }
627 tbl_cnt = tcpack_sup_mod->tcpack_info_cnt;
628 tcpack_info_tbl = tcpack_sup_mod->tcpack_info_tbl;
629
630 ASSERT(tbl_cnt <= TCPACK_INFO_MAXNUM);
631
632 for (i = 0; i < tbl_cnt; i++) {
633 if (tcpack_info_tbl[i].pkt_in_q == pkt) {
634 DHD_TRACE(("%s %d: pkt %p sent out. idx %d, tbl_cnt %d\n",
635 __FUNCTION__, __LINE__, pkt, i, tbl_cnt));
636 /* This pkt is being transmitted so remove the tcp_ack_info of it.
637 */
638 if (i < tbl_cnt - 1) {
639 bcopy(&tcpack_info_tbl[tbl_cnt - 1], &tcpack_info_tbl[i],
640 sizeof(tcpack_info_t));
641 }
642 bzero(&tcpack_info_tbl[tbl_cnt - 1], sizeof(tcpack_info_t));
643 if (--tcpack_sup_mod->tcpack_info_cnt < 0) {
644 DHD_ERROR(("%s %d: ERROR!!! tcp_ack_info_cnt %d\n",
645 __FUNCTION__, __LINE__,
646 tcpack_sup_mod->tcpack_info_cnt));
647 ret = BCME_ERROR;
648 }
649 break;
650 }
651 }
652 dhd_os_tcpackunlock(dhdp, flags);
653
654 exit:
655 return ret;
656 }
657
dhd_tcpdata_psh_acked(dhd_pub_t * dhdp,uint8 * ip_hdr,uint8 * tcp_hdr,uint32 tcp_ack_num)658 static INLINE bool dhd_tcpdata_psh_acked(dhd_pub_t *dhdp, uint8 *ip_hdr,
659 uint8 *tcp_hdr, uint32 tcp_ack_num)
660 {
661 tcpack_sup_module_t *tcpack_sup_mod;
662 int i;
663 tcpdata_info_t *tcpdata_info = NULL;
664 tdata_psh_info_t *tdata_psh_info = NULL;
665 bool ret = FALSE;
666
667 if (dhdp->tcpack_sup_mode != TCPACK_SUP_DELAYTX) {
668 goto exit;
669 }
670
671 tcpack_sup_mod = dhdp->tcpack_sup_module;
672
673 if (!tcpack_sup_mod) {
674 DHD_ERROR(
675 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
676 goto exit;
677 }
678
679 DHD_TRACE(("%s %d: IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR
680 " TCP port %d %d, ack %u\n",
681 __FUNCTION__, __LINE__,
682 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
683 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
684 ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
685 ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET]), tcp_ack_num));
686
687 for (i = 0; i < tcpack_sup_mod->tcpdata_info_cnt; i++) {
688 tcpdata_info_t *tcpdata_info_tmp = &tcpack_sup_mod->tcpdata_info_tbl[i];
689 DHD_TRACE(("%s %d: data info[%d], IP addr " IPV4_ADDR_STR
690 " " IPV4_ADDR_STR " TCP port %d %d\n",
691 __FUNCTION__, __LINE__, i,
692 IPV4_ADDR_TO_STR(ntoh32_ua(tcpdata_info_tmp->ip_addr.src)),
693 IPV4_ADDR_TO_STR(ntoh32_ua(tcpdata_info_tmp->ip_addr.dst)),
694 ntoh16_ua(tcpdata_info_tmp->tcp_port.src),
695 ntoh16_ua(tcpdata_info_tmp->tcp_port.dst)));
696
697 /* If either IP address or TCP port number does not match, skip. */
698 if (memcmp(&ip_hdr[IPV4_SRC_IP_OFFSET], tcpdata_info_tmp->ip_addr.dst,
699 IPV4_ADDR_LEN) == 0 &&
700 memcmp(&ip_hdr[IPV4_DEST_IP_OFFSET], tcpdata_info_tmp->ip_addr.src,
701 IPV4_ADDR_LEN) == 0 &&
702 memcmp(&tcp_hdr[TCP_SRC_PORT_OFFSET],
703 tcpdata_info_tmp->tcp_port.dst, TCP_PORT_LEN) == 0 &&
704 memcmp(&tcp_hdr[TCP_DEST_PORT_OFFSET],
705 tcpdata_info_tmp->tcp_port.src, TCP_PORT_LEN) == 0) {
706 tcpdata_info = tcpdata_info_tmp;
707 break;
708 }
709 }
710
711 if (tcpdata_info == NULL) {
712 DHD_TRACE(("%s %d: no tcpdata_info!\n", __FUNCTION__, __LINE__));
713 goto exit;
714 }
715
716 if (tcpdata_info->tdata_psh_info_head == NULL) {
717 DHD_TRACE(
718 ("%s %d: No PSH DATA to be acked!\n", __FUNCTION__, __LINE__));
719 }
720
721 while ((tdata_psh_info = tcpdata_info->tdata_psh_info_head)) {
722 if (IS_TCPSEQ_GE(tcp_ack_num, tdata_psh_info->end_seq)) {
723 DHD_TRACE(("%s %d: PSH ACKED! %u >= %u\n", __FUNCTION__, __LINE__,
724 tcp_ack_num, tdata_psh_info->end_seq));
725 tcpdata_info->tdata_psh_info_head = tdata_psh_info->next;
726 tdata_psh_info->next = NULL;
727 _tdata_psh_info_pool_enq(tcpack_sup_mod, tdata_psh_info);
728 ret = TRUE;
729 } else {
730 break;
731 }
732 }
733 if (tdata_psh_info == NULL) {
734 tcpdata_info->tdata_psh_info_tail = NULL;
735 }
736
737 #ifdef DHDTCPACK_SUP_DBG
738 DHD_TRACE(("%s %d: PSH INFO ENQ %d\n", __FUNCTION__, __LINE__,
739 tcpack_sup_mod->psh_info_enq_num));
740 #endif /* DHDTCPACK_SUP_DBG */
741
742 exit:
743 return ret;
744 }
745
dhd_tcpack_suppress(dhd_pub_t * dhdp,void * pkt)746 bool dhd_tcpack_suppress(dhd_pub_t *dhdp, void *pkt)
747 {
748 uint8 *new_ether_hdr; /* Ethernet header of the new packet */
749 uint16 new_ether_type; /* Ethernet type of the new packet */
750 uint8 *new_ip_hdr; /* IP header of the new packet */
751 uint8 *new_tcp_hdr; /* TCP header of the new packet */
752 uint32 new_ip_hdr_len; /* IP header length of the new packet */
753 uint32 cur_framelen;
754 uint32 new_tcp_ack_num; /* TCP acknowledge number of the new packet */
755 uint16 new_ip_total_len; /* Total length of IP packet for the new packet */
756 uint32 new_tcp_hdr_len; /* TCP header length of the new packet */
757 tcpack_sup_module_t *tcpack_sup_mod;
758 tcpack_info_t *tcpack_info_tbl;
759 int i;
760 bool ret = FALSE;
761 bool set_dotxinrx = TRUE;
762 unsigned long flags;
763
764 if (dhdp->tcpack_sup_mode == TCPACK_SUP_OFF) {
765 goto exit;
766 }
767
768 new_ether_hdr = PKTDATA(dhdp->osh, pkt);
769 cur_framelen = PKTLEN(dhdp->osh, pkt);
770 if (cur_framelen < TCPACKSZMIN || cur_framelen > TCPACKSZMAX) {
771 DHD_TRACE(("%s %d: Too short or long length %d to be TCP ACK\n",
772 __FUNCTION__, __LINE__, cur_framelen));
773 goto exit;
774 }
775
776 new_ether_type = new_ether_hdr[0xC] << 0x8 | new_ether_hdr[0xD];
777
778 if (new_ether_type != ETHER_TYPE_IP) {
779 DHD_TRACE(("%s %d: Not a IP packet 0x%x\n", __FUNCTION__, __LINE__,
780 new_ether_type));
781 goto exit;
782 }
783
784 DHD_TRACE(
785 ("%s %d: IP pkt! 0x%x\n", __FUNCTION__, __LINE__, new_ether_type));
786
787 new_ip_hdr = new_ether_hdr + ETHER_HDR_LEN;
788 cur_framelen -= ETHER_HDR_LEN;
789
790 ASSERT(cur_framelen >= IPV4_MIN_HEADER_LEN);
791
792 new_ip_hdr_len = IPV4_HLEN(new_ip_hdr);
793 if (IP_VER(new_ip_hdr) != IP_VER_4 ||
794 IPV4_PROT(new_ip_hdr) != IP_PROT_TCP) {
795 DHD_TRACE(("%s %d: Not IPv4 nor TCP! ip ver %d, prot %d\n",
796 __FUNCTION__, __LINE__, IP_VER(new_ip_hdr),
797 IPV4_PROT(new_ip_hdr)));
798 goto exit;
799 }
800
801 new_tcp_hdr = new_ip_hdr + new_ip_hdr_len;
802 cur_framelen -= new_ip_hdr_len;
803
804 ASSERT(cur_framelen >= TCP_MIN_HEADER_LEN);
805
806 DHD_TRACE(("%s %d: TCP pkt!\n", __FUNCTION__, __LINE__));
807
808 /* is it an ack ? Allow only ACK flag, not to suppress others. */
809 if (new_tcp_hdr[TCP_FLAGS_OFFSET] != TCP_FLAG_ACK) {
810 DHD_TRACE(("%s %d: Do not touch TCP flag 0x%x\n", __FUNCTION__,
811 __LINE__, new_tcp_hdr[TCP_FLAGS_OFFSET]));
812 goto exit;
813 }
814
815 new_ip_total_len = ntoh16_ua(&new_ip_hdr[IPV4_PKTLEN_OFFSET]);
816 new_tcp_hdr_len = 0x4 * TCP_HDRLEN(new_tcp_hdr[TCP_HLEN_OFFSET]);
817 /* This packet has TCP data, so just send */
818 if (new_ip_total_len > new_ip_hdr_len + new_tcp_hdr_len) {
819 DHD_TRACE(("%s %d: Do nothing for TCP DATA\n", __FUNCTION__, __LINE__));
820 goto exit;
821 }
822
823 ASSERT(new_ip_total_len == new_ip_hdr_len + new_tcp_hdr_len);
824
825 new_tcp_ack_num = ntoh32_ua(&new_tcp_hdr[TCP_ACK_NUM_OFFSET]);
826
827 DHD_TRACE(("%s %d: TCP ACK with zero DATA length"
828 " IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR " TCP port %d %d\n",
829 __FUNCTION__, __LINE__,
830 IPV4_ADDR_TO_STR(ntoh32_ua(&new_ip_hdr[IPV4_SRC_IP_OFFSET])),
831 IPV4_ADDR_TO_STR(ntoh32_ua(&new_ip_hdr[IPV4_DEST_IP_OFFSET])),
832 ntoh16_ua(&new_tcp_hdr[TCP_SRC_PORT_OFFSET]),
833 ntoh16_ua(&new_tcp_hdr[TCP_DEST_PORT_OFFSET])));
834
835 /* Look for tcp_ack_info that has the same ip src/dst addrs and tcp src/dst
836 * ports */
837 flags = dhd_os_tcpacklock(dhdp);
838 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
839 counter_printlog(&tack_tbl);
840 tack_tbl.cnt[0]++;
841 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
842
843 tcpack_sup_mod = dhdp->tcpack_sup_module;
844 tcpack_info_tbl = tcpack_sup_mod->tcpack_info_tbl;
845
846 if (!tcpack_sup_mod) {
847 DHD_ERROR(
848 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
849 ret = BCME_ERROR;
850 dhd_os_tcpackunlock(dhdp, flags);
851 goto exit;
852 }
853
854 if (dhd_tcpdata_psh_acked(dhdp, new_ip_hdr, new_tcp_hdr, new_tcp_ack_num)) {
855 /* This TCPACK is ACK to TCPDATA PSH pkt, so keep set_dotxinrx TRUE */
856 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
857 tack_tbl.cnt[0x5]++;
858 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
859 } else {
860 set_dotxinrx = FALSE;
861 }
862
863 for (i = 0; i < tcpack_sup_mod->tcpack_info_cnt; i++) {
864 void *oldpkt; /* TCPACK packet that is already in txq or DelayQ */
865 uint8 *old_ether_hdr, *old_ip_hdr, *old_tcp_hdr;
866 uint32 old_ip_hdr_len, old_tcp_hdr_len;
867 uint32 old_tcpack_num; /* TCP ACK number of old TCPACK packet in Q */
868
869 if ((oldpkt = tcpack_info_tbl[i].pkt_in_q) == NULL) {
870 DHD_ERROR(("%s %d: Unexpected error!! cur idx %d, ttl cnt %d\n",
871 __FUNCTION__, __LINE__, i,
872 tcpack_sup_mod->tcpack_info_cnt));
873 break;
874 }
875
876 if (PKTDATA(dhdp->osh, oldpkt) == NULL) {
877 DHD_ERROR(("%s %d: oldpkt data NULL!! cur idx %d, ttl cnt %d\n",
878 __FUNCTION__, __LINE__, i,
879 tcpack_sup_mod->tcpack_info_cnt));
880 break;
881 }
882
883 old_ether_hdr = tcpack_info_tbl[i].pkt_ether_hdr;
884 old_ip_hdr = old_ether_hdr + ETHER_HDR_LEN;
885 old_ip_hdr_len = IPV4_HLEN(old_ip_hdr);
886 old_tcp_hdr = old_ip_hdr + old_ip_hdr_len;
887 old_tcp_hdr_len = 0x4 * TCP_HDRLEN(old_tcp_hdr[TCP_HLEN_OFFSET]);
888
889 DHD_TRACE(
890 ("%s %d: oldpkt %p[%d], IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR
891 " TCP port %d %d\n",
892 __FUNCTION__, __LINE__, oldpkt, i,
893 IPV4_ADDR_TO_STR(ntoh32_ua(&old_ip_hdr[IPV4_SRC_IP_OFFSET])),
894 IPV4_ADDR_TO_STR(ntoh32_ua(&old_ip_hdr[IPV4_DEST_IP_OFFSET])),
895 ntoh16_ua(&old_tcp_hdr[TCP_SRC_PORT_OFFSET]),
896 ntoh16_ua(&old_tcp_hdr[TCP_DEST_PORT_OFFSET])));
897
898 /* If either of IP address or TCP port number does not match, skip.
899 * Note that src/dst addr fields in ip header are contiguous being 8
900 * bytes in total. Also, src/dst port fields in TCP header are
901 * contiguous being 4 bytes in total.
902 */
903 if (memcmp(&new_ip_hdr[IPV4_SRC_IP_OFFSET],
904 &old_ip_hdr[IPV4_SRC_IP_OFFSET], IPV4_ADDR_LEN * 0x2) ||
905 memcmp(&new_tcp_hdr[TCP_SRC_PORT_OFFSET],
906 &old_tcp_hdr[TCP_SRC_PORT_OFFSET], TCP_PORT_LEN * 0x2)) {
907 continue;
908 }
909
910 old_tcpack_num = ntoh32_ua(&old_tcp_hdr[TCP_ACK_NUM_OFFSET]);
911 if (IS_TCPSEQ_GT(new_tcp_ack_num, old_tcpack_num)) {
912 /* New packet has higher TCP ACK number, so it replaces the old
913 * packet */
914 if (new_ip_hdr_len == old_ip_hdr_len &&
915 new_tcp_hdr_len == old_tcp_hdr_len) {
916 ASSERT(memcmp(new_ether_hdr, old_ether_hdr, ETHER_HDR_LEN) ==
917 0);
918 bcopy(new_ip_hdr, old_ip_hdr, new_ip_total_len);
919 PKTFREE(dhdp->osh, pkt, FALSE);
920 DHD_TRACE(("%s %d: TCP ACK replace %u -> %u\n", __FUNCTION__,
921 __LINE__, old_tcpack_num, new_tcp_ack_num));
922 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
923 tack_tbl.cnt[0x2]++;
924 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
925 ret = TRUE;
926 } else {
927 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
928 tack_tbl.cnt[0x6]++;
929 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
930 DHD_TRACE(("%s %d: lenth mismatch %d != %d || %d != %d"
931 " ACK %u -> %u\n",
932 __FUNCTION__, __LINE__, new_ip_hdr_len,
933 old_ip_hdr_len, new_tcp_hdr_len, old_tcp_hdr_len,
934 old_tcpack_num, new_tcp_ack_num));
935 }
936 } else if (new_tcp_ack_num == old_tcpack_num) {
937 set_dotxinrx = TRUE;
938 /* TCPACK retransmission */
939 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
940 tack_tbl.cnt[0x3]++;
941 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
942 } else {
943 DHD_TRACE(("%s %d: ACK number reverse old %u(0x%p) new %u(0x%p)\n",
944 __FUNCTION__, __LINE__, old_tcpack_num, oldpkt,
945 new_tcp_ack_num, pkt));
946 }
947 dhd_os_tcpackunlock(dhdp, flags);
948 goto exit;
949 }
950
951 if (i == tcpack_sup_mod->tcpack_info_cnt && i < TCPACK_INFO_MAXNUM) {
952 /* No TCPACK packet with the same IP addr and TCP port is found
953 * in tcp_ack_info_tbl. So add this packet to the table.
954 */
955 DHD_TRACE(("%s %d: Add pkt 0x%p(ether_hdr 0x%p) to tbl[%d]\n",
956 __FUNCTION__, __LINE__, pkt, new_ether_hdr,
957 tcpack_sup_mod->tcpack_info_cnt));
958
959 tcpack_info_tbl[tcpack_sup_mod->tcpack_info_cnt].pkt_in_q = pkt;
960 tcpack_info_tbl[tcpack_sup_mod->tcpack_info_cnt].pkt_ether_hdr =
961 new_ether_hdr;
962 tcpack_sup_mod->tcpack_info_cnt++;
963 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
964 tack_tbl.cnt[1]++;
965 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
966 } else {
967 ASSERT(i == tcpack_sup_mod->tcpack_info_cnt);
968 DHD_TRACE(
969 ("%s %d: No empty tcp ack info tbl\n", __FUNCTION__, __LINE__));
970 }
971 dhd_os_tcpackunlock(dhdp, flags);
972
973 exit:
974 /* Unless TCPACK_SUP_DELAYTX, dotxinrx is alwasy TRUE, so no need to set
975 * here */
976 if (dhdp->tcpack_sup_mode == TCPACK_SUP_DELAYTX && set_dotxinrx) {
977 dhd_bus_set_dotxinrx(dhdp->bus, TRUE);
978 }
979
980 return ret;
981 }
982
dhd_tcpdata_info_get(dhd_pub_t * dhdp,void * pkt)983 bool dhd_tcpdata_info_get(dhd_pub_t *dhdp, void *pkt)
984 {
985 uint8 *ether_hdr; /* Ethernet header of the new packet */
986 uint16 ether_type; /* Ethernet type of the new packet */
987 uint8 *ip_hdr; /* IP header of the new packet */
988 uint8 *tcp_hdr; /* TCP header of the new packet */
989 uint32 ip_hdr_len; /* IP header length of the new packet */
990 uint32 cur_framelen;
991 uint16 ip_total_len; /* Total length of IP packet for the new packet */
992 uint32 tcp_hdr_len; /* TCP header length of the new packet */
993 uint32 tcp_seq_num; /* TCP sequence number of the new packet */
994 uint16 tcp_data_len; /* TCP DATA length that excludes IP and TCP headers */
995 uint32
996 end_tcp_seq_num; /* TCP seq number of the last byte in the new packet */
997 tcpack_sup_module_t *tcpack_sup_mod;
998 tcpdata_info_t *tcpdata_info = NULL;
999 tdata_psh_info_t *tdata_psh_info;
1000
1001 int i;
1002 bool ret = FALSE;
1003 unsigned long flags;
1004
1005 if (dhdp->tcpack_sup_mode != TCPACK_SUP_DELAYTX) {
1006 goto exit;
1007 }
1008
1009 ether_hdr = PKTDATA(dhdp->osh, pkt);
1010 cur_framelen = PKTLEN(dhdp->osh, pkt);
1011
1012 ether_type = ether_hdr[0xC] << 0x8 | ether_hdr[0xD];
1013
1014 if (ether_type != ETHER_TYPE_IP) {
1015 DHD_TRACE(("%s %d: Not a IP packet 0x%x\n", __FUNCTION__, __LINE__,
1016 ether_type));
1017 goto exit;
1018 }
1019
1020 DHD_TRACE(("%s %d: IP pkt! 0x%x\n", __FUNCTION__, __LINE__, ether_type));
1021
1022 ip_hdr = ether_hdr + ETHER_HDR_LEN;
1023 cur_framelen -= ETHER_HDR_LEN;
1024
1025 ASSERT(cur_framelen >= IPV4_MIN_HEADER_LEN);
1026
1027 ip_hdr_len = IPV4_HLEN(ip_hdr);
1028 if (IP_VER(ip_hdr) != IP_VER_4 || IPV4_PROT(ip_hdr) != IP_PROT_TCP) {
1029 DHD_TRACE(("%s %d: Not IPv4 nor TCP! ip ver %d, prot %d\n",
1030 __FUNCTION__, __LINE__, IP_VER(ip_hdr), IPV4_PROT(ip_hdr)));
1031 goto exit;
1032 }
1033
1034 tcp_hdr = ip_hdr + ip_hdr_len;
1035 cur_framelen -= ip_hdr_len;
1036
1037 ASSERT(cur_framelen >= TCP_MIN_HEADER_LEN);
1038
1039 DHD_TRACE(("%s %d: TCP pkt!\n", __FUNCTION__, __LINE__));
1040
1041 ip_total_len = ntoh16_ua(&ip_hdr[IPV4_PKTLEN_OFFSET]);
1042 tcp_hdr_len = 0x4 * TCP_HDRLEN(tcp_hdr[TCP_HLEN_OFFSET]);
1043 /* This packet is mere TCP ACK, so do nothing */
1044 if (ip_total_len == ip_hdr_len + tcp_hdr_len) {
1045 DHD_TRACE(("%s %d: Do nothing for no data TCP ACK\n", __FUNCTION__,
1046 __LINE__));
1047 goto exit;
1048 }
1049
1050 ASSERT(ip_total_len > ip_hdr_len + tcp_hdr_len);
1051
1052 if ((tcp_hdr[TCP_FLAGS_OFFSET] & TCP_FLAG_PSH) == 0) {
1053 DHD_TRACE(("%s %d: Not interested TCP DATA packet\n", __FUNCTION__,
1054 __LINE__));
1055 goto exit;
1056 }
1057
1058 DHD_TRACE(("%s %d: TCP DATA with nonzero DATA length"
1059 " IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR
1060 " TCP port %d %d, flag 0x%x\n",
1061 __FUNCTION__, __LINE__,
1062 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
1063 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
1064 ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
1065 ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET]),
1066 tcp_hdr[TCP_FLAGS_OFFSET]));
1067
1068 flags = dhd_os_tcpacklock(dhdp);
1069 tcpack_sup_mod = dhdp->tcpack_sup_module;
1070
1071 if (!tcpack_sup_mod) {
1072 DHD_ERROR(
1073 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
1074 ret = BCME_ERROR;
1075 dhd_os_tcpackunlock(dhdp, flags);
1076 goto exit;
1077 }
1078
1079 /* Look for tcpdata_info that has the same ip src/dst addrs and tcp src/dst
1080 * ports */
1081 i = 0;
1082 while (i < tcpack_sup_mod->tcpdata_info_cnt) {
1083 tcpdata_info_t *tdata_info_tmp = &tcpack_sup_mod->tcpdata_info_tbl[i];
1084 uint32 now_in_ms = OSL_SYSUPTIME();
1085 DHD_TRACE(("%s %d: data info[%d], IP addr " IPV4_ADDR_STR
1086 " " IPV4_ADDR_STR " TCP port %d %d\n",
1087 __FUNCTION__, __LINE__, i,
1088 IPV4_ADDR_TO_STR(ntoh32_ua(tdata_info_tmp->ip_addr.src)),
1089 IPV4_ADDR_TO_STR(ntoh32_ua(tdata_info_tmp->ip_addr.dst)),
1090 ntoh16_ua(tdata_info_tmp->tcp_port.src),
1091 ntoh16_ua(tdata_info_tmp->tcp_port.dst)));
1092
1093 /* If both IP address and TCP port number match, we found it so break.
1094 * Note that src/dst addr fields in ip header are contiguous being 8
1095 * bytes in total. Also, src/dst port fields in TCP header are
1096 * contiguous being 4 bytes in total.
1097 */
1098 if (memcmp(&ip_hdr[IPV4_SRC_IP_OFFSET],
1099 (void *)&tdata_info_tmp->ip_addr, IPV4_ADDR_LEN * 0x2) == 0 &&
1100 memcmp(&tcp_hdr[TCP_SRC_PORT_OFFSET],
1101 (void *)&tdata_info_tmp->tcp_port, TCP_PORT_LEN * 0x2) == 0) {
1102 tcpdata_info = tdata_info_tmp;
1103 tcpdata_info->last_used_time = now_in_ms;
1104 break;
1105 }
1106
1107 if (now_in_ms - tdata_info_tmp->last_used_time > TCPDATA_INFO_TIMEOUT) {
1108 tdata_psh_info_t *tdata_psh_info_tmp;
1109 tcpdata_info_t *last_tdata_info;
1110
1111 while ((tdata_psh_info_tmp = tdata_info_tmp->tdata_psh_info_head)) {
1112 tdata_info_tmp->tdata_psh_info_head = tdata_psh_info_tmp->next;
1113 tdata_psh_info_tmp->next = NULL;
1114 DHD_TRACE(("%s %d: Clean tdata_psh_info(end_seq %u)!\n",
1115 __FUNCTION__, __LINE__,
1116 tdata_psh_info_tmp->end_seq));
1117 _tdata_psh_info_pool_enq(tcpack_sup_mod, tdata_psh_info_tmp);
1118 }
1119 #ifdef DHDTCPACK_SUP_DBG
1120 DHD_ERROR(("%s %d: PSH INFO ENQ %d\n", __FUNCTION__, __LINE__,
1121 tcpack_sup_mod->psh_info_enq_num));
1122 #endif /* DHDTCPACK_SUP_DBG */
1123 tcpack_sup_mod->tcpdata_info_cnt--;
1124 ASSERT(tcpack_sup_mod->tcpdata_info_cnt >= 0);
1125
1126 last_tdata_info =
1127 &tcpack_sup_mod
1128 ->tcpdata_info_tbl[tcpack_sup_mod->tcpdata_info_cnt];
1129 if (i < tcpack_sup_mod->tcpdata_info_cnt) {
1130 ASSERT(last_tdata_info != tdata_info_tmp);
1131 bcopy(last_tdata_info, tdata_info_tmp, sizeof(tcpdata_info_t));
1132 }
1133 bzero(last_tdata_info, sizeof(tcpdata_info_t));
1134 DHD_INFO(
1135 ("%s %d: tcpdata_info(idx %d) is aged out. ttl cnt is now %d\n",
1136 __FUNCTION__, __LINE__, i, tcpack_sup_mod->tcpdata_info_cnt));
1137 /* Don't increase "i" here, so that the prev last tcpdata_info is
1138 * checked */
1139 } else {
1140 i++;
1141 }
1142 }
1143
1144 tcp_seq_num = ntoh32_ua(&tcp_hdr[TCP_SEQ_NUM_OFFSET]);
1145 tcp_data_len = ip_total_len - ip_hdr_len - tcp_hdr_len;
1146 end_tcp_seq_num = tcp_seq_num + tcp_data_len;
1147
1148 if (tcpdata_info == NULL) {
1149 ASSERT(i == tcpack_sup_mod->tcpdata_info_cnt);
1150 if (i >= TCPDATA_INFO_MAXNUM) {
1151 DHD_TRACE((
1152 "%s %d: tcp_data_info_tbl FULL! %d %d"
1153 " IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR " TCP port %d %d\n",
1154 __FUNCTION__, __LINE__, i, tcpack_sup_mod->tcpdata_info_cnt,
1155 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
1156 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
1157 ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
1158 ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET])));
1159 dhd_os_tcpackunlock(dhdp, flags);
1160 goto exit;
1161 }
1162 tcpdata_info = &tcpack_sup_mod->tcpdata_info_tbl[i];
1163
1164 /* No TCP flow with the same IP addr and TCP port is found
1165 * in tcp_data_info_tbl. So add this flow to the table.
1166 */
1167 DHD_INFO(("%s %d: Add data info to tbl[%d]: IP addr " IPV4_ADDR_STR
1168 " " IPV4_ADDR_STR " TCP port %d %d\n",
1169 __FUNCTION__, __LINE__, tcpack_sup_mod->tcpdata_info_cnt,
1170 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_SRC_IP_OFFSET])),
1171 IPV4_ADDR_TO_STR(ntoh32_ua(&ip_hdr[IPV4_DEST_IP_OFFSET])),
1172 ntoh16_ua(&tcp_hdr[TCP_SRC_PORT_OFFSET]),
1173 ntoh16_ua(&tcp_hdr[TCP_DEST_PORT_OFFSET])));
1174 /* Note that src/dst addr fields in ip header are contiguous being 8
1175 * bytes in total. Also, src/dst port fields in TCP header are
1176 * contiguous being 4 bytes in total.
1177 */
1178 bcopy(&ip_hdr[IPV4_SRC_IP_OFFSET], (void *)&tcpdata_info->ip_addr,
1179 IPV4_ADDR_LEN * 0x2);
1180 bcopy(&tcp_hdr[TCP_SRC_PORT_OFFSET], (void *)&tcpdata_info->tcp_port,
1181 TCP_PORT_LEN * 0x2);
1182
1183 tcpdata_info->last_used_time = OSL_SYSUPTIME();
1184 tcpack_sup_mod->tcpdata_info_cnt++;
1185 }
1186
1187 ASSERT(tcpdata_info != NULL);
1188
1189 tdata_psh_info = _tdata_psh_info_pool_deq(tcpack_sup_mod);
1190 #ifdef DHDTCPACK_SUP_DBG
1191 DHD_TRACE(("%s %d: PSH INFO ENQ %d\n", __FUNCTION__, __LINE__,
1192 tcpack_sup_mod->psh_info_enq_num));
1193 #endif /* DHDTCPACK_SUP_DBG */
1194
1195 if (tdata_psh_info == NULL) {
1196 DHD_ERROR(
1197 ("%s %d: No more free tdata_psh_info!!\n", __FUNCTION__, __LINE__));
1198 ret = BCME_ERROR;
1199 dhd_os_tcpackunlock(dhdp, flags);
1200 goto exit;
1201 }
1202 tdata_psh_info->end_seq = end_tcp_seq_num;
1203
1204 #if defined(DEBUG_COUNTER) && defined(DHDTCPACK_SUP_DBG)
1205 tack_tbl.cnt[0x4]++;
1206 #endif /* DEBUG_COUNTER && DHDTCPACK_SUP_DBG */
1207
1208 DHD_TRACE(("%s %d: TCP PSH DATA recvd! end seq %u\n", __FUNCTION__,
1209 __LINE__, tdata_psh_info->end_seq));
1210
1211 ASSERT(tdata_psh_info->next == NULL);
1212
1213 if (tcpdata_info->tdata_psh_info_head == NULL) {
1214 tcpdata_info->tdata_psh_info_head = tdata_psh_info;
1215 } else {
1216 ASSERT(tcpdata_info->tdata_psh_info_tail);
1217 tcpdata_info->tdata_psh_info_tail->next = tdata_psh_info;
1218 }
1219 tcpdata_info->tdata_psh_info_tail = tdata_psh_info;
1220
1221 dhd_os_tcpackunlock(dhdp, flags);
1222
1223 exit:
1224 return ret;
1225 }
1226
dhd_tcpack_hold(dhd_pub_t * dhdp,void * pkt,int ifidx)1227 bool dhd_tcpack_hold(dhd_pub_t *dhdp, void *pkt, int ifidx)
1228 {
1229 uint8 *new_ether_hdr; /* Ethernet header of the new packet */
1230 uint16 new_ether_type; /* Ethernet type of the new packet */
1231 uint8 *new_ip_hdr; /* IP header of the new packet */
1232 uint8 *new_tcp_hdr; /* TCP header of the new packet */
1233 uint32 new_ip_hdr_len; /* IP header length of the new packet */
1234 uint32 cur_framelen;
1235 uint32 new_tcp_ack_num; /* TCP acknowledge number of the new packet */
1236 uint16 new_ip_total_len; /* Total length of IP packet for the new packet */
1237 uint32 new_tcp_hdr_len; /* TCP header length of the new packet */
1238 tcpack_sup_module_t *tcpack_sup_mod;
1239 tcpack_info_t *tcpack_info_tbl;
1240 int i, free_slot = TCPACK_INFO_MAXNUM;
1241 bool hold = FALSE;
1242 unsigned long flags;
1243
1244 if (dhdp->tcpack_sup_mode != TCPACK_SUP_HOLD) {
1245 goto exit;
1246 }
1247
1248 if (dhdp->tcpack_sup_ratio == 1) {
1249 goto exit;
1250 }
1251
1252 new_ether_hdr = PKTDATA(dhdp->osh, pkt);
1253 cur_framelen = PKTLEN(dhdp->osh, pkt);
1254 if (cur_framelen < TCPACKSZMIN || cur_framelen > TCPACKSZMAX) {
1255 DHD_TRACE(("%s %d: Too short or long length %d to be TCP ACK\n",
1256 __FUNCTION__, __LINE__, cur_framelen));
1257 goto exit;
1258 }
1259
1260 new_ether_type = new_ether_hdr[0xC] << 0x8 | new_ether_hdr[0xD];
1261
1262 if (new_ether_type != ETHER_TYPE_IP) {
1263 DHD_TRACE(("%s %d: Not a IP packet 0x%x\n", __FUNCTION__, __LINE__,
1264 new_ether_type));
1265 goto exit;
1266 }
1267
1268 DHD_TRACE(
1269 ("%s %d: IP pkt! 0x%x\n", __FUNCTION__, __LINE__, new_ether_type));
1270
1271 new_ip_hdr = new_ether_hdr + ETHER_HDR_LEN;
1272 cur_framelen -= ETHER_HDR_LEN;
1273
1274 ASSERT(cur_framelen >= IPV4_MIN_HEADER_LEN);
1275
1276 new_ip_hdr_len = IPV4_HLEN(new_ip_hdr);
1277 if (IP_VER(new_ip_hdr) != IP_VER_4 ||
1278 IPV4_PROT(new_ip_hdr) != IP_PROT_TCP) {
1279 DHD_TRACE(("%s %d: Not IPv4 nor TCP! ip ver %d, prot %d\n",
1280 __FUNCTION__, __LINE__, IP_VER(new_ip_hdr),
1281 IPV4_PROT(new_ip_hdr)));
1282 goto exit;
1283 }
1284
1285 new_tcp_hdr = new_ip_hdr + new_ip_hdr_len;
1286 cur_framelen -= new_ip_hdr_len;
1287
1288 ASSERT(cur_framelen >= TCP_MIN_HEADER_LEN);
1289
1290 DHD_TRACE(("%s %d: TCP pkt!\n", __FUNCTION__, __LINE__));
1291
1292 /* is it an ack ? Allow only ACK flag, not to suppress others. */
1293 if (new_tcp_hdr[TCP_FLAGS_OFFSET] != TCP_FLAG_ACK) {
1294 DHD_TRACE(("%s %d: Do not touch TCP flag 0x%x\n", __FUNCTION__,
1295 __LINE__, new_tcp_hdr[TCP_FLAGS_OFFSET]));
1296 goto exit;
1297 }
1298
1299 new_ip_total_len = ntoh16_ua(&new_ip_hdr[IPV4_PKTLEN_OFFSET]);
1300 new_tcp_hdr_len = 0x4 * TCP_HDRLEN(new_tcp_hdr[TCP_HLEN_OFFSET]);
1301 /* This packet has TCP data, so just send */
1302 if (new_ip_total_len > new_ip_hdr_len + new_tcp_hdr_len) {
1303 DHD_TRACE(("%s %d: Do nothing for TCP DATA\n", __FUNCTION__, __LINE__));
1304 goto exit;
1305 }
1306
1307 ASSERT(new_ip_total_len == new_ip_hdr_len + new_tcp_hdr_len);
1308
1309 new_tcp_ack_num = ntoh32_ua(&new_tcp_hdr[TCP_ACK_NUM_OFFSET]);
1310
1311 DHD_TRACE(("%s %d: TCP ACK with zero DATA length"
1312 " IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR " TCP port %d %d\n",
1313 __FUNCTION__, __LINE__,
1314 IPV4_ADDR_TO_STR(ntoh32_ua(&new_ip_hdr[IPV4_SRC_IP_OFFSET])),
1315 IPV4_ADDR_TO_STR(ntoh32_ua(&new_ip_hdr[IPV4_DEST_IP_OFFSET])),
1316 ntoh16_ua(&new_tcp_hdr[TCP_SRC_PORT_OFFSET]),
1317 ntoh16_ua(&new_tcp_hdr[TCP_DEST_PORT_OFFSET])));
1318
1319 /* Look for tcp_ack_info that has the same ip src/dst addrs and tcp src/dst
1320 * ports */
1321 flags = dhd_os_tcpacklock(dhdp);
1322
1323 tcpack_sup_mod = dhdp->tcpack_sup_module;
1324 tcpack_info_tbl = tcpack_sup_mod->tcpack_info_tbl;
1325
1326 if (!tcpack_sup_mod) {
1327 DHD_ERROR(
1328 ("%s %d: tcpack suppress module NULL!!\n", __FUNCTION__, __LINE__));
1329 dhd_os_tcpackunlock(dhdp, flags);
1330 goto exit;
1331 }
1332
1333 hold = TRUE;
1334
1335 for (i = 0; i < TCPACK_INFO_MAXNUM; i++) {
1336 void *oldpkt; /* TCPACK packet that is already in txq or DelayQ */
1337 uint8 *old_ether_hdr, *old_ip_hdr, *old_tcp_hdr;
1338 uint32 old_ip_hdr_len;
1339 uint32 old_tcpack_num; /* TCP ACK number of old TCPACK packet in Q */
1340
1341 if ((oldpkt = tcpack_info_tbl[i].pkt_in_q) == NULL) {
1342 if (free_slot == TCPACK_INFO_MAXNUM) {
1343 free_slot = i;
1344 }
1345 continue;
1346 }
1347
1348 if (PKTDATA(dhdp->osh, oldpkt) == NULL) {
1349 DHD_ERROR(("%s %d: oldpkt data NULL!! cur idx %d\n", __FUNCTION__,
1350 __LINE__, i));
1351 hold = FALSE;
1352 dhd_os_tcpackunlock(dhdp, flags);
1353 goto exit;
1354 }
1355
1356 old_ether_hdr = tcpack_info_tbl[i].pkt_ether_hdr;
1357 old_ip_hdr = old_ether_hdr + ETHER_HDR_LEN;
1358 old_ip_hdr_len = IPV4_HLEN(old_ip_hdr);
1359 old_tcp_hdr = old_ip_hdr + old_ip_hdr_len;
1360
1361 DHD_TRACE(
1362 ("%s %d: oldpkt %p[%d], IP addr " IPV4_ADDR_STR " " IPV4_ADDR_STR
1363 " TCP port %d %d\n",
1364 __FUNCTION__, __LINE__, oldpkt, i,
1365 IPV4_ADDR_TO_STR(ntoh32_ua(&old_ip_hdr[IPV4_SRC_IP_OFFSET])),
1366 IPV4_ADDR_TO_STR(ntoh32_ua(&old_ip_hdr[IPV4_DEST_IP_OFFSET])),
1367 ntoh16_ua(&old_tcp_hdr[TCP_SRC_PORT_OFFSET]),
1368 ntoh16_ua(&old_tcp_hdr[TCP_DEST_PORT_OFFSET])));
1369
1370 /* If either of IP address or TCP port number does not match, skip. */
1371 if (memcmp(&new_ip_hdr[IPV4_SRC_IP_OFFSET],
1372 &old_ip_hdr[IPV4_SRC_IP_OFFSET], IPV4_ADDR_LEN * 0x2) ||
1373 memcmp(&new_tcp_hdr[TCP_SRC_PORT_OFFSET],
1374 &old_tcp_hdr[TCP_SRC_PORT_OFFSET], TCP_PORT_LEN * 0x2)) {
1375 continue;
1376 }
1377
1378 old_tcpack_num = ntoh32_ua(&old_tcp_hdr[TCP_ACK_NUM_OFFSET]);
1379 if (IS_TCPSEQ_GE(new_tcp_ack_num, old_tcpack_num)) {
1380 tcpack_info_tbl[i].supp_cnt++;
1381 if (tcpack_info_tbl[i].supp_cnt >= dhdp->tcpack_sup_ratio) {
1382 tcpack_info_tbl[i].pkt_in_q = NULL;
1383 tcpack_info_tbl[i].pkt_ether_hdr = NULL;
1384 tcpack_info_tbl[i].ifidx = 0;
1385 tcpack_info_tbl[i].supp_cnt = 0;
1386 hold = FALSE;
1387 } else {
1388 tcpack_info_tbl[i].pkt_in_q = pkt;
1389 tcpack_info_tbl[i].pkt_ether_hdr = new_ether_hdr;
1390 tcpack_info_tbl[i].ifidx = ifidx;
1391 }
1392 PKTFREE(dhdp->osh, oldpkt, TRUE);
1393 } else {
1394 PKTFREE(dhdp->osh, pkt, TRUE);
1395 }
1396 dhd_os_tcpackunlock(dhdp, flags);
1397
1398 if (!hold) {
1399 #ifndef TCPACK_SUPPRESS_HOLD_HRT
1400 del_timer_sync(&tcpack_info_tbl[i].timer);
1401 #else
1402 hrtimer_cancel(&tcpack_sup_mod->tcpack_info_tbl[i].timer.timer);
1403 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
1404 }
1405 goto exit;
1406 }
1407
1408 if (free_slot < TCPACK_INFO_MAXNUM) {
1409 /* No TCPACK packet with the same IP addr and TCP port is found
1410 * in tcp_ack_info_tbl. So add this packet to the table.
1411 */
1412 DHD_TRACE(("%s %d: Add pkt 0x%p(ether_hdr 0x%p) to tbl[%d]\n",
1413 __FUNCTION__, __LINE__, pkt, new_ether_hdr, free_slot));
1414
1415 tcpack_info_tbl[free_slot].pkt_in_q = pkt;
1416 tcpack_info_tbl[free_slot].pkt_ether_hdr = new_ether_hdr;
1417 tcpack_info_tbl[free_slot].ifidx = ifidx;
1418 tcpack_info_tbl[free_slot].supp_cnt = 1;
1419 #ifndef TCPACK_SUPPRESS_HOLD_HRT
1420 mod_timer(&tcpack_sup_mod->tcpack_info_tbl[free_slot].timer,
1421 jiffies + msecs_to_jiffies(dhdp->tcpack_sup_delay));
1422 #else
1423 tasklet_hrtimer_start(&tcpack_sup_mod->tcpack_info_tbl[free_slot].timer,
1424 ktime_set(0, dhdp->tcpack_sup_delay * 0xF4240),
1425 HRTIMER_MODE_REL);
1426 #endif /* TCPACK_SUPPRESS_HOLD_HRT */
1427 tcpack_sup_mod->tcpack_info_cnt++;
1428 } else {
1429 DHD_TRACE(
1430 ("%s %d: No empty tcp ack info tbl\n", __FUNCTION__, __LINE__));
1431 }
1432 dhd_os_tcpackunlock(dhdp, flags);
1433
1434 exit:
1435 return hold;
1436 }
1437 #endif /* DHDTCPACK_SUPPRESS */
1438
1439 #ifdef DHDTCPSYNC_FLOOD_BLK
dhd_tcpdata_get_flag(dhd_pub_t * dhdp,void * pkt)1440 tcp_hdr_flag_t dhd_tcpdata_get_flag(dhd_pub_t *dhdp, void *pkt)
1441 {
1442 uint8 *ether_hdr; /* Ethernet header of the new packet */
1443 uint16 ether_type; /* Ethernet type of the new packet */
1444 uint8 *ip_hdr; /* IP header of the new packet */
1445 uint8 *tcp_hdr; /* TCP header of the new packet */
1446 uint32 ip_hdr_len; /* IP header length of the new packet */
1447 uint32 cur_framelen;
1448 uint8 flags;
1449
1450 ether_hdr = PKTDATA(dhdp->osh, pkt);
1451 cur_framelen = PKTLEN(dhdp->osh, pkt);
1452
1453 ether_type = ether_hdr[0xC] << 0x8 | ether_hdr[0xD];
1454
1455 if (ether_type != ETHER_TYPE_IP) {
1456 DHD_TRACE(("%s %d: Not a IP packet 0x%x\n", __FUNCTION__, __LINE__,
1457 ether_type));
1458 return FLAG_OTHERS;
1459 }
1460
1461 ip_hdr = ether_hdr + ETHER_HDR_LEN;
1462 cur_framelen -= ETHER_HDR_LEN;
1463
1464 if (cur_framelen < IPV4_MIN_HEADER_LEN) {
1465 return FLAG_OTHERS;
1466 }
1467
1468 ip_hdr_len = IPV4_HLEN(ip_hdr);
1469 if (IP_VER(ip_hdr) != IP_VER_4 || IPV4_PROT(ip_hdr) != IP_PROT_TCP) {
1470 DHD_TRACE(("%s %d: Not IPv4 nor TCP! ip ver %d, prot %d\n",
1471 __FUNCTION__, __LINE__, IP_VER(ip_hdr), IPV4_PROT(ip_hdr)));
1472 return FLAG_OTHERS;
1473 }
1474
1475 tcp_hdr = ip_hdr + ip_hdr_len;
1476
1477 flags = (uint8)tcp_hdr[TCP_FLAGS_OFFSET];
1478
1479 if (flags & TCP_FLAG_SYN) {
1480 if (flags & TCP_FLAG_ACK) {
1481 return FLAG_SYNCACK;
1482 }
1483 return FLAG_SYNC;
1484 }
1485 return FLAG_OTHERS;
1486 }
1487 #endif /* DHDTCPSYNC_FLOOD_BLK */
1488