main.c revision 7a725f73403e874ec52c58741e9b98cd604dbd03
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 <net/net_namespace.h> 25#include <net/cfg80211.h> 26 27#include "ieee80211_i.h" 28#include "rate.h" 29#include "mesh.h" 30#include "wep.h" 31#include "wme.h" 32#include "aes_ccm.h" 33#include "led.h" 34#include "cfg.h" 35#include "debugfs.h" 36#include "debugfs_netdev.h" 37 38/* 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; 44 __le16 tx_flags; 45 u8 data_retries; 46} __attribute__ ((packed)); 47 48 49/* must be called under mdev tx lock */ 50void ieee80211_configure_filter(struct ieee80211_local *local) 51{ 52 unsigned int changed_flags; 53 unsigned int new_flags = 0; 54 55 if (atomic_read(&local->iff_promiscs)) 56 new_flags |= FIF_PROMISC_IN_BSS; 57 58 if (atomic_read(&local->iff_allmultis)) 59 new_flags |= FIF_ALLMULTI; 60 61 if (local->monitors) 62 new_flags |= FIF_BCN_PRBRESP_PROMISC; 63 64 if (local->fif_fcsfail) 65 new_flags |= FIF_FCSFAIL; 66 67 if (local->fif_plcpfail) 68 new_flags |= FIF_PLCPFAIL; 69 70 if (local->fif_control) 71 new_flags |= FIF_CONTROL; 72 73 if (local->fif_other_bss) 74 new_flags |= FIF_OTHER_BSS; 75 76 changed_flags = local->filter_flags ^ new_flags; 77 78 /* be a bit nasty */ 79 new_flags |= (1<<31); 80 81 local->ops->configure_filter(local_to_hw(local), 82 changed_flags, &new_flags, 83 local->mdev->mc_count, 84 local->mdev->mc_list); 85 86 WARN_ON(new_flags & (1<<31)); 87 88 local->filter_flags = new_flags & ~(1<<31); 89} 90 91/* master interface */ 92 93static int header_parse_80211(const struct sk_buff *skb, unsigned char *haddr) 94{ 95 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */ 96 return ETH_ALEN; 97} 98 99static 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, 105}; 106 107static int ieee80211_master_open(struct net_device *dev) 108{ 109 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 110 struct ieee80211_sub_if_data *sdata; 111 int res = -EOPNOTSUPP; 112 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)) { 116 res = 0; 117 break; 118 } 119 } 120 121 if (res) 122 return res; 123 124 netif_tx_start_all_queues(local->mdev); 125 126 return 0; 127} 128 129static int ieee80211_master_stop(struct net_device *dev) 130{ 131 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 132 struct ieee80211_sub_if_data *sdata; 133 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); 138 139 return 0; 140} 141 142static void ieee80211_master_set_multicast_list(struct net_device *dev) 143{ 144 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr); 145 146 ieee80211_configure_filter(local); 147} 148 149/* everything else */ 150 151int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed) 152{ 153 struct ieee80211_local *local = sdata->local; 154 struct ieee80211_if_conf conf; 155 156 if (WARN_ON(!netif_running(sdata->dev))) 157 return 0; 158 159 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) 160 return -EINVAL; 161 162 if (!local->ops->config_interface) 163 return 0; 164 165 memset(&conf, 0, sizeof(conf)); 166 conf.changed = changed; 167 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 }; 179 conf.bssid = zero; 180 conf.ssid = zero; 181 conf.ssid_len = 0; 182 } else { 183 WARN_ON(1); 184 return -EINVAL; 185 } 186 187 if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID))) 188 return -EINVAL; 189 190 if (WARN_ON(!conf.ssid && (changed & IEEE80211_IFCC_SSID))) 191 return -EINVAL; 192 193 return local->ops->config_interface(local_to_hw(local), 194 &sdata->vif, &conf); 195} 196 197int ieee80211_hw_config(struct ieee80211_local *local) 198{ 199 struct ieee80211_channel *chan; 200 int ret = 0; 201 202 if (local->sw_scanning) 203 chan = local->scan_channel; 204 else 205 chan = local->oper_channel; 206 207 local->hw.conf.channel = chan; 208 209 if (!local->hw.conf.power_level) 210 local->hw.conf.power_level = chan->max_power; 211 else 212 local->hw.conf.power_level = min(chan->max_power, 213 local->hw.conf.power_level); 214 215 local->hw.conf.max_antenna_gain = chan->max_antenna_gain; 216 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); 220#endif 221 222 if (local->open_count) 223 ret = local->ops->config(local_to_hw(local), &local->hw.conf); 224 225 return ret; 226} 227 228/** 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. 232 */ 233u32 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) 236{ 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; 241 u32 changed = 0; 242 int i; 243 u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS; 244 u8 tx_mcs_set_cap; 245 246 sband = local->hw.wiphy->bands[conf->channel->band]; 247 248 memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info)); 249 memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info)); 250 251 /* HT is not supported */ 252 if (!sband->ht_info.ht_supported) { 253 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 254 goto out; 255 } 256 257 /* disable HT */ 258 if (!enable_ht) { 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; 263 goto out; 264 } 265 266 267 if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) 268 changed |= BSS_CHANGED_HT; 269 270 conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE; 271 ht_conf.ht_supported = 1; 272 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; 279 280 ht_conf.ampdu_factor = req_ht_cap->ampdu_factor; 281 ht_conf.ampdu_density = req_ht_cap->ampdu_density; 282 283 /* Bits 96-100 */ 284 tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12]; 285 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)) 291 goto check_changed; 292 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; 297 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]; 302 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]; 309 310check_changed: 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)); 317 } 318out: 319 return changed; 320} 321 322void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 323 u32 changed) 324{ 325 struct ieee80211_local *local = sdata->local; 326 327 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) 328 return; 329 330 if (!changed) 331 return; 332 333 if (local->ops->bss_info_changed) 334 local->ops->bss_info_changed(local_to_hw(local), 335 &sdata->vif, 336 &sdata->bss_conf, 337 changed); 338} 339 340u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 341{ 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; 345} 346 347void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw, 348 struct sk_buff *skb) 349{ 350 struct ieee80211_local *local = hw_to_local(hw); 351 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 352 int tmp; 353 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); 363 tmp--; 364 I802_DEBUG_INC(local->tx_status_drop); 365 } 366 tasklet_schedule(&local->tasklet); 367} 368EXPORT_SYMBOL(ieee80211_tx_status_irqsafe); 369 370static void ieee80211_tasklet_handler(unsigned long data) 371{ 372 struct ieee80211_local *local = (struct ieee80211_local *) data; 373 struct sk_buff *skb; 374 struct ieee80211_rx_status rx_status; 375 struct ieee80211_ra_tid *ra_tid; 376 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 384 * netstack. */ 385 skb->pkt_type = 0; 386 __ieee80211_rx(local_to_hw(local), skb, &rx_status); 387 break; 388 case IEEE80211_TX_STATUS_MSG: 389 skb->pkt_type = 0; 390 ieee80211_tx_status(local_to_hw(local), skb); 391 break; 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); 396 dev_kfree_skb(skb); 397 break; 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); 402 dev_kfree_skb(skb); 403 break ; 404 default: 405 WARN_ON(1); 406 dev_kfree_skb(skb); 407 break; 408 } 409 } 410} 411 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. 415 */ 416static void ieee80211_remove_tx_extra(struct ieee80211_local *local, 417 struct ieee80211_key *key, 418 struct sk_buff *skb) 419{ 420 unsigned int hdrlen, iv_len, mic_len; 421 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 422 423 hdrlen = ieee80211_hdrlen(hdr->frame_control); 424 425 if (!key) 426 goto no_key; 427 428 switch (key->conf.alg) { 429 case ALG_WEP: 430 iv_len = WEP_IV_LEN; 431 mic_len = WEP_ICV_LEN; 432 break; 433 case ALG_TKIP: 434 iv_len = TKIP_IV_LEN; 435 mic_len = TKIP_ICV_LEN; 436 break; 437 case ALG_CCMP: 438 iv_len = CCMP_HDR_LEN; 439 mic_len = CCMP_MIC_LEN; 440 break; 441 default: 442 goto no_key; 443 } 444 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); 451 } 452 453no_key: 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); 459 } 460} 461 462static void ieee80211_handle_filtered_frame(struct ieee80211_local *local, 463 struct sta_info *sta, 464 struct sk_buff *skb) 465{ 466 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 467 468 sta->tx_filtered_count++; 469 470 /* 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. 474 */ 475 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT); 476 477 /* 478 * This code races in the following way: 479 * 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. 485 * 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. 493 * 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. 499 * 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 502 * functions and 503 * (b) always process RX events before TX status events if ordering 504 * can be unknown, for example with different interrupt status 505 * bits. 506 */ 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); 511 return; 512 } 513 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); 519 dev_queue_xmit(skb); 520 return; 521 } 522 523#ifdef CONFIG_MAC80211_VERBOSE_DEBUG 524 if (net_ratelimit()) 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); 530#endif 531 dev_kfree_skb(skb); 532} 533 534void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb) 535{ 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); 540 u16 frag, type; 541 __le16 fc; 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; 546 547 rcu_read_lock(); 548 549 if (info->status.excessive_retries) { 550 sta = sta_info_get(local, hdr->addr1); 551 if (sta) { 552 if (test_sta_flags(sta, WLAN_STA_PS)) { 553 /* 554 * The STA is in power save mode, so assume 555 * that this TX packet failed because of that. 556 */ 557 ieee80211_handle_filtered_frame(local, sta, skb); 558 rcu_read_unlock(); 559 return; 560 } 561 } 562 } 563 564 fc = hdr->frame_control; 565 566 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) && 567 (ieee80211_is_data_qos(fc))) { 568 u16 tid, ssn; 569 u8 *qc; 570 sta = sta_info_get(local, hdr->addr1); 571 if (sta) { 572 qc = ieee80211_get_qos_ctl(hdr); 573 tid = qc[0] & 0xf; 574 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10) 575 & IEEE80211_SCTL_SEQ); 576 ieee80211_send_bar(sta->sdata, hdr->addr1, 577 tid, ssn); 578 } 579 } 580 581 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) { 582 sta = sta_info_get(local, hdr->addr1); 583 if (sta) { 584 ieee80211_handle_filtered_frame(local, sta, skb); 585 rcu_read_unlock(); 586 return; 587 } 588 } else 589 rate_control_tx_status(local->mdev, skb); 590 591 rcu_read_unlock(); 592 593 ieee80211_led_tx(local, 0); 594 595 /* SNMP counters 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. */ 599 600 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG; 601 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE; 602 603 if (info->flags & IEEE80211_TX_STAT_ACK) { 604 if (frag == 0) { 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++; 612 } 613 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 617 * or Management. */ 618 if (!is_multicast_ether_addr(hdr->addr1) || 619 type == IEEE80211_FTYPE_DATA || 620 type == IEEE80211_FTYPE_MGMT) 621 local->dot11TransmittedFragmentCount++; 622 } else { 623 if (frag == 0) 624 local->dot11FailedCount++; 625 } 626 627 /* this was a transmitted frame, but now we want to reuse it */ 628 skb_orphan(skb); 629 630 /* 631 * This is a bit racy but we can avoid a lot of work 632 * with this test... 633 */ 634 if (!local->monitors && !local->cooked_mntrs) { 635 dev_kfree_skb(skb); 636 return; 637 } 638 639 /* send frame to monitor interfaces now */ 640 641 if (skb_headroom(skb) < sizeof(*rthdr)) { 642 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n"); 643 dev_kfree_skb(skb); 644 return; 645 } 646 647 rthdr = (struct ieee80211_tx_status_rtap_hdr *) 648 skb_push(skb, sizeof(*rthdr)); 649 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)); 655 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); 659 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); 665 666 rthdr->data_retries = info->status.retry_count; 667 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)); 674 675 rcu_read_lock(); 676 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 677 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) { 678 if (!netif_running(sdata->dev)) 679 continue; 680 681 if (prev_dev) { 682 skb2 = skb_clone(skb, GFP_ATOMIC); 683 if (skb2) { 684 skb2->dev = prev_dev; 685 netif_rx(skb2); 686 } 687 } 688 689 prev_dev = sdata->dev; 690 } 691 } 692 if (prev_dev) { 693 skb->dev = prev_dev; 694 netif_rx(skb); 695 skb = NULL; 696 } 697 rcu_read_unlock(); 698 dev_kfree_skb(skb); 699} 700EXPORT_SYMBOL(ieee80211_tx_status); 701 702struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 703 const struct ieee80211_ops *ops) 704{ 705 struct ieee80211_local *local; 706 int priv_size; 707 struct wiphy *wiphy; 708 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 712 * 713 * In memory it'll be like this: 714 * 715 * +-------------------------+ 716 * | struct wiphy | 717 * +-------------------------+ 718 * | struct ieee80211_local | 719 * +-------------------------+ 720 * | driver's private data | 721 * +-------------------------+ 722 * 723 */ 724 priv_size = ((sizeof(struct ieee80211_local) + 725 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) + 726 priv_data_len; 727 728 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 729 730 if (!wiphy) 731 return NULL; 732 733 wiphy->privid = mac80211_wiphy_privid; 734 735 local = wiphy_priv(wiphy); 736 local->hw.wiphy = wiphy; 737 738 local->hw.priv = (char *)local + 739 ((sizeof(struct ieee80211_local) + 740 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST); 741 742 BUG_ON(!ops->tx); 743 BUG_ON(!ops->start); 744 BUG_ON(!ops->stop); 745 BUG_ON(!ops->config); 746 BUG_ON(!ops->add_interface); 747 BUG_ON(!ops->remove_interface); 748 BUG_ON(!ops->configure_filter); 749 local->ops = ops; 750 751 local->hw.queues = 1; /* default */ 752 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; 758 759 INIT_LIST_HEAD(&local->interfaces); 760 761 spin_lock_init(&local->key_lock); 762 763 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 764 765 sta_info_init(local); 766 767 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 768 (unsigned long)local); 769 tasklet_disable(&local->tx_pending_tasklet); 770 771 tasklet_init(&local->tasklet, 772 ieee80211_tasklet_handler, 773 (unsigned long) local); 774 tasklet_disable(&local->tasklet); 775 776 skb_queue_head_init(&local->skb_queue); 777 skb_queue_head_init(&local->skb_queue_unreliable); 778 779 return local_to_hw(local); 780} 781EXPORT_SYMBOL(ieee80211_alloc_hw); 782 783int ieee80211_register_hw(struct ieee80211_hw *hw) 784{ 785 struct ieee80211_local *local = hw_to_local(hw); 786 const char *name; 787 int result; 788 enum ieee80211_band band; 789 struct net_device *mdev; 790 struct wireless_dev *mwdev; 791 792 /* 793 * generic code guarantees at least one band, 794 * set this very early because much code assumes 795 * that hw.conf.channel is assigned 796 */ 797 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 798 struct ieee80211_supported_band *sband; 799 800 sband = local->hw.wiphy->bands[band]; 801 if (sband) { 802 /* init channel we're on */ 803 local->hw.conf.channel = 804 local->oper_channel = 805 local->scan_channel = &sband->channels[0]; 806 break; 807 } 808 } 809 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); 813 814 /* mac80211 always supports monitor */ 815 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 816 817 result = wiphy_register(local->hw.wiphy); 818 if (result < 0) 819 return result; 820 821 /* 822 * We use the number of queues for feature tests (QoS, HT) internally 823 * so restrict them appropriately. 824 */ 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; 829 if (hw->queues < 4) 830 hw->ampdu_queues = 0; 831 832 mdev = alloc_netdev_mq(sizeof(struct wireless_dev), 833 "wmaster%d", ether_setup, 834 ieee80211_num_queues(hw)); 835 if (!mdev) 836 goto fail_mdev_alloc; 837 838 mwdev = netdev_priv(mdev); 839 mdev->ieee80211_ptr = mwdev; 840 mwdev->wiphy = local->hw.wiphy; 841 842 local->mdev = mdev; 843 844 ieee80211_rx_bss_list_init(local); 845 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; 852 853 name = wiphy_dev(local->hw.wiphy)->driver->name; 854 local->hw.workqueue = create_freezeable_workqueue(name); 855 if (!local->hw.workqueue) { 856 result = -ENOMEM; 857 goto fail_workqueue; 858 } 859 860 /* 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. 864 */ 865 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 866 sizeof(struct ieee80211_tx_status_rtap_hdr)); 867 868 debugfs_hw_add(local); 869 870 if (local->hw.conf.beacon_int < 10) 871 local->hw.conf.beacon_int = 100; 872 873 if (local->hw.max_listen_interval == 0) 874 local->hw.max_listen_interval = 1; 875 876 local->hw.conf.listen_interval = local->hw.max_listen_interval; 877 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; 886 887 result = sta_info_start(local); 888 if (result < 0) 889 goto fail_sta_info; 890 891 rtnl_lock(); 892 result = dev_alloc_name(local->mdev, local->mdev->name); 893 if (result < 0) 894 goto fail_dev; 895 896 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 897 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy)); 898 899 result = register_netdevice(local->mdev); 900 if (result < 0) 901 goto fail_dev; 902 903 result = ieee80211_init_rate_ctrl_alg(local, 904 hw->rate_control_algorithm); 905 if (result < 0) { 906 printk(KERN_DEBUG "%s: Failed to initialize rate control " 907 "algorithm\n", wiphy_name(local->hw.wiphy)); 908 goto fail_rate; 909 } 910 911 result = ieee80211_wep_init(local); 912 913 if (result < 0) { 914 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 915 wiphy_name(local->hw.wiphy), result); 916 goto fail_wep; 917 } 918 919 local->mdev->select_queue = ieee80211_select_queue; 920 921 /* add one default STA interface */ 922 result = ieee80211_if_add(local, "wlan%d", NULL, 923 NL80211_IFTYPE_STATION, NULL); 924 if (result) 925 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 926 wiphy_name(local->hw.wiphy)); 927 928 rtnl_unlock(); 929 930 ieee80211_led_init(local); 931 932 return 0; 933 934fail_wep: 935 rate_control_deinitialize(local); 936fail_rate: 937 unregister_netdevice(local->mdev); 938 local->mdev = NULL; 939fail_dev: 940 rtnl_unlock(); 941 sta_info_stop(local); 942fail_sta_info: 943 debugfs_hw_del(local); 944 destroy_workqueue(local->hw.workqueue); 945fail_workqueue: 946 if (local->mdev) 947 free_netdev(local->mdev); 948fail_mdev_alloc: 949 wiphy_unregister(local->hw.wiphy); 950 return result; 951} 952EXPORT_SYMBOL(ieee80211_register_hw); 953 954void ieee80211_unregister_hw(struct ieee80211_hw *hw) 955{ 956 struct ieee80211_local *local = hw_to_local(hw); 957 958 tasklet_kill(&local->tx_pending_tasklet); 959 tasklet_kill(&local->tasklet); 960 961 rtnl_lock(); 962 963 /* 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. 967 */ 968 969 /* First, we remove all virtual interfaces. */ 970 ieee80211_remove_interfaces(local); 971 972 /* then, finally, remove the master interface */ 973 unregister_netdevice(local->mdev); 974 975 rtnl_unlock(); 976 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); 982 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); 989 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); 995} 996EXPORT_SYMBOL(ieee80211_unregister_hw); 997 998void ieee80211_free_hw(struct ieee80211_hw *hw) 999{ 1000 struct ieee80211_local *local = hw_to_local(hw); 1001 1002 wiphy_free(local->hw.wiphy); 1003} 1004EXPORT_SYMBOL(ieee80211_free_hw); 1005 1006static int __init ieee80211_init(void) 1007{ 1008 struct sk_buff *skb; 1009 int ret; 1010 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)); 1014 1015 ret = rc80211_pid_init(); 1016 if (ret) 1017 return ret; 1018 1019 ieee80211_debugfs_netdev_init(); 1020 1021 return 0; 1022} 1023 1024static void __exit ieee80211_exit(void) 1025{ 1026 rc80211_pid_exit(); 1027 1028 /* 1029 * For key todo, it'll be empty by now but the work 1030 * might still be scheduled. 1031 */ 1032 flush_scheduled_work(); 1033 1034 if (mesh_allocated) 1035 ieee80211s_stop(); 1036 1037 ieee80211_debugfs_netdev_exit(); 1038} 1039 1040 1041subsys_initcall(ieee80211_init); 1042module_exit(ieee80211_exit); 1043 1044MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1045MODULE_LICENSE("GPL"); 1046