Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +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 | * utilities for mac80211 |
| 12 | */ |
| 13 | |
| 14 | #include <net/mac80211.h> |
| 15 | #include <linux/netdevice.h> |
| 16 | #include <linux/types.h> |
| 17 | #include <linux/slab.h> |
| 18 | #include <linux/skbuff.h> |
| 19 | #include <linux/etherdevice.h> |
| 20 | #include <linux/if_arp.h> |
| 21 | #include <linux/wireless.h> |
| 22 | #include <linux/bitmap.h> |
Eric W. Biederman | 881d966 | 2007-09-17 11:56:21 -0700 | [diff] [blame] | 23 | #include <net/net_namespace.h> |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 24 | #include <net/cfg80211.h> |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 25 | #include <net/rtnetlink.h> |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 26 | |
| 27 | #include "ieee80211_i.h" |
Johannes Berg | 2c8dccc | 2008-04-08 15:14:40 -0400 | [diff] [blame] | 28 | #include "rate.h" |
Luis Carlos Cobo | ee38585 | 2008-02-23 15:17:11 +0100 | [diff] [blame] | 29 | #include "mesh.h" |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 30 | #include "wme.h" |
| 31 | |
| 32 | /* privid for wiphys to determine whether they belong to us or not */ |
| 33 | void *mac80211_wiphy_privid = &mac80211_wiphy_privid; |
| 34 | |
| 35 | /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ |
| 36 | /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ |
| 37 | const unsigned char rfc1042_header[] = |
| 38 | { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; |
| 39 | |
| 40 | /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ |
| 41 | const unsigned char bridge_tunnel_header[] = |
| 42 | { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; |
| 43 | |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 44 | |
Ron Rindjunsky | 7136471 | 2007-12-25 17:00:36 +0200 | [diff] [blame] | 45 | u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, |
| 46 | enum ieee80211_if_types type) |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 47 | { |
| 48 | u16 fc; |
| 49 | |
Ron Rindjunsky | 98f0b0a | 2007-12-18 17:23:53 +0200 | [diff] [blame] | 50 | /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ |
| 51 | if (len < 16) |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 52 | return NULL; |
| 53 | |
| 54 | fc = le16_to_cpu(hdr->frame_control); |
| 55 | |
| 56 | switch (fc & IEEE80211_FCTL_FTYPE) { |
| 57 | case IEEE80211_FTYPE_DATA: |
Ron Rindjunsky | 98f0b0a | 2007-12-18 17:23:53 +0200 | [diff] [blame] | 58 | if (len < 24) /* drop incorrect hdr len (data) */ |
| 59 | return NULL; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 60 | switch (fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) { |
| 61 | case IEEE80211_FCTL_TODS: |
| 62 | return hdr->addr1; |
| 63 | case (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS): |
| 64 | return NULL; |
| 65 | case IEEE80211_FCTL_FROMDS: |
| 66 | return hdr->addr2; |
| 67 | case 0: |
| 68 | return hdr->addr3; |
| 69 | } |
| 70 | break; |
| 71 | case IEEE80211_FTYPE_MGMT: |
Ron Rindjunsky | 98f0b0a | 2007-12-18 17:23:53 +0200 | [diff] [blame] | 72 | if (len < 24) /* drop incorrect hdr len (mgmt) */ |
| 73 | return NULL; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 74 | return hdr->addr3; |
| 75 | case IEEE80211_FTYPE_CTL: |
| 76 | if ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PSPOLL) |
| 77 | return hdr->addr1; |
Ron Rindjunsky | 7136471 | 2007-12-25 17:00:36 +0200 | [diff] [blame] | 78 | else if ((fc & IEEE80211_FCTL_STYPE) == |
| 79 | IEEE80211_STYPE_BACK_REQ) { |
| 80 | switch (type) { |
| 81 | case IEEE80211_IF_TYPE_STA: |
| 82 | return hdr->addr2; |
| 83 | case IEEE80211_IF_TYPE_AP: |
| 84 | case IEEE80211_IF_TYPE_VLAN: |
| 85 | return hdr->addr1; |
| 86 | default: |
| 87 | return NULL; |
| 88 | } |
| 89 | } |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 90 | else |
| 91 | return NULL; |
| 92 | } |
| 93 | |
| 94 | return NULL; |
| 95 | } |
| 96 | |
| 97 | int ieee80211_get_hdrlen(u16 fc) |
| 98 | { |
| 99 | int hdrlen = 24; |
| 100 | |
| 101 | switch (fc & IEEE80211_FCTL_FTYPE) { |
| 102 | case IEEE80211_FTYPE_DATA: |
| 103 | if ((fc & IEEE80211_FCTL_FROMDS) && (fc & IEEE80211_FCTL_TODS)) |
| 104 | hdrlen = 30; /* Addr4 */ |
| 105 | /* |
| 106 | * The QoS Control field is two bytes and its presence is |
| 107 | * indicated by the IEEE80211_STYPE_QOS_DATA bit. Add 2 to |
| 108 | * hdrlen if that bit is set. |
| 109 | * This works by masking out the bit and shifting it to |
| 110 | * bit position 1 so the result has the value 0 or 2. |
| 111 | */ |
| 112 | hdrlen += (fc & IEEE80211_STYPE_QOS_DATA) |
| 113 | >> (ilog2(IEEE80211_STYPE_QOS_DATA)-1); |
| 114 | break; |
| 115 | case IEEE80211_FTYPE_CTL: |
| 116 | /* |
| 117 | * ACK and CTS are 10 bytes, all others 16. To see how |
| 118 | * to get this condition consider |
| 119 | * subtype mask: 0b0000000011110000 (0x00F0) |
| 120 | * ACK subtype: 0b0000000011010000 (0x00D0) |
| 121 | * CTS subtype: 0b0000000011000000 (0x00C0) |
| 122 | * bits that matter: ^^^ (0x00E0) |
| 123 | * value of those: 0b0000000011000000 (0x00C0) |
| 124 | */ |
| 125 | if ((fc & 0xE0) == 0xC0) |
| 126 | hdrlen = 10; |
| 127 | else |
| 128 | hdrlen = 16; |
| 129 | break; |
| 130 | } |
| 131 | |
| 132 | return hdrlen; |
| 133 | } |
| 134 | EXPORT_SYMBOL(ieee80211_get_hdrlen); |
| 135 | |
| 136 | int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) |
| 137 | { |
| 138 | const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *) skb->data; |
| 139 | int hdrlen; |
| 140 | |
| 141 | if (unlikely(skb->len < 10)) |
| 142 | return 0; |
| 143 | hdrlen = ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_control)); |
| 144 | if (unlikely(hdrlen > skb->len)) |
| 145 | return 0; |
| 146 | return hdrlen; |
| 147 | } |
| 148 | EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); |
| 149 | |
Luis Carlos Cobo | ee38585 | 2008-02-23 15:17:11 +0100 | [diff] [blame] | 150 | int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) |
| 151 | { |
| 152 | int ae = meshhdr->flags & IEEE80211S_FLAGS_AE; |
| 153 | /* 7.1.3.5a.2 */ |
| 154 | switch (ae) { |
| 155 | case 0: |
| 156 | return 5; |
| 157 | case 1: |
| 158 | return 11; |
| 159 | case 2: |
| 160 | return 17; |
| 161 | case 3: |
| 162 | return 23; |
| 163 | default: |
| 164 | return 5; |
| 165 | } |
| 166 | } |
Luis Carlos Cobo | ee38585 | 2008-02-23 15:17:11 +0100 | [diff] [blame] | 167 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 168 | void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 169 | { |
| 170 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx->skb->data; |
| 171 | |
| 172 | hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 173 | if (tx->extra_frag) { |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 174 | struct ieee80211_hdr *fhdr; |
| 175 | int i; |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 176 | for (i = 0; i < tx->num_extra_frag; i++) { |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 177 | fhdr = (struct ieee80211_hdr *) |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 178 | tx->extra_frag[i]->data; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 179 | fhdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); |
| 180 | } |
| 181 | } |
| 182 | } |
| 183 | |
| 184 | int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, |
| 185 | int rate, int erp, int short_preamble) |
| 186 | { |
| 187 | int dur; |
| 188 | |
| 189 | /* calculate duration (in microseconds, rounded up to next higher |
| 190 | * integer if it includes a fractional microsecond) to send frame of |
| 191 | * len bytes (does not include FCS) at the given rate. Duration will |
| 192 | * also include SIFS. |
| 193 | * |
| 194 | * rate is in 100 kbps, so divident is multiplied by 10 in the |
| 195 | * DIV_ROUND_UP() operations. |
| 196 | */ |
| 197 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 198 | if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) { |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 199 | /* |
| 200 | * OFDM: |
| 201 | * |
| 202 | * N_DBPS = DATARATE x 4 |
| 203 | * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) |
| 204 | * (16 = SIGNAL time, 6 = tail bits) |
| 205 | * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext |
| 206 | * |
| 207 | * T_SYM = 4 usec |
| 208 | * 802.11a - 17.5.2: aSIFSTime = 16 usec |
| 209 | * 802.11g - 19.8.4: aSIFSTime = 10 usec + |
| 210 | * signal ext = 6 usec |
| 211 | */ |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 212 | dur = 16; /* SIFS + signal ext */ |
| 213 | dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ |
| 214 | dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ |
| 215 | dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, |
| 216 | 4 * rate); /* T_SYM x N_SYM */ |
| 217 | } else { |
| 218 | /* |
| 219 | * 802.11b or 802.11g with 802.11b compatibility: |
| 220 | * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + |
| 221 | * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. |
| 222 | * |
| 223 | * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 |
| 224 | * aSIFSTime = 10 usec |
| 225 | * aPreambleLength = 144 usec or 72 usec with short preamble |
| 226 | * aPLCPHeaderLength = 48 usec or 24 usec with short preamble |
| 227 | */ |
| 228 | dur = 10; /* aSIFSTime = 10 usec */ |
| 229 | dur += short_preamble ? (72 + 24) : (144 + 48); |
| 230 | |
| 231 | dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); |
| 232 | } |
| 233 | |
| 234 | return dur; |
| 235 | } |
| 236 | |
| 237 | /* Exported duration function for driver use */ |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 238 | __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, |
| 239 | struct ieee80211_vif *vif, |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 240 | size_t frame_len, |
| 241 | struct ieee80211_rate *rate) |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 242 | { |
| 243 | struct ieee80211_local *local = hw_to_local(hw); |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 244 | struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 245 | u16 dur; |
| 246 | int erp; |
| 247 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 248 | erp = 0; |
| 249 | if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) |
| 250 | erp = rate->flags & IEEE80211_RATE_ERP_G; |
| 251 | |
| 252 | dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp, |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 253 | sdata->bss_conf.use_short_preamble); |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 254 | |
| 255 | return cpu_to_le16(dur); |
| 256 | } |
| 257 | EXPORT_SYMBOL(ieee80211_generic_frame_duration); |
| 258 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 259 | __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, |
| 260 | struct ieee80211_vif *vif, size_t frame_len, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 261 | const struct ieee80211_tx_control *frame_txctl) |
| 262 | { |
| 263 | struct ieee80211_local *local = hw_to_local(hw); |
| 264 | struct ieee80211_rate *rate; |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 265 | struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 266 | bool short_preamble; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 267 | int erp; |
| 268 | u16 dur; |
| 269 | |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 270 | short_preamble = sdata->bss_conf.use_short_preamble; |
Daniel Drake | 7e9ed18 | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 271 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 272 | rate = frame_txctl->rts_cts_rate; |
| 273 | |
| 274 | erp = 0; |
| 275 | if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) |
| 276 | erp = rate->flags & IEEE80211_RATE_ERP_G; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 277 | |
| 278 | /* CTS duration */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 279 | dur = ieee80211_frame_duration(local, 10, rate->bitrate, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 280 | erp, short_preamble); |
| 281 | /* Data frame duration */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 282 | dur += ieee80211_frame_duration(local, frame_len, rate->bitrate, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 283 | erp, short_preamble); |
| 284 | /* ACK duration */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 285 | dur += ieee80211_frame_duration(local, 10, rate->bitrate, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 286 | erp, short_preamble); |
| 287 | |
| 288 | return cpu_to_le16(dur); |
| 289 | } |
| 290 | EXPORT_SYMBOL(ieee80211_rts_duration); |
| 291 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 292 | __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, |
| 293 | struct ieee80211_vif *vif, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 294 | size_t frame_len, |
| 295 | const struct ieee80211_tx_control *frame_txctl) |
| 296 | { |
| 297 | struct ieee80211_local *local = hw_to_local(hw); |
| 298 | struct ieee80211_rate *rate; |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 299 | struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 300 | bool short_preamble; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 301 | int erp; |
| 302 | u16 dur; |
| 303 | |
Johannes Berg | 471b3ef | 2007-12-28 14:32:58 +0100 | [diff] [blame] | 304 | short_preamble = sdata->bss_conf.use_short_preamble; |
Daniel Drake | 7e9ed18 | 2007-07-27 15:43:24 +0200 | [diff] [blame] | 305 | |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 306 | rate = frame_txctl->rts_cts_rate; |
| 307 | erp = 0; |
| 308 | if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) |
| 309 | erp = rate->flags & IEEE80211_RATE_ERP_G; |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 310 | |
| 311 | /* Data frame duration */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 312 | dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 313 | erp, short_preamble); |
| 314 | if (!(frame_txctl->flags & IEEE80211_TXCTL_NO_ACK)) { |
| 315 | /* ACK duration */ |
Johannes Berg | 8318d78 | 2008-01-24 19:38:38 +0100 | [diff] [blame] | 316 | dur += ieee80211_frame_duration(local, 10, rate->bitrate, |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 317 | erp, short_preamble); |
| 318 | } |
| 319 | |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 320 | return cpu_to_le16(dur); |
| 321 | } |
| 322 | EXPORT_SYMBOL(ieee80211_ctstoself_duration); |
| 323 | |
Johannes Berg | c2d1560 | 2007-07-27 15:43:23 +0200 | [diff] [blame] | 324 | void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) |
| 325 | { |
| 326 | struct ieee80211_local *local = hw_to_local(hw); |
| 327 | |
| 328 | if (test_and_clear_bit(IEEE80211_LINK_STATE_XOFF, |
| 329 | &local->state[queue])) { |
| 330 | if (test_bit(IEEE80211_LINK_STATE_PENDING, |
| 331 | &local->state[queue])) |
| 332 | tasklet_schedule(&local->tx_pending_tasklet); |
| 333 | else |
| 334 | if (!ieee80211_qdisc_installed(local->mdev)) { |
| 335 | if (queue == 0) |
| 336 | netif_wake_queue(local->mdev); |
| 337 | } else |
| 338 | __netif_schedule(local->mdev); |
| 339 | } |
| 340 | } |
| 341 | EXPORT_SYMBOL(ieee80211_wake_queue); |
| 342 | |
| 343 | void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) |
| 344 | { |
| 345 | struct ieee80211_local *local = hw_to_local(hw); |
| 346 | |
| 347 | if (!ieee80211_qdisc_installed(local->mdev) && queue == 0) |
| 348 | netif_stop_queue(local->mdev); |
| 349 | set_bit(IEEE80211_LINK_STATE_XOFF, &local->state[queue]); |
| 350 | } |
| 351 | EXPORT_SYMBOL(ieee80211_stop_queue); |
| 352 | |
| 353 | void ieee80211_start_queues(struct ieee80211_hw *hw) |
| 354 | { |
| 355 | struct ieee80211_local *local = hw_to_local(hw); |
| 356 | int i; |
| 357 | |
| 358 | for (i = 0; i < local->hw.queues; i++) |
| 359 | clear_bit(IEEE80211_LINK_STATE_XOFF, &local->state[i]); |
| 360 | if (!ieee80211_qdisc_installed(local->mdev)) |
| 361 | netif_start_queue(local->mdev); |
| 362 | } |
| 363 | EXPORT_SYMBOL(ieee80211_start_queues); |
| 364 | |
| 365 | void ieee80211_stop_queues(struct ieee80211_hw *hw) |
| 366 | { |
| 367 | int i; |
| 368 | |
| 369 | for (i = 0; i < hw->queues; i++) |
| 370 | ieee80211_stop_queue(hw, i); |
| 371 | } |
| 372 | EXPORT_SYMBOL(ieee80211_stop_queues); |
| 373 | |
| 374 | void ieee80211_wake_queues(struct ieee80211_hw *hw) |
| 375 | { |
| 376 | int i; |
| 377 | |
| 378 | for (i = 0; i < hw->queues; i++) |
| 379 | ieee80211_wake_queue(hw, i); |
| 380 | } |
| 381 | EXPORT_SYMBOL(ieee80211_wake_queues); |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 382 | |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 383 | void ieee80211_iterate_active_interfaces( |
| 384 | struct ieee80211_hw *hw, |
| 385 | void (*iterator)(void *data, u8 *mac, |
| 386 | struct ieee80211_vif *vif), |
| 387 | void *data) |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 388 | { |
| 389 | struct ieee80211_local *local = hw_to_local(hw); |
| 390 | struct ieee80211_sub_if_data *sdata; |
| 391 | |
Johannes Berg | e38bad4 | 2007-11-28 10:55:32 +0100 | [diff] [blame] | 392 | rcu_read_lock(); |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 393 | |
Johannes Berg | e38bad4 | 2007-11-28 10:55:32 +0100 | [diff] [blame] | 394 | list_for_each_entry_rcu(sdata, &local->interfaces, list) { |
Johannes Berg | 51fb61e | 2007-12-19 01:31:27 +0100 | [diff] [blame] | 395 | switch (sdata->vif.type) { |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 396 | case IEEE80211_IF_TYPE_INVALID: |
| 397 | case IEEE80211_IF_TYPE_MNTR: |
| 398 | case IEEE80211_IF_TYPE_VLAN: |
| 399 | continue; |
| 400 | case IEEE80211_IF_TYPE_AP: |
| 401 | case IEEE80211_IF_TYPE_STA: |
| 402 | case IEEE80211_IF_TYPE_IBSS: |
| 403 | case IEEE80211_IF_TYPE_WDS: |
Johannes Berg | 6032f93 | 2008-02-23 15:17:07 +0100 | [diff] [blame] | 404 | case IEEE80211_IF_TYPE_MESH_POINT: |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 405 | break; |
| 406 | } |
| 407 | if (sdata->dev == local->mdev) |
| 408 | continue; |
| 409 | if (netif_running(sdata->dev)) |
| 410 | iterator(data, sdata->dev->dev_addr, |
Johannes Berg | 32bfd35 | 2007-12-19 01:31:26 +0100 | [diff] [blame] | 411 | &sdata->vif); |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 412 | } |
Johannes Berg | e38bad4 | 2007-11-28 10:55:32 +0100 | [diff] [blame] | 413 | |
| 414 | rcu_read_unlock(); |
Johannes Berg | dabeb34 | 2007-11-09 01:57:29 +0100 | [diff] [blame] | 415 | } |
| 416 | EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); |