1/* 2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> 3 <http://rt2x00.serialmonkey.com> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the 17 Free Software Foundation, Inc., 18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 19 */ 20 21/* 22 Module: rt2x00mac 23 Abstract: rt2x00 generic mac80211 routines. 24 */ 25 26#include <linux/kernel.h> 27#include <linux/module.h> 28 29#include "rt2x00.h" 30#include "rt2x00lib.h" 31 32static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev, 33 struct data_queue *queue, 34 struct sk_buff *frag_skb) 35{ 36 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(frag_skb); 37 struct ieee80211_tx_info *rts_info; 38 struct sk_buff *skb; 39 unsigned int data_length; 40 int retval = 0; 41 42 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) 43 data_length = sizeof(struct ieee80211_cts); 44 else 45 data_length = sizeof(struct ieee80211_rts); 46 47 skb = dev_alloc_skb(data_length + rt2x00dev->hw->extra_tx_headroom); 48 if (unlikely(!skb)) { 49 WARNING(rt2x00dev, "Failed to create RTS/CTS frame.\n"); 50 return -ENOMEM; 51 } 52 53 skb_reserve(skb, rt2x00dev->hw->extra_tx_headroom); 54 skb_put(skb, data_length); 55 56 /* 57 * Copy TX information over from original frame to 58 * RTS/CTS frame. Note that we set the no encryption flag 59 * since we don't want this frame to be encrypted. 60 * RTS frames should be acked, while CTS-to-self frames 61 * should not. The ready for TX flag is cleared to prevent 62 * it being automatically send when the descriptor is 63 * written to the hardware. 64 */ 65 memcpy(skb->cb, frag_skb->cb, sizeof(skb->cb)); 66 rts_info = IEEE80211_SKB_CB(skb); 67 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_RTS_CTS; 68 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_CTS_PROTECT; 69 70 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) 71 rts_info->flags |= IEEE80211_TX_CTL_NO_ACK; 72 else 73 rts_info->flags &= ~IEEE80211_TX_CTL_NO_ACK; 74 75 /* Disable hardware encryption */ 76 rts_info->control.hw_key = NULL; 77 78 /* 79 * RTS/CTS frame should use the length of the frame plus any 80 * encryption overhead that will be added by the hardware. 81 */ 82 data_length += rt2x00crypto_tx_overhead(rt2x00dev, skb); 83 84 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) 85 ieee80211_ctstoself_get(rt2x00dev->hw, tx_info->control.vif, 86 frag_skb->data, data_length, tx_info, 87 (struct ieee80211_cts *)(skb->data)); 88 else 89 ieee80211_rts_get(rt2x00dev->hw, tx_info->control.vif, 90 frag_skb->data, data_length, tx_info, 91 (struct ieee80211_rts *)(skb->data)); 92 93 retval = rt2x00queue_write_tx_frame(queue, skb, true); 94 if (retval) { 95 dev_kfree_skb_any(skb); 96 WARNING(rt2x00dev, "Failed to send RTS/CTS frame.\n"); 97 } 98 99 return retval; 100} 101 102void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb) 103{ 104 struct rt2x00_dev *rt2x00dev = hw->priv; 105 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 106 enum data_queue_qid qid = skb_get_queue_mapping(skb); 107 struct data_queue *queue = NULL; 108 109 /* 110 * Mac80211 might be calling this function while we are trying 111 * to remove the device or perhaps suspending it. 112 * Note that we can only stop the TX queues inside the TX path 113 * due to possible race conditions in mac80211. 114 */ 115 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 116 goto exit_free_skb; 117 118 /* 119 * Use the ATIM queue if appropriate and present. 120 */ 121 if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM && 122 test_bit(REQUIRE_ATIM_QUEUE, &rt2x00dev->cap_flags)) 123 qid = QID_ATIM; 124 125 queue = rt2x00queue_get_tx_queue(rt2x00dev, qid); 126 if (unlikely(!queue)) { 127 ERROR(rt2x00dev, 128 "Attempt to send packet over invalid queue %d.\n" 129 "Please file bug report to %s.\n", qid, DRV_PROJECT); 130 goto exit_free_skb; 131 } 132 133 /* 134 * If CTS/RTS is required. create and queue that frame first. 135 * Make sure we have at least enough entries available to send 136 * this CTS/RTS frame as well as the data frame. 137 * Note that when the driver has set the set_rts_threshold() 138 * callback function it doesn't need software generation of 139 * either RTS or CTS-to-self frame and handles everything 140 * inside the hardware. 141 */ 142 if (!rt2x00dev->ops->hw->set_rts_threshold && 143 (tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS | 144 IEEE80211_TX_RC_USE_CTS_PROTECT))) { 145 if (rt2x00queue_available(queue) <= 1) 146 goto exit_fail; 147 148 if (rt2x00mac_tx_rts_cts(rt2x00dev, queue, skb)) 149 goto exit_fail; 150 } 151 152 if (unlikely(rt2x00queue_write_tx_frame(queue, skb, false))) 153 goto exit_fail; 154 155 /* 156 * Pausing queue has to be serialized with rt2x00lib_txdone(). Note 157 * we should not use spin_lock_bh variant as bottom halve was already 158 * disabled before ieee80211_xmit() call. 159 */ 160 spin_lock(&queue->tx_lock); 161 if (rt2x00queue_threshold(queue)) 162 rt2x00queue_pause_queue(queue); 163 spin_unlock(&queue->tx_lock); 164 165 return; 166 167 exit_fail: 168 spin_lock(&queue->tx_lock); 169 rt2x00queue_pause_queue(queue); 170 spin_unlock(&queue->tx_lock); 171 exit_free_skb: 172 ieee80211_free_txskb(hw, skb); 173} 174EXPORT_SYMBOL_GPL(rt2x00mac_tx); 175 176int rt2x00mac_start(struct ieee80211_hw *hw) 177{ 178 struct rt2x00_dev *rt2x00dev = hw->priv; 179 180 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 181 return 0; 182 183 return rt2x00lib_start(rt2x00dev); 184} 185EXPORT_SYMBOL_GPL(rt2x00mac_start); 186 187void rt2x00mac_stop(struct ieee80211_hw *hw) 188{ 189 struct rt2x00_dev *rt2x00dev = hw->priv; 190 191 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 192 return; 193 194 rt2x00lib_stop(rt2x00dev); 195} 196EXPORT_SYMBOL_GPL(rt2x00mac_stop); 197 198int rt2x00mac_add_interface(struct ieee80211_hw *hw, 199 struct ieee80211_vif *vif) 200{ 201 struct rt2x00_dev *rt2x00dev = hw->priv; 202 struct rt2x00_intf *intf = vif_to_intf(vif); 203 struct data_queue *queue = rt2x00dev->bcn; 204 struct queue_entry *entry = NULL; 205 unsigned int i; 206 207 /* 208 * Don't allow interfaces to be added 209 * the device has disappeared. 210 */ 211 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || 212 !test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags)) 213 return -ENODEV; 214 215 switch (vif->type) { 216 case NL80211_IFTYPE_AP: 217 /* 218 * We don't support mixed combinations of 219 * sta and ap interfaces. 220 */ 221 if (rt2x00dev->intf_sta_count) 222 return -ENOBUFS; 223 224 /* 225 * Check if we exceeded the maximum amount 226 * of supported interfaces. 227 */ 228 if (rt2x00dev->intf_ap_count >= rt2x00dev->ops->max_ap_intf) 229 return -ENOBUFS; 230 231 break; 232 case NL80211_IFTYPE_STATION: 233 case NL80211_IFTYPE_ADHOC: 234 case NL80211_IFTYPE_MESH_POINT: 235 case NL80211_IFTYPE_WDS: 236 /* 237 * We don't support mixed combinations of 238 * sta and ap interfaces. 239 */ 240 if (rt2x00dev->intf_ap_count) 241 return -ENOBUFS; 242 243 /* 244 * Check if we exceeded the maximum amount 245 * of supported interfaces. 246 */ 247 if (rt2x00dev->intf_sta_count >= rt2x00dev->ops->max_sta_intf) 248 return -ENOBUFS; 249 250 break; 251 default: 252 return -EINVAL; 253 } 254 255 /* 256 * Loop through all beacon queues to find a free 257 * entry. Since there are as much beacon entries 258 * as the maximum interfaces, this search shouldn't 259 * fail. 260 */ 261 for (i = 0; i < queue->limit; i++) { 262 entry = &queue->entries[i]; 263 if (!test_and_set_bit(ENTRY_BCN_ASSIGNED, &entry->flags)) 264 break; 265 } 266 267 if (unlikely(i == queue->limit)) 268 return -ENOBUFS; 269 270 /* 271 * We are now absolutely sure the interface can be created, 272 * increase interface count and start initialization. 273 */ 274 275 if (vif->type == NL80211_IFTYPE_AP) 276 rt2x00dev->intf_ap_count++; 277 else 278 rt2x00dev->intf_sta_count++; 279 280 mutex_init(&intf->beacon_skb_mutex); 281 intf->beacon = entry; 282 283 /* 284 * The MAC address must be configured after the device 285 * has been initialized. Otherwise the device can reset 286 * the MAC registers. 287 * The BSSID address must only be configured in AP mode, 288 * however we should not send an empty BSSID address for 289 * STA interfaces at this time, since this can cause 290 * invalid behavior in the device. 291 */ 292 rt2x00lib_config_intf(rt2x00dev, intf, vif->type, 293 vif->addr, NULL); 294 295 /* 296 * Some filters depend on the current working mode. We can force 297 * an update during the next configure_filter() run by mac80211 by 298 * resetting the current packet_filter state. 299 */ 300 rt2x00dev->packet_filter = 0; 301 302 return 0; 303} 304EXPORT_SYMBOL_GPL(rt2x00mac_add_interface); 305 306void rt2x00mac_remove_interface(struct ieee80211_hw *hw, 307 struct ieee80211_vif *vif) 308{ 309 struct rt2x00_dev *rt2x00dev = hw->priv; 310 struct rt2x00_intf *intf = vif_to_intf(vif); 311 312 /* 313 * Don't allow interfaces to be remove while 314 * either the device has disappeared or when 315 * no interface is present. 316 */ 317 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || 318 (vif->type == NL80211_IFTYPE_AP && !rt2x00dev->intf_ap_count) || 319 (vif->type != NL80211_IFTYPE_AP && !rt2x00dev->intf_sta_count)) 320 return; 321 322 if (vif->type == NL80211_IFTYPE_AP) 323 rt2x00dev->intf_ap_count--; 324 else 325 rt2x00dev->intf_sta_count--; 326 327 /* 328 * Release beacon entry so it is available for 329 * new interfaces again. 330 */ 331 clear_bit(ENTRY_BCN_ASSIGNED, &intf->beacon->flags); 332 333 /* 334 * Make sure the bssid and mac address registers 335 * are cleared to prevent false ACKing of frames. 336 */ 337 rt2x00lib_config_intf(rt2x00dev, intf, 338 NL80211_IFTYPE_UNSPECIFIED, NULL, NULL); 339} 340EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface); 341 342int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed) 343{ 344 struct rt2x00_dev *rt2x00dev = hw->priv; 345 struct ieee80211_conf *conf = &hw->conf; 346 347 /* 348 * mac80211 might be calling this function while we are trying 349 * to remove the device or perhaps suspending it. 350 */ 351 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 352 return 0; 353 354 /* 355 * Some configuration parameters (e.g. channel and antenna values) can 356 * only be set when the radio is enabled, but do require the RX to 357 * be off. During this period we should keep link tuning enabled, 358 * if for any reason the link tuner must be reset, this will be 359 * handled by rt2x00lib_config(). 360 */ 361 rt2x00queue_stop_queue(rt2x00dev->rx); 362 363 /* 364 * When we've just turned on the radio, we want to reprogram 365 * everything to ensure a consistent state 366 */ 367 rt2x00lib_config(rt2x00dev, conf, changed); 368 369 /* 370 * After the radio has been enabled we need to configure 371 * the antenna to the default settings. rt2x00lib_config_antenna() 372 * should determine if any action should be taken based on 373 * checking if diversity has been enabled or no antenna changes 374 * have been made since the last configuration change. 375 */ 376 rt2x00lib_config_antenna(rt2x00dev, rt2x00dev->default_ant); 377 378 /* Turn RX back on */ 379 rt2x00queue_start_queue(rt2x00dev->rx); 380 381 return 0; 382} 383EXPORT_SYMBOL_GPL(rt2x00mac_config); 384 385void rt2x00mac_configure_filter(struct ieee80211_hw *hw, 386 unsigned int changed_flags, 387 unsigned int *total_flags, 388 u64 multicast) 389{ 390 struct rt2x00_dev *rt2x00dev = hw->priv; 391 392 /* 393 * Mask off any flags we are going to ignore 394 * from the total_flags field. 395 */ 396 *total_flags &= 397 FIF_ALLMULTI | 398 FIF_FCSFAIL | 399 FIF_PLCPFAIL | 400 FIF_CONTROL | 401 FIF_PSPOLL | 402 FIF_OTHER_BSS | 403 FIF_PROMISC_IN_BSS; 404 405 /* 406 * Apply some rules to the filters: 407 * - Some filters imply different filters to be set. 408 * - Some things we can't filter out at all. 409 * - Multicast filter seems to kill broadcast traffic so never use it. 410 */ 411 *total_flags |= FIF_ALLMULTI; 412 if (*total_flags & FIF_OTHER_BSS || 413 *total_flags & FIF_PROMISC_IN_BSS) 414 *total_flags |= FIF_PROMISC_IN_BSS | FIF_OTHER_BSS; 415 416 /* 417 * If the device has a single filter for all control frames, 418 * FIF_CONTROL and FIF_PSPOLL flags imply each other. 419 * And if the device has more than one filter for control frames 420 * of different types, but has no a separate filter for PS Poll frames, 421 * FIF_CONTROL flag implies FIF_PSPOLL. 422 */ 423 if (!test_bit(CAPABILITY_CONTROL_FILTERS, &rt2x00dev->cap_flags)) { 424 if (*total_flags & FIF_CONTROL || *total_flags & FIF_PSPOLL) 425 *total_flags |= FIF_CONTROL | FIF_PSPOLL; 426 } 427 if (!test_bit(CAPABILITY_CONTROL_FILTER_PSPOLL, &rt2x00dev->cap_flags)) { 428 if (*total_flags & FIF_CONTROL) 429 *total_flags |= FIF_PSPOLL; 430 } 431 432 /* 433 * Check if there is any work left for us. 434 */ 435 if (rt2x00dev->packet_filter == *total_flags) 436 return; 437 rt2x00dev->packet_filter = *total_flags; 438 439 rt2x00dev->ops->lib->config_filter(rt2x00dev, *total_flags); 440} 441EXPORT_SYMBOL_GPL(rt2x00mac_configure_filter); 442 443static void rt2x00mac_set_tim_iter(void *data, u8 *mac, 444 struct ieee80211_vif *vif) 445{ 446 struct rt2x00_intf *intf = vif_to_intf(vif); 447 448 if (vif->type != NL80211_IFTYPE_AP && 449 vif->type != NL80211_IFTYPE_ADHOC && 450 vif->type != NL80211_IFTYPE_MESH_POINT && 451 vif->type != NL80211_IFTYPE_WDS) 452 return; 453 454 set_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags); 455} 456 457int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 458 bool set) 459{ 460 struct rt2x00_dev *rt2x00dev = hw->priv; 461 462 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 463 return 0; 464 465 ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw, 466 rt2x00mac_set_tim_iter, 467 rt2x00dev); 468 469 /* queue work to upodate the beacon template */ 470 ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->intf_work); 471 return 0; 472} 473EXPORT_SYMBOL_GPL(rt2x00mac_set_tim); 474 475#ifdef CONFIG_RT2X00_LIB_CRYPTO 476static void memcpy_tkip(struct rt2x00lib_crypto *crypto, u8 *key, u8 key_len) 477{ 478 if (key_len > NL80211_TKIP_DATA_OFFSET_ENCR_KEY) 479 memcpy(crypto->key, 480 &key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY], 481 sizeof(crypto->key)); 482 483 if (key_len > NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY) 484 memcpy(crypto->tx_mic, 485 &key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY], 486 sizeof(crypto->tx_mic)); 487 488 if (key_len > NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY) 489 memcpy(crypto->rx_mic, 490 &key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY], 491 sizeof(crypto->rx_mic)); 492} 493 494int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 495 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 496 struct ieee80211_key_conf *key) 497{ 498 struct rt2x00_dev *rt2x00dev = hw->priv; 499 int (*set_key) (struct rt2x00_dev *rt2x00dev, 500 struct rt2x00lib_crypto *crypto, 501 struct ieee80211_key_conf *key); 502 struct rt2x00lib_crypto crypto; 503 static const u8 bcast_addr[ETH_ALEN] = 504 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; 505 struct rt2x00_sta *sta_priv = NULL; 506 507 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 508 return 0; 509 else if (!test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags)) 510 return -EOPNOTSUPP; 511 else if (key->keylen > 32) 512 return -ENOSPC; 513 514 memset(&crypto, 0, sizeof(crypto)); 515 516 crypto.bssidx = rt2x00lib_get_bssidx(rt2x00dev, vif); 517 crypto.cipher = rt2x00crypto_key_to_cipher(key); 518 if (crypto.cipher == CIPHER_NONE) 519 return -EOPNOTSUPP; 520 521 crypto.cmd = cmd; 522 523 if (sta) { 524 crypto.address = sta->addr; 525 sta_priv = sta_to_rt2x00_sta(sta); 526 crypto.wcid = sta_priv->wcid; 527 } else 528 crypto.address = bcast_addr; 529 530 if (crypto.cipher == CIPHER_TKIP) 531 memcpy_tkip(&crypto, &key->key[0], key->keylen); 532 else 533 memcpy(crypto.key, &key->key[0], key->keylen); 534 /* 535 * Each BSS has a maximum of 4 shared keys. 536 * Shared key index values: 537 * 0) BSS0 key0 538 * 1) BSS0 key1 539 * ... 540 * 4) BSS1 key0 541 * ... 542 * 8) BSS2 key0 543 * ... 544 * Both pairwise as shared key indeces are determined by 545 * driver. This is required because the hardware requires 546 * keys to be assigned in correct order (When key 1 is 547 * provided but key 0 is not, then the key is not found 548 * by the hardware during RX). 549 */ 550 if (cmd == SET_KEY) 551 key->hw_key_idx = 0; 552 553 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 554 set_key = rt2x00dev->ops->lib->config_pairwise_key; 555 else 556 set_key = rt2x00dev->ops->lib->config_shared_key; 557 558 if (!set_key) 559 return -EOPNOTSUPP; 560 561 return set_key(rt2x00dev, &crypto, key); 562} 563EXPORT_SYMBOL_GPL(rt2x00mac_set_key); 564#endif /* CONFIG_RT2X00_LIB_CRYPTO */ 565 566int rt2x00mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 567 struct ieee80211_sta *sta) 568{ 569 struct rt2x00_dev *rt2x00dev = hw->priv; 570 struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta); 571 572 /* 573 * If there's no space left in the device table store 574 * -1 as wcid but tell mac80211 everything went ok. 575 */ 576 if (rt2x00dev->ops->lib->sta_add(rt2x00dev, vif, sta)) 577 sta_priv->wcid = -1; 578 579 return 0; 580} 581EXPORT_SYMBOL_GPL(rt2x00mac_sta_add); 582 583int rt2x00mac_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 584 struct ieee80211_sta *sta) 585{ 586 struct rt2x00_dev *rt2x00dev = hw->priv; 587 struct rt2x00_sta *sta_priv = sta_to_rt2x00_sta(sta); 588 589 /* 590 * If we never sent the STA to the device no need to clean it up. 591 */ 592 if (sta_priv->wcid < 0) 593 return 0; 594 595 return rt2x00dev->ops->lib->sta_remove(rt2x00dev, sta_priv->wcid); 596} 597EXPORT_SYMBOL_GPL(rt2x00mac_sta_remove); 598 599void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw) 600{ 601 struct rt2x00_dev *rt2x00dev = hw->priv; 602 set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags); 603 rt2x00link_stop_tuner(rt2x00dev); 604} 605EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start); 606 607void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw) 608{ 609 struct rt2x00_dev *rt2x00dev = hw->priv; 610 clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags); 611 rt2x00link_start_tuner(rt2x00dev); 612} 613EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_complete); 614 615int rt2x00mac_get_stats(struct ieee80211_hw *hw, 616 struct ieee80211_low_level_stats *stats) 617{ 618 struct rt2x00_dev *rt2x00dev = hw->priv; 619 620 /* 621 * The dot11ACKFailureCount, dot11RTSFailureCount and 622 * dot11RTSSuccessCount are updated in interrupt time. 623 * dot11FCSErrorCount is updated in the link tuner. 624 */ 625 memcpy(stats, &rt2x00dev->low_level_stats, sizeof(*stats)); 626 627 return 0; 628} 629EXPORT_SYMBOL_GPL(rt2x00mac_get_stats); 630 631void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, 632 struct ieee80211_vif *vif, 633 struct ieee80211_bss_conf *bss_conf, 634 u32 changes) 635{ 636 struct rt2x00_dev *rt2x00dev = hw->priv; 637 struct rt2x00_intf *intf = vif_to_intf(vif); 638 639 /* 640 * mac80211 might be calling this function while we are trying 641 * to remove the device or perhaps suspending it. 642 */ 643 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 644 return; 645 646 /* 647 * Update the BSSID. 648 */ 649 if (changes & BSS_CHANGED_BSSID) 650 rt2x00lib_config_intf(rt2x00dev, intf, vif->type, NULL, 651 bss_conf->bssid); 652 653 /* 654 * Update the beacon. This is only required on USB devices. PCI 655 * devices fetch beacons periodically. 656 */ 657 if (changes & BSS_CHANGED_BEACON && rt2x00_is_usb(rt2x00dev)) 658 rt2x00queue_update_beacon(rt2x00dev, vif); 659 660 /* 661 * Start/stop beaconing. 662 */ 663 if (changes & BSS_CHANGED_BEACON_ENABLED) { 664 if (!bss_conf->enable_beacon && intf->enable_beacon) { 665 rt2x00queue_clear_beacon(rt2x00dev, vif); 666 rt2x00dev->intf_beaconing--; 667 intf->enable_beacon = false; 668 669 if (rt2x00dev->intf_beaconing == 0) { 670 /* 671 * Last beaconing interface disabled 672 * -> stop beacon queue. 673 */ 674 mutex_lock(&intf->beacon_skb_mutex); 675 rt2x00queue_stop_queue(rt2x00dev->bcn); 676 mutex_unlock(&intf->beacon_skb_mutex); 677 } 678 679 680 } else if (bss_conf->enable_beacon && !intf->enable_beacon) { 681 rt2x00dev->intf_beaconing++; 682 intf->enable_beacon = true; 683 684 if (rt2x00dev->intf_beaconing == 1) { 685 /* 686 * First beaconing interface enabled 687 * -> start beacon queue. 688 */ 689 mutex_lock(&intf->beacon_skb_mutex); 690 rt2x00queue_start_queue(rt2x00dev->bcn); 691 mutex_unlock(&intf->beacon_skb_mutex); 692 } 693 } 694 } 695 696 /* 697 * When the association status has changed we must reset the link 698 * tuner counter. This is because some drivers determine if they 699 * should perform link tuning based on the number of seconds 700 * while associated or not associated. 701 */ 702 if (changes & BSS_CHANGED_ASSOC) { 703 rt2x00dev->link.count = 0; 704 705 if (bss_conf->assoc) 706 rt2x00dev->intf_associated++; 707 else 708 rt2x00dev->intf_associated--; 709 710 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated); 711 } 712 713 /* 714 * When the erp information has changed, we should perform 715 * additional configuration steps. For all other changes we are done. 716 */ 717 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE | 718 BSS_CHANGED_ERP_SLOT | BSS_CHANGED_BASIC_RATES | 719 BSS_CHANGED_BEACON_INT | BSS_CHANGED_HT)) 720 rt2x00lib_config_erp(rt2x00dev, intf, bss_conf, changes); 721} 722EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed); 723 724int rt2x00mac_conf_tx(struct ieee80211_hw *hw, 725 struct ieee80211_vif *vif, u16 queue_idx, 726 const struct ieee80211_tx_queue_params *params) 727{ 728 struct rt2x00_dev *rt2x00dev = hw->priv; 729 struct data_queue *queue; 730 731 queue = rt2x00queue_get_tx_queue(rt2x00dev, queue_idx); 732 if (unlikely(!queue)) 733 return -EINVAL; 734 735 /* 736 * The passed variables are stored as real value ((2^n)-1). 737 * Ralink registers require to know the bit number 'n'. 738 */ 739 if (params->cw_min > 0) 740 queue->cw_min = fls(params->cw_min); 741 else 742 queue->cw_min = 5; /* cw_min: 2^5 = 32. */ 743 744 if (params->cw_max > 0) 745 queue->cw_max = fls(params->cw_max); 746 else 747 queue->cw_max = 10; /* cw_min: 2^10 = 1024. */ 748 749 queue->aifs = params->aifs; 750 queue->txop = params->txop; 751 752 INFO(rt2x00dev, 753 "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d.\n", 754 queue_idx, queue->cw_min, queue->cw_max, queue->aifs, queue->txop); 755 756 return 0; 757} 758EXPORT_SYMBOL_GPL(rt2x00mac_conf_tx); 759 760void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw) 761{ 762 struct rt2x00_dev *rt2x00dev = hw->priv; 763 bool active = !!rt2x00dev->ops->lib->rfkill_poll(rt2x00dev); 764 765 wiphy_rfkill_set_hw_state(hw->wiphy, !active); 766} 767EXPORT_SYMBOL_GPL(rt2x00mac_rfkill_poll); 768 769void rt2x00mac_flush(struct ieee80211_hw *hw, bool drop) 770{ 771 struct rt2x00_dev *rt2x00dev = hw->priv; 772 struct data_queue *queue; 773 774 tx_queue_for_each(rt2x00dev, queue) 775 rt2x00queue_flush_queue(queue, drop); 776} 777EXPORT_SYMBOL_GPL(rt2x00mac_flush); 778 779int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 780{ 781 struct rt2x00_dev *rt2x00dev = hw->priv; 782 struct link_ant *ant = &rt2x00dev->link.ant; 783 struct antenna_setup *def = &rt2x00dev->default_ant; 784 struct antenna_setup setup; 785 786 // The antenna value is not supposed to be 0, 787 // or exceed the maximum number of antenna's. 788 if (!tx_ant || (tx_ant & ~3) || !rx_ant || (rx_ant & ~3)) 789 return -EINVAL; 790 791 // When the client tried to configure the antenna to or from 792 // diversity mode, we must reset the default antenna as well 793 // as that controls the diversity switch. 794 if (ant->flags & ANTENNA_TX_DIVERSITY && tx_ant != 3) 795 ant->flags &= ~ANTENNA_TX_DIVERSITY; 796 if (ant->flags & ANTENNA_RX_DIVERSITY && rx_ant != 3) 797 ant->flags &= ~ANTENNA_RX_DIVERSITY; 798 799 // If diversity is being enabled, check if we need hardware 800 // or software diversity. In the latter case, reset the value, 801 // and make sure we update the antenna flags to have the 802 // link tuner pick up the diversity tuning. 803 if (tx_ant == 3 && def->tx == ANTENNA_SW_DIVERSITY) { 804 tx_ant = ANTENNA_SW_DIVERSITY; 805 ant->flags |= ANTENNA_TX_DIVERSITY; 806 } 807 808 if (rx_ant == 3 && def->rx == ANTENNA_SW_DIVERSITY) { 809 rx_ant = ANTENNA_SW_DIVERSITY; 810 ant->flags |= ANTENNA_RX_DIVERSITY; 811 } 812 813 setup.tx = tx_ant; 814 setup.rx = rx_ant; 815 816 rt2x00lib_config_antenna(rt2x00dev, setup); 817 818 return 0; 819} 820EXPORT_SYMBOL_GPL(rt2x00mac_set_antenna); 821 822int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 823{ 824 struct rt2x00_dev *rt2x00dev = hw->priv; 825 struct link_ant *ant = &rt2x00dev->link.ant; 826 struct antenna_setup *active = &rt2x00dev->link.ant.active; 827 828 // When software diversity is active, we must report this to the 829 // client and not the current active antenna state. 830 if (ant->flags & ANTENNA_TX_DIVERSITY) 831 *tx_ant = ANTENNA_HW_DIVERSITY; 832 else 833 *tx_ant = active->tx; 834 835 if (ant->flags & ANTENNA_RX_DIVERSITY) 836 *rx_ant = ANTENNA_HW_DIVERSITY; 837 else 838 *rx_ant = active->rx; 839 840 return 0; 841} 842EXPORT_SYMBOL_GPL(rt2x00mac_get_antenna); 843 844void rt2x00mac_get_ringparam(struct ieee80211_hw *hw, 845 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max) 846{ 847 struct rt2x00_dev *rt2x00dev = hw->priv; 848 struct data_queue *queue; 849 850 tx_queue_for_each(rt2x00dev, queue) { 851 *tx += queue->length; 852 *tx_max += queue->limit; 853 } 854 855 *rx = rt2x00dev->rx->length; 856 *rx_max = rt2x00dev->rx->limit; 857} 858EXPORT_SYMBOL_GPL(rt2x00mac_get_ringparam); 859 860bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw) 861{ 862 struct rt2x00_dev *rt2x00dev = hw->priv; 863 struct data_queue *queue; 864 865 tx_queue_for_each(rt2x00dev, queue) { 866 if (!rt2x00queue_empty(queue)) 867 return true; 868 } 869 870 return false; 871} 872EXPORT_SYMBOL_GPL(rt2x00mac_tx_frames_pending); 873