2 * Copyright (c) 2002-2009 Sam Leffler, Errno Consulting
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #include <sys/cdefs.h>
27 __FBSDID("$FreeBSD$");
31 #ifdef IEEE80211_SUPPORT_SUPERG
33 #include <sys/param.h>
34 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/endian.h>
39 #include <sys/socket.h>
42 #include <net/if_var.h>
43 #include <net/if_llc.h>
44 #include <net/if_media.h>
46 #include <net/ethernet.h>
48 #include <net80211/ieee80211_var.h>
49 #include <net80211/ieee80211_input.h>
50 #include <net80211/ieee80211_phy.h>
51 #include <net80211/ieee80211_superg.h>
54 * Atheros fast-frame encapsulation format.
56 * 802.2 + FFHDR + HPAD + 802.3 + 802.2 + 1500 + SPAD + 802.3 + 802.2 + 1500:
57 * 8 + 4 + 4 + 14 + 8 + 1500 + 6 + 14 + 8 + 1500
60 /* fast frame header is 32-bits */
61 #define ATH_FF_PROTO 0x0000003f /* protocol */
62 #define ATH_FF_PROTO_S 0
63 #define ATH_FF_FTYPE 0x000000c0 /* frame type */
64 #define ATH_FF_FTYPE_S 6
65 #define ATH_FF_HLEN32 0x00000300 /* optional hdr length */
66 #define ATH_FF_HLEN32_S 8
67 #define ATH_FF_SEQNUM 0x001ffc00 /* sequence number */
68 #define ATH_FF_SEQNUM_S 10
69 #define ATH_FF_OFFSET 0xffe00000 /* offset to 2nd payload */
70 #define ATH_FF_OFFSET_S 21
72 #define ATH_FF_MAX_HDR_PAD 4
73 #define ATH_FF_MAX_SEP_PAD 6
74 #define ATH_FF_MAX_HDR 30
76 #define ATH_FF_PROTO_L2TUNNEL 0 /* L2 tunnel protocol */
77 #define ATH_FF_ETH_TYPE 0x88bd /* Ether type for encapsulated frames */
78 #define ATH_FF_SNAP_ORGCODE_0 0x00
79 #define ATH_FF_SNAP_ORGCODE_1 0x03
80 #define ATH_FF_SNAP_ORGCODE_2 0x7f
82 #define ATH_FF_TXQMIN 2 /* min txq depth for staging */
83 #define ATH_FF_TXQMAX 50 /* maximum # of queued frames allowed */
84 #define ATH_FF_STAGEMAX 5 /* max waiting period for staged frame*/
86 #define ETHER_HEADER_COPY(dst, src) \
87 memcpy(dst, src, sizeof(struct ether_header))
89 static int ieee80211_ffppsmin
= 2; /* pps threshold for ff aggregation */
90 SYSCTL_INT(_net_wlan
, OID_AUTO
, ffppsmin
, CTLFLAG_RW
,
91 &ieee80211_ffppsmin
, 0, "min packet rate before fast-frame staging");
92 static int ieee80211_ffagemax
= -1; /* max time frames held on stage q */
93 SYSCTL_PROC(_net_wlan
, OID_AUTO
, ffagemax
, CTLTYPE_INT
| CTLFLAG_RW
,
94 &ieee80211_ffagemax
, 0, ieee80211_sysctl_msecs_ticks
, "I",
95 "max hold time for fast-frame staging (ms)");
98 ieee80211_superg_attach(struct ieee80211com
*ic
)
100 struct ieee80211_superg
*sg
;
102 sg
= (struct ieee80211_superg
*) IEEE80211_MALLOC(
103 sizeof(struct ieee80211_superg
), M_80211_VAP
,
104 IEEE80211_M_NOWAIT
| IEEE80211_M_ZERO
);
106 printf("%s: cannot allocate SuperG state block\n",
113 * Default to not being so aggressive for FF/AMSDU
114 * aging, otherwise we may hold a frame around
115 * for way too long before we expire it out.
117 ieee80211_ffagemax
= msecs_to_ticks(2);
121 ieee80211_superg_detach(struct ieee80211com
*ic
)
123 if (ic
->ic_superg
!= NULL
) {
124 IEEE80211_FREE(ic
->ic_superg
, M_80211_VAP
);
125 ic
->ic_superg
= NULL
;
130 ieee80211_superg_vattach(struct ieee80211vap
*vap
)
132 struct ieee80211com
*ic
= vap
->iv_ic
;
134 if (ic
->ic_superg
== NULL
) /* NB: can't do fast-frames w/o state */
135 vap
->iv_caps
&= ~IEEE80211_C_FF
;
136 if (vap
->iv_caps
& IEEE80211_C_FF
)
137 vap
->iv_flags
|= IEEE80211_F_FF
;
138 /* NB: we only implement sta mode */
139 if (vap
->iv_opmode
== IEEE80211_M_STA
&&
140 (vap
->iv_caps
& IEEE80211_C_TURBOP
))
141 vap
->iv_flags
|= IEEE80211_F_TURBOP
;
145 ieee80211_superg_vdetach(struct ieee80211vap
*vap
)
149 #define ATH_OUI_BYTES 0x00, 0x03, 0x7f
151 * Add a WME information element to a frame.
154 ieee80211_add_ath(uint8_t *frm
, uint8_t caps
, ieee80211_keyix defkeyix
)
156 static const struct ieee80211_ath_ie info
= {
157 .ath_id
= IEEE80211_ELEMID_VENDOR
,
158 .ath_len
= sizeof(struct ieee80211_ath_ie
) - 2,
159 .ath_oui
= { ATH_OUI_BYTES
},
160 .ath_oui_type
= ATH_OUI_TYPE
,
161 .ath_oui_subtype
= ATH_OUI_SUBTYPE
,
162 .ath_version
= ATH_OUI_VERSION
,
164 struct ieee80211_ath_ie
*ath
= (struct ieee80211_ath_ie
*) frm
;
166 memcpy(frm
, &info
, sizeof(info
));
167 ath
->ath_capability
= caps
;
168 if (defkeyix
!= IEEE80211_KEYIX_NONE
) {
169 ath
->ath_defkeyix
[0] = (defkeyix
& 0xff);
170 ath
->ath_defkeyix
[1] = ((defkeyix
>> 8) & 0xff);
172 ath
->ath_defkeyix
[0] = 0xff;
173 ath
->ath_defkeyix
[1] = 0x7f;
175 return frm
+ sizeof(info
);
180 ieee80211_add_athcaps(uint8_t *frm
, const struct ieee80211_node
*bss
)
182 const struct ieee80211vap
*vap
= bss
->ni_vap
;
184 return ieee80211_add_ath(frm
,
185 vap
->iv_flags
& IEEE80211_F_ATHEROS
,
186 ((vap
->iv_flags
& IEEE80211_F_WPA
) == 0 &&
187 bss
->ni_authmode
!= IEEE80211_AUTH_8021X
) ?
188 vap
->iv_def_txkey
: IEEE80211_KEYIX_NONE
);
192 ieee80211_parse_ath(struct ieee80211_node
*ni
, uint8_t *ie
)
194 const struct ieee80211_ath_ie
*ath
=
195 (const struct ieee80211_ath_ie
*) ie
;
197 ni
->ni_ath_flags
= ath
->ath_capability
;
198 ni
->ni_ath_defkeyix
= le16dec(&ath
->ath_defkeyix
);
202 ieee80211_parse_athparams(struct ieee80211_node
*ni
, uint8_t *frm
,
203 const struct ieee80211_frame
*wh
)
205 struct ieee80211vap
*vap
= ni
->ni_vap
;
206 const struct ieee80211_ath_ie
*ath
;
211 if (len
< sizeof(struct ieee80211_ath_ie
)-2) {
212 IEEE80211_DISCARD_IE(vap
,
213 IEEE80211_MSG_ELEMID
| IEEE80211_MSG_SUPERG
,
214 wh
, "Atheros", "too short, len %u", len
);
217 ath
= (const struct ieee80211_ath_ie
*)frm
;
218 capschanged
= (ni
->ni_ath_flags
!= ath
->ath_capability
);
219 defkeyix
= le16dec(ath
->ath_defkeyix
);
220 if (capschanged
|| defkeyix
!= ni
->ni_ath_defkeyix
) {
221 ni
->ni_ath_flags
= ath
->ath_capability
;
222 ni
->ni_ath_defkeyix
= defkeyix
;
223 IEEE80211_NOTE(vap
, IEEE80211_MSG_SUPERG
, ni
,
224 "ath ie change: new caps 0x%x defkeyix 0x%x",
225 ni
->ni_ath_flags
, ni
->ni_ath_defkeyix
);
227 if (IEEE80211_ATH_CAP(vap
, ni
, ATHEROS_CAP_TURBO_PRIME
)) {
228 uint16_t curflags
, newflags
;
231 * Check for turbo mode switch. Calculate flags
232 * for the new mode and effect the switch.
234 newflags
= curflags
= vap
->iv_ic
->ic_bsschan
->ic_flags
;
235 /* NB: BOOST is not in ic_flags, so get it from the ie */
236 if (ath
->ath_capability
& ATHEROS_CAP_BOOST
)
237 newflags
|= IEEE80211_CHAN_TURBO
;
239 newflags
&= ~IEEE80211_CHAN_TURBO
;
240 if (newflags
!= curflags
)
241 ieee80211_dturbo_switch(vap
, newflags
);
247 * Decap the encapsulated frame pair and dispatch the first
248 * for delivery. The second frame is returned for delivery
249 * via the normal path.
252 ieee80211_ff_decap(struct ieee80211_node
*ni
, struct mbuf
*m
)
254 #define FF_LLC_SIZE (sizeof(struct ether_header) + sizeof(struct llc))
255 #define MS(x,f) (((x) & f) >> f##_S)
256 struct ieee80211vap
*vap
= ni
->ni_vap
;
262 /* NB: we assume caller does this check for us */
263 KASSERT(IEEE80211_ATH_CAP(vap
, ni
, IEEE80211_NODE_FF
),
264 ("ff not negotiated"));
266 * Check for fast-frame tunnel encapsulation.
268 if (m
->m_pkthdr
.len
< 3*FF_LLC_SIZE
)
270 if (m
->m_len
< FF_LLC_SIZE
&&
271 (m
= m_pullup(m
, FF_LLC_SIZE
)) == NULL
) {
272 IEEE80211_DISCARD_MAC(vap
, IEEE80211_MSG_ANY
,
273 ni
->ni_macaddr
, "fast-frame",
274 "%s", "m_pullup(llc) failed");
275 vap
->iv_stats
.is_rx_tooshort
++;
278 llc
= (struct llc
*)(mtod(m
, uint8_t *) +
279 sizeof(struct ether_header
));
280 if (llc
->llc_snap
.ether_type
!= htons(ATH_FF_ETH_TYPE
))
282 m_adj(m
, FF_LLC_SIZE
);
283 m_copydata(m
, 0, sizeof(uint32_t), (caddr_t
) &ath
);
284 if (MS(ath
, ATH_FF_PROTO
) != ATH_FF_PROTO_L2TUNNEL
) {
285 IEEE80211_DISCARD_MAC(vap
, IEEE80211_MSG_ANY
,
286 ni
->ni_macaddr
, "fast-frame",
287 "unsupport tunnel protocol, header 0x%x", ath
);
288 vap
->iv_stats
.is_ff_badhdr
++;
292 /* NB: skip header and alignment padding */
293 m_adj(m
, roundup(sizeof(uint32_t) - 2, 4) + 2);
295 vap
->iv_stats
.is_ff_decap
++;
298 * Decap the first frame, bust it apart from the
299 * second and deliver; then decap the second frame
300 * and return it to the caller for normal delivery.
302 m
= ieee80211_decap1(m
, &framelen
);
304 IEEE80211_DISCARD_MAC(vap
, IEEE80211_MSG_ANY
,
305 ni
->ni_macaddr
, "fast-frame", "%s", "first decap failed");
306 vap
->iv_stats
.is_ff_tooshort
++;
309 n
= m_split(m
, framelen
, M_NOWAIT
);
311 IEEE80211_DISCARD_MAC(vap
, IEEE80211_MSG_ANY
,
312 ni
->ni_macaddr
, "fast-frame",
313 "%s", "unable to split encapsulated frames");
314 vap
->iv_stats
.is_ff_split
++;
315 m_freem(m
); /* NB: must reclaim */
318 /* XXX not right for WDS */
319 vap
->iv_deliver_data(vap
, ni
, m
); /* 1st of pair */
322 * Decap second frame.
324 m_adj(n
, roundup2(framelen
, 4) - framelen
); /* padding */
325 n
= ieee80211_decap1(n
, &framelen
);
327 IEEE80211_DISCARD_MAC(vap
, IEEE80211_MSG_ANY
,
328 ni
->ni_macaddr
, "fast-frame", "%s", "second decap failed");
329 vap
->iv_stats
.is_ff_tooshort
++;
331 /* XXX verify framelen against mbuf contents */
332 return n
; /* 2nd delivered by caller */
338 * Fast frame encapsulation. There must be two packets
339 * chained with m_nextpkt. We do header adjustment for
340 * each, add the tunnel encapsulation, and then concatenate
341 * the mbuf chains to form a single frame for transmission.
344 ieee80211_ff_encap(struct ieee80211vap
*vap
, struct mbuf
*m1
, int hdrspace
,
345 struct ieee80211_key
*key
)
348 struct ether_header eh1
, eh2
;
355 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
356 "%s: only one frame\n", __func__
);
359 m1
->m_nextpkt
= NULL
;
362 * Adjust to include 802.11 header requirement.
364 KASSERT(m1
->m_len
>= sizeof(eh1
), ("no ethernet header!"));
365 ETHER_HEADER_COPY(&eh1
, mtod(m1
, caddr_t
));
366 m1
= ieee80211_mbuf_adjust(vap
, hdrspace
, key
, m1
);
368 printf("%s: failed initial mbuf_adjust\n", __func__
);
369 /* NB: ieee80211_mbuf_adjust handles msgs+statistics */
375 * Copy second frame's Ethernet header out of line
376 * and adjust for possible padding in case there isn't room
377 * at the end of first frame.
379 KASSERT(m2
->m_len
>= sizeof(eh2
), ("no ethernet header!"));
380 ETHER_HEADER_COPY(&eh2
, mtod(m2
, caddr_t
));
381 m2
= ieee80211_mbuf_adjust(vap
, 4, NULL
, m2
);
383 /* NB: ieee80211_mbuf_adjust handles msgs+statistics */
384 printf("%s: failed second \n", __func__
);
389 * Now do tunnel encapsulation. First, each
390 * frame gets a standard encapsulation.
392 m1
= ieee80211_ff_encap1(vap
, m1
, &eh1
);
395 m2
= ieee80211_ff_encap1(vap
, m2
, &eh2
);
400 * Pad leading frame to a 4-byte boundary. If there
401 * is space at the end of the first frame, put it
402 * there; otherwise prepend to the front of the second
403 * frame. We know doing the second will always work
404 * because we reserve space above. We prefer appending
405 * as this typically has better DMA alignment properties.
407 for (m
= m1
; m
->m_next
!= NULL
; m
= m
->m_next
)
409 pad
= roundup2(m1
->m_pkthdr
.len
, 4) - m1
->m_pkthdr
.len
;
411 if (M_TRAILINGSPACE(m
) < pad
) { /* prepend to second */
414 m2
->m_pkthdr
.len
+= pad
;
415 } else { /* append to first */
417 m1
->m_pkthdr
.len
+= pad
;
422 * A-MSDU's are just appended; the "I'm A-MSDU!" bit is in the
425 * XXX optimize by prepending together
427 m
->m_next
= m2
; /* NB: last mbuf from above */
428 m1
->m_pkthdr
.len
+= m2
->m_pkthdr
.len
;
429 M_PREPEND(m1
, sizeof(uint32_t)+2, M_NOWAIT
);
430 if (m1
== NULL
) { /* XXX cannot happen */
431 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
432 "%s: no space for tunnel header\n", __func__
);
433 vap
->iv_stats
.is_tx_nobuf
++;
436 memset(mtod(m1
, void *), 0, sizeof(uint32_t)+2);
438 M_PREPEND(m1
, sizeof(struct llc
), M_NOWAIT
);
439 if (m1
== NULL
) { /* XXX cannot happen */
440 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
441 "%s: no space for llc header\n", __func__
);
442 vap
->iv_stats
.is_tx_nobuf
++;
445 llc
= mtod(m1
, struct llc
*);
446 llc
->llc_dsap
= llc
->llc_ssap
= LLC_SNAP_LSAP
;
447 llc
->llc_control
= LLC_UI
;
448 llc
->llc_snap
.org_code
[0] = ATH_FF_SNAP_ORGCODE_0
;
449 llc
->llc_snap
.org_code
[1] = ATH_FF_SNAP_ORGCODE_1
;
450 llc
->llc_snap
.org_code
[2] = ATH_FF_SNAP_ORGCODE_2
;
451 llc
->llc_snap
.ether_type
= htons(ATH_FF_ETH_TYPE
);
453 vap
->iv_stats
.is_ff_encap
++;
457 vap
->iv_stats
.is_ff_encapfail
++;
466 * A-MSDU encapsulation.
468 * This assumes just two frames for now, since we're borrowing the
469 * same queuing code and infrastructure as fast-frames.
471 * There must be two packets chained with m_nextpkt.
472 * We do header adjustment for each, and then concatenate the mbuf chains
473 * to form a single frame for transmission.
476 ieee80211_amsdu_encap(struct ieee80211vap
*vap
, struct mbuf
*m1
, int hdrspace
,
477 struct ieee80211_key
*key
)
480 struct ether_header eh1
, eh2
;
486 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
487 "%s: only one frame\n", __func__
);
490 m1
->m_nextpkt
= NULL
;
493 * Include A-MSDU header in adjusting header layout.
495 KASSERT(m1
->m_len
>= sizeof(eh1
), ("no ethernet header!"));
496 ETHER_HEADER_COPY(&eh1
, mtod(m1
, caddr_t
));
497 m1
= ieee80211_mbuf_adjust(vap
,
498 hdrspace
+ sizeof(struct llc
) + sizeof(uint32_t) +
499 sizeof(struct ether_header
),
502 /* NB: ieee80211_mbuf_adjust handles msgs+statistics */
508 * Copy second frame's Ethernet header out of line
509 * and adjust for encapsulation headers. Note that
510 * we make room for padding in case there isn't room
511 * at the end of first frame.
513 KASSERT(m2
->m_len
>= sizeof(eh2
), ("no ethernet header!"));
514 ETHER_HEADER_COPY(&eh2
, mtod(m2
, caddr_t
));
515 m2
= ieee80211_mbuf_adjust(vap
, 4, NULL
, m2
);
517 /* NB: ieee80211_mbuf_adjust handles msgs+statistics */
522 * Now do tunnel encapsulation. First, each
523 * frame gets a standard encapsulation.
525 m1
= ieee80211_ff_encap1(vap
, m1
, &eh1
);
528 m2
= ieee80211_ff_encap1(vap
, m2
, &eh2
);
533 * Pad leading frame to a 4-byte boundary. If there
534 * is space at the end of the first frame, put it
535 * there; otherwise prepend to the front of the second
536 * frame. We know doing the second will always work
537 * because we reserve space above. We prefer appending
538 * as this typically has better DMA alignment properties.
540 for (m
= m1
; m
->m_next
!= NULL
; m
= m
->m_next
)
542 pad
= roundup2(m1
->m_pkthdr
.len
, 4) - m1
->m_pkthdr
.len
;
544 if (M_TRAILINGSPACE(m
) < pad
) { /* prepend to second */
547 m2
->m_pkthdr
.len
+= pad
;
548 } else { /* append to first */
550 m1
->m_pkthdr
.len
+= pad
;
555 * Now, stick 'em together.
557 m
->m_next
= m2
; /* NB: last mbuf from above */
558 m1
->m_pkthdr
.len
+= m2
->m_pkthdr
.len
;
560 vap
->iv_stats
.is_amsdu_encap
++;
564 vap
->iv_stats
.is_amsdu_encapfail
++;
574 ff_transmit(struct ieee80211_node
*ni
, struct mbuf
*m
)
576 struct ieee80211vap
*vap
= ni
->ni_vap
;
577 struct ieee80211com
*ic
= ni
->ni_ic
;
580 IEEE80211_TX_LOCK_ASSERT(vap
->iv_ic
);
583 m
= ieee80211_encap(vap
, ni
, m
);
585 struct ifnet
*ifp
= vap
->iv_ifp
;
587 error
= ieee80211_parent_xmitpkt(ic
, m
);
589 if_inc_counter(ifp
, IFCOUNTER_OPACKETS
, 1);
591 ieee80211_free_node(ni
);
595 * Flush frames to device; note we re-use the linked list
596 * the frames were stored on and use the sentinel (unchanged)
597 * which may be non-NULL.
600 ff_flush(struct mbuf
*head
, struct mbuf
*last
)
602 struct mbuf
*m
, *next
;
603 struct ieee80211_node
*ni
;
604 struct ieee80211vap
*vap
;
606 for (m
= head
; m
!= last
; m
= next
) {
610 ni
= (struct ieee80211_node
*) m
->m_pkthdr
.rcvif
;
613 IEEE80211_NOTE(vap
, IEEE80211_MSG_SUPERG
, ni
,
614 "%s: flush frame, age %u", __func__
, M_AGE_GET(m
));
615 vap
->iv_stats
.is_ff_flush
++;
622 * Age frames on the staging queue.
624 * This is called without the comlock held, but it does all its work
625 * behind the comlock. Because of this, it's possible that the
626 * staging queue will be serviced between the function which called
627 * it and now; thus simply checking that the queue has work in it
630 * See PR kern/174283 for more details.
633 ieee80211_ff_age(struct ieee80211com
*ic
, struct ieee80211_stageq
*sq
,
636 struct mbuf
*m
, *head
;
637 struct ieee80211_node
*ni
;
640 KASSERT(sq
->head
!= NULL
, ("stageq empty"));
645 while ((m
= sq
->head
) != NULL
&& M_AGE_GET(m
) < quanta
) {
646 int tid
= WME_AC_TO_TID(M_WME_GETAC(m
));
648 /* clear staging ref to frame */
649 ni
= (struct ieee80211_node
*) m
->m_pkthdr
.rcvif
;
650 KASSERT(ni
->ni_tx_superg
[tid
] == m
, ("staging queue empty"));
651 ni
->ni_tx_superg
[tid
] = NULL
;
653 sq
->head
= m
->m_nextpkt
;
659 M_AGE_SUB(m
, quanta
);
660 IEEE80211_UNLOCK(ic
);
662 IEEE80211_TX_LOCK(ic
);
664 IEEE80211_TX_UNLOCK(ic
);
668 stageq_add(struct ieee80211com
*ic
, struct ieee80211_stageq
*sq
, struct mbuf
*m
)
670 int age
= ieee80211_ffagemax
;
672 IEEE80211_LOCK_ASSERT(ic
);
674 if (sq
->tail
!= NULL
) {
675 sq
->tail
->m_nextpkt
= m
;
676 age
-= M_AGE_GET(sq
->head
);
679 KASSERT(age
>= 0, ("age %d", age
));
687 stageq_remove(struct ieee80211com
*ic
, struct ieee80211_stageq
*sq
, struct mbuf
*mstaged
)
689 struct mbuf
*m
, *mprev
;
691 IEEE80211_LOCK_ASSERT(ic
);
694 for (m
= sq
->head
; m
!= NULL
; m
= m
->m_nextpkt
) {
697 sq
->head
= m
->m_nextpkt
;
699 mprev
->m_nextpkt
= m
->m_nextpkt
;
707 printf("%s: packet not found\n", __func__
);
711 ff_approx_txtime(struct ieee80211_node
*ni
,
712 const struct mbuf
*m1
, const struct mbuf
*m2
)
714 struct ieee80211com
*ic
= ni
->ni_ic
;
715 struct ieee80211vap
*vap
= ni
->ni_vap
;
720 * Approximate the frame length to be transmitted. A swag to add
721 * the following maximal values to the skb payload:
722 * - 32: 802.11 encap + CRC
723 * - 24: encryption overhead (if wep bit)
724 * - 4 + 6: fast-frame header and padding
725 * - 16: 2 LLC FF tunnel headers
726 * - 14: 1 802.3 FF tunnel header (mbuf already accounts for 2nd)
728 framelen
= m1
->m_pkthdr
.len
+ 32 +
729 ATH_FF_MAX_HDR_PAD
+ ATH_FF_MAX_SEP_PAD
+ ATH_FF_MAX_HDR
;
730 if (vap
->iv_flags
& IEEE80211_F_PRIVACY
)
733 framelen
+= m2
->m_pkthdr
.len
;
736 * For now, we assume non-shortgi, 20MHz, just because I want to
737 * at least test 802.11n.
739 if (ni
->ni_txrate
& IEEE80211_RATE_MCS
)
740 frame_time
= ieee80211_compute_duration_ht(framelen
,
742 IEEE80211_HT_RC_2_STREAMS(ni
->ni_txrate
),
746 frame_time
= ieee80211_compute_duration(ic
->ic_rt
, framelen
,
752 * Check if the supplied frame can be partnered with an existing
753 * or pending frame. Return a reference to any frame that should be
754 * sent on return; otherwise return NULL.
757 ieee80211_ff_check(struct ieee80211_node
*ni
, struct mbuf
*m
)
759 struct ieee80211vap
*vap
= ni
->ni_vap
;
760 struct ieee80211com
*ic
= ni
->ni_ic
;
761 struct ieee80211_superg
*sg
= ic
->ic_superg
;
762 const int pri
= M_WME_GETAC(m
);
763 struct ieee80211_stageq
*sq
;
764 struct ieee80211_tx_ampdu
*tap
;
765 struct mbuf
*mstaged
;
766 uint32_t txtime
, limit
;
768 IEEE80211_TX_UNLOCK_ASSERT(ic
);
771 * Check if the supplied frame can be aggregated.
773 * NB: we allow EAPOL frames to be aggregated with other ucast traffic.
774 * Do 802.1x EAPOL frames proceed in the clear? Then they couldn't
775 * be aggregated with other types of frames when encryption is on?
778 tap
= &ni
->ni_tx_ampdu
[WME_AC_TO_TID(pri
)];
779 mstaged
= ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)];
780 /* XXX NOTE: reusing packet counter state from A-MPDU */
782 * XXX NOTE: this means we're double-counting; it should just
783 * be done in ieee80211_output.c once for both superg and A-MPDU.
785 ieee80211_txampdu_count_packet(tap
);
788 * When not in station mode never aggregate a multicast
789 * frame; this insures, for example, that a combined frame
790 * does not require multiple encryption keys.
792 if (vap
->iv_opmode
!= IEEE80211_M_STA
&&
793 ETHER_IS_MULTICAST(mtod(m
, struct ether_header
*)->ether_dhost
)) {
794 /* XXX flush staged frame? */
795 IEEE80211_UNLOCK(ic
);
799 * If there is no frame to combine with and the pps is
800 * too low; then do not attempt to aggregate this frame.
802 if (mstaged
== NULL
&&
803 ieee80211_txampdu_getpps(tap
) < ieee80211_ffppsmin
) {
804 IEEE80211_UNLOCK(ic
);
807 sq
= &sg
->ff_stageq
[pri
];
809 * Check the txop limit to insure the aggregate fits.
811 limit
= IEEE80211_TXOP_TO_US(
812 ic
->ic_wme
.wme_chanParams
.cap_wmeParams
[pri
].wmep_txopLimit
);
814 (txtime
= ff_approx_txtime(ni
, m
, mstaged
)) > limit
) {
816 * Aggregate too long, return to the caller for direct
817 * transmission. In addition, flush any pending frame
818 * before sending this one.
820 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
821 "%s: txtime %u exceeds txop limit %u\n",
822 __func__
, txtime
, limit
);
824 ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)] = NULL
;
826 stageq_remove(ic
, sq
, mstaged
);
827 IEEE80211_UNLOCK(ic
);
829 if (mstaged
!= NULL
) {
830 IEEE80211_TX_LOCK(ic
);
831 IEEE80211_NOTE(vap
, IEEE80211_MSG_SUPERG
, ni
,
832 "%s: flush staged frame", __func__
);
834 ff_transmit(ni
, mstaged
);
835 IEEE80211_TX_UNLOCK(ic
);
837 return m
; /* NB: original frame */
840 * An aggregation candidate. If there's a frame to partner
841 * with then combine and return for processing. Otherwise
842 * save this frame and wait for a partner to show up (or
843 * the frame to be flushed). Note that staged frames also
844 * hold their node reference.
846 if (mstaged
!= NULL
) {
847 ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)] = NULL
;
848 stageq_remove(ic
, sq
, mstaged
);
849 IEEE80211_UNLOCK(ic
);
851 IEEE80211_NOTE(vap
, IEEE80211_MSG_SUPERG
, ni
,
852 "%s: aggregate fast-frame", __func__
);
854 * Release the node reference; we only need
855 * the one already in mstaged.
857 KASSERT(mstaged
->m_pkthdr
.rcvif
== (void *)ni
,
858 ("rcvif %p ni %p", mstaged
->m_pkthdr
.rcvif
, ni
));
859 ieee80211_free_node(ni
);
862 mstaged
->m_nextpkt
= m
;
863 mstaged
->m_flags
|= M_FF
; /* NB: mark for encap work */
865 KASSERT(ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)]== NULL
,
866 ("ni_tx_superg[]: %p",
867 ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)]));
868 ni
->ni_tx_superg
[WME_AC_TO_TID(pri
)] = m
;
870 stageq_add(ic
, sq
, m
);
871 IEEE80211_UNLOCK(ic
);
873 IEEE80211_NOTE(vap
, IEEE80211_MSG_SUPERG
, ni
,
874 "%s: stage frame, %u queued", __func__
, sq
->depth
);
875 /* NB: mstaged is NULL */
881 ieee80211_amsdu_check(struct ieee80211_node
*ni
, struct mbuf
*m
)
884 * XXX TODO: actually enforce the node support
885 * and HTCAP requirements for the maximum A-MSDU
889 /* First: software A-MSDU transmit? */
890 if (! ieee80211_amsdu_tx_ok(ni
))
893 /* Next - EAPOL? Nope, don't aggregate; we don't QoS encap them */
894 if (m
->m_flags
& (M_EAPOL
| M_MCAST
| M_BCAST
))
897 /* Next - needs to be a data frame, non-broadcast, etc */
898 if (ETHER_IS_MULTICAST(mtod(m
, struct ether_header
*)->ether_dhost
))
901 return (ieee80211_ff_check(ni
, m
));
905 ieee80211_ff_node_init(struct ieee80211_node
*ni
)
908 * Clean FF state on re-associate. This handles the case
909 * where a station leaves w/o notifying us and then returns
910 * before node is reaped for inactivity.
912 ieee80211_ff_node_cleanup(ni
);
916 ieee80211_ff_node_cleanup(struct ieee80211_node
*ni
)
918 struct ieee80211com
*ic
= ni
->ni_ic
;
919 struct ieee80211_superg
*sg
= ic
->ic_superg
;
920 struct mbuf
*m
, *next_m
, *head
;
925 for (tid
= 0; tid
< WME_NUM_TID
; tid
++) {
926 int ac
= TID_TO_WME_AC(tid
);
928 * XXX Initialise the packet counter.
930 * This may be double-work for 11n stations;
931 * but without it we never setup things.
933 ieee80211_txampdu_init_pps(&ni
->ni_tx_ampdu
[tid
]);
934 m
= ni
->ni_tx_superg
[tid
];
936 ni
->ni_tx_superg
[tid
] = NULL
;
937 stageq_remove(ic
, &sg
->ff_stageq
[ac
], m
);
942 IEEE80211_UNLOCK(ic
);
945 * Free mbufs, taking care to not dereference the mbuf after
946 * we free it (hence grabbing m_nextpkt before we free it.)
950 next_m
= m
->m_nextpkt
;
952 ieee80211_free_node(ni
);
958 * Switch between turbo and non-turbo operating modes.
959 * Use the specified channel flags to locate the new
960 * channel, update 802.11 state, and then call back into
961 * the driver to effect the change.
964 ieee80211_dturbo_switch(struct ieee80211vap
*vap
, int newflags
)
966 struct ieee80211com
*ic
= vap
->iv_ic
;
967 struct ieee80211_channel
*chan
;
969 chan
= ieee80211_find_channel(ic
, ic
->ic_bsschan
->ic_freq
, newflags
);
970 if (chan
== NULL
) { /* XXX should not happen */
971 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
972 "%s: no channel with freq %u flags 0x%x\n",
973 __func__
, ic
->ic_bsschan
->ic_freq
, newflags
);
977 IEEE80211_DPRINTF(vap
, IEEE80211_MSG_SUPERG
,
978 "%s: %s -> %s (freq %u flags 0x%x)\n", __func__
,
979 ieee80211_phymode_name
[ieee80211_chan2mode(ic
->ic_bsschan
)],
980 ieee80211_phymode_name
[ieee80211_chan2mode(chan
)],
981 chan
->ic_freq
, chan
->ic_flags
);
983 ic
->ic_bsschan
= chan
;
984 ic
->ic_prevchan
= ic
->ic_curchan
;
985 ic
->ic_curchan
= chan
;
986 ic
->ic_rt
= ieee80211_get_ratetable(chan
);
987 ic
->ic_set_channel(ic
);
988 ieee80211_radiotap_chan_change(ic
);
989 /* NB: do not need to reset ERP state 'cuz we're in sta mode */
993 * Return the current ``state'' of an Atheros capbility.
994 * If associated in station mode report the negotiated
995 * setting. Otherwise report the current setting.
998 getathcap(struct ieee80211vap
*vap
, int cap
)
1000 if (vap
->iv_opmode
== IEEE80211_M_STA
&&
1001 vap
->iv_state
== IEEE80211_S_RUN
)
1002 return IEEE80211_ATH_CAP(vap
, vap
->iv_bss
, cap
) != 0;
1004 return (vap
->iv_flags
& cap
) != 0;
1008 superg_ioctl_get80211(struct ieee80211vap
*vap
, struct ieee80211req
*ireq
)
1010 switch (ireq
->i_type
) {
1011 case IEEE80211_IOC_FF
:
1012 ireq
->i_val
= getathcap(vap
, IEEE80211_F_FF
);
1014 case IEEE80211_IOC_TURBOP
:
1015 ireq
->i_val
= getathcap(vap
, IEEE80211_F_TURBOP
);
1022 IEEE80211_IOCTL_GET(superg
, superg_ioctl_get80211
);
1025 superg_ioctl_set80211(struct ieee80211vap
*vap
, struct ieee80211req
*ireq
)
1027 switch (ireq
->i_type
) {
1028 case IEEE80211_IOC_FF
:
1030 if ((vap
->iv_caps
& IEEE80211_C_FF
) == 0)
1032 vap
->iv_flags
|= IEEE80211_F_FF
;
1034 vap
->iv_flags
&= ~IEEE80211_F_FF
;
1036 case IEEE80211_IOC_TURBOP
:
1038 if ((vap
->iv_caps
& IEEE80211_C_TURBOP
) == 0)
1040 vap
->iv_flags
|= IEEE80211_F_TURBOP
;
1042 vap
->iv_flags
&= ~IEEE80211_F_TURBOP
;
1048 IEEE80211_IOCTL_SET(superg
, superg_ioctl_set80211
);
1050 #endif /* IEEE80211_SUPPORT_SUPERG */