15 #include <linux/kernel.h>
16 #include <linux/slab.h>
19 #include <linux/bitmap.h>
21 #include <linux/export.h>
26 #include <asm/unaligned.h>
58 sband = local->
hw.wiphy->bands[info->
band];
125 if (tx->
sdata->vif.bss_conf.basic_rates &
BIT(i))
128 switch (sband->
band) {
165 tx->
sdata->vif.bss_conf.use_short_preamble);
174 tx->
sdata->vif.bss_conf.use_short_preamble);
196 if (local->
hw.conf.dynamic_ps_timeout <= 0)
214 ifmgd = &tx->
sdata->u.mgd;
295 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
297 "dropped data frame to not associated station %pM\n",
322 int total = 0, purged = 0;
354 total += skb_queue_len(&sta->
ps_tx_buf[ac]);
366 ps_dbg_hw(&local->
hw,
"PS buffers full - purged %d frames\n", purged);
405 purge_old_ps_buffers(tx->
local);
409 "BC TX buffer full - dropping the oldest frame\n");
412 tx->
local->total_ps_buffered++;
422 if (!ieee80211_is_mgmt(fc))
449 int ac = skb_get_queue_mapping(tx->
skb);
460 ps_dbg(sta->
sdata,
"STA %pM aid %d: PS buffer for AC %d\n",
461 sta->
sta.addr, sta->
sta.aid, ac);
463 purge_old_ps_buffers(tx->
local);
467 "STA %pM TX buffer for AC %d full - dropping oldest frame\n",
471 tx->
local->total_ps_buffered++;
492 "STA %pM in PS mode, but polling/in SP -> send frame\n",
506 return ieee80211_tx_h_unicast_ps_buf(tx);
508 return ieee80211_tx_h_multicast_ps_buf(tx);
517 tx->
sdata->control_port_no_encrypt))
535 is_multicast_ether_addr(hdr->
addr1) &&
536 ieee80211_is_robust_mgmt_frame(hdr) &&
539 else if (is_multicast_ether_addr(hdr->
addr1) &&
542 else if (!is_multicast_ether_addr(hdr->
addr1) &&
547 else if (!tx->
sdata->drop_unencrypted)
549 else if (tx->
skb->protocol == tx->
sdata->control_port_protocol)
551 else if (ieee80211_is_robust_mgmt_frame(hdr) &&
556 !ieee80211_is_robust_mgmt_frame(hdr))
564 bool skip_hw =
false;
566 tx->
key->tx_rx_count++;
569 switch (tx->
key->conf.cipher) {
582 skip_hw = (tx->
key->conf.flags &
595 if (!skip_hw && tx->
key &&
612 bool inval =
false,
rts =
false, short_preamble =
false;
616 memset(&txrc, 0,
sizeof(txrc));
618 sband = tx->
local->hw.wiphy->bands[info->
band];
621 tx->
local->hw.wiphy->frag_threshold);
624 txrc.hw = &tx->
local->hw;
626 txrc.bss_conf = &tx->
sdata->vif.bss_conf;
628 txrc.reported_rate.idx = -1;
629 txrc.rate_idx_mask = tx->
sdata->rc_rateidx_mask[info->
band];
630 if (txrc.rate_idx_mask == (1 << sband->
n_bitrates) - 1)
631 txrc.max_rate_idx = -1;
633 txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
634 memcpy(txrc.rate_idx_mcs_mask,
635 tx->
sdata->rc_rateidx_mcs_mask[info->
band],
636 sizeof(txrc.rate_idx_mcs_mask));
642 if (len > tx->
local->hw.wiphy->rts_threshold) {
643 txrc.rts =
rts =
true;
652 if (tx->
sdata->vif.bss_conf.use_short_preamble &&
655 txrc.short_preamble = short_preamble =
true;
665 !rate_usable_index_exists(sband, &tx->
sta->sta),
666 "%s: Dropped data frame as no usable bitrate found while "
667 "scanning and associated. Target station: "
668 "%pM on %d GHz band\n",
682 if (txrc.reported_rate.idx < 0) {
683 txrc.reported_rate = info->
control.rates[0];
685 tx->
sta->last_tx_rate = txrc.reported_rate;
687 tx->
sta->last_tx_rate = txrc.reported_rate;
690 info->
control.rates[0].count = 1;
694 info->
control.rates[0].count = 1;
696 if (is_multicast_ether_addr(hdr->
addr1)) {
716 if (!(tx->
sdata->vif.bss_conf.basic_rates &
BIT(i)))
719 if (sband->
bitrates[i].bitrate > rate->bitrate)
722 if (sband->
bitrates[baserate].bitrate <
727 info->
control.rts_cts_rate_idx = baserate;
740 if (info->
control.rates[i].idx < 0) {
769 if (short_preamble &&
775 if (!
rts && tx->
sdata->vif.bss_conf.use_cts_prot &&
820 tx->
sdata->sequence_number += 0x10;
834 qc = ieee80211_get_qos_ctl(hdr);
853 int per_fragm = frag_threshold - hdrlen -
FCS_LEN;
854 int pos = hdrlen + per_fragm;
855 int rem = skb->
len - hdrlen - per_fragm;
863 int fraglen = per_fragm;
875 __skb_queue_tail(&tx->
skbs, tmp);
880 memcpy(tmp->cb, skb->cb,
sizeof(tmp->cb));
882 info = IEEE80211_SKB_CB(tmp);
889 skb_copy_queue_mapping(tmp, skb);
901 skb->
len = hdrlen + per_fragm;
911 int frag_threshold = tx->
local->hw.wiphy->frag_threshold;
916 __skb_queue_tail(&tx->
skbs, skb);
922 if (tx->
local->ops->set_frag_threshold)
936 if (
WARN_ON(skb->
len + FCS_LEN <= frag_threshold))
947 if (ieee80211_fragment(tx, skb, hdrlen, frag_threshold))
953 skb_queue_walk(&tx->
skbs, skb) {
957 hdr = (
void *)skb->
data;
958 info = IEEE80211_SKB_CB(skb);
960 if (!skb_queue_is_last(&tx->
skbs, skb)) {
966 info->
control.rates[1].idx = -1;
967 info->
control.rates[2].idx = -1;
968 info->
control.rates[3].idx = -1;
990 tx->
sta->tx_packets++;
991 skb_queue_walk(&tx->
skbs, skb) {
992 tx->
sta->tx_fragments++;
993 tx->
sta->tx_bytes += skb->
len;
1005 switch (tx->
key->conf.cipher) {
1030 skb_queue_walk(&tx->
skbs, skb) {
1031 hdr = (
void *) skb->
data;
1034 if (!skb_queue_is_last(&tx->
skbs, skb)) {
1036 next_len = next->
len;
1039 group_addr = is_multicast_ether_addr(hdr->
addr1);
1042 ieee80211_duration(tx, skb, group_addr, next_len);
1056 bool queued =
false;
1057 bool reset_agg_timer =
false;
1062 reset_agg_timer =
true;
1069 spin_lock(&tx->
sta->lock);
1088 tid_tx = rcu_dereference_protected_tid_tx(tx->
sta, tid);
1094 reset_agg_timer =
true;
1099 __skb_queue_tail(&tid_tx->
pending, skb);
1101 purge_skb = __skb_dequeue(&tid_tx->
pending);
1103 spin_unlock(&tx->
sta->lock);
1110 if (reset_agg_timer && tid_tx->
timeout)
1130 memset(tx, 0,
sizeof(*tx));
1134 __skb_queue_head_init(&tx->
skbs);
1147 if (!tx->
sta && sdata->
dev->ieee80211_ptr->use_4addr)
1150 tx->
sdata->control_port_protocol == tx->
skb->protocol) {
1162 qc = ieee80211_get_qos_ctl(hdr);
1169 queued = ieee80211_tx_prep_agg(tx, skb, info,
1177 if (is_multicast_ether_addr(hdr->
addr1)) {
1185 skb->
len + FCS_LEN <= local->
hw.wiphy->frag_threshold ||
1208 unsigned long flags;
1210 skb_queue_walk_safe(skbs, skb, tmp) {
1214 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1216 __skb_unlink(skb, skbs);
1224 (!txpending && !skb_queue_empty(&local->
pending[q]))) {
1231 skb_queue_splice_init(skbs, &local->
pending[q]);
1233 skb_queue_splice_tail_init(skbs,
1245 __skb_unlink(skb, skbs);
1257 struct sta_info *sta,
bool txpending)
1267 if (
WARN_ON(skb_queue_empty(skbs)))
1270 skb = skb_peek(skbs);
1272 info = IEEE80211_SKB_CB(skb);
1273 sdata = vif_to_sdata(info->
control.vif);
1282 switch (sdata->
vif.type) {
1288 vif->
hw_queue[skb_get_queue_mapping(skb)];
1304 result = ieee80211_tx_frags(local, vif, pubsta, skbs,
1307 ieee80211_tpt_led_trig_tx(local, fc, led_len);
1324 #define CALL_TXH(txh) \
1327 if (res != TX_CONTINUE) \
1331 CALL_TXH(ieee80211_tx_h_dynamic_ps);
1332 CALL_TXH(ieee80211_tx_h_check_assoc);
1334 CALL_TXH(ieee80211_tx_h_check_control_port_protocol);
1335 CALL_TXH(ieee80211_tx_h_select_key);
1337 CALL_TXH(ieee80211_tx_h_rate_ctrl);
1340 __skb_queue_tail(&tx->
skbs, tx->
skb);
1352 CALL_TXH(ieee80211_tx_h_calculate_duration);
1375 struct sk_buff *skb,
bool txpending)
1393 res_prepare = ieee80211_tx_prepare(sdata, &tx, skb);
1402 info->
band = local->
hw.conf.channel->band;
1408 sdata->
vif.hw_queue[skb_get_queue_mapping(skb)];
1410 if (!invoke_tx_handlers(&tx))
1411 result = __ieee80211_tx(local, &tx.
skbs, led_len,
1422 int head_need,
bool may_encrypt)
1429 tail_need -= skb_tailroom(skb);
1430 tail_need =
max_t(
int, tail_need, 0);
1433 if (skb_cloned(skb))
1435 else if (head_need || tail_need)
1442 "failed to reallocate TX buffer\n");
1464 headroom -= skb_headroom(skb);
1465 headroom =
max_t(
int, 0, headroom);
1467 if (ieee80211_skb_resize(sdata, skb, headroom, may_encrypt)) {
1476 if (ieee80211_vif_is_mesh(&sdata->
vif) &&
1478 !is_multicast_ether_addr(hdr->
addr1) &&
1486 ieee80211_tx(sdata, skb,
false);
1490 static bool ieee80211_parse_tx_radiotap(
struct sk_buff *skb)
1516 switch (iterator.this_arg_index) {
1532 if (skb->
len < (iterator._max_length + FCS_LEN))
1544 txflags = get_unaligned_le16(iterator.this_arg);
1568 skb_pull(skb, iterator._max_length);
1615 len_rthdr = ieee80211_get_radiotap_len(skb->
data);
1627 skb_set_mac_header(skb, len_rthdr);
1632 skb_set_network_header(skb, len_rthdr);
1633 skb_set_transport_header(skb, len_rthdr);
1635 if (skb->
len < len_rthdr + 2)
1641 if (skb->
len < len_rthdr + hdrlen)
1657 memset(info, 0,
sizeof(*info));
1663 if (!ieee80211_parse_tx_radiotap(skb))
1676 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1679 if (!ieee80211_sdata_running(tmp_sdata))
1685 if (ether_addr_equal(tmp_sdata->
vif.addr, hdr->
addr2)) {
1728 const u8 *encaps_data;
1729 int encaps_len, skip_header_bytes;
1732 bool wme_sta =
false, authorized =
false, tdls_auth =
false;
1733 bool tdls_direct =
false;
1743 ethertype = (skb->
data[12] << 8) | skb->
data[13];
1746 switch (sdata->
vif.type) {
1782 #ifdef CONFIG_MAC80211_MESH
1784 if (!sdata->
u.
mesh.mshcfg.dot11MeshTTL) {
1786 sdata->
u.
mesh.mshstats.dropped_frames_ttl++;
1790 if (!is_multicast_ether_addr(skb->
data)) {
1803 !(mppath && !ether_addr_equal(mppath->
mpp, skb->
data))) {
1816 const u8 *mesh_da = skb->
data;
1819 mesh_da = mppath->
mpp;
1821 mesh_da = mpath->dst;
1825 mesh_da, sdata->
vif.addr);
1826 if (is_multicast_ether_addr(mesh_da))
1846 bool tdls_peer =
false;
1851 authorized = test_sta_flag(sta,
1854 tdls_peer = test_sta_flag(sta,
1856 tdls_auth = test_sta_flag(sta,
1866 tdls_direct = tdls_peer && (tdls_auth ||
1881 }
else if (sdata->
u.
mgd.use_4addr &&
1916 multicast = is_multicast_ether_addr(hdr.
addr1);
1928 if (ieee80211_vif_is_mesh(&sdata->
vif))
1941 if (
unlikely(!ieee80211_vif_is_mesh(&sdata->
vif) &&
1942 !is_multicast_ether_addr(hdr.
addr1) && !authorized &&
1945 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1961 unsigned long flags;
1973 if (
WARN_ON(!
id) ||
id > 0xffff) {
1982 }
else if (skb_shared(skb)) {
1997 if (skb_shared(skb)) {
2018 skip_header_bytes -= 2;
2019 }
else if (ethertype >= 0x600) {
2022 skip_header_bytes -= 2;
2028 nh_pos = skb_network_header(skb) - skb->
data;
2029 h_pos = skb_transport_header(skb) - skb->
data;
2032 nh_pos -= skip_header_bytes;
2033 h_pos -= skip_header_bytes;
2035 head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
2049 if (head_need > 0 || skb_cloned(skb)) {
2052 head_need =
max_t(
int, 0, head_need);
2053 if (ieee80211_skb_resize(sdata, skb, head_need,
true)) {
2061 nh_pos += encaps_len;
2062 h_pos += encaps_len;
2065 #ifdef CONFIG_MAC80211_MESH
2066 if (meshhdrlen > 0) {
2068 nh_pos += meshhdrlen;
2069 h_pos += meshhdrlen;
2073 if (ieee80211_is_data_qos(fc)) {
2089 dev->
stats.tx_packets++;
2095 skb_set_mac_header(skb, 0);
2096 skb_set_network_header(skb, nh_pos);
2097 skb_set_transport_header(skb, h_pos);
2099 info = IEEE80211_SKB_CB(skb);
2100 memset(info, 0,
sizeof(*info));
2126 for (i = 0; i < local->
hw.queues; i++) {
2146 sdata = vif_to_sdata(info->
control.vif);
2149 result = ieee80211_tx(sdata, skb,
true);
2153 __skb_queue_head_init(&skbs);
2154 __skb_queue_tail(&skbs, skb);
2159 result = __ieee80211_tx(local, &skbs, skb->
len, sta,
true);
2171 unsigned long flags;
2178 for (i = 0; i < local->
hw.queues; i++) {
2184 skb_queue_empty(&local->
pending[i]))
2187 while (!skb_queue_empty(&local->
pending[i])) {
2199 txok = ieee80211_tx_pending_skb(local, skb);
2206 if (skb_queue_empty(&local->
pending[i]))
2223 int i, have_bits = 0, n1, n2;
2230 have_bits = !bitmap_empty((
unsigned long*)bss->
tim,
2242 *pos++ = sdata->
vif.bss_conf.dtim_period;
2261 for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
2272 memcpy(pos, bss->
tim + n1, n2 - n1 + 1);
2274 tim[1] = n2 - n1 + 4;
2283 u16 *tim_offset,
u16 *tim_length)
2296 sdata = vif_to_sdata(vif);
2298 if (!ieee80211_sdata_running(sdata))
2332 ieee80211_beacon_add_tim(sdata, ap, skb,
2335 unsigned long flags;
2338 ieee80211_beacon_add_tim(sdata, ap, skb,
2340 spin_unlock_irqrestore(&local->
tim_lock, flags);
2368 }
else if (ieee80211_vif_is_mesh(&sdata->
vif)) {
2373 sizeof(mgmt->
u.beacon);
2375 #ifdef CONFIG_MAC80211_MESH
2376 if (!sdata->
u.
mesh.mesh_id_len)
2392 2 + sdata->
u.
mesh.mesh_id_len +
2394 sdata->
u.
mesh.ie_len);
2398 skb_reserve(skb, local->
hw.extra_tx_headroom);
2400 memset(mgmt, 0, hdr_len);
2403 eth_broadcast_addr(mgmt->
da);
2406 mgmt->
u.beacon.beacon_int =
2424 pr_err(
"o11s: couldn't add ies!\n");
2432 info = IEEE80211_SKB_CB(skb);
2438 memset(&txrc, 0,
sizeof(txrc));
2440 txrc.
sband = local->
hw.wiphy->bands[band];
2484 skb = dev_alloc_skb(presp->
len);
2511 sdata = vif_to_sdata(vif);
2512 ifmgd = &sdata->
u.
mgd;
2513 local = sdata->
local;
2515 skb = dev_alloc_skb(local->
hw.extra_tx_headroom +
sizeof(*pspoll));
2519 skb_reserve(skb, local->
hw.extra_tx_headroom);
2522 memset(pspoll, 0,
sizeof(*pspoll));
2549 sdata = vif_to_sdata(vif);
2550 ifmgd = &sdata->
u.
mgd;
2551 local = sdata->
local;
2553 skb = dev_alloc_skb(local->
hw.extra_tx_headroom +
sizeof(*nullfunc));
2557 skb_reserve(skb, local->
hw.extra_tx_headroom);
2561 memset(nullfunc, 0,
sizeof(*nullfunc));
2575 const u8 *
ssid,
size_t ssid_len,
2585 sdata = vif_to_sdata(vif);
2586 local = sdata->
local;
2587 ie_ssid_len = 2 + ssid_len;
2589 skb = dev_alloc_skb(local->
hw.extra_tx_headroom +
sizeof(*hdr) +
2590 ie_ssid_len + ie_len);
2594 skb_reserve(skb, local->
hw.extra_tx_headroom);
2597 memset(hdr, 0,
sizeof(*hdr));
2600 eth_broadcast_addr(hdr->
addr1);
2602 eth_broadcast_addr(hdr->
addr3);
2604 pos =
skb_put(skb, ie_ssid_len);
2608 memcpy(pos, ssid, ssid_len);
2621 const void *
frame,
size_t frame_len,
2637 const void *
frame,
size_t frame_len,
2646 frame_len, frame_txctl);
2663 sdata = vif_to_sdata(vif);
2681 if (!skb_queue_empty(&bss->
ps_bc_buf) && skb->
len >= 2) {
2691 if (!ieee80211_tx_prepare(sdata, &tx, skb))
2696 info = IEEE80211_SKB_CB(skb);
2701 if (invoke_tx_handlers(&tx))
2715 skb_set_mac_header(skb, 0);
2716 skb_set_network_header(skb, 0);
2717 skb_set_transport_header(skb, 0);
2719 skb_set_queue_mapping(skb, ac);