2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
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.
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 <net/net_namespace.h>
25 #include <net/cfg80211.h>
27 #include "ieee80211_i.h"
36 #include "debugfs_netdev.h"
39 * For seeing transmitted packets on monitor interfaces
40 * we have a radiotap header too.
42 struct ieee80211_tx_status_rtap_hdr {
43 struct ieee80211_radiotap_header hdr;
46 } __attribute__ ((packed));
49 /* must be called under mdev tx lock */
50 void ieee80211_configure_filter(struct ieee80211_local *local)
52 unsigned int changed_flags;
53 unsigned int new_flags = 0;
55 if (atomic_read(&local->iff_promiscs))
56 new_flags |= FIF_PROMISC_IN_BSS;
58 if (atomic_read(&local->iff_allmultis))
59 new_flags |= FIF_ALLMULTI;
62 new_flags |= FIF_BCN_PRBRESP_PROMISC;
64 if (local->fif_fcsfail)
65 new_flags |= FIF_FCSFAIL;
67 if (local->fif_plcpfail)
68 new_flags |= FIF_PLCPFAIL;
70 if (local->fif_control)
71 new_flags |= FIF_CONTROL;
73 if (local->fif_other_bss)
74 new_flags |= FIF_OTHER_BSS;
76 changed_flags = local->filter_flags ^ new_flags;
81 local->ops->configure_filter(local_to_hw(local),
82 changed_flags, &new_flags,
83 local->mdev->mc_count,
84 local->mdev->mc_list);
86 WARN_ON(new_flags & (1<<31));
88 local->filter_flags = new_flags & ~(1<<31);
91 /* master interface */
93 static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr)
95 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
99 static const struct header_ops ieee80211_header_ops = {
100 .create = eth_header,
101 .parse = header_parse_80211,
102 .rebuild = eth_rebuild_header,
103 .cache = eth_header_cache,
104 .cache_update = eth_header_cache_update,
107 static int ieee80211_master_open(struct net_device *dev)
109 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
110 struct ieee80211_sub_if_data *sdata;
111 int res = -EOPNOTSUPP;
113 /* we hold the RTNL here so can safely walk the list */
114 list_for_each_entry(sdata, &local->interfaces, list) {
115 if (netif_running(sdata->dev)) {
124 netif_tx_start_all_queues(local->mdev);
129 static int ieee80211_master_stop(struct net_device *dev)
131 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
132 struct ieee80211_sub_if_data *sdata;
134 /* we hold the RTNL here so can safely walk the list */
135 list_for_each_entry(sdata, &local->interfaces, list)
136 if (netif_running(sdata->dev))
137 dev_close(sdata->dev);
142 static void ieee80211_master_set_multicast_list(struct net_device *dev)
144 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
146 ieee80211_configure_filter(local);
149 /* everything else */
151 int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed)
153 struct ieee80211_local *local = sdata->local;
154 struct ieee80211_if_conf conf;
156 if (WARN_ON(!netif_running(sdata->dev)))
159 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
162 if (!local->ops->config_interface)
165 memset(&conf, 0, sizeof(conf));
166 conf.changed = changed;
168 if (sdata->vif.type == NL80211_IFTYPE_STATION ||
169 sdata->vif.type == NL80211_IFTYPE_ADHOC) {
170 conf.bssid = sdata->u.sta.bssid;
171 conf.ssid = sdata->u.sta.ssid;
172 conf.ssid_len = sdata->u.sta.ssid_len;
173 } else if (sdata->vif.type == NL80211_IFTYPE_AP) {
174 conf.bssid = sdata->dev->dev_addr;
175 conf.ssid = sdata->u.ap.ssid;
176 conf.ssid_len = sdata->u.ap.ssid_len;
177 } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
178 u8 zero[ETH_ALEN] = { 0 };
187 if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID)))
190 if (WARN_ON(!conf.ssid && (changed & IEEE80211_IFCC_SSID)))
193 return local->ops->config_interface(local_to_hw(local),
197 int ieee80211_hw_config(struct ieee80211_local *local)
199 struct ieee80211_channel *chan;
202 if (local->sw_scanning)
203 chan = local->scan_channel;
205 chan = local->oper_channel;
207 local->hw.conf.channel = chan;
209 if (!local->hw.conf.power_level)
210 local->hw.conf.power_level = chan->max_power;
212 local->hw.conf.power_level = min(chan->max_power,
213 local->hw.conf.power_level);
215 local->hw.conf.max_antenna_gain = chan->max_antenna_gain;
217 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
218 printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n",
219 wiphy_name(local->hw.wiphy), chan->center_freq);
222 if (local->open_count)
223 ret = local->ops->config(local_to_hw(local), &local->hw.conf);
229 * ieee80211_handle_ht should be used only after legacy configuration
230 * has been determined namely band, as ht configuration depends upon
231 * the hardware's HT abilities for a _specific_ band.
233 u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht,
234 struct ieee80211_ht_info *req_ht_cap,
235 struct ieee80211_ht_bss_info *req_bss_cap)
237 struct ieee80211_conf *conf = &local->hw.conf;
238 struct ieee80211_supported_band *sband;
239 struct ieee80211_ht_info ht_conf;
240 struct ieee80211_ht_bss_info ht_bss_conf;
243 u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS;
246 sband = local->hw.wiphy->bands[conf->channel->band];
248 memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info));
249 memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info));
251 /* HT is not supported */
252 if (!sband->ht_info.ht_supported) {
253 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
259 if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)
260 changed |= BSS_CHANGED_HT;
261 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE;
262 conf->ht_conf.ht_supported = 0;
267 if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE))
268 changed |= BSS_CHANGED_HT;
270 conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE;
271 ht_conf.ht_supported = 1;
273 ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap;
274 ht_conf.cap &= ~(IEEE80211_HT_CAP_SM_PS);
275 ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_SM_PS;
276 ht_bss_conf.primary_channel = req_bss_cap->primary_channel;
277 ht_bss_conf.bss_cap = req_bss_cap->bss_cap;
278 ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode;
280 ht_conf.ampdu_factor = req_ht_cap->ampdu_factor;
281 ht_conf.ampdu_density = req_ht_cap->ampdu_density;
284 tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12];
286 /* configure suppoerted Tx MCS according to requested MCS
287 * (based in most cases on Rx capabilities of peer) and self
288 * Tx MCS capabilities (as defined by low level driver HW
289 * Tx capabilities) */
290 if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED))
293 /* Counting from 0 therfore + 1 */
294 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF)
295 max_tx_streams = ((tx_mcs_set_cap &
296 IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1;
298 for (i = 0; i < max_tx_streams; i++)
299 ht_conf.supp_mcs_set[i] =
300 sband->ht_info.supp_mcs_set[i] &
301 req_ht_cap->supp_mcs_set[i];
303 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM)
304 for (i = IEEE80211_SUPP_MCS_SET_UEQM;
305 i < IEEE80211_SUPP_MCS_SET_LEN; i++)
306 ht_conf.supp_mcs_set[i] =
307 sband->ht_info.supp_mcs_set[i] &
308 req_ht_cap->supp_mcs_set[i];
311 /* if bss configuration changed store the new one */
312 if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) ||
313 memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) {
314 changed |= BSS_CHANGED_HT;
315 memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf));
316 memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf));
322 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata,
325 struct ieee80211_local *local = sdata->local;
327 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN))
333 if (local->ops->bss_info_changed)
334 local->ops->bss_info_changed(local_to_hw(local),
340 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata)
342 sdata->bss_conf.use_cts_prot = 0;
343 sdata->bss_conf.use_short_preamble = 0;
344 return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE;
347 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
350 struct ieee80211_local *local = hw_to_local(hw);
351 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
354 skb->dev = local->mdev;
355 skb->pkt_type = IEEE80211_TX_STATUS_MSG;
356 skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ?
357 &local->skb_queue : &local->skb_queue_unreliable, skb);
358 tmp = skb_queue_len(&local->skb_queue) +
359 skb_queue_len(&local->skb_queue_unreliable);
360 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT &&
361 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
362 dev_kfree_skb_irq(skb);
364 I802_DEBUG_INC(local->tx_status_drop);
366 tasklet_schedule(&local->tasklet);
368 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe);
370 static void ieee80211_tasklet_handler(unsigned long data)
372 struct ieee80211_local *local = (struct ieee80211_local *) data;
374 struct ieee80211_rx_status rx_status;
375 struct ieee80211_ra_tid *ra_tid;
377 while ((skb = skb_dequeue(&local->skb_queue)) ||
378 (skb = skb_dequeue(&local->skb_queue_unreliable))) {
379 switch (skb->pkt_type) {
380 case IEEE80211_RX_MSG:
381 /* status is in skb->cb */
382 memcpy(&rx_status, skb->cb, sizeof(rx_status));
383 /* Clear skb->pkt_type in order to not confuse kernel
386 __ieee80211_rx(local_to_hw(local), skb, &rx_status);
388 case IEEE80211_TX_STATUS_MSG:
390 ieee80211_tx_status(local_to_hw(local), skb);
392 case IEEE80211_DELBA_MSG:
393 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
394 ieee80211_stop_tx_ba_cb(local_to_hw(local),
395 ra_tid->ra, ra_tid->tid);
398 case IEEE80211_ADDBA_MSG:
399 ra_tid = (struct ieee80211_ra_tid *) &skb->cb;
400 ieee80211_start_tx_ba_cb(local_to_hw(local),
401 ra_tid->ra, ra_tid->tid);
412 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to
413 * make a prepared TX frame (one that has been given to hw) to look like brand
414 * new IEEE 802.11 frame that is ready to go through TX processing again.
416 static void ieee80211_remove_tx_extra(struct ieee80211_local *local,
417 struct ieee80211_key *key,
420 unsigned int hdrlen, iv_len, mic_len;
421 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
423 hdrlen = ieee80211_hdrlen(hdr->frame_control);
428 switch (key->conf.alg) {
431 mic_len = WEP_ICV_LEN;
434 iv_len = TKIP_IV_LEN;
435 mic_len = TKIP_ICV_LEN;
438 iv_len = CCMP_HDR_LEN;
439 mic_len = CCMP_MIC_LEN;
445 if (skb->len >= hdrlen + mic_len &&
446 !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
447 skb_trim(skb, skb->len - mic_len);
448 if (skb->len >= hdrlen + iv_len) {
449 memmove(skb->data + iv_len, skb->data, hdrlen);
450 hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len);
454 if (ieee80211_is_data_qos(hdr->frame_control)) {
455 hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
456 memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data,
457 hdrlen - IEEE80211_QOS_CTL_LEN);
458 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
462 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local,
463 struct sta_info *sta,
466 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
468 sta->tx_filtered_count++;
471 * Clear the TX filter mask for this STA when sending the next
472 * packet. If the STA went to power save mode, this will happen
473 * when it wakes up for the next time.
475 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
478 * This code races in the following way:
480 * (1) STA sends frame indicating it will go to sleep and does so
481 * (2) hardware/firmware adds STA to filter list, passes frame up
482 * (3) hardware/firmware processes TX fifo and suppresses a frame
483 * (4) we get TX status before having processed the frame and
484 * knowing that the STA has gone to sleep.
486 * This is actually quite unlikely even when both those events are
487 * processed from interrupts coming in quickly after one another or
488 * even at the same time because we queue both TX status events and
489 * RX frames to be processed by a tasklet and process them in the
490 * same order that they were received or TX status last. Hence, there
491 * is no race as long as the frame RX is processed before the next TX
492 * status, which drivers can ensure, see below.
494 * Note that this can only happen if the hardware or firmware can
495 * actually add STAs to the filter list, if this is done by the
496 * driver in response to set_tim() (which will only reduce the race
497 * this whole filtering tries to solve, not completely solve it)
498 * this situation cannot happen.
500 * To completely solve this race drivers need to make sure that they
501 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing
503 * (b) always process RX events before TX status events if ordering
504 * can be unknown, for example with different interrupt status
507 if (test_sta_flags(sta, WLAN_STA_PS) &&
508 skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) {
509 ieee80211_remove_tx_extra(local, sta->key, skb);
510 skb_queue_tail(&sta->tx_filtered, skb);
514 if (!test_sta_flags(sta, WLAN_STA_PS) &&
515 !(info->flags & IEEE80211_TX_CTL_REQUEUE)) {
516 /* Software retry the packet once */
517 info->flags |= IEEE80211_TX_CTL_REQUEUE;
518 ieee80211_remove_tx_extra(local, sta->key, skb);
523 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
525 printk(KERN_DEBUG "%s: dropped TX filtered frame, "
526 "queue_len=%d PS=%d @%lu\n",
527 wiphy_name(local->hw.wiphy),
528 skb_queue_len(&sta->tx_filtered),
529 !!test_sta_flags(sta, WLAN_STA_PS), jiffies);
534 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb)
536 struct sk_buff *skb2;
537 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
538 struct ieee80211_local *local = hw_to_local(hw);
539 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
542 struct ieee80211_tx_status_rtap_hdr *rthdr;
543 struct ieee80211_sub_if_data *sdata;
544 struct net_device *prev_dev = NULL;
545 struct sta_info *sta;
549 sta = sta_info_get(local, hdr->addr1);
552 if (info->status.excessive_retries &&
553 test_sta_flags(sta, WLAN_STA_PS)) {
555 * The STA is in power save mode, so assume
556 * that this TX packet failed because of that.
558 ieee80211_handle_filtered_frame(local, sta, skb);
563 fc = hdr->frame_control;
565 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) &&
566 (ieee80211_is_data_qos(fc))) {
570 qc = ieee80211_get_qos_ctl(hdr);
572 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10)
573 & IEEE80211_SCTL_SEQ);
574 ieee80211_send_bar(sta->sdata, hdr->addr1,
578 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
579 ieee80211_handle_filtered_frame(local, sta, skb);
583 if (info->status.excessive_retries)
584 sta->tx_retry_failed++;
585 sta->tx_retry_count += info->status.retry_count;
588 rate_control_tx_status(local->mdev, skb);
593 ieee80211_led_tx(local, 0);
596 * Fragments are passed to low-level drivers as separate skbs, so these
597 * are actually fragments, not frames. Update frame counters only for
598 * the first fragment of the frame. */
600 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG;
601 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE;
603 if (info->flags & IEEE80211_TX_STAT_ACK) {
605 local->dot11TransmittedFrameCount++;
606 if (is_multicast_ether_addr(hdr->addr1))
607 local->dot11MulticastTransmittedFrameCount++;
608 if (info->status.retry_count > 0)
609 local->dot11RetryCount++;
610 if (info->status.retry_count > 1)
611 local->dot11MultipleRetryCount++;
614 /* This counter shall be incremented for an acknowledged MPDU
615 * with an individual address in the address 1 field or an MPDU
616 * with a multicast address in the address 1 field of type Data
618 if (!is_multicast_ether_addr(hdr->addr1) ||
619 type == IEEE80211_FTYPE_DATA ||
620 type == IEEE80211_FTYPE_MGMT)
621 local->dot11TransmittedFragmentCount++;
624 local->dot11FailedCount++;
627 /* this was a transmitted frame, but now we want to reuse it */
631 * This is a bit racy but we can avoid a lot of work
634 if (!local->monitors && !local->cooked_mntrs) {
639 /* send frame to monitor interfaces now */
641 if (skb_headroom(skb) < sizeof(*rthdr)) {
642 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n");
647 rthdr = (struct ieee80211_tx_status_rtap_hdr *)
648 skb_push(skb, sizeof(*rthdr));
650 memset(rthdr, 0, sizeof(*rthdr));
651 rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr));
652 rthdr->hdr.it_present =
653 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) |
654 (1 << IEEE80211_RADIOTAP_DATA_RETRIES));
656 if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
657 !is_multicast_ether_addr(hdr->addr1))
658 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL);
660 if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) &&
661 (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT))
662 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS);
663 else if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS)
664 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS);
666 rthdr->data_retries = info->status.retry_count;
668 /* XXX: is this sufficient for BPF? */
669 skb_set_mac_header(skb, 0);
670 skb->ip_summed = CHECKSUM_UNNECESSARY;
671 skb->pkt_type = PACKET_OTHERHOST;
672 skb->protocol = htons(ETH_P_802_2);
673 memset(skb->cb, 0, sizeof(skb->cb));
676 list_for_each_entry_rcu(sdata, &local->interfaces, list) {
677 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) {
678 if (!netif_running(sdata->dev))
682 skb2 = skb_clone(skb, GFP_ATOMIC);
684 skb2->dev = prev_dev;
689 prev_dev = sdata->dev;
700 EXPORT_SYMBOL(ieee80211_tx_status);
702 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
703 const struct ieee80211_ops *ops)
705 struct ieee80211_local *local;
709 /* Ensure 32-byte alignment of our private data and hw private data.
710 * We use the wiphy priv data for both our ieee80211_local and for
711 * the driver's private data
713 * In memory it'll be like this:
715 * +-------------------------+
717 * +-------------------------+
718 * | struct ieee80211_local |
719 * +-------------------------+
720 * | driver's private data |
721 * +-------------------------+
724 priv_size = ((sizeof(struct ieee80211_local) +
725 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) +
728 wiphy = wiphy_new(&mac80211_config_ops, priv_size);
733 wiphy->privid = mac80211_wiphy_privid;
735 local = wiphy_priv(wiphy);
736 local->hw.wiphy = wiphy;
738 local->hw.priv = (char *)local +
739 ((sizeof(struct ieee80211_local) +
740 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
745 BUG_ON(!ops->config);
746 BUG_ON(!ops->add_interface);
747 BUG_ON(!ops->remove_interface);
748 BUG_ON(!ops->configure_filter);
751 local->hw.queues = 1; /* default */
753 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
754 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
755 local->short_retry_limit = 7;
756 local->long_retry_limit = 4;
757 local->hw.conf.radio_enabled = 1;
759 INIT_LIST_HEAD(&local->interfaces);
761 spin_lock_init(&local->key_lock);
763 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work);
765 sta_info_init(local);
767 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending,
768 (unsigned long)local);
769 tasklet_disable(&local->tx_pending_tasklet);
771 tasklet_init(&local->tasklet,
772 ieee80211_tasklet_handler,
773 (unsigned long) local);
774 tasklet_disable(&local->tasklet);
776 skb_queue_head_init(&local->skb_queue);
777 skb_queue_head_init(&local->skb_queue_unreliable);
779 return local_to_hw(local);
781 EXPORT_SYMBOL(ieee80211_alloc_hw);
783 int ieee80211_register_hw(struct ieee80211_hw *hw)
785 struct ieee80211_local *local = hw_to_local(hw);
788 enum ieee80211_band band;
789 struct net_device *mdev;
790 struct wireless_dev *mwdev;
793 * generic code guarantees at least one band,
794 * set this very early because much code assumes
795 * that hw.conf.channel is assigned
797 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
798 struct ieee80211_supported_band *sband;
800 sband = local->hw.wiphy->bands[band];
802 /* init channel we're on */
803 local->hw.conf.channel =
804 local->oper_channel =
805 local->scan_channel = &sband->channels[0];
810 /* if low-level driver supports AP, we also support VLAN */
811 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP))
812 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
814 /* mac80211 always supports monitor */
815 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
817 result = wiphy_register(local->hw.wiphy);
822 * We use the number of queues for feature tests (QoS, HT) internally
823 * so restrict them appropriately.
825 if (hw->queues > IEEE80211_MAX_QUEUES)
826 hw->queues = IEEE80211_MAX_QUEUES;
827 if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES)
828 hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES;
830 hw->ampdu_queues = 0;
832 mdev = alloc_netdev_mq(sizeof(struct wireless_dev),
833 "wmaster%d", ether_setup,
834 ieee80211_num_queues(hw));
836 goto fail_mdev_alloc;
838 mwdev = netdev_priv(mdev);
839 mdev->ieee80211_ptr = mwdev;
840 mwdev->wiphy = local->hw.wiphy;
844 ieee80211_rx_bss_list_init(local);
846 mdev->hard_start_xmit = ieee80211_master_start_xmit;
847 mdev->open = ieee80211_master_open;
848 mdev->stop = ieee80211_master_stop;
849 mdev->type = ARPHRD_IEEE80211;
850 mdev->header_ops = &ieee80211_header_ops;
851 mdev->set_multicast_list = ieee80211_master_set_multicast_list;
853 name = wiphy_dev(local->hw.wiphy)->driver->name;
854 local->hw.workqueue = create_freezeable_workqueue(name);
855 if (!local->hw.workqueue) {
861 * The hardware needs headroom for sending the frame,
862 * and we need some headroom for passing the frame to monitor
863 * interfaces, but never both at the same time.
865 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom,
866 sizeof(struct ieee80211_tx_status_rtap_hdr));
868 debugfs_hw_add(local);
870 if (local->hw.conf.beacon_int < 10)
871 local->hw.conf.beacon_int = 100;
873 if (local->hw.max_listen_interval == 0)
874 local->hw.max_listen_interval = 1;
876 local->hw.conf.listen_interval = local->hw.max_listen_interval;
878 local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC |
879 IEEE80211_HW_SIGNAL_DB |
880 IEEE80211_HW_SIGNAL_DBM) ?
881 IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID;
882 local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ?
883 IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID;
884 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
885 local->wstats_flags |= IW_QUAL_DBM;
887 result = sta_info_start(local);
892 result = dev_alloc_name(local->mdev, local->mdev->name);
896 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
897 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy));
899 result = register_netdevice(local->mdev);
903 result = ieee80211_init_rate_ctrl_alg(local,
904 hw->rate_control_algorithm);
906 printk(KERN_DEBUG "%s: Failed to initialize rate control "
907 "algorithm\n", wiphy_name(local->hw.wiphy));
911 result = ieee80211_wep_init(local);
914 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n",
915 wiphy_name(local->hw.wiphy), result);
919 local->mdev->select_queue = ieee80211_select_queue;
921 /* add one default STA interface */
922 result = ieee80211_if_add(local, "wlan%d", NULL,
923 NL80211_IFTYPE_STATION, NULL);
925 printk(KERN_WARNING "%s: Failed to add default virtual iface\n",
926 wiphy_name(local->hw.wiphy));
930 ieee80211_led_init(local);
935 rate_control_deinitialize(local);
937 unregister_netdevice(local->mdev);
941 sta_info_stop(local);
943 debugfs_hw_del(local);
944 destroy_workqueue(local->hw.workqueue);
947 free_netdev(local->mdev);
949 wiphy_unregister(local->hw.wiphy);
952 EXPORT_SYMBOL(ieee80211_register_hw);
954 void ieee80211_unregister_hw(struct ieee80211_hw *hw)
956 struct ieee80211_local *local = hw_to_local(hw);
958 tasklet_kill(&local->tx_pending_tasklet);
959 tasklet_kill(&local->tasklet);
964 * At this point, interface list manipulations are fine
965 * because the driver cannot be handing us frames any
966 * more and the tasklet is killed.
969 /* First, we remove all virtual interfaces. */
970 ieee80211_remove_interfaces(local);
972 /* then, finally, remove the master interface */
973 unregister_netdevice(local->mdev);
977 ieee80211_rx_bss_list_deinit(local);
978 ieee80211_clear_tx_pending(local);
979 sta_info_stop(local);
980 rate_control_deinitialize(local);
981 debugfs_hw_del(local);
983 if (skb_queue_len(&local->skb_queue)
984 || skb_queue_len(&local->skb_queue_unreliable))
985 printk(KERN_WARNING "%s: skb_queue not empty\n",
986 wiphy_name(local->hw.wiphy));
987 skb_queue_purge(&local->skb_queue);
988 skb_queue_purge(&local->skb_queue_unreliable);
990 destroy_workqueue(local->hw.workqueue);
991 wiphy_unregister(local->hw.wiphy);
992 ieee80211_wep_free(local);
993 ieee80211_led_exit(local);
994 free_netdev(local->mdev);
996 EXPORT_SYMBOL(ieee80211_unregister_hw);
998 void ieee80211_free_hw(struct ieee80211_hw *hw)
1000 struct ieee80211_local *local = hw_to_local(hw);
1002 wiphy_free(local->hw.wiphy);
1004 EXPORT_SYMBOL(ieee80211_free_hw);
1006 static int __init ieee80211_init(void)
1008 struct sk_buff *skb;
1011 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb));
1012 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) +
1013 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb));
1015 ret = rc80211_pid_init();
1019 ieee80211_debugfs_netdev_init();
1024 static void __exit ieee80211_exit(void)
1029 * For key todo, it'll be empty by now but the work
1030 * might still be scheduled.
1032 flush_scheduled_work();
1037 ieee80211_debugfs_netdev_exit();
1041 subsys_initcall(ieee80211_init);
1042 module_exit(ieee80211_exit);
1044 MODULE_DESCRIPTION("IEEE 802.11 subsystem");
1045 MODULE_LICENSE("GPL");