Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[kernel.git] / net / mac80211 / util.c
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>
23 #include <linux/crc32.h>
24 #include <net/net_namespace.h>
25 #include <net/cfg80211.h>
26 #include <net/rtnetlink.h>
27
28 #include "ieee80211_i.h"
29 #include "driver-ops.h"
30 #include "rate.h"
31 #include "mesh.h"
32 #include "wme.h"
33 #include "led.h"
34 #include "wep.h"
35
36 /* privid for wiphys to determine whether they belong to us or not */
37 void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
38
39 struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
40 {
41         struct ieee80211_local *local;
42         BUG_ON(!wiphy);
43
44         local = wiphy_priv(wiphy);
45         return &local->hw;
46 }
47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
48
49 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
50                         enum nl80211_iftype type)
51 {
52         __le16 fc = hdr->frame_control;
53
54          /* drop ACK/CTS frames and incorrect hdr len (ctrl) */
55         if (len < 16)
56                 return NULL;
57
58         if (ieee80211_is_data(fc)) {
59                 if (len < 24) /* drop incorrect hdr len (data) */
60                         return NULL;
61
62                 if (ieee80211_has_a4(fc))
63                         return NULL;
64                 if (ieee80211_has_tods(fc))
65                         return hdr->addr1;
66                 if (ieee80211_has_fromds(fc))
67                         return hdr->addr2;
68
69                 return hdr->addr3;
70         }
71
72         if (ieee80211_is_mgmt(fc)) {
73                 if (len < 24) /* drop incorrect hdr len (mgmt) */
74                         return NULL;
75                 return hdr->addr3;
76         }
77
78         if (ieee80211_is_ctl(fc)) {
79                 if(ieee80211_is_pspoll(fc))
80                         return hdr->addr1;
81
82                 if (ieee80211_is_back_req(fc)) {
83                         switch (type) {
84                         case NL80211_IFTYPE_STATION:
85                                 return hdr->addr2;
86                         case NL80211_IFTYPE_AP:
87                         case NL80211_IFTYPE_AP_VLAN:
88                                 return hdr->addr1;
89                         default:
90                                 break; /* fall through to the return */
91                         }
92                 }
93         }
94
95         return NULL;
96 }
97
98 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
99 {
100         struct sk_buff *skb = tx->skb;
101         struct ieee80211_hdr *hdr;
102
103         do {
104                 hdr = (struct ieee80211_hdr *) skb->data;
105                 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
106         } while ((skb = skb->next));
107 }
108
109 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
110                              int rate, int erp, int short_preamble)
111 {
112         int dur;
113
114         /* calculate duration (in microseconds, rounded up to next higher
115          * integer if it includes a fractional microsecond) to send frame of
116          * len bytes (does not include FCS) at the given rate. Duration will
117          * also include SIFS.
118          *
119          * rate is in 100 kbps, so divident is multiplied by 10 in the
120          * DIV_ROUND_UP() operations.
121          */
122
123         if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) {
124                 /*
125                  * OFDM:
126                  *
127                  * N_DBPS = DATARATE x 4
128                  * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
129                  *      (16 = SIGNAL time, 6 = tail bits)
130                  * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
131                  *
132                  * T_SYM = 4 usec
133                  * 802.11a - 17.5.2: aSIFSTime = 16 usec
134                  * 802.11g - 19.8.4: aSIFSTime = 10 usec +
135                  *      signal ext = 6 usec
136                  */
137                 dur = 16; /* SIFS + signal ext */
138                 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
139                 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
140                 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
141                                         4 * rate); /* T_SYM x N_SYM */
142         } else {
143                 /*
144                  * 802.11b or 802.11g with 802.11b compatibility:
145                  * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
146                  * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
147                  *
148                  * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
149                  * aSIFSTime = 10 usec
150                  * aPreambleLength = 144 usec or 72 usec with short preamble
151                  * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
152                  */
153                 dur = 10; /* aSIFSTime = 10 usec */
154                 dur += short_preamble ? (72 + 24) : (144 + 48);
155
156                 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
157         }
158
159         return dur;
160 }
161
162 /* Exported duration function for driver use */
163 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
164                                         struct ieee80211_vif *vif,
165                                         size_t frame_len,
166                                         struct ieee80211_rate *rate)
167 {
168         struct ieee80211_local *local = hw_to_local(hw);
169         struct ieee80211_sub_if_data *sdata;
170         u16 dur;
171         int erp;
172         bool short_preamble = false;
173
174         erp = 0;
175         if (vif) {
176                 sdata = vif_to_sdata(vif);
177                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
178                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
179                         erp = rate->flags & IEEE80211_RATE_ERP_G;
180         }
181
182         dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp,
183                                        short_preamble);
184
185         return cpu_to_le16(dur);
186 }
187 EXPORT_SYMBOL(ieee80211_generic_frame_duration);
188
189 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
190                               struct ieee80211_vif *vif, size_t frame_len,
191                               const struct ieee80211_tx_info *frame_txctl)
192 {
193         struct ieee80211_local *local = hw_to_local(hw);
194         struct ieee80211_rate *rate;
195         struct ieee80211_sub_if_data *sdata;
196         bool short_preamble;
197         int erp;
198         u16 dur;
199         struct ieee80211_supported_band *sband;
200
201         sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
202
203         short_preamble = false;
204
205         rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
206
207         erp = 0;
208         if (vif) {
209                 sdata = vif_to_sdata(vif);
210                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
211                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
212                         erp = rate->flags & IEEE80211_RATE_ERP_G;
213         }
214
215         /* CTS duration */
216         dur = ieee80211_frame_duration(local, 10, rate->bitrate,
217                                        erp, short_preamble);
218         /* Data frame duration */
219         dur += ieee80211_frame_duration(local, frame_len, rate->bitrate,
220                                         erp, short_preamble);
221         /* ACK duration */
222         dur += ieee80211_frame_duration(local, 10, rate->bitrate,
223                                         erp, short_preamble);
224
225         return cpu_to_le16(dur);
226 }
227 EXPORT_SYMBOL(ieee80211_rts_duration);
228
229 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
230                                     struct ieee80211_vif *vif,
231                                     size_t frame_len,
232                                     const struct ieee80211_tx_info *frame_txctl)
233 {
234         struct ieee80211_local *local = hw_to_local(hw);
235         struct ieee80211_rate *rate;
236         struct ieee80211_sub_if_data *sdata;
237         bool short_preamble;
238         int erp;
239         u16 dur;
240         struct ieee80211_supported_band *sband;
241
242         sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
243
244         short_preamble = false;
245
246         rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
247         erp = 0;
248         if (vif) {
249                 sdata = vif_to_sdata(vif);
250                 short_preamble = sdata->vif.bss_conf.use_short_preamble;
251                 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
252                         erp = rate->flags & IEEE80211_RATE_ERP_G;
253         }
254
255         /* Data frame duration */
256         dur = ieee80211_frame_duration(local, frame_len, rate->bitrate,
257                                        erp, short_preamble);
258         if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
259                 /* ACK duration */
260                 dur += ieee80211_frame_duration(local, 10, rate->bitrate,
261                                                 erp, short_preamble);
262         }
263
264         return cpu_to_le16(dur);
265 }
266 EXPORT_SYMBOL(ieee80211_ctstoself_duration);
267
268 static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
269                                    enum queue_stop_reason reason)
270 {
271         struct ieee80211_local *local = hw_to_local(hw);
272
273         if (WARN_ON(queue >= hw->queues))
274                 return;
275
276         __clear_bit(reason, &local->queue_stop_reasons[queue]);
277
278         if (local->queue_stop_reasons[queue] != 0)
279                 /* someone still has this queue stopped */
280                 return;
281
282         if (!skb_queue_empty(&local->pending[queue]))
283                 tasklet_schedule(&local->tx_pending_tasklet);
284 }
285
286 void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
287                                     enum queue_stop_reason reason)
288 {
289         struct ieee80211_local *local = hw_to_local(hw);
290         unsigned long flags;
291
292         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
293         __ieee80211_wake_queue(hw, queue, reason);
294         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
295 }
296
297 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
298 {
299         ieee80211_wake_queue_by_reason(hw, queue,
300                                        IEEE80211_QUEUE_STOP_REASON_DRIVER);
301 }
302 EXPORT_SYMBOL(ieee80211_wake_queue);
303
304 static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
305                                    enum queue_stop_reason reason)
306 {
307         struct ieee80211_local *local = hw_to_local(hw);
308
309         if (WARN_ON(queue >= hw->queues))
310                 return;
311
312         __set_bit(reason, &local->queue_stop_reasons[queue]);
313 }
314
315 void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
316                                     enum queue_stop_reason reason)
317 {
318         struct ieee80211_local *local = hw_to_local(hw);
319         unsigned long flags;
320
321         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
322         __ieee80211_stop_queue(hw, queue, reason);
323         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
324 }
325
326 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
327 {
328         ieee80211_stop_queue_by_reason(hw, queue,
329                                        IEEE80211_QUEUE_STOP_REASON_DRIVER);
330 }
331 EXPORT_SYMBOL(ieee80211_stop_queue);
332
333 void ieee80211_add_pending_skb(struct ieee80211_local *local,
334                                struct sk_buff *skb)
335 {
336         struct ieee80211_hw *hw = &local->hw;
337         unsigned long flags;
338         int queue = skb_get_queue_mapping(skb);
339         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
340
341         if (WARN_ON(!info->control.vif)) {
342                 kfree_skb(skb);
343                 return;
344         }
345
346         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
347         __ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
348         __skb_queue_tail(&local->pending[queue], skb);
349         __ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
350         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
351 }
352
353 int ieee80211_add_pending_skbs(struct ieee80211_local *local,
354                                struct sk_buff_head *skbs)
355 {
356         struct ieee80211_hw *hw = &local->hw;
357         struct sk_buff *skb;
358         unsigned long flags;
359         int queue, ret = 0, i;
360
361         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
362         for (i = 0; i < hw->queues; i++)
363                 __ieee80211_stop_queue(hw, i,
364                         IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
365
366         while ((skb = skb_dequeue(skbs))) {
367                 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
368
369                 if (WARN_ON(!info->control.vif)) {
370                         kfree_skb(skb);
371                         continue;
372                 }
373
374                 ret++;
375                 queue = skb_get_queue_mapping(skb);
376                 __skb_queue_tail(&local->pending[queue], skb);
377         }
378
379         for (i = 0; i < hw->queues; i++)
380                 __ieee80211_wake_queue(hw, i,
381                         IEEE80211_QUEUE_STOP_REASON_SKB_ADD);
382         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
383
384         return ret;
385 }
386
387 void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
388                                     enum queue_stop_reason reason)
389 {
390         struct ieee80211_local *local = hw_to_local(hw);
391         unsigned long flags;
392         int i;
393
394         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
395
396         for (i = 0; i < hw->queues; i++)
397                 __ieee80211_stop_queue(hw, i, reason);
398
399         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
400 }
401
402 void ieee80211_stop_queues(struct ieee80211_hw *hw)
403 {
404         ieee80211_stop_queues_by_reason(hw,
405                                         IEEE80211_QUEUE_STOP_REASON_DRIVER);
406 }
407 EXPORT_SYMBOL(ieee80211_stop_queues);
408
409 int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
410 {
411         struct ieee80211_local *local = hw_to_local(hw);
412         unsigned long flags;
413         int ret;
414
415         if (WARN_ON(queue >= hw->queues))
416                 return true;
417
418         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
419         ret = !!local->queue_stop_reasons[queue];
420         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
421         return ret;
422 }
423 EXPORT_SYMBOL(ieee80211_queue_stopped);
424
425 void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
426                                      enum queue_stop_reason reason)
427 {
428         struct ieee80211_local *local = hw_to_local(hw);
429         unsigned long flags;
430         int i;
431
432         spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
433
434         for (i = 0; i < hw->queues; i++)
435                 __ieee80211_wake_queue(hw, i, reason);
436
437         spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
438 }
439
440 void ieee80211_wake_queues(struct ieee80211_hw *hw)
441 {
442         ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER);
443 }
444 EXPORT_SYMBOL(ieee80211_wake_queues);
445
446 void ieee80211_iterate_active_interfaces(
447         struct ieee80211_hw *hw,
448         void (*iterator)(void *data, u8 *mac,
449                          struct ieee80211_vif *vif),
450         void *data)
451 {
452         struct ieee80211_local *local = hw_to_local(hw);
453         struct ieee80211_sub_if_data *sdata;
454
455         mutex_lock(&local->iflist_mtx);
456
457         list_for_each_entry(sdata, &local->interfaces, list) {
458                 switch (sdata->vif.type) {
459                 case __NL80211_IFTYPE_AFTER_LAST:
460                 case NL80211_IFTYPE_UNSPECIFIED:
461                 case NL80211_IFTYPE_MONITOR:
462                 case NL80211_IFTYPE_AP_VLAN:
463                         continue;
464                 case NL80211_IFTYPE_AP:
465                 case NL80211_IFTYPE_STATION:
466                 case NL80211_IFTYPE_ADHOC:
467                 case NL80211_IFTYPE_WDS:
468                 case NL80211_IFTYPE_MESH_POINT:
469                         break;
470                 }
471                 if (netif_running(sdata->dev))
472                         iterator(data, sdata->vif.addr,
473                                  &sdata->vif);
474         }
475
476         mutex_unlock(&local->iflist_mtx);
477 }
478 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
479
480 void ieee80211_iterate_active_interfaces_atomic(
481         struct ieee80211_hw *hw,
482         void (*iterator)(void *data, u8 *mac,
483                          struct ieee80211_vif *vif),
484         void *data)
485 {
486         struct ieee80211_local *local = hw_to_local(hw);
487         struct ieee80211_sub_if_data *sdata;
488
489         rcu_read_lock();
490
491         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
492                 switch (sdata->vif.type) {
493                 case __NL80211_IFTYPE_AFTER_LAST:
494                 case NL80211_IFTYPE_UNSPECIFIED:
495                 case NL80211_IFTYPE_MONITOR:
496                 case NL80211_IFTYPE_AP_VLAN:
497                         continue;
498                 case NL80211_IFTYPE_AP:
499                 case NL80211_IFTYPE_STATION:
500                 case NL80211_IFTYPE_ADHOC:
501                 case NL80211_IFTYPE_WDS:
502                 case NL80211_IFTYPE_MESH_POINT:
503                         break;
504                 }
505                 if (netif_running(sdata->dev))
506                         iterator(data, sdata->vif.addr,
507                                  &sdata->vif);
508         }
509
510         rcu_read_unlock();
511 }
512 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
513
514 /*
515  * Nothing should have been stuffed into the workqueue during
516  * the suspend->resume cycle. If this WARN is seen then there
517  * is a bug with either the driver suspend or something in
518  * mac80211 stuffing into the workqueue which we haven't yet
519  * cleared during mac80211's suspend cycle.
520  */
521 static bool ieee80211_can_queue_work(struct ieee80211_local *local)
522 {
523         if (WARN(local->suspended && !local->resuming,
524                  "queueing ieee80211 work while going to suspend\n"))
525                 return false;
526
527         return true;
528 }
529
530 void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
531 {
532         struct ieee80211_local *local = hw_to_local(hw);
533
534         if (!ieee80211_can_queue_work(local))
535                 return;
536
537         queue_work(local->workqueue, work);
538 }
539 EXPORT_SYMBOL(ieee80211_queue_work);
540
541 void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
542                                   struct delayed_work *dwork,
543                                   unsigned long delay)
544 {
545         struct ieee80211_local *local = hw_to_local(hw);
546
547         if (!ieee80211_can_queue_work(local))
548                 return;
549
550         queue_delayed_work(local->workqueue, dwork, delay);
551 }
552 EXPORT_SYMBOL(ieee80211_queue_delayed_work);
553
554 void ieee802_11_parse_elems(u8 *start, size_t len,
555                             struct ieee802_11_elems *elems)
556 {
557         ieee802_11_parse_elems_crc(start, len, elems, 0, 0);
558 }
559
560 u32 ieee802_11_parse_elems_crc(u8 *start, size_t len,
561                                struct ieee802_11_elems *elems,
562                                u64 filter, u32 crc)
563 {
564         size_t left = len;
565         u8 *pos = start;
566         bool calc_crc = filter != 0;
567
568         memset(elems, 0, sizeof(*elems));
569         elems->ie_start = start;
570         elems->total_len = len;
571
572         while (left >= 2) {
573                 u8 id, elen;
574
575                 id = *pos++;
576                 elen = *pos++;
577                 left -= 2;
578
579                 if (elen > left)
580                         break;
581
582                 if (calc_crc && id < 64 && (filter & (1ULL << id)))
583                         crc = crc32_be(crc, pos - 2, elen + 2);
584
585                 switch (id) {
586                 case WLAN_EID_SSID:
587                         elems->ssid = pos;
588                         elems->ssid_len = elen;
589                         break;
590                 case WLAN_EID_SUPP_RATES:
591                         elems->supp_rates = pos;
592                         elems->supp_rates_len = elen;
593                         break;
594                 case WLAN_EID_FH_PARAMS:
595                         elems->fh_params = pos;
596                         elems->fh_params_len = elen;
597                         break;
598                 case WLAN_EID_DS_PARAMS:
599                         elems->ds_params = pos;
600                         elems->ds_params_len = elen;
601                         break;
602                 case WLAN_EID_CF_PARAMS:
603                         elems->cf_params = pos;
604                         elems->cf_params_len = elen;
605                         break;
606                 case WLAN_EID_TIM:
607                         if (elen >= sizeof(struct ieee80211_tim_ie)) {
608                                 elems->tim = (void *)pos;
609                                 elems->tim_len = elen;
610                         }
611                         break;
612                 case WLAN_EID_IBSS_PARAMS:
613                         elems->ibss_params = pos;
614                         elems->ibss_params_len = elen;
615                         break;
616                 case WLAN_EID_CHALLENGE:
617                         elems->challenge = pos;
618                         elems->challenge_len = elen;
619                         break;
620                 case WLAN_EID_VENDOR_SPECIFIC:
621                         if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
622                             pos[2] == 0xf2) {
623                                 /* Microsoft OUI (00:50:F2) */
624
625                                 if (calc_crc)
626                                         crc = crc32_be(crc, pos - 2, elen + 2);
627
628                                 if (pos[3] == 1) {
629                                         /* OUI Type 1 - WPA IE */
630                                         elems->wpa = pos;
631                                         elems->wpa_len = elen;
632                                 } else if (elen >= 5 && pos[3] == 2) {
633                                         /* OUI Type 2 - WMM IE */
634                                         if (pos[4] == 0) {
635                                                 elems->wmm_info = pos;
636                                                 elems->wmm_info_len = elen;
637                                         } else if (pos[4] == 1) {
638                                                 elems->wmm_param = pos;
639                                                 elems->wmm_param_len = elen;
640                                         }
641                                 }
642                         }
643                         break;
644                 case WLAN_EID_RSN:
645                         elems->rsn = pos;
646                         elems->rsn_len = elen;
647                         break;
648                 case WLAN_EID_ERP_INFO:
649                         elems->erp_info = pos;
650                         elems->erp_info_len = elen;
651                         break;
652                 case WLAN_EID_EXT_SUPP_RATES:
653                         elems->ext_supp_rates = pos;
654                         elems->ext_supp_rates_len = elen;
655                         break;
656                 case WLAN_EID_HT_CAPABILITY:
657                         if (elen >= sizeof(struct ieee80211_ht_cap))
658                                 elems->ht_cap_elem = (void *)pos;
659                         break;
660                 case WLAN_EID_HT_INFORMATION:
661                         if (elen >= sizeof(struct ieee80211_ht_info))
662                                 elems->ht_info_elem = (void *)pos;
663                         break;
664                 case WLAN_EID_MESH_ID:
665                         elems->mesh_id = pos;
666                         elems->mesh_id_len = elen;
667                         break;
668                 case WLAN_EID_MESH_CONFIG:
669                         if (elen >= sizeof(struct ieee80211_meshconf_ie))
670                                 elems->mesh_config = (void *)pos;
671                         break;
672                 case WLAN_EID_PEER_LINK:
673                         elems->peer_link = pos;
674                         elems->peer_link_len = elen;
675                         break;
676                 case WLAN_EID_PREQ:
677                         elems->preq = pos;
678                         elems->preq_len = elen;
679                         break;
680                 case WLAN_EID_PREP:
681                         elems->prep = pos;
682                         elems->prep_len = elen;
683                         break;
684                 case WLAN_EID_PERR:
685                         elems->perr = pos;
686                         elems->perr_len = elen;
687                         break;
688                 case WLAN_EID_RANN:
689                         if (elen >= sizeof(struct ieee80211_rann_ie))
690                                 elems->rann = (void *)pos;
691                         break;
692                 case WLAN_EID_CHANNEL_SWITCH:
693                         elems->ch_switch_elem = pos;
694                         elems->ch_switch_elem_len = elen;
695                         break;
696                 case WLAN_EID_QUIET:
697                         if (!elems->quiet_elem) {
698                                 elems->quiet_elem = pos;
699                                 elems->quiet_elem_len = elen;
700                         }
701                         elems->num_of_quiet_elem++;
702                         break;
703                 case WLAN_EID_COUNTRY:
704                         elems->country_elem = pos;
705                         elems->country_elem_len = elen;
706                         break;
707                 case WLAN_EID_PWR_CONSTRAINT:
708                         elems->pwr_constr_elem = pos;
709                         elems->pwr_constr_elem_len = elen;
710                         break;
711                 case WLAN_EID_TIMEOUT_INTERVAL:
712                         elems->timeout_int = pos;
713                         elems->timeout_int_len = elen;
714                         break;
715                 default:
716                         break;
717                 }
718
719                 left -= elen;
720                 pos += elen;
721         }
722
723         return crc;
724 }
725
726 void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)
727 {
728         struct ieee80211_local *local = sdata->local;
729         struct ieee80211_tx_queue_params qparam;
730         int queue;
731         bool use_11b;
732         int aCWmin, aCWmax;
733
734         if (!local->ops->conf_tx)
735                 return;
736
737         memset(&qparam, 0, sizeof(qparam));
738
739         use_11b = (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) &&
740                  !(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE);
741
742         for (queue = 0; queue < local_to_hw(local)->queues; queue++) {
743                 /* Set defaults according to 802.11-2007 Table 7-37 */
744                 aCWmax = 1023;
745                 if (use_11b)
746                         aCWmin = 31;
747                 else
748                         aCWmin = 15;
749
750                 switch (queue) {
751                 case 3: /* AC_BK */
752                         qparam.cw_max = aCWmax;
753                         qparam.cw_min = aCWmin;
754                         qparam.txop = 0;
755                         qparam.aifs = 7;
756                         break;
757                 default: /* never happens but let's not leave undefined */
758                 case 2: /* AC_BE */
759                         qparam.cw_max = aCWmax;
760                         qparam.cw_min = aCWmin;
761                         qparam.txop = 0;
762                         qparam.aifs = 3;
763                         break;
764                 case 1: /* AC_VI */
765                         qparam.cw_max = aCWmin;
766                         qparam.cw_min = (aCWmin + 1) / 2 - 1;
767                         if (use_11b)
768                                 qparam.txop = 6016/32;
769                         else
770                                 qparam.txop = 3008/32;
771                         qparam.aifs = 2;
772                         break;
773                 case 0: /* AC_VO */
774                         qparam.cw_max = (aCWmin + 1) / 2 - 1;
775                         qparam.cw_min = (aCWmin + 1) / 4 - 1;
776                         if (use_11b)
777                                 qparam.txop = 3264/32;
778                         else
779                                 qparam.txop = 1504/32;
780                         qparam.aifs = 2;
781                         break;
782                 }
783
784                 drv_conf_tx(local, queue, &qparam);
785         }
786 }
787
788 void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
789                                   const size_t supp_rates_len,
790                                   const u8 *supp_rates)
791 {
792         struct ieee80211_local *local = sdata->local;
793         int i, have_higher_than_11mbit = 0;
794
795         /* cf. IEEE 802.11 9.2.12 */
796         for (i = 0; i < supp_rates_len; i++)
797                 if ((supp_rates[i] & 0x7f) * 5 > 110)
798                         have_higher_than_11mbit = 1;
799
800         if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
801             have_higher_than_11mbit)
802                 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
803         else
804                 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
805
806         ieee80211_set_wmm_default(sdata);
807 }
808
809 u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
810                               enum ieee80211_band band)
811 {
812         struct ieee80211_supported_band *sband;
813         struct ieee80211_rate *bitrates;
814         u32 mandatory_rates;
815         enum ieee80211_rate_flags mandatory_flag;
816         int i;
817
818         sband = local->hw.wiphy->bands[band];
819         if (!sband) {
820                 WARN_ON(1);
821                 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
822         }
823
824         if (band == IEEE80211_BAND_2GHZ)
825                 mandatory_flag = IEEE80211_RATE_MANDATORY_B;
826         else
827                 mandatory_flag = IEEE80211_RATE_MANDATORY_A;
828
829         bitrates = sband->bitrates;
830         mandatory_rates = 0;
831         for (i = 0; i < sband->n_bitrates; i++)
832                 if (bitrates[i].flags & mandatory_flag)
833                         mandatory_rates |= BIT(i);
834         return mandatory_rates;
835 }
836
837 void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
838                          u16 transaction, u16 auth_alg,
839                          u8 *extra, size_t extra_len, const u8 *bssid,
840                          const u8 *key, u8 key_len, u8 key_idx)
841 {
842         struct ieee80211_local *local = sdata->local;
843         struct sk_buff *skb;
844         struct ieee80211_mgmt *mgmt;
845         int err;
846
847         skb = dev_alloc_skb(local->hw.extra_tx_headroom +
848                             sizeof(*mgmt) + 6 + extra_len);
849         if (!skb) {
850                 printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
851                        "frame\n", sdata->name);
852                 return;
853         }
854         skb_reserve(skb, local->hw.extra_tx_headroom);
855
856         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
857         memset(mgmt, 0, 24 + 6);
858         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
859                                           IEEE80211_STYPE_AUTH);
860         memcpy(mgmt->da, bssid, ETH_ALEN);
861         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
862         memcpy(mgmt->bssid, bssid, ETH_ALEN);
863         mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
864         mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
865         mgmt->u.auth.status_code = cpu_to_le16(0);
866         if (extra)
867                 memcpy(skb_put(skb, extra_len), extra, extra_len);
868
869         if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
870                 mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
871                 err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
872                 WARN_ON(err);
873         }
874
875         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
876         ieee80211_tx_skb(sdata, skb);
877 }
878
879 int ieee80211_build_preq_ies(struct ieee80211_local *local, u8 *buffer,
880                              const u8 *ie, size_t ie_len,
881                              enum ieee80211_band band)
882 {
883         struct ieee80211_supported_band *sband;
884         u8 *pos, *supp_rates_len, *esupp_rates_len = NULL;
885         int i;
886
887         sband = local->hw.wiphy->bands[band];
888
889         pos = buffer;
890
891         *pos++ = WLAN_EID_SUPP_RATES;
892         supp_rates_len = pos;
893         *pos++ = 0;
894
895         for (i = 0; i < sband->n_bitrates; i++) {
896                 struct ieee80211_rate *rate = &sband->bitrates[i];
897
898                 if (esupp_rates_len) {
899                         *esupp_rates_len += 1;
900                 } else if (*supp_rates_len == 8) {
901                         *pos++ = WLAN_EID_EXT_SUPP_RATES;
902                         esupp_rates_len = pos;
903                         *pos++ = 1;
904                 } else
905                         *supp_rates_len += 1;
906
907                 *pos++ = rate->bitrate / 5;
908         }
909
910         if (sband->ht_cap.ht_supported) {
911                 u16 cap = sband->ht_cap.cap;
912                 __le16 tmp;
913
914                 if (ieee80211_disable_40mhz_24ghz &&
915                     sband->band == IEEE80211_BAND_2GHZ) {
916                         cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
917                         cap &= ~IEEE80211_HT_CAP_SGI_40;
918                 }
919
920                 *pos++ = WLAN_EID_HT_CAPABILITY;
921                 *pos++ = sizeof(struct ieee80211_ht_cap);
922                 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
923                 tmp = cpu_to_le16(cap);
924                 memcpy(pos, &tmp, sizeof(u16));
925                 pos += sizeof(u16);
926                 *pos++ = sband->ht_cap.ampdu_factor |
927                          (sband->ht_cap.ampdu_density <<
928                                 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
929                 memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
930                 pos += sizeof(sband->ht_cap.mcs);
931                 pos += 2 + 4 + 1; /* ext info, BF cap, antsel */
932         }
933
934         /*
935          * If adding more here, adjust code in main.c
936          * that calculates local->scan_ies_len.
937          */
938
939         if (ie) {
940                 memcpy(pos, ie, ie_len);
941                 pos += ie_len;
942         }
943
944         return pos - buffer;
945 }
946
947 void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
948                               const u8 *ssid, size_t ssid_len,
949                               const u8 *ie, size_t ie_len)
950 {
951         struct ieee80211_local *local = sdata->local;
952         struct sk_buff *skb;
953         struct ieee80211_mgmt *mgmt;
954         u8 *pos;
955
956         skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
957                             ie_len);
958         if (!skb) {
959                 printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
960                        "request\n", sdata->name);
961                 return;
962         }
963         skb_reserve(skb, local->hw.extra_tx_headroom);
964
965         mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
966         memset(mgmt, 0, 24);
967         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
968                                           IEEE80211_STYPE_PROBE_REQ);
969         memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
970         if (dst) {
971                 memcpy(mgmt->da, dst, ETH_ALEN);
972                 memcpy(mgmt->bssid, dst, ETH_ALEN);
973         } else {
974                 memset(mgmt->da, 0xff, ETH_ALEN);
975                 memset(mgmt->bssid, 0xff, ETH_ALEN);
976         }
977         pos = skb_put(skb, 2 + ssid_len);
978         *pos++ = WLAN_EID_SSID;
979         *pos++ = ssid_len;
980         memcpy(pos, ssid, ssid_len);
981         pos += ssid_len;
982
983         skb_put(skb, ieee80211_build_preq_ies(local, pos, ie, ie_len,
984                                               local->hw.conf.channel->band));
985
986         IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
987         ieee80211_tx_skb(sdata, skb);
988 }
989
990 u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
991                             struct ieee802_11_elems *elems,
992                             enum ieee80211_band band)
993 {
994         struct ieee80211_supported_band *sband;
995         struct ieee80211_rate *bitrates;
996         size_t num_rates;
997         u32 supp_rates;
998         int i, j;
999         sband = local->hw.wiphy->bands[band];
1000
1001         if (!sband) {
1002                 WARN_ON(1);
1003                 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1004         }
1005
1006         bitrates = sband->bitrates;
1007         num_rates = sband->n_bitrates;
1008         supp_rates = 0;
1009         for (i = 0; i < elems->supp_rates_len +
1010                      elems->ext_supp_rates_len; i++) {
1011                 u8 rate = 0;
1012                 int own_rate;
1013                 if (i < elems->supp_rates_len)
1014                         rate = elems->supp_rates[i];
1015                 else if (elems->ext_supp_rates)
1016                         rate = elems->ext_supp_rates
1017                                 [i - elems->supp_rates_len];
1018                 own_rate = 5 * (rate & 0x7f);
1019                 for (j = 0; j < num_rates; j++)
1020                         if (bitrates[j].bitrate == own_rate)
1021                                 supp_rates |= BIT(j);
1022         }
1023         return supp_rates;
1024 }
1025
1026 void ieee80211_stop_device(struct ieee80211_local *local)
1027 {
1028         ieee80211_led_radio(local, false);
1029
1030         cancel_work_sync(&local->reconfig_filter);
1031         drv_stop(local);
1032
1033         flush_workqueue(local->workqueue);
1034 }
1035
1036 int ieee80211_reconfig(struct ieee80211_local *local)
1037 {
1038         struct ieee80211_hw *hw = &local->hw;
1039         struct ieee80211_sub_if_data *sdata;
1040         struct ieee80211_if_init_conf conf;
1041         struct sta_info *sta;
1042         unsigned long flags;
1043         int res;
1044
1045         if (local->suspended)
1046                 local->resuming = true;
1047
1048         /* restart hardware */
1049         if (local->open_count) {
1050                 res = drv_start(local);
1051
1052                 ieee80211_led_radio(local, true);
1053         }
1054
1055         /* add interfaces */
1056         list_for_each_entry(sdata, &local->interfaces, list) {
1057                 if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1058                     sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1059                     netif_running(sdata->dev)) {
1060                         conf.vif = &sdata->vif;
1061                         conf.type = sdata->vif.type;
1062                         conf.mac_addr = sdata->vif.addr;
1063                         res = drv_add_interface(local, &conf);
1064                 }
1065         }
1066
1067         /* add STAs back */
1068         if (local->ops->sta_notify) {
1069                 spin_lock_irqsave(&local->sta_lock, flags);
1070                 list_for_each_entry(sta, &local->sta_list, list) {
1071                         sdata = sta->sdata;
1072                         if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
1073                                 sdata = container_of(sdata->bss,
1074                                              struct ieee80211_sub_if_data,
1075                                              u.ap);
1076
1077                         drv_sta_notify(local, sdata, STA_NOTIFY_ADD,
1078                                        &sta->sta);
1079                 }
1080                 spin_unlock_irqrestore(&local->sta_lock, flags);
1081         }
1082
1083         /* Clear Suspend state so that ADDBA requests can be processed */
1084
1085         rcu_read_lock();
1086
1087         if (hw->flags & IEEE80211_HW_AMPDU_AGGREGATION) {
1088                 list_for_each_entry_rcu(sta, &local->sta_list, list) {
1089                         clear_sta_flags(sta, WLAN_STA_SUSPEND);
1090                 }
1091         }
1092
1093         rcu_read_unlock();
1094
1095         /* setup RTS threshold */
1096         drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
1097
1098         /* reconfigure hardware */
1099         ieee80211_hw_config(local, ~0);
1100
1101         ieee80211_configure_filter(local);
1102
1103         /* Finally also reconfigure all the BSS information */
1104         list_for_each_entry(sdata, &local->interfaces, list) {
1105                 u32 changed = ~0;
1106                 if (!netif_running(sdata->dev))
1107                         continue;
1108                 switch (sdata->vif.type) {
1109                 case NL80211_IFTYPE_STATION:
1110                         /* disable beacon change bits */
1111                         changed &= ~(BSS_CHANGED_BEACON |
1112                                      BSS_CHANGED_BEACON_ENABLED);
1113                         /* fall through */
1114                 case NL80211_IFTYPE_ADHOC:
1115                 case NL80211_IFTYPE_AP:
1116                 case NL80211_IFTYPE_MESH_POINT:
1117                         ieee80211_bss_info_change_notify(sdata, changed);
1118                         break;
1119                 case NL80211_IFTYPE_WDS:
1120                         break;
1121                 case NL80211_IFTYPE_AP_VLAN:
1122                 case NL80211_IFTYPE_MONITOR:
1123                         /* ignore virtual */
1124                         break;
1125                 case NL80211_IFTYPE_UNSPECIFIED:
1126                 case __NL80211_IFTYPE_AFTER_LAST:
1127                         WARN_ON(1);
1128                         break;
1129                 }
1130         }
1131
1132         /* add back keys */
1133         list_for_each_entry(sdata, &local->interfaces, list)
1134                 if (netif_running(sdata->dev))
1135                         ieee80211_enable_keys(sdata);
1136
1137         ieee80211_wake_queues_by_reason(hw,
1138                         IEEE80211_QUEUE_STOP_REASON_SUSPEND);
1139
1140         /*
1141          * If this is for hw restart things are still running.
1142          * We may want to change that later, however.
1143          */
1144         if (!local->suspended)
1145                 return 0;
1146
1147 #ifdef CONFIG_PM
1148         /* first set suspended false, then resuming */
1149         local->suspended = false;
1150         mb();
1151         local->resuming = false;
1152
1153         list_for_each_entry(sdata, &local->interfaces, list) {
1154                 switch(sdata->vif.type) {
1155                 case NL80211_IFTYPE_STATION:
1156                         ieee80211_sta_restart(sdata);
1157                         break;
1158                 case NL80211_IFTYPE_ADHOC:
1159                         ieee80211_ibss_restart(sdata);
1160                         break;
1161                 case NL80211_IFTYPE_MESH_POINT:
1162                         ieee80211_mesh_restart(sdata);
1163                         break;
1164                 default:
1165                         break;
1166                 }
1167         }
1168
1169         add_timer(&local->sta_cleanup);
1170
1171         spin_lock_irqsave(&local->sta_lock, flags);
1172         list_for_each_entry(sta, &local->sta_list, list)
1173                 mesh_plink_restart(sta);
1174         spin_unlock_irqrestore(&local->sta_lock, flags);
1175 #else
1176         WARN_ON(1);
1177 #endif
1178         return 0;
1179 }
1180
1181 static int check_mgd_smps(struct ieee80211_if_managed *ifmgd,
1182                           enum ieee80211_smps_mode *smps_mode)
1183 {
1184         if (ifmgd->associated) {
1185                 *smps_mode = ifmgd->ap_smps;
1186
1187                 if (*smps_mode == IEEE80211_SMPS_AUTOMATIC) {
1188                         if (ifmgd->powersave)
1189                                 *smps_mode = IEEE80211_SMPS_DYNAMIC;
1190                         else
1191                                 *smps_mode = IEEE80211_SMPS_OFF;
1192                 }
1193
1194                 return 1;
1195         }
1196
1197         return 0;
1198 }
1199
1200 /* must hold iflist_mtx */
1201 void ieee80211_recalc_smps(struct ieee80211_local *local,
1202                            struct ieee80211_sub_if_data *forsdata)
1203 {
1204         struct ieee80211_sub_if_data *sdata;
1205         enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_OFF;
1206         int count = 0;
1207
1208         if (forsdata)
1209                 WARN_ON(!mutex_is_locked(&forsdata->u.mgd.mtx));
1210
1211         WARN_ON(!mutex_is_locked(&local->iflist_mtx));
1212
1213         /*
1214          * This function could be improved to handle multiple
1215          * interfaces better, but right now it makes any
1216          * non-station interfaces force SM PS to be turned
1217          * off. If there are multiple station interfaces it
1218          * could also use the best possible mode, e.g. if
1219          * one is in static and the other in dynamic then
1220          * dynamic is ok.
1221          */
1222
1223         list_for_each_entry(sdata, &local->interfaces, list) {
1224                 if (!netif_running(sdata->dev))
1225                         continue;
1226                 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1227                         goto set;
1228                 if (sdata != forsdata) {
1229                         /*
1230                          * This nested is ok -- we are holding the iflist_mtx
1231                          * so can't get here twice or so. But it's required
1232                          * since normally we acquire it first and then the
1233                          * iflist_mtx.
1234                          */
1235                         mutex_lock_nested(&sdata->u.mgd.mtx, SINGLE_DEPTH_NESTING);
1236                         count += check_mgd_smps(&sdata->u.mgd, &smps_mode);
1237                         mutex_unlock(&sdata->u.mgd.mtx);
1238                 } else
1239                         count += check_mgd_smps(&sdata->u.mgd, &smps_mode);
1240
1241                 if (count > 1) {
1242                         smps_mode = IEEE80211_SMPS_OFF;
1243                         break;
1244                 }
1245         }
1246
1247         if (smps_mode == local->smps_mode)
1248                 return;
1249
1250  set:
1251         local->smps_mode = smps_mode;
1252         /* changed flag is auto-detected for this */
1253         ieee80211_hw_config(local, 0);
1254 }