Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2002-2005, Instant802 Networks, Inc. |
| 3 | * Copyright 2005-2006, Devicescape Software, Inc. |
| 4 | * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> |
| 5 | * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of the GNU General Public License version 2 as |
| 9 | * published by the Free Software Foundation. |
| 10 | * |
| 11 | * |
| 12 | * Transmit and frame generation functions. |
| 13 | */ |
| 14 | |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/slab.h> |
| 17 | #include <linux/skbuff.h> |
| 18 | #include <linux/etherdevice.h> |
| 19 | #include <linux/bitmap.h> |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 20 | #include <linux/rcupdate.h> |
Eric W. Biederman | 881d966 | 2007-09-17 11:56:21 -0700 | [diff] [blame] | 21 | #include <net/net_namespace.h> |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 22 | #include <net/ieee80211_radiotap.h> |
| 23 | #include <net/cfg80211.h> |
| 24 | #include <net/mac80211.h> |
| 25 | #include <asm/unaligned.h> |
| 26 | |
| 27 | #include "ieee80211_i.h" |
Johannes Berg | 2c8dccc | 2008-04-08 15:14:40 -0400 | [diff] [blame] | 28 | #include "led.h" |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 29 | #include "mesh.h" |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 30 | #include "wep.h" |
| 31 | #include "wpa.h" |
| 32 | #include "wme.h" |
Johannes Berg | 2c8dccc | 2008-04-08 15:14:40 -0400 | [diff] [blame] | 33 | #include "rate.h" |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 34 | |
| 35 | #define IEEE80211_TX_OK 0 |
| 36 | #define IEEE80211_TX_AGAIN 1 |
| 37 | #define IEEE80211_TX_FRAG_AGAIN 2 |
| 38 | |
| 39 | /* misc utils */ |
| 40 | |
| 41 | static inline void ieee80211_include_sequence(struct ieee80211_sub_if_data *sdata, |
| 42 | struct ieee80211_hdr *hdr) |
| 43 | { |
| 44 | /* Set the sequence number for this frame. */ |
| 45 | hdr->seq_ctrl = cpu_to_le16(sdata->sequence); |
| 46 | |
| 47 | /* Increase the sequence number. */ |
| 48 | sdata->sequence = (sdata->sequence + 0x10) & IEEE80211_SCTL_SEQ; |
| 49 | } |
| 50 | |
| 51 | #ifdef CONFIG_MAC80211_LOWTX_FRAME_DUMP |
| 52 | static void ieee80211_dump_frame(const char *ifname, const char *title, |
| 53 | const struct sk_buff *skb) |
| 54 | { |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 55 | const struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 56 | unsigned int hdrlen; |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 57 | DECLARE_MAC_BUF(mac); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 58 | |
| 59 | printk(KERN_DEBUG "%s: %s (len=%d)", ifname, title, skb->len); |
| 60 | if (skb->len < 4) { |
| 61 | printk("\n"); |
| 62 | return; |
| 63 | } |
| 64 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 65 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 66 | if (hdrlen > skb->len) |
| 67 | hdrlen = skb->len; |
| 68 | if (hdrlen >= 4) |
| 69 | printk(" FC=0x%04x DUR=0x%04x", |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 70 | le16_to_cpu(hdr->frame_control), le16_to_cpu(hdr->duration_id)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 71 | if (hdrlen >= 10) |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 72 | printk(" A1=%s", print_mac(mac, hdr->addr1)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 73 | if (hdrlen >= 16) |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 74 | printk(" A2=%s", print_mac(mac, hdr->addr2)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 75 | if (hdrlen >= 24) |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 76 | printk(" A3=%s", print_mac(mac, hdr->addr3)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 77 | if (hdrlen >= 30) |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 78 | printk(" A4=%s", print_mac(mac, hdr->addr4)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 79 | printk("\n"); |
| 80 | } |
| 81 | #else /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */ |
| 82 | static inline void ieee80211_dump_frame(const char *ifname, const char *title, |
| 83 | struct sk_buff *skb) |
| 84 | { |
| 85 | } |
| 86 | #endif /* CONFIG_MAC80211_LOWTX_FRAME_DUMP */ |
| 87 | |
Johannes Berg | 03f93c3 | 2008-06-25 14:36:27 +0300 | [diff] [blame] | 88 | static __le16 ieee80211_duration(struct ieee80211_tx_data *tx, int group_addr, |
| 89 | int next_frag_len) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 90 | { |
| 91 | int rate, mrate, erp, dur, i; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 92 | struct ieee80211_rate *txrate; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 93 | struct ieee80211_local *local = tx->local; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 94 | struct ieee80211_supported_band *sband; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 95 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 96 | sband = local->hw.wiphy->bands[tx->channel->band]; |
| 97 | txrate = &sband->bitrates[tx->rate_idx]; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 98 | |
| 99 | erp = 0; |
| 100 | if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) |
| 101 | erp = txrate->flags & IEEE80211_RATE_ERP_G; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 102 | |
| 103 | /* |
| 104 | * data and mgmt (except PS Poll): |
| 105 | * - during CFP: 32768 |
| 106 | * - during contention period: |
| 107 | * if addr1 is group address: 0 |
| 108 | * if more fragments = 0 and addr1 is individual address: time to |
| 109 | * transmit one ACK plus SIFS |
| 110 | * if more fragments = 1 and addr1 is individual address: time to |
| 111 | * transmit next fragment plus 2 x ACK plus 3 x SIFS |
| 112 | * |
| 113 | * IEEE 802.11, 9.6: |
| 114 | * - control response frame (CTS or ACK) shall be transmitted using the |
| 115 | * same rate as the immediately previous frame in the frame exchange |
| 116 | * sequence, if this rate belongs to the PHY mandatory rates, or else |
| 117 | * at the highest possible rate belonging to the PHY rates in the |
| 118 | * BSSBasicRateSet |
| 119 | */ |
| 120 | |
| 121 | if ((tx->fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) { |
| 122 | /* TODO: These control frames are not currently sent by |
| 123 | * 80211.o, but should they be implemented, this function |
| 124 | * needs to be updated to support duration field calculation. |
| 125 | * |
| 126 | * RTS: time needed to transmit pending data/mgmt frame plus |
| 127 | * one CTS frame plus one ACK frame plus 3 x SIFS |
| 128 | * CTS: duration of immediately previous RTS minus time |
| 129 | * required to transmit CTS and its SIFS |
| 130 | * ACK: 0 if immediately previous directed data/mgmt had |
| 131 | * more=0, with more=1 duration in ACK frame is duration |
| 132 | * from previous frame minus time needed to transmit ACK |
| 133 | * and its SIFS |
| 134 | * PS Poll: BIT(15) | BIT(14) | aid |
| 135 | */ |
| 136 | return 0; |
| 137 | } |
| 138 | |
| 139 | /* data/mgmt */ |
| 140 | if (0 /* FIX: data/mgmt during CFP */) |
Johannes Berg | 03f93c3 | 2008-06-25 14:36:27 +0300 | [diff] [blame] | 141 | return cpu_to_le16(32768); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 142 | |
| 143 | if (group_addr) /* Group address as the destination - no ACK */ |
| 144 | return 0; |
| 145 | |
| 146 | /* Individual destination address: |
| 147 | * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes) |
| 148 | * CTS and ACK frames shall be transmitted using the highest rate in |
| 149 | * basic rate set that is less than or equal to the rate of the |
| 150 | * immediately previous frame and that is using the same modulation |
| 151 | * (CCK or OFDM). If no basic rate set matches with these requirements, |
| 152 | * the highest mandatory rate of the PHY that is less than or equal to |
| 153 | * the rate of the previous frame is used. |
| 154 | * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps |
| 155 | */ |
| 156 | rate = -1; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 157 | /* use lowest available if everything fails */ |
| 158 | mrate = sband->bitrates[0].bitrate; |
| 159 | for (i = 0; i < sband->n_bitrates; i++) { |
| 160 | struct ieee80211_rate *r = &sband->bitrates[i]; |
| 161 | |
| 162 | if (r->bitrate > txrate->bitrate) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 163 | break; |
| 164 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 165 | if (tx->sdata->basic_rates & BIT(i)) |
| 166 | rate = r->bitrate; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 167 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 168 | switch (sband->band) { |
| 169 | case IEEE80211_BAND_2GHZ: { |
| 170 | u32 flag; |
| 171 | if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) |
| 172 | flag = IEEE80211_RATE_MANDATORY_G; |
| 173 | else |
| 174 | flag = IEEE80211_RATE_MANDATORY_B; |
| 175 | if (r->flags & flag) |
| 176 | mrate = r->bitrate; |
| 177 | break; |
| 178 | } |
| 179 | case IEEE80211_BAND_5GHZ: |
| 180 | if (r->flags & IEEE80211_RATE_MANDATORY_A) |
| 181 | mrate = r->bitrate; |
| 182 | break; |
| 183 | case IEEE80211_NUM_BANDS: |
| 184 | WARN_ON(1); |
| 185 | break; |
| 186 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 187 | } |
| 188 | if (rate == -1) { |
| 189 | /* No matching basic rate found; use highest suitable mandatory |
| 190 | * PHY rate */ |
| 191 | rate = mrate; |
| 192 | } |
| 193 | |
| 194 | /* Time needed to transmit ACK |
| 195 | * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up |
| 196 | * to closest integer */ |
| 197 | |
| 198 | dur = ieee80211_frame_duration(local, 10, rate, erp, |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 199 | tx->sdata->bss_conf.use_short_preamble); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 200 | |
| 201 | if (next_frag_len) { |
| 202 | /* Frame is fragmented: duration increases with time needed to |
| 203 | * transmit next fragment plus ACK and 2 x SIFS. */ |
| 204 | dur *= 2; /* ACK + SIFS */ |
| 205 | /* next fragment */ |
| 206 | dur += ieee80211_frame_duration(local, next_frag_len, |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 207 | txrate->bitrate, erp, |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 208 | tx->sdata->bss_conf.use_short_preamble); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 209 | } |
| 210 | |
Johannes Berg | 03f93c3 | 2008-06-25 14:36:27 +0300 | [diff] [blame] | 211 | return cpu_to_le16(dur); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 212 | } |
| 213 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 214 | static int inline is_ieee80211_device(struct net_device *dev, |
| 215 | struct net_device *master) |
| 216 | { |
| 217 | return (wdev_priv(dev->ieee80211_ptr) == |
| 218 | wdev_priv(master->ieee80211_ptr)); |
| 219 | } |
| 220 | |
| 221 | /* tx handlers */ |
| 222 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 223 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 224 | ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 225 | { |
| 226 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 227 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 228 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 229 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 230 | u32 sta_flags; |
| 231 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 232 | if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 233 | return TX_CONTINUE; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 234 | |
Zhu Yi | ece8edd | 2007-11-22 10:53:21 +0800 | [diff] [blame] | 235 | if (unlikely(tx->local->sta_sw_scanning) && |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 236 | ((tx->fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT || |
| 237 | (tx->fc & IEEE80211_FCTL_STYPE) != IEEE80211_STYPE_PROBE_REQ)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 238 | return TX_DROP; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 239 | |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 240 | if (tx->sdata->vif.type == IEEE80211_IF_TYPE_MESH_POINT) |
| 241 | return TX_CONTINUE; |
| 242 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 243 | if (tx->flags & IEEE80211_TX_PS_BUFFERED) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 244 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 245 | |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 246 | sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 247 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 248 | if (likely(tx->flags & IEEE80211_TX_UNICAST)) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 249 | if (unlikely(!(sta_flags & WLAN_STA_ASSOC) && |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 250 | tx->sdata->vif.type != IEEE80211_IF_TYPE_IBSS && |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 251 | (tx->fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)) { |
| 252 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 253 | DECLARE_MAC_BUF(mac); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 254 | printk(KERN_DEBUG "%s: dropped data frame to not " |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 255 | "associated station %s\n", |
| 256 | tx->dev->name, print_mac(mac, hdr->addr1)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 257 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ |
| 258 | I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc); |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 259 | return TX_DROP; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 260 | } |
| 261 | } else { |
| 262 | if (unlikely((tx->fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA && |
| 263 | tx->local->num_sta == 0 && |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 264 | tx->sdata->vif.type != IEEE80211_IF_TYPE_IBSS)) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 265 | /* |
| 266 | * No associated STAs - no need to send multicast |
| 267 | * frames. |
| 268 | */ |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 269 | return TX_DROP; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 270 | } |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 271 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 272 | } |
| 273 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 274 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 275 | } |
| 276 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 277 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 278 | ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 279 | { |
| 280 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; |
| 281 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 282 | if (ieee80211_hdrlen(hdr->frame_control) >= 24) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 283 | ieee80211_include_sequence(tx->sdata, hdr); |
| 284 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 285 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | /* This function is called whenever the AP is about to exceed the maximum limit |
| 289 | * of buffered frames for power saving STAs. This situation should not really |
| 290 | * happen often during normal operation, so dropping the oldest buffered packet |
| 291 | * from each queue should be OK to make some room for new frames. */ |
| 292 | static void purge_old_ps_buffers(struct ieee80211_local *local) |
| 293 | { |
| 294 | int total = 0, purged = 0; |
| 295 | struct sk_buff *skb; |
| 296 | struct ieee80211_sub_if_data *sdata; |
| 297 | struct sta_info *sta; |
| 298 | |
Johannes Berg | 7901042 | 2007-09-18 17:29:21 -0400 | [diff] [blame] | 299 | /* |
| 300 | * virtual interfaces are protected by RCU |
| 301 | */ |
| 302 | rcu_read_lock(); |
| 303 | |
| 304 | list_for_each_entry_rcu(sdata, &local->interfaces, list) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 305 | struct ieee80211_if_ap *ap; |
| 306 | if (sdata->dev == local->mdev || |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 307 | sdata->vif.type != IEEE80211_IF_TYPE_AP) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 308 | continue; |
| 309 | ap = &sdata->u.ap; |
| 310 | skb = skb_dequeue(&ap->ps_bc_buf); |
| 311 | if (skb) { |
| 312 | purged++; |
| 313 | dev_kfree_skb(skb); |
| 314 | } |
| 315 | total += skb_queue_len(&ap->ps_bc_buf); |
| 316 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 317 | |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 318 | list_for_each_entry_rcu(sta, &local->sta_list, list) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 319 | skb = skb_dequeue(&sta->ps_tx_buf); |
| 320 | if (skb) { |
| 321 | purged++; |
| 322 | dev_kfree_skb(skb); |
| 323 | } |
| 324 | total += skb_queue_len(&sta->ps_tx_buf); |
| 325 | } |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 326 | |
| 327 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 328 | |
| 329 | local->total_ps_buffered = total; |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 330 | #ifdef MAC80211_VERBOSE_PS_DEBUG |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 331 | printk(KERN_DEBUG "%s: PS buffers full - purged %d frames\n", |
Johannes Berg | dd1cd4c | 2007-09-18 17:29:20 -0400 | [diff] [blame] | 332 | wiphy_name(local->hw.wiphy), purged); |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 333 | #endif |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 334 | } |
| 335 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 336 | static ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 337 | ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 338 | { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 339 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
| 340 | |
Johannes Berg | 7d54d0d | 2007-12-19 01:31:25 +0100 | [diff] [blame] | 341 | /* |
| 342 | * broadcast/multicast frame |
| 343 | * |
| 344 | * If any of the associated stations is in power save mode, |
| 345 | * the frame is buffered to be sent after DTIM beacon frame. |
| 346 | * This is done either by the hardware or us. |
| 347 | */ |
| 348 | |
| 349 | /* not AP/IBSS or ordered frame */ |
| 350 | if (!tx->sdata->bss || (tx->fc & IEEE80211_FCTL_ORDER)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 351 | return TX_CONTINUE; |
Johannes Berg | 7d54d0d | 2007-12-19 01:31:25 +0100 | [diff] [blame] | 352 | |
| 353 | /* no stations in PS mode */ |
| 354 | if (!atomic_read(&tx->sdata->bss->num_sta_ps)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 355 | return TX_CONTINUE; |
Johannes Berg | 7d54d0d | 2007-12-19 01:31:25 +0100 | [diff] [blame] | 356 | |
| 357 | /* buffered in mac80211 */ |
| 358 | if (tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 359 | if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER) |
| 360 | purge_old_ps_buffers(tx->local); |
| 361 | if (skb_queue_len(&tx->sdata->bss->ps_bc_buf) >= |
| 362 | AP_MAX_BC_BUFFER) { |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 363 | #ifdef MAC80211_VERBOSE_PS_DEBUG |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 364 | if (net_ratelimit()) { |
| 365 | printk(KERN_DEBUG "%s: BC TX buffer full - " |
| 366 | "dropping the oldest frame\n", |
| 367 | tx->dev->name); |
| 368 | } |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 369 | #endif |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 370 | dev_kfree_skb(skb_dequeue(&tx->sdata->bss->ps_bc_buf)); |
| 371 | } else |
| 372 | tx->local->total_ps_buffered++; |
| 373 | skb_queue_tail(&tx->sdata->bss->ps_bc_buf, tx->skb); |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 374 | return TX_QUEUED; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 375 | } |
| 376 | |
Johannes Berg | 7d54d0d | 2007-12-19 01:31:25 +0100 | [diff] [blame] | 377 | /* buffered in hardware */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 378 | info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM; |
Johannes Berg | 7d54d0d | 2007-12-19 01:31:25 +0100 | [diff] [blame] | 379 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 380 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 381 | } |
| 382 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 383 | static ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 384 | ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 385 | { |
| 386 | struct sta_info *sta = tx->sta; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 387 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 388 | u32 staflags; |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 389 | DECLARE_MAC_BUF(mac); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 390 | |
| 391 | if (unlikely(!sta || |
| 392 | ((tx->fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && |
| 393 | (tx->fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP))) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 394 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 395 | |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 396 | staflags = get_sta_flags(sta); |
| 397 | |
| 398 | if (unlikely((staflags & WLAN_STA_PS) && |
| 399 | !(staflags & WLAN_STA_PSPOLL))) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 400 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 401 | printk(KERN_DEBUG "STA %s aid %d: PS buffer (entries " |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 402 | "before %d)\n", |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 403 | print_mac(mac, sta->addr), sta->aid, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 404 | skb_queue_len(&sta->ps_tx_buf)); |
| 405 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 406 | if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER) |
| 407 | purge_old_ps_buffers(tx->local); |
| 408 | if (skb_queue_len(&sta->ps_tx_buf) >= STA_MAX_TX_BUFFER) { |
| 409 | struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf); |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 410 | #ifdef MAC80211_VERBOSE_PS_DEBUG |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 411 | if (net_ratelimit()) { |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 412 | printk(KERN_DEBUG "%s: STA %s TX " |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 413 | "buffer full - dropping oldest frame\n", |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 414 | tx->dev->name, print_mac(mac, sta->addr)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 415 | } |
Johannes Berg | f4ea83d | 2008-06-30 15:10:46 +0200 | [diff] [blame] | 416 | #endif |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 417 | dev_kfree_skb(old); |
| 418 | } else |
| 419 | tx->local->total_ps_buffered++; |
Johannes Berg | 004c872 | 2008-02-20 11:21:35 +0100 | [diff] [blame] | 420 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 421 | /* Queue frame to be sent after STA sends an PS Poll frame */ |
Johannes Berg | 004c872 | 2008-02-20 11:21:35 +0100 | [diff] [blame] | 422 | if (skb_queue_empty(&sta->ps_tx_buf)) |
| 423 | sta_info_set_tim_bit(sta); |
| 424 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 425 | info->control.jiffies = jiffies; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 426 | skb_queue_tail(&sta->ps_tx_buf, tx->skb); |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 427 | return TX_QUEUED; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 428 | } |
| 429 | #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 430 | else if (unlikely(test_sta_flags(sta, WLAN_STA_PS))) { |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 431 | printk(KERN_DEBUG "%s: STA %s in PS mode, but pspoll " |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 432 | "set -> send frame\n", tx->dev->name, |
Joe Perches | 0795af5 | 2007-10-03 17:59:30 -0700 | [diff] [blame] | 433 | print_mac(mac, sta->addr)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 434 | } |
| 435 | #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */ |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 436 | clear_sta_flags(sta, WLAN_STA_PSPOLL); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 437 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 438 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 439 | } |
| 440 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 441 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 442 | ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 443 | { |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 444 | if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 445 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 446 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 447 | if (tx->flags & IEEE80211_TX_UNICAST) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 448 | return ieee80211_tx_h_unicast_ps_buf(tx); |
| 449 | else |
| 450 | return ieee80211_tx_h_multicast_ps_buf(tx); |
| 451 | } |
| 452 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 453 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 454 | ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 455 | { |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 456 | struct ieee80211_key *key; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 457 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 458 | u16 fc = tx->fc; |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 459 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 460 | if (unlikely(info->flags & IEEE80211_TX_CTL_DO_NOT_ENCRYPT)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 461 | tx->key = NULL; |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 462 | else if (tx->sta && (key = rcu_dereference(tx->sta->key))) |
| 463 | tx->key = key; |
| 464 | else if ((key = rcu_dereference(tx->sdata->default_key))) |
| 465 | tx->key = key; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 466 | else if (tx->sdata->drop_unencrypted && |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 467 | !(info->flags & IEEE80211_TX_CTL_EAPOL_FRAME) && |
| 468 | !(info->flags & IEEE80211_TX_CTL_INJECTED)) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 469 | I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted); |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 470 | return TX_DROP; |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 471 | } else |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 472 | tx->key = NULL; |
| 473 | |
| 474 | if (tx->key) { |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 475 | u16 ftype, stype; |
| 476 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 477 | tx->key->tx_rx_count++; |
Johannes Berg | 011bfcc | 2007-09-17 01:29:25 -0400 | [diff] [blame] | 478 | /* TODO: add threshold stuff again */ |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 479 | |
| 480 | switch (tx->key->conf.alg) { |
| 481 | case ALG_WEP: |
| 482 | ftype = fc & IEEE80211_FCTL_FTYPE; |
| 483 | stype = fc & IEEE80211_FCTL_STYPE; |
| 484 | |
| 485 | if (ftype == IEEE80211_FTYPE_MGMT && |
| 486 | stype == IEEE80211_STYPE_AUTH) |
| 487 | break; |
| 488 | case ALG_TKIP: |
| 489 | case ALG_CCMP: |
| 490 | if (!WLAN_FC_DATA_PRESENT(fc)) |
| 491 | tx->key = NULL; |
| 492 | break; |
| 493 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 494 | } |
| 495 | |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 496 | if (!tx->key || !(tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 497 | info->flags |= IEEE80211_TX_CTL_DO_NOT_ENCRYPT; |
Johannes Berg | 176e4f8 | 2007-12-18 15:27:47 +0100 | [diff] [blame] | 498 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 499 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 500 | } |
| 501 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 502 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 503 | ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 504 | { |
Mattias Nissler | 1abbe49 | 2007-12-20 13:50:07 +0100 | [diff] [blame] | 505 | struct rate_selection rsel; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 506 | struct ieee80211_supported_band *sband; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 507 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 508 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 509 | sband = tx->local->hw.wiphy->bands[tx->channel->band]; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 510 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 511 | if (likely(tx->rate_idx < 0)) { |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 512 | rate_control_get_rate(tx->dev, sband, tx->skb, &rsel); |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 513 | tx->rate_idx = rsel.rate_idx; |
| 514 | if (unlikely(rsel.probe_idx >= 0)) { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 515 | info->flags |= IEEE80211_TX_CTL_RATE_CTRL_PROBE; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 516 | tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 517 | info->control.alt_retry_rate_idx = tx->rate_idx; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 518 | tx->rate_idx = rsel.probe_idx; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 519 | } else |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 520 | info->control.alt_retry_rate_idx = -1; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 521 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 522 | if (unlikely(tx->rate_idx < 0)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 523 | return TX_DROP; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 524 | } else |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 525 | info->control.alt_retry_rate_idx = -1; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 526 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 527 | if (tx->sdata->bss_conf.use_cts_prot && |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 528 | (tx->flags & IEEE80211_TX_FRAGMENTED) && (rsel.nonerp_idx >= 0)) { |
| 529 | tx->last_frag_rate_idx = tx->rate_idx; |
| 530 | if (rsel.probe_idx >= 0) |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 531 | tx->flags &= ~IEEE80211_TX_PROBE_LAST_FRAG; |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 532 | else |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 533 | tx->flags |= IEEE80211_TX_PROBE_LAST_FRAG; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 534 | tx->rate_idx = rsel.nonerp_idx; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 535 | info->tx_rate_idx = rsel.nonerp_idx; |
| 536 | info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 537 | } else { |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 538 | tx->last_frag_rate_idx = tx->rate_idx; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 539 | info->tx_rate_idx = tx->rate_idx; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 540 | } |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 541 | info->tx_rate_idx = tx->rate_idx; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 542 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 543 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 544 | } |
| 545 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 546 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 547 | ieee80211_tx_h_misc(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 548 | { |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 549 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 550 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb); |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 551 | struct ieee80211_supported_band *sband; |
| 552 | |
| 553 | sband = tx->local->hw.wiphy->bands[tx->channel->band]; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 554 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 555 | if (tx->sta) |
| 556 | info->control.aid = tx->sta->aid; |
| 557 | |
| 558 | if (!info->control.retry_limit) { |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 559 | if (!is_multicast_ether_addr(hdr->addr1)) { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 560 | int len = min_t(int, tx->skb->len + FCS_LEN, |
| 561 | tx->local->fragmentation_threshold); |
| 562 | if (len > tx->local->rts_threshold |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 563 | && tx->local->rts_threshold < |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 564 | IEEE80211_MAX_RTS_THRESHOLD) { |
| 565 | info->flags |= IEEE80211_TX_CTL_USE_RTS_CTS; |
| 566 | info->flags |= |
| 567 | IEEE80211_TX_CTL_LONG_RETRY_LIMIT; |
| 568 | info->control.retry_limit = |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 569 | tx->local->long_retry_limit; |
| 570 | } else { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 571 | info->control.retry_limit = |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 572 | tx->local->short_retry_limit; |
| 573 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 574 | } else { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 575 | info->control.retry_limit = 1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 576 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 577 | } |
| 578 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 579 | if (tx->flags & IEEE80211_TX_FRAGMENTED) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 580 | /* Do not use multiple retry rates when sending fragmented |
| 581 | * frames. |
| 582 | * TODO: The last fragment could still use multiple retry |
| 583 | * rates. */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 584 | info->control.alt_retry_rate_idx = -1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 585 | } |
| 586 | |
| 587 | /* Use CTS protection for unicast frames sent using extended rates if |
| 588 | * there are associated non-ERP stations and RTS/CTS is not configured |
| 589 | * for the frame. */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 590 | if ((tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) && |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 591 | (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_ERP_G) && |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 592 | (tx->flags & IEEE80211_TX_UNICAST) && |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 593 | tx->sdata->bss_conf.use_cts_prot && |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 594 | !(info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)) |
| 595 | info->flags |= IEEE80211_TX_CTL_USE_CTS_PROTECT; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 596 | |
Daniel Drake | 7e9ed18 | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 597 | /* Transmit data frames using short preambles if the driver supports |
| 598 | * short preambles at the selected rate and short preambles are |
| 599 | * available on the network at the current point in time. */ |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 600 | if (ieee80211_is_data(hdr->frame_control) && |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 601 | (sband->bitrates[tx->rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE) && |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 602 | tx->sdata->bss_conf.use_short_preamble && |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 603 | (!tx->sta || test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))) { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 604 | info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE; |
Daniel Drake | 7e9ed18 | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 605 | } |
| 606 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 607 | if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) || |
| 608 | (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) { |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 609 | struct ieee80211_rate *rate; |
| 610 | s8 baserate = -1; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 611 | int idx; |
| 612 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 613 | /* Do not use multiple retry rates when using RTS/CTS */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 614 | info->control.alt_retry_rate_idx = -1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 615 | |
| 616 | /* Use min(data rate, max base rate) as CTS/RTS rate */ |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 617 | rate = &sband->bitrates[tx->rate_idx]; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 618 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 619 | for (idx = 0; idx < sband->n_bitrates; idx++) { |
| 620 | if (sband->bitrates[idx].bitrate > rate->bitrate) |
| 621 | continue; |
| 622 | if (tx->sdata->basic_rates & BIT(idx) && |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 623 | (baserate < 0 || |
| 624 | (sband->bitrates[baserate].bitrate |
| 625 | < sband->bitrates[idx].bitrate))) |
| 626 | baserate = idx; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 627 | } |
| 628 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 629 | if (baserate >= 0) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 630 | info->control.rts_cts_rate_idx = baserate; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 631 | else |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 632 | info->control.rts_cts_rate_idx = 0; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 633 | } |
| 634 | |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 635 | if (tx->sta) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 636 | info->control.aid = tx->sta->aid; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 637 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 638 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 639 | } |
| 640 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 641 | static ieee80211_tx_result debug_noinline |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 642 | ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx) |
| 643 | { |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 644 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 645 | size_t hdrlen, per_fragm, num_fragm, payload_len, left; |
| 646 | struct sk_buff **frags, *first, *frag; |
| 647 | int i; |
| 648 | u16 seq; |
| 649 | u8 *pos; |
| 650 | int frag_threshold = tx->local->fragmentation_threshold; |
| 651 | |
| 652 | if (!(tx->flags & IEEE80211_TX_FRAGMENTED)) |
| 653 | return TX_CONTINUE; |
| 654 | |
Johannes Berg | eefce91 | 2008-05-17 00:57:13 +0200 | [diff] [blame] | 655 | /* |
| 656 | * Warn when submitting a fragmented A-MPDU frame and drop it. |
Ron Rindjunsky | 8d5e0d5 | 2008-06-12 15:42:29 +0300 | [diff] [blame] | 657 | * This scenario is handled in __ieee80211_tx_prepare but extra |
| 658 | * caution taken here as fragmented ampdu may cause Tx stop. |
Johannes Berg | eefce91 | 2008-05-17 00:57:13 +0200 | [diff] [blame] | 659 | */ |
| 660 | if (WARN_ON(tx->flags & IEEE80211_TX_CTL_AMPDU || |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 661 | skb_get_queue_mapping(tx->skb) >= |
| 662 | ieee80211_num_regular_queues(&tx->local->hw))) |
Johannes Berg | eefce91 | 2008-05-17 00:57:13 +0200 | [diff] [blame] | 663 | return TX_DROP; |
| 664 | |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 665 | first = tx->skb; |
| 666 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 667 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 668 | payload_len = first->len - hdrlen; |
| 669 | per_fragm = frag_threshold - hdrlen - FCS_LEN; |
| 670 | num_fragm = DIV_ROUND_UP(payload_len, per_fragm); |
| 671 | |
| 672 | frags = kzalloc(num_fragm * sizeof(struct sk_buff *), GFP_ATOMIC); |
| 673 | if (!frags) |
| 674 | goto fail; |
| 675 | |
| 676 | hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREFRAGS); |
| 677 | seq = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ; |
| 678 | pos = first->data + hdrlen + per_fragm; |
| 679 | left = payload_len - per_fragm; |
| 680 | for (i = 0; i < num_fragm - 1; i++) { |
| 681 | struct ieee80211_hdr *fhdr; |
| 682 | size_t copylen; |
| 683 | |
| 684 | if (left <= 0) |
| 685 | goto fail; |
| 686 | |
| 687 | /* reserve enough extra head and tail room for possible |
| 688 | * encryption */ |
| 689 | frag = frags[i] = |
| 690 | dev_alloc_skb(tx->local->tx_headroom + |
| 691 | frag_threshold + |
| 692 | IEEE80211_ENCRYPT_HEADROOM + |
| 693 | IEEE80211_ENCRYPT_TAILROOM); |
| 694 | if (!frag) |
| 695 | goto fail; |
| 696 | /* Make sure that all fragments use the same priority so |
| 697 | * that they end up using the same TX queue */ |
| 698 | frag->priority = first->priority; |
| 699 | skb_reserve(frag, tx->local->tx_headroom + |
| 700 | IEEE80211_ENCRYPT_HEADROOM); |
| 701 | fhdr = (struct ieee80211_hdr *) skb_put(frag, hdrlen); |
| 702 | memcpy(fhdr, first->data, hdrlen); |
| 703 | if (i == num_fragm - 2) |
| 704 | fhdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS); |
| 705 | fhdr->seq_ctrl = cpu_to_le16(seq | ((i + 1) & IEEE80211_SCTL_FRAG)); |
| 706 | copylen = left > per_fragm ? per_fragm : left; |
| 707 | memcpy(skb_put(frag, copylen), pos, copylen); |
Johannes Berg | 03f93c3 | 2008-06-25 14:36:27 +0300 | [diff] [blame] | 708 | memcpy(frag->cb, first->cb, sizeof(frag->cb)); |
| 709 | skb_copy_queue_mapping(frag, first); |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 710 | |
| 711 | pos += copylen; |
| 712 | left -= copylen; |
| 713 | } |
| 714 | skb_trim(first, hdrlen + per_fragm); |
| 715 | |
| 716 | tx->num_extra_frag = num_fragm - 1; |
| 717 | tx->extra_frag = frags; |
| 718 | |
| 719 | return TX_CONTINUE; |
| 720 | |
| 721 | fail: |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 722 | if (frags) { |
| 723 | for (i = 0; i < num_fragm - 1; i++) |
| 724 | if (frags[i]) |
| 725 | dev_kfree_skb(frags[i]); |
| 726 | kfree(frags); |
| 727 | } |
| 728 | I802_DEBUG_INC(tx->local->tx_handlers_drop_fragment); |
| 729 | return TX_DROP; |
| 730 | } |
| 731 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 732 | static ieee80211_tx_result debug_noinline |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 733 | ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx) |
| 734 | { |
| 735 | if (!tx->key) |
| 736 | return TX_CONTINUE; |
| 737 | |
| 738 | switch (tx->key->conf.alg) { |
| 739 | case ALG_WEP: |
| 740 | return ieee80211_crypto_wep_encrypt(tx); |
| 741 | case ALG_TKIP: |
| 742 | return ieee80211_crypto_tkip_encrypt(tx); |
| 743 | case ALG_CCMP: |
| 744 | return ieee80211_crypto_ccmp_encrypt(tx); |
| 745 | } |
| 746 | |
| 747 | /* not reached */ |
| 748 | WARN_ON(1); |
| 749 | return TX_DROP; |
| 750 | } |
| 751 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 752 | static ieee80211_tx_result debug_noinline |
Johannes Berg | 03f93c3 | 2008-06-25 14:36:27 +0300 | [diff] [blame] | 753 | ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx) |
| 754 | { |
| 755 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data; |
| 756 | int next_len, i; |
| 757 | int group_addr = is_multicast_ether_addr(hdr->addr1); |
| 758 | |
| 759 | if (!(tx->flags & IEEE80211_TX_FRAGMENTED)) { |
| 760 | hdr->duration_id = ieee80211_duration(tx, group_addr, 0); |
| 761 | return TX_CONTINUE; |
| 762 | } |
| 763 | |
| 764 | hdr->duration_id = ieee80211_duration(tx, group_addr, |
| 765 | tx->extra_frag[0]->len); |
| 766 | |
| 767 | for (i = 0; i < tx->num_extra_frag; i++) { |
| 768 | if (i + 1 < tx->num_extra_frag) { |
| 769 | next_len = tx->extra_frag[i + 1]->len; |
| 770 | } else { |
| 771 | next_len = 0; |
| 772 | tx->rate_idx = tx->last_frag_rate_idx; |
| 773 | } |
| 774 | |
| 775 | hdr = (struct ieee80211_hdr *)tx->extra_frag[i]->data; |
| 776 | hdr->duration_id = ieee80211_duration(tx, 0, next_len); |
| 777 | } |
| 778 | |
| 779 | return TX_CONTINUE; |
| 780 | } |
| 781 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 782 | static ieee80211_tx_result debug_noinline |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 783 | ieee80211_tx_h_stats(struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 784 | { |
Johannes Berg | 9e72ebd | 2008-05-21 17:33:42 +0200 | [diff] [blame] | 785 | int i; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 786 | |
Johannes Berg | 9e72ebd | 2008-05-21 17:33:42 +0200 | [diff] [blame] | 787 | if (!tx->sta) |
| 788 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 789 | |
Johannes Berg | 9e72ebd | 2008-05-21 17:33:42 +0200 | [diff] [blame] | 790 | tx->sta->tx_packets++; |
| 791 | tx->sta->tx_fragments++; |
| 792 | tx->sta->tx_bytes += tx->skb->len; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 793 | if (tx->extra_frag) { |
Johannes Berg | 9e72ebd | 2008-05-21 17:33:42 +0200 | [diff] [blame] | 794 | tx->sta->tx_fragments += tx->num_extra_frag; |
| 795 | for (i = 0; i < tx->num_extra_frag; i++) |
| 796 | tx->sta->tx_bytes += tx->extra_frag[i]->len; |
Johannes Berg | e245494 | 2008-05-15 12:55:28 +0200 | [diff] [blame] | 797 | } |
| 798 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 799 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 800 | } |
| 801 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 802 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 803 | /* actual transmit path */ |
| 804 | |
| 805 | /* |
| 806 | * deal with packet injection down monitor interface |
| 807 | * with Radiotap Header -- only called for monitor mode interface |
| 808 | */ |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 809 | static ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 810 | __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx, |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 811 | struct sk_buff *skb) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 812 | { |
| 813 | /* |
| 814 | * this is the moment to interpret and discard the radiotap header that |
| 815 | * must be at the start of the packet injected in Monitor mode |
| 816 | * |
| 817 | * Need to take some care with endian-ness since radiotap |
| 818 | * args are little-endian |
| 819 | */ |
| 820 | |
| 821 | struct ieee80211_radiotap_iterator iterator; |
| 822 | struct ieee80211_radiotap_header *rthdr = |
| 823 | (struct ieee80211_radiotap_header *) skb->data; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 824 | struct ieee80211_supported_band *sband; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 825 | int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 826 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 827 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 828 | sband = tx->local->hw.wiphy->bands[tx->channel->band]; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 829 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 830 | info->flags |= IEEE80211_TX_CTL_DO_NOT_ENCRYPT; |
| 831 | info->flags |= IEEE80211_TX_CTL_INJECTED; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 832 | tx->flags &= ~IEEE80211_TX_FRAGMENTED; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 833 | |
| 834 | /* |
| 835 | * for every radiotap entry that is present |
| 836 | * (ieee80211_radiotap_iterator_next returns -ENOENT when no more |
| 837 | * entries present, or -EINVAL on error) |
| 838 | */ |
| 839 | |
| 840 | while (!ret) { |
| 841 | int i, target_rate; |
| 842 | |
| 843 | ret = ieee80211_radiotap_iterator_next(&iterator); |
| 844 | |
| 845 | if (ret) |
| 846 | continue; |
| 847 | |
| 848 | /* see if this argument is something we can use */ |
| 849 | switch (iterator.this_arg_index) { |
| 850 | /* |
| 851 | * You must take care when dereferencing iterator.this_arg |
| 852 | * for multibyte types... the pointer is not aligned. Use |
| 853 | * get_unaligned((type *)iterator.this_arg) to dereference |
| 854 | * iterator.this_arg for type "type" safely on all arches. |
| 855 | */ |
| 856 | case IEEE80211_RADIOTAP_RATE: |
| 857 | /* |
| 858 | * radiotap rate u8 is in 500kbps units eg, 0x02=1Mbps |
| 859 | * ieee80211 rate int is in 100kbps units eg, 0x0a=1Mbps |
| 860 | */ |
| 861 | target_rate = (*iterator.this_arg) * 5; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 862 | for (i = 0; i < sband->n_bitrates; i++) { |
| 863 | struct ieee80211_rate *r; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 864 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 865 | r = &sband->bitrates[i]; |
| 866 | |
| 867 | if (r->bitrate == target_rate) { |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 868 | tx->rate_idx = i; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 869 | break; |
| 870 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 871 | } |
| 872 | break; |
| 873 | |
| 874 | case IEEE80211_RADIOTAP_ANTENNA: |
| 875 | /* |
| 876 | * radiotap uses 0 for 1st ant, mac80211 is 1 for |
| 877 | * 1st ant |
| 878 | */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 879 | info->antenna_sel_tx = (*iterator.this_arg) + 1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 880 | break; |
| 881 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 882 | #if 0 |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 883 | case IEEE80211_RADIOTAP_DBM_TX_POWER: |
| 884 | control->power_level = *iterator.this_arg; |
| 885 | break; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 886 | #endif |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 887 | |
| 888 | case IEEE80211_RADIOTAP_FLAGS: |
| 889 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) { |
| 890 | /* |
| 891 | * this indicates that the skb we have been |
| 892 | * handed has the 32-bit FCS CRC at the end... |
| 893 | * we should react to that by snipping it off |
| 894 | * because it will be recomputed and added |
| 895 | * on transmission |
| 896 | */ |
| 897 | if (skb->len < (iterator.max_length + FCS_LEN)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 898 | return TX_DROP; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 899 | |
| 900 | skb_trim(skb, skb->len - FCS_LEN); |
| 901 | } |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 902 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 903 | info->flags &= |
| 904 | ~IEEE80211_TX_CTL_DO_NOT_ENCRYPT; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 905 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG) |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 906 | tx->flags |= IEEE80211_TX_FRAGMENTED; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 907 | break; |
| 908 | |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 909 | /* |
| 910 | * Please update the file |
| 911 | * Documentation/networking/mac80211-injection.txt |
| 912 | * when parsing new fields here. |
| 913 | */ |
| 914 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 915 | default: |
| 916 | break; |
| 917 | } |
| 918 | } |
| 919 | |
| 920 | if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */ |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 921 | return TX_DROP; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 922 | |
| 923 | /* |
| 924 | * remove the radiotap header |
| 925 | * iterator->max_length was sanity-checked against |
| 926 | * skb->len by iterator init |
| 927 | */ |
| 928 | skb_pull(skb, iterator.max_length); |
| 929 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 930 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 931 | } |
| 932 | |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 933 | /* |
| 934 | * initialises @tx |
| 935 | */ |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 936 | static ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 937 | __ieee80211_tx_prepare(struct ieee80211_tx_data *tx, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 938 | struct sk_buff *skb, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 939 | struct net_device *dev) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 940 | { |
| 941 | struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 942 | struct ieee80211_hdr *hdr; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 943 | struct ieee80211_sub_if_data *sdata; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 944 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 945 | |
| 946 | int hdrlen; |
| 947 | |
| 948 | memset(tx, 0, sizeof(*tx)); |
| 949 | tx->skb = skb; |
| 950 | tx->dev = dev; /* use original interface */ |
| 951 | tx->local = local; |
| 952 | tx->sdata = IEEE80211_DEV_TO_SUB_IF(dev); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 953 | tx->channel = local->hw.conf.channel; |
Johannes Berg | 5854a32 | 2008-06-02 09:38:04 +0200 | [diff] [blame] | 954 | tx->rate_idx = -1; |
| 955 | tx->last_frag_rate_idx = -1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 956 | /* |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 957 | * Set this flag (used below to indicate "automatic fragmentation"), |
| 958 | * it will be cleared/left by radiotap as desired. |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 959 | */ |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 960 | tx->flags |= IEEE80211_TX_FRAGMENTED; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 961 | |
| 962 | /* process and remove the injection radiotap header */ |
| 963 | sdata = IEEE80211_DEV_TO_SUB_IF(dev); |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 964 | if (unlikely(sdata->vif.type == IEEE80211_IF_TYPE_MNTR)) { |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 965 | if (__ieee80211_parse_tx_radiotap(tx, skb) == TX_DROP) |
| 966 | return TX_DROP; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 967 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 968 | /* |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 969 | * __ieee80211_parse_tx_radiotap has now removed |
| 970 | * the radiotap header that was present and pre-filled |
| 971 | * 'tx' with tx control information. |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 972 | */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 973 | } |
| 974 | |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 975 | hdr = (struct ieee80211_hdr *) skb->data; |
| 976 | |
warmcat | 2433879 | 2007-09-14 11:10:25 -0400 | [diff] [blame] | 977 | tx->sta = sta_info_get(local, hdr->addr1); |
| 978 | tx->fc = le16_to_cpu(hdr->frame_control); |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 979 | |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 980 | if (is_multicast_ether_addr(hdr->addr1)) { |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 981 | tx->flags &= ~IEEE80211_TX_UNICAST; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 982 | info->flags |= IEEE80211_TX_CTL_NO_ACK; |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 983 | } else { |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 984 | tx->flags |= IEEE80211_TX_UNICAST; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 985 | info->flags &= ~IEEE80211_TX_CTL_NO_ACK; |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 986 | } |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 987 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 988 | if (tx->flags & IEEE80211_TX_FRAGMENTED) { |
| 989 | if ((tx->flags & IEEE80211_TX_UNICAST) && |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 990 | skb->len + FCS_LEN > local->fragmentation_threshold && |
Ron Rindjunsky | 8d5e0d5 | 2008-06-12 15:42:29 +0300 | [diff] [blame] | 991 | !local->ops->set_frag_threshold && |
| 992 | !(info->flags & IEEE80211_TX_CTL_AMPDU)) |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 993 | tx->flags |= IEEE80211_TX_FRAGMENTED; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 994 | else |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 995 | tx->flags &= ~IEEE80211_TX_FRAGMENTED; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 996 | } |
| 997 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 998 | if (!tx->sta) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 999 | info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 1000 | else if (test_and_clear_sta_flags(tx->sta, WLAN_STA_CLEAR_PS_FILT)) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1001 | info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 1002 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1003 | hdrlen = ieee80211_get_hdrlen(tx->fc); |
| 1004 | if (skb->len > hdrlen + sizeof(rfc1042_header) + 2) { |
| 1005 | u8 *pos = &skb->data[hdrlen + sizeof(rfc1042_header)]; |
| 1006 | tx->ethertype = (pos[0] << 8) | pos[1]; |
| 1007 | } |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1008 | info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1009 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 1010 | return TX_CONTINUE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1011 | } |
| 1012 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1013 | /* |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 1014 | * NB: @tx is uninitialised when passed in here |
| 1015 | */ |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1016 | static int ieee80211_tx_prepare(struct ieee80211_tx_data *tx, |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 1017 | struct sk_buff *skb, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1018 | struct net_device *mdev) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1019 | { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1020 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1021 | struct net_device *dev; |
| 1022 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1023 | dev = dev_get_by_index(&init_net, info->control.ifindex); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1024 | if (unlikely(dev && !is_ieee80211_device(dev, mdev))) { |
| 1025 | dev_put(dev); |
| 1026 | dev = NULL; |
| 1027 | } |
| 1028 | if (unlikely(!dev)) |
| 1029 | return -ENODEV; |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 1030 | /* initialises tx with control */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1031 | __ieee80211_tx_prepare(tx, skb, dev); |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1032 | dev_put(dev); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1033 | return 0; |
| 1034 | } |
| 1035 | |
| 1036 | static int __ieee80211_tx(struct ieee80211_local *local, struct sk_buff *skb, |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1037 | struct ieee80211_tx_data *tx) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1038 | { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1039 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1040 | int ret, i; |
| 1041 | |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1042 | if (netif_subqueue_stopped(local->mdev, skb)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1043 | return IEEE80211_TX_AGAIN; |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1044 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1045 | if (skb) { |
Johannes Berg | dd1cd4c | 2007-09-18 17:29:20 -0400 | [diff] [blame] | 1046 | ieee80211_dump_frame(wiphy_name(local->hw.wiphy), |
| 1047 | "TX to low-level driver", skb); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1048 | ret = local->ops->tx(local_to_hw(local), skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1049 | if (ret) |
| 1050 | return IEEE80211_TX_AGAIN; |
| 1051 | local->mdev->trans_start = jiffies; |
| 1052 | ieee80211_led_tx(local, 1); |
| 1053 | } |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1054 | if (tx->extra_frag) { |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1055 | for (i = 0; i < tx->num_extra_frag; i++) { |
| 1056 | if (!tx->extra_frag[i]) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1057 | continue; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1058 | info = IEEE80211_SKB_CB(tx->extra_frag[i]); |
| 1059 | info->flags &= ~(IEEE80211_TX_CTL_USE_RTS_CTS | |
| 1060 | IEEE80211_TX_CTL_USE_CTS_PROTECT | |
| 1061 | IEEE80211_TX_CTL_CLEAR_PS_FILT | |
| 1062 | IEEE80211_TX_CTL_FIRST_FRAGMENT); |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1063 | if (netif_subqueue_stopped(local->mdev, |
| 1064 | tx->extra_frag[i])) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1065 | return IEEE80211_TX_FRAG_AGAIN; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1066 | if (i == tx->num_extra_frag) { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1067 | info->tx_rate_idx = tx->last_frag_rate_idx; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 1068 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1069 | if (tx->flags & IEEE80211_TX_PROBE_LAST_FRAG) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1070 | info->flags |= |
| 1071 | IEEE80211_TX_CTL_RATE_CTRL_PROBE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1072 | else |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1073 | info->flags &= |
| 1074 | ~IEEE80211_TX_CTL_RATE_CTRL_PROBE; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1075 | } |
| 1076 | |
Johannes Berg | dd1cd4c | 2007-09-18 17:29:20 -0400 | [diff] [blame] | 1077 | ieee80211_dump_frame(wiphy_name(local->hw.wiphy), |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1078 | "TX to low-level driver", |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1079 | tx->extra_frag[i]); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1080 | ret = local->ops->tx(local_to_hw(local), |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1081 | tx->extra_frag[i]); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1082 | if (ret) |
| 1083 | return IEEE80211_TX_FRAG_AGAIN; |
| 1084 | local->mdev->trans_start = jiffies; |
| 1085 | ieee80211_led_tx(local, 1); |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1086 | tx->extra_frag[i] = NULL; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1087 | } |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1088 | kfree(tx->extra_frag); |
| 1089 | tx->extra_frag = NULL; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1090 | } |
| 1091 | return IEEE80211_TX_OK; |
| 1092 | } |
| 1093 | |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1094 | /* |
| 1095 | * Invoke TX handlers, return 0 on success and non-zero if the |
| 1096 | * frame was dropped or queued. |
| 1097 | */ |
| 1098 | static int invoke_tx_handlers(struct ieee80211_tx_data *tx) |
| 1099 | { |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1100 | struct sk_buff *skb = tx->skb; |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1101 | ieee80211_tx_result res = TX_DROP; |
| 1102 | int i; |
| 1103 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 1104 | #define CALL_TXH(txh) \ |
| 1105 | res = txh(tx); \ |
| 1106 | if (res != TX_CONTINUE) \ |
| 1107 | goto txh_done; |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1108 | |
Johannes Berg | d9e8a70 | 2008-06-30 15:10:44 +0200 | [diff] [blame] | 1109 | CALL_TXH(ieee80211_tx_h_check_assoc) |
| 1110 | CALL_TXH(ieee80211_tx_h_sequence) |
| 1111 | CALL_TXH(ieee80211_tx_h_ps_buf) |
| 1112 | CALL_TXH(ieee80211_tx_h_select_key) |
| 1113 | CALL_TXH(ieee80211_tx_h_michael_mic_add) |
| 1114 | CALL_TXH(ieee80211_tx_h_rate_ctrl) |
| 1115 | CALL_TXH(ieee80211_tx_h_misc) |
| 1116 | CALL_TXH(ieee80211_tx_h_fragment) |
| 1117 | /* handlers after fragment must be aware of tx info fragmentation! */ |
| 1118 | CALL_TXH(ieee80211_tx_h_encrypt) |
| 1119 | CALL_TXH(ieee80211_tx_h_calculate_duration) |
| 1120 | CALL_TXH(ieee80211_tx_h_stats) |
| 1121 | #undef CALL_TXH |
| 1122 | |
| 1123 | txh_done: |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1124 | if (unlikely(res == TX_DROP)) { |
Tomas Winkler | 5479d0e | 2008-06-28 03:15:03 +0300 | [diff] [blame] | 1125 | I802_DEBUG_INC(tx->local->tx_handlers_drop); |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1126 | dev_kfree_skb(skb); |
| 1127 | for (i = 0; i < tx->num_extra_frag; i++) |
| 1128 | if (tx->extra_frag[i]) |
| 1129 | dev_kfree_skb(tx->extra_frag[i]); |
| 1130 | kfree(tx->extra_frag); |
| 1131 | return -1; |
| 1132 | } else if (unlikely(res == TX_QUEUED)) { |
Tomas Winkler | 5479d0e | 2008-06-28 03:15:03 +0300 | [diff] [blame] | 1133 | I802_DEBUG_INC(tx->local->tx_handlers_queued); |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1134 | return -1; |
| 1135 | } |
| 1136 | |
| 1137 | return 0; |
| 1138 | } |
| 1139 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1140 | static int ieee80211_tx(struct net_device *dev, struct sk_buff *skb) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1141 | { |
| 1142 | struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); |
| 1143 | struct sta_info *sta; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1144 | struct ieee80211_tx_data tx; |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1145 | ieee80211_tx_result res_prepare; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1146 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1147 | int ret, i; |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1148 | u16 queue; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1149 | |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1150 | queue = skb_get_queue_mapping(skb); |
| 1151 | |
| 1152 | WARN_ON(test_bit(queue, local->queues_pending)); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1153 | |
| 1154 | if (unlikely(skb->len < 10)) { |
| 1155 | dev_kfree_skb(skb); |
| 1156 | return 0; |
| 1157 | } |
| 1158 | |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1159 | rcu_read_lock(); |
| 1160 | |
Johannes Berg | 58d4185 | 2007-09-26 17:53:18 +0200 | [diff] [blame] | 1161 | /* initialises tx */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1162 | res_prepare = __ieee80211_tx_prepare(&tx, skb, dev); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1163 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 1164 | if (res_prepare == TX_DROP) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1165 | dev_kfree_skb(skb); |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1166 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1167 | return 0; |
| 1168 | } |
| 1169 | |
| 1170 | sta = tx.sta; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1171 | tx.channel = local->hw.conf.channel; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1172 | info->band = tx.channel->band; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1173 | |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1174 | if (invoke_tx_handlers(&tx)) |
| 1175 | goto out; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1176 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1177 | retry: |
| 1178 | ret = __ieee80211_tx(local, skb, &tx); |
| 1179 | if (ret) { |
Johannes Berg | eefce91 | 2008-05-17 00:57:13 +0200 | [diff] [blame] | 1180 | struct ieee80211_tx_stored_packet *store; |
| 1181 | |
| 1182 | /* |
| 1183 | * Since there are no fragmented frames on A-MPDU |
| 1184 | * queues, there's no reason for a driver to reject |
| 1185 | * a frame there, warn and drop it. |
| 1186 | */ |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1187 | if (WARN_ON(queue >= ieee80211_num_regular_queues(&local->hw))) |
Johannes Berg | eefce91 | 2008-05-17 00:57:13 +0200 | [diff] [blame] | 1188 | goto drop; |
| 1189 | |
| 1190 | store = &local->pending_packet[queue]; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1191 | |
| 1192 | if (ret == IEEE80211_TX_FRAG_AGAIN) |
| 1193 | skb = NULL; |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1194 | set_bit(queue, local->queues_pending); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1195 | smp_mb(); |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1196 | /* |
| 1197 | * When the driver gets out of buffers during sending of |
| 1198 | * fragments and calls ieee80211_stop_queue, the netif |
| 1199 | * subqueue is stopped. There is, however, a small window |
| 1200 | * in which the PENDING bit is not yet set. If a buffer |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1201 | * gets available in that window (i.e. driver calls |
| 1202 | * ieee80211_wake_queue), we would end up with ieee80211_tx |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1203 | * called with the PENDING bit still set. Prevent this by |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1204 | * continuing transmitting here when that situation is |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1205 | * possible to have happened. |
| 1206 | */ |
| 1207 | if (!__netif_subqueue_stopped(local->mdev, queue)) { |
| 1208 | clear_bit(queue, local->queues_pending); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1209 | goto retry; |
| 1210 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1211 | store->skb = skb; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1212 | store->extra_frag = tx.extra_frag; |
| 1213 | store->num_extra_frag = tx.num_extra_frag; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 1214 | store->last_frag_rate_idx = tx.last_frag_rate_idx; |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1215 | store->last_frag_rate_ctrl_probe = |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1216 | !!(tx.flags & IEEE80211_TX_PROBE_LAST_FRAG); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1217 | } |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 1218 | out: |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 1219 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1220 | return 0; |
| 1221 | |
| 1222 | drop: |
| 1223 | if (skb) |
| 1224 | dev_kfree_skb(skb); |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1225 | for (i = 0; i < tx.num_extra_frag; i++) |
| 1226 | if (tx.extra_frag[i]) |
| 1227 | dev_kfree_skb(tx.extra_frag[i]); |
| 1228 | kfree(tx.extra_frag); |
Johannes Berg | d4e46a3 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 1229 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1230 | return 0; |
| 1231 | } |
| 1232 | |
| 1233 | /* device xmit handlers */ |
| 1234 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1235 | static int ieee80211_skb_resize(struct ieee80211_local *local, |
| 1236 | struct sk_buff *skb, |
| 1237 | int head_need, bool may_encrypt) |
| 1238 | { |
| 1239 | int tail_need = 0; |
| 1240 | |
| 1241 | /* |
| 1242 | * This could be optimised, devices that do full hardware |
| 1243 | * crypto (including TKIP MMIC) need no tailroom... But we |
| 1244 | * have no drivers for such devices currently. |
| 1245 | */ |
| 1246 | if (may_encrypt) { |
| 1247 | tail_need = IEEE80211_ENCRYPT_TAILROOM; |
| 1248 | tail_need -= skb_tailroom(skb); |
| 1249 | tail_need = max_t(int, tail_need, 0); |
| 1250 | } |
| 1251 | |
| 1252 | if (head_need || tail_need) { |
| 1253 | /* Sorry. Can't account for this any more */ |
| 1254 | skb_orphan(skb); |
| 1255 | } |
| 1256 | |
| 1257 | if (skb_header_cloned(skb)) |
| 1258 | I802_DEBUG_INC(local->tx_expand_skb_head_cloned); |
| 1259 | else |
| 1260 | I802_DEBUG_INC(local->tx_expand_skb_head); |
| 1261 | |
| 1262 | if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) { |
| 1263 | printk(KERN_DEBUG "%s: failed to reallocate TX buffer\n", |
| 1264 | wiphy_name(local->hw.wiphy)); |
| 1265 | return -ENOMEM; |
| 1266 | } |
| 1267 | |
| 1268 | /* update truesize too */ |
| 1269 | skb->truesize += head_need + tail_need; |
| 1270 | |
| 1271 | return 0; |
| 1272 | } |
| 1273 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1274 | int ieee80211_master_start_xmit(struct sk_buff *skb, |
| 1275 | struct net_device *dev) |
| 1276 | { |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1277 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1278 | struct net_device *odev = NULL; |
| 1279 | struct ieee80211_sub_if_data *osdata; |
| 1280 | int headroom; |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1281 | bool may_encrypt; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1282 | int ret; |
| 1283 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1284 | if (info->control.ifindex) |
| 1285 | odev = dev_get_by_index(&init_net, info->control.ifindex); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1286 | if (unlikely(odev && !is_ieee80211_device(odev, dev))) { |
| 1287 | dev_put(odev); |
| 1288 | odev = NULL; |
| 1289 | } |
| 1290 | if (unlikely(!odev)) { |
| 1291 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
| 1292 | printk(KERN_DEBUG "%s: Discarded packet with nonexistent " |
| 1293 | "originating device\n", dev->name); |
| 1294 | #endif |
| 1295 | dev_kfree_skb(skb); |
| 1296 | return 0; |
| 1297 | } |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1298 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1299 | osdata = IEEE80211_DEV_TO_SUB_IF(odev); |
| 1300 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1301 | may_encrypt = !(info->flags & IEEE80211_TX_CTL_DO_NOT_ENCRYPT); |
| 1302 | |
| 1303 | headroom = osdata->local->tx_headroom; |
| 1304 | if (may_encrypt) |
| 1305 | headroom += IEEE80211_ENCRYPT_HEADROOM; |
| 1306 | headroom -= skb_headroom(skb); |
| 1307 | headroom = max_t(int, 0, headroom); |
| 1308 | |
| 1309 | if (ieee80211_skb_resize(osdata->local, skb, headroom, may_encrypt)) { |
| 1310 | dev_kfree_skb(skb); |
| 1311 | dev_put(odev); |
| 1312 | return 0; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1313 | } |
| 1314 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1315 | info->control.vif = &osdata->vif; |
| 1316 | ret = ieee80211_tx(odev, skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1317 | dev_put(odev); |
| 1318 | |
| 1319 | return ret; |
| 1320 | } |
| 1321 | |
| 1322 | int ieee80211_monitor_start_xmit(struct sk_buff *skb, |
| 1323 | struct net_device *dev) |
| 1324 | { |
| 1325 | struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1326 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1327 | struct ieee80211_radiotap_header *prthdr = |
| 1328 | (struct ieee80211_radiotap_header *)skb->data; |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1329 | u16 len_rthdr; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1330 | |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1331 | /* check for not even having the fixed radiotap header part */ |
| 1332 | if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header))) |
| 1333 | goto fail; /* too short to be possibly valid */ |
| 1334 | |
| 1335 | /* is it a header version we can trust to find length from? */ |
| 1336 | if (unlikely(prthdr->it_version)) |
| 1337 | goto fail; /* only version 0 is supported */ |
| 1338 | |
| 1339 | /* then there must be a radiotap header with a length we can use */ |
| 1340 | len_rthdr = ieee80211_get_radiotap_len(skb->data); |
| 1341 | |
| 1342 | /* does the skb contain enough to deliver on the alleged length? */ |
| 1343 | if (unlikely(skb->len < len_rthdr)) |
| 1344 | goto fail; /* skb too short for claimed rt header extent */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1345 | |
| 1346 | skb->dev = local->mdev; |
| 1347 | |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1348 | /* needed because we set skb device to master */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1349 | info->control.ifindex = dev->ifindex; |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1350 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1351 | info->flags |= IEEE80211_TX_CTL_DO_NOT_ENCRYPT; |
Ivo van Doorn | b0a6717 | 2008-05-13 15:03:02 +0200 | [diff] [blame] | 1352 | /* Interfaces should always request a status report */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1353 | info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1354 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1355 | /* |
| 1356 | * fix up the pointers accounting for the radiotap |
| 1357 | * header still being in there. We are being given |
| 1358 | * a precooked IEEE80211 header so no need for |
| 1359 | * normal processing |
| 1360 | */ |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1361 | skb_set_mac_header(skb, len_rthdr); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1362 | /* |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1363 | * these are just fixed to the end of the rt area since we |
| 1364 | * don't have any better information and at this point, nobody cares |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1365 | */ |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1366 | skb_set_network_header(skb, len_rthdr); |
| 1367 | skb_set_transport_header(skb, len_rthdr); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1368 | |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1369 | /* pass the radiotap header up to the next stage intact */ |
| 1370 | dev_queue_xmit(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1371 | return NETDEV_TX_OK; |
Andy Green | 9b8a74e | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 1372 | |
| 1373 | fail: |
| 1374 | dev_kfree_skb(skb); |
| 1375 | return NETDEV_TX_OK; /* meaning, we dealt with the skb */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1376 | } |
| 1377 | |
| 1378 | /** |
| 1379 | * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type |
| 1380 | * subinterfaces (wlan#, WDS, and VLAN interfaces) |
| 1381 | * @skb: packet to be sent |
| 1382 | * @dev: incoming interface |
| 1383 | * |
| 1384 | * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will |
| 1385 | * not be freed, and caller is responsible for either retrying later or freeing |
| 1386 | * skb). |
| 1387 | * |
| 1388 | * This function takes in an Ethernet header and encapsulates it with suitable |
| 1389 | * IEEE 802.11 header based on which interface the packet is coming in. The |
| 1390 | * encapsulated packet will then be passed to master interface, wlan#.11, for |
| 1391 | * transmission (through low-level driver). |
| 1392 | */ |
| 1393 | int ieee80211_subif_start_xmit(struct sk_buff *skb, |
| 1394 | struct net_device *dev) |
| 1395 | { |
| 1396 | struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1397 | struct ieee80211_tx_info *info; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1398 | struct ieee80211_sub_if_data *sdata; |
| 1399 | int ret = 1, head_need; |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1400 | u16 ethertype, hdrlen, meshhdrlen = 0; |
| 1401 | __le16 fc; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1402 | struct ieee80211_hdr hdr; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1403 | struct ieee80211s_hdr mesh_hdr; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1404 | const u8 *encaps_data; |
| 1405 | int encaps_len, skip_header_bytes; |
Jiri Slaby | e8bf964 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1406 | int nh_pos, h_pos; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1407 | struct sta_info *sta; |
Johannes Berg | ce3edf6d0 | 2007-12-19 01:31:22 +0100 | [diff] [blame] | 1408 | u32 sta_flags = 0; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1409 | |
| 1410 | sdata = IEEE80211_DEV_TO_SUB_IF(dev); |
| 1411 | if (unlikely(skb->len < ETH_HLEN)) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1412 | ret = 0; |
| 1413 | goto fail; |
| 1414 | } |
| 1415 | |
| 1416 | nh_pos = skb_network_header(skb) - skb->data; |
| 1417 | h_pos = skb_transport_header(skb) - skb->data; |
| 1418 | |
| 1419 | /* convert Ethernet header to proper 802.11 header (based on |
| 1420 | * operation mode) */ |
| 1421 | ethertype = (skb->data[12] << 8) | skb->data[13]; |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1422 | fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1423 | |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 1424 | switch (sdata->vif.type) { |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1425 | case IEEE80211_IF_TYPE_AP: |
| 1426 | case IEEE80211_IF_TYPE_VLAN: |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1427 | fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1428 | /* DA BSSID SA */ |
| 1429 | memcpy(hdr.addr1, skb->data, ETH_ALEN); |
| 1430 | memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN); |
| 1431 | memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN); |
| 1432 | hdrlen = 24; |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1433 | break; |
| 1434 | case IEEE80211_IF_TYPE_WDS: |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1435 | fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1436 | /* RA TA DA SA */ |
| 1437 | memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN); |
| 1438 | memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN); |
| 1439 | memcpy(hdr.addr3, skb->data, ETH_ALEN); |
| 1440 | memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN); |
| 1441 | hdrlen = 30; |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1442 | break; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1443 | #ifdef CONFIG_MAC80211_MESH |
| 1444 | case IEEE80211_IF_TYPE_MESH_POINT: |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1445 | fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1446 | /* RA TA DA SA */ |
| 1447 | if (is_multicast_ether_addr(skb->data)) |
| 1448 | memcpy(hdr.addr1, skb->data, ETH_ALEN); |
| 1449 | else if (mesh_nexthop_lookup(hdr.addr1, skb, dev)) |
| 1450 | return 0; |
| 1451 | memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN); |
| 1452 | memcpy(hdr.addr3, skb->data, ETH_ALEN); |
| 1453 | memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN); |
| 1454 | if (skb->pkt_type == PACKET_OTHERHOST) { |
| 1455 | /* Forwarded frame, keep mesh ttl and seqnum */ |
| 1456 | struct ieee80211s_hdr *prev_meshhdr; |
| 1457 | prev_meshhdr = ((struct ieee80211s_hdr *)skb->cb); |
| 1458 | meshhdrlen = ieee80211_get_mesh_hdrlen(prev_meshhdr); |
| 1459 | memcpy(&mesh_hdr, prev_meshhdr, meshhdrlen); |
| 1460 | sdata->u.sta.mshstats.fwded_frames++; |
| 1461 | } else { |
| 1462 | if (!sdata->u.sta.mshcfg.dot11MeshTTL) { |
| 1463 | /* Do not send frames with mesh_ttl == 0 */ |
| 1464 | sdata->u.sta.mshstats.dropped_frames_ttl++; |
| 1465 | ret = 0; |
| 1466 | goto fail; |
| 1467 | } |
| 1468 | meshhdrlen = ieee80211_new_mesh_header(&mesh_hdr, |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1469 | sdata); |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1470 | } |
| 1471 | hdrlen = 30; |
| 1472 | break; |
| 1473 | #endif |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1474 | case IEEE80211_IF_TYPE_STA: |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1475 | fc |= cpu_to_le16(IEEE80211_FCTL_TODS); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1476 | /* BSSID SA DA */ |
| 1477 | memcpy(hdr.addr1, sdata->u.sta.bssid, ETH_ALEN); |
| 1478 | memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); |
| 1479 | memcpy(hdr.addr3, skb->data, ETH_ALEN); |
| 1480 | hdrlen = 24; |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1481 | break; |
| 1482 | case IEEE80211_IF_TYPE_IBSS: |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1483 | /* DA SA BSSID */ |
| 1484 | memcpy(hdr.addr1, skb->data, ETH_ALEN); |
| 1485 | memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN); |
| 1486 | memcpy(hdr.addr3, sdata->u.sta.bssid, ETH_ALEN); |
| 1487 | hdrlen = 24; |
Johannes Berg | cf96683 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1488 | break; |
| 1489 | default: |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1490 | ret = 0; |
| 1491 | goto fail; |
| 1492 | } |
| 1493 | |
Johannes Berg | 7d185b8 | 2008-01-28 17:11:43 +0100 | [diff] [blame] | 1494 | /* |
| 1495 | * There's no need to try to look up the destination |
| 1496 | * if it is a multicast address (which can only happen |
| 1497 | * in AP mode) |
| 1498 | */ |
| 1499 | if (!is_multicast_ether_addr(hdr.addr1)) { |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1500 | rcu_read_lock(); |
Johannes Berg | 7d185b8 | 2008-01-28 17:11:43 +0100 | [diff] [blame] | 1501 | sta = sta_info_get(local, hdr.addr1); |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1502 | if (sta) |
Johannes Berg | 07346f81 | 2008-05-03 01:02:02 +0200 | [diff] [blame] | 1503 | sta_flags = get_sta_flags(sta); |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1504 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1505 | } |
| 1506 | |
Johannes Berg | 3434fbd | 2008-05-03 00:59:37 +0200 | [diff] [blame] | 1507 | /* receiver and we are QoS enabled, use a QoS type frame */ |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1508 | if (sta_flags & WLAN_STA_WME && |
| 1509 | ieee80211_num_regular_queues(&local->hw) >= 4) { |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1510 | fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA); |
Johannes Berg | ce3edf6d0 | 2007-12-19 01:31:22 +0100 | [diff] [blame] | 1511 | hdrlen += 2; |
| 1512 | } |
| 1513 | |
| 1514 | /* |
Johannes Berg | 238814f | 2008-01-28 17:19:37 +0100 | [diff] [blame] | 1515 | * Drop unicast frames to unauthorised stations unless they are |
| 1516 | * EAPOL frames from the local station. |
Johannes Berg | ce3edf6d0 | 2007-12-19 01:31:22 +0100 | [diff] [blame] | 1517 | */ |
Johannes Berg | 238814f | 2008-01-28 17:19:37 +0100 | [diff] [blame] | 1518 | if (unlikely(!is_multicast_ether_addr(hdr.addr1) && |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1519 | !(sta_flags & WLAN_STA_AUTHORIZED) && |
| 1520 | !(ethertype == ETH_P_PAE && |
Johannes Berg | ce3edf6d0 | 2007-12-19 01:31:22 +0100 | [diff] [blame] | 1521 | compare_ether_addr(dev->dev_addr, |
| 1522 | skb->data + ETH_ALEN) == 0))) { |
| 1523 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
| 1524 | DECLARE_MAC_BUF(mac); |
| 1525 | |
| 1526 | if (net_ratelimit()) |
| 1527 | printk(KERN_DEBUG "%s: dropped frame to %s" |
| 1528 | " (unauthorized port)\n", dev->name, |
| 1529 | print_mac(mac, hdr.addr1)); |
| 1530 | #endif |
| 1531 | |
| 1532 | I802_DEBUG_INC(local->tx_handlers_drop_unauth_port); |
| 1533 | |
| 1534 | ret = 0; |
| 1535 | goto fail; |
| 1536 | } |
| 1537 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1538 | hdr.frame_control = fc; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1539 | hdr.duration_id = 0; |
| 1540 | hdr.seq_ctrl = 0; |
| 1541 | |
| 1542 | skip_header_bytes = ETH_HLEN; |
| 1543 | if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) { |
| 1544 | encaps_data = bridge_tunnel_header; |
| 1545 | encaps_len = sizeof(bridge_tunnel_header); |
| 1546 | skip_header_bytes -= 2; |
| 1547 | } else if (ethertype >= 0x600) { |
| 1548 | encaps_data = rfc1042_header; |
| 1549 | encaps_len = sizeof(rfc1042_header); |
| 1550 | skip_header_bytes -= 2; |
| 1551 | } else { |
| 1552 | encaps_data = NULL; |
| 1553 | encaps_len = 0; |
| 1554 | } |
| 1555 | |
| 1556 | skb_pull(skb, skip_header_bytes); |
| 1557 | nh_pos -= skip_header_bytes; |
| 1558 | h_pos -= skip_header_bytes; |
| 1559 | |
| 1560 | /* TODO: implement support for fragments so that there is no need to |
| 1561 | * reallocate and copy payload; it might be enough to support one |
| 1562 | * extra fragment that would be copied in the beginning of the frame |
| 1563 | * data.. anyway, it would be nice to include this into skb structure |
| 1564 | * somehow |
| 1565 | * |
| 1566 | * There are few options for this: |
| 1567 | * use skb->cb as an extra space for 802.11 header |
| 1568 | * allocate new buffer if not enough headroom |
| 1569 | * make sure that there is enough headroom in every skb by increasing |
| 1570 | * build in headroom in __dev_alloc_skb() (linux/skbuff.h) and |
| 1571 | * alloc_skb() (net/core/skbuff.c) |
| 1572 | */ |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1573 | head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1574 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1575 | /* |
| 1576 | * So we need to modify the skb header and hence need a copy of |
| 1577 | * that. The head_need variable above doesn't, so far, include |
| 1578 | * the needed header space that we don't need right away. If we |
| 1579 | * can, then we don't reallocate right now but only after the |
| 1580 | * frame arrives at the master device (if it does...) |
| 1581 | * |
| 1582 | * If we cannot, however, then we will reallocate to include all |
| 1583 | * the ever needed space. Also, if we need to reallocate it anyway, |
| 1584 | * make it big enough for everything we may ever need. |
| 1585 | */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1586 | |
David S. Miller | 3a5be7d | 2008-06-18 01:19:51 -0700 | [diff] [blame] | 1587 | if (head_need > 0 || skb_cloned(skb)) { |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 1588 | head_need += IEEE80211_ENCRYPT_HEADROOM; |
| 1589 | head_need += local->tx_headroom; |
| 1590 | head_need = max_t(int, 0, head_need); |
| 1591 | if (ieee80211_skb_resize(local, skb, head_need, true)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1592 | goto fail; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1593 | } |
| 1594 | |
| 1595 | if (encaps_data) { |
| 1596 | memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len); |
| 1597 | nh_pos += encaps_len; |
| 1598 | h_pos += encaps_len; |
| 1599 | } |
Johannes Berg | c29b9b9 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 1600 | |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1601 | if (meshhdrlen > 0) { |
| 1602 | memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen); |
| 1603 | nh_pos += meshhdrlen; |
| 1604 | h_pos += meshhdrlen; |
| 1605 | } |
| 1606 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1607 | if (ieee80211_is_data_qos(fc)) { |
Johannes Berg | c29b9b9 | 2007-09-14 11:10:24 -0400 | [diff] [blame] | 1608 | __le16 *qos_control; |
| 1609 | |
| 1610 | qos_control = (__le16*) skb_push(skb, 2); |
| 1611 | memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2); |
| 1612 | /* |
| 1613 | * Maybe we could actually set some fields here, for now just |
| 1614 | * initialise to zero to indicate no special operation. |
| 1615 | */ |
| 1616 | *qos_control = 0; |
| 1617 | } else |
| 1618 | memcpy(skb_push(skb, hdrlen), &hdr, hdrlen); |
| 1619 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1620 | nh_pos += hdrlen; |
| 1621 | h_pos += hdrlen; |
| 1622 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1623 | info = IEEE80211_SKB_CB(skb); |
| 1624 | memset(info, 0, sizeof(*info)); |
| 1625 | info->control.ifindex = dev->ifindex; |
Johannes Berg | 678f5f71 | 2007-12-19 01:31:23 +0100 | [diff] [blame] | 1626 | if (ethertype == ETH_P_PAE) |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1627 | info->flags |= IEEE80211_TX_CTL_EAPOL_FRAME; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1628 | |
Ivo van Doorn | b0a6717 | 2008-05-13 15:03:02 +0200 | [diff] [blame] | 1629 | /* Interfaces should always request a status report */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1630 | info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS; |
Ivo van Doorn | b0a6717 | 2008-05-13 15:03:02 +0200 | [diff] [blame] | 1631 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1632 | skb->dev = local->mdev; |
Stephen Hemminger | 68aae11 | 2007-08-24 11:29:34 -0700 | [diff] [blame] | 1633 | dev->stats.tx_packets++; |
| 1634 | dev->stats.tx_bytes += skb->len; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1635 | |
| 1636 | /* Update skb pointers to various headers since this modified frame |
| 1637 | * is going to go through Linux networking code that may potentially |
| 1638 | * need things like pointer to IP header. */ |
| 1639 | skb_set_mac_header(skb, 0); |
| 1640 | skb_set_network_header(skb, nh_pos); |
| 1641 | skb_set_transport_header(skb, h_pos); |
| 1642 | |
| 1643 | dev->trans_start = jiffies; |
| 1644 | dev_queue_xmit(skb); |
| 1645 | |
| 1646 | return 0; |
| 1647 | |
| 1648 | fail: |
| 1649 | if (!ret) |
| 1650 | dev_kfree_skb(skb); |
| 1651 | |
| 1652 | return ret; |
| 1653 | } |
| 1654 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1655 | |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1656 | /* |
| 1657 | * ieee80211_clear_tx_pending may not be called in a context where |
| 1658 | * it is possible that it packets could come in again. |
| 1659 | */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1660 | void ieee80211_clear_tx_pending(struct ieee80211_local *local) |
| 1661 | { |
| 1662 | int i, j; |
| 1663 | struct ieee80211_tx_stored_packet *store; |
| 1664 | |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1665 | for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) { |
| 1666 | if (!test_bit(i, local->queues_pending)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1667 | continue; |
| 1668 | store = &local->pending_packet[i]; |
| 1669 | kfree_skb(store->skb); |
| 1670 | for (j = 0; j < store->num_extra_frag; j++) |
| 1671 | kfree_skb(store->extra_frag[j]); |
| 1672 | kfree(store->extra_frag); |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1673 | clear_bit(i, local->queues_pending); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1674 | } |
| 1675 | } |
| 1676 | |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1677 | /* |
| 1678 | * Transmit all pending packets. Called from tasklet, locks master device |
| 1679 | * TX lock so that no new packets can come in. |
| 1680 | */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1681 | void ieee80211_tx_pending(unsigned long data) |
| 1682 | { |
| 1683 | struct ieee80211_local *local = (struct ieee80211_local *)data; |
| 1684 | struct net_device *dev = local->mdev; |
| 1685 | struct ieee80211_tx_stored_packet *store; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1686 | struct ieee80211_tx_data tx; |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1687 | int i, ret; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1688 | |
| 1689 | netif_tx_lock_bh(dev); |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1690 | for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) { |
| 1691 | /* Check that this queue is ok */ |
| 1692 | if (__netif_subqueue_stopped(local->mdev, i)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1693 | continue; |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1694 | |
| 1695 | if (!test_bit(i, local->queues_pending)) { |
| 1696 | ieee80211_wake_queue(&local->hw, i); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1697 | continue; |
| 1698 | } |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1699 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1700 | store = &local->pending_packet[i]; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1701 | tx.extra_frag = store->extra_frag; |
| 1702 | tx.num_extra_frag = store->num_extra_frag; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 1703 | tx.last_frag_rate_idx = store->last_frag_rate_idx; |
Jiri Slaby | badffb7 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 1704 | tx.flags = 0; |
| 1705 | if (store->last_frag_rate_ctrl_probe) |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1706 | tx.flags |= IEEE80211_TX_PROBE_LAST_FRAG; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1707 | ret = __ieee80211_tx(local, store->skb, &tx); |
| 1708 | if (ret) { |
| 1709 | if (ret == IEEE80211_TX_FRAG_AGAIN) |
| 1710 | store->skb = NULL; |
| 1711 | } else { |
Johannes Berg | e253008 | 2008-05-17 00:57:14 +0200 | [diff] [blame] | 1712 | clear_bit(i, local->queues_pending); |
| 1713 | ieee80211_wake_queue(&local->hw, i); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1714 | } |
| 1715 | } |
| 1716 | netif_tx_unlock_bh(dev); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1717 | } |
| 1718 | |
| 1719 | /* functions for drivers to get certain frames */ |
| 1720 | |
| 1721 | static void ieee80211_beacon_add_tim(struct ieee80211_local *local, |
| 1722 | struct ieee80211_if_ap *bss, |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1723 | struct sk_buff *skb, |
| 1724 | struct beacon_data *beacon) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1725 | { |
| 1726 | u8 *pos, *tim; |
| 1727 | int aid0 = 0; |
| 1728 | int i, have_bits = 0, n1, n2; |
| 1729 | |
| 1730 | /* Generate bitmap for TIM only if there are any STAs in power save |
| 1731 | * mode. */ |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1732 | if (atomic_read(&bss->num_sta_ps) > 0) |
| 1733 | /* in the hope that this is faster than |
| 1734 | * checking byte-for-byte */ |
| 1735 | have_bits = !bitmap_empty((unsigned long*)bss->tim, |
| 1736 | IEEE80211_MAX_AID+1); |
| 1737 | |
| 1738 | if (bss->dtim_count == 0) |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1739 | bss->dtim_count = beacon->dtim_period - 1; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1740 | else |
| 1741 | bss->dtim_count--; |
| 1742 | |
| 1743 | tim = pos = (u8 *) skb_put(skb, 6); |
| 1744 | *pos++ = WLAN_EID_TIM; |
| 1745 | *pos++ = 4; |
| 1746 | *pos++ = bss->dtim_count; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1747 | *pos++ = beacon->dtim_period; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1748 | |
| 1749 | if (bss->dtim_count == 0 && !skb_queue_empty(&bss->ps_bc_buf)) |
| 1750 | aid0 = 1; |
| 1751 | |
| 1752 | if (have_bits) { |
| 1753 | /* Find largest even number N1 so that bits numbered 1 through |
| 1754 | * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits |
| 1755 | * (N2 + 1) x 8 through 2007 are 0. */ |
| 1756 | n1 = 0; |
| 1757 | for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) { |
| 1758 | if (bss->tim[i]) { |
| 1759 | n1 = i & 0xfe; |
| 1760 | break; |
| 1761 | } |
| 1762 | } |
| 1763 | n2 = n1; |
| 1764 | for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) { |
| 1765 | if (bss->tim[i]) { |
| 1766 | n2 = i; |
| 1767 | break; |
| 1768 | } |
| 1769 | } |
| 1770 | |
| 1771 | /* Bitmap control */ |
| 1772 | *pos++ = n1 | aid0; |
| 1773 | /* Part Virt Bitmap */ |
| 1774 | memcpy(pos, bss->tim + n1, n2 - n1 + 1); |
| 1775 | |
| 1776 | tim[1] = n2 - n1 + 4; |
| 1777 | skb_put(skb, n2 - n1); |
| 1778 | } else { |
| 1779 | *pos++ = aid0; /* Bitmap control */ |
| 1780 | *pos++ = 0; /* Part Virt Bitmap */ |
| 1781 | } |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1782 | } |
| 1783 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1784 | struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1785 | struct ieee80211_vif *vif) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1786 | { |
| 1787 | struct ieee80211_local *local = hw_to_local(hw); |
| 1788 | struct sk_buff *skb; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1789 | struct ieee80211_tx_info *info; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1790 | struct net_device *bdev; |
| 1791 | struct ieee80211_sub_if_data *sdata = NULL; |
| 1792 | struct ieee80211_if_ap *ap = NULL; |
Mattias Nissler | 1abbe49 | 2007-12-20 13:50:07 +0100 | [diff] [blame] | 1793 | struct rate_selection rsel; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1794 | struct beacon_data *beacon; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 1795 | struct ieee80211_supported_band *sband; |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1796 | struct ieee80211_mgmt *mgmt; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1797 | int *num_beacons; |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1798 | bool err = true; |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 1799 | enum ieee80211_band band = local->hw.conf.channel->band; |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1800 | u8 *pos; |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 1801 | |
Johannes Berg | 2e92e6f | 2008-05-15 12:55:27 +0200 | [diff] [blame] | 1802 | sband = local->hw.wiphy->bands[band]; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1803 | |
| 1804 | rcu_read_lock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1805 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1806 | sdata = vif_to_sdata(vif); |
| 1807 | bdev = sdata->dev; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1808 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1809 | if (sdata->vif.type == IEEE80211_IF_TYPE_AP) { |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1810 | ap = &sdata->u.ap; |
| 1811 | beacon = rcu_dereference(ap->beacon); |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1812 | if (ap && beacon) { |
| 1813 | /* |
| 1814 | * headroom, head length, |
| 1815 | * tail length and maximum TIM length |
| 1816 | */ |
| 1817 | skb = dev_alloc_skb(local->tx_headroom + |
| 1818 | beacon->head_len + |
| 1819 | beacon->tail_len + 256); |
| 1820 | if (!skb) |
| 1821 | goto out; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1822 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1823 | skb_reserve(skb, local->tx_headroom); |
| 1824 | memcpy(skb_put(skb, beacon->head_len), beacon->head, |
| 1825 | beacon->head_len); |
| 1826 | |
| 1827 | ieee80211_include_sequence(sdata, |
| 1828 | (struct ieee80211_hdr *)skb->data); |
| 1829 | |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 1830 | /* |
| 1831 | * Not very nice, but we want to allow the driver to call |
| 1832 | * ieee80211_beacon_get() as a response to the set_tim() |
| 1833 | * callback. That, however, is already invoked under the |
| 1834 | * sta_lock to guarantee consistent and race-free update |
| 1835 | * of the tim bitmap in mac80211 and the driver. |
| 1836 | */ |
| 1837 | if (local->tim_in_locked_section) { |
| 1838 | ieee80211_beacon_add_tim(local, ap, skb, beacon); |
| 1839 | } else { |
| 1840 | unsigned long flags; |
| 1841 | |
| 1842 | spin_lock_irqsave(&local->sta_lock, flags); |
| 1843 | ieee80211_beacon_add_tim(local, ap, skb, beacon); |
| 1844 | spin_unlock_irqrestore(&local->sta_lock, flags); |
| 1845 | } |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1846 | |
| 1847 | if (beacon->tail) |
| 1848 | memcpy(skb_put(skb, beacon->tail_len), |
| 1849 | beacon->tail, beacon->tail_len); |
| 1850 | |
| 1851 | num_beacons = &ap->num_beacons; |
| 1852 | |
| 1853 | err = false; |
| 1854 | } |
| 1855 | } else if (ieee80211_vif_is_mesh(&sdata->vif)) { |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1856 | /* headroom, head length, tail length and maximum TIM length */ |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1857 | skb = dev_alloc_skb(local->tx_headroom + 400); |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1858 | if (!skb) |
| 1859 | goto out; |
| 1860 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1861 | skb_reserve(skb, local->hw.extra_tx_headroom); |
| 1862 | mgmt = (struct ieee80211_mgmt *) |
| 1863 | skb_put(skb, 24 + sizeof(mgmt->u.beacon)); |
| 1864 | memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon)); |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1865 | mgmt->frame_control = |
| 1866 | cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON); |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1867 | memset(mgmt->da, 0xff, ETH_ALEN); |
| 1868 | memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN); |
| 1869 | /* BSSID is left zeroed, wildcard value */ |
| 1870 | mgmt->u.beacon.beacon_int = |
| 1871 | cpu_to_le16(local->hw.conf.beacon_int); |
| 1872 | mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */ |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1873 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1874 | pos = skb_put(skb, 2); |
| 1875 | *pos++ = WLAN_EID_SSID; |
| 1876 | *pos++ = 0x0; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1877 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1878 | mesh_mgmt_ies_add(skb, sdata->dev); |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1879 | |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1880 | num_beacons = &sdata->u.sta.num_beacons; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1881 | |
Johannes Berg | 902acc7 | 2008-02-23 15:17:19 +0100 | [diff] [blame] | 1882 | err = false; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1883 | } |
| 1884 | |
| 1885 | if (err) { |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1886 | #ifdef CONFIG_MAC80211_VERBOSE_DEBUG |
| 1887 | if (net_ratelimit()) |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1888 | printk(KERN_DEBUG "no beacon data avail for %s\n", |
| 1889 | bdev->name); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1890 | #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */ |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1891 | skb = NULL; |
| 1892 | goto out; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1893 | } |
| 1894 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1895 | info = IEEE80211_SKB_CB(skb); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1896 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1897 | info->band = band; |
| 1898 | rate_control_get_rate(local->mdev, sband, skb, &rsel); |
| 1899 | |
| 1900 | if (unlikely(rsel.rate_idx < 0)) { |
| 1901 | if (net_ratelimit()) { |
| 1902 | printk(KERN_DEBUG "%s: ieee80211_beacon_get: " |
| 1903 | "no rate found\n", |
| 1904 | wiphy_name(local->hw.wiphy)); |
| 1905 | } |
| 1906 | dev_kfree_skb(skb); |
| 1907 | skb = NULL; |
| 1908 | goto out; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1909 | } |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1910 | |
| 1911 | info->control.vif = vif; |
| 1912 | info->tx_rate_idx = rsel.rate_idx; |
| 1913 | if (sdata->bss_conf.use_short_preamble && |
| 1914 | sband->bitrates[rsel.rate_idx].flags & IEEE80211_RATE_SHORT_PREAMBLE) |
| 1915 | info->flags |= IEEE80211_TX_CTL_SHORT_PREAMBLE; |
| 1916 | info->antenna_sel_tx = local->hw.conf.antenna_sel_tx; |
| 1917 | info->flags |= IEEE80211_TX_CTL_NO_ACK; |
| 1918 | info->flags |= IEEE80211_TX_CTL_DO_NOT_ENCRYPT; |
| 1919 | info->control.retry_limit = 1; |
| 1920 | info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT; |
Luis Carlos Cobo | 33b64eb | 2008-02-23 15:17:10 +0100 | [diff] [blame] | 1921 | (*num_beacons)++; |
| 1922 | out: |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1923 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1924 | return skb; |
| 1925 | } |
| 1926 | EXPORT_SYMBOL(ieee80211_beacon_get); |
| 1927 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1928 | void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1929 | const void *frame, size_t frame_len, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1930 | const struct ieee80211_tx_info *frame_txctl, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1931 | struct ieee80211_rts *rts) |
| 1932 | { |
| 1933 | const struct ieee80211_hdr *hdr = frame; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1934 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1935 | rts->frame_control = |
| 1936 | cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS); |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1937 | rts->duration = ieee80211_rts_duration(hw, vif, frame_len, |
| 1938 | frame_txctl); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1939 | memcpy(rts->ra, hdr->addr1, sizeof(rts->ra)); |
| 1940 | memcpy(rts->ta, hdr->addr2, sizeof(rts->ta)); |
| 1941 | } |
| 1942 | EXPORT_SYMBOL(ieee80211_rts_get); |
| 1943 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1944 | void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1945 | const void *frame, size_t frame_len, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1946 | const struct ieee80211_tx_info *frame_txctl, |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1947 | struct ieee80211_cts *cts) |
| 1948 | { |
| 1949 | const struct ieee80211_hdr *hdr = frame; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1950 | |
Harvey Harrison | 065e9605 | 2008-06-22 16:45:27 -0700 | [diff] [blame] | 1951 | cts->frame_control = |
| 1952 | cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS); |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1953 | cts->duration = ieee80211_ctstoself_duration(hw, vif, |
| 1954 | frame_len, frame_txctl); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1955 | memcpy(cts->ra, hdr->addr1, sizeof(cts->ra)); |
| 1956 | } |
| 1957 | EXPORT_SYMBOL(ieee80211_ctstoself_get); |
| 1958 | |
| 1959 | struct sk_buff * |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1960 | ieee80211_get_buffered_bc(struct ieee80211_hw *hw, |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1961 | struct ieee80211_vif *vif) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1962 | { |
| 1963 | struct ieee80211_local *local = hw_to_local(hw); |
Tomas Winkler | 747cf5e | 2008-05-27 17:50:51 +0300 | [diff] [blame] | 1964 | struct sk_buff *skb = NULL; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1965 | struct sta_info *sta; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 1966 | struct ieee80211_tx_data tx; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1967 | struct net_device *bdev; |
| 1968 | struct ieee80211_sub_if_data *sdata; |
| 1969 | struct ieee80211_if_ap *bss = NULL; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1970 | struct beacon_data *beacon; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1971 | struct ieee80211_tx_info *info; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1972 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 1973 | sdata = vif_to_sdata(vif); |
| 1974 | bdev = sdata->dev; |
Tomas Winkler | 747cf5e | 2008-05-27 17:50:51 +0300 | [diff] [blame] | 1975 | bss = &sdata->u.ap; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1976 | |
| 1977 | if (!bss) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1978 | return NULL; |
| 1979 | |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1980 | rcu_read_lock(); |
| 1981 | beacon = rcu_dereference(bss->beacon); |
| 1982 | |
Tomas Winkler | 747cf5e | 2008-05-27 17:50:51 +0300 | [diff] [blame] | 1983 | if (sdata->vif.type != IEEE80211_IF_TYPE_AP || !beacon || !beacon->head) |
| 1984 | goto out; |
Johannes Berg | 5dfdaf5 | 2007-12-19 02:03:33 +0100 | [diff] [blame] | 1985 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1986 | if (bss->dtim_count != 0) |
Tomas Winkler | 747cf5e | 2008-05-27 17:50:51 +0300 | [diff] [blame] | 1987 | goto out; /* send buffered bc/mc only after DTIM beacon */ |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 1988 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1989 | while (1) { |
| 1990 | skb = skb_dequeue(&bss->ps_bc_buf); |
| 1991 | if (!skb) |
Tomas Winkler | 747cf5e | 2008-05-27 17:50:51 +0300 | [diff] [blame] | 1992 | goto out; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 1993 | local->total_ps_buffered--; |
| 1994 | |
| 1995 | if (!skb_queue_empty(&bss->ps_bc_buf) && skb->len >= 2) { |
| 1996 | struct ieee80211_hdr *hdr = |
| 1997 | (struct ieee80211_hdr *) skb->data; |
| 1998 | /* more buffered multicast/broadcast frames ==> set |
| 1999 | * MoreData flag in IEEE 802.11 header to inform PS |
| 2000 | * STAs */ |
| 2001 | hdr->frame_control |= |
| 2002 | cpu_to_le16(IEEE80211_FCTL_MOREDATA); |
| 2003 | } |
| 2004 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 2005 | if (!ieee80211_tx_prepare(&tx, skb, local->mdev)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 2006 | break; |
| 2007 | dev_kfree_skb_any(skb); |
| 2008 | } |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 2009 | |
| 2010 | info = IEEE80211_SKB_CB(skb); |
| 2011 | |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 2012 | sta = tx.sta; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 2013 | tx.flags |= IEEE80211_TX_PS_BUFFERED; |
| 2014 | tx.channel = local->hw.conf.channel; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 2015 | info->band = tx.channel->band; |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 2016 | |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 2017 | if (invoke_tx_handlers(&tx)) |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 2018 | skb = NULL; |
Johannes Berg | 97b045d | 2008-06-20 01:22:30 +0200 | [diff] [blame] | 2019 | out: |
Johannes Berg | d0709a6 | 2008-02-25 16:27:46 +0100 | [diff] [blame] | 2020 | rcu_read_unlock(); |
Johannes Berg | e2ebc74 | 2007-07-27 15:43:22 +0200 | [diff] [blame] | 2021 | |
| 2022 | return skb; |
| 2023 | } |
| 2024 | EXPORT_SYMBOL(ieee80211_get_buffered_bc); |