133aca94dSKalle Valo /* 233aca94dSKalle Valo Copyright (C) 2010 Willow Garage <http://www.willowgarage.com> 333aca94dSKalle Valo Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com> 433aca94dSKalle Valo <http://rt2x00.serialmonkey.com> 533aca94dSKalle Valo 633aca94dSKalle Valo This program is free software; you can redistribute it and/or modify 733aca94dSKalle Valo it under the terms of the GNU General Public License as published by 833aca94dSKalle Valo the Free Software Foundation; either version 2 of the License, or 933aca94dSKalle Valo (at your option) any later version. 1033aca94dSKalle Valo 1133aca94dSKalle Valo This program is distributed in the hope that it will be useful, 1233aca94dSKalle Valo but WITHOUT ANY WARRANTY; without even the implied warranty of 1333aca94dSKalle Valo MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1433aca94dSKalle Valo GNU General Public License for more details. 1533aca94dSKalle Valo 1633aca94dSKalle Valo You should have received a copy of the GNU General Public License 1733aca94dSKalle Valo along with this program; if not, see <http://www.gnu.org/licenses/>. 1833aca94dSKalle Valo */ 1933aca94dSKalle Valo 2033aca94dSKalle Valo /* 2133aca94dSKalle Valo Module: rt2x00lib 2233aca94dSKalle Valo Abstract: rt2x00 generic device routines. 2333aca94dSKalle Valo */ 2433aca94dSKalle Valo 2533aca94dSKalle Valo #include <linux/kernel.h> 2633aca94dSKalle Valo #include <linux/module.h> 2733aca94dSKalle Valo #include <linux/slab.h> 2833aca94dSKalle Valo #include <linux/log2.h> 299766cb70SMathias Kresin #include <linux/of.h> 309766cb70SMathias Kresin #include <linux/of_net.h> 3133aca94dSKalle Valo 3233aca94dSKalle Valo #include "rt2x00.h" 3333aca94dSKalle Valo #include "rt2x00lib.h" 3433aca94dSKalle Valo 3533aca94dSKalle Valo /* 3633aca94dSKalle Valo * Utility functions. 3733aca94dSKalle Valo */ 3833aca94dSKalle Valo u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev, 3933aca94dSKalle Valo struct ieee80211_vif *vif) 4033aca94dSKalle Valo { 4133aca94dSKalle Valo /* 4233aca94dSKalle Valo * When in STA mode, bssidx is always 0 otherwise local_address[5] 4333aca94dSKalle Valo * contains the bss number, see BSS_ID_MASK comments for details. 4433aca94dSKalle Valo */ 4533aca94dSKalle Valo if (rt2x00dev->intf_sta_count) 4633aca94dSKalle Valo return 0; 4733aca94dSKalle Valo return vif->addr[5] & (rt2x00dev->ops->max_ap_intf - 1); 4833aca94dSKalle Valo } 4933aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_get_bssidx); 5033aca94dSKalle Valo 5133aca94dSKalle Valo /* 5233aca94dSKalle Valo * Radio control handlers. 5333aca94dSKalle Valo */ 5433aca94dSKalle Valo int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev) 5533aca94dSKalle Valo { 5633aca94dSKalle Valo int status; 5733aca94dSKalle Valo 5833aca94dSKalle Valo /* 5933aca94dSKalle Valo * Don't enable the radio twice. 6033aca94dSKalle Valo * And check if the hardware button has been disabled. 6133aca94dSKalle Valo */ 6233aca94dSKalle Valo if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 6333aca94dSKalle Valo return 0; 6433aca94dSKalle Valo 6533aca94dSKalle Valo /* 6633aca94dSKalle Valo * Initialize all data queues. 6733aca94dSKalle Valo */ 6833aca94dSKalle Valo rt2x00queue_init_queues(rt2x00dev); 6933aca94dSKalle Valo 7033aca94dSKalle Valo /* 7133aca94dSKalle Valo * Enable radio. 7233aca94dSKalle Valo */ 7333aca94dSKalle Valo status = 7433aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON); 7533aca94dSKalle Valo if (status) 7633aca94dSKalle Valo return status; 7733aca94dSKalle Valo 7833aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON); 7933aca94dSKalle Valo 8033aca94dSKalle Valo rt2x00leds_led_radio(rt2x00dev, true); 8133aca94dSKalle Valo rt2x00led_led_activity(rt2x00dev, true); 8233aca94dSKalle Valo 8333aca94dSKalle Valo set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags); 8433aca94dSKalle Valo 8533aca94dSKalle Valo /* 8633aca94dSKalle Valo * Enable queues. 8733aca94dSKalle Valo */ 8833aca94dSKalle Valo rt2x00queue_start_queues(rt2x00dev); 8933aca94dSKalle Valo rt2x00link_start_tuner(rt2x00dev); 9033aca94dSKalle Valo 9133aca94dSKalle Valo /* 9233aca94dSKalle Valo * Start watchdog monitoring. 9333aca94dSKalle Valo */ 9433aca94dSKalle Valo rt2x00link_start_watchdog(rt2x00dev); 9533aca94dSKalle Valo 9633aca94dSKalle Valo return 0; 9733aca94dSKalle Valo } 9833aca94dSKalle Valo 9933aca94dSKalle Valo void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev) 10033aca94dSKalle Valo { 10133aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 10233aca94dSKalle Valo return; 10333aca94dSKalle Valo 10433aca94dSKalle Valo /* 10533aca94dSKalle Valo * Stop watchdog monitoring. 10633aca94dSKalle Valo */ 10733aca94dSKalle Valo rt2x00link_stop_watchdog(rt2x00dev); 10833aca94dSKalle Valo 10933aca94dSKalle Valo /* 11033aca94dSKalle Valo * Stop all queues 11133aca94dSKalle Valo */ 11233aca94dSKalle Valo rt2x00link_stop_tuner(rt2x00dev); 11333aca94dSKalle Valo rt2x00queue_stop_queues(rt2x00dev); 11433aca94dSKalle Valo rt2x00queue_flush_queues(rt2x00dev, true); 11533aca94dSKalle Valo 11633aca94dSKalle Valo /* 11733aca94dSKalle Valo * Disable radio. 11833aca94dSKalle Valo */ 11933aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF); 12033aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF); 12133aca94dSKalle Valo rt2x00led_led_activity(rt2x00dev, false); 12233aca94dSKalle Valo rt2x00leds_led_radio(rt2x00dev, false); 12333aca94dSKalle Valo } 12433aca94dSKalle Valo 12533aca94dSKalle Valo static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac, 12633aca94dSKalle Valo struct ieee80211_vif *vif) 12733aca94dSKalle Valo { 12833aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data; 12933aca94dSKalle Valo struct rt2x00_intf *intf = vif_to_intf(vif); 13033aca94dSKalle Valo 13133aca94dSKalle Valo /* 13233aca94dSKalle Valo * It is possible the radio was disabled while the work had been 13333aca94dSKalle Valo * scheduled. If that happens we should return here immediately, 13433aca94dSKalle Valo * note that in the spinlock protected area above the delayed_flags 13533aca94dSKalle Valo * have been cleared correctly. 13633aca94dSKalle Valo */ 13733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 13833aca94dSKalle Valo return; 13933aca94dSKalle Valo 14033aca94dSKalle Valo if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags)) { 14133aca94dSKalle Valo mutex_lock(&intf->beacon_skb_mutex); 14233aca94dSKalle Valo rt2x00queue_update_beacon(rt2x00dev, vif); 14333aca94dSKalle Valo mutex_unlock(&intf->beacon_skb_mutex); 14433aca94dSKalle Valo } 14533aca94dSKalle Valo } 14633aca94dSKalle Valo 14733aca94dSKalle Valo static void rt2x00lib_intf_scheduled(struct work_struct *work) 14833aca94dSKalle Valo { 14933aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = 15033aca94dSKalle Valo container_of(work, struct rt2x00_dev, intf_work); 15133aca94dSKalle Valo 15233aca94dSKalle Valo /* 15333aca94dSKalle Valo * Iterate over each interface and perform the 15433aca94dSKalle Valo * requested configurations. 15533aca94dSKalle Valo */ 15633aca94dSKalle Valo ieee80211_iterate_active_interfaces(rt2x00dev->hw, 15733aca94dSKalle Valo IEEE80211_IFACE_ITER_RESUME_ALL, 15833aca94dSKalle Valo rt2x00lib_intf_scheduled_iter, 15933aca94dSKalle Valo rt2x00dev); 16033aca94dSKalle Valo } 16133aca94dSKalle Valo 16233aca94dSKalle Valo static void rt2x00lib_autowakeup(struct work_struct *work) 16333aca94dSKalle Valo { 16433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = 16533aca94dSKalle Valo container_of(work, struct rt2x00_dev, autowakeup_work.work); 16633aca94dSKalle Valo 16733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 16833aca94dSKalle Valo return; 16933aca94dSKalle Valo 17033aca94dSKalle Valo if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE)) 17133aca94dSKalle Valo rt2x00_err(rt2x00dev, "Device failed to wakeup\n"); 17233aca94dSKalle Valo clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags); 17333aca94dSKalle Valo } 17433aca94dSKalle Valo 17533aca94dSKalle Valo /* 17633aca94dSKalle Valo * Interrupt context handlers. 17733aca94dSKalle Valo */ 17833aca94dSKalle Valo static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac, 17933aca94dSKalle Valo struct ieee80211_vif *vif) 18033aca94dSKalle Valo { 18133aca94dSKalle Valo struct ieee80211_tx_control control = {}; 18233aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data; 18333aca94dSKalle Valo struct sk_buff *skb; 18433aca94dSKalle Valo 18533aca94dSKalle Valo /* 18633aca94dSKalle Valo * Only AP mode interfaces do broad- and multicast buffering 18733aca94dSKalle Valo */ 18833aca94dSKalle Valo if (vif->type != NL80211_IFTYPE_AP) 18933aca94dSKalle Valo return; 19033aca94dSKalle Valo 19133aca94dSKalle Valo /* 19233aca94dSKalle Valo * Send out buffered broad- and multicast frames 19333aca94dSKalle Valo */ 19433aca94dSKalle Valo skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif); 19533aca94dSKalle Valo while (skb) { 19633aca94dSKalle Valo rt2x00mac_tx(rt2x00dev->hw, &control, skb); 19733aca94dSKalle Valo skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif); 19833aca94dSKalle Valo } 19933aca94dSKalle Valo } 20033aca94dSKalle Valo 20133aca94dSKalle Valo static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac, 20233aca94dSKalle Valo struct ieee80211_vif *vif) 20333aca94dSKalle Valo { 20433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data; 20533aca94dSKalle Valo 20633aca94dSKalle Valo if (vif->type != NL80211_IFTYPE_AP && 20733aca94dSKalle Valo vif->type != NL80211_IFTYPE_ADHOC && 20833aca94dSKalle Valo vif->type != NL80211_IFTYPE_MESH_POINT && 20933aca94dSKalle Valo vif->type != NL80211_IFTYPE_WDS) 21033aca94dSKalle Valo return; 21133aca94dSKalle Valo 21233aca94dSKalle Valo /* 21333aca94dSKalle Valo * Update the beacon without locking. This is safe on PCI devices 21433aca94dSKalle Valo * as they only update the beacon periodically here. This should 21533aca94dSKalle Valo * never be called for USB devices. 21633aca94dSKalle Valo */ 21733aca94dSKalle Valo WARN_ON(rt2x00_is_usb(rt2x00dev)); 21833aca94dSKalle Valo rt2x00queue_update_beacon(rt2x00dev, vif); 21933aca94dSKalle Valo } 22033aca94dSKalle Valo 22133aca94dSKalle Valo void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev) 22233aca94dSKalle Valo { 22333aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 22433aca94dSKalle Valo return; 22533aca94dSKalle Valo 22633aca94dSKalle Valo /* send buffered bc/mc frames out for every bssid */ 22733aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic( 22833aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 22933aca94dSKalle Valo rt2x00lib_bc_buffer_iter, rt2x00dev); 23033aca94dSKalle Valo /* 23133aca94dSKalle Valo * Devices with pre tbtt interrupt don't need to update the beacon 23233aca94dSKalle Valo * here as they will fetch the next beacon directly prior to 23333aca94dSKalle Valo * transmission. 23433aca94dSKalle Valo */ 23533aca94dSKalle Valo if (rt2x00_has_cap_pre_tbtt_interrupt(rt2x00dev)) 23633aca94dSKalle Valo return; 23733aca94dSKalle Valo 23833aca94dSKalle Valo /* fetch next beacon */ 23933aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic( 24033aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 24133aca94dSKalle Valo rt2x00lib_beaconupdate_iter, rt2x00dev); 24233aca94dSKalle Valo } 24333aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_beacondone); 24433aca94dSKalle Valo 24533aca94dSKalle Valo void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev) 24633aca94dSKalle Valo { 24733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 24833aca94dSKalle Valo return; 24933aca94dSKalle Valo 25033aca94dSKalle Valo /* fetch next beacon */ 25133aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic( 25233aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL, 25333aca94dSKalle Valo rt2x00lib_beaconupdate_iter, rt2x00dev); 25433aca94dSKalle Valo } 25533aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt); 25633aca94dSKalle Valo 25733aca94dSKalle Valo void rt2x00lib_dmastart(struct queue_entry *entry) 25833aca94dSKalle Valo { 25933aca94dSKalle Valo set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags); 26033aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX); 26133aca94dSKalle Valo } 26233aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_dmastart); 26333aca94dSKalle Valo 26433aca94dSKalle Valo void rt2x00lib_dmadone(struct queue_entry *entry) 26533aca94dSKalle Valo { 26633aca94dSKalle Valo set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags); 26733aca94dSKalle Valo clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags); 26833aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE); 26933aca94dSKalle Valo } 27033aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_dmadone); 27133aca94dSKalle Valo 27233aca94dSKalle Valo static inline int rt2x00lib_txdone_bar_status(struct queue_entry *entry) 27333aca94dSKalle Valo { 27433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 27533aca94dSKalle Valo struct ieee80211_bar *bar = (void *) entry->skb->data; 27633aca94dSKalle Valo struct rt2x00_bar_list_entry *bar_entry; 27733aca94dSKalle Valo int ret; 27833aca94dSKalle Valo 27933aca94dSKalle Valo if (likely(!ieee80211_is_back_req(bar->frame_control))) 28033aca94dSKalle Valo return 0; 28133aca94dSKalle Valo 28233aca94dSKalle Valo /* 28333aca94dSKalle Valo * Unlike all other frames, the status report for BARs does 28433aca94dSKalle Valo * not directly come from the hardware as it is incapable of 28533aca94dSKalle Valo * matching a BA to a previously send BAR. The hardware will 28633aca94dSKalle Valo * report all BARs as if they weren't acked at all. 28733aca94dSKalle Valo * 28833aca94dSKalle Valo * Instead the RX-path will scan for incoming BAs and set the 28933aca94dSKalle Valo * block_acked flag if it sees one that was likely caused by 29033aca94dSKalle Valo * a BAR from us. 29133aca94dSKalle Valo * 29233aca94dSKalle Valo * Remove remaining BARs here and return their status for 29333aca94dSKalle Valo * TX done processing. 29433aca94dSKalle Valo */ 29533aca94dSKalle Valo ret = 0; 29633aca94dSKalle Valo rcu_read_lock(); 29733aca94dSKalle Valo list_for_each_entry_rcu(bar_entry, &rt2x00dev->bar_list, list) { 29833aca94dSKalle Valo if (bar_entry->entry != entry) 29933aca94dSKalle Valo continue; 30033aca94dSKalle Valo 30133aca94dSKalle Valo spin_lock_bh(&rt2x00dev->bar_list_lock); 30233aca94dSKalle Valo /* Return whether this BAR was blockacked or not */ 30333aca94dSKalle Valo ret = bar_entry->block_acked; 30433aca94dSKalle Valo /* Remove the BAR from our checklist */ 30533aca94dSKalle Valo list_del_rcu(&bar_entry->list); 30633aca94dSKalle Valo spin_unlock_bh(&rt2x00dev->bar_list_lock); 30733aca94dSKalle Valo kfree_rcu(bar_entry, head); 30833aca94dSKalle Valo 30933aca94dSKalle Valo break; 31033aca94dSKalle Valo } 31133aca94dSKalle Valo rcu_read_unlock(); 31233aca94dSKalle Valo 31333aca94dSKalle Valo return ret; 31433aca94dSKalle Valo } 31533aca94dSKalle Valo 31633aca94dSKalle Valo void rt2x00lib_txdone(struct queue_entry *entry, 31733aca94dSKalle Valo struct txdone_entry_desc *txdesc) 31833aca94dSKalle Valo { 31933aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 32033aca94dSKalle Valo struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb); 32133aca94dSKalle Valo struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 32233aca94dSKalle Valo unsigned int header_length, i; 32333aca94dSKalle Valo u8 rate_idx, rate_flags, retry_rates; 32433aca94dSKalle Valo u8 skbdesc_flags = skbdesc->flags; 32533aca94dSKalle Valo bool success; 32633aca94dSKalle Valo 32733aca94dSKalle Valo /* 32833aca94dSKalle Valo * Unmap the skb. 32933aca94dSKalle Valo */ 33033aca94dSKalle Valo rt2x00queue_unmap_skb(entry); 33133aca94dSKalle Valo 33233aca94dSKalle Valo /* 33333aca94dSKalle Valo * Remove the extra tx headroom from the skb. 33433aca94dSKalle Valo */ 33533aca94dSKalle Valo skb_pull(entry->skb, rt2x00dev->extra_tx_headroom); 33633aca94dSKalle Valo 33733aca94dSKalle Valo /* 33833aca94dSKalle Valo * Signal that the TX descriptor is no longer in the skb. 33933aca94dSKalle Valo */ 34033aca94dSKalle Valo skbdesc->flags &= ~SKBDESC_DESC_IN_SKB; 34133aca94dSKalle Valo 34233aca94dSKalle Valo /* 34333aca94dSKalle Valo * Determine the length of 802.11 header. 34433aca94dSKalle Valo */ 34533aca94dSKalle Valo header_length = ieee80211_get_hdrlen_from_skb(entry->skb); 34633aca94dSKalle Valo 34733aca94dSKalle Valo /* 34833aca94dSKalle Valo * Remove L2 padding which was added during 34933aca94dSKalle Valo */ 35033aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD)) 35133aca94dSKalle Valo rt2x00queue_remove_l2pad(entry->skb, header_length); 35233aca94dSKalle Valo 35333aca94dSKalle Valo /* 35433aca94dSKalle Valo * If the IV/EIV data was stripped from the frame before it was 35533aca94dSKalle Valo * passed to the hardware, we should now reinsert it again because 35633aca94dSKalle Valo * mac80211 will expect the same data to be present it the 35733aca94dSKalle Valo * frame as it was passed to us. 35833aca94dSKalle Valo */ 35933aca94dSKalle Valo if (rt2x00_has_cap_hw_crypto(rt2x00dev)) 36033aca94dSKalle Valo rt2x00crypto_tx_insert_iv(entry->skb, header_length); 36133aca94dSKalle Valo 36233aca94dSKalle Valo /* 36333aca94dSKalle Valo * Send frame to debugfs immediately, after this call is completed 36433aca94dSKalle Valo * we are going to overwrite the skb->cb array. 36533aca94dSKalle Valo */ 3662ceb8137SStanislaw Gruszka rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry); 36733aca94dSKalle Valo 36833aca94dSKalle Valo /* 36933aca94dSKalle Valo * Determine if the frame has been successfully transmitted and 37033aca94dSKalle Valo * remove BARs from our check list while checking for their 37133aca94dSKalle Valo * TX status. 37233aca94dSKalle Valo */ 37333aca94dSKalle Valo success = 37433aca94dSKalle Valo rt2x00lib_txdone_bar_status(entry) || 37533aca94dSKalle Valo test_bit(TXDONE_SUCCESS, &txdesc->flags) || 37633aca94dSKalle Valo test_bit(TXDONE_UNKNOWN, &txdesc->flags); 37733aca94dSKalle Valo 37833aca94dSKalle Valo /* 37933aca94dSKalle Valo * Update TX statistics. 38033aca94dSKalle Valo */ 38133aca94dSKalle Valo rt2x00dev->link.qual.tx_success += success; 38233aca94dSKalle Valo rt2x00dev->link.qual.tx_failed += !success; 38333aca94dSKalle Valo 38433aca94dSKalle Valo rate_idx = skbdesc->tx_rate_idx; 38533aca94dSKalle Valo rate_flags = skbdesc->tx_rate_flags; 38633aca94dSKalle Valo retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ? 38733aca94dSKalle Valo (txdesc->retry + 1) : 1; 38833aca94dSKalle Valo 38933aca94dSKalle Valo /* 39033aca94dSKalle Valo * Initialize TX status 39133aca94dSKalle Valo */ 39233aca94dSKalle Valo memset(&tx_info->status, 0, sizeof(tx_info->status)); 39333aca94dSKalle Valo tx_info->status.ack_signal = 0; 39433aca94dSKalle Valo 39533aca94dSKalle Valo /* 39633aca94dSKalle Valo * Frame was send with retries, hardware tried 39733aca94dSKalle Valo * different rates to send out the frame, at each 39833aca94dSKalle Valo * retry it lowered the rate 1 step except when the 39933aca94dSKalle Valo * lowest rate was used. 40033aca94dSKalle Valo */ 40133aca94dSKalle Valo for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) { 40233aca94dSKalle Valo tx_info->status.rates[i].idx = rate_idx - i; 40333aca94dSKalle Valo tx_info->status.rates[i].flags = rate_flags; 40433aca94dSKalle Valo 40533aca94dSKalle Valo if (rate_idx - i == 0) { 40633aca94dSKalle Valo /* 40733aca94dSKalle Valo * The lowest rate (index 0) was used until the 40833aca94dSKalle Valo * number of max retries was reached. 40933aca94dSKalle Valo */ 41033aca94dSKalle Valo tx_info->status.rates[i].count = retry_rates - i; 41133aca94dSKalle Valo i++; 41233aca94dSKalle Valo break; 41333aca94dSKalle Valo } 41433aca94dSKalle Valo tx_info->status.rates[i].count = 1; 41533aca94dSKalle Valo } 41633aca94dSKalle Valo if (i < (IEEE80211_TX_MAX_RATES - 1)) 41733aca94dSKalle Valo tx_info->status.rates[i].idx = -1; /* terminate */ 41833aca94dSKalle Valo 41933aca94dSKalle Valo if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) { 42033aca94dSKalle Valo if (success) 42133aca94dSKalle Valo tx_info->flags |= IEEE80211_TX_STAT_ACK; 42233aca94dSKalle Valo else 42333aca94dSKalle Valo rt2x00dev->low_level_stats.dot11ACKFailureCount++; 42433aca94dSKalle Valo } 42533aca94dSKalle Valo 42633aca94dSKalle Valo /* 42733aca94dSKalle Valo * Every single frame has it's own tx status, hence report 42833aca94dSKalle Valo * every frame as ampdu of size 1. 42933aca94dSKalle Valo * 43033aca94dSKalle Valo * TODO: if we can find out how many frames were aggregated 43133aca94dSKalle Valo * by the hw we could provide the real ampdu_len to mac80211 43233aca94dSKalle Valo * which would allow the rc algorithm to better decide on 43333aca94dSKalle Valo * which rates are suitable. 43433aca94dSKalle Valo */ 43533aca94dSKalle Valo if (test_bit(TXDONE_AMPDU, &txdesc->flags) || 43633aca94dSKalle Valo tx_info->flags & IEEE80211_TX_CTL_AMPDU) { 43733aca94dSKalle Valo tx_info->flags |= IEEE80211_TX_STAT_AMPDU; 43833aca94dSKalle Valo tx_info->status.ampdu_len = 1; 43933aca94dSKalle Valo tx_info->status.ampdu_ack_len = success ? 1 : 0; 44033aca94dSKalle Valo 44133aca94dSKalle Valo if (!success) 44233aca94dSKalle Valo tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK; 44333aca94dSKalle Valo } 44433aca94dSKalle Valo 44533aca94dSKalle Valo if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) { 44633aca94dSKalle Valo if (success) 44733aca94dSKalle Valo rt2x00dev->low_level_stats.dot11RTSSuccessCount++; 44833aca94dSKalle Valo else 44933aca94dSKalle Valo rt2x00dev->low_level_stats.dot11RTSFailureCount++; 45033aca94dSKalle Valo } 45133aca94dSKalle Valo 45233aca94dSKalle Valo /* 45333aca94dSKalle Valo * Only send the status report to mac80211 when it's a frame 45433aca94dSKalle Valo * that originated in mac80211. If this was a extra frame coming 45533aca94dSKalle Valo * through a mac80211 library call (RTS/CTS) then we should not 45633aca94dSKalle Valo * send the status report back. 45733aca94dSKalle Valo */ 45833aca94dSKalle Valo if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) { 45933aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TASKLET_CONTEXT)) 46033aca94dSKalle Valo ieee80211_tx_status(rt2x00dev->hw, entry->skb); 46133aca94dSKalle Valo else 46233aca94dSKalle Valo ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb); 46333aca94dSKalle Valo } else 46433aca94dSKalle Valo dev_kfree_skb_any(entry->skb); 46533aca94dSKalle Valo 46633aca94dSKalle Valo /* 46733aca94dSKalle Valo * Make this entry available for reuse. 46833aca94dSKalle Valo */ 46933aca94dSKalle Valo entry->skb = NULL; 47033aca94dSKalle Valo entry->flags = 0; 47133aca94dSKalle Valo 47233aca94dSKalle Valo rt2x00dev->ops->lib->clear_entry(entry); 47333aca94dSKalle Valo 47433aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX_DONE); 47533aca94dSKalle Valo 47633aca94dSKalle Valo /* 47733aca94dSKalle Valo * If the data queue was below the threshold before the txdone 47833aca94dSKalle Valo * handler we must make sure the packet queue in the mac80211 stack 47933aca94dSKalle Valo * is reenabled when the txdone handler has finished. This has to be 48033aca94dSKalle Valo * serialized with rt2x00mac_tx(), otherwise we can wake up queue 48133aca94dSKalle Valo * before it was stopped. 48233aca94dSKalle Valo */ 48333aca94dSKalle Valo spin_lock_bh(&entry->queue->tx_lock); 48433aca94dSKalle Valo if (!rt2x00queue_threshold(entry->queue)) 48533aca94dSKalle Valo rt2x00queue_unpause_queue(entry->queue); 48633aca94dSKalle Valo spin_unlock_bh(&entry->queue->tx_lock); 48733aca94dSKalle Valo } 48833aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_txdone); 48933aca94dSKalle Valo 49033aca94dSKalle Valo void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status) 49133aca94dSKalle Valo { 49233aca94dSKalle Valo struct txdone_entry_desc txdesc; 49333aca94dSKalle Valo 49433aca94dSKalle Valo txdesc.flags = 0; 49533aca94dSKalle Valo __set_bit(status, &txdesc.flags); 49633aca94dSKalle Valo txdesc.retry = 0; 49733aca94dSKalle Valo 49833aca94dSKalle Valo rt2x00lib_txdone(entry, &txdesc); 49933aca94dSKalle Valo } 50033aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo); 50133aca94dSKalle Valo 50233aca94dSKalle Valo static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie) 50333aca94dSKalle Valo { 50433aca94dSKalle Valo struct ieee80211_mgmt *mgmt = (void *)data; 50533aca94dSKalle Valo u8 *pos, *end; 50633aca94dSKalle Valo 50733aca94dSKalle Valo pos = (u8 *)mgmt->u.beacon.variable; 50833aca94dSKalle Valo end = data + len; 50933aca94dSKalle Valo while (pos < end) { 51033aca94dSKalle Valo if (pos + 2 + pos[1] > end) 51133aca94dSKalle Valo return NULL; 51233aca94dSKalle Valo 51333aca94dSKalle Valo if (pos[0] == ie) 51433aca94dSKalle Valo return pos; 51533aca94dSKalle Valo 51633aca94dSKalle Valo pos += 2 + pos[1]; 51733aca94dSKalle Valo } 51833aca94dSKalle Valo 51933aca94dSKalle Valo return NULL; 52033aca94dSKalle Valo } 52133aca94dSKalle Valo 52233aca94dSKalle Valo static void rt2x00lib_sleep(struct work_struct *work) 52333aca94dSKalle Valo { 52433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = 52533aca94dSKalle Valo container_of(work, struct rt2x00_dev, sleep_work); 52633aca94dSKalle Valo 52733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 52833aca94dSKalle Valo return; 52933aca94dSKalle Valo 53033aca94dSKalle Valo /* 53133aca94dSKalle Valo * Check again is powersaving is enabled, to prevent races from delayed 53233aca94dSKalle Valo * work execution. 53333aca94dSKalle Valo */ 53433aca94dSKalle Valo if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags)) 53533aca94dSKalle Valo rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 53633aca94dSKalle Valo IEEE80211_CONF_CHANGE_PS); 53733aca94dSKalle Valo } 53833aca94dSKalle Valo 53933aca94dSKalle Valo static void rt2x00lib_rxdone_check_ba(struct rt2x00_dev *rt2x00dev, 54033aca94dSKalle Valo struct sk_buff *skb, 54133aca94dSKalle Valo struct rxdone_entry_desc *rxdesc) 54233aca94dSKalle Valo { 54333aca94dSKalle Valo struct rt2x00_bar_list_entry *entry; 54433aca94dSKalle Valo struct ieee80211_bar *ba = (void *)skb->data; 54533aca94dSKalle Valo 54633aca94dSKalle Valo if (likely(!ieee80211_is_back(ba->frame_control))) 54733aca94dSKalle Valo return; 54833aca94dSKalle Valo 54933aca94dSKalle Valo if (rxdesc->size < sizeof(*ba) + FCS_LEN) 55033aca94dSKalle Valo return; 55133aca94dSKalle Valo 55233aca94dSKalle Valo rcu_read_lock(); 55333aca94dSKalle Valo list_for_each_entry_rcu(entry, &rt2x00dev->bar_list, list) { 55433aca94dSKalle Valo 55533aca94dSKalle Valo if (ba->start_seq_num != entry->start_seq_num) 55633aca94dSKalle Valo continue; 55733aca94dSKalle Valo 55833aca94dSKalle Valo #define TID_CHECK(a, b) ( \ 55933aca94dSKalle Valo ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) == \ 56033aca94dSKalle Valo ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK))) \ 56133aca94dSKalle Valo 56233aca94dSKalle Valo if (!TID_CHECK(ba->control, entry->control)) 56333aca94dSKalle Valo continue; 56433aca94dSKalle Valo 56533aca94dSKalle Valo #undef TID_CHECK 56633aca94dSKalle Valo 56733aca94dSKalle Valo if (!ether_addr_equal_64bits(ba->ra, entry->ta)) 56833aca94dSKalle Valo continue; 56933aca94dSKalle Valo 57033aca94dSKalle Valo if (!ether_addr_equal_64bits(ba->ta, entry->ra)) 57133aca94dSKalle Valo continue; 57233aca94dSKalle Valo 57333aca94dSKalle Valo /* Mark BAR since we received the according BA */ 57433aca94dSKalle Valo spin_lock_bh(&rt2x00dev->bar_list_lock); 57533aca94dSKalle Valo entry->block_acked = 1; 57633aca94dSKalle Valo spin_unlock_bh(&rt2x00dev->bar_list_lock); 57733aca94dSKalle Valo break; 57833aca94dSKalle Valo } 57933aca94dSKalle Valo rcu_read_unlock(); 58033aca94dSKalle Valo 58133aca94dSKalle Valo } 58233aca94dSKalle Valo 58333aca94dSKalle Valo static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev, 58433aca94dSKalle Valo struct sk_buff *skb, 58533aca94dSKalle Valo struct rxdone_entry_desc *rxdesc) 58633aca94dSKalle Valo { 58733aca94dSKalle Valo struct ieee80211_hdr *hdr = (void *) skb->data; 58833aca94dSKalle Valo struct ieee80211_tim_ie *tim_ie; 58933aca94dSKalle Valo u8 *tim; 59033aca94dSKalle Valo u8 tim_len; 59133aca94dSKalle Valo bool cam; 59233aca94dSKalle Valo 59333aca94dSKalle Valo /* If this is not a beacon, or if mac80211 has no powersaving 59433aca94dSKalle Valo * configured, or if the device is already in powersaving mode 59533aca94dSKalle Valo * we can exit now. */ 59633aca94dSKalle Valo if (likely(!ieee80211_is_beacon(hdr->frame_control) || 59733aca94dSKalle Valo !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS))) 59833aca94dSKalle Valo return; 59933aca94dSKalle Valo 60033aca94dSKalle Valo /* min. beacon length + FCS_LEN */ 60133aca94dSKalle Valo if (skb->len <= 40 + FCS_LEN) 60233aca94dSKalle Valo return; 60333aca94dSKalle Valo 60433aca94dSKalle Valo /* and only beacons from the associated BSSID, please */ 60533aca94dSKalle Valo if (!(rxdesc->dev_flags & RXDONE_MY_BSS) || 60633aca94dSKalle Valo !rt2x00dev->aid) 60733aca94dSKalle Valo return; 60833aca94dSKalle Valo 60933aca94dSKalle Valo rt2x00dev->last_beacon = jiffies; 61033aca94dSKalle Valo 61133aca94dSKalle Valo tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM); 61233aca94dSKalle Valo if (!tim) 61333aca94dSKalle Valo return; 61433aca94dSKalle Valo 61533aca94dSKalle Valo if (tim[1] < sizeof(*tim_ie)) 61633aca94dSKalle Valo return; 61733aca94dSKalle Valo 61833aca94dSKalle Valo tim_len = tim[1]; 61933aca94dSKalle Valo tim_ie = (struct ieee80211_tim_ie *) &tim[2]; 62033aca94dSKalle Valo 62133aca94dSKalle Valo /* Check whenever the PHY can be turned off again. */ 62233aca94dSKalle Valo 62333aca94dSKalle Valo /* 1. What about buffered unicast traffic for our AID? */ 62433aca94dSKalle Valo cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid); 62533aca94dSKalle Valo 62633aca94dSKalle Valo /* 2. Maybe the AP wants to send multicast/broadcast data? */ 62733aca94dSKalle Valo cam |= (tim_ie->bitmap_ctrl & 0x01); 62833aca94dSKalle Valo 62933aca94dSKalle Valo if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags)) 63033aca94dSKalle Valo queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work); 63133aca94dSKalle Valo } 63233aca94dSKalle Valo 63333aca94dSKalle Valo static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev, 63433aca94dSKalle Valo struct rxdone_entry_desc *rxdesc) 63533aca94dSKalle Valo { 63633aca94dSKalle Valo struct ieee80211_supported_band *sband; 63733aca94dSKalle Valo const struct rt2x00_rate *rate; 63833aca94dSKalle Valo unsigned int i; 63933aca94dSKalle Valo int signal = rxdesc->signal; 64033aca94dSKalle Valo int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK); 64133aca94dSKalle Valo 64233aca94dSKalle Valo switch (rxdesc->rate_mode) { 64333aca94dSKalle Valo case RATE_MODE_CCK: 64433aca94dSKalle Valo case RATE_MODE_OFDM: 64533aca94dSKalle Valo /* 64633aca94dSKalle Valo * For non-HT rates the MCS value needs to contain the 64733aca94dSKalle Valo * actually used rate modulation (CCK or OFDM). 64833aca94dSKalle Valo */ 64933aca94dSKalle Valo if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS) 65033aca94dSKalle Valo signal = RATE_MCS(rxdesc->rate_mode, signal); 65133aca94dSKalle Valo 65233aca94dSKalle Valo sband = &rt2x00dev->bands[rt2x00dev->curr_band]; 65333aca94dSKalle Valo for (i = 0; i < sband->n_bitrates; i++) { 65433aca94dSKalle Valo rate = rt2x00_get_rate(sband->bitrates[i].hw_value); 65533aca94dSKalle Valo if (((type == RXDONE_SIGNAL_PLCP) && 65633aca94dSKalle Valo (rate->plcp == signal)) || 65733aca94dSKalle Valo ((type == RXDONE_SIGNAL_BITRATE) && 65833aca94dSKalle Valo (rate->bitrate == signal)) || 65933aca94dSKalle Valo ((type == RXDONE_SIGNAL_MCS) && 66033aca94dSKalle Valo (rate->mcs == signal))) { 66133aca94dSKalle Valo return i; 66233aca94dSKalle Valo } 66333aca94dSKalle Valo } 66433aca94dSKalle Valo break; 66533aca94dSKalle Valo case RATE_MODE_HT_MIX: 66633aca94dSKalle Valo case RATE_MODE_HT_GREENFIELD: 66733aca94dSKalle Valo if (signal >= 0 && signal <= 76) 66833aca94dSKalle Valo return signal; 66933aca94dSKalle Valo break; 67033aca94dSKalle Valo default: 67133aca94dSKalle Valo break; 67233aca94dSKalle Valo } 67333aca94dSKalle Valo 67433aca94dSKalle Valo rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n", 67533aca94dSKalle Valo rxdesc->rate_mode, signal, type); 67633aca94dSKalle Valo return 0; 67733aca94dSKalle Valo } 67833aca94dSKalle Valo 67933aca94dSKalle Valo void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp) 68033aca94dSKalle Valo { 68133aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 68233aca94dSKalle Valo struct rxdone_entry_desc rxdesc; 68333aca94dSKalle Valo struct sk_buff *skb; 68433aca94dSKalle Valo struct ieee80211_rx_status *rx_status; 68533aca94dSKalle Valo unsigned int header_length; 68633aca94dSKalle Valo int rate_idx; 68733aca94dSKalle Valo 68833aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) || 68933aca94dSKalle Valo !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 69033aca94dSKalle Valo goto submit_entry; 69133aca94dSKalle Valo 69233aca94dSKalle Valo if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) 69333aca94dSKalle Valo goto submit_entry; 69433aca94dSKalle Valo 69533aca94dSKalle Valo /* 69633aca94dSKalle Valo * Allocate a new sk_buffer. If no new buffer available, drop the 69733aca94dSKalle Valo * received frame and reuse the existing buffer. 69833aca94dSKalle Valo */ 69933aca94dSKalle Valo skb = rt2x00queue_alloc_rxskb(entry, gfp); 70033aca94dSKalle Valo if (!skb) 70133aca94dSKalle Valo goto submit_entry; 70233aca94dSKalle Valo 70333aca94dSKalle Valo /* 70433aca94dSKalle Valo * Unmap the skb. 70533aca94dSKalle Valo */ 70633aca94dSKalle Valo rt2x00queue_unmap_skb(entry); 70733aca94dSKalle Valo 70833aca94dSKalle Valo /* 70933aca94dSKalle Valo * Extract the RXD details. 71033aca94dSKalle Valo */ 71133aca94dSKalle Valo memset(&rxdesc, 0, sizeof(rxdesc)); 71233aca94dSKalle Valo rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc); 71333aca94dSKalle Valo 71433aca94dSKalle Valo /* 71533aca94dSKalle Valo * Check for valid size in case we get corrupted descriptor from 71633aca94dSKalle Valo * hardware. 71733aca94dSKalle Valo */ 71833aca94dSKalle Valo if (unlikely(rxdesc.size == 0 || 71933aca94dSKalle Valo rxdesc.size > entry->queue->data_size)) { 72033aca94dSKalle Valo rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n", 72133aca94dSKalle Valo rxdesc.size, entry->queue->data_size); 72233aca94dSKalle Valo dev_kfree_skb(entry->skb); 72333aca94dSKalle Valo goto renew_skb; 72433aca94dSKalle Valo } 72533aca94dSKalle Valo 72633aca94dSKalle Valo /* 72733aca94dSKalle Valo * The data behind the ieee80211 header must be 72833aca94dSKalle Valo * aligned on a 4 byte boundary. 72933aca94dSKalle Valo */ 73033aca94dSKalle Valo header_length = ieee80211_get_hdrlen_from_skb(entry->skb); 73133aca94dSKalle Valo 73233aca94dSKalle Valo /* 73333aca94dSKalle Valo * Hardware might have stripped the IV/EIV/ICV data, 73433aca94dSKalle Valo * in that case it is possible that the data was 73533aca94dSKalle Valo * provided separately (through hardware descriptor) 73633aca94dSKalle Valo * in which case we should reinsert the data into the frame. 73733aca94dSKalle Valo */ 73833aca94dSKalle Valo if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) && 73933aca94dSKalle Valo (rxdesc.flags & RX_FLAG_IV_STRIPPED)) 74033aca94dSKalle Valo rt2x00crypto_rx_insert_iv(entry->skb, header_length, 74133aca94dSKalle Valo &rxdesc); 74233aca94dSKalle Valo else if (header_length && 74333aca94dSKalle Valo (rxdesc.size > header_length) && 74433aca94dSKalle Valo (rxdesc.dev_flags & RXDONE_L2PAD)) 74533aca94dSKalle Valo rt2x00queue_remove_l2pad(entry->skb, header_length); 74633aca94dSKalle Valo 74733aca94dSKalle Valo /* Trim buffer to correct size */ 74833aca94dSKalle Valo skb_trim(entry->skb, rxdesc.size); 74933aca94dSKalle Valo 75033aca94dSKalle Valo /* 75133aca94dSKalle Valo * Translate the signal to the correct bitrate index. 75233aca94dSKalle Valo */ 75333aca94dSKalle Valo rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc); 75433aca94dSKalle Valo if (rxdesc.rate_mode == RATE_MODE_HT_MIX || 75533aca94dSKalle Valo rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD) 75633aca94dSKalle Valo rxdesc.flags |= RX_FLAG_HT; 75733aca94dSKalle Valo 75833aca94dSKalle Valo /* 75933aca94dSKalle Valo * Check if this is a beacon, and more frames have been 76033aca94dSKalle Valo * buffered while we were in powersaving mode. 76133aca94dSKalle Valo */ 76233aca94dSKalle Valo rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc); 76333aca94dSKalle Valo 76433aca94dSKalle Valo /* 76533aca94dSKalle Valo * Check for incoming BlockAcks to match to the BlockAckReqs 76633aca94dSKalle Valo * we've send out. 76733aca94dSKalle Valo */ 76833aca94dSKalle Valo rt2x00lib_rxdone_check_ba(rt2x00dev, entry->skb, &rxdesc); 76933aca94dSKalle Valo 77033aca94dSKalle Valo /* 77133aca94dSKalle Valo * Update extra components 77233aca94dSKalle Valo */ 77333aca94dSKalle Valo rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc); 77433aca94dSKalle Valo rt2x00debug_update_crypto(rt2x00dev, &rxdesc); 7752ceb8137SStanislaw Gruszka rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry); 77633aca94dSKalle Valo 77733aca94dSKalle Valo /* 77833aca94dSKalle Valo * Initialize RX status information, and send frame 77933aca94dSKalle Valo * to mac80211. 78033aca94dSKalle Valo */ 78133aca94dSKalle Valo rx_status = IEEE80211_SKB_RXCB(entry->skb); 78233aca94dSKalle Valo 78333aca94dSKalle Valo /* Ensure that all fields of rx_status are initialized 78433aca94dSKalle Valo * properly. The skb->cb array was used for driver 78533aca94dSKalle Valo * specific informations, so rx_status might contain 78633aca94dSKalle Valo * garbage. 78733aca94dSKalle Valo */ 78833aca94dSKalle Valo memset(rx_status, 0, sizeof(*rx_status)); 78933aca94dSKalle Valo 79033aca94dSKalle Valo rx_status->mactime = rxdesc.timestamp; 79133aca94dSKalle Valo rx_status->band = rt2x00dev->curr_band; 79233aca94dSKalle Valo rx_status->freq = rt2x00dev->curr_freq; 79333aca94dSKalle Valo rx_status->rate_idx = rate_idx; 79433aca94dSKalle Valo rx_status->signal = rxdesc.rssi; 79533aca94dSKalle Valo rx_status->flag = rxdesc.flags; 79633aca94dSKalle Valo rx_status->antenna = rt2x00dev->link.ant.active.rx; 79733aca94dSKalle Valo 79833aca94dSKalle Valo ieee80211_rx_ni(rt2x00dev->hw, entry->skb); 79933aca94dSKalle Valo 80033aca94dSKalle Valo renew_skb: 80133aca94dSKalle Valo /* 80233aca94dSKalle Valo * Replace the skb with the freshly allocated one. 80333aca94dSKalle Valo */ 80433aca94dSKalle Valo entry->skb = skb; 80533aca94dSKalle Valo 80633aca94dSKalle Valo submit_entry: 80733aca94dSKalle Valo entry->flags = 0; 80833aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX_DONE); 80933aca94dSKalle Valo if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) && 81033aca94dSKalle Valo test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags)) 81133aca94dSKalle Valo rt2x00dev->ops->lib->clear_entry(entry); 81233aca94dSKalle Valo } 81333aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_rxdone); 81433aca94dSKalle Valo 81533aca94dSKalle Valo /* 81633aca94dSKalle Valo * Driver initialization handlers. 81733aca94dSKalle Valo */ 81833aca94dSKalle Valo const struct rt2x00_rate rt2x00_supported_rates[12] = { 81933aca94dSKalle Valo { 82033aca94dSKalle Valo .flags = DEV_RATE_CCK, 82133aca94dSKalle Valo .bitrate = 10, 82233aca94dSKalle Valo .ratemask = BIT(0), 82333aca94dSKalle Valo .plcp = 0x00, 82433aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 0), 82533aca94dSKalle Valo }, 82633aca94dSKalle Valo { 82733aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 82833aca94dSKalle Valo .bitrate = 20, 82933aca94dSKalle Valo .ratemask = BIT(1), 83033aca94dSKalle Valo .plcp = 0x01, 83133aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 1), 83233aca94dSKalle Valo }, 83333aca94dSKalle Valo { 83433aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 83533aca94dSKalle Valo .bitrate = 55, 83633aca94dSKalle Valo .ratemask = BIT(2), 83733aca94dSKalle Valo .plcp = 0x02, 83833aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 2), 83933aca94dSKalle Valo }, 84033aca94dSKalle Valo { 84133aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE, 84233aca94dSKalle Valo .bitrate = 110, 84333aca94dSKalle Valo .ratemask = BIT(3), 84433aca94dSKalle Valo .plcp = 0x03, 84533aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 3), 84633aca94dSKalle Valo }, 84733aca94dSKalle Valo { 84833aca94dSKalle Valo .flags = DEV_RATE_OFDM, 84933aca94dSKalle Valo .bitrate = 60, 85033aca94dSKalle Valo .ratemask = BIT(4), 85133aca94dSKalle Valo .plcp = 0x0b, 85233aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 0), 85333aca94dSKalle Valo }, 85433aca94dSKalle Valo { 85533aca94dSKalle Valo .flags = DEV_RATE_OFDM, 85633aca94dSKalle Valo .bitrate = 90, 85733aca94dSKalle Valo .ratemask = BIT(5), 85833aca94dSKalle Valo .plcp = 0x0f, 85933aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 1), 86033aca94dSKalle Valo }, 86133aca94dSKalle Valo { 86233aca94dSKalle Valo .flags = DEV_RATE_OFDM, 86333aca94dSKalle Valo .bitrate = 120, 86433aca94dSKalle Valo .ratemask = BIT(6), 86533aca94dSKalle Valo .plcp = 0x0a, 86633aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 2), 86733aca94dSKalle Valo }, 86833aca94dSKalle Valo { 86933aca94dSKalle Valo .flags = DEV_RATE_OFDM, 87033aca94dSKalle Valo .bitrate = 180, 87133aca94dSKalle Valo .ratemask = BIT(7), 87233aca94dSKalle Valo .plcp = 0x0e, 87333aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 3), 87433aca94dSKalle Valo }, 87533aca94dSKalle Valo { 87633aca94dSKalle Valo .flags = DEV_RATE_OFDM, 87733aca94dSKalle Valo .bitrate = 240, 87833aca94dSKalle Valo .ratemask = BIT(8), 87933aca94dSKalle Valo .plcp = 0x09, 88033aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 4), 88133aca94dSKalle Valo }, 88233aca94dSKalle Valo { 88333aca94dSKalle Valo .flags = DEV_RATE_OFDM, 88433aca94dSKalle Valo .bitrate = 360, 88533aca94dSKalle Valo .ratemask = BIT(9), 88633aca94dSKalle Valo .plcp = 0x0d, 88733aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 5), 88833aca94dSKalle Valo }, 88933aca94dSKalle Valo { 89033aca94dSKalle Valo .flags = DEV_RATE_OFDM, 89133aca94dSKalle Valo .bitrate = 480, 89233aca94dSKalle Valo .ratemask = BIT(10), 89333aca94dSKalle Valo .plcp = 0x08, 89433aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 6), 89533aca94dSKalle Valo }, 89633aca94dSKalle Valo { 89733aca94dSKalle Valo .flags = DEV_RATE_OFDM, 89833aca94dSKalle Valo .bitrate = 540, 89933aca94dSKalle Valo .ratemask = BIT(11), 90033aca94dSKalle Valo .plcp = 0x0c, 90133aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 7), 90233aca94dSKalle Valo }, 90333aca94dSKalle Valo }; 90433aca94dSKalle Valo 90533aca94dSKalle Valo static void rt2x00lib_channel(struct ieee80211_channel *entry, 90633aca94dSKalle Valo const int channel, const int tx_power, 90733aca94dSKalle Valo const int value) 90833aca94dSKalle Valo { 90933aca94dSKalle Valo /* XXX: this assumption about the band is wrong for 802.11j */ 91057fbcce3SJohannes Berg entry->band = channel <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ; 91133aca94dSKalle Valo entry->center_freq = ieee80211_channel_to_frequency(channel, 91233aca94dSKalle Valo entry->band); 91333aca94dSKalle Valo entry->hw_value = value; 91433aca94dSKalle Valo entry->max_power = tx_power; 91533aca94dSKalle Valo entry->max_antenna_gain = 0xff; 91633aca94dSKalle Valo } 91733aca94dSKalle Valo 91833aca94dSKalle Valo static void rt2x00lib_rate(struct ieee80211_rate *entry, 91933aca94dSKalle Valo const u16 index, const struct rt2x00_rate *rate) 92033aca94dSKalle Valo { 92133aca94dSKalle Valo entry->flags = 0; 92233aca94dSKalle Valo entry->bitrate = rate->bitrate; 92333aca94dSKalle Valo entry->hw_value = index; 92433aca94dSKalle Valo entry->hw_value_short = index; 92533aca94dSKalle Valo 92633aca94dSKalle Valo if (rate->flags & DEV_RATE_SHORT_PREAMBLE) 92733aca94dSKalle Valo entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE; 92833aca94dSKalle Valo } 92933aca94dSKalle Valo 9309766cb70SMathias Kresin void rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr) 9319766cb70SMathias Kresin { 9329766cb70SMathias Kresin const char *mac_addr; 9339766cb70SMathias Kresin 9349766cb70SMathias Kresin mac_addr = of_get_mac_address(rt2x00dev->dev->of_node); 9359766cb70SMathias Kresin if (mac_addr) 9369766cb70SMathias Kresin ether_addr_copy(eeprom_mac_addr, mac_addr); 9379766cb70SMathias Kresin 9389766cb70SMathias Kresin if (!is_valid_ether_addr(eeprom_mac_addr)) { 9399766cb70SMathias Kresin eth_random_addr(eeprom_mac_addr); 9409766cb70SMathias Kresin rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", eeprom_mac_addr); 9419766cb70SMathias Kresin } 9429766cb70SMathias Kresin } 9439766cb70SMathias Kresin EXPORT_SYMBOL_GPL(rt2x00lib_set_mac_address); 9449766cb70SMathias Kresin 94533aca94dSKalle Valo static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev, 94633aca94dSKalle Valo struct hw_mode_spec *spec) 94733aca94dSKalle Valo { 94833aca94dSKalle Valo struct ieee80211_hw *hw = rt2x00dev->hw; 94933aca94dSKalle Valo struct ieee80211_channel *channels; 95033aca94dSKalle Valo struct ieee80211_rate *rates; 95133aca94dSKalle Valo unsigned int num_rates; 95233aca94dSKalle Valo unsigned int i; 95333aca94dSKalle Valo 95433aca94dSKalle Valo num_rates = 0; 95533aca94dSKalle Valo if (spec->supported_rates & SUPPORT_RATE_CCK) 95633aca94dSKalle Valo num_rates += 4; 95733aca94dSKalle Valo if (spec->supported_rates & SUPPORT_RATE_OFDM) 95833aca94dSKalle Valo num_rates += 8; 95933aca94dSKalle Valo 96033aca94dSKalle Valo channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL); 96133aca94dSKalle Valo if (!channels) 96233aca94dSKalle Valo return -ENOMEM; 96333aca94dSKalle Valo 96433aca94dSKalle Valo rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL); 96533aca94dSKalle Valo if (!rates) 96633aca94dSKalle Valo goto exit_free_channels; 96733aca94dSKalle Valo 96833aca94dSKalle Valo /* 96933aca94dSKalle Valo * Initialize Rate list. 97033aca94dSKalle Valo */ 97133aca94dSKalle Valo for (i = 0; i < num_rates; i++) 97233aca94dSKalle Valo rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i)); 97333aca94dSKalle Valo 97433aca94dSKalle Valo /* 97533aca94dSKalle Valo * Initialize Channel list. 97633aca94dSKalle Valo */ 97733aca94dSKalle Valo for (i = 0; i < spec->num_channels; i++) { 97833aca94dSKalle Valo rt2x00lib_channel(&channels[i], 97933aca94dSKalle Valo spec->channels[i].channel, 98033aca94dSKalle Valo spec->channels_info[i].max_power, i); 98133aca94dSKalle Valo } 98233aca94dSKalle Valo 98333aca94dSKalle Valo /* 98433aca94dSKalle Valo * Intitialize 802.11b, 802.11g 98533aca94dSKalle Valo * Rates: CCK, OFDM. 98633aca94dSKalle Valo * Channels: 2.4 GHz 98733aca94dSKalle Valo */ 98833aca94dSKalle Valo if (spec->supported_bands & SUPPORT_BAND_2GHZ) { 98957fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].n_channels = 14; 99057fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].n_bitrates = num_rates; 99157fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].channels = channels; 99257fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].bitrates = rates; 99357fbcce3SJohannes Berg hw->wiphy->bands[NL80211_BAND_2GHZ] = 99457fbcce3SJohannes Berg &rt2x00dev->bands[NL80211_BAND_2GHZ]; 99557fbcce3SJohannes Berg memcpy(&rt2x00dev->bands[NL80211_BAND_2GHZ].ht_cap, 99633aca94dSKalle Valo &spec->ht, sizeof(spec->ht)); 99733aca94dSKalle Valo } 99833aca94dSKalle Valo 99933aca94dSKalle Valo /* 100033aca94dSKalle Valo * Intitialize 802.11a 100133aca94dSKalle Valo * Rates: OFDM. 100233aca94dSKalle Valo * Channels: OFDM, UNII, HiperLAN2. 100333aca94dSKalle Valo */ 100433aca94dSKalle Valo if (spec->supported_bands & SUPPORT_BAND_5GHZ) { 100557fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].n_channels = 100633aca94dSKalle Valo spec->num_channels - 14; 100757fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].n_bitrates = 100833aca94dSKalle Valo num_rates - 4; 100957fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].channels = &channels[14]; 101057fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].bitrates = &rates[4]; 101157fbcce3SJohannes Berg hw->wiphy->bands[NL80211_BAND_5GHZ] = 101257fbcce3SJohannes Berg &rt2x00dev->bands[NL80211_BAND_5GHZ]; 101357fbcce3SJohannes Berg memcpy(&rt2x00dev->bands[NL80211_BAND_5GHZ].ht_cap, 101433aca94dSKalle Valo &spec->ht, sizeof(spec->ht)); 101533aca94dSKalle Valo } 101633aca94dSKalle Valo 101733aca94dSKalle Valo return 0; 101833aca94dSKalle Valo 101933aca94dSKalle Valo exit_free_channels: 102033aca94dSKalle Valo kfree(channels); 102133aca94dSKalle Valo rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n"); 102233aca94dSKalle Valo return -ENOMEM; 102333aca94dSKalle Valo } 102433aca94dSKalle Valo 102533aca94dSKalle Valo static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev) 102633aca94dSKalle Valo { 102733aca94dSKalle Valo if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags)) 102833aca94dSKalle Valo ieee80211_unregister_hw(rt2x00dev->hw); 102933aca94dSKalle Valo 103057fbcce3SJohannes Berg if (likely(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ])) { 103157fbcce3SJohannes Berg kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels); 103257fbcce3SJohannes Berg kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->bitrates); 103357fbcce3SJohannes Berg rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL; 103457fbcce3SJohannes Berg rt2x00dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL; 103533aca94dSKalle Valo } 103633aca94dSKalle Valo 103733aca94dSKalle Valo kfree(rt2x00dev->spec.channels_info); 103833aca94dSKalle Valo } 103933aca94dSKalle Valo 104033aca94dSKalle Valo static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev) 104133aca94dSKalle Valo { 104233aca94dSKalle Valo struct hw_mode_spec *spec = &rt2x00dev->spec; 104333aca94dSKalle Valo int status; 104433aca94dSKalle Valo 104533aca94dSKalle Valo if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags)) 104633aca94dSKalle Valo return 0; 104733aca94dSKalle Valo 104833aca94dSKalle Valo /* 104933aca94dSKalle Valo * Initialize HW modes. 105033aca94dSKalle Valo */ 105133aca94dSKalle Valo status = rt2x00lib_probe_hw_modes(rt2x00dev, spec); 105233aca94dSKalle Valo if (status) 105333aca94dSKalle Valo return status; 105433aca94dSKalle Valo 105533aca94dSKalle Valo /* 105633aca94dSKalle Valo * Initialize HW fields. 105733aca94dSKalle Valo */ 105833aca94dSKalle Valo rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues; 105933aca94dSKalle Valo 106033aca94dSKalle Valo /* 106133aca94dSKalle Valo * Initialize extra TX headroom required. 106233aca94dSKalle Valo */ 106333aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom = 106433aca94dSKalle Valo max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM, 106533aca94dSKalle Valo rt2x00dev->extra_tx_headroom); 106633aca94dSKalle Valo 106733aca94dSKalle Valo /* 106833aca94dSKalle Valo * Take TX headroom required for alignment into account. 106933aca94dSKalle Valo */ 107033aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD)) 107133aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE; 107233aca94dSKalle Valo else if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA)) 107333aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE; 107433aca94dSKalle Valo 107533aca94dSKalle Valo /* 107633aca94dSKalle Valo * Tell mac80211 about the size of our private STA structure. 107733aca94dSKalle Valo */ 107833aca94dSKalle Valo rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta); 107933aca94dSKalle Valo 108033aca94dSKalle Valo /* 108133aca94dSKalle Valo * Allocate tx status FIFO for driver use. 108233aca94dSKalle Valo */ 108333aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO)) { 108433aca94dSKalle Valo /* 108533aca94dSKalle Valo * Allocate the txstatus fifo. In the worst case the tx 108633aca94dSKalle Valo * status fifo has to hold the tx status of all entries 108733aca94dSKalle Valo * in all tx queues. Hence, calculate the kfifo size as 108833aca94dSKalle Valo * tx_queues * entry_num and round up to the nearest 108933aca94dSKalle Valo * power of 2. 109033aca94dSKalle Valo */ 109133aca94dSKalle Valo int kfifo_size = 109233aca94dSKalle Valo roundup_pow_of_two(rt2x00dev->ops->tx_queues * 109333aca94dSKalle Valo rt2x00dev->tx->limit * 109433aca94dSKalle Valo sizeof(u32)); 109533aca94dSKalle Valo 109633aca94dSKalle Valo status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size, 109733aca94dSKalle Valo GFP_KERNEL); 109833aca94dSKalle Valo if (status) 109933aca94dSKalle Valo return status; 110033aca94dSKalle Valo } 110133aca94dSKalle Valo 110233aca94dSKalle Valo /* 110333aca94dSKalle Valo * Initialize tasklets if used by the driver. Tasklets are 110433aca94dSKalle Valo * disabled until the interrupts are turned on. The driver 110533aca94dSKalle Valo * has to handle that. 110633aca94dSKalle Valo */ 110733aca94dSKalle Valo #define RT2X00_TASKLET_INIT(taskletname) \ 110833aca94dSKalle Valo if (rt2x00dev->ops->lib->taskletname) { \ 110933aca94dSKalle Valo tasklet_init(&rt2x00dev->taskletname, \ 111033aca94dSKalle Valo rt2x00dev->ops->lib->taskletname, \ 111133aca94dSKalle Valo (unsigned long)rt2x00dev); \ 111233aca94dSKalle Valo } 111333aca94dSKalle Valo 111433aca94dSKalle Valo RT2X00_TASKLET_INIT(txstatus_tasklet); 111533aca94dSKalle Valo RT2X00_TASKLET_INIT(pretbtt_tasklet); 111633aca94dSKalle Valo RT2X00_TASKLET_INIT(tbtt_tasklet); 111733aca94dSKalle Valo RT2X00_TASKLET_INIT(rxdone_tasklet); 111833aca94dSKalle Valo RT2X00_TASKLET_INIT(autowake_tasklet); 111933aca94dSKalle Valo 112033aca94dSKalle Valo #undef RT2X00_TASKLET_INIT 112133aca94dSKalle Valo 112233aca94dSKalle Valo /* 112333aca94dSKalle Valo * Register HW. 112433aca94dSKalle Valo */ 112533aca94dSKalle Valo status = ieee80211_register_hw(rt2x00dev->hw); 112633aca94dSKalle Valo if (status) 112733aca94dSKalle Valo return status; 112833aca94dSKalle Valo 112933aca94dSKalle Valo set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags); 113033aca94dSKalle Valo 113133aca94dSKalle Valo return 0; 113233aca94dSKalle Valo } 113333aca94dSKalle Valo 113433aca94dSKalle Valo /* 113533aca94dSKalle Valo * Initialization/uninitialization handlers. 113633aca94dSKalle Valo */ 113733aca94dSKalle Valo static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev) 113833aca94dSKalle Valo { 113933aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags)) 114033aca94dSKalle Valo return; 114133aca94dSKalle Valo 114233aca94dSKalle Valo /* 114333aca94dSKalle Valo * Stop rfkill polling. 114433aca94dSKalle Valo */ 114533aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL)) 114633aca94dSKalle Valo rt2x00rfkill_unregister(rt2x00dev); 114733aca94dSKalle Valo 114833aca94dSKalle Valo /* 114933aca94dSKalle Valo * Allow the HW to uninitialize. 115033aca94dSKalle Valo */ 115133aca94dSKalle Valo rt2x00dev->ops->lib->uninitialize(rt2x00dev); 115233aca94dSKalle Valo 115333aca94dSKalle Valo /* 115433aca94dSKalle Valo * Free allocated queue entries. 115533aca94dSKalle Valo */ 115633aca94dSKalle Valo rt2x00queue_uninitialize(rt2x00dev); 115733aca94dSKalle Valo } 115833aca94dSKalle Valo 115933aca94dSKalle Valo static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev) 116033aca94dSKalle Valo { 116133aca94dSKalle Valo int status; 116233aca94dSKalle Valo 116333aca94dSKalle Valo if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags)) 116433aca94dSKalle Valo return 0; 116533aca94dSKalle Valo 116633aca94dSKalle Valo /* 116733aca94dSKalle Valo * Allocate all queue entries. 116833aca94dSKalle Valo */ 116933aca94dSKalle Valo status = rt2x00queue_initialize(rt2x00dev); 117033aca94dSKalle Valo if (status) 117133aca94dSKalle Valo return status; 117233aca94dSKalle Valo 117333aca94dSKalle Valo /* 117433aca94dSKalle Valo * Initialize the device. 117533aca94dSKalle Valo */ 117633aca94dSKalle Valo status = rt2x00dev->ops->lib->initialize(rt2x00dev); 117733aca94dSKalle Valo if (status) { 117833aca94dSKalle Valo rt2x00queue_uninitialize(rt2x00dev); 117933aca94dSKalle Valo return status; 118033aca94dSKalle Valo } 118133aca94dSKalle Valo 118233aca94dSKalle Valo set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags); 118333aca94dSKalle Valo 118433aca94dSKalle Valo /* 118533aca94dSKalle Valo * Start rfkill polling. 118633aca94dSKalle Valo */ 118733aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL)) 118833aca94dSKalle Valo rt2x00rfkill_register(rt2x00dev); 118933aca94dSKalle Valo 119033aca94dSKalle Valo return 0; 119133aca94dSKalle Valo } 119233aca94dSKalle Valo 119333aca94dSKalle Valo int rt2x00lib_start(struct rt2x00_dev *rt2x00dev) 119433aca94dSKalle Valo { 119533aca94dSKalle Valo int retval; 119633aca94dSKalle Valo 119733aca94dSKalle Valo if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags)) 119833aca94dSKalle Valo return 0; 119933aca94dSKalle Valo 120033aca94dSKalle Valo /* 120133aca94dSKalle Valo * If this is the first interface which is added, 120233aca94dSKalle Valo * we should load the firmware now. 120333aca94dSKalle Valo */ 120433aca94dSKalle Valo retval = rt2x00lib_load_firmware(rt2x00dev); 120533aca94dSKalle Valo if (retval) 120633aca94dSKalle Valo return retval; 120733aca94dSKalle Valo 120833aca94dSKalle Valo /* 120933aca94dSKalle Valo * Initialize the device. 121033aca94dSKalle Valo */ 121133aca94dSKalle Valo retval = rt2x00lib_initialize(rt2x00dev); 121233aca94dSKalle Valo if (retval) 121333aca94dSKalle Valo return retval; 121433aca94dSKalle Valo 121533aca94dSKalle Valo rt2x00dev->intf_ap_count = 0; 121633aca94dSKalle Valo rt2x00dev->intf_sta_count = 0; 121733aca94dSKalle Valo rt2x00dev->intf_associated = 0; 121833aca94dSKalle Valo 121933aca94dSKalle Valo /* Enable the radio */ 122033aca94dSKalle Valo retval = rt2x00lib_enable_radio(rt2x00dev); 122133aca94dSKalle Valo if (retval) 122233aca94dSKalle Valo return retval; 122333aca94dSKalle Valo 122433aca94dSKalle Valo set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags); 122533aca94dSKalle Valo 122633aca94dSKalle Valo return 0; 122733aca94dSKalle Valo } 122833aca94dSKalle Valo 122933aca94dSKalle Valo void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev) 123033aca94dSKalle Valo { 123133aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags)) 123233aca94dSKalle Valo return; 123333aca94dSKalle Valo 123433aca94dSKalle Valo /* 123533aca94dSKalle Valo * Perhaps we can add something smarter here, 123633aca94dSKalle Valo * but for now just disabling the radio should do. 123733aca94dSKalle Valo */ 123833aca94dSKalle Valo rt2x00lib_disable_radio(rt2x00dev); 123933aca94dSKalle Valo 124033aca94dSKalle Valo rt2x00dev->intf_ap_count = 0; 124133aca94dSKalle Valo rt2x00dev->intf_sta_count = 0; 124233aca94dSKalle Valo rt2x00dev->intf_associated = 0; 124333aca94dSKalle Valo } 124433aca94dSKalle Valo 124533aca94dSKalle Valo static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev) 124633aca94dSKalle Valo { 124733aca94dSKalle Valo struct ieee80211_iface_limit *if_limit; 124833aca94dSKalle Valo struct ieee80211_iface_combination *if_combination; 124933aca94dSKalle Valo 125033aca94dSKalle Valo if (rt2x00dev->ops->max_ap_intf < 2) 125133aca94dSKalle Valo return; 125233aca94dSKalle Valo 125333aca94dSKalle Valo /* 125433aca94dSKalle Valo * Build up AP interface limits structure. 125533aca94dSKalle Valo */ 125633aca94dSKalle Valo if_limit = &rt2x00dev->if_limits_ap; 125733aca94dSKalle Valo if_limit->max = rt2x00dev->ops->max_ap_intf; 125833aca94dSKalle Valo if_limit->types = BIT(NL80211_IFTYPE_AP); 125933aca94dSKalle Valo #ifdef CONFIG_MAC80211_MESH 126033aca94dSKalle Valo if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT); 126133aca94dSKalle Valo #endif 126233aca94dSKalle Valo 126333aca94dSKalle Valo /* 126433aca94dSKalle Valo * Build up AP interface combinations structure. 126533aca94dSKalle Valo */ 126633aca94dSKalle Valo if_combination = &rt2x00dev->if_combinations[IF_COMB_AP]; 126733aca94dSKalle Valo if_combination->limits = if_limit; 126833aca94dSKalle Valo if_combination->n_limits = 1; 126933aca94dSKalle Valo if_combination->max_interfaces = if_limit->max; 127033aca94dSKalle Valo if_combination->num_different_channels = 1; 127133aca94dSKalle Valo 127233aca94dSKalle Valo /* 127333aca94dSKalle Valo * Finally, specify the possible combinations to mac80211. 127433aca94dSKalle Valo */ 127533aca94dSKalle Valo rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations; 127633aca94dSKalle Valo rt2x00dev->hw->wiphy->n_iface_combinations = 1; 127733aca94dSKalle Valo } 127833aca94dSKalle Valo 127933aca94dSKalle Valo static unsigned int rt2x00dev_extra_tx_headroom(struct rt2x00_dev *rt2x00dev) 128033aca94dSKalle Valo { 128133aca94dSKalle Valo if (WARN_ON(!rt2x00dev->tx)) 128233aca94dSKalle Valo return 0; 128333aca94dSKalle Valo 128433aca94dSKalle Valo if (rt2x00_is_usb(rt2x00dev)) 128533aca94dSKalle Valo return rt2x00dev->tx[0].winfo_size + rt2x00dev->tx[0].desc_size; 128633aca94dSKalle Valo 128733aca94dSKalle Valo return rt2x00dev->tx[0].winfo_size; 128833aca94dSKalle Valo } 128933aca94dSKalle Valo 129033aca94dSKalle Valo /* 129133aca94dSKalle Valo * driver allocation handlers. 129233aca94dSKalle Valo */ 129333aca94dSKalle Valo int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev) 129433aca94dSKalle Valo { 129533aca94dSKalle Valo int retval = -ENOMEM; 129633aca94dSKalle Valo 129733aca94dSKalle Valo /* 129833aca94dSKalle Valo * Set possible interface combinations. 129933aca94dSKalle Valo */ 130033aca94dSKalle Valo rt2x00lib_set_if_combinations(rt2x00dev); 130133aca94dSKalle Valo 130233aca94dSKalle Valo /* 130333aca94dSKalle Valo * Allocate the driver data memory, if necessary. 130433aca94dSKalle Valo */ 130533aca94dSKalle Valo if (rt2x00dev->ops->drv_data_size > 0) { 130633aca94dSKalle Valo rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size, 130733aca94dSKalle Valo GFP_KERNEL); 130833aca94dSKalle Valo if (!rt2x00dev->drv_data) { 130933aca94dSKalle Valo retval = -ENOMEM; 131033aca94dSKalle Valo goto exit; 131133aca94dSKalle Valo } 131233aca94dSKalle Valo } 131333aca94dSKalle Valo 131433aca94dSKalle Valo spin_lock_init(&rt2x00dev->irqmask_lock); 131533aca94dSKalle Valo mutex_init(&rt2x00dev->csr_mutex); 1316c7d1c777SStanislaw Gruszka mutex_init(&rt2x00dev->conf_mutex); 131733aca94dSKalle Valo INIT_LIST_HEAD(&rt2x00dev->bar_list); 131833aca94dSKalle Valo spin_lock_init(&rt2x00dev->bar_list_lock); 131933aca94dSKalle Valo 132033aca94dSKalle Valo set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 132133aca94dSKalle Valo 132233aca94dSKalle Valo /* 132333aca94dSKalle Valo * Make room for rt2x00_intf inside the per-interface 132433aca94dSKalle Valo * structure ieee80211_vif. 132533aca94dSKalle Valo */ 132633aca94dSKalle Valo rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf); 132733aca94dSKalle Valo 132833aca94dSKalle Valo /* 132933aca94dSKalle Valo * rt2x00 devices can only use the last n bits of the MAC address 133033aca94dSKalle Valo * for virtual interfaces. 133133aca94dSKalle Valo */ 133233aca94dSKalle Valo rt2x00dev->hw->wiphy->addr_mask[ETH_ALEN - 1] = 133333aca94dSKalle Valo (rt2x00dev->ops->max_ap_intf - 1); 133433aca94dSKalle Valo 133533aca94dSKalle Valo /* 133633aca94dSKalle Valo * Initialize work. 133733aca94dSKalle Valo */ 133833aca94dSKalle Valo rt2x00dev->workqueue = 133933aca94dSKalle Valo alloc_ordered_workqueue("%s", 0, wiphy_name(rt2x00dev->hw->wiphy)); 134033aca94dSKalle Valo if (!rt2x00dev->workqueue) { 134133aca94dSKalle Valo retval = -ENOMEM; 134233aca94dSKalle Valo goto exit; 134333aca94dSKalle Valo } 134433aca94dSKalle Valo 134533aca94dSKalle Valo INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled); 134633aca94dSKalle Valo INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup); 134733aca94dSKalle Valo INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep); 134833aca94dSKalle Valo 134933aca94dSKalle Valo /* 135033aca94dSKalle Valo * Let the driver probe the device to detect the capabilities. 135133aca94dSKalle Valo */ 135233aca94dSKalle Valo retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev); 135333aca94dSKalle Valo if (retval) { 135433aca94dSKalle Valo rt2x00_err(rt2x00dev, "Failed to allocate device\n"); 135533aca94dSKalle Valo goto exit; 135633aca94dSKalle Valo } 135733aca94dSKalle Valo 135833aca94dSKalle Valo /* 135933aca94dSKalle Valo * Allocate queue array. 136033aca94dSKalle Valo */ 136133aca94dSKalle Valo retval = rt2x00queue_allocate(rt2x00dev); 136233aca94dSKalle Valo if (retval) 136333aca94dSKalle Valo goto exit; 136433aca94dSKalle Valo 136533aca94dSKalle Valo /* Cache TX headroom value */ 136633aca94dSKalle Valo rt2x00dev->extra_tx_headroom = rt2x00dev_extra_tx_headroom(rt2x00dev); 136733aca94dSKalle Valo 136833aca94dSKalle Valo /* 136933aca94dSKalle Valo * Determine which operating modes are supported, all modes 137033aca94dSKalle Valo * which require beaconing, depend on the availability of 137133aca94dSKalle Valo * beacon entries. 137233aca94dSKalle Valo */ 137333aca94dSKalle Valo rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION); 137433aca94dSKalle Valo if (rt2x00dev->bcn->limit > 0) 137533aca94dSKalle Valo rt2x00dev->hw->wiphy->interface_modes |= 137633aca94dSKalle Valo BIT(NL80211_IFTYPE_ADHOC) | 137733aca94dSKalle Valo #ifdef CONFIG_MAC80211_MESH 137833aca94dSKalle Valo BIT(NL80211_IFTYPE_MESH_POINT) | 137933aca94dSKalle Valo #endif 13808f205423SJohannes Berg #ifdef CONFIG_WIRELESS_WDS 13818f205423SJohannes Berg BIT(NL80211_IFTYPE_WDS) | 13828f205423SJohannes Berg #endif 13838f205423SJohannes Berg BIT(NL80211_IFTYPE_AP); 138433aca94dSKalle Valo 138533aca94dSKalle Valo rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN; 138633aca94dSKalle Valo 1387ae44b502SAndrew Zaborowski wiphy_ext_feature_set(rt2x00dev->hw->wiphy, 1388ae44b502SAndrew Zaborowski NL80211_EXT_FEATURE_CQM_RSSI_LIST); 1389ae44b502SAndrew Zaborowski 139033aca94dSKalle Valo /* 139133aca94dSKalle Valo * Initialize ieee80211 structure. 139233aca94dSKalle Valo */ 139333aca94dSKalle Valo retval = rt2x00lib_probe_hw(rt2x00dev); 139433aca94dSKalle Valo if (retval) { 139533aca94dSKalle Valo rt2x00_err(rt2x00dev, "Failed to initialize hw\n"); 139633aca94dSKalle Valo goto exit; 139733aca94dSKalle Valo } 139833aca94dSKalle Valo 139933aca94dSKalle Valo /* 140033aca94dSKalle Valo * Register extra components. 140133aca94dSKalle Valo */ 140233aca94dSKalle Valo rt2x00link_register(rt2x00dev); 140333aca94dSKalle Valo rt2x00leds_register(rt2x00dev); 140433aca94dSKalle Valo rt2x00debug_register(rt2x00dev); 140533aca94dSKalle Valo 140633aca94dSKalle Valo /* 140733aca94dSKalle Valo * Start rfkill polling. 140833aca94dSKalle Valo */ 140933aca94dSKalle Valo if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL)) 141033aca94dSKalle Valo rt2x00rfkill_register(rt2x00dev); 141133aca94dSKalle Valo 141233aca94dSKalle Valo return 0; 141333aca94dSKalle Valo 141433aca94dSKalle Valo exit: 141533aca94dSKalle Valo rt2x00lib_remove_dev(rt2x00dev); 141633aca94dSKalle Valo 141733aca94dSKalle Valo return retval; 141833aca94dSKalle Valo } 141933aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev); 142033aca94dSKalle Valo 142133aca94dSKalle Valo void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev) 142233aca94dSKalle Valo { 142333aca94dSKalle Valo clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 142433aca94dSKalle Valo 142533aca94dSKalle Valo /* 142633aca94dSKalle Valo * Stop rfkill polling. 142733aca94dSKalle Valo */ 142833aca94dSKalle Valo if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL)) 142933aca94dSKalle Valo rt2x00rfkill_unregister(rt2x00dev); 143033aca94dSKalle Valo 143133aca94dSKalle Valo /* 143233aca94dSKalle Valo * Disable radio. 143333aca94dSKalle Valo */ 143433aca94dSKalle Valo rt2x00lib_disable_radio(rt2x00dev); 143533aca94dSKalle Valo 143633aca94dSKalle Valo /* 143733aca94dSKalle Valo * Stop all work. 143833aca94dSKalle Valo */ 143933aca94dSKalle Valo cancel_work_sync(&rt2x00dev->intf_work); 144033aca94dSKalle Valo cancel_delayed_work_sync(&rt2x00dev->autowakeup_work); 144133aca94dSKalle Valo cancel_work_sync(&rt2x00dev->sleep_work); 144233aca94dSKalle Valo 144333aca94dSKalle Valo /* 144433aca94dSKalle Valo * Kill the tx status tasklet. 144533aca94dSKalle Valo */ 144633aca94dSKalle Valo tasklet_kill(&rt2x00dev->txstatus_tasklet); 144733aca94dSKalle Valo tasklet_kill(&rt2x00dev->pretbtt_tasklet); 144833aca94dSKalle Valo tasklet_kill(&rt2x00dev->tbtt_tasklet); 144933aca94dSKalle Valo tasklet_kill(&rt2x00dev->rxdone_tasklet); 145033aca94dSKalle Valo tasklet_kill(&rt2x00dev->autowake_tasklet); 145133aca94dSKalle Valo 145233aca94dSKalle Valo /* 145333aca94dSKalle Valo * Uninitialize device. 145433aca94dSKalle Valo */ 145533aca94dSKalle Valo rt2x00lib_uninitialize(rt2x00dev); 145633aca94dSKalle Valo 14576232c174SStanislaw Gruszka if (rt2x00dev->workqueue) 14586232c174SStanislaw Gruszka destroy_workqueue(rt2x00dev->workqueue); 14596232c174SStanislaw Gruszka 14606232c174SStanislaw Gruszka /* 14616232c174SStanislaw Gruszka * Free the tx status fifo. 14626232c174SStanislaw Gruszka */ 14636232c174SStanislaw Gruszka kfifo_free(&rt2x00dev->txstatus_fifo); 14646232c174SStanislaw Gruszka 146533aca94dSKalle Valo /* 146633aca94dSKalle Valo * Free extra components 146733aca94dSKalle Valo */ 146833aca94dSKalle Valo rt2x00debug_deregister(rt2x00dev); 146933aca94dSKalle Valo rt2x00leds_unregister(rt2x00dev); 147033aca94dSKalle Valo 147133aca94dSKalle Valo /* 147233aca94dSKalle Valo * Free ieee80211_hw memory. 147333aca94dSKalle Valo */ 147433aca94dSKalle Valo rt2x00lib_remove_hw(rt2x00dev); 147533aca94dSKalle Valo 147633aca94dSKalle Valo /* 147733aca94dSKalle Valo * Free firmware image. 147833aca94dSKalle Valo */ 147933aca94dSKalle Valo rt2x00lib_free_firmware(rt2x00dev); 148033aca94dSKalle Valo 148133aca94dSKalle Valo /* 148233aca94dSKalle Valo * Free queue structures. 148333aca94dSKalle Valo */ 148433aca94dSKalle Valo rt2x00queue_free(rt2x00dev); 148533aca94dSKalle Valo 148633aca94dSKalle Valo /* 148733aca94dSKalle Valo * Free the driver data. 148833aca94dSKalle Valo */ 148933aca94dSKalle Valo kfree(rt2x00dev->drv_data); 149033aca94dSKalle Valo } 149133aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev); 149233aca94dSKalle Valo 149333aca94dSKalle Valo /* 149433aca94dSKalle Valo * Device state handlers 149533aca94dSKalle Valo */ 149633aca94dSKalle Valo #ifdef CONFIG_PM 149733aca94dSKalle Valo int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state) 149833aca94dSKalle Valo { 149933aca94dSKalle Valo rt2x00_dbg(rt2x00dev, "Going to sleep\n"); 150033aca94dSKalle Valo 150133aca94dSKalle Valo /* 150233aca94dSKalle Valo * Prevent mac80211 from accessing driver while suspended. 150333aca94dSKalle Valo */ 150433aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 150533aca94dSKalle Valo return 0; 150633aca94dSKalle Valo 150733aca94dSKalle Valo /* 150833aca94dSKalle Valo * Cleanup as much as possible. 150933aca94dSKalle Valo */ 151033aca94dSKalle Valo rt2x00lib_uninitialize(rt2x00dev); 151133aca94dSKalle Valo 151233aca94dSKalle Valo /* 151333aca94dSKalle Valo * Suspend/disable extra components. 151433aca94dSKalle Valo */ 151533aca94dSKalle Valo rt2x00leds_suspend(rt2x00dev); 151633aca94dSKalle Valo rt2x00debug_deregister(rt2x00dev); 151733aca94dSKalle Valo 151833aca94dSKalle Valo /* 151933aca94dSKalle Valo * Set device mode to sleep for power management, 152033aca94dSKalle Valo * on some hardware this call seems to consistently fail. 152133aca94dSKalle Valo * From the specifications it is hard to tell why it fails, 152233aca94dSKalle Valo * and if this is a "bad thing". 152333aca94dSKalle Valo * Overall it is safe to just ignore the failure and 152433aca94dSKalle Valo * continue suspending. The only downside is that the 152533aca94dSKalle Valo * device will not be in optimal power save mode, but with 152633aca94dSKalle Valo * the radio and the other components already disabled the 152733aca94dSKalle Valo * device is as good as disabled. 152833aca94dSKalle Valo */ 152933aca94dSKalle Valo if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP)) 153033aca94dSKalle Valo rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n"); 153133aca94dSKalle Valo 153233aca94dSKalle Valo return 0; 153333aca94dSKalle Valo } 153433aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_suspend); 153533aca94dSKalle Valo 153633aca94dSKalle Valo int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev) 153733aca94dSKalle Valo { 153833aca94dSKalle Valo rt2x00_dbg(rt2x00dev, "Waking up\n"); 153933aca94dSKalle Valo 154033aca94dSKalle Valo /* 154133aca94dSKalle Valo * Restore/enable extra components. 154233aca94dSKalle Valo */ 154333aca94dSKalle Valo rt2x00debug_register(rt2x00dev); 154433aca94dSKalle Valo rt2x00leds_resume(rt2x00dev); 154533aca94dSKalle Valo 154633aca94dSKalle Valo /* 154733aca94dSKalle Valo * We are ready again to receive requests from mac80211. 154833aca94dSKalle Valo */ 154933aca94dSKalle Valo set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 155033aca94dSKalle Valo 155133aca94dSKalle Valo return 0; 155233aca94dSKalle Valo } 155333aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_resume); 155433aca94dSKalle Valo #endif /* CONFIG_PM */ 155533aca94dSKalle Valo 155633aca94dSKalle Valo /* 155733aca94dSKalle Valo * rt2x00lib module information. 155833aca94dSKalle Valo */ 155933aca94dSKalle Valo MODULE_AUTHOR(DRV_PROJECT); 156033aca94dSKalle Valo MODULE_VERSION(DRV_VERSION); 156133aca94dSKalle Valo MODULE_DESCRIPTION("rt2x00 library"); 156233aca94dSKalle Valo MODULE_LICENSE("GPL"); 1563