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 */ 42 struct 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 */ 50 void 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 93 static 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 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, 105 }; 106 107 static int ieee80211_master_open(struct net_device *dev) 108 { 109 struct ieee80211_master_priv *mpriv = netdev_priv(dev); 110 struct ieee80211_local *local = mpriv->local; 111 struct ieee80211_sub_if_data *sdata; 112 int res = -EOPNOTSUPP; 113 114 /* we hold the RTNL here so can safely walk the list */ 115 list_for_each_entry(sdata, &local->interfaces, list) { 116 if (netif_running(sdata->dev)) { 117 res = 0; 118 break; 119 } 120 } 121 122 if (res) 123 return res; 124 125 netif_tx_start_all_queues(local->mdev); 126 127 return 0; 128 } 129 130 static int ieee80211_master_stop(struct net_device *dev) 131 { 132 struct ieee80211_master_priv *mpriv = netdev_priv(dev); 133 struct ieee80211_local *local = mpriv->local; 134 struct ieee80211_sub_if_data *sdata; 135 136 /* we hold the RTNL here so can safely walk the list */ 137 list_for_each_entry(sdata, &local->interfaces, list) 138 if (netif_running(sdata->dev)) 139 dev_close(sdata->dev); 140 141 return 0; 142 } 143 144 static void ieee80211_master_set_multicast_list(struct net_device *dev) 145 { 146 struct ieee80211_master_priv *mpriv = netdev_priv(dev); 147 struct ieee80211_local *local = mpriv->local; 148 149 ieee80211_configure_filter(local); 150 } 151 152 /* everything else */ 153 154 int ieee80211_if_config(struct ieee80211_sub_if_data *sdata, u32 changed) 155 { 156 struct ieee80211_local *local = sdata->local; 157 struct ieee80211_if_conf conf; 158 159 if (WARN_ON(!netif_running(sdata->dev))) 160 return 0; 161 162 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) 163 return -EINVAL; 164 165 if (!local->ops->config_interface) 166 return 0; 167 168 memset(&conf, 0, sizeof(conf)); 169 conf.changed = changed; 170 171 if (sdata->vif.type == NL80211_IFTYPE_STATION || 172 sdata->vif.type == NL80211_IFTYPE_ADHOC) { 173 conf.bssid = sdata->u.sta.bssid; 174 conf.ssid = sdata->u.sta.ssid; 175 conf.ssid_len = sdata->u.sta.ssid_len; 176 } else if (sdata->vif.type == NL80211_IFTYPE_AP) { 177 conf.bssid = sdata->dev->dev_addr; 178 conf.ssid = sdata->u.ap.ssid; 179 conf.ssid_len = sdata->u.ap.ssid_len; 180 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 181 u8 zero[ETH_ALEN] = { 0 }; 182 conf.bssid = zero; 183 conf.ssid = zero; 184 conf.ssid_len = 0; 185 } else { 186 WARN_ON(1); 187 return -EINVAL; 188 } 189 190 if (WARN_ON(!conf.bssid && (changed & IEEE80211_IFCC_BSSID))) 191 return -EINVAL; 192 193 if (WARN_ON(!conf.ssid && (changed & IEEE80211_IFCC_SSID))) 194 return -EINVAL; 195 196 return local->ops->config_interface(local_to_hw(local), 197 &sdata->vif, &conf); 198 } 199 200 int ieee80211_hw_config(struct ieee80211_local *local) 201 { 202 struct ieee80211_channel *chan; 203 int ret = 0; 204 205 if (local->sw_scanning) 206 chan = local->scan_channel; 207 else 208 chan = local->oper_channel; 209 210 local->hw.conf.channel = chan; 211 212 if (!local->hw.conf.power_level) 213 local->hw.conf.power_level = chan->max_power; 214 else 215 local->hw.conf.power_level = min(chan->max_power, 216 local->hw.conf.power_level); 217 218 local->hw.conf.max_antenna_gain = chan->max_antenna_gain; 219 220 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 221 printk(KERN_DEBUG "%s: HW CONFIG: freq=%d\n", 222 wiphy_name(local->hw.wiphy), chan->center_freq); 223 #endif 224 225 if (local->open_count) 226 ret = local->ops->config(local_to_hw(local), &local->hw.conf); 227 228 return ret; 229 } 230 231 /** 232 * ieee80211_handle_ht should be used only after legacy configuration 233 * has been determined namely band, as ht configuration depends upon 234 * the hardware's HT abilities for a _specific_ band. 235 */ 236 u32 ieee80211_handle_ht(struct ieee80211_local *local, int enable_ht, 237 struct ieee80211_ht_info *req_ht_cap, 238 struct ieee80211_ht_bss_info *req_bss_cap) 239 { 240 struct ieee80211_conf *conf = &local->hw.conf; 241 struct ieee80211_supported_band *sband; 242 struct ieee80211_ht_info ht_conf; 243 struct ieee80211_ht_bss_info ht_bss_conf; 244 u32 changed = 0; 245 int i; 246 u8 max_tx_streams = IEEE80211_HT_CAP_MAX_STREAMS; 247 u8 tx_mcs_set_cap; 248 249 sband = local->hw.wiphy->bands[conf->channel->band]; 250 251 memset(&ht_conf, 0, sizeof(struct ieee80211_ht_info)); 252 memset(&ht_bss_conf, 0, sizeof(struct ieee80211_ht_bss_info)); 253 254 /* HT is not supported */ 255 if (!sband->ht_info.ht_supported) { 256 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 257 goto out; 258 } 259 260 /* disable HT */ 261 if (!enable_ht) { 262 if (conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) 263 changed |= BSS_CHANGED_HT; 264 conf->flags &= ~IEEE80211_CONF_SUPPORT_HT_MODE; 265 conf->ht_conf.ht_supported = 0; 266 goto out; 267 } 268 269 270 if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) 271 changed |= BSS_CHANGED_HT; 272 273 conf->flags |= IEEE80211_CONF_SUPPORT_HT_MODE; 274 ht_conf.ht_supported = 1; 275 276 ht_conf.cap = req_ht_cap->cap & sband->ht_info.cap; 277 ht_conf.cap &= ~(IEEE80211_HT_CAP_SM_PS); 278 ht_conf.cap |= sband->ht_info.cap & IEEE80211_HT_CAP_SM_PS; 279 ht_bss_conf.primary_channel = req_bss_cap->primary_channel; 280 ht_bss_conf.bss_cap = req_bss_cap->bss_cap; 281 ht_bss_conf.bss_op_mode = req_bss_cap->bss_op_mode; 282 283 ht_conf.ampdu_factor = req_ht_cap->ampdu_factor; 284 ht_conf.ampdu_density = req_ht_cap->ampdu_density; 285 286 /* Bits 96-100 */ 287 tx_mcs_set_cap = sband->ht_info.supp_mcs_set[12]; 288 289 /* configure suppoerted Tx MCS according to requested MCS 290 * (based in most cases on Rx capabilities of peer) and self 291 * Tx MCS capabilities (as defined by low level driver HW 292 * Tx capabilities) */ 293 if (!(tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_DEFINED)) 294 goto check_changed; 295 296 /* Counting from 0 therfore + 1 */ 297 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_RX_DIFF) 298 max_tx_streams = ((tx_mcs_set_cap & 299 IEEE80211_HT_CAP_MCS_TX_STREAMS) >> 2) + 1; 300 301 for (i = 0; i < max_tx_streams; i++) 302 ht_conf.supp_mcs_set[i] = 303 sband->ht_info.supp_mcs_set[i] & 304 req_ht_cap->supp_mcs_set[i]; 305 306 if (tx_mcs_set_cap & IEEE80211_HT_CAP_MCS_TX_UEQM) 307 for (i = IEEE80211_SUPP_MCS_SET_UEQM; 308 i < IEEE80211_SUPP_MCS_SET_LEN; i++) 309 ht_conf.supp_mcs_set[i] = 310 sband->ht_info.supp_mcs_set[i] & 311 req_ht_cap->supp_mcs_set[i]; 312 313 check_changed: 314 /* if bss configuration changed store the new one */ 315 if (memcmp(&conf->ht_conf, &ht_conf, sizeof(ht_conf)) || 316 memcmp(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf))) { 317 changed |= BSS_CHANGED_HT; 318 memcpy(&conf->ht_conf, &ht_conf, sizeof(ht_conf)); 319 memcpy(&conf->ht_bss_conf, &ht_bss_conf, sizeof(ht_bss_conf)); 320 } 321 out: 322 return changed; 323 } 324 325 void ieee80211_bss_info_change_notify(struct ieee80211_sub_if_data *sdata, 326 u32 changed) 327 { 328 struct ieee80211_local *local = sdata->local; 329 330 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN)) 331 return; 332 333 if (!changed) 334 return; 335 336 if (local->ops->bss_info_changed) 337 local->ops->bss_info_changed(local_to_hw(local), 338 &sdata->vif, 339 &sdata->bss_conf, 340 changed); 341 } 342 343 u32 ieee80211_reset_erp_info(struct ieee80211_sub_if_data *sdata) 344 { 345 sdata->bss_conf.use_cts_prot = 0; 346 sdata->bss_conf.use_short_preamble = 0; 347 return BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE; 348 } 349 350 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw, 351 struct sk_buff *skb) 352 { 353 struct ieee80211_local *local = hw_to_local(hw); 354 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 355 int tmp; 356 357 skb->dev = local->mdev; 358 skb->pkt_type = IEEE80211_TX_STATUS_MSG; 359 skb_queue_tail(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS ? 360 &local->skb_queue : &local->skb_queue_unreliable, skb); 361 tmp = skb_queue_len(&local->skb_queue) + 362 skb_queue_len(&local->skb_queue_unreliable); 363 while (tmp > IEEE80211_IRQSAFE_QUEUE_LIMIT && 364 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 365 dev_kfree_skb_irq(skb); 366 tmp--; 367 I802_DEBUG_INC(local->tx_status_drop); 368 } 369 tasklet_schedule(&local->tasklet); 370 } 371 EXPORT_SYMBOL(ieee80211_tx_status_irqsafe); 372 373 static void ieee80211_tasklet_handler(unsigned long data) 374 { 375 struct ieee80211_local *local = (struct ieee80211_local *) data; 376 struct sk_buff *skb; 377 struct ieee80211_rx_status rx_status; 378 struct ieee80211_ra_tid *ra_tid; 379 380 while ((skb = skb_dequeue(&local->skb_queue)) || 381 (skb = skb_dequeue(&local->skb_queue_unreliable))) { 382 switch (skb->pkt_type) { 383 case IEEE80211_RX_MSG: 384 /* status is in skb->cb */ 385 memcpy(&rx_status, skb->cb, sizeof(rx_status)); 386 /* Clear skb->pkt_type in order to not confuse kernel 387 * netstack. */ 388 skb->pkt_type = 0; 389 __ieee80211_rx(local_to_hw(local), skb, &rx_status); 390 break; 391 case IEEE80211_TX_STATUS_MSG: 392 skb->pkt_type = 0; 393 ieee80211_tx_status(local_to_hw(local), skb); 394 break; 395 case IEEE80211_DELBA_MSG: 396 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 397 ieee80211_stop_tx_ba_cb(local_to_hw(local), 398 ra_tid->ra, ra_tid->tid); 399 dev_kfree_skb(skb); 400 break; 401 case IEEE80211_ADDBA_MSG: 402 ra_tid = (struct ieee80211_ra_tid *) &skb->cb; 403 ieee80211_start_tx_ba_cb(local_to_hw(local), 404 ra_tid->ra, ra_tid->tid); 405 dev_kfree_skb(skb); 406 break ; 407 default: 408 WARN_ON(1); 409 dev_kfree_skb(skb); 410 break; 411 } 412 } 413 } 414 415 /* Remove added headers (e.g., QoS control), encryption header/MIC, etc. to 416 * make a prepared TX frame (one that has been given to hw) to look like brand 417 * new IEEE 802.11 frame that is ready to go through TX processing again. 418 */ 419 static void ieee80211_remove_tx_extra(struct ieee80211_local *local, 420 struct ieee80211_key *key, 421 struct sk_buff *skb) 422 { 423 unsigned int hdrlen, iv_len, mic_len; 424 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 425 426 hdrlen = ieee80211_hdrlen(hdr->frame_control); 427 428 if (!key) 429 goto no_key; 430 431 switch (key->conf.alg) { 432 case ALG_WEP: 433 iv_len = WEP_IV_LEN; 434 mic_len = WEP_ICV_LEN; 435 break; 436 case ALG_TKIP: 437 iv_len = TKIP_IV_LEN; 438 mic_len = TKIP_ICV_LEN; 439 break; 440 case ALG_CCMP: 441 iv_len = CCMP_HDR_LEN; 442 mic_len = CCMP_MIC_LEN; 443 break; 444 default: 445 goto no_key; 446 } 447 448 if (skb->len >= hdrlen + mic_len && 449 !(key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)) 450 skb_trim(skb, skb->len - mic_len); 451 if (skb->len >= hdrlen + iv_len) { 452 memmove(skb->data + iv_len, skb->data, hdrlen); 453 hdr = (struct ieee80211_hdr *)skb_pull(skb, iv_len); 454 } 455 456 no_key: 457 if (ieee80211_is_data_qos(hdr->frame_control)) { 458 hdr->frame_control &= ~cpu_to_le16(IEEE80211_STYPE_QOS_DATA); 459 memmove(skb->data + IEEE80211_QOS_CTL_LEN, skb->data, 460 hdrlen - IEEE80211_QOS_CTL_LEN); 461 skb_pull(skb, IEEE80211_QOS_CTL_LEN); 462 } 463 } 464 465 static void ieee80211_handle_filtered_frame(struct ieee80211_local *local, 466 struct sta_info *sta, 467 struct sk_buff *skb) 468 { 469 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 470 471 sta->tx_filtered_count++; 472 473 /* 474 * Clear the TX filter mask for this STA when sending the next 475 * packet. If the STA went to power save mode, this will happen 476 * when it wakes up for the next time. 477 */ 478 set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT); 479 480 /* 481 * This code races in the following way: 482 * 483 * (1) STA sends frame indicating it will go to sleep and does so 484 * (2) hardware/firmware adds STA to filter list, passes frame up 485 * (3) hardware/firmware processes TX fifo and suppresses a frame 486 * (4) we get TX status before having processed the frame and 487 * knowing that the STA has gone to sleep. 488 * 489 * This is actually quite unlikely even when both those events are 490 * processed from interrupts coming in quickly after one another or 491 * even at the same time because we queue both TX status events and 492 * RX frames to be processed by a tasklet and process them in the 493 * same order that they were received or TX status last. Hence, there 494 * is no race as long as the frame RX is processed before the next TX 495 * status, which drivers can ensure, see below. 496 * 497 * Note that this can only happen if the hardware or firmware can 498 * actually add STAs to the filter list, if this is done by the 499 * driver in response to set_tim() (which will only reduce the race 500 * this whole filtering tries to solve, not completely solve it) 501 * this situation cannot happen. 502 * 503 * To completely solve this race drivers need to make sure that they 504 * (a) don't mix the irq-safe/not irq-safe TX status/RX processing 505 * functions and 506 * (b) always process RX events before TX status events if ordering 507 * can be unknown, for example with different interrupt status 508 * bits. 509 */ 510 if (test_sta_flags(sta, WLAN_STA_PS) && 511 skb_queue_len(&sta->tx_filtered) < STA_MAX_TX_BUFFER) { 512 ieee80211_remove_tx_extra(local, sta->key, skb); 513 skb_queue_tail(&sta->tx_filtered, skb); 514 return; 515 } 516 517 if (!test_sta_flags(sta, WLAN_STA_PS) && 518 !(info->flags & IEEE80211_TX_CTL_REQUEUE)) { 519 /* Software retry the packet once */ 520 info->flags |= IEEE80211_TX_CTL_REQUEUE; 521 ieee80211_remove_tx_extra(local, sta->key, skb); 522 dev_queue_xmit(skb); 523 return; 524 } 525 526 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG 527 if (net_ratelimit()) 528 printk(KERN_DEBUG "%s: dropped TX filtered frame, " 529 "queue_len=%d PS=%d @%lu\n", 530 wiphy_name(local->hw.wiphy), 531 skb_queue_len(&sta->tx_filtered), 532 !!test_sta_flags(sta, WLAN_STA_PS), jiffies); 533 #endif 534 dev_kfree_skb(skb); 535 } 536 537 void ieee80211_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb) 538 { 539 struct sk_buff *skb2; 540 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; 541 struct ieee80211_local *local = hw_to_local(hw); 542 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 543 u16 frag, type; 544 __le16 fc; 545 struct ieee80211_supported_band *sband; 546 struct ieee80211_tx_status_rtap_hdr *rthdr; 547 struct ieee80211_sub_if_data *sdata; 548 struct net_device *prev_dev = NULL; 549 struct sta_info *sta; 550 551 rcu_read_lock(); 552 553 sta = sta_info_get(local, hdr->addr1); 554 555 if (sta) { 556 if (info->status.excessive_retries && 557 test_sta_flags(sta, WLAN_STA_PS)) { 558 /* 559 * The STA is in power save mode, so assume 560 * that this TX packet failed because of that. 561 */ 562 ieee80211_handle_filtered_frame(local, sta, skb); 563 rcu_read_unlock(); 564 return; 565 } 566 567 fc = hdr->frame_control; 568 569 if ((info->flags & IEEE80211_TX_STAT_AMPDU_NO_BACK) && 570 (ieee80211_is_data_qos(fc))) { 571 u16 tid, ssn; 572 u8 *qc; 573 574 qc = ieee80211_get_qos_ctl(hdr); 575 tid = qc[0] & 0xf; 576 ssn = ((le16_to_cpu(hdr->seq_ctrl) + 0x10) 577 & IEEE80211_SCTL_SEQ); 578 ieee80211_send_bar(sta->sdata, hdr->addr1, 579 tid, ssn); 580 } 581 582 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) { 583 ieee80211_handle_filtered_frame(local, sta, skb); 584 rcu_read_unlock(); 585 return; 586 } else { 587 if (info->status.excessive_retries) 588 sta->tx_retry_failed++; 589 sta->tx_retry_count += info->status.retry_count; 590 } 591 592 sband = local->hw.wiphy->bands[info->band]; 593 rate_control_tx_status(local, sband, sta, skb); 594 } 595 596 rcu_read_unlock(); 597 598 ieee80211_led_tx(local, 0); 599 600 /* SNMP counters 601 * Fragments are passed to low-level drivers as separate skbs, so these 602 * are actually fragments, not frames. Update frame counters only for 603 * the first fragment of the frame. */ 604 605 frag = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG; 606 type = le16_to_cpu(hdr->frame_control) & IEEE80211_FCTL_FTYPE; 607 608 if (info->flags & IEEE80211_TX_STAT_ACK) { 609 if (frag == 0) { 610 local->dot11TransmittedFrameCount++; 611 if (is_multicast_ether_addr(hdr->addr1)) 612 local->dot11MulticastTransmittedFrameCount++; 613 if (info->status.retry_count > 0) 614 local->dot11RetryCount++; 615 if (info->status.retry_count > 1) 616 local->dot11MultipleRetryCount++; 617 } 618 619 /* This counter shall be incremented for an acknowledged MPDU 620 * with an individual address in the address 1 field or an MPDU 621 * with a multicast address in the address 1 field of type Data 622 * or Management. */ 623 if (!is_multicast_ether_addr(hdr->addr1) || 624 type == IEEE80211_FTYPE_DATA || 625 type == IEEE80211_FTYPE_MGMT) 626 local->dot11TransmittedFragmentCount++; 627 } else { 628 if (frag == 0) 629 local->dot11FailedCount++; 630 } 631 632 /* this was a transmitted frame, but now we want to reuse it */ 633 skb_orphan(skb); 634 635 /* 636 * This is a bit racy but we can avoid a lot of work 637 * with this test... 638 */ 639 if (!local->monitors && !local->cooked_mntrs) { 640 dev_kfree_skb(skb); 641 return; 642 } 643 644 /* send frame to monitor interfaces now */ 645 646 if (skb_headroom(skb) < sizeof(*rthdr)) { 647 printk(KERN_ERR "ieee80211_tx_status: headroom too small\n"); 648 dev_kfree_skb(skb); 649 return; 650 } 651 652 rthdr = (struct ieee80211_tx_status_rtap_hdr *) 653 skb_push(skb, sizeof(*rthdr)); 654 655 memset(rthdr, 0, sizeof(*rthdr)); 656 rthdr->hdr.it_len = cpu_to_le16(sizeof(*rthdr)); 657 rthdr->hdr.it_present = 658 cpu_to_le32((1 << IEEE80211_RADIOTAP_TX_FLAGS) | 659 (1 << IEEE80211_RADIOTAP_DATA_RETRIES)); 660 661 if (!(info->flags & IEEE80211_TX_STAT_ACK) && 662 !is_multicast_ether_addr(hdr->addr1)) 663 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_FAIL); 664 665 if ((info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) && 666 (info->flags & IEEE80211_TX_CTL_USE_CTS_PROTECT)) 667 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_CTS); 668 else if (info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) 669 rthdr->tx_flags |= cpu_to_le16(IEEE80211_RADIOTAP_F_TX_RTS); 670 671 rthdr->data_retries = info->status.retry_count; 672 673 /* XXX: is this sufficient for BPF? */ 674 skb_set_mac_header(skb, 0); 675 skb->ip_summed = CHECKSUM_UNNECESSARY; 676 skb->pkt_type = PACKET_OTHERHOST; 677 skb->protocol = htons(ETH_P_802_2); 678 memset(skb->cb, 0, sizeof(skb->cb)); 679 680 rcu_read_lock(); 681 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 682 if (sdata->vif.type == NL80211_IFTYPE_MONITOR) { 683 if (!netif_running(sdata->dev)) 684 continue; 685 686 if (prev_dev) { 687 skb2 = skb_clone(skb, GFP_ATOMIC); 688 if (skb2) { 689 skb2->dev = prev_dev; 690 netif_rx(skb2); 691 } 692 } 693 694 prev_dev = sdata->dev; 695 } 696 } 697 if (prev_dev) { 698 skb->dev = prev_dev; 699 netif_rx(skb); 700 skb = NULL; 701 } 702 rcu_read_unlock(); 703 dev_kfree_skb(skb); 704 } 705 EXPORT_SYMBOL(ieee80211_tx_status); 706 707 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len, 708 const struct ieee80211_ops *ops) 709 { 710 struct ieee80211_local *local; 711 int priv_size; 712 struct wiphy *wiphy; 713 714 /* Ensure 32-byte alignment of our private data and hw private data. 715 * We use the wiphy priv data for both our ieee80211_local and for 716 * the driver's private data 717 * 718 * In memory it'll be like this: 719 * 720 * +-------------------------+ 721 * | struct wiphy | 722 * +-------------------------+ 723 * | struct ieee80211_local | 724 * +-------------------------+ 725 * | driver's private data | 726 * +-------------------------+ 727 * 728 */ 729 priv_size = ((sizeof(struct ieee80211_local) + 730 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST) + 731 priv_data_len; 732 733 wiphy = wiphy_new(&mac80211_config_ops, priv_size); 734 735 if (!wiphy) 736 return NULL; 737 738 wiphy->privid = mac80211_wiphy_privid; 739 740 local = wiphy_priv(wiphy); 741 local->hw.wiphy = wiphy; 742 743 local->hw.priv = (char *)local + 744 ((sizeof(struct ieee80211_local) + 745 NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST); 746 747 BUG_ON(!ops->tx); 748 BUG_ON(!ops->start); 749 BUG_ON(!ops->stop); 750 BUG_ON(!ops->config); 751 BUG_ON(!ops->add_interface); 752 BUG_ON(!ops->remove_interface); 753 BUG_ON(!ops->configure_filter); 754 local->ops = ops; 755 756 local->hw.queues = 1; /* default */ 757 758 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; 759 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 760 local->short_retry_limit = 7; 761 local->long_retry_limit = 4; 762 local->hw.conf.radio_enabled = 1; 763 764 INIT_LIST_HEAD(&local->interfaces); 765 766 spin_lock_init(&local->key_lock); 767 768 INIT_DELAYED_WORK(&local->scan_work, ieee80211_scan_work); 769 770 sta_info_init(local); 771 772 tasklet_init(&local->tx_pending_tasklet, ieee80211_tx_pending, 773 (unsigned long)local); 774 tasklet_disable(&local->tx_pending_tasklet); 775 776 tasklet_init(&local->tasklet, 777 ieee80211_tasklet_handler, 778 (unsigned long) local); 779 tasklet_disable(&local->tasklet); 780 781 skb_queue_head_init(&local->skb_queue); 782 skb_queue_head_init(&local->skb_queue_unreliable); 783 784 return local_to_hw(local); 785 } 786 EXPORT_SYMBOL(ieee80211_alloc_hw); 787 788 int ieee80211_register_hw(struct ieee80211_hw *hw) 789 { 790 struct ieee80211_local *local = hw_to_local(hw); 791 const char *name; 792 int result; 793 enum ieee80211_band band; 794 struct net_device *mdev; 795 struct ieee80211_master_priv *mpriv; 796 797 /* 798 * generic code guarantees at least one band, 799 * set this very early because much code assumes 800 * that hw.conf.channel is assigned 801 */ 802 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 803 struct ieee80211_supported_band *sband; 804 805 sband = local->hw.wiphy->bands[band]; 806 if (sband) { 807 /* init channel we're on */ 808 local->hw.conf.channel = 809 local->oper_channel = 810 local->scan_channel = &sband->channels[0]; 811 break; 812 } 813 } 814 815 /* if low-level driver supports AP, we also support VLAN */ 816 if (local->hw.wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) 817 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN); 818 819 /* mac80211 always supports monitor */ 820 local->hw.wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 821 822 result = wiphy_register(local->hw.wiphy); 823 if (result < 0) 824 return result; 825 826 /* 827 * We use the number of queues for feature tests (QoS, HT) internally 828 * so restrict them appropriately. 829 */ 830 if (hw->queues > IEEE80211_MAX_QUEUES) 831 hw->queues = IEEE80211_MAX_QUEUES; 832 if (hw->ampdu_queues > IEEE80211_MAX_AMPDU_QUEUES) 833 hw->ampdu_queues = IEEE80211_MAX_AMPDU_QUEUES; 834 if (hw->queues < 4) 835 hw->ampdu_queues = 0; 836 837 mdev = alloc_netdev_mq(sizeof(struct ieee80211_master_priv), 838 "wmaster%d", ether_setup, 839 ieee80211_num_queues(hw)); 840 if (!mdev) 841 goto fail_mdev_alloc; 842 843 mpriv = netdev_priv(mdev); 844 mpriv->local = local; 845 local->mdev = mdev; 846 847 ieee80211_rx_bss_list_init(local); 848 849 mdev->hard_start_xmit = ieee80211_master_start_xmit; 850 mdev->open = ieee80211_master_open; 851 mdev->stop = ieee80211_master_stop; 852 mdev->type = ARPHRD_IEEE80211; 853 mdev->header_ops = &ieee80211_header_ops; 854 mdev->set_multicast_list = ieee80211_master_set_multicast_list; 855 856 name = wiphy_dev(local->hw.wiphy)->driver->name; 857 local->hw.workqueue = create_freezeable_workqueue(name); 858 if (!local->hw.workqueue) { 859 result = -ENOMEM; 860 goto fail_workqueue; 861 } 862 863 /* 864 * The hardware needs headroom for sending the frame, 865 * and we need some headroom for passing the frame to monitor 866 * interfaces, but never both at the same time. 867 */ 868 local->tx_headroom = max_t(unsigned int , local->hw.extra_tx_headroom, 869 sizeof(struct ieee80211_tx_status_rtap_hdr)); 870 871 debugfs_hw_add(local); 872 873 if (local->hw.conf.beacon_int < 10) 874 local->hw.conf.beacon_int = 100; 875 876 if (local->hw.max_listen_interval == 0) 877 local->hw.max_listen_interval = 1; 878 879 local->hw.conf.listen_interval = local->hw.max_listen_interval; 880 881 local->wstats_flags |= local->hw.flags & (IEEE80211_HW_SIGNAL_UNSPEC | 882 IEEE80211_HW_SIGNAL_DB | 883 IEEE80211_HW_SIGNAL_DBM) ? 884 IW_QUAL_QUAL_UPDATED : IW_QUAL_QUAL_INVALID; 885 local->wstats_flags |= local->hw.flags & IEEE80211_HW_NOISE_DBM ? 886 IW_QUAL_NOISE_UPDATED : IW_QUAL_NOISE_INVALID; 887 if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM) 888 local->wstats_flags |= IW_QUAL_DBM; 889 890 result = sta_info_start(local); 891 if (result < 0) 892 goto fail_sta_info; 893 894 rtnl_lock(); 895 result = dev_alloc_name(local->mdev, local->mdev->name); 896 if (result < 0) 897 goto fail_dev; 898 899 memcpy(local->mdev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN); 900 SET_NETDEV_DEV(local->mdev, wiphy_dev(local->hw.wiphy)); 901 902 result = register_netdevice(local->mdev); 903 if (result < 0) 904 goto fail_dev; 905 906 result = ieee80211_init_rate_ctrl_alg(local, 907 hw->rate_control_algorithm); 908 if (result < 0) { 909 printk(KERN_DEBUG "%s: Failed to initialize rate control " 910 "algorithm\n", wiphy_name(local->hw.wiphy)); 911 goto fail_rate; 912 } 913 914 result = ieee80211_wep_init(local); 915 916 if (result < 0) { 917 printk(KERN_DEBUG "%s: Failed to initialize wep: %d\n", 918 wiphy_name(local->hw.wiphy), result); 919 goto fail_wep; 920 } 921 922 local->mdev->select_queue = ieee80211_select_queue; 923 924 /* add one default STA interface */ 925 result = ieee80211_if_add(local, "wlan%d", NULL, 926 NL80211_IFTYPE_STATION, NULL); 927 if (result) 928 printk(KERN_WARNING "%s: Failed to add default virtual iface\n", 929 wiphy_name(local->hw.wiphy)); 930 931 rtnl_unlock(); 932 933 ieee80211_led_init(local); 934 935 return 0; 936 937 fail_wep: 938 rate_control_deinitialize(local); 939 fail_rate: 940 unregister_netdevice(local->mdev); 941 local->mdev = NULL; 942 fail_dev: 943 rtnl_unlock(); 944 sta_info_stop(local); 945 fail_sta_info: 946 debugfs_hw_del(local); 947 destroy_workqueue(local->hw.workqueue); 948 fail_workqueue: 949 if (local->mdev) 950 free_netdev(local->mdev); 951 fail_mdev_alloc: 952 wiphy_unregister(local->hw.wiphy); 953 return result; 954 } 955 EXPORT_SYMBOL(ieee80211_register_hw); 956 957 void ieee80211_unregister_hw(struct ieee80211_hw *hw) 958 { 959 struct ieee80211_local *local = hw_to_local(hw); 960 961 tasklet_kill(&local->tx_pending_tasklet); 962 tasklet_kill(&local->tasklet); 963 964 rtnl_lock(); 965 966 /* 967 * At this point, interface list manipulations are fine 968 * because the driver cannot be handing us frames any 969 * more and the tasklet is killed. 970 */ 971 972 /* First, we remove all virtual interfaces. */ 973 ieee80211_remove_interfaces(local); 974 975 /* then, finally, remove the master interface */ 976 unregister_netdevice(local->mdev); 977 978 rtnl_unlock(); 979 980 ieee80211_rx_bss_list_deinit(local); 981 ieee80211_clear_tx_pending(local); 982 sta_info_stop(local); 983 rate_control_deinitialize(local); 984 debugfs_hw_del(local); 985 986 if (skb_queue_len(&local->skb_queue) 987 || skb_queue_len(&local->skb_queue_unreliable)) 988 printk(KERN_WARNING "%s: skb_queue not empty\n", 989 wiphy_name(local->hw.wiphy)); 990 skb_queue_purge(&local->skb_queue); 991 skb_queue_purge(&local->skb_queue_unreliable); 992 993 destroy_workqueue(local->hw.workqueue); 994 wiphy_unregister(local->hw.wiphy); 995 ieee80211_wep_free(local); 996 ieee80211_led_exit(local); 997 free_netdev(local->mdev); 998 } 999 EXPORT_SYMBOL(ieee80211_unregister_hw); 1000 1001 void ieee80211_free_hw(struct ieee80211_hw *hw) 1002 { 1003 struct ieee80211_local *local = hw_to_local(hw); 1004 1005 wiphy_free(local->hw.wiphy); 1006 } 1007 EXPORT_SYMBOL(ieee80211_free_hw); 1008 1009 static int __init ieee80211_init(void) 1010 { 1011 struct sk_buff *skb; 1012 int ret; 1013 1014 BUILD_BUG_ON(sizeof(struct ieee80211_tx_info) > sizeof(skb->cb)); 1015 BUILD_BUG_ON(offsetof(struct ieee80211_tx_info, driver_data) + 1016 IEEE80211_TX_INFO_DRIVER_DATA_SIZE > sizeof(skb->cb)); 1017 1018 ret = rc80211_minstrel_init(); 1019 if (ret) 1020 return ret; 1021 1022 ret = rc80211_pid_init(); 1023 if (ret) 1024 return ret; 1025 1026 ieee80211_debugfs_netdev_init(); 1027 1028 return 0; 1029 } 1030 1031 static void __exit ieee80211_exit(void) 1032 { 1033 rc80211_pid_exit(); 1034 rc80211_minstrel_exit(); 1035 1036 /* 1037 * For key todo, it'll be empty by now but the work 1038 * might still be scheduled. 1039 */ 1040 flush_scheduled_work(); 1041 1042 if (mesh_allocated) 1043 ieee80211s_stop(); 1044 1045 ieee80211_debugfs_netdev_exit(); 1046 } 1047 1048 1049 subsys_initcall(ieee80211_init); 1050 module_exit(ieee80211_exit); 1051 1052 MODULE_DESCRIPTION("IEEE 802.11 subsystem"); 1053 MODULE_LICENSE("GPL"); 1054