blob: 29c3ecf7e914c4722734ef51f667611325a2dc0a [file] [log] [blame]
Jiri Bencf0706e82007-05-05 11:45:53 -07001/*
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>
Jiri Bencf0706e82007-05-05 11:45:53 -070023#include <linux/bitmap.h>
Eric W. Biederman881d9662007-09-17 11:56:21 -070024#include <net/net_namespace.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070025#include <net/cfg80211.h>
26
Jiri Bencf0706e82007-05-05 11:45:53 -070027#include "ieee80211_i.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040028#include "rate.h"
Luis Carlos Cobof7a92142008-02-23 15:17:18 +010029#include "mesh.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070030#include "wep.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070031#include "wme.h"
32#include "aes_ccm.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040033#include "led.h"
Michael Wue0eb6852007-09-18 17:29:21 -040034#include "cfg.h"
Jiri Bence9f207f2007-05-05 11:46:38 -070035#include "debugfs.h"
36#include "debugfs_netdev.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070037
Johannes Bergb306f452007-07-10 19:32:08 +020038/*
39 * For seeing transmitted packets on monitor interfaces
40 * we have a radiotap header too.
41 */
42struct ieee80211_tx_status_rtap_hdr {
43 struct ieee80211_radiotap_header hdr;
Johannes Berge6a98542008-10-21 12:40:02 +020044 u8 rate;
45 u8 padding_for_rate;
Johannes Bergb306f452007-07-10 19:32:08 +020046 __le16 tx_flags;
47 u8 data_retries;
48} __attribute__ ((packed));
49
Jiri Bencf0706e82007-05-05 11:45:53 -070050
Johannes Berg4150c572007-09-17 01:29:23 -040051/* must be called under mdev tx lock */
Johannes Berg0d143fe2008-09-11 00:01:59 +020052void ieee80211_configure_filter(struct ieee80211_local *local)
Johannes Berg4150c572007-09-17 01:29:23 -040053{
54 unsigned int changed_flags;
55 unsigned int new_flags = 0;
56
Johannes Berg53918992007-09-26 15:19:47 +020057 if (atomic_read(&local->iff_promiscs))
Johannes Berg4150c572007-09-17 01:29:23 -040058 new_flags |= FIF_PROMISC_IN_BSS;
59
Johannes Berg53918992007-09-26 15:19:47 +020060 if (atomic_read(&local->iff_allmultis))
Johannes Berg4150c572007-09-17 01:29:23 -040061 new_flags |= FIF_ALLMULTI;
62
63 if (local->monitors)
Michael Wu8cc9a732008-01-31 19:48:23 +010064 new_flags |= FIF_BCN_PRBRESP_PROMISC;
65
66 if (local->fif_fcsfail)
67 new_flags |= FIF_FCSFAIL;
68
69 if (local->fif_plcpfail)
70 new_flags |= FIF_PLCPFAIL;
71
72 if (local->fif_control)
73 new_flags |= FIF_CONTROL;
74
75 if (local->fif_other_bss)
76 new_flags |= FIF_OTHER_BSS;
Johannes Berg4150c572007-09-17 01:29:23 -040077
78 changed_flags = local->filter_flags ^ new_flags;
79
80 /* be a bit nasty */
81 new_flags |= (1<<31);
82
83 local->ops->configure_filter(local_to_hw(local),
84 changed_flags, &new_flags,
85 local->mdev->mc_count,
86 local->mdev->mc_list);
87
88 WARN_ON(new_flags & (1<<31));
89
90 local->filter_flags = new_flags & ~(1<<31);
91}
92
Johannes Bergb2c258f2007-07-27 15:43:23 +020093/* master interface */
Jiri Bencf0706e82007-05-05 11:45:53 -070094
Johannes Berg0d143fe2008-09-11 00:01:59 +020095static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
96{
97 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
98 return ETH_ALEN;
99}
100
101static const struct header_ops ieee80211_header_ops = {
102 .create = eth_header,
103 .parse = header_parse_80211,
104 .rebuild = eth_rebuild_header,
105 .cache = eth_header_cache,
106 .cache_update = eth_header_cache_update,
107};
108
Jiri Bencf0706e82007-05-05 11:45:53 -0700109static int ieee80211_master_open(struct net_device *dev)
110{
Johannes Berg133b8222008-09-16 14:18:59 +0200111 struct ieee80211_master_priv *mpriv = netdev_priv(dev);
112 struct ieee80211_local *local = mpriv->local;
Jiri Bencf0706e82007-05-05 11:45:53 -0700113 struct ieee80211_sub_if_data *sdata;
114 int res = -EOPNOTSUPP;
115
Johannes Berg79010422007-09-18 17:29:21 -0400116 /* we hold the RTNL here so can safely walk the list */
117 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg3e122be2008-07-09 14:40:34 +0200118 if (netif_running(sdata->dev)) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700119 res = 0;
120 break;
121 }
122 }
Johannes Berg36d68252008-05-15 12:55:26 +0200123
124 if (res)
125 return res;
126
David S. Miller51cb6db2008-07-15 03:34:57 -0700127 netif_tx_start_all_queues(local->mdev);
Johannes Berg36d68252008-05-15 12:55:26 +0200128
129 return 0;
Jiri Bencf0706e82007-05-05 11:45:53 -0700130}
131
132static int ieee80211_master_stop(struct net_device *dev)
133{
Johannes Berg133b8222008-09-16 14:18:59 +0200134 struct ieee80211_master_priv *mpriv = netdev_priv(dev);
135 struct ieee80211_local *local = mpriv->local;
Jiri Bencf0706e82007-05-05 11:45:53 -0700136 struct ieee80211_sub_if_data *sdata;
137
Johannes Berg79010422007-09-18 17:29:21 -0400138 /* we hold the RTNL here so can safely walk the list */
139 list_for_each_entry(sdata, &local->interfaces, list)
Johannes Berg3e122be2008-07-09 14:40:34 +0200140 if (netif_running(sdata->dev))
Jiri Bencf0706e82007-05-05 11:45:53 -0700141 dev_close(sdata->dev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700142
143 return 0;
144}
145
Johannes Berg4150c572007-09-17 01:29:23 -0400146static void ieee80211_master_set_multicast_list(struct net_device *dev)
147{
Johannes Berg133b8222008-09-16 14:18:59 +0200148 struct ieee80211_master_priv *mpriv = netdev_priv(dev);
149 struct ieee80211_local *local = mpriv->local;
Johannes Berg4150c572007-09-17 01:29:23 -0400150
151 ieee80211_configure_filter(local);
152}
153
Johannes Bergb2c258f2007-07-27 15:43:23 +0200154/* everything else */
155
Johannes Berg9d139c82008-07-09 14:40:37 +0200156int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
Johannes Bergb2c258f2007-07-27 15:43:23 +0200157{
Johannes Berg9d139c82008-07-09 14:40:37 +0200158 struct ieee80211_local *local = sdata->local;
Johannes Bergb2c258f2007-07-27 15:43:23 +0200159 struct ieee80211_if_conf conf;
Johannes Bergb2c258f2007-07-27 15:43:23 +0200160
Johannes Berg9d139c82008-07-09 14:40:37 +0200161 if (WARN_ON(!netif_running(sdata->dev)))
162 return 0;
163
Johannes Berg7a725f72008-09-11 00:02:00 +0200164 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
165 return -EINVAL;
166
Johannes Berg9d139c82008-07-09 14:40:37 +0200167 if (!local->ops->config_interface)
Johannes Bergb2c258f2007-07-27 15:43:23 +0200168 return 0;
169
170 memset(&conf, 0, sizeof(conf));
Johannes Berg9d139c82008-07-09 14:40:37 +0200171 conf.changed = changed;
172
Johannes Berg05c914f2008-09-11 00:01:58 +0200173 if (sdata->vif.type == NL80211_IFTYPE_STATION ||
Johannes Berg41bb73e2008-10-29 01:09:37 +0100174 sdata->vif.type == NL80211_IFTYPE_ADHOC)
Johannes Berg4150c572007-09-17 01:29:23 -0400175 conf.bssid = sdata->u.sta.bssid;
Johannes Berg41bb73e2008-10-29 01:09:37 +0100176 else if (sdata->vif.type == NL80211_IFTYPE_AP)
Johannes Berg9d139c82008-07-09 14:40:37 +0200177 conf.bssid = sdata->dev->dev_addr;
Johannes Berg41bb73e2008-10-29 01:09:37 +0100178 else if (ieee80211_vif_is_mesh(&sdata->vif)) {
Johannes Berg9d139c82008-07-09 14:40:37 +0200179 u8 zero[ETH_ALEN] = { 0 };
180 conf.bssid = zero;
Johannes Berg9d139c82008-07-09 14:40:37 +0200181 } else {
182 WARN_ON(1);
183 return -EINVAL;
Johannes Bergb2c258f2007-07-27 15:43:23 +0200184 }
Johannes Berg9d139c82008-07-09 14:40:37 +0200185
186 if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID)))
187 return -EINVAL;
188
Johannes Bergb2c258f2007-07-27 15:43:23 +0200189 return local->ops->config_interface(local_to_hw(local),
Johannes Berg32bfd352007-12-19 01:31:26 +0100190 &sdata->vif, &conf);
Johannes Bergb2c258f2007-07-27 15:43:23 +0200191}
192
Johannes Berge8975582008-10-09 12:18:51 +0200193int ieee80211_hw_config(struct ieee80211_local *local, u32 changed)
Johannes Bergb2c258f2007-07-27 15:43:23 +0200194{
Johannes Bergb2c258f2007-07-27 15:43:23 +0200195 struct ieee80211_channel *chan;
196 int ret = 0;
Johannes Berge8975582008-10-09 12:18:51 +0200197 int power;
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200198 enum nl80211_sec_chan_offset sec_chan_offset;
Johannes Bergb2c258f2007-07-27 15:43:23 +0200199
Johannes Bergcb121ba2008-10-14 16:38:55 +0200200 might_sleep();
201
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200202 if (local->sw_scanning) {
Johannes Bergb2c258f2007-07-27 15:43:23 +0200203 chan = local->scan_channel;
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200204 sec_chan_offset = NL80211_SEC_CHAN_NO_HT;
205 } else {
Johannes Bergb2c258f2007-07-27 15:43:23 +0200206 chan = local->oper_channel;
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200207 sec_chan_offset = local->oper_sec_chan_offset;
Johannes Berge8975582008-10-09 12:18:51 +0200208 }
209
Jouni Malinen72bdcf32008-11-26 16:15:24 +0200210 if (chan != local->hw.conf.channel ||
211 sec_chan_offset != local->hw.conf.ht.sec_chan_offset) {
212 local->hw.conf.channel = chan;
213 switch (sec_chan_offset) {
214 case NL80211_SEC_CHAN_NO_HT:
215 local->hw.conf.ht.enabled = false;
216 local->hw.conf.ht.sec_chan_offset = 0;
217 break;
218 case NL80211_SEC_CHAN_DISABLED:
219 local->hw.conf.ht.enabled = true;
220 local->hw.conf.ht.sec_chan_offset = 0;
221 break;
222 case NL80211_SEC_CHAN_BELOW:
223 local->hw.conf.ht.enabled = true;
224 local->hw.conf.ht.sec_chan_offset = -1;
225 break;
226 case NL80211_SEC_CHAN_ABOVE:
227 local->hw.conf.ht.enabled = true;
228 local->hw.conf.ht.sec_chan_offset = 1;
229 break;
230 }
231 changed |= IEEE80211_CONF_CHANGE_CHANNEL;
232 }
Johannes Berg8318d782008-01-24 19:38:38 +0100233
234 if (!local->hw.conf.power_level)
Johannes Berge8975582008-10-09 12:18:51 +0200235 power = chan->max_power;
Johannes Berg8318d782008-01-24 19:38:38 +0100236 else
Johannes Berge8975582008-10-09 12:18:51 +0200237 power = min(chan->max_power, local->hw.conf.power_level);
238 if (local->hw.conf.power_level != power) {
239 changed |= IEEE80211_CONF_CHANGE_POWER;
240 local->hw.conf.power_level = power;
241 }
Johannes Berg8318d782008-01-24 19:38:38 +0100242
Johannes Berge8975582008-10-09 12:18:51 +0200243 if (changed && local->open_count) {
244 ret = local->ops->config(local_to_hw(local), changed);
Johannes Bergd73782f2008-10-07 12:04:34 +0200245 /*
246 * HW reconfiguration should never fail, the driver has told
247 * us what it can support so it should live up to that promise.
248 */
249 WARN_ON(ret);
250 }
Johannes Bergb2c258f2007-07-27 15:43:23 +0200251
252 return ret;
253}
254
Johannes Berg471b3ef2007-12-28 14:32:58 +0100255void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
256 u32 changed)
Daniel Draked9430a32007-07-27 15:43:24 +0200257{
Johannes Berg471b3ef2007-12-28 14:32:58 +0100258 struct ieee80211_local *local = sdata->local;
259
Johannes Berg7a725f72008-09-11 00:02:00 +0200260 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
261 return;
262
Johannes Berg471b3ef2007-12-28 14:32:58 +0100263 if (!changed)
264 return;
265
266 if (local->ops->bss_info_changed)
267 local->ops->bss_info_changed(local_to_hw(local),
268 &sdata->vif,
Johannes Bergbda39332008-10-11 01:51:51 +0200269 &sdata->vif.bss_conf,
Johannes Berg471b3ef2007-12-28 14:32:58 +0100270 changed);
Daniel Draked9430a32007-07-27 15:43:24 +0200271}
272
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200273u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
Daniel Draked9430a32007-07-27 15:43:24 +0200274{
Johannes Bergbda39332008-10-11 01:51:51 +0200275 sdata->vif.bss_conf.use_cts_prot = false;
276 sdata->vif.bss_conf.use_short_preamble = false;
277 sdata->vif.bss_conf.use_short_slot = false;
Johannes Berg7a5158e2008-10-08 10:59:33 +0200278 return BSS_CHANGED_ERP_CTS_PROT |
279 BSS_CHANGED_ERP_PREAMBLE |
280 BSS_CHANGED_ERP_SLOT;
Daniel Draked9430a32007-07-27 15:43:24 +0200281}
282
Jiri Bencf0706e82007-05-05 11:45:53 -0700283void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
Johannes Berge039fa42008-05-15 12:55:29 +0200284 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -0700285{
286 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berge039fa42008-05-15 12:55:29 +0200287 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
Jiri Bencf0706e82007-05-05 11:45:53 -0700288 int tmp;
289
290 skb->dev = local->mdev;
Jiri Bencf0706e82007-05-05 11:45:53 -0700291 skb->pkt_type = IEEE80211_TX_STATUS_MSG;
Johannes Berge039fa42008-05-15 12:55:29 +0200292 skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
Jiri Bencf0706e82007-05-05 11:45:53 -0700293 &local->skb_queue : &local->skb_queue_unreliable, skb);
294 tmp = skb_queue_len(&local->skb_queue) +
295 skb_queue_len(&local->skb_queue_unreliable);
296 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
297 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700298 dev_kfree_skb_irq(skb);
299 tmp--;
300 I802_DEBUG_INC(local->tx_status_drop);
301 }
302 tasklet_schedule(&local->tasklet);
303}
304EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
305
306static void ieee80211_tasklet_handler(unsigned long data)
307{
308 struct ieee80211_local *local = (struct ieee80211_local *) data;
309 struct sk_buff *skb;
310 struct ieee80211_rx_status rx_status;
Ron Rindjunskyeadc8d92008-01-28 14:07:17 +0200311 struct ieee80211_ra_tid *ra_tid;
Jiri Bencf0706e82007-05-05 11:45:53 -0700312
313 while ((skb = skb_dequeue(&local->skb_queue)) ||
314 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
315 switch (skb->pkt_type) {
316 case IEEE80211_RX_MSG:
317 /* status is in skb->cb */
318 memcpy(&rx_status, skb->cb, sizeof(rx_status));
Johannes Berg51fb61e2007-12-19 01:31:27 +0100319 /* Clear skb->pkt_type in order to not confuse kernel
Jiri Bencf0706e82007-05-05 11:45:53 -0700320 * netstack. */
321 skb->pkt_type = 0;
322 __ieee80211_rx(local_to_hw(local), skb, &rx_status);
323 break;
324 case IEEE80211_TX_STATUS_MSG:
Jiri Bencf0706e82007-05-05 11:45:53 -0700325 skb->pkt_type = 0;
Johannes Berge039fa42008-05-15 12:55:29 +0200326 ieee80211_tx_status(local_to_hw(local), skb);
Jiri Bencf0706e82007-05-05 11:45:53 -0700327 break;
Ron Rindjunskyeadc8d92008-01-28 14:07:17 +0200328 case IEEE80211_DELBA_MSG:
329 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
330 ieee80211_stop_tx_ba_cb(local_to_hw(local),
331 ra_tid->ra, ra_tid->tid);
332 dev_kfree_skb(skb);
333 break;
334 case IEEE80211_ADDBA_MSG:
335 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
336 ieee80211_start_tx_ba_cb(local_to_hw(local),
337 ra_tid->ra, ra_tid->tid);
338 dev_kfree_skb(skb);
339 break ;
Johannes Bergf4ea83d2008-06-30 15:10:46 +0200340 default:
341 WARN_ON(1);
Jiri Bencf0706e82007-05-05 11:45:53 -0700342 dev_kfree_skb(skb);
343 break;
344 }
345 }
346}
347
Jiri Bencf0706e82007-05-05 11:45:53 -0700348/* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
349 * make a prepared TX frame (one that has been given to hw) to look like brand
350 * new IEEE 802.11 frame that is ready to go through TX processing again.
Johannes Bergd0f09802008-07-29 11:32:07 +0200351 */
Jiri Bencf0706e82007-05-05 11:45:53 -0700352static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
353 struct ieee80211_key *key,
Johannes Berge039fa42008-05-15 12:55:29 +0200354 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -0700355{
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700356 unsigned int hdrlen, iv_len, mic_len;
357 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
Jiri Bencf0706e82007-05-05 11:45:53 -0700358
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700359 hdrlen = ieee80211_hdrlen(hdr->frame_control);
Jiri Bencf0706e82007-05-05 11:45:53 -0700360
361 if (!key)
362 goto no_key;
363
Johannes Berg8f20fc22007-08-28 17:01:54 -0400364 switch (key->conf.alg) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700365 case ALG_WEP:
366 iv_len = WEP_IV_LEN;
367 mic_len = WEP_ICV_LEN;
368 break;
369 case ALG_TKIP:
370 iv_len = TKIP_IV_LEN;
371 mic_len = TKIP_ICV_LEN;
372 break;
373 case ALG_CCMP:
374 iv_len = CCMP_HDR_LEN;
375 mic_len = CCMP_MIC_LEN;
376 break;
377 default:
378 goto no_key;
379 }
380
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700381 if (skb->len >= hdrlen + mic_len &&
Johannes Berg11a843b2007-08-28 17:01:55 -0400382 !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
Jiri Bencf0706e82007-05-05 11:45:53 -0700383 skb_trim(skb, skb->len - mic_len);
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700384 if (skb->len >= hdrlen + iv_len) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700385 memmove(skb->data + iv_len, skb->data, hdrlen);
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700386 hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
Jiri Bencf0706e82007-05-05 11:45:53 -0700387 }
388
389no_key:
Harvey Harrison62bf1d72008-07-15 18:44:05 -0700390 if (ieee80211_is_data_qos(hdr->frame_control)) {
391 hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
392 memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
393 hdrlen - IEEE80211_QOS_CTL_LEN);
394 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
Jiri Bencf0706e82007-05-05 11:45:53 -0700395 }
396}
397
Johannes Bergd46e1442008-02-20 23:59:33 +0100398static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
399 struct sta_info *sta,
Johannes Berge039fa42008-05-15 12:55:29 +0200400 struct sk_buff *skb)
Johannes Bergd46e1442008-02-20 23:59:33 +0100401{
402 sta->tx_filtered_count++;
403
404 /*
405 * Clear the TX filter mask for this STA when sending the next
406 * packet. If the STA went to power save mode, this will happen
Yi Zhuf6d97102008-05-27 17:50:50 +0300407 * when it wakes up for the next time.
Johannes Bergd46e1442008-02-20 23:59:33 +0100408 */
Johannes Berg07346f812008-05-03 01:02:02 +0200409 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
Johannes Bergd46e1442008-02-20 23:59:33 +0100410
411 /*
412 * This code races in the following way:
413 *
414 * (1) STA sends frame indicating it will go to sleep and does so
415 * (2) hardware/firmware adds STA to filter list, passes frame up
416 * (3) hardware/firmware processes TX fifo and suppresses a frame
417 * (4) we get TX status before having processed the frame and
418 * knowing that the STA has gone to sleep.
419 *
420 * This is actually quite unlikely even when both those events are
421 * processed from interrupts coming in quickly after one another or
422 * even at the same time because we queue both TX status events and
423 * RX frames to be processed by a tasklet and process them in the
424 * same order that they were received or TX status last. Hence, there
425 * is no race as long as the frame RX is processed before the next TX
426 * status, which drivers can ensure, see below.
427 *
428 * Note that this can only happen if the hardware or firmware can
429 * actually add STAs to the filter list, if this is done by the
430 * driver in response to set_tim() (which will only reduce the race
431 * this whole filtering tries to solve, not completely solve it)
432 * this situation cannot happen.
433 *
434 * To completely solve this race drivers need to make sure that they
435 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
436 * functions and
437 * (b) always process RX events before TX status events if ordering
438 * can be unknown, for example with different interrupt status
439 * bits.
440 */
Johannes Berg07346f812008-05-03 01:02:02 +0200441 if (test_sta_flags(sta, WLAN_STA_PS) &&
Johannes Bergd46e1442008-02-20 23:59:33 +0100442 skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
Johannes Berge039fa42008-05-15 12:55:29 +0200443 ieee80211_remove_tx_extra(local, sta->key, skb);
Johannes Bergd46e1442008-02-20 23:59:33 +0100444 skb_queue_tail(&sta->tx_filtered, skb);
445 return;
446 }
447
Sujith8b30b1f2008-10-24 09:55:27 +0530448 if (!test_sta_flags(sta, WLAN_STA_PS) && !skb->requeue) {
Johannes Bergd46e1442008-02-20 23:59:33 +0100449 /* Software retry the packet once */
Sujith8b30b1f2008-10-24 09:55:27 +0530450 skb->requeue = 1;
Johannes Berge039fa42008-05-15 12:55:29 +0200451 ieee80211_remove_tx_extra(local, sta->key, skb);
Johannes Bergd46e1442008-02-20 23:59:33 +0100452 dev_queue_xmit(skb);
453 return;
454 }
455
Johannes Bergf4ea83d2008-06-30 15:10:46 +0200456#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Johannes Bergd46e1442008-02-20 23:59:33 +0100457 if (net_ratelimit())
458 printk(KERN_DEBUG "%s: dropped TX filtered frame, "
459 "queue_len=%d PS=%d @%lu\n",
460 wiphy_name(local->hw.wiphy),
461 skb_queue_len(&sta->tx_filtered),
Johannes Berg07346f812008-05-03 01:02:02 +0200462 !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
Johannes Bergf4ea83d2008-06-30 15:10:46 +0200463#endif
Johannes Bergd46e1442008-02-20 23:59:33 +0100464 dev_kfree_skb(skb);
465}
466
Johannes Berge039fa42008-05-15 12:55:29 +0200467void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -0700468{
469 struct sk_buff *skb2;
470 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
471 struct ieee80211_local *local = hw_to_local(hw);
Johannes Berge039fa42008-05-15 12:55:29 +0200472 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
Jiri Bencf0706e82007-05-05 11:45:53 -0700473 u16 frag, type;
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300474 __le16 fc;
Johannes Berg4b7679a2008-09-18 18:14:18 +0200475 struct ieee80211_supported_band *sband;
Johannes Bergb306f452007-07-10 19:32:08 +0200476 struct ieee80211_tx_status_rtap_hdr *rthdr;
477 struct ieee80211_sub_if_data *sdata;
Michael Wu3d30d942008-01-31 19:48:27 +0100478 struct net_device *prev_dev = NULL;
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300479 struct sta_info *sta;
Johannes Berge6a98542008-10-21 12:40:02 +0200480 int retry_count = -1, i;
481
482 for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
483 /* the HW cannot have attempted that rate */
484 if (i >= hw->max_rates) {
485 info->status.rates[i].idx = -1;
486 info->status.rates[i].count = 0;
487 }
488
489 retry_count += info->status.rates[i].count;
490 }
491 if (retry_count < 0)
492 retry_count = 0;
Jiri Bencf0706e82007-05-05 11:45:53 -0700493
Johannes Bergd0709a62008-02-25 16:27:46 +0100494 rcu_read_lock();
495
Johannes Berge6a98542008-10-21 12:40:02 +0200496 sband = local->hw.wiphy->bands[info->band];
497
Johannes Berg95dac0402008-09-11 02:03:28 +0200498 sta = sta_info_get(local, hdr->addr1);
499
500 if (sta) {
Johannes Berge6a98542008-10-21 12:40:02 +0200501 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
Johannes Berg95dac0402008-09-11 02:03:28 +0200502 test_sta_flags(sta, WLAN_STA_PS)) {
503 /*
504 * The STA is in power save mode, so assume
505 * that this TX packet failed because of that.
506 */
507 ieee80211_handle_filtered_frame(local, sta, skb);
508 rcu_read_unlock();
509 return;
Jiri Bencf0706e82007-05-05 11:45:53 -0700510 }
Jiri Bencf0706e82007-05-05 11:45:53 -0700511
Johannes Berg95dac0402008-09-11 02:03:28 +0200512 fc = hdr->frame_control;
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300513
Johannes Berg95dac0402008-09-11 02:03:28 +0200514 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
515 (ieee80211_is_data_qos(fc))) {
516 u16 tid, ssn;
517 u8 *qc;
518
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300519 qc = ieee80211_get_qos_ctl(hdr);
520 tid = qc[0] & 0xf;
521 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
522 & IEEE80211_SCTL_SEQ);
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +1200523 ieee80211_send_bar(sta->sdata, hdr->addr1,
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300524 tid, ssn);
525 }
Ron Rindjunsky429a3802008-07-01 14:16:03 +0300526
Johannes Berg95dac0402008-09-11 02:03:28 +0200527 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
Johannes Berge039fa42008-05-15 12:55:29 +0200528 ieee80211_handle_filtered_frame(local, sta, skb);
Johannes Bergd0709a62008-02-25 16:27:46 +0100529 rcu_read_unlock();
Jiri Bencf0706e82007-05-05 11:45:53 -0700530 return;
Johannes Berg95dac0402008-09-11 02:03:28 +0200531 } else {
Johannes Berge6a98542008-10-21 12:40:02 +0200532 if (!(info->flags & IEEE80211_TX_STAT_ACK))
Johannes Berg95dac0402008-09-11 02:03:28 +0200533 sta->tx_retry_failed++;
Johannes Berge6a98542008-10-21 12:40:02 +0200534 sta->tx_retry_count += retry_count;
Jiri Bencf0706e82007-05-05 11:45:53 -0700535 }
Johannes Berg95dac0402008-09-11 02:03:28 +0200536
Johannes Berg4b7679a2008-09-18 18:14:18 +0200537 rate_control_tx_status(local, sband, sta, skb);
Johannes Berg95dac0402008-09-11 02:03:28 +0200538 }
Jiri Bencf0706e82007-05-05 11:45:53 -0700539
Johannes Bergd0709a62008-02-25 16:27:46 +0100540 rcu_read_unlock();
541
Jiri Bencf0706e82007-05-05 11:45:53 -0700542 ieee80211_led_tx(local, 0);
543
544 /* SNMP counters
545 * Fragments are passed to low-level drivers as separate skbs, so these
546 * are actually fragments, not frames. Update frame counters only for
547 * the first fragment of the frame. */
548
549 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
550 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;
551
Johannes Berge039fa42008-05-15 12:55:29 +0200552 if (info->flags & IEEE80211_TX_STAT_ACK) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700553 if (frag == 0) {
554 local->dot11TransmittedFrameCount++;
555 if (is_multicast_ether_addr(hdr->addr1))
556 local->dot11MulticastTransmittedFrameCount++;
Johannes Berge6a98542008-10-21 12:40:02 +0200557 if (retry_count > 0)
Jiri Bencf0706e82007-05-05 11:45:53 -0700558 local->dot11RetryCount++;
Johannes Berge6a98542008-10-21 12:40:02 +0200559 if (retry_count > 1)
Jiri Bencf0706e82007-05-05 11:45:53 -0700560 local->dot11MultipleRetryCount++;
561 }
562
563 /* This counter shall be incremented for an acknowledged MPDU
564 * with an individual address in the address 1 field or an MPDU
565 * with a multicast address in the address 1 field of type Data
566 * or Management. */
567 if (!is_multicast_ether_addr(hdr->addr1) ||
568 type == IEEE80211_FTYPE_DATA ||
569 type == IEEE80211_FTYPE_MGMT)
570 local->dot11TransmittedFragmentCount++;
571 } else {
572 if (frag == 0)
573 local->dot11FailedCount++;
574 }
575
Johannes Bergb306f452007-07-10 19:32:08 +0200576 /* this was a transmitted frame, but now we want to reuse it */
577 skb_orphan(skb);
578
Michael Wu3d30d942008-01-31 19:48:27 +0100579 /*
580 * This is a bit racy but we can avoid a lot of work
581 * with this test...
582 */
583 if (!local->monitors && !local->cooked_mntrs) {
Jiri Bencf0706e82007-05-05 11:45:53 -0700584 dev_kfree_skb(skb);
585 return;
586 }
Jiri Bencf0706e82007-05-05 11:45:53 -0700587
Johannes Bergb306f452007-07-10 19:32:08 +0200588 /* send frame to monitor interfaces now */
589
590 if (skb_headroom(skb) < sizeof(*rthdr)) {
591 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
592 dev_kfree_skb(skb);
593 return;
594 }
595
Johannes Berg988c0f72008-04-17 19:21:22 +0200596 rthdr = (struct ieee80211_tx_status_rtap_hdr *)
Johannes Bergb306f452007-07-10 19:32:08 +0200597 skb_push(skb, sizeof(*rthdr));
598
599 memset(rthdr, 0, sizeof(*rthdr));
600 rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
601 rthdr->hdr.it_present =
602 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
Johannes Berge6a98542008-10-21 12:40:02 +0200603 (1 << IEEE80211_RADIOTAP_DATA_RETRIES) |
604 (1 << IEEE80211_RADIOTAP_RATE));
Johannes Bergb306f452007-07-10 19:32:08 +0200605
Johannes Berge039fa42008-05-15 12:55:29 +0200606 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
Johannes Bergb306f452007-07-10 19:32:08 +0200607 !is_multicast_ether_addr(hdr->addr1))
608 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
609
Johannes Berge6a98542008-10-21 12:40:02 +0200610 /*
611 * XXX: Once radiotap gets the bitmap reset thing the vendor
612 * extensions proposal contains, we can actually report
613 * the whole set of tries we did.
614 */
615 if ((info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) ||
616 (info->status.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT))
Johannes Bergb306f452007-07-10 19:32:08 +0200617 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
Johannes Berge6a98542008-10-21 12:40:02 +0200618 else if (info->status.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
Johannes Bergb306f452007-07-10 19:32:08 +0200619 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
Johannes Berge6a98542008-10-21 12:40:02 +0200620 if (info->status.rates[0].idx >= 0 &&
621 !(info->status.rates[0].flags & IEEE80211_TX_RC_MCS))
622 rthdr->rate = sband->bitrates[
623 info->status.rates[0].idx].bitrate / 5;
Johannes Bergb306f452007-07-10 19:32:08 +0200624
Johannes Berge6a98542008-10-21 12:40:02 +0200625 /* for now report the total retry_count */
626 rthdr->data_retries = retry_count;
Johannes Bergb306f452007-07-10 19:32:08 +0200627
Michael Wu3d30d942008-01-31 19:48:27 +0100628 /* XXX: is this sufficient for BPF? */
629 skb_set_mac_header(skb, 0);
630 skb->ip_summed = CHECKSUM_UNNECESSARY;
631 skb->pkt_type = PACKET_OTHERHOST;
632 skb->protocol = htons(ETH_P_802_2);
633 memset(skb->cb, 0, sizeof(skb->cb));
Johannes Bergb306f452007-07-10 19:32:08 +0200634
Michael Wu3d30d942008-01-31 19:48:27 +0100635 rcu_read_lock();
636 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
Johannes Berg05c914f2008-09-11 00:01:58 +0200637 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
Johannes Bergb306f452007-07-10 19:32:08 +0200638 if (!netif_running(sdata->dev))
639 continue;
Michael Wu3d30d942008-01-31 19:48:27 +0100640
641 if (prev_dev) {
Johannes Berg79010422007-09-18 17:29:21 -0400642 skb2 = skb_clone(skb, GFP_ATOMIC);
Michael Wu3d30d942008-01-31 19:48:27 +0100643 if (skb2) {
644 skb2->dev = prev_dev;
645 netif_rx(skb2);
646 }
647 }
648
649 prev_dev = sdata->dev;
Johannes Bergb306f452007-07-10 19:32:08 +0200650 }
651 }
Michael Wu3d30d942008-01-31 19:48:27 +0100652 if (prev_dev) {
653 skb->dev = prev_dev;
654 netif_rx(skb);
655 skb = NULL;
656 }
Johannes Berg79010422007-09-18 17:29:21 -0400657 rcu_read_unlock();
Michael Wu3d30d942008-01-31 19:48:27 +0100658 dev_kfree_skb(skb);
Jiri Bencf0706e82007-05-05 11:45:53 -0700659}
660EXPORT_SYMBOL(ieee80211_tx_status);
661
Jiri Bencf0706e82007-05-05 11:45:53 -0700662struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
663 const struct ieee80211_ops *ops)
664{
Jiri Bencf0706e82007-05-05 11:45:53 -0700665 struct ieee80211_local *local;
Jiri Bencf0706e82007-05-05 11:45:53 -0700666 int priv_size;
667 struct wiphy *wiphy;
668
669 /* Ensure 32-byte alignment of our private data and hw private data.
670 * We use the wiphy priv data for both our ieee80211_local and for
671 * the driver's private data
672 *
673 * In memory it'll be like this:
674 *
675 * +-------------------------+
676 * | struct wiphy |
677 * +-------------------------+
678 * | struct ieee80211_local |
679 * +-------------------------+
680 * | driver's private data |
681 * +-------------------------+
682 *
683 */
684 priv_size = ((sizeof(struct ieee80211_local) +
685 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
686 priv_data_len;
687
688 wiphy = wiphy_new(&mac80211_config_ops, priv_size);
689
690 if (!wiphy)
691 return NULL;
692
693 wiphy->privid = mac80211_wiphy_privid;
694
695 local = wiphy_priv(wiphy);
696 local->hw.wiphy = wiphy;
697
698 local->hw.priv = (char *)local +
699 ((sizeof(struct ieee80211_local) +
700 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
701
Johannes Berg4480f15c2007-07-10 19:32:10 +0200702 BUG_ON(!ops->tx);
Johannes Berg4150c572007-09-17 01:29:23 -0400703 BUG_ON(!ops->start);
704 BUG_ON(!ops->stop);
Johannes Berg4480f15c2007-07-10 19:32:10 +0200705 BUG_ON(!ops->config);
706 BUG_ON(!ops->add_interface);
Johannes Berg4150c572007-09-17 01:29:23 -0400707 BUG_ON(!ops->remove_interface);
708 BUG_ON(!ops->configure_filter);
Jiri Bencf0706e82007-05-05 11:45:53 -0700709 local->ops = ops;
710
Johannes Berge6a98542008-10-21 12:40:02 +0200711 /* set up some defaults */
712 local->hw.queues = 1;
713 local->hw.max_rates = 1;
Jiri Bencf0706e82007-05-05 11:45:53 -0700714 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
715 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
Johannes Berg9124b072008-10-14 19:17:54 +0200716 local->hw.conf.long_frame_max_tx_count = 4;
717 local->hw.conf.short_frame_max_tx_count = 7;
Johannes Berge8975582008-10-09 12:18:51 +0200718 local->hw.conf.radio_enabled = true;
Jiri Bencf0706e82007-05-05 11:45:53 -0700719
Johannes Berg79010422007-09-18 17:29:21 -0400720 INIT_LIST_HEAD(&local->interfaces);
Jiri Bencf0706e82007-05-05 11:45:53 -0700721
Johannes Bergb16bd152008-04-11 21:40:35 +0200722 spin_lock_init(&local->key_lock);
723
Johannes Bergc2b13452008-09-11 00:01:55 +0200724 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
Jiri Bencf0706e82007-05-05 11:45:53 -0700725
726 sta_info_init(local);
727
Jiri Bencf0706e82007-05-05 11:45:53 -0700728 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
729 (unsigned long)local);
730 tasklet_disable(&local->tx_pending_tasklet);
731
732 tasklet_init(&local->tasklet,
733 ieee80211_tasklet_handler,
734 (unsigned long) local);
735 tasklet_disable(&local->tasklet);
736
737 skb_queue_head_init(&local->skb_queue);
738 skb_queue_head_init(&local->skb_queue_unreliable);
739
740 return local_to_hw(local);
741}
742EXPORT_SYMBOL(ieee80211_alloc_hw);
743
744int ieee80211_register_hw(struct ieee80211_hw *hw)
745{
746 struct ieee80211_local *local = hw_to_local(hw);
Jiri Bencf0706e82007-05-05 11:45:53 -0700747 int result;
Johannes Berg8318d782008-01-24 19:38:38 +0100748 enum ieee80211_band band;
Johannes Berg96d51052008-02-08 09:48:13 +0100749 struct net_device *mdev;
Johannes Berg133b8222008-09-16 14:18:59 +0200750 struct ieee80211_master_priv *mpriv;
Johannes Berg8318d782008-01-24 19:38:38 +0100751
752 /*
753 * generic code guarantees at least one band,
754 * set this very early because much code assumes
755 * that hw.conf.channel is assigned
756 */
757 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
758 struct ieee80211_supported_band *sband;
759
760 sband = local->hw.wiphy->bands[band];
761 if (sband) {
762 /* init channel we're on */
763 local->hw.conf.channel =
764 local->oper_channel =
765 local->scan_channel = &sband->channels[0];
766 break;
767 }
768 }
Jiri Bencf0706e82007-05-05 11:45:53 -0700769
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700770 /* if low-level driver supports AP, we also support VLAN */
771 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP))
772 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
773
774 /* mac80211 always supports monitor */
775 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
776
Jiri Bencf0706e82007-05-05 11:45:53 -0700777 result = wiphy_register(local->hw.wiphy);
778 if (result < 0)
779 return result;
780
Johannes Berge2530082008-05-17 00:57:14 +0200781 /*
782 * We use the number of queues for feature tests (QoS, HT) internally
783 * so restrict them appropriately.
784 */
Johannes Berge2530082008-05-17 00:57:14 +0200785 if (hw->queues > IEEE80211_MAX_QUEUES)
786 hw->queues = IEEE80211_MAX_QUEUES;
787 if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES)
788 hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES;
789 if (hw->queues < 4)
790 hw->ampdu_queues = 0;
Johannes Berge2530082008-05-17 00:57:14 +0200791
Johannes Berg133b8222008-09-16 14:18:59 +0200792 mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv),
Johannes Berge2530082008-05-17 00:57:14 +0200793 "wmaster%d", ether_setup,
794 ieee80211_num_queues(hw));
Johannes Berg96d51052008-02-08 09:48:13 +0100795 if (!mdev)
796 goto fail_mdev_alloc;
797
Johannes Berg133b8222008-09-16 14:18:59 +0200798 mpriv = netdev_priv(mdev);
799 mpriv->local = local;
Johannes Berg96d51052008-02-08 09:48:13 +0100800 local->mdev = mdev;
801
Johannes Berg3e122be2008-07-09 14:40:34 +0200802 ieee80211_rx_bss_list_init(local);
Johannes Berg96d51052008-02-08 09:48:13 +0100803
804 mdev->hard_start_xmit = ieee80211_master_start_xmit;
805 mdev->open = ieee80211_master_open;
806 mdev->stop = ieee80211_master_stop;
807 mdev->type = ARPHRD_IEEE80211;
808 mdev->header_ops = &ieee80211_header_ops;
809 mdev->set_multicast_list = ieee80211_master_set_multicast_list;
810
Luis R. Rodriguez4ada4242008-11-14 14:44:22 -0800811 local->hw.workqueue =
812 create_freezeable_workqueue(wiphy_name(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700813 if (!local->hw.workqueue) {
814 result = -ENOMEM;
815 goto fail_workqueue;
816 }
817
Johannes Bergb306f452007-07-10 19:32:08 +0200818 /*
819 * The hardware needs headroom for sending the frame,
820 * and we need some headroom for passing the frame to monitor
821 * interfaces, but never both at the same time.
822 */
Jiri Benc33ccad32007-07-18 17:10:44 +0200823 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
824 sizeof(struct ieee80211_tx_status_rtap_hdr));
Johannes Bergb306f452007-07-10 19:32:08 +0200825
Jiri Bence9f207f2007-05-05 11:46:38 -0700826 debugfs_hw_add(local);
827
Tomas Winklerdc0ae302008-06-12 22:38:37 +0300828 if (local->hw.conf.beacon_int < 10)
829 local->hw.conf.beacon_int = 100;
Jiri Bencf0706e82007-05-05 11:45:53 -0700830
Tomas Winklerea95bba2008-07-18 13:53:00 +0800831 if (local->hw.max_listen_interval == 0)
832 local->hw.max_listen_interval = 1;
833
834 local->hw.conf.listen_interval = local->hw.max_listen_interval;
835
Bruno Randolf566bfe52008-05-08 19:15:40 +0200836 local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
837 IEEE80211_HW_SIGNAL_DB |
838 IEEE80211_HW_SIGNAL_DBM) ?
Jiri Bencf0706e82007-05-05 11:45:53 -0700839 IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
Bruno Randolf566bfe52008-05-08 19:15:40 +0200840 local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
Jiri Bencf0706e82007-05-05 11:45:53 -0700841 IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID;
Bruno Randolf566bfe52008-05-08 19:15:40 +0200842 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
Jiri Bencf0706e82007-05-05 11:45:53 -0700843 local->wstats_flags |= IW_QUAL_DBM;
844
845 result = sta_info_start(local);
846 if (result < 0)
847 goto fail_sta_info;
848
849 rtnl_lock();
850 result = dev_alloc_name(local->mdev, local->mdev->name);
851 if (result < 0)
852 goto fail_dev;
853
854 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
855 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));
856
857 result = register_netdevice(local->mdev);
858 if (result < 0)
859 goto fail_dev;
860
Johannes Berg830f9032007-10-28 14:51:05 +0100861 result = ieee80211_init_rate_ctrl_alg(local,
862 hw->rate_control_algorithm);
Jiri Bencf0706e82007-05-05 11:45:53 -0700863 if (result < 0) {
864 printk(KERN_DEBUG "%s: Failed to initialize rate control "
Johannes Bergdd1cd4c2007-09-18 17:29:20 -0400865 "algorithm\n", wiphy_name(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700866 goto fail_rate;
867 }
868
869 result = ieee80211_wep_init(local);
870
871 if (result < 0) {
Jeremy Fitzhardinge023a04b2008-07-14 12:52:08 -0700872 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
873 wiphy_name(local->hw.wiphy), result);
Jiri Bencf0706e82007-05-05 11:45:53 -0700874 goto fail_wep;
875 }
876
David S. Miller51cb6db2008-07-15 03:34:57 -0700877 local->mdev->select_queue = ieee80211_select_queue;
Jiri Bencf0706e82007-05-05 11:45:53 -0700878
879 /* add one default STA interface */
Johannes Berg3e122be2008-07-09 14:40:34 +0200880 result = ieee80211_if_add(local, "wlan%d", NULL,
Johannes Berg05c914f2008-09-11 00:01:58 +0200881 NL80211_IFTYPE_STATION, NULL);
Jiri Bencf0706e82007-05-05 11:45:53 -0700882 if (result)
883 printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
Johannes Bergdd1cd4c2007-09-18 17:29:20 -0400884 wiphy_name(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700885
Jiri Bencf0706e82007-05-05 11:45:53 -0700886 rtnl_unlock();
887
888 ieee80211_led_init(local);
889
890 return 0;
891
892fail_wep:
893 rate_control_deinitialize(local);
894fail_rate:
895 unregister_netdevice(local->mdev);
Pavel Emelyanov339a7c42008-05-04 17:59:30 -0700896 local->mdev = NULL;
Jiri Bencf0706e82007-05-05 11:45:53 -0700897fail_dev:
898 rtnl_unlock();
899 sta_info_stop(local);
900fail_sta_info:
Jiri Bence9f207f2007-05-05 11:46:38 -0700901 debugfs_hw_del(local);
Jiri Bencf0706e82007-05-05 11:45:53 -0700902 destroy_workqueue(local->hw.workqueue);
903fail_workqueue:
Johannes Berg3e122be2008-07-09 14:40:34 +0200904 if (local->mdev)
905 free_netdev(local->mdev);
Johannes Berg96d51052008-02-08 09:48:13 +0100906fail_mdev_alloc:
Jiri Bencf0706e82007-05-05 11:45:53 -0700907 wiphy_unregister(local->hw.wiphy);
908 return result;
909}
910EXPORT_SYMBOL(ieee80211_register_hw);
911
Jiri Bencf0706e82007-05-05 11:45:53 -0700912void ieee80211_unregister_hw(struct ieee80211_hw *hw)
913{
914 struct ieee80211_local *local = hw_to_local(hw);
Jiri Bencf0706e82007-05-05 11:45:53 -0700915
916 tasklet_kill(&local->tx_pending_tasklet);
917 tasklet_kill(&local->tasklet);
918
919 rtnl_lock();
920
Johannes Berg79010422007-09-18 17:29:21 -0400921 /*
922 * At this point, interface list manipulations are fine
923 * because the driver cannot be handing us frames any
924 * more and the tasklet is killed.
925 */
Johannes Berg5b2812e2007-09-26 14:27:23 +0200926
Johannes Berg75636522008-07-09 14:40:35 +0200927 /* First, we remove all virtual interfaces. */
928 ieee80211_remove_interfaces(local);
Johannes Berg5b2812e2007-09-26 14:27:23 +0200929
930 /* then, finally, remove the master interface */
Johannes Berg3e122be2008-07-09 14:40:34 +0200931 unregister_netdevice(local->mdev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700932
933 rtnl_unlock();
934
Johannes Berg3e122be2008-07-09 14:40:34 +0200935 ieee80211_rx_bss_list_deinit(local);
Jiri Bencf0706e82007-05-05 11:45:53 -0700936 ieee80211_clear_tx_pending(local);
937 sta_info_stop(local);
938 rate_control_deinitialize(local);
Jiri Bence9f207f2007-05-05 11:46:38 -0700939 debugfs_hw_del(local);
Jiri Bencf0706e82007-05-05 11:45:53 -0700940
Jiri Bencf0706e82007-05-05 11:45:53 -0700941 if (skb_queue_len(&local->skb_queue)
942 || skb_queue_len(&local->skb_queue_unreliable))
943 printk(KERN_WARNING "%s: skb_queue not empty\n",
Johannes Bergdd1cd4c2007-09-18 17:29:20 -0400944 wiphy_name(local->hw.wiphy));
Jiri Bencf0706e82007-05-05 11:45:53 -0700945 skb_queue_purge(&local->skb_queue);
946 skb_queue_purge(&local->skb_queue_unreliable);
947
948 destroy_workqueue(local->hw.workqueue);
949 wiphy_unregister(local->hw.wiphy);
950 ieee80211_wep_free(local);
951 ieee80211_led_exit(local);
Johannes Berg3e122be2008-07-09 14:40:34 +0200952 free_netdev(local->mdev);
Jiri Bencf0706e82007-05-05 11:45:53 -0700953}
954EXPORT_SYMBOL(ieee80211_unregister_hw);
955
956void ieee80211_free_hw(struct ieee80211_hw *hw)
957{
958 struct ieee80211_local *local = hw_to_local(hw);
959
Jiri Bencf0706e82007-05-05 11:45:53 -0700960 wiphy_free(local->hw.wiphy);
961}
962EXPORT_SYMBOL(ieee80211_free_hw);
963
Jiri Bencf0706e82007-05-05 11:45:53 -0700964static int __init ieee80211_init(void)
965{
966 struct sk_buff *skb;
967 int ret;
968
Johannes Berge039fa42008-05-15 12:55:29 +0200969 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
970 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
Johannes Bergc6a1fa12008-10-07 12:04:32 +0200971 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
Jiri Bencf0706e82007-05-05 11:45:53 -0700972
Felix Fietkaucccf1292008-10-05 18:07:45 +0200973 ret = rc80211_minstrel_init();
974 if (ret)
975 return ret;
976
Johannes Berg4b475892008-01-02 15:17:03 +0100977 ret = rc80211_pid_init();
Mattias Nisslerad018372007-12-19 01:25:57 +0100978 if (ret)
David S. Miller51cb6db2008-07-15 03:34:57 -0700979 return ret;
Jiri Bencf0706e82007-05-05 11:45:53 -0700980
Jiri Bence9f207f2007-05-05 11:46:38 -0700981 ieee80211_debugfs_netdev_init();
982
Jiri Bencf0706e82007-05-05 11:45:53 -0700983 return 0;
984}
985
Jiri Bencf0706e82007-05-05 11:45:53 -0700986static void __exit ieee80211_exit(void)
987{
Johannes Berg4b475892008-01-02 15:17:03 +0100988 rc80211_pid_exit();
Felix Fietkaucccf1292008-10-05 18:07:45 +0200989 rc80211_minstrel_exit();
Johannes Bergac71c692007-10-28 14:17:44 +0100990
Johannes Berg3b967662008-04-08 17:56:52 +0200991 /*
992 * For key todo, it'll be empty by now but the work
993 * might still be scheduled.
994 */
995 flush_scheduled_work();
996
Luis Carlos Cobof7a92142008-02-23 15:17:18 +0100997 if (mesh_allocated)
998 ieee80211s_stop();
Johannes Berg902acc72008-02-23 15:17:19 +0100999
Jiri Bence9f207f2007-05-05 11:46:38 -07001000 ieee80211_debugfs_netdev_exit();
Jiri Bencf0706e82007-05-05 11:45:53 -07001001}
1002
1003
Johannes Bergca9938f2007-09-11 12:50:32 +02001004subsys_initcall(ieee80211_init);
Jiri Bencf0706e82007-05-05 11:45:53 -07001005module_exit(ieee80211_exit);
1006
1007MODULE_DESCRIPTION("IEEE 802.11 subsystem");
1008MODULE_LICENSE("GPL");