Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / mac80211 / main.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  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10
11 #include <net/mac80211.h>
12 #include <net/ieee80211_radiotap.h>
13 #include <linux/module.h>
14 #include <linux/init.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/rtnetlink.h>
23 #include <linux/bitmap.h>
24 #include <linux/pm_qos_params.h>
25 #include <net/net_namespace.h>
26 #include <net/cfg80211.h>
27
28 #include "ieee80211_i.h"
29 #include "rate.h"
30 #include "mesh.h"
31 #include "wep.h"
32 #include "wme.h"
33 #include "aes_ccm.h"
34 #include "led.h"
35 #include "cfg.h"
36 #include "debugfs.h"
37 #include "debugfs_netdev.h"
38
39 /*
40  * For seeing transmitted packets on monitor interfaces
41  * we have a radiotap header too.
42  */
43 struct ieee80211_tx_status_rtap_hdr {
44         struct ieee80211_radiotap_header hdr;
45         u8 rate;
46         u8 padding_for_rate;
47         __le16 tx_flags;
48         u8 data_retries;
49 } __attribute__ ((packed));
50
51
52 /* must be called under mdev tx lock */
53 void ieee80211_configure_filter(struct ieee80211_local *local)
54 {
55         unsigned int changed_flags;
56         unsigned int new_flags = 0;
57
58         if (atomic_read(&local->iff_promiscs))
59                 new_flags |= FIF_PROMISC_IN_BSS;
60
61         if (atomic_read(&local->iff_allmultis))
62                 new_flags |= FIF_ALLMULTI;
63
64         if (local->monitors)
65                 new_flags |= FIF_BCN_PRBRESP_PROMISC;
66
67         if (local->fif_fcsfail)
68                 new_flags |= FIF_FCSFAIL;
69
70         if (local->fif_plcpfail)
71                 new_flags |= FIF_PLCPFAIL;
72
73         if (local->fif_control)
74                 new_flags |= FIF_CONTROL;
75
76         if (local->fif_other_bss)
77                 new_flags |= FIF_OTHER_BSS;
78
79         changed_flags = local->filter_flags ^ new_flags;
80
81         /* be a bit nasty */
82         new_flags |= (1<<31);
83
84         local->ops->configure_filter(local_to_hw(local),
85                                      changed_flags, &new_flags,
86                                      local->mdev->mc_count,
87                                      local->mdev->mc_list);
88
89         WARN_ON(new_flags & (1<<31));
90
91         local->filter_flags = new_flags & ~(1<<31);
92 }
93
94 /* master interface */
95
96 static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
97 {
98         memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
99         return ETH_ALEN;
100 }
101
102 static const struct header_ops ieee80211_header_ops = {
103         .create         = eth_header,
104         .parse          = header_parse_80211,
105         .rebuild        = eth_rebuild_header,
106         .cache          = eth_header_cache,
107         .cache_update   = eth_header_cache_update,
108 };
109
110 static int ieee80211_master_open(struct net_device *dev)
111 {
112         struct ieee80211_master_priv *mpriv = netdev_priv(dev);
113         struct ieee80211_local *local = mpriv->local;
114         struct ieee80211_sub_if_data *sdata;
115         int res = -EOPNOTSUPP;
116
117         /* we hold the RTNL here so can safely walk the list */
118         list_for_each_entry(sdata, &local->interfaces, list) {
119                 if (netif_running(sdata->dev)) {
120                         res = 0;
121                         break;
122                 }
123         }
124
125         if (res)
126                 return res;
127
128         netif_tx_start_all_queues(local->mdev);
129
130         return 0;
131 }
132
133 static int ieee80211_master_stop(struct net_device *dev)
134 {
135         struct ieee80211_master_priv *mpriv = netdev_priv(dev);
136         struct ieee80211_local *local = mpriv->local;
137         struct ieee80211_sub_if_data *sdata;
138
139         /* we hold the RTNL here so can safely walk the list */
140         list_for_each_entry(sdata, &local->interfaces, list)
141                 if (netif_running(sdata->dev))
142                         dev_close(sdata->dev);
143
144         return 0;
145 }
146
147 static void ieee80211_master_set_multicast_list(struct net_device *dev)
148 {
149         struct ieee80211_master_priv *mpriv = netdev_priv(dev);
150         struct ieee80211_local *local = mpriv->local;
151
152         ieee80211_configure_filter(local);
153 }
154
155 /* everything else */
156
157 int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
158 {
159         struct ieee80211_local *local = sdata->local;
160         struct ieee80211_if_conf conf;
161
162         if (WARN_ON(!netif_running(sdata->dev)))
163                 return 0;
164
165         memset(&conf, 0, sizeof(conf));
166
167         if (sdata->vif.type == NL80211_IFTYPE_STATION)
168                 conf.bssid = sdata->u.mgd.bssid;
169         else if (sdata->vif.type == NL80211_IFTYPE_ADHOC)
170                 conf.bssid = sdata->u.ibss.bssid;
171         else if (sdata->vif.type == NL80211_IFTYPE_AP)
172                 conf.bssid = sdata->dev->dev_addr;
173         else if (ieee80211_vif_is_mesh(&sdata->vif)) {
174                 static const u8 zero[ETH_ALEN] = { 0 };
175                 conf.bssid = zero;
176         } else {
177                 WARN_ON(1);
178                 return -EINVAL;
179         }
180
181         if (!local->ops->config_interface)
182                 return 0;
183
184         switch (sdata->vif.type) {
185         case NL80211_IFTYPE_AP:
186         case NL80211_IFTYPE_ADHOC:
187         case NL80211_IFTYPE_MESH_POINT:
188                 break;
189         default:
190                 /* do not warn to simplify caller in scan.c */
191                 changed &= ~IEEE80211_IFCC_BEACON_ENABLED;
192                 if (WARN_ON(changed & IEEE80211_IFCC_BEACON))
193                         return -EINVAL;
194                 changed &= ~IEEE80211_IFCC_BEACON;
195                 break;
196         }
197
198         if (changed & IEEE80211_IFCC_BEACON_ENABLED) {
199                 if (local->sw_scanning) {
200                         conf.enable_beacon = false;
201                 } else {
202                         /*
203                          * Beacon should be enabled, but AP mode must
204                          * check whether there is a beacon configured.
205                          */
206                         switch (sdata->vif.type) {
207                         case NL80211_IFTYPE_AP:
208                                 conf.enable_beacon =
209                                         !!rcu_dereference(sdata->u.ap.beacon);
210                                 break;
211                         case NL80211_IFTYPE_ADHOC:
212                                 conf.enable_beacon = !!sdata->u.ibss.presp;
213                                 break;
214                         case NL80211_IFTYPE_MESH_POINT:
215                                 conf.enable_beacon = true;
216                                 break;
217                         default:
218                                 /* not reached */
219                                 WARN_ON(1);
220                                 break;
221                         }
222                 }
223         }
224
225         conf.changed = changed;
226
227         return local->ops->config_interface(local_to_hw(local),
228                                             &sdata->vif, &conf);
229 }
230
231 int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
232 {
233         struct ieee80211_channel *chan;
234         int ret = 0;
235         int power;
236         enum nl80211_channel_type channel_type;
237
238         might_sleep();
239
240         if (local->sw_scanning) {
241                 chan = local->scan_channel;
242                 channel_type = NL80211_CHAN_NO_HT;
243         } else {
244                 chan = local->oper_channel;
245                 channel_type = local->oper_channel_type;
246         }
247
248         if (chan != local->hw.conf.channel ||
249             channel_type != local->hw.conf.channel_type) {
250                 local->hw.conf.channel = chan;
251                 local->hw.conf.channel_type = channel_type;
252                 changed |= IEEE80211_CONF_CHANGE_CHANNEL;
253         }
254
255         if (local->sw_scanning)
256                 power = chan->max_power;
257         else
258                 power = local->power_constr_level ?
259                         (chan->max_power - local->power_constr_level) :
260                         chan->max_power;
261
262         if (local->user_power_level >= 0)
263                 power = min(power, local->user_power_level);
264
265         if (local->hw.conf.power_level != power) {
266                 changed |= IEEE80211_CONF_CHANGE_POWER;
267                 local->hw.conf.power_level = power;
268         }
269
270         if (changed && local->open_count) {
271                 ret = local->ops->config(local_to_hw(local), changed);
272                 /*
273                  * Goal:
274                  * HW reconfiguration should never fail, the driver has told
275                  * us what it can support so it should live up to that promise.
276                  *
277                  * Current status:
278                  * rfkill is not integrated with mac80211 and a
279                  * configuration command can thus fail if hardware rfkill
280                  * is enabled
281                  *
282                  * FIXME: integrate rfkill with mac80211 and then add this
283                  * WARN_ON() back
284                  *
285                  */
286                 /* WARN_ON(ret); */
287         }
288
289         return ret;
290 }
291
292 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
293                                       u32 changed)
294 {
295         struct ieee80211_local *local = sdata->local;
296
297         if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
298                 return;
299
300         if (!changed)
301                 return;
302
303         if (local->ops->bss_info_changed)
304                 local->ops->bss_info_changed(local_to_hw(local),
305                                              &sdata->vif,
306                                              &sdata->vif.bss_conf,
307                                              changed);
308 }
309
310 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
311 {
312         sdata->vif.bss_conf.use_cts_prot = false;
313         sdata->vif.bss_conf.use_short_preamble = false;
314         sdata->vif.bss_conf.use_short_slot = false;
315         return BSS_CHANGED_ERP_CTS_PROT |
316                BSS_CHANGED_ERP_PREAMBLE |
317                BSS_CHANGED_ERP_SLOT;
318 }
319
320 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
321                                  struct sk_buff *skb)
322 {
323         struct ieee80211_local *local = hw_to_local(hw);
324         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
325         int tmp;
326
327         skb->dev = local->mdev;
328         skb->pkt_type = IEEE80211_TX_STATUS_MSG;
329         skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
330                        &local->skb_queue : &local->skb_queue_unreliable, skb);
331         tmp = skb_queue_len(&local->skb_queue) +
332                 skb_queue_len(&local->skb_queue_unreliable);
333         while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
334                (skb = skb_dequeue(&local->skb_queue_unreliable))) {
335                 dev_kfree_skb_irq(skb);
336                 tmp--;
337                 I802_DEBUG_INC(local->tx_status_drop);
338         }
339         tasklet_schedule(&local->tasklet);
340 }
341 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
342
343 static void ieee80211_tasklet_handler(unsigned long data)
344 {
345         struct ieee80211_local *local = (struct ieee80211_local *) data;
346         struct sk_buff *skb;
347         struct ieee80211_rx_status rx_status;
348         struct ieee80211_ra_tid *ra_tid;
349
350         while ((skb = skb_dequeue(&local->skb_queue)) ||
351                (skb = skb_dequeue(&local->skb_queue_unreliable))) {
352                 switch (skb->pkt_type) {
353                 case IEEE80211_RX_MSG:
354                         /* status is in skb->cb */
355                         memcpy(&rx_status, skb->cb, sizeof(rx_status));
356                         /* Clear skb->pkt_type in order to not confuse kernel
357                          * netstack. */
358                         skb->pkt_type = 0;
359                         __ieee80211_rx(local_to_hw(local), skb, &rx_status);
360                         break;
361                 case IEEE80211_TX_STATUS_MSG:
362                         skb->pkt_type = 0;
363                         ieee80211_tx_status(local_to_hw(local), skb);
364                         break;
365                 case IEEE80211_DELBA_MSG:
366                         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
367                         ieee80211_stop_tx_ba_cb(local_to_hw(local),
368                                                 ra_tid->ra, ra_tid->tid);
369                         dev_kfree_skb(skb);
370                         break;
371                 case IEEE80211_ADDBA_MSG:
372                         ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
373                         ieee80211_start_tx_ba_cb(local_to_hw(local),
374                                                  ra_tid->ra, ra_tid->tid);
375                         dev_kfree_skb(skb);
376                         break ;
377                 default:
378                         WARN(1, "mac80211: Packet is of unknown type %d\n",
379                              skb->pkt_type);
380                         dev_kfree_skb(skb);
381                         break;
382                 }
383         }
384 }
385
386 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
387  * make a prepared TX frame (one that has been given to hw) to look like brand
388  * new IEEE 802.11 frame that is ready to go through TX processing again.
389  */
390 static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
391                                       struct ieee80211_key *key,
392                                       struct sk_buff *skb)
393 {
394         unsigned int hdrlen, iv_len, mic_len;
395         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
396
397         hdrlen = ieee80211_hdrlen(hdr->frame_control);
398
399         if (!key)
400                 goto no_key;
401
402         switch (key->conf.alg) {
403         case ALG_WEP:
404                 iv_len = WEP_IV_LEN;
405                 mic_len = WEP_ICV_LEN;
406                 break;
407         case ALG_TKIP:
408                 iv_len = TKIP_IV_LEN;
409                 mic_len = TKIP_ICV_LEN;
410                 break;
411         case ALG_CCMP:
412                 iv_len = CCMP_HDR_LEN;
413                 mic_len = CCMP_MIC_LEN;
414                 break;
415         default:
416                 goto no_key;
417         }
418
419         if (skb->len >= hdrlen + mic_len &&
420             !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
421                 skb_trim(skb, skb->len - mic_len);
422         if (skb->len >= hdrlen + iv_len) {
423                 memmove(skb->data + iv_len, skb->data, hdrlen);
424                 hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
425         }
426
427 no_key:
428         if (ieee80211_is_data_qos(hdr->frame_control)) {
429                 hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
430                 memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
431                         hdrlen - IEEE80211_QOS_CTL_LEN);
432                 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
433         }
434 }
435
436 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
437                                             struct sta_info *sta,
438                                             struct sk_buff *skb)
439 {
440         sta->tx_filtered_count++;
441
442         /*
443          * Clear the TX filter mask for this STA when sending the next
444          * packet. If the STA went to power save mode, this will happen
445          * when it wakes up for the next time.
446          */
447         set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
448
449         /*
450          * This code races in the following way:
451          *
452          *  (1) STA sends frame indicating it will go to sleep and does so
453          *  (2) hardware/firmware adds STA to filter list, passes frame up
454          *  (3) hardware/firmware processes TX fifo and suppresses a frame
455          *  (4) we get TX status before having processed the frame and
456          *      knowing that the STA has gone to sleep.
457          *
458          * This is actually quite unlikely even when both those events are
459          * processed from interrupts coming in quickly after one another or
460          * even at the same time because we queue both TX status events and
461          * RX frames to be processed by a tasklet and process them in the
462          * same order that they were received or TX status last. Hence, there
463          * is no race as long as the frame RX is processed before the next TX
464          * status, which drivers can ensure, see below.
465          *
466          * Note that this can only happen if the hardware or firmware can
467          * actually add STAs to the filter list, if this is done by the
468          * driver in response to set_tim() (which will only reduce the race
469          * this whole filtering tries to solve, not completely solve it)
470          * this situation cannot happen.
471          *
472          * To completely solve this race drivers need to make sure that they
473          *  (a) don't mix the irq-safe/not irq-safe TX status/RX processing
474          *      functions and
475          *  (b) always process RX events before TX status events if ordering
476          *      can be unknown, for example with different interrupt status
477          *      bits.
478          */
479         if (test_sta_flags(sta, WLAN_STA_PS) &&
480             skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
481                 ieee80211_remove_tx_extra(local, sta->key, skb);
482                 skb_queue_tail(&sta->tx_filtered, skb);
483                 return;
484         }
485
486         if (!test_sta_flags(sta, WLAN_STA_PS) && !skb->requeue) {
487                 /* Software retry the packet once */
488                 skb->requeue = 1;
489                 ieee80211_remove_tx_extra(local, sta->key, skb);
490                 dev_queue_xmit(skb);
491                 return;
492         }
493
494 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
495         if (net_ratelimit())
496                 printk(KERN_DEBUG "%s: dropped TX filtered frame, "
497                        "queue_len=%d PS=%d @%lu\n",
498                        wiphy_name(local->hw.wiphy),
499                        skb_queue_len(&sta->tx_filtered),
500                        !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
501 #endif
502         dev_kfree_skb(skb);
503 }
504
505 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
506 {
507         struct sk_buff *skb2;
508         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
509         struct ieee80211_local *local = hw_to_local(hw);
510         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
511         u16 frag, type;
512         __le16 fc;
513         struct ieee80211_supported_band *sband;
514         struct ieee80211_tx_status_rtap_hdr *rthdr;
515         struct ieee80211_sub_if_data *sdata;
516         struct net_device *prev_dev = NULL;
517         struct sta_info *sta;
518         int retry_count = -1, i;
519
520         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
521                 /* the HW cannot have attempted that rate */
522                 if (i >= hw->max_rates) {
523                         info->status.rates[i].idx = -1;
524                         info->status.rates[i].count = 0;
525                 }
526
527                 retry_count += info->status.rates[i].count;
528         }
529         if (retry_count < 0)
530                 retry_count = 0;
531
532         rcu_read_lock();
533
534         sband = local->hw.wiphy->bands[info->band];
535
536         sta = sta_info_get(local, hdr->addr1);
537
538         if (sta) {
539                 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
540                     test_sta_flags(sta, WLAN_STA_PS)) {
541                         /*
542                          * The STA is in power save mode, so assume
543                          * that this TX packet failed because of that.
544                          */
545                         ieee80211_handle_filtered_frame(local, sta, skb);
546                         rcu_read_unlock();
547                         return;
548                 }
549
550                 fc = hdr->frame_control;
551
552                 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
553                     (ieee80211_is_data_qos(fc))) {
554                         u16 tid, ssn;
555                         u8 *qc;
556
557                         qc = ieee80211_get_qos_ctl(hdr);
558                         tid = qc[0] & 0xf;
559                         ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
560                                                 & IEEE80211_SCTL_SEQ);
561                         ieee80211_send_bar(sta->sdata, hdr->addr1,
562                                            tid, ssn);
563                 }
564
565                 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
566                         ieee80211_handle_filtered_frame(local, sta, skb);
567                         rcu_read_unlock();
568                         return;
569                 } else {
570                         if (!(info->flags & IEEE80211_TX_STAT_ACK))
571                                 sta->tx_retry_failed++;
572                         sta->tx_retry_count += retry_count;
573                 }
574
575                 rate_control_tx_status(local, sband, sta, skb);
576         }
577
578         rcu_read_unlock();
579
580         ieee80211_led_tx(local, 0);
581
582         /* SNMP counters
583          * Fragments are passed to low-level drivers as separate skbs, so these
584          * are actually fragments, not frames. Update frame counters only for
585          * the first fragment of the frame. */
586
587         frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
588         type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;
589
590         if (info->flags & IEEE80211_TX_STAT_ACK) {
591                 if (frag == 0) {
592                         local->dot11TransmittedFrameCount++;
593                         if (is_multicast_ether_addr(hdr->addr1))
594                                 local->dot11MulticastTransmittedFrameCount++;
595                         if (retry_count > 0)
596                                 local->dot11RetryCount++;
597                         if (retry_count > 1)
598                                 local->dot11MultipleRetryCount++;
599                 }
600
601                 /* This counter shall be incremented for an acknowledged MPDU
602                  * with an individual address in the address 1 field or an MPDU
603                  * with a multicast address in the address 1 field of type Data
604                  * or Management. */
605                 if (!is_multicast_ether_addr(hdr->addr1) ||
606                     type == IEEE80211_FTYPE_DATA ||
607                     type == IEEE80211_FTYPE_MGMT)
608                         local->dot11TransmittedFragmentCount++;
609         } else {
610                 if (frag == 0)
611                         local->dot11FailedCount++;
612         }
613
614         /* this was a transmitted frame, but now we want to reuse it */
615         skb_orphan(skb);
616
617         /*
618          * This is a bit racy but we can avoid a lot of work
619          * with this test...
620          */
621         if (!local->monitors && !local->cooked_mntrs) {
622                 dev_kfree_skb(skb);
623                 return;
624         }
625
626         /* send frame to monitor interfaces now */
627
628         if (skb_headroom(skb) < sizeof(*rthdr)) {
629                 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
630                 dev_kfree_skb(skb);
631                 return;
632         }
633
634         rthdr = (struct ieee80211_tx_status_rtap_hdr *)
635                                 skb_push(skb, sizeof(*rthdr));
636
637         memset(rthdr, 0, sizeof(*rthdr));
638         rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
639         rthdr->hdr.it_present =
640                 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
641                             (1 << IEEE80211_RADIOTAP_DATA_RETRIES) |
642                             (1 << IEEE80211_RADIOTAP_RATE));
643
644         if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
645             !is_multicast_ether_addr(hdr->addr1))
646                 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
647
648         /*
649          * XXX: Once radiotap gets the bitmap reset thing the vendor
650          *      extensions proposal contains, we can actually report
651          *      the whole set of tries we did.
652          */
653         if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
654             (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
655                 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
656         else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
657                 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
658         if (info->status.rates[0].idx >= 0 &&
659             !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
660                 rthdr->rate = sband->bitrates[
661                                 info->status.rates[0].idx].bitrate / 5;
662
663         /* for now report the total retry_count */
664         rthdr->data_retries = retry_count;
665
666         /* XXX: is this sufficient for BPF? */
667         skb_set_mac_header(skb, 0);
668         skb->ip_summed = CHECKSUM_UNNECESSARY;
669         skb->pkt_type = PACKET_OTHERHOST;
670         skb->protocol = htons(ETH_P_802_2);
671         memset(skb->cb, 0, sizeof(skb->cb));
672
673         rcu_read_lock();
674         list_for_each_entry_rcu(sdata, &local->interfaces, list) {
675                 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
676                         if (!netif_running(sdata->dev))
677                                 continue;
678
679                         if (prev_dev) {
680                                 skb2 = skb_clone(skb, GFP_ATOMIC);
681                                 if (skb2) {
682                                         skb2->dev = prev_dev;
683                                         netif_rx(skb2);
684                                 }
685                         }
686
687                         prev_dev = sdata->dev;
688                 }
689         }
690         if (prev_dev) {
691                 skb->dev = prev_dev;
692                 netif_rx(skb);
693                 skb = NULL;
694         }
695         rcu_read_unlock();
696         dev_kfree_skb(skb);
697 }
698 EXPORT_SYMBOL(ieee80211_tx_status);
699
700 static void ieee80211_restart_work(struct work_struct *work)
701 {
702         struct ieee80211_local *local =
703                 container_of(work, struct ieee80211_local, restart_work);
704
705         rtnl_lock();
706         ieee80211_reconfig(local);
707         rtnl_unlock();
708 }
709
710 void ieee80211_restart_hw(struct ieee80211_hw *hw)
711 {
712         struct ieee80211_local *local = hw_to_local(hw);
713
714         /* use this reason, __ieee80211_resume will unblock it */
715         ieee80211_stop_queues_by_reason(hw,
716                 IEEE80211_QUEUE_STOP_REASON_SUSPEND);
717
718         schedule_work(&local->restart_work);
719 }
720 EXPORT_SYMBOL(ieee80211_restart_hw);
721
722 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
723                                         const struct ieee80211_ops *ops)
724 {
725         struct ieee80211_local *local;
726         int priv_size, i;
727         struct wiphy *wiphy;
728
729         /* Ensure 32-byte alignment of our private data and hw private data.
730          * We use the wiphy priv data for both our ieee80211_local and for
731          * the driver's private data
732          *
733          * In memory it'll be like this:
734          *
735          * +-------------------------+
736          * | struct wiphy           |
737          * +-------------------------+
738          * | struct ieee80211_local  |
739          * +-------------------------+
740          * | driver's private data   |
741          * +-------------------------+
742          *
743          */
744         priv_size = ((sizeof(struct ieee80211_local) +
745                       NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
746                     priv_data_len;
747
748         wiphy = wiphy_new(&mac80211_config_ops, priv_size);
749
750         if (!wiphy)
751                 return NULL;
752
753         wiphy->privid = mac80211_wiphy_privid;
754
755         /* Yes, putting cfg80211_bss into ieee80211_bss is a hack */
756         wiphy->bss_priv_size = sizeof(struct ieee80211_bss) -
757                                sizeof(struct cfg80211_bss);
758
759         local = wiphy_priv(wiphy);
760
761         local->hw.wiphy = wiphy;
762
763         local->hw.priv = (char *)local +
764                          ((sizeof(struct ieee80211_local) +
765                            NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
766
767         BUG_ON(!ops->tx);
768         BUG_ON(!ops->start);
769         BUG_ON(!ops->stop);
770         BUG_ON(!ops->config);
771         BUG_ON(!ops->add_interface);
772         BUG_ON(!ops->remove_interface);
773         BUG_ON(!ops->configure_filter);
774         local->ops = ops;
775
776         /* set up some defaults */
777         local->hw.queues = 1;
778         local->hw.max_rates = 1;
779         local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
780         local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
781         local->hw.conf.radio_enabled = true;
782         local->user_power_level = -1;
783
784         INIT_LIST_HEAD(&local->interfaces);
785         mutex_init(&local->iflist_mtx);
786
787         spin_lock_init(&local->key_lock);
788
789         spin_lock_init(&local->queue_stop_reason_lock);
790
791         INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
792
793         INIT_WORK(&local->restart_work, ieee80211_restart_work);
794
795         INIT_WORK(&local->dynamic_ps_enable_work,
796                   ieee80211_dynamic_ps_enable_work);
797         INIT_WORK(&local->dynamic_ps_disable_work,
798                   ieee80211_dynamic_ps_disable_work);
799         setup_timer(&local->dynamic_ps_timer,
800                     ieee80211_dynamic_ps_timer, (unsigned long) local);
801
802         sta_info_init(local);
803
804         for (i = 0; i < IEEE80211_MAX_QUEUES; i++)
805                 skb_queue_head_init(&local->pending[i]);
806         tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
807                      (unsigned long)local);
808         tasklet_disable(&local->tx_pending_tasklet);
809
810         tasklet_init(&local->tasklet,
811                      ieee80211_tasklet_handler,
812                      (unsigned long) local);
813         tasklet_disable(&local->tasklet);
814
815         skb_queue_head_init(&local->skb_queue);
816         skb_queue_head_init(&local->skb_queue_unreliable);
817
818         spin_lock_init(&local->ampdu_lock);
819
820         return local_to_hw(local);
821 }
822 EXPORT_SYMBOL(ieee80211_alloc_hw);
823
824 static const struct net_device_ops ieee80211_master_ops = {
825         .ndo_start_xmit = ieee80211_master_start_xmit,
826         .ndo_open = ieee80211_master_open,
827         .ndo_stop = ieee80211_master_stop,
828         .ndo_set_multicast_list = ieee80211_master_set_multicast_list,
829         .ndo_select_queue = ieee80211_select_queue,
830 };
831
832 static void ieee80211_master_setup(struct net_device *mdev)
833 {
834         mdev->type = ARPHRD_IEEE80211;
835         mdev->netdev_ops = &ieee80211_master_ops;
836         mdev->header_ops = &ieee80211_header_ops;
837         mdev->tx_queue_len = 1000;
838         mdev->addr_len = ETH_ALEN;
839 }
840
841 int ieee80211_register_hw(struct ieee80211_hw *hw)
842 {
843         struct ieee80211_local *local = hw_to_local(hw);
844         int result;
845         enum ieee80211_band band;
846         struct net_device *mdev;
847         struct ieee80211_master_priv *mpriv;
848         int channels, i, j, max_bitrates;
849         bool supp_ht;
850         static const u32 cipher_suites[] = {
851                 WLAN_CIPHER_SUITE_WEP40,
852                 WLAN_CIPHER_SUITE_WEP104,
853                 WLAN_CIPHER_SUITE_TKIP,
854                 WLAN_CIPHER_SUITE_CCMP,
855
856                 /* keep last -- depends on hw flags! */
857                 WLAN_CIPHER_SUITE_AES_CMAC
858         };
859
860         /*
861          * generic code guarantees at least one band,
862          * set this very early because much code assumes
863          * that hw.conf.channel is assigned
864          */
865         channels = 0;
866         max_bitrates = 0;
867         supp_ht = false;
868         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
869                 struct ieee80211_supported_band *sband;
870
871                 sband = local->hw.wiphy->bands[band];
872                 if (!sband)
873                         continue;
874                 if (!local->oper_channel) {
875                         /* init channel we're on */
876                         local->hw.conf.channel =
877                         local->oper_channel =
878                         local->scan_channel = &sband->channels[0];
879                 }
880                 channels += sband->n_channels;
881
882                 if (max_bitrates < sband->n_bitrates)
883                         max_bitrates = sband->n_bitrates;
884                 supp_ht = supp_ht || sband->ht_cap.ht_supported;
885         }
886
887         local->int_scan_req.n_channels = channels;
888         local->int_scan_req.channels = kzalloc(sizeof(void *) * channels, GFP_KERNEL);
889         if (!local->int_scan_req.channels)
890                 return -ENOMEM;
891
892         /* if low-level driver supports AP, we also support VLAN */
893         if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP))
894                 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
895
896         /* mac80211 always supports monitor */
897         local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
898
899         if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
900                 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
901         else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
902                 local->hw.wiphy->signal_type = CFG80211_SIGNAL_TYPE_UNSPEC;
903
904         /*
905          * Calculate scan IE length -- we need this to alloc
906          * memory and to subtract from the driver limit. It
907          * includes the (extended) supported rates and HT
908          * information -- SSID is the driver's responsibility.
909          */
910         local->scan_ies_len = 4 + max_bitrates; /* (ext) supp rates */
911         if (supp_ht)
912                 local->scan_ies_len += 2 + sizeof(struct ieee80211_ht_cap);
913
914         if (!local->ops->hw_scan) {
915                 /* For hw_scan, driver needs to set these up. */
916                 local->hw.wiphy->max_scan_ssids = 4;
917                 local->hw.wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
918         }
919
920         /*
921          * If the driver supports any scan IEs, then assume the
922          * limit includes the IEs mac80211 will add, otherwise
923          * leave it at zero and let the driver sort it out; we
924          * still pass our IEs to the driver but userspace will
925          * not be allowed to in that case.
926          */
927         if (local->hw.wiphy->max_scan_ie_len)
928                 local->hw.wiphy->max_scan_ie_len -= local->scan_ies_len;
929
930         local->hw.wiphy->cipher_suites = cipher_suites;
931         local->hw.wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
932         if (!(local->hw.flags & IEEE80211_HW_MFP_CAPABLE))
933                 local->hw.wiphy->n_cipher_suites--;
934
935         result = wiphy_register(local->hw.wiphy);
936         if (result < 0)
937                 goto fail_wiphy_register;
938
939         /*
940          * We use the number of queues for feature tests (QoS, HT) internally
941          * so restrict them appropriately.
942          */
943         if (hw->queues > IEEE80211_MAX_QUEUES)
944                 hw->queues = IEEE80211_MAX_QUEUES;
945
946         mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv),
947                                "wmaster%d", ieee80211_master_setup,
948                                hw->queues);
949         if (!mdev)
950                 goto fail_mdev_alloc;
951
952         mpriv = netdev_priv(mdev);
953         mpriv->local = local;
954         local->mdev = mdev;
955
956         local->hw.workqueue =
957                 create_singlethread_workqueue(wiphy_name(local->hw.wiphy));
958         if (!local->hw.workqueue) {
959                 result = -ENOMEM;
960                 goto fail_workqueue;
961         }
962
963         /*
964          * The hardware needs headroom for sending the frame,
965          * and we need some headroom for passing the frame to monitor
966          * interfaces, but never both at the same time.
967          */
968         local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
969                                    sizeof(struct ieee80211_tx_status_rtap_hdr));
970
971         debugfs_hw_add(local);
972
973         if (local->hw.conf.beacon_int < 10)
974                 local->hw.conf.beacon_int = 100;
975
976         if (local->hw.max_listen_interval == 0)
977                 local->hw.max_listen_interval = 1;
978
979         local->hw.conf.listen_interval = local->hw.max_listen_interval;
980
981         result = sta_info_start(local);
982         if (result < 0)
983                 goto fail_sta_info;
984
985         result = ieee80211_wep_init(local);
986         if (result < 0) {
987                 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
988                        wiphy_name(local->hw.wiphy), result);
989                 goto fail_wep;
990         }
991
992         rtnl_lock();
993         result = dev_alloc_name(local->mdev, local->mdev->name);
994         if (result < 0)
995                 goto fail_dev;
996
997         memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
998         SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));
999         local->mdev->features |= NETIF_F_NETNS_LOCAL;
1000
1001         result = register_netdevice(local->mdev);
1002         if (result < 0)
1003                 goto fail_dev;
1004
1005         result = ieee80211_init_rate_ctrl_alg(local,
1006                                               hw->rate_control_algorithm);
1007         if (result < 0) {
1008                 printk(KERN_DEBUG "%s: Failed to initialize rate control "
1009                        "algorithm\n", wiphy_name(local->hw.wiphy));
1010                 goto fail_rate;
1011         }
1012
1013         /* add one default STA interface if supported */
1014         if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_STATION)) {
1015                 result = ieee80211_if_add(local, "wlan%d", NULL,
1016                                           NL80211_IFTYPE_STATION, NULL);
1017                 if (result)
1018                         printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
1019                                wiphy_name(local->hw.wiphy));
1020         }
1021
1022         rtnl_unlock();
1023
1024         ieee80211_led_init(local);
1025
1026         /* alloc internal scan request */
1027         i = 0;
1028         local->int_scan_req.ssids = &local->scan_ssid;
1029         local->int_scan_req.n_ssids = 1;
1030         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1031                 if (!hw->wiphy->bands[band])
1032                         continue;
1033                 for (j = 0; j < hw->wiphy->bands[band]->n_channels; j++) {
1034                         local->int_scan_req.channels[i] =
1035                                 &hw->wiphy->bands[band]->channels[j];
1036                         i++;
1037                 }
1038         }
1039
1040         local->network_latency_notifier.notifier_call =
1041                 ieee80211_max_network_latency;
1042         result = pm_qos_add_notifier(PM_QOS_NETWORK_LATENCY,
1043                                      &local->network_latency_notifier);
1044
1045         if (result) {
1046                 rtnl_lock();
1047                 goto fail_pm_qos;
1048         }
1049
1050         return 0;
1051
1052  fail_pm_qos:
1053         ieee80211_led_exit(local);
1054         ieee80211_remove_interfaces(local);
1055  fail_rate:
1056         unregister_netdevice(local->mdev);
1057         local->mdev = NULL;
1058  fail_dev:
1059         rtnl_unlock();
1060         ieee80211_wep_free(local);
1061  fail_wep:
1062         sta_info_stop(local);
1063  fail_sta_info:
1064         debugfs_hw_del(local);
1065         destroy_workqueue(local->hw.workqueue);
1066  fail_workqueue:
1067         if (local->mdev)
1068                 free_netdev(local->mdev);
1069  fail_mdev_alloc:
1070         wiphy_unregister(local->hw.wiphy);
1071  fail_wiphy_register:
1072         kfree(local->int_scan_req.channels);
1073         return result;
1074 }
1075 EXPORT_SYMBOL(ieee80211_register_hw);
1076
1077 void ieee80211_unregister_hw(struct ieee80211_hw *hw)
1078 {
1079         struct ieee80211_local *local = hw_to_local(hw);
1080
1081         tasklet_kill(&local->tx_pending_tasklet);
1082         tasklet_kill(&local->tasklet);
1083
1084         pm_qos_remove_notifier(PM_QOS_NETWORK_LATENCY,
1085                                &local->network_latency_notifier);
1086
1087         rtnl_lock();
1088
1089         /*
1090          * At this point, interface list manipulations are fine
1091          * because the driver cannot be handing us frames any
1092          * more and the tasklet is killed.
1093          */
1094
1095         /* First, we remove all virtual interfaces. */
1096         ieee80211_remove_interfaces(local);
1097
1098         /* then, finally, remove the master interface */
1099         unregister_netdevice(local->mdev);
1100
1101         rtnl_unlock();
1102
1103         ieee80211_clear_tx_pending(local);
1104         sta_info_stop(local);
1105         rate_control_deinitialize(local);
1106         debugfs_hw_del(local);
1107
1108         if (skb_queue_len(&local->skb_queue)
1109                         || skb_queue_len(&local->skb_queue_unreliable))
1110                 printk(KERN_WARNING "%s: skb_queue not empty\n",
1111                        wiphy_name(local->hw.wiphy));
1112         skb_queue_purge(&local->skb_queue);
1113         skb_queue_purge(&local->skb_queue_unreliable);
1114
1115         destroy_workqueue(local->hw.workqueue);
1116         wiphy_unregister(local->hw.wiphy);
1117         ieee80211_wep_free(local);
1118         ieee80211_led_exit(local);
1119         free_netdev(local->mdev);
1120         kfree(local->int_scan_req.channels);
1121 }
1122 EXPORT_SYMBOL(ieee80211_unregister_hw);
1123
1124 void ieee80211_free_hw(struct ieee80211_hw *hw)
1125 {
1126         struct ieee80211_local *local = hw_to_local(hw);
1127
1128         mutex_destroy(&local->iflist_mtx);
1129
1130         wiphy_free(local->hw.wiphy);
1131 }
1132 EXPORT_SYMBOL(ieee80211_free_hw);
1133
1134 static int __init ieee80211_init(void)
1135 {
1136         struct sk_buff *skb;
1137         int ret;
1138
1139         BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
1140         BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
1141                      IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
1142
1143         ret = rc80211_minstrel_init();
1144         if (ret)
1145                 return ret;
1146
1147         ret = rc80211_pid_init();
1148         if (ret)
1149                 return ret;
1150
1151         ieee80211_debugfs_netdev_init();
1152
1153         return 0;
1154 }
1155
1156 static void __exit ieee80211_exit(void)
1157 {
1158         rc80211_pid_exit();
1159         rc80211_minstrel_exit();
1160
1161         /*
1162          * For key todo, it'll be empty by now but the work
1163          * might still be scheduled.
1164          */
1165         flush_scheduled_work();
1166
1167         if (mesh_allocated)
1168                 ieee80211s_stop();
1169
1170         ieee80211_debugfs_netdev_exit();
1171 }
1172
1173
1174 subsys_initcall(ieee80211_init);
1175 module_exit(ieee80211_exit);
1176
1177 MODULE_DESCRIPTION("IEEE 802.11 subsystem");
1178 MODULE_LICENSE("GPL");