839 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>4 <http://rt2x00.serialmonkey.com>5 6 */7 8/*9 Module: rt2x00mac10 Abstract: rt2x00 generic mac80211 routines.11 */12 13#include <linux/kernel.h>14#include <linux/module.h>15 16#include "rt2x00.h"17#include "rt2x00lib.h"18 19static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev,20 struct data_queue *queue,21 struct sk_buff *frag_skb)22{23 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(frag_skb);24 struct ieee80211_tx_info *rts_info;25 struct sk_buff *skb;26 unsigned int data_length;27 int retval = 0;28 29 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)30 data_length = sizeof(struct ieee80211_cts);31 else32 data_length = sizeof(struct ieee80211_rts);33 34 skb = dev_alloc_skb(data_length + rt2x00dev->hw->extra_tx_headroom);35 if (unlikely(!skb)) {36 rt2x00_warn(rt2x00dev, "Failed to create RTS/CTS frame\n");37 return -ENOMEM;38 }39 40 skb_reserve(skb, rt2x00dev->hw->extra_tx_headroom);41 skb_put(skb, data_length);42 43 /*44 * Copy TX information over from original frame to45 * RTS/CTS frame. Note that we set the no encryption flag46 * since we don't want this frame to be encrypted.47 * RTS frames should be acked, while CTS-to-self frames48 * should not. The ready for TX flag is cleared to prevent49 * it being automatically send when the descriptor is50 * written to the hardware.51 */52 memcpy(skb->cb, frag_skb->cb, sizeof(skb->cb));53 rts_info = IEEE80211_SKB_CB(skb);54 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_RTS_CTS;55 rts_info->control.rates[0].flags &= ~IEEE80211_TX_RC_USE_CTS_PROTECT;56 57 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)58 rts_info->flags |= IEEE80211_TX_CTL_NO_ACK;59 else60 rts_info->flags &= ~IEEE80211_TX_CTL_NO_ACK;61 62 /* Disable hardware encryption */63 rts_info->control.hw_key = NULL;64 65 /*66 * RTS/CTS frame should use the length of the frame plus any67 * encryption overhead that will be added by the hardware.68 */69 data_length += rt2x00crypto_tx_overhead(rt2x00dev, skb);70 71 if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)72 ieee80211_ctstoself_get(rt2x00dev->hw, tx_info->control.vif,73 frag_skb->data, data_length, tx_info,74 (struct ieee80211_cts *)(skb->data));75 else76 ieee80211_rts_get(rt2x00dev->hw, tx_info->control.vif,77 frag_skb->data, data_length, tx_info,78 (struct ieee80211_rts *)(skb->data));79 80 retval = rt2x00queue_write_tx_frame(queue, skb, NULL, true);81 if (retval) {82 dev_kfree_skb_any(skb);83 rt2x00_warn(rt2x00dev, "Failed to send RTS/CTS frame\n");84 }85 86 return retval;87}88 89void rt2x00mac_tx(struct ieee80211_hw *hw,90 struct ieee80211_tx_control *control,91 struct sk_buff *skb)92{93 struct rt2x00_dev *rt2x00dev = hw->priv;94 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);95 enum data_queue_qid qid = skb_get_queue_mapping(skb);96 struct data_queue *queue = NULL;97 98 /*99 * Mac80211 might be calling this function while we are trying100 * to remove the device or perhaps suspending it.101 * Note that we can only stop the TX queues inside the TX path102 * due to possible race conditions in mac80211.103 */104 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))105 goto exit_free_skb;106 107 /*108 * Use the ATIM queue if appropriate and present.109 */110 if (tx_info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM &&111 rt2x00_has_cap_flag(rt2x00dev, REQUIRE_ATIM_QUEUE))112 qid = QID_ATIM;113 114 queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);115 if (unlikely(!queue)) {116 rt2x00_err(rt2x00dev,117 "Attempt to send packet over invalid queue %d\n"118 "Please file bug report to %s\n", qid, DRV_PROJECT);119 goto exit_free_skb;120 }121 122 /*123 * If CTS/RTS is required. create and queue that frame first.124 * Make sure we have at least enough entries available to send125 * this CTS/RTS frame as well as the data frame.126 * Note that when the driver has set the set_rts_threshold()127 * callback function it doesn't need software generation of128 * either RTS or CTS-to-self frame and handles everything129 * inside the hardware.130 */131 if (!rt2x00dev->ops->hw->set_rts_threshold &&132 (tx_info->control.rates[0].flags & (IEEE80211_TX_RC_USE_RTS_CTS |133 IEEE80211_TX_RC_USE_CTS_PROTECT))) {134 if (rt2x00queue_available(queue) <= 1) {135 /*136 * Recheck for full queue under lock to avoid race137 * conditions with rt2x00lib_txdone().138 */139 spin_lock(&queue->tx_lock);140 if (rt2x00queue_threshold(queue))141 rt2x00queue_pause_queue(queue);142 spin_unlock(&queue->tx_lock);143 144 goto exit_free_skb;145 }146 147 if (rt2x00mac_tx_rts_cts(rt2x00dev, queue, skb))148 goto exit_free_skb;149 }150 151 if (unlikely(rt2x00queue_write_tx_frame(queue, skb, control->sta, false)))152 goto exit_free_skb;153 154 return;155 156 exit_free_skb:157 ieee80211_free_txskb(hw, skb);158}159EXPORT_SYMBOL_GPL(rt2x00mac_tx);160 161int rt2x00mac_start(struct ieee80211_hw *hw)162{163 struct rt2x00_dev *rt2x00dev = hw->priv;164 165 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))166 return 0;167 168 if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags)) {169 /*170 * This is special case for ieee80211_restart_hw(), otherwise171 * mac80211 never call start() two times in row without stop();172 */173 set_bit(DEVICE_STATE_RESET, &rt2x00dev->flags);174 rt2x00dev->ops->lib->pre_reset_hw(rt2x00dev);175 rt2x00lib_stop(rt2x00dev);176 }177 return rt2x00lib_start(rt2x00dev);178}179EXPORT_SYMBOL_GPL(rt2x00mac_start);180 181void rt2x00mac_stop(struct ieee80211_hw *hw, bool suspend)182{183 struct rt2x00_dev *rt2x00dev = hw->priv;184 185 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))186 return;187 188 rt2x00lib_stop(rt2x00dev);189}190EXPORT_SYMBOL_GPL(rt2x00mac_stop);191 192void193rt2x00mac_reconfig_complete(struct ieee80211_hw *hw,194 enum ieee80211_reconfig_type reconfig_type)195{196 struct rt2x00_dev *rt2x00dev = hw->priv;197 198 if (reconfig_type == IEEE80211_RECONFIG_TYPE_RESTART)199 clear_bit(DEVICE_STATE_RESET, &rt2x00dev->flags);200}201EXPORT_SYMBOL_GPL(rt2x00mac_reconfig_complete);202 203int rt2x00mac_add_interface(struct ieee80211_hw *hw,204 struct ieee80211_vif *vif)205{206 struct rt2x00_dev *rt2x00dev = hw->priv;207 struct rt2x00_intf *intf = vif_to_intf(vif);208 struct data_queue *queue = rt2x00dev->bcn;209 struct queue_entry *entry = NULL;210 unsigned int i;211 212 /*213 * Don't allow interfaces to be added214 * the device has disappeared.215 */216 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||217 !test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))218 return -ENODEV;219 220 /*221 * Loop through all beacon queues to find a free222 * entry. Since there are as much beacon entries223 * as the maximum interfaces, this search shouldn't224 * fail.225 */226 for (i = 0; i < queue->limit; i++) {227 entry = &queue->entries[i];228 if (!test_and_set_bit(ENTRY_BCN_ASSIGNED, &entry->flags))229 break;230 }231 232 if (unlikely(i == queue->limit))233 return -ENOBUFS;234 235 /*236 * We are now absolutely sure the interface can be created,237 * increase interface count and start initialization.238 */239 240 if (vif->type == NL80211_IFTYPE_AP)241 rt2x00dev->intf_ap_count++;242 else243 rt2x00dev->intf_sta_count++;244 245 mutex_init(&intf->beacon_skb_mutex);246 intf->beacon = entry;247 248 /*249 * The MAC address must be configured after the device250 * has been initialized. Otherwise the device can reset251 * the MAC registers.252 * The BSSID address must only be configured in AP mode,253 * however we should not send an empty BSSID address for254 * STA interfaces at this time, since this can cause255 * invalid behavior in the device.256 */257 rt2x00lib_config_intf(rt2x00dev, intf, vif->type,258 vif->addr, NULL);259 260 /*261 * Some filters depend on the current working mode. We can force262 * an update during the next configure_filter() run by mac80211 by263 * resetting the current packet_filter state.264 */265 rt2x00dev->packet_filter = 0;266 267 return 0;268}269EXPORT_SYMBOL_GPL(rt2x00mac_add_interface);270 271void rt2x00mac_remove_interface(struct ieee80211_hw *hw,272 struct ieee80211_vif *vif)273{274 struct rt2x00_dev *rt2x00dev = hw->priv;275 struct rt2x00_intf *intf = vif_to_intf(vif);276 277 /*278 * Don't allow interfaces to be remove while279 * either the device has disappeared or when280 * no interface is present.281 */282 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||283 (vif->type == NL80211_IFTYPE_AP && !rt2x00dev->intf_ap_count) ||284 (vif->type != NL80211_IFTYPE_AP && !rt2x00dev->intf_sta_count))285 return;286 287 if (vif->type == NL80211_IFTYPE_AP)288 rt2x00dev->intf_ap_count--;289 else290 rt2x00dev->intf_sta_count--;291 292 /*293 * Release beacon entry so it is available for294 * new interfaces again.295 */296 clear_bit(ENTRY_BCN_ASSIGNED, &intf->beacon->flags);297 298 /*299 * Make sure the bssid and mac address registers300 * are cleared to prevent false ACKing of frames.301 */302 rt2x00lib_config_intf(rt2x00dev, intf,303 NL80211_IFTYPE_UNSPECIFIED, NULL, NULL);304}305EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface);306 307int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed)308{309 struct rt2x00_dev *rt2x00dev = hw->priv;310 struct ieee80211_conf *conf = &hw->conf;311 312 /*313 * mac80211 might be calling this function while we are trying314 * to remove the device or perhaps suspending it.315 */316 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))317 return 0;318 319 /*320 * Some configuration parameters (e.g. channel and antenna values) can321 * only be set when the radio is enabled, but do require the RX to322 * be off. During this period we should keep link tuning enabled,323 * if for any reason the link tuner must be reset, this will be324 * handled by rt2x00lib_config().325 */326 rt2x00queue_stop_queue(rt2x00dev->rx);327 328 /* Do not race with link tuner. */329 mutex_lock(&rt2x00dev->conf_mutex);330 331 /*332 * When we've just turned on the radio, we want to reprogram333 * everything to ensure a consistent state334 */335 rt2x00lib_config(rt2x00dev, conf, changed);336 337 /*338 * After the radio has been enabled we need to configure339 * the antenna to the default settings. rt2x00lib_config_antenna()340 * should determine if any action should be taken based on341 * checking if diversity has been enabled or no antenna changes342 * have been made since the last configuration change.343 */344 rt2x00lib_config_antenna(rt2x00dev, rt2x00dev->default_ant);345 346 mutex_unlock(&rt2x00dev->conf_mutex);347 348 /* Turn RX back on */349 rt2x00queue_start_queue(rt2x00dev->rx);350 351 return 0;352}353EXPORT_SYMBOL_GPL(rt2x00mac_config);354 355void rt2x00mac_configure_filter(struct ieee80211_hw *hw,356 unsigned int changed_flags,357 unsigned int *total_flags,358 u64 multicast)359{360 struct rt2x00_dev *rt2x00dev = hw->priv;361 362 /*363 * Mask off any flags we are going to ignore364 * from the total_flags field.365 */366 *total_flags &=367 FIF_ALLMULTI |368 FIF_FCSFAIL |369 FIF_PLCPFAIL |370 FIF_CONTROL |371 FIF_PSPOLL |372 FIF_OTHER_BSS;373 374 /*375 * Apply some rules to the filters:376 * - Some filters imply different filters to be set.377 * - Some things we can't filter out at all.378 * - Multicast filter seems to kill broadcast traffic so never use it.379 */380 *total_flags |= FIF_ALLMULTI;381 382 /*383 * If the device has a single filter for all control frames,384 * FIF_CONTROL and FIF_PSPOLL flags imply each other.385 * And if the device has more than one filter for control frames386 * of different types, but has no a separate filter for PS Poll frames,387 * FIF_CONTROL flag implies FIF_PSPOLL.388 */389 if (!rt2x00_has_cap_control_filters(rt2x00dev)) {390 if (*total_flags & FIF_CONTROL || *total_flags & FIF_PSPOLL)391 *total_flags |= FIF_CONTROL | FIF_PSPOLL;392 }393 if (!rt2x00_has_cap_control_filter_pspoll(rt2x00dev)) {394 if (*total_flags & FIF_CONTROL)395 *total_flags |= FIF_PSPOLL;396 }397 398 rt2x00dev->packet_filter = *total_flags;399 400 rt2x00dev->ops->lib->config_filter(rt2x00dev, *total_flags);401}402EXPORT_SYMBOL_GPL(rt2x00mac_configure_filter);403 404static void rt2x00mac_set_tim_iter(void *data, u8 *mac,405 struct ieee80211_vif *vif)406{407 struct rt2x00_intf *intf = vif_to_intf(vif);408 409 if (vif->type != NL80211_IFTYPE_AP &&410 vif->type != NL80211_IFTYPE_ADHOC &&411 vif->type != NL80211_IFTYPE_MESH_POINT)412 return;413 414 set_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags);415}416 417int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta,418 bool set)419{420 struct rt2x00_dev *rt2x00dev = hw->priv;421 422 if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))423 return 0;424 425 ieee80211_iterate_active_interfaces_atomic(426 rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,427 rt2x00mac_set_tim_iter, rt2x00dev);428 429 /* queue work to upodate the beacon template */430 ieee80211_queue_work(rt2x00dev->hw, &rt2x00dev->intf_work);431 return 0;432}433EXPORT_SYMBOL_GPL(rt2x00mac_set_tim);434 435#ifdef CONFIG_RT2X00_LIB_CRYPTO436static void memcpy_tkip(struct rt2x00lib_crypto *crypto, u8 *key, u8 key_len)437{438 if (key_len > NL80211_TKIP_DATA_OFFSET_ENCR_KEY)439 memcpy(crypto->key,440 &key[NL80211_TKIP_DATA_OFFSET_ENCR_KEY],441 sizeof(crypto->key));442 443 if (key_len > NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY)444 memcpy(crypto->tx_mic,445 &key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],446 sizeof(crypto->tx_mic));447 448 if (key_len > NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY)449 memcpy(crypto->rx_mic,450 &key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],451 sizeof(crypto->rx_mic));452}453 454int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,455 struct ieee80211_vif *vif, struct ieee80211_sta *sta,456 struct ieee80211_key_conf *key)457{458 struct rt2x00_dev *rt2x00dev = hw->priv;459 int (*set_key) (struct rt2x00_dev *rt2x00dev,460 struct rt2x00lib_crypto *crypto,461 struct ieee80211_key_conf *key);462 struct rt2x00lib_crypto crypto;463 static const u8 bcast_addr[ETH_ALEN] =464 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, };465 struct rt2x00_sta *sta_priv = NULL;466 467 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))468 return 0;469 470 /* The hardware can't do MFP */471 if (!rt2x00_has_cap_hw_crypto(rt2x00dev) || (sta && sta->mfp))472 return -EOPNOTSUPP;473 474 /*475 * To support IBSS RSN, don't program group keys in IBSS, the476 * hardware will then not attempt to decrypt the frames.477 */478 if (vif->type == NL80211_IFTYPE_ADHOC &&479 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))480 return -EOPNOTSUPP;481 482 if (key->keylen > 32)483 return -ENOSPC;484 485 memset(&crypto, 0, sizeof(crypto));486 487 crypto.bssidx = rt2x00lib_get_bssidx(rt2x00dev, vif);488 crypto.cipher = rt2x00crypto_key_to_cipher(key);489 if (crypto.cipher == CIPHER_NONE)490 return -EOPNOTSUPP;491 if (crypto.cipher == CIPHER_TKIP && rt2x00_is_usb(rt2x00dev))492 return -EOPNOTSUPP;493 494 crypto.cmd = cmd;495 496 if (sta) {497 crypto.address = sta->addr;498 sta_priv = sta_to_rt2x00_sta(sta);499 crypto.wcid = sta_priv->wcid;500 } else501 crypto.address = bcast_addr;502 503 if (crypto.cipher == CIPHER_TKIP)504 memcpy_tkip(&crypto, &key->key[0], key->keylen);505 else506 memcpy(crypto.key, &key->key[0], key->keylen);507 /*508 * Each BSS has a maximum of 4 shared keys.509 * Shared key index values:510 * 0) BSS0 key0511 * 1) BSS0 key1512 * ...513 * 4) BSS1 key0514 * ...515 * 8) BSS2 key0516 * ...517 * Both pairwise as shared key indeces are determined by518 * driver. This is required because the hardware requires519 * keys to be assigned in correct order (When key 1 is520 * provided but key 0 is not, then the key is not found521 * by the hardware during RX).522 */523 if (cmd == SET_KEY)524 key->hw_key_idx = 0;525 526 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)527 set_key = rt2x00dev->ops->lib->config_pairwise_key;528 else529 set_key = rt2x00dev->ops->lib->config_shared_key;530 531 if (!set_key)532 return -EOPNOTSUPP;533 534 return set_key(rt2x00dev, &crypto, key);535}536EXPORT_SYMBOL_GPL(rt2x00mac_set_key);537#endif /* CONFIG_RT2X00_LIB_CRYPTO */538 539void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw,540 struct ieee80211_vif *vif,541 const u8 *mac_addr)542{543 struct rt2x00_dev *rt2x00dev = hw->priv;544 set_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);545 rt2x00link_stop_tuner(rt2x00dev);546}547EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_start);548 549void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw,550 struct ieee80211_vif *vif)551{552 struct rt2x00_dev *rt2x00dev = hw->priv;553 clear_bit(DEVICE_STATE_SCANNING, &rt2x00dev->flags);554 rt2x00link_start_tuner(rt2x00dev);555}556EXPORT_SYMBOL_GPL(rt2x00mac_sw_scan_complete);557 558int rt2x00mac_get_stats(struct ieee80211_hw *hw,559 struct ieee80211_low_level_stats *stats)560{561 struct rt2x00_dev *rt2x00dev = hw->priv;562 563 /*564 * The dot11ACKFailureCount, dot11RTSFailureCount and565 * dot11RTSSuccessCount are updated in interrupt time.566 * dot11FCSErrorCount is updated in the link tuner.567 */568 memcpy(stats, &rt2x00dev->low_level_stats, sizeof(*stats));569 570 return 0;571}572EXPORT_SYMBOL_GPL(rt2x00mac_get_stats);573 574void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,575 struct ieee80211_vif *vif,576 struct ieee80211_bss_conf *bss_conf,577 u64 changes)578{579 struct rt2x00_dev *rt2x00dev = hw->priv;580 struct rt2x00_intf *intf = vif_to_intf(vif);581 582 /*583 * mac80211 might be calling this function while we are trying584 * to remove the device or perhaps suspending it.585 */586 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))587 return;588 589 /*590 * Update the BSSID.591 */592 if (changes & BSS_CHANGED_BSSID)593 rt2x00lib_config_intf(rt2x00dev, intf, vif->type, NULL,594 bss_conf->bssid);595 596 /*597 * Start/stop beaconing.598 */599 if (changes & BSS_CHANGED_BEACON_ENABLED) {600 mutex_lock(&intf->beacon_skb_mutex);601 602 /*603 * Clear the 'enable_beacon' flag and clear beacon because604 * the beacon queue has been stopped after hardware reset.605 */606 if (test_bit(DEVICE_STATE_RESET, &rt2x00dev->flags) &&607 intf->enable_beacon) {608 intf->enable_beacon = false;609 rt2x00queue_clear_beacon(rt2x00dev, vif);610 }611 612 if (!bss_conf->enable_beacon && intf->enable_beacon) {613 rt2x00dev->intf_beaconing--;614 intf->enable_beacon = false;615 616 if (rt2x00dev->intf_beaconing == 0) {617 /*618 * Last beaconing interface disabled619 * -> stop beacon queue.620 */621 rt2x00queue_stop_queue(rt2x00dev->bcn);622 }623 /*624 * Clear beacon in the H/W for this vif. This is needed625 * to disable beaconing on this particular interface626 * and keep it running on other interfaces.627 */628 rt2x00queue_clear_beacon(rt2x00dev, vif);629 } else if (bss_conf->enable_beacon && !intf->enable_beacon) {630 rt2x00dev->intf_beaconing++;631 intf->enable_beacon = true;632 /*633 * Upload beacon to the H/W. This is only required on634 * USB devices. PCI devices fetch beacons periodically.635 */636 if (rt2x00_is_usb(rt2x00dev))637 rt2x00queue_update_beacon(rt2x00dev, vif);638 639 if (rt2x00dev->intf_beaconing == 1) {640 /*641 * First beaconing interface enabled642 * -> start beacon queue.643 */644 rt2x00queue_start_queue(rt2x00dev->bcn);645 }646 }647 mutex_unlock(&intf->beacon_skb_mutex);648 }649 650 /*651 * When the association status has changed we must reset the link652 * tuner counter. This is because some drivers determine if they653 * should perform link tuning based on the number of seconds654 * while associated or not associated.655 */656 if (changes & BSS_CHANGED_ASSOC) {657 rt2x00dev->link.count = 0;658 659 if (vif->cfg.assoc)660 rt2x00dev->intf_associated++;661 else662 rt2x00dev->intf_associated--;663 664 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);665 }666 667 /*668 * When the erp information has changed, we should perform669 * additional configuration steps. For all other changes we are done.670 */671 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_ERP_PREAMBLE |672 BSS_CHANGED_ERP_SLOT | BSS_CHANGED_BASIC_RATES |673 BSS_CHANGED_BEACON_INT | BSS_CHANGED_HT))674 rt2x00lib_config_erp(rt2x00dev, intf, bss_conf, changes);675}676EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed);677 678int rt2x00mac_conf_tx(struct ieee80211_hw *hw,679 struct ieee80211_vif *vif,680 unsigned int link_id, u16 queue_idx,681 const struct ieee80211_tx_queue_params *params)682{683 struct rt2x00_dev *rt2x00dev = hw->priv;684 struct data_queue *queue;685 686 queue = rt2x00queue_get_tx_queue(rt2x00dev, queue_idx);687 if (unlikely(!queue))688 return -EINVAL;689 690 /*691 * The passed variables are stored as real value ((2^n)-1).692 * Ralink registers require to know the bit number 'n'.693 */694 if (params->cw_min > 0)695 queue->cw_min = fls(params->cw_min);696 else697 queue->cw_min = 5; /* cw_min: 2^5 = 32. */698 699 if (params->cw_max > 0)700 queue->cw_max = fls(params->cw_max);701 else702 queue->cw_max = 10; /* cw_min: 2^10 = 1024. */703 704 queue->aifs = params->aifs;705 queue->txop = params->txop;706 707 rt2x00_dbg(rt2x00dev,708 "Configured TX queue %d - CWmin: %d, CWmax: %d, Aifs: %d, TXop: %d\n",709 queue_idx, queue->cw_min, queue->cw_max, queue->aifs,710 queue->txop);711 712 return 0;713}714EXPORT_SYMBOL_GPL(rt2x00mac_conf_tx);715 716void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw)717{718 struct rt2x00_dev *rt2x00dev = hw->priv;719 bool active = !!rt2x00dev->ops->lib->rfkill_poll(rt2x00dev);720 721 wiphy_rfkill_set_hw_state(hw->wiphy, !active);722}723EXPORT_SYMBOL_GPL(rt2x00mac_rfkill_poll);724 725void rt2x00mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,726 u32 queues, bool drop)727{728 struct rt2x00_dev *rt2x00dev = hw->priv;729 struct data_queue *queue;730 731 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))732 return;733 734 set_bit(DEVICE_STATE_FLUSHING, &rt2x00dev->flags);735 736 tx_queue_for_each(rt2x00dev, queue)737 rt2x00queue_flush_queue(queue, drop);738 739 clear_bit(DEVICE_STATE_FLUSHING, &rt2x00dev->flags);740}741EXPORT_SYMBOL_GPL(rt2x00mac_flush);742 743int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)744{745 struct rt2x00_dev *rt2x00dev = hw->priv;746 struct link_ant *ant = &rt2x00dev->link.ant;747 struct antenna_setup *def = &rt2x00dev->default_ant;748 struct antenna_setup setup;749 750 // The antenna value is not supposed to be 0,751 // or exceed the maximum number of antenna's.752 if (!tx_ant || (tx_ant & ~3) || !rx_ant || (rx_ant & ~3))753 return -EINVAL;754 755 // When the client tried to configure the antenna to or from756 // diversity mode, we must reset the default antenna as well757 // as that controls the diversity switch.758 if (ant->flags & ANTENNA_TX_DIVERSITY && tx_ant != 3)759 ant->flags &= ~ANTENNA_TX_DIVERSITY;760 if (ant->flags & ANTENNA_RX_DIVERSITY && rx_ant != 3)761 ant->flags &= ~ANTENNA_RX_DIVERSITY;762 763 // If diversity is being enabled, check if we need hardware764 // or software diversity. In the latter case, reset the value,765 // and make sure we update the antenna flags to have the766 // link tuner pick up the diversity tuning.767 if (tx_ant == 3 && def->tx == ANTENNA_SW_DIVERSITY) {768 tx_ant = ANTENNA_SW_DIVERSITY;769 ant->flags |= ANTENNA_TX_DIVERSITY;770 }771 772 if (rx_ant == 3 && def->rx == ANTENNA_SW_DIVERSITY) {773 rx_ant = ANTENNA_SW_DIVERSITY;774 ant->flags |= ANTENNA_RX_DIVERSITY;775 }776 777 setup.tx = tx_ant;778 setup.rx = rx_ant;779 setup.rx_chain_num = 0;780 setup.tx_chain_num = 0;781 782 rt2x00lib_config_antenna(rt2x00dev, setup);783 784 return 0;785}786EXPORT_SYMBOL_GPL(rt2x00mac_set_antenna);787 788int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)789{790 struct rt2x00_dev *rt2x00dev = hw->priv;791 struct link_ant *ant = &rt2x00dev->link.ant;792 struct antenna_setup *active = &rt2x00dev->link.ant.active;793 794 // When software diversity is active, we must report this to the795 // client and not the current active antenna state.796 if (ant->flags & ANTENNA_TX_DIVERSITY)797 *tx_ant = ANTENNA_HW_DIVERSITY;798 else799 *tx_ant = active->tx;800 801 if (ant->flags & ANTENNA_RX_DIVERSITY)802 *rx_ant = ANTENNA_HW_DIVERSITY;803 else804 *rx_ant = active->rx;805 806 return 0;807}808EXPORT_SYMBOL_GPL(rt2x00mac_get_antenna);809 810void rt2x00mac_get_ringparam(struct ieee80211_hw *hw,811 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)812{813 struct rt2x00_dev *rt2x00dev = hw->priv;814 struct data_queue *queue;815 816 tx_queue_for_each(rt2x00dev, queue) {817 *tx += queue->length;818 *tx_max += queue->limit;819 }820 821 *rx = rt2x00dev->rx->length;822 *rx_max = rt2x00dev->rx->limit;823}824EXPORT_SYMBOL_GPL(rt2x00mac_get_ringparam);825 826bool rt2x00mac_tx_frames_pending(struct ieee80211_hw *hw)827{828 struct rt2x00_dev *rt2x00dev = hw->priv;829 struct data_queue *queue;830 831 tx_queue_for_each(rt2x00dev, queue) {832 if (!rt2x00queue_empty(queue))833 return true;834 }835 836 return false;837}838EXPORT_SYMBOL_GPL(rt2x00mac_tx_frames_pending);839