11ccea77eSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
233aca94dSKalle Valo /*
333aca94dSKalle Valo Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
433aca94dSKalle Valo Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
533aca94dSKalle Valo <http://rt2x00.serialmonkey.com>
633aca94dSKalle Valo
733aca94dSKalle Valo */
833aca94dSKalle Valo
933aca94dSKalle Valo /*
1033aca94dSKalle Valo Module: rt2x00lib
1133aca94dSKalle Valo Abstract: rt2x00 generic device routines.
1233aca94dSKalle Valo */
1333aca94dSKalle Valo
1433aca94dSKalle Valo #include <linux/kernel.h>
1533aca94dSKalle Valo #include <linux/module.h>
1633aca94dSKalle Valo #include <linux/slab.h>
1733aca94dSKalle Valo #include <linux/log2.h>
189766cb70SMathias Kresin #include <linux/of.h>
199766cb70SMathias Kresin #include <linux/of_net.h>
2033aca94dSKalle Valo
2133aca94dSKalle Valo #include "rt2x00.h"
2233aca94dSKalle Valo #include "rt2x00lib.h"
2333aca94dSKalle Valo
2433aca94dSKalle Valo /*
2533aca94dSKalle Valo * Utility functions.
2633aca94dSKalle Valo */
rt2x00lib_get_bssidx(struct rt2x00_dev * rt2x00dev,struct ieee80211_vif * vif)2733aca94dSKalle Valo u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
2833aca94dSKalle Valo struct ieee80211_vif *vif)
2933aca94dSKalle Valo {
3033aca94dSKalle Valo /*
3133aca94dSKalle Valo * When in STA mode, bssidx is always 0 otherwise local_address[5]
3233aca94dSKalle Valo * contains the bss number, see BSS_ID_MASK comments for details.
3333aca94dSKalle Valo */
3433aca94dSKalle Valo if (rt2x00dev->intf_sta_count)
3533aca94dSKalle Valo return 0;
3633aca94dSKalle Valo return vif->addr[5] & (rt2x00dev->ops->max_ap_intf - 1);
3733aca94dSKalle Valo }
3833aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_get_bssidx);
3933aca94dSKalle Valo
4033aca94dSKalle Valo /*
4133aca94dSKalle Valo * Radio control handlers.
4233aca94dSKalle Valo */
rt2x00lib_enable_radio(struct rt2x00_dev * rt2x00dev)4333aca94dSKalle Valo int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
4433aca94dSKalle Valo {
4533aca94dSKalle Valo int status;
4633aca94dSKalle Valo
4733aca94dSKalle Valo /*
4833aca94dSKalle Valo * Don't enable the radio twice.
4933aca94dSKalle Valo * And check if the hardware button has been disabled.
5033aca94dSKalle Valo */
5133aca94dSKalle Valo if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
5233aca94dSKalle Valo return 0;
5333aca94dSKalle Valo
5433aca94dSKalle Valo /*
5533aca94dSKalle Valo * Initialize all data queues.
5633aca94dSKalle Valo */
5733aca94dSKalle Valo rt2x00queue_init_queues(rt2x00dev);
5833aca94dSKalle Valo
5933aca94dSKalle Valo /*
6033aca94dSKalle Valo * Enable radio.
6133aca94dSKalle Valo */
6233aca94dSKalle Valo status =
6333aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
6433aca94dSKalle Valo if (status)
6533aca94dSKalle Valo return status;
6633aca94dSKalle Valo
6733aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
6833aca94dSKalle Valo
6933aca94dSKalle Valo rt2x00leds_led_radio(rt2x00dev, true);
7033aca94dSKalle Valo rt2x00led_led_activity(rt2x00dev, true);
7133aca94dSKalle Valo
7233aca94dSKalle Valo set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags);
7333aca94dSKalle Valo
7433aca94dSKalle Valo /*
7533aca94dSKalle Valo * Enable queues.
7633aca94dSKalle Valo */
7733aca94dSKalle Valo rt2x00queue_start_queues(rt2x00dev);
7833aca94dSKalle Valo rt2x00link_start_tuner(rt2x00dev);
7933aca94dSKalle Valo
8033aca94dSKalle Valo /*
8133aca94dSKalle Valo * Start watchdog monitoring.
8233aca94dSKalle Valo */
8333aca94dSKalle Valo rt2x00link_start_watchdog(rt2x00dev);
8433aca94dSKalle Valo
8533aca94dSKalle Valo return 0;
8633aca94dSKalle Valo }
8733aca94dSKalle Valo
rt2x00lib_disable_radio(struct rt2x00_dev * rt2x00dev)8833aca94dSKalle Valo void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
8933aca94dSKalle Valo {
9033aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
9133aca94dSKalle Valo return;
9233aca94dSKalle Valo
9333aca94dSKalle Valo /*
9433aca94dSKalle Valo * Stop watchdog monitoring.
9533aca94dSKalle Valo */
9633aca94dSKalle Valo rt2x00link_stop_watchdog(rt2x00dev);
9733aca94dSKalle Valo
9833aca94dSKalle Valo /*
9933aca94dSKalle Valo * Stop all queues
10033aca94dSKalle Valo */
10133aca94dSKalle Valo rt2x00link_stop_tuner(rt2x00dev);
10233aca94dSKalle Valo rt2x00queue_stop_queues(rt2x00dev);
10333aca94dSKalle Valo rt2x00queue_flush_queues(rt2x00dev, true);
104*04cfe4a5SShiji Yang rt2x00queue_stop_queue(rt2x00dev->bcn);
10533aca94dSKalle Valo
10633aca94dSKalle Valo /*
10733aca94dSKalle Valo * Disable radio.
10833aca94dSKalle Valo */
10933aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
11033aca94dSKalle Valo rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
11133aca94dSKalle Valo rt2x00led_led_activity(rt2x00dev, false);
11233aca94dSKalle Valo rt2x00leds_led_radio(rt2x00dev, false);
11333aca94dSKalle Valo }
11433aca94dSKalle Valo
rt2x00lib_intf_scheduled_iter(void * data,u8 * mac,struct ieee80211_vif * vif)11533aca94dSKalle Valo static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
11633aca94dSKalle Valo struct ieee80211_vif *vif)
11733aca94dSKalle Valo {
11833aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data;
11933aca94dSKalle Valo struct rt2x00_intf *intf = vif_to_intf(vif);
12033aca94dSKalle Valo
12133aca94dSKalle Valo /*
12233aca94dSKalle Valo * It is possible the radio was disabled while the work had been
12333aca94dSKalle Valo * scheduled. If that happens we should return here immediately,
12433aca94dSKalle Valo * note that in the spinlock protected area above the delayed_flags
12533aca94dSKalle Valo * have been cleared correctly.
12633aca94dSKalle Valo */
12733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
12833aca94dSKalle Valo return;
12933aca94dSKalle Valo
13033aca94dSKalle Valo if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags)) {
13133aca94dSKalle Valo mutex_lock(&intf->beacon_skb_mutex);
13233aca94dSKalle Valo rt2x00queue_update_beacon(rt2x00dev, vif);
13333aca94dSKalle Valo mutex_unlock(&intf->beacon_skb_mutex);
13433aca94dSKalle Valo }
13533aca94dSKalle Valo }
13633aca94dSKalle Valo
rt2x00lib_intf_scheduled(struct work_struct * work)13733aca94dSKalle Valo static void rt2x00lib_intf_scheduled(struct work_struct *work)
13833aca94dSKalle Valo {
13933aca94dSKalle Valo struct rt2x00_dev *rt2x00dev =
14033aca94dSKalle Valo container_of(work, struct rt2x00_dev, intf_work);
14133aca94dSKalle Valo
14233aca94dSKalle Valo /*
14333aca94dSKalle Valo * Iterate over each interface and perform the
14433aca94dSKalle Valo * requested configurations.
14533aca94dSKalle Valo */
14633aca94dSKalle Valo ieee80211_iterate_active_interfaces(rt2x00dev->hw,
14733aca94dSKalle Valo IEEE80211_IFACE_ITER_RESUME_ALL,
14833aca94dSKalle Valo rt2x00lib_intf_scheduled_iter,
14933aca94dSKalle Valo rt2x00dev);
15033aca94dSKalle Valo }
15133aca94dSKalle Valo
rt2x00lib_autowakeup(struct work_struct * work)15233aca94dSKalle Valo static void rt2x00lib_autowakeup(struct work_struct *work)
15333aca94dSKalle Valo {
15433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev =
15533aca94dSKalle Valo container_of(work, struct rt2x00_dev, autowakeup_work.work);
15633aca94dSKalle Valo
15733aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
15833aca94dSKalle Valo return;
15933aca94dSKalle Valo
16033aca94dSKalle Valo if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
16133aca94dSKalle Valo rt2x00_err(rt2x00dev, "Device failed to wakeup\n");
16233aca94dSKalle Valo clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
16333aca94dSKalle Valo }
16433aca94dSKalle Valo
16533aca94dSKalle Valo /*
16633aca94dSKalle Valo * Interrupt context handlers.
16733aca94dSKalle Valo */
rt2x00lib_bc_buffer_iter(void * data,u8 * mac,struct ieee80211_vif * vif)16833aca94dSKalle Valo static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
16933aca94dSKalle Valo struct ieee80211_vif *vif)
17033aca94dSKalle Valo {
17133aca94dSKalle Valo struct ieee80211_tx_control control = {};
17233aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data;
17333aca94dSKalle Valo struct sk_buff *skb;
17433aca94dSKalle Valo
17533aca94dSKalle Valo /*
17633aca94dSKalle Valo * Only AP mode interfaces do broad- and multicast buffering
17733aca94dSKalle Valo */
17833aca94dSKalle Valo if (vif->type != NL80211_IFTYPE_AP)
17933aca94dSKalle Valo return;
18033aca94dSKalle Valo
18133aca94dSKalle Valo /*
18233aca94dSKalle Valo * Send out buffered broad- and multicast frames
18333aca94dSKalle Valo */
18433aca94dSKalle Valo skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
18533aca94dSKalle Valo while (skb) {
18633aca94dSKalle Valo rt2x00mac_tx(rt2x00dev->hw, &control, skb);
18733aca94dSKalle Valo skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
18833aca94dSKalle Valo }
18933aca94dSKalle Valo }
19033aca94dSKalle Valo
rt2x00lib_beaconupdate_iter(void * data,u8 * mac,struct ieee80211_vif * vif)19133aca94dSKalle Valo static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
19233aca94dSKalle Valo struct ieee80211_vif *vif)
19333aca94dSKalle Valo {
19433aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = data;
19533aca94dSKalle Valo
19633aca94dSKalle Valo if (vif->type != NL80211_IFTYPE_AP &&
19733aca94dSKalle Valo vif->type != NL80211_IFTYPE_ADHOC &&
198801a46bdSJohannes Berg vif->type != NL80211_IFTYPE_MESH_POINT)
19933aca94dSKalle Valo return;
20033aca94dSKalle Valo
20133aca94dSKalle Valo /*
20233aca94dSKalle Valo * Update the beacon without locking. This is safe on PCI devices
20333aca94dSKalle Valo * as they only update the beacon periodically here. This should
20433aca94dSKalle Valo * never be called for USB devices.
20533aca94dSKalle Valo */
20633aca94dSKalle Valo WARN_ON(rt2x00_is_usb(rt2x00dev));
20733aca94dSKalle Valo rt2x00queue_update_beacon(rt2x00dev, vif);
20833aca94dSKalle Valo }
20933aca94dSKalle Valo
rt2x00lib_beacondone(struct rt2x00_dev * rt2x00dev)21033aca94dSKalle Valo void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
21133aca94dSKalle Valo {
21233aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
21333aca94dSKalle Valo return;
21433aca94dSKalle Valo
21533aca94dSKalle Valo /* send buffered bc/mc frames out for every bssid */
21633aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic(
21733aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
21833aca94dSKalle Valo rt2x00lib_bc_buffer_iter, rt2x00dev);
21933aca94dSKalle Valo /*
22033aca94dSKalle Valo * Devices with pre tbtt interrupt don't need to update the beacon
22133aca94dSKalle Valo * here as they will fetch the next beacon directly prior to
22233aca94dSKalle Valo * transmission.
22333aca94dSKalle Valo */
22433aca94dSKalle Valo if (rt2x00_has_cap_pre_tbtt_interrupt(rt2x00dev))
22533aca94dSKalle Valo return;
22633aca94dSKalle Valo
22733aca94dSKalle Valo /* fetch next beacon */
22833aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic(
22933aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
23033aca94dSKalle Valo rt2x00lib_beaconupdate_iter, rt2x00dev);
23133aca94dSKalle Valo }
23233aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
23333aca94dSKalle Valo
rt2x00lib_pretbtt(struct rt2x00_dev * rt2x00dev)23433aca94dSKalle Valo void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
23533aca94dSKalle Valo {
23633aca94dSKalle Valo if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
23733aca94dSKalle Valo return;
23833aca94dSKalle Valo
23933aca94dSKalle Valo /* fetch next beacon */
24033aca94dSKalle Valo ieee80211_iterate_active_interfaces_atomic(
24133aca94dSKalle Valo rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
24233aca94dSKalle Valo rt2x00lib_beaconupdate_iter, rt2x00dev);
24333aca94dSKalle Valo }
24433aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);
24533aca94dSKalle Valo
rt2x00lib_dmastart(struct queue_entry * entry)24633aca94dSKalle Valo void rt2x00lib_dmastart(struct queue_entry *entry)
24733aca94dSKalle Valo {
24833aca94dSKalle Valo set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
24933aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX);
25033aca94dSKalle Valo }
25133aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);
25233aca94dSKalle Valo
rt2x00lib_dmadone(struct queue_entry * entry)25333aca94dSKalle Valo void rt2x00lib_dmadone(struct queue_entry *entry)
25433aca94dSKalle Valo {
25533aca94dSKalle Valo set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
25633aca94dSKalle Valo clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
25733aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE);
25833aca94dSKalle Valo }
25933aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);
26033aca94dSKalle Valo
rt2x00lib_txdone_bar_status(struct queue_entry * entry)26133aca94dSKalle Valo static inline int rt2x00lib_txdone_bar_status(struct queue_entry *entry)
26233aca94dSKalle Valo {
26333aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
26433aca94dSKalle Valo struct ieee80211_bar *bar = (void *) entry->skb->data;
26533aca94dSKalle Valo struct rt2x00_bar_list_entry *bar_entry;
26633aca94dSKalle Valo int ret;
26733aca94dSKalle Valo
26833aca94dSKalle Valo if (likely(!ieee80211_is_back_req(bar->frame_control)))
26933aca94dSKalle Valo return 0;
27033aca94dSKalle Valo
27133aca94dSKalle Valo /*
27233aca94dSKalle Valo * Unlike all other frames, the status report for BARs does
27333aca94dSKalle Valo * not directly come from the hardware as it is incapable of
27433aca94dSKalle Valo * matching a BA to a previously send BAR. The hardware will
27533aca94dSKalle Valo * report all BARs as if they weren't acked at all.
27633aca94dSKalle Valo *
27733aca94dSKalle Valo * Instead the RX-path will scan for incoming BAs and set the
27833aca94dSKalle Valo * block_acked flag if it sees one that was likely caused by
27933aca94dSKalle Valo * a BAR from us.
28033aca94dSKalle Valo *
28133aca94dSKalle Valo * Remove remaining BARs here and return their status for
28233aca94dSKalle Valo * TX done processing.
28333aca94dSKalle Valo */
28433aca94dSKalle Valo ret = 0;
28533aca94dSKalle Valo rcu_read_lock();
28633aca94dSKalle Valo list_for_each_entry_rcu(bar_entry, &rt2x00dev->bar_list, list) {
28733aca94dSKalle Valo if (bar_entry->entry != entry)
28833aca94dSKalle Valo continue;
28933aca94dSKalle Valo
29033aca94dSKalle Valo spin_lock_bh(&rt2x00dev->bar_list_lock);
29133aca94dSKalle Valo /* Return whether this BAR was blockacked or not */
29233aca94dSKalle Valo ret = bar_entry->block_acked;
29333aca94dSKalle Valo /* Remove the BAR from our checklist */
29433aca94dSKalle Valo list_del_rcu(&bar_entry->list);
29533aca94dSKalle Valo spin_unlock_bh(&rt2x00dev->bar_list_lock);
29633aca94dSKalle Valo kfree_rcu(bar_entry, head);
29733aca94dSKalle Valo
29833aca94dSKalle Valo break;
29933aca94dSKalle Valo }
30033aca94dSKalle Valo rcu_read_unlock();
30133aca94dSKalle Valo
30233aca94dSKalle Valo return ret;
30333aca94dSKalle Valo }
30433aca94dSKalle Valo
rt2x00lib_fill_tx_status(struct rt2x00_dev * rt2x00dev,struct ieee80211_tx_info * tx_info,struct skb_frame_desc * skbdesc,struct txdone_entry_desc * txdesc,bool success)3055edb05afSStanislaw Gruszka static void rt2x00lib_fill_tx_status(struct rt2x00_dev *rt2x00dev,
3065edb05afSStanislaw Gruszka struct ieee80211_tx_info *tx_info,
3075edb05afSStanislaw Gruszka struct skb_frame_desc *skbdesc,
3085edb05afSStanislaw Gruszka struct txdone_entry_desc *txdesc,
3095edb05afSStanislaw Gruszka bool success)
31033aca94dSKalle Valo {
31133aca94dSKalle Valo u8 rate_idx, rate_flags, retry_rates;
3125edb05afSStanislaw Gruszka int i;
31333aca94dSKalle Valo
31433aca94dSKalle Valo rate_idx = skbdesc->tx_rate_idx;
31533aca94dSKalle Valo rate_flags = skbdesc->tx_rate_flags;
31633aca94dSKalle Valo retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
31733aca94dSKalle Valo (txdesc->retry + 1) : 1;
31833aca94dSKalle Valo
31933aca94dSKalle Valo /*
32033aca94dSKalle Valo * Initialize TX status
32133aca94dSKalle Valo */
32233aca94dSKalle Valo memset(&tx_info->status, 0, sizeof(tx_info->status));
32333aca94dSKalle Valo tx_info->status.ack_signal = 0;
32433aca94dSKalle Valo
32533aca94dSKalle Valo /*
32633aca94dSKalle Valo * Frame was send with retries, hardware tried
32733aca94dSKalle Valo * different rates to send out the frame, at each
32833aca94dSKalle Valo * retry it lowered the rate 1 step except when the
32933aca94dSKalle Valo * lowest rate was used.
33033aca94dSKalle Valo */
33133aca94dSKalle Valo for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
33233aca94dSKalle Valo tx_info->status.rates[i].idx = rate_idx - i;
33333aca94dSKalle Valo tx_info->status.rates[i].flags = rate_flags;
33433aca94dSKalle Valo
33533aca94dSKalle Valo if (rate_idx - i == 0) {
33633aca94dSKalle Valo /*
33733aca94dSKalle Valo * The lowest rate (index 0) was used until the
33833aca94dSKalle Valo * number of max retries was reached.
33933aca94dSKalle Valo */
34033aca94dSKalle Valo tx_info->status.rates[i].count = retry_rates - i;
34133aca94dSKalle Valo i++;
34233aca94dSKalle Valo break;
34333aca94dSKalle Valo }
34433aca94dSKalle Valo tx_info->status.rates[i].count = 1;
34533aca94dSKalle Valo }
34633aca94dSKalle Valo if (i < (IEEE80211_TX_MAX_RATES - 1))
34733aca94dSKalle Valo tx_info->status.rates[i].idx = -1; /* terminate */
34833aca94dSKalle Valo
349ec80ad70SStanislaw Gruszka if (test_bit(TXDONE_NO_ACK_REQ, &txdesc->flags))
350ec80ad70SStanislaw Gruszka tx_info->flags |= IEEE80211_TX_CTL_NO_ACK;
351ec80ad70SStanislaw Gruszka
35233aca94dSKalle Valo if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
35333aca94dSKalle Valo if (success)
35433aca94dSKalle Valo tx_info->flags |= IEEE80211_TX_STAT_ACK;
35533aca94dSKalle Valo else
35633aca94dSKalle Valo rt2x00dev->low_level_stats.dot11ACKFailureCount++;
35733aca94dSKalle Valo }
35833aca94dSKalle Valo
35933aca94dSKalle Valo /*
36033aca94dSKalle Valo * Every single frame has it's own tx status, hence report
36133aca94dSKalle Valo * every frame as ampdu of size 1.
36233aca94dSKalle Valo *
36333aca94dSKalle Valo * TODO: if we can find out how many frames were aggregated
36433aca94dSKalle Valo * by the hw we could provide the real ampdu_len to mac80211
36533aca94dSKalle Valo * which would allow the rc algorithm to better decide on
36633aca94dSKalle Valo * which rates are suitable.
36733aca94dSKalle Valo */
36833aca94dSKalle Valo if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
36933aca94dSKalle Valo tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
370ec80ad70SStanislaw Gruszka tx_info->flags |= IEEE80211_TX_STAT_AMPDU |
371ec80ad70SStanislaw Gruszka IEEE80211_TX_CTL_AMPDU;
37233aca94dSKalle Valo tx_info->status.ampdu_len = 1;
37333aca94dSKalle Valo tx_info->status.ampdu_ack_len = success ? 1 : 0;
37433aca94dSKalle Valo }
37533aca94dSKalle Valo
37633aca94dSKalle Valo if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
37733aca94dSKalle Valo if (success)
37833aca94dSKalle Valo rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
37933aca94dSKalle Valo else
38033aca94dSKalle Valo rt2x00dev->low_level_stats.dot11RTSFailureCount++;
38133aca94dSKalle Valo }
3825edb05afSStanislaw Gruszka }
3835edb05afSStanislaw Gruszka
rt2x00lib_clear_entry(struct rt2x00_dev * rt2x00dev,struct queue_entry * entry)38456646adfSStanislaw Gruszka static void rt2x00lib_clear_entry(struct rt2x00_dev *rt2x00dev,
38556646adfSStanislaw Gruszka struct queue_entry *entry)
38656646adfSStanislaw Gruszka {
38756646adfSStanislaw Gruszka /*
38856646adfSStanislaw Gruszka * Make this entry available for reuse.
38956646adfSStanislaw Gruszka */
39056646adfSStanislaw Gruszka entry->skb = NULL;
39156646adfSStanislaw Gruszka entry->flags = 0;
39256646adfSStanislaw Gruszka
39356646adfSStanislaw Gruszka rt2x00dev->ops->lib->clear_entry(entry);
39456646adfSStanislaw Gruszka
39556646adfSStanislaw Gruszka rt2x00queue_index_inc(entry, Q_INDEX_DONE);
39656646adfSStanislaw Gruszka
39756646adfSStanislaw Gruszka /*
39856646adfSStanislaw Gruszka * If the data queue was below the threshold before the txdone
39956646adfSStanislaw Gruszka * handler we must make sure the packet queue in the mac80211 stack
40056646adfSStanislaw Gruszka * is reenabled when the txdone handler has finished. This has to be
40156646adfSStanislaw Gruszka * serialized with rt2x00mac_tx(), otherwise we can wake up queue
40256646adfSStanislaw Gruszka * before it was stopped.
40356646adfSStanislaw Gruszka */
40456646adfSStanislaw Gruszka spin_lock_bh(&entry->queue->tx_lock);
40556646adfSStanislaw Gruszka if (!rt2x00queue_threshold(entry->queue))
40656646adfSStanislaw Gruszka rt2x00queue_unpause_queue(entry->queue);
40756646adfSStanislaw Gruszka spin_unlock_bh(&entry->queue->tx_lock);
40856646adfSStanislaw Gruszka }
40956646adfSStanislaw Gruszka
rt2x00lib_txdone_nomatch(struct queue_entry * entry,struct txdone_entry_desc * txdesc)410a09305d0SStanislaw Gruszka void rt2x00lib_txdone_nomatch(struct queue_entry *entry,
411a09305d0SStanislaw Gruszka struct txdone_entry_desc *txdesc)
412a09305d0SStanislaw Gruszka {
413a09305d0SStanislaw Gruszka struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
414a09305d0SStanislaw Gruszka struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
415a09305d0SStanislaw Gruszka struct ieee80211_tx_info txinfo = {};
416a09305d0SStanislaw Gruszka bool success;
417a09305d0SStanislaw Gruszka
418a09305d0SStanislaw Gruszka /*
419a09305d0SStanislaw Gruszka * Unmap the skb.
420a09305d0SStanislaw Gruszka */
421a09305d0SStanislaw Gruszka rt2x00queue_unmap_skb(entry);
422a09305d0SStanislaw Gruszka
423a09305d0SStanislaw Gruszka /*
424a09305d0SStanislaw Gruszka * Signal that the TX descriptor is no longer in the skb.
425a09305d0SStanislaw Gruszka */
426a09305d0SStanislaw Gruszka skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
427a09305d0SStanislaw Gruszka
428a09305d0SStanislaw Gruszka /*
429a09305d0SStanislaw Gruszka * Send frame to debugfs immediately, after this call is completed
430a09305d0SStanislaw Gruszka * we are going to overwrite the skb->cb array.
431a09305d0SStanislaw Gruszka */
432a09305d0SStanislaw Gruszka rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry);
433a09305d0SStanislaw Gruszka
434a09305d0SStanislaw Gruszka /*
435a09305d0SStanislaw Gruszka * Determine if the frame has been successfully transmitted and
436a09305d0SStanislaw Gruszka * remove BARs from our check list while checking for their
437a09305d0SStanislaw Gruszka * TX status.
438a09305d0SStanislaw Gruszka */
439a09305d0SStanislaw Gruszka success =
440a09305d0SStanislaw Gruszka rt2x00lib_txdone_bar_status(entry) ||
441a09305d0SStanislaw Gruszka test_bit(TXDONE_SUCCESS, &txdesc->flags);
442a09305d0SStanislaw Gruszka
443a09305d0SStanislaw Gruszka if (!test_bit(TXDONE_UNKNOWN, &txdesc->flags)) {
444a09305d0SStanislaw Gruszka /*
445a09305d0SStanislaw Gruszka * Update TX statistics.
446a09305d0SStanislaw Gruszka */
447a09305d0SStanislaw Gruszka rt2x00dev->link.qual.tx_success += success;
448a09305d0SStanislaw Gruszka rt2x00dev->link.qual.tx_failed += !success;
449a09305d0SStanislaw Gruszka
450a09305d0SStanislaw Gruszka rt2x00lib_fill_tx_status(rt2x00dev, &txinfo, skbdesc, txdesc,
451a09305d0SStanislaw Gruszka success);
452a09305d0SStanislaw Gruszka ieee80211_tx_status_noskb(rt2x00dev->hw, skbdesc->sta, &txinfo);
453a09305d0SStanislaw Gruszka }
454a09305d0SStanislaw Gruszka
455a09305d0SStanislaw Gruszka dev_kfree_skb_any(entry->skb);
456a09305d0SStanislaw Gruszka rt2x00lib_clear_entry(rt2x00dev, entry);
457a09305d0SStanislaw Gruszka }
458a09305d0SStanislaw Gruszka EXPORT_SYMBOL_GPL(rt2x00lib_txdone_nomatch);
459a09305d0SStanislaw Gruszka
rt2x00lib_txdone(struct queue_entry * entry,struct txdone_entry_desc * txdesc)4605edb05afSStanislaw Gruszka void rt2x00lib_txdone(struct queue_entry *entry,
4615edb05afSStanislaw Gruszka struct txdone_entry_desc *txdesc)
4625edb05afSStanislaw Gruszka {
4635edb05afSStanislaw Gruszka struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
4645edb05afSStanislaw Gruszka struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
4655edb05afSStanislaw Gruszka struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
4665edb05afSStanislaw Gruszka u8 skbdesc_flags = skbdesc->flags;
4675edb05afSStanislaw Gruszka unsigned int header_length;
4685edb05afSStanislaw Gruszka bool success;
4695edb05afSStanislaw Gruszka
4705edb05afSStanislaw Gruszka /*
4715edb05afSStanislaw Gruszka * Unmap the skb.
4725edb05afSStanislaw Gruszka */
4735edb05afSStanislaw Gruszka rt2x00queue_unmap_skb(entry);
4745edb05afSStanislaw Gruszka
4755edb05afSStanislaw Gruszka /*
4765edb05afSStanislaw Gruszka * Remove the extra tx headroom from the skb.
4775edb05afSStanislaw Gruszka */
4785edb05afSStanislaw Gruszka skb_pull(entry->skb, rt2x00dev->extra_tx_headroom);
4795edb05afSStanislaw Gruszka
4805edb05afSStanislaw Gruszka /*
4815edb05afSStanislaw Gruszka * Signal that the TX descriptor is no longer in the skb.
4825edb05afSStanislaw Gruszka */
4835edb05afSStanislaw Gruszka skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
4845edb05afSStanislaw Gruszka
4855edb05afSStanislaw Gruszka /*
4865edb05afSStanislaw Gruszka * Determine the length of 802.11 header.
4875edb05afSStanislaw Gruszka */
4885edb05afSStanislaw Gruszka header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
4895edb05afSStanislaw Gruszka
4905edb05afSStanislaw Gruszka /*
4915edb05afSStanislaw Gruszka * Remove L2 padding which was added during
4925edb05afSStanislaw Gruszka */
4935edb05afSStanislaw Gruszka if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
4945edb05afSStanislaw Gruszka rt2x00queue_remove_l2pad(entry->skb, header_length);
4955edb05afSStanislaw Gruszka
4965edb05afSStanislaw Gruszka /*
4975edb05afSStanislaw Gruszka * If the IV/EIV data was stripped from the frame before it was
4985edb05afSStanislaw Gruszka * passed to the hardware, we should now reinsert it again because
4995edb05afSStanislaw Gruszka * mac80211 will expect the same data to be present it the
5005edb05afSStanislaw Gruszka * frame as it was passed to us.
5015edb05afSStanislaw Gruszka */
5025edb05afSStanislaw Gruszka if (rt2x00_has_cap_hw_crypto(rt2x00dev))
5035edb05afSStanislaw Gruszka rt2x00crypto_tx_insert_iv(entry->skb, header_length);
5045edb05afSStanislaw Gruszka
5055edb05afSStanislaw Gruszka /*
5065edb05afSStanislaw Gruszka * Send frame to debugfs immediately, after this call is completed
5075edb05afSStanislaw Gruszka * we are going to overwrite the skb->cb array.
5085edb05afSStanislaw Gruszka */
5095edb05afSStanislaw Gruszka rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry);
5105edb05afSStanislaw Gruszka
5115edb05afSStanislaw Gruszka /*
5125edb05afSStanislaw Gruszka * Determine if the frame has been successfully transmitted and
5135edb05afSStanislaw Gruszka * remove BARs from our check list while checking for their
5145edb05afSStanislaw Gruszka * TX status.
5155edb05afSStanislaw Gruszka */
5165edb05afSStanislaw Gruszka success =
5175edb05afSStanislaw Gruszka rt2x00lib_txdone_bar_status(entry) ||
5185edb05afSStanislaw Gruszka test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
5195edb05afSStanislaw Gruszka test_bit(TXDONE_UNKNOWN, &txdesc->flags);
5205edb05afSStanislaw Gruszka
5215edb05afSStanislaw Gruszka /*
5225edb05afSStanislaw Gruszka * Update TX statistics.
5235edb05afSStanislaw Gruszka */
5245edb05afSStanislaw Gruszka rt2x00dev->link.qual.tx_success += success;
5255edb05afSStanislaw Gruszka rt2x00dev->link.qual.tx_failed += !success;
5265edb05afSStanislaw Gruszka
5275edb05afSStanislaw Gruszka rt2x00lib_fill_tx_status(rt2x00dev, tx_info, skbdesc, txdesc, success);
52833aca94dSKalle Valo
52933aca94dSKalle Valo /*
53033aca94dSKalle Valo * Only send the status report to mac80211 when it's a frame
53133aca94dSKalle Valo * that originated in mac80211. If this was a extra frame coming
53233aca94dSKalle Valo * through a mac80211 library call (RTS/CTS) then we should not
53333aca94dSKalle Valo * send the status report back.
53433aca94dSKalle Valo */
53533aca94dSKalle Valo if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
53633aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TASKLET_CONTEXT))
53733aca94dSKalle Valo ieee80211_tx_status(rt2x00dev->hw, entry->skb);
53833aca94dSKalle Valo else
53933aca94dSKalle Valo ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
54056646adfSStanislaw Gruszka } else {
54133aca94dSKalle Valo dev_kfree_skb_any(entry->skb);
54256646adfSStanislaw Gruszka }
54333aca94dSKalle Valo
54456646adfSStanislaw Gruszka rt2x00lib_clear_entry(rt2x00dev, entry);
54533aca94dSKalle Valo }
54633aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
54733aca94dSKalle Valo
rt2x00lib_txdone_noinfo(struct queue_entry * entry,u32 status)54833aca94dSKalle Valo void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
54933aca94dSKalle Valo {
55033aca94dSKalle Valo struct txdone_entry_desc txdesc;
55133aca94dSKalle Valo
55233aca94dSKalle Valo txdesc.flags = 0;
55333aca94dSKalle Valo __set_bit(status, &txdesc.flags);
55433aca94dSKalle Valo txdesc.retry = 0;
55533aca94dSKalle Valo
55633aca94dSKalle Valo rt2x00lib_txdone(entry, &txdesc);
55733aca94dSKalle Valo }
55833aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo);
55933aca94dSKalle Valo
rt2x00lib_find_ie(u8 * data,unsigned int len,u8 ie)56033aca94dSKalle Valo static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
56133aca94dSKalle Valo {
56233aca94dSKalle Valo struct ieee80211_mgmt *mgmt = (void *)data;
56333aca94dSKalle Valo u8 *pos, *end;
56433aca94dSKalle Valo
56533aca94dSKalle Valo pos = (u8 *)mgmt->u.beacon.variable;
56633aca94dSKalle Valo end = data + len;
56733aca94dSKalle Valo while (pos < end) {
56833aca94dSKalle Valo if (pos + 2 + pos[1] > end)
56933aca94dSKalle Valo return NULL;
57033aca94dSKalle Valo
57133aca94dSKalle Valo if (pos[0] == ie)
57233aca94dSKalle Valo return pos;
57333aca94dSKalle Valo
57433aca94dSKalle Valo pos += 2 + pos[1];
57533aca94dSKalle Valo }
57633aca94dSKalle Valo
57733aca94dSKalle Valo return NULL;
57833aca94dSKalle Valo }
57933aca94dSKalle Valo
rt2x00lib_sleep(struct work_struct * work)58033aca94dSKalle Valo static void rt2x00lib_sleep(struct work_struct *work)
58133aca94dSKalle Valo {
58233aca94dSKalle Valo struct rt2x00_dev *rt2x00dev =
58333aca94dSKalle Valo container_of(work, struct rt2x00_dev, sleep_work);
58433aca94dSKalle Valo
58533aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
58633aca94dSKalle Valo return;
58733aca94dSKalle Valo
58833aca94dSKalle Valo /*
58933aca94dSKalle Valo * Check again is powersaving is enabled, to prevent races from delayed
59033aca94dSKalle Valo * work execution.
59133aca94dSKalle Valo */
59233aca94dSKalle Valo if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
59333aca94dSKalle Valo rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
59433aca94dSKalle Valo IEEE80211_CONF_CHANGE_PS);
59533aca94dSKalle Valo }
59633aca94dSKalle Valo
rt2x00lib_rxdone_check_ba(struct rt2x00_dev * rt2x00dev,struct sk_buff * skb,struct rxdone_entry_desc * rxdesc)59733aca94dSKalle Valo static void rt2x00lib_rxdone_check_ba(struct rt2x00_dev *rt2x00dev,
59833aca94dSKalle Valo struct sk_buff *skb,
59933aca94dSKalle Valo struct rxdone_entry_desc *rxdesc)
60033aca94dSKalle Valo {
60133aca94dSKalle Valo struct rt2x00_bar_list_entry *entry;
60233aca94dSKalle Valo struct ieee80211_bar *ba = (void *)skb->data;
60333aca94dSKalle Valo
60433aca94dSKalle Valo if (likely(!ieee80211_is_back(ba->frame_control)))
60533aca94dSKalle Valo return;
60633aca94dSKalle Valo
60733aca94dSKalle Valo if (rxdesc->size < sizeof(*ba) + FCS_LEN)
60833aca94dSKalle Valo return;
60933aca94dSKalle Valo
61033aca94dSKalle Valo rcu_read_lock();
61133aca94dSKalle Valo list_for_each_entry_rcu(entry, &rt2x00dev->bar_list, list) {
61233aca94dSKalle Valo
61333aca94dSKalle Valo if (ba->start_seq_num != entry->start_seq_num)
61433aca94dSKalle Valo continue;
61533aca94dSKalle Valo
61633aca94dSKalle Valo #define TID_CHECK(a, b) ( \
61733aca94dSKalle Valo ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) == \
61833aca94dSKalle Valo ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK))) \
61933aca94dSKalle Valo
62033aca94dSKalle Valo if (!TID_CHECK(ba->control, entry->control))
62133aca94dSKalle Valo continue;
62233aca94dSKalle Valo
62333aca94dSKalle Valo #undef TID_CHECK
62433aca94dSKalle Valo
62533aca94dSKalle Valo if (!ether_addr_equal_64bits(ba->ra, entry->ta))
62633aca94dSKalle Valo continue;
62733aca94dSKalle Valo
62833aca94dSKalle Valo if (!ether_addr_equal_64bits(ba->ta, entry->ra))
62933aca94dSKalle Valo continue;
63033aca94dSKalle Valo
63133aca94dSKalle Valo /* Mark BAR since we received the according BA */
63233aca94dSKalle Valo spin_lock_bh(&rt2x00dev->bar_list_lock);
63333aca94dSKalle Valo entry->block_acked = 1;
63433aca94dSKalle Valo spin_unlock_bh(&rt2x00dev->bar_list_lock);
63533aca94dSKalle Valo break;
63633aca94dSKalle Valo }
63733aca94dSKalle Valo rcu_read_unlock();
63833aca94dSKalle Valo
63933aca94dSKalle Valo }
64033aca94dSKalle Valo
rt2x00lib_rxdone_check_ps(struct rt2x00_dev * rt2x00dev,struct sk_buff * skb,struct rxdone_entry_desc * rxdesc)64133aca94dSKalle Valo static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
64233aca94dSKalle Valo struct sk_buff *skb,
64333aca94dSKalle Valo struct rxdone_entry_desc *rxdesc)
64433aca94dSKalle Valo {
64533aca94dSKalle Valo struct ieee80211_hdr *hdr = (void *) skb->data;
64633aca94dSKalle Valo struct ieee80211_tim_ie *tim_ie;
64733aca94dSKalle Valo u8 *tim;
64833aca94dSKalle Valo u8 tim_len;
64933aca94dSKalle Valo bool cam;
65033aca94dSKalle Valo
65133aca94dSKalle Valo /* If this is not a beacon, or if mac80211 has no powersaving
65233aca94dSKalle Valo * configured, or if the device is already in powersaving mode
65333aca94dSKalle Valo * we can exit now. */
65433aca94dSKalle Valo if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
65533aca94dSKalle Valo !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
65633aca94dSKalle Valo return;
65733aca94dSKalle Valo
65833aca94dSKalle Valo /* min. beacon length + FCS_LEN */
65933aca94dSKalle Valo if (skb->len <= 40 + FCS_LEN)
66033aca94dSKalle Valo return;
66133aca94dSKalle Valo
66233aca94dSKalle Valo /* and only beacons from the associated BSSID, please */
66333aca94dSKalle Valo if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
66433aca94dSKalle Valo !rt2x00dev->aid)
66533aca94dSKalle Valo return;
66633aca94dSKalle Valo
66733aca94dSKalle Valo rt2x00dev->last_beacon = jiffies;
66833aca94dSKalle Valo
66933aca94dSKalle Valo tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
67033aca94dSKalle Valo if (!tim)
67133aca94dSKalle Valo return;
67233aca94dSKalle Valo
67333aca94dSKalle Valo if (tim[1] < sizeof(*tim_ie))
67433aca94dSKalle Valo return;
67533aca94dSKalle Valo
67633aca94dSKalle Valo tim_len = tim[1];
67733aca94dSKalle Valo tim_ie = (struct ieee80211_tim_ie *) &tim[2];
67833aca94dSKalle Valo
67933aca94dSKalle Valo /* Check whenever the PHY can be turned off again. */
68033aca94dSKalle Valo
68133aca94dSKalle Valo /* 1. What about buffered unicast traffic for our AID? */
68233aca94dSKalle Valo cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);
68333aca94dSKalle Valo
68433aca94dSKalle Valo /* 2. Maybe the AP wants to send multicast/broadcast data? */
68533aca94dSKalle Valo cam |= (tim_ie->bitmap_ctrl & 0x01);
68633aca94dSKalle Valo
68733aca94dSKalle Valo if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
68833aca94dSKalle Valo queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work);
68933aca94dSKalle Valo }
69033aca94dSKalle Valo
rt2x00lib_rxdone_read_signal(struct rt2x00_dev * rt2x00dev,struct rxdone_entry_desc * rxdesc)69133aca94dSKalle Valo static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
69233aca94dSKalle Valo struct rxdone_entry_desc *rxdesc)
69333aca94dSKalle Valo {
69433aca94dSKalle Valo struct ieee80211_supported_band *sband;
69533aca94dSKalle Valo const struct rt2x00_rate *rate;
69633aca94dSKalle Valo unsigned int i;
69733aca94dSKalle Valo int signal = rxdesc->signal;
69833aca94dSKalle Valo int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);
69933aca94dSKalle Valo
70033aca94dSKalle Valo switch (rxdesc->rate_mode) {
70133aca94dSKalle Valo case RATE_MODE_CCK:
70233aca94dSKalle Valo case RATE_MODE_OFDM:
70333aca94dSKalle Valo /*
70433aca94dSKalle Valo * For non-HT rates the MCS value needs to contain the
70533aca94dSKalle Valo * actually used rate modulation (CCK or OFDM).
70633aca94dSKalle Valo */
70733aca94dSKalle Valo if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
70833aca94dSKalle Valo signal = RATE_MCS(rxdesc->rate_mode, signal);
70933aca94dSKalle Valo
71033aca94dSKalle Valo sband = &rt2x00dev->bands[rt2x00dev->curr_band];
71133aca94dSKalle Valo for (i = 0; i < sband->n_bitrates; i++) {
71233aca94dSKalle Valo rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
71333aca94dSKalle Valo if (((type == RXDONE_SIGNAL_PLCP) &&
71433aca94dSKalle Valo (rate->plcp == signal)) ||
71533aca94dSKalle Valo ((type == RXDONE_SIGNAL_BITRATE) &&
71633aca94dSKalle Valo (rate->bitrate == signal)) ||
71733aca94dSKalle Valo ((type == RXDONE_SIGNAL_MCS) &&
71833aca94dSKalle Valo (rate->mcs == signal))) {
71933aca94dSKalle Valo return i;
72033aca94dSKalle Valo }
72133aca94dSKalle Valo }
72233aca94dSKalle Valo break;
72333aca94dSKalle Valo case RATE_MODE_HT_MIX:
72433aca94dSKalle Valo case RATE_MODE_HT_GREENFIELD:
72533aca94dSKalle Valo if (signal >= 0 && signal <= 76)
72633aca94dSKalle Valo return signal;
72733aca94dSKalle Valo break;
72833aca94dSKalle Valo default:
72933aca94dSKalle Valo break;
73033aca94dSKalle Valo }
73133aca94dSKalle Valo
73233aca94dSKalle Valo rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n",
73333aca94dSKalle Valo rxdesc->rate_mode, signal, type);
73433aca94dSKalle Valo return 0;
73533aca94dSKalle Valo }
73633aca94dSKalle Valo
rt2x00lib_rxdone(struct queue_entry * entry,gfp_t gfp)73733aca94dSKalle Valo void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
73833aca94dSKalle Valo {
73933aca94dSKalle Valo struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
74033aca94dSKalle Valo struct rxdone_entry_desc rxdesc;
74133aca94dSKalle Valo struct sk_buff *skb;
74233aca94dSKalle Valo struct ieee80211_rx_status *rx_status;
74333aca94dSKalle Valo unsigned int header_length;
74433aca94dSKalle Valo int rate_idx;
74533aca94dSKalle Valo
74633aca94dSKalle Valo if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
74733aca94dSKalle Valo !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
74833aca94dSKalle Valo goto submit_entry;
74933aca94dSKalle Valo
75033aca94dSKalle Valo if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
75133aca94dSKalle Valo goto submit_entry;
75233aca94dSKalle Valo
75333aca94dSKalle Valo /*
75433aca94dSKalle Valo * Allocate a new sk_buffer. If no new buffer available, drop the
75533aca94dSKalle Valo * received frame and reuse the existing buffer.
75633aca94dSKalle Valo */
75733aca94dSKalle Valo skb = rt2x00queue_alloc_rxskb(entry, gfp);
75833aca94dSKalle Valo if (!skb)
75933aca94dSKalle Valo goto submit_entry;
76033aca94dSKalle Valo
76133aca94dSKalle Valo /*
76233aca94dSKalle Valo * Unmap the skb.
76333aca94dSKalle Valo */
76433aca94dSKalle Valo rt2x00queue_unmap_skb(entry);
76533aca94dSKalle Valo
76633aca94dSKalle Valo /*
76733aca94dSKalle Valo * Extract the RXD details.
76833aca94dSKalle Valo */
76933aca94dSKalle Valo memset(&rxdesc, 0, sizeof(rxdesc));
77033aca94dSKalle Valo rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
77133aca94dSKalle Valo
77233aca94dSKalle Valo /*
77333aca94dSKalle Valo * Check for valid size in case we get corrupted descriptor from
77433aca94dSKalle Valo * hardware.
77533aca94dSKalle Valo */
77633aca94dSKalle Valo if (unlikely(rxdesc.size == 0 ||
77733aca94dSKalle Valo rxdesc.size > entry->queue->data_size)) {
77833aca94dSKalle Valo rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n",
77933aca94dSKalle Valo rxdesc.size, entry->queue->data_size);
78033aca94dSKalle Valo dev_kfree_skb(entry->skb);
78133aca94dSKalle Valo goto renew_skb;
78233aca94dSKalle Valo }
78333aca94dSKalle Valo
78433aca94dSKalle Valo /*
78533aca94dSKalle Valo * The data behind the ieee80211 header must be
78633aca94dSKalle Valo * aligned on a 4 byte boundary.
78733aca94dSKalle Valo */
78833aca94dSKalle Valo header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
78933aca94dSKalle Valo
79033aca94dSKalle Valo /*
79133aca94dSKalle Valo * Hardware might have stripped the IV/EIV/ICV data,
79233aca94dSKalle Valo * in that case it is possible that the data was
79333aca94dSKalle Valo * provided separately (through hardware descriptor)
79433aca94dSKalle Valo * in which case we should reinsert the data into the frame.
79533aca94dSKalle Valo */
79633aca94dSKalle Valo if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
79733aca94dSKalle Valo (rxdesc.flags & RX_FLAG_IV_STRIPPED))
79833aca94dSKalle Valo rt2x00crypto_rx_insert_iv(entry->skb, header_length,
79933aca94dSKalle Valo &rxdesc);
80033aca94dSKalle Valo else if (header_length &&
80133aca94dSKalle Valo (rxdesc.size > header_length) &&
80233aca94dSKalle Valo (rxdesc.dev_flags & RXDONE_L2PAD))
80333aca94dSKalle Valo rt2x00queue_remove_l2pad(entry->skb, header_length);
80433aca94dSKalle Valo
80533aca94dSKalle Valo /* Trim buffer to correct size */
80633aca94dSKalle Valo skb_trim(entry->skb, rxdesc.size);
80733aca94dSKalle Valo
80833aca94dSKalle Valo /*
80933aca94dSKalle Valo * Translate the signal to the correct bitrate index.
81033aca94dSKalle Valo */
81133aca94dSKalle Valo rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
81233aca94dSKalle Valo if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
81333aca94dSKalle Valo rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
814da6a4352SJohannes Berg rxdesc.encoding = RX_ENC_HT;
81533aca94dSKalle Valo
81633aca94dSKalle Valo /*
81733aca94dSKalle Valo * Check if this is a beacon, and more frames have been
81833aca94dSKalle Valo * buffered while we were in powersaving mode.
81933aca94dSKalle Valo */
82033aca94dSKalle Valo rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);
82133aca94dSKalle Valo
82233aca94dSKalle Valo /*
82333aca94dSKalle Valo * Check for incoming BlockAcks to match to the BlockAckReqs
82433aca94dSKalle Valo * we've send out.
82533aca94dSKalle Valo */
82633aca94dSKalle Valo rt2x00lib_rxdone_check_ba(rt2x00dev, entry->skb, &rxdesc);
82733aca94dSKalle Valo
82833aca94dSKalle Valo /*
82933aca94dSKalle Valo * Update extra components
83033aca94dSKalle Valo */
83133aca94dSKalle Valo rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
83233aca94dSKalle Valo rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
8332ceb8137SStanislaw Gruszka rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry);
83433aca94dSKalle Valo
83533aca94dSKalle Valo /*
83633aca94dSKalle Valo * Initialize RX status information, and send frame
83733aca94dSKalle Valo * to mac80211.
83833aca94dSKalle Valo */
83933aca94dSKalle Valo rx_status = IEEE80211_SKB_RXCB(entry->skb);
84033aca94dSKalle Valo
84133aca94dSKalle Valo /* Ensure that all fields of rx_status are initialized
84233aca94dSKalle Valo * properly. The skb->cb array was used for driver
84333aca94dSKalle Valo * specific informations, so rx_status might contain
84433aca94dSKalle Valo * garbage.
84533aca94dSKalle Valo */
84633aca94dSKalle Valo memset(rx_status, 0, sizeof(*rx_status));
84733aca94dSKalle Valo
84833aca94dSKalle Valo rx_status->mactime = rxdesc.timestamp;
84933aca94dSKalle Valo rx_status->band = rt2x00dev->curr_band;
85033aca94dSKalle Valo rx_status->freq = rt2x00dev->curr_freq;
85133aca94dSKalle Valo rx_status->rate_idx = rate_idx;
85233aca94dSKalle Valo rx_status->signal = rxdesc.rssi;
85333aca94dSKalle Valo rx_status->flag = rxdesc.flags;
8547fdd69c5SJohannes Berg rx_status->enc_flags = rxdesc.enc_flags;
855da6a4352SJohannes Berg rx_status->encoding = rxdesc.encoding;
856da6a4352SJohannes Berg rx_status->bw = rxdesc.bw;
85733aca94dSKalle Valo rx_status->antenna = rt2x00dev->link.ant.active.rx;
85833aca94dSKalle Valo
85933aca94dSKalle Valo ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
86033aca94dSKalle Valo
86133aca94dSKalle Valo renew_skb:
86233aca94dSKalle Valo /*
86333aca94dSKalle Valo * Replace the skb with the freshly allocated one.
86433aca94dSKalle Valo */
86533aca94dSKalle Valo entry->skb = skb;
86633aca94dSKalle Valo
86733aca94dSKalle Valo submit_entry:
86833aca94dSKalle Valo entry->flags = 0;
86933aca94dSKalle Valo rt2x00queue_index_inc(entry, Q_INDEX_DONE);
87033aca94dSKalle Valo if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
87133aca94dSKalle Valo test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
87233aca94dSKalle Valo rt2x00dev->ops->lib->clear_entry(entry);
87333aca94dSKalle Valo }
87433aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
87533aca94dSKalle Valo
87633aca94dSKalle Valo /*
87733aca94dSKalle Valo * Driver initialization handlers.
87833aca94dSKalle Valo */
87933aca94dSKalle Valo const struct rt2x00_rate rt2x00_supported_rates[12] = {
88033aca94dSKalle Valo {
88133aca94dSKalle Valo .flags = DEV_RATE_CCK,
88233aca94dSKalle Valo .bitrate = 10,
88333aca94dSKalle Valo .ratemask = BIT(0),
88433aca94dSKalle Valo .plcp = 0x00,
88533aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 0),
88633aca94dSKalle Valo },
88733aca94dSKalle Valo {
88833aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
88933aca94dSKalle Valo .bitrate = 20,
89033aca94dSKalle Valo .ratemask = BIT(1),
89133aca94dSKalle Valo .plcp = 0x01,
89233aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 1),
89333aca94dSKalle Valo },
89433aca94dSKalle Valo {
89533aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
89633aca94dSKalle Valo .bitrate = 55,
89733aca94dSKalle Valo .ratemask = BIT(2),
89833aca94dSKalle Valo .plcp = 0x02,
89933aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 2),
90033aca94dSKalle Valo },
90133aca94dSKalle Valo {
90233aca94dSKalle Valo .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
90333aca94dSKalle Valo .bitrate = 110,
90433aca94dSKalle Valo .ratemask = BIT(3),
90533aca94dSKalle Valo .plcp = 0x03,
90633aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_CCK, 3),
90733aca94dSKalle Valo },
90833aca94dSKalle Valo {
90933aca94dSKalle Valo .flags = DEV_RATE_OFDM,
91033aca94dSKalle Valo .bitrate = 60,
91133aca94dSKalle Valo .ratemask = BIT(4),
91233aca94dSKalle Valo .plcp = 0x0b,
91333aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 0),
91433aca94dSKalle Valo },
91533aca94dSKalle Valo {
91633aca94dSKalle Valo .flags = DEV_RATE_OFDM,
91733aca94dSKalle Valo .bitrate = 90,
91833aca94dSKalle Valo .ratemask = BIT(5),
91933aca94dSKalle Valo .plcp = 0x0f,
92033aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 1),
92133aca94dSKalle Valo },
92233aca94dSKalle Valo {
92333aca94dSKalle Valo .flags = DEV_RATE_OFDM,
92433aca94dSKalle Valo .bitrate = 120,
92533aca94dSKalle Valo .ratemask = BIT(6),
92633aca94dSKalle Valo .plcp = 0x0a,
92733aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 2),
92833aca94dSKalle Valo },
92933aca94dSKalle Valo {
93033aca94dSKalle Valo .flags = DEV_RATE_OFDM,
93133aca94dSKalle Valo .bitrate = 180,
93233aca94dSKalle Valo .ratemask = BIT(7),
93333aca94dSKalle Valo .plcp = 0x0e,
93433aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 3),
93533aca94dSKalle Valo },
93633aca94dSKalle Valo {
93733aca94dSKalle Valo .flags = DEV_RATE_OFDM,
93833aca94dSKalle Valo .bitrate = 240,
93933aca94dSKalle Valo .ratemask = BIT(8),
94033aca94dSKalle Valo .plcp = 0x09,
94133aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 4),
94233aca94dSKalle Valo },
94333aca94dSKalle Valo {
94433aca94dSKalle Valo .flags = DEV_RATE_OFDM,
94533aca94dSKalle Valo .bitrate = 360,
94633aca94dSKalle Valo .ratemask = BIT(9),
94733aca94dSKalle Valo .plcp = 0x0d,
94833aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 5),
94933aca94dSKalle Valo },
95033aca94dSKalle Valo {
95133aca94dSKalle Valo .flags = DEV_RATE_OFDM,
95233aca94dSKalle Valo .bitrate = 480,
95333aca94dSKalle Valo .ratemask = BIT(10),
95433aca94dSKalle Valo .plcp = 0x08,
95533aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 6),
95633aca94dSKalle Valo },
95733aca94dSKalle Valo {
95833aca94dSKalle Valo .flags = DEV_RATE_OFDM,
95933aca94dSKalle Valo .bitrate = 540,
96033aca94dSKalle Valo .ratemask = BIT(11),
96133aca94dSKalle Valo .plcp = 0x0c,
96233aca94dSKalle Valo .mcs = RATE_MCS(RATE_MODE_OFDM, 7),
96333aca94dSKalle Valo },
96433aca94dSKalle Valo };
96533aca94dSKalle Valo
rt2x00lib_channel(struct ieee80211_channel * entry,const int channel,const int tx_power,const int value)96633aca94dSKalle Valo static void rt2x00lib_channel(struct ieee80211_channel *entry,
96733aca94dSKalle Valo const int channel, const int tx_power,
96833aca94dSKalle Valo const int value)
96933aca94dSKalle Valo {
97033aca94dSKalle Valo /* XXX: this assumption about the band is wrong for 802.11j */
97157fbcce3SJohannes Berg entry->band = channel <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
97233aca94dSKalle Valo entry->center_freq = ieee80211_channel_to_frequency(channel,
97333aca94dSKalle Valo entry->band);
97433aca94dSKalle Valo entry->hw_value = value;
97533aca94dSKalle Valo entry->max_power = tx_power;
97633aca94dSKalle Valo entry->max_antenna_gain = 0xff;
97733aca94dSKalle Valo }
97833aca94dSKalle Valo
rt2x00lib_rate(struct ieee80211_rate * entry,const u16 index,const struct rt2x00_rate * rate)97933aca94dSKalle Valo static void rt2x00lib_rate(struct ieee80211_rate *entry,
98033aca94dSKalle Valo const u16 index, const struct rt2x00_rate *rate)
98133aca94dSKalle Valo {
98233aca94dSKalle Valo entry->flags = 0;
98333aca94dSKalle Valo entry->bitrate = rate->bitrate;
98433aca94dSKalle Valo entry->hw_value = index;
98533aca94dSKalle Valo entry->hw_value_short = index;
98633aca94dSKalle Valo
98733aca94dSKalle Valo if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
98833aca94dSKalle Valo entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
98933aca94dSKalle Valo }
99033aca94dSKalle Valo
rt2x00lib_set_mac_address(struct rt2x00_dev * rt2x00dev,u8 * eeprom_mac_addr)9919766cb70SMathias Kresin void rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr)
9929766cb70SMathias Kresin {
99383216e39SMichael Walle of_get_mac_address(rt2x00dev->dev->of_node, eeprom_mac_addr);
9949766cb70SMathias Kresin
9959766cb70SMathias Kresin if (!is_valid_ether_addr(eeprom_mac_addr)) {
9969766cb70SMathias Kresin eth_random_addr(eeprom_mac_addr);
9979766cb70SMathias Kresin rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", eeprom_mac_addr);
9989766cb70SMathias Kresin }
9999766cb70SMathias Kresin }
10009766cb70SMathias Kresin EXPORT_SYMBOL_GPL(rt2x00lib_set_mac_address);
10019766cb70SMathias Kresin
rt2x00lib_probe_hw_modes(struct rt2x00_dev * rt2x00dev,struct hw_mode_spec * spec)100233aca94dSKalle Valo static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
100333aca94dSKalle Valo struct hw_mode_spec *spec)
100433aca94dSKalle Valo {
100533aca94dSKalle Valo struct ieee80211_hw *hw = rt2x00dev->hw;
100633aca94dSKalle Valo struct ieee80211_channel *channels;
100733aca94dSKalle Valo struct ieee80211_rate *rates;
100833aca94dSKalle Valo unsigned int num_rates;
100933aca94dSKalle Valo unsigned int i;
101033aca94dSKalle Valo
101133aca94dSKalle Valo num_rates = 0;
101233aca94dSKalle Valo if (spec->supported_rates & SUPPORT_RATE_CCK)
101333aca94dSKalle Valo num_rates += 4;
101433aca94dSKalle Valo if (spec->supported_rates & SUPPORT_RATE_OFDM)
101533aca94dSKalle Valo num_rates += 8;
101633aca94dSKalle Valo
101733aca94dSKalle Valo channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL);
101833aca94dSKalle Valo if (!channels)
101933aca94dSKalle Valo return -ENOMEM;
102033aca94dSKalle Valo
102133aca94dSKalle Valo rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
102233aca94dSKalle Valo if (!rates)
102333aca94dSKalle Valo goto exit_free_channels;
102433aca94dSKalle Valo
102533aca94dSKalle Valo /*
102633aca94dSKalle Valo * Initialize Rate list.
102733aca94dSKalle Valo */
102833aca94dSKalle Valo for (i = 0; i < num_rates; i++)
102933aca94dSKalle Valo rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
103033aca94dSKalle Valo
103133aca94dSKalle Valo /*
103233aca94dSKalle Valo * Initialize Channel list.
103333aca94dSKalle Valo */
103433aca94dSKalle Valo for (i = 0; i < spec->num_channels; i++) {
103533aca94dSKalle Valo rt2x00lib_channel(&channels[i],
103633aca94dSKalle Valo spec->channels[i].channel,
103733aca94dSKalle Valo spec->channels_info[i].max_power, i);
103833aca94dSKalle Valo }
103933aca94dSKalle Valo
104033aca94dSKalle Valo /*
104133aca94dSKalle Valo * Intitialize 802.11b, 802.11g
104233aca94dSKalle Valo * Rates: CCK, OFDM.
104333aca94dSKalle Valo * Channels: 2.4 GHz
104433aca94dSKalle Valo */
104533aca94dSKalle Valo if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
104657fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].n_channels = 14;
104757fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].n_bitrates = num_rates;
104857fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].channels = channels;
104957fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_2GHZ].bitrates = rates;
105057fbcce3SJohannes Berg hw->wiphy->bands[NL80211_BAND_2GHZ] =
105157fbcce3SJohannes Berg &rt2x00dev->bands[NL80211_BAND_2GHZ];
105257fbcce3SJohannes Berg memcpy(&rt2x00dev->bands[NL80211_BAND_2GHZ].ht_cap,
105333aca94dSKalle Valo &spec->ht, sizeof(spec->ht));
105433aca94dSKalle Valo }
105533aca94dSKalle Valo
105633aca94dSKalle Valo /*
105733aca94dSKalle Valo * Intitialize 802.11a
105833aca94dSKalle Valo * Rates: OFDM.
105933aca94dSKalle Valo * Channels: OFDM, UNII, HiperLAN2.
106033aca94dSKalle Valo */
106133aca94dSKalle Valo if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
106257fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].n_channels =
106333aca94dSKalle Valo spec->num_channels - 14;
106457fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].n_bitrates =
106533aca94dSKalle Valo num_rates - 4;
106657fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].channels = &channels[14];
106757fbcce3SJohannes Berg rt2x00dev->bands[NL80211_BAND_5GHZ].bitrates = &rates[4];
106857fbcce3SJohannes Berg hw->wiphy->bands[NL80211_BAND_5GHZ] =
106957fbcce3SJohannes Berg &rt2x00dev->bands[NL80211_BAND_5GHZ];
107057fbcce3SJohannes Berg memcpy(&rt2x00dev->bands[NL80211_BAND_5GHZ].ht_cap,
107133aca94dSKalle Valo &spec->ht, sizeof(spec->ht));
107233aca94dSKalle Valo }
107333aca94dSKalle Valo
107433aca94dSKalle Valo return 0;
107533aca94dSKalle Valo
107633aca94dSKalle Valo exit_free_channels:
107733aca94dSKalle Valo kfree(channels);
107833aca94dSKalle Valo rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n");
107933aca94dSKalle Valo return -ENOMEM;
108033aca94dSKalle Valo }
108133aca94dSKalle Valo
rt2x00lib_remove_hw(struct rt2x00_dev * rt2x00dev)108233aca94dSKalle Valo static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
108333aca94dSKalle Valo {
108433aca94dSKalle Valo if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
108533aca94dSKalle Valo ieee80211_unregister_hw(rt2x00dev->hw);
108633aca94dSKalle Valo
108757fbcce3SJohannes Berg if (likely(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ])) {
108857fbcce3SJohannes Berg kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels);
108957fbcce3SJohannes Berg kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->bitrates);
109057fbcce3SJohannes Berg rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
109157fbcce3SJohannes Berg rt2x00dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
109233aca94dSKalle Valo }
109333aca94dSKalle Valo
109433aca94dSKalle Valo kfree(rt2x00dev->spec.channels_info);
1095cbef9a83SArmin Wolf kfree(rt2x00dev->chan_survey);
109633aca94dSKalle Valo }
109733aca94dSKalle Valo
109847c40fd2SDavid Bauer static const struct ieee80211_tpt_blink rt2x00_tpt_blink[] = {
109947c40fd2SDavid Bauer { .throughput = 0 * 1024, .blink_time = 334 },
110047c40fd2SDavid Bauer { .throughput = 1 * 1024, .blink_time = 260 },
110147c40fd2SDavid Bauer { .throughput = 2 * 1024, .blink_time = 220 },
110247c40fd2SDavid Bauer { .throughput = 5 * 1024, .blink_time = 190 },
110347c40fd2SDavid Bauer { .throughput = 10 * 1024, .blink_time = 170 },
110447c40fd2SDavid Bauer { .throughput = 25 * 1024, .blink_time = 150 },
110547c40fd2SDavid Bauer { .throughput = 54 * 1024, .blink_time = 130 },
110647c40fd2SDavid Bauer { .throughput = 120 * 1024, .blink_time = 110 },
110747c40fd2SDavid Bauer { .throughput = 265 * 1024, .blink_time = 80 },
110847c40fd2SDavid Bauer { .throughput = 586 * 1024, .blink_time = 50 },
110947c40fd2SDavid Bauer };
111047c40fd2SDavid Bauer
rt2x00lib_probe_hw(struct rt2x00_dev * rt2x00dev)111133aca94dSKalle Valo static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
111233aca94dSKalle Valo {
111333aca94dSKalle Valo struct hw_mode_spec *spec = &rt2x00dev->spec;
111433aca94dSKalle Valo int status;
111533aca94dSKalle Valo
111633aca94dSKalle Valo if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
111733aca94dSKalle Valo return 0;
111833aca94dSKalle Valo
111933aca94dSKalle Valo /*
112033aca94dSKalle Valo * Initialize HW modes.
112133aca94dSKalle Valo */
112233aca94dSKalle Valo status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
112333aca94dSKalle Valo if (status)
112433aca94dSKalle Valo return status;
112533aca94dSKalle Valo
112633aca94dSKalle Valo /*
112733aca94dSKalle Valo * Initialize HW fields.
112833aca94dSKalle Valo */
112933aca94dSKalle Valo rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
113033aca94dSKalle Valo
113133aca94dSKalle Valo /*
113233aca94dSKalle Valo * Initialize extra TX headroom required.
113333aca94dSKalle Valo */
113433aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom =
113533aca94dSKalle Valo max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
113633aca94dSKalle Valo rt2x00dev->extra_tx_headroom);
113733aca94dSKalle Valo
113833aca94dSKalle Valo /*
113933aca94dSKalle Valo * Take TX headroom required for alignment into account.
114033aca94dSKalle Valo */
114133aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
114233aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
114333aca94dSKalle Valo else if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA))
114433aca94dSKalle Valo rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
114533aca94dSKalle Valo
114633aca94dSKalle Valo /*
114733aca94dSKalle Valo * Tell mac80211 about the size of our private STA structure.
114833aca94dSKalle Valo */
114933aca94dSKalle Valo rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta);
115033aca94dSKalle Valo
115133aca94dSKalle Valo /*
115233aca94dSKalle Valo * Allocate tx status FIFO for driver use.
115333aca94dSKalle Valo */
115433aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO)) {
115533aca94dSKalle Valo /*
115633aca94dSKalle Valo * Allocate the txstatus fifo. In the worst case the tx
115733aca94dSKalle Valo * status fifo has to hold the tx status of all entries
115833aca94dSKalle Valo * in all tx queues. Hence, calculate the kfifo size as
115933aca94dSKalle Valo * tx_queues * entry_num and round up to the nearest
116033aca94dSKalle Valo * power of 2.
116133aca94dSKalle Valo */
116233aca94dSKalle Valo int kfifo_size =
116333aca94dSKalle Valo roundup_pow_of_two(rt2x00dev->ops->tx_queues *
116433aca94dSKalle Valo rt2x00dev->tx->limit *
116533aca94dSKalle Valo sizeof(u32));
116633aca94dSKalle Valo
116733aca94dSKalle Valo status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
116833aca94dSKalle Valo GFP_KERNEL);
116933aca94dSKalle Valo if (status)
117033aca94dSKalle Valo return status;
117133aca94dSKalle Valo }
117233aca94dSKalle Valo
117333aca94dSKalle Valo /*
117433aca94dSKalle Valo * Initialize tasklets if used by the driver. Tasklets are
117533aca94dSKalle Valo * disabled until the interrupts are turned on. The driver
117633aca94dSKalle Valo * has to handle that.
117733aca94dSKalle Valo */
117833aca94dSKalle Valo #define RT2X00_TASKLET_INIT(taskletname) \
117933aca94dSKalle Valo if (rt2x00dev->ops->lib->taskletname) { \
1180a0d6ea9bSAllen Pais tasklet_setup(&rt2x00dev->taskletname, \
1181a0d6ea9bSAllen Pais rt2x00dev->ops->lib->taskletname); \
118233aca94dSKalle Valo }
118333aca94dSKalle Valo
118433aca94dSKalle Valo RT2X00_TASKLET_INIT(txstatus_tasklet);
118533aca94dSKalle Valo RT2X00_TASKLET_INIT(pretbtt_tasklet);
118633aca94dSKalle Valo RT2X00_TASKLET_INIT(tbtt_tasklet);
118733aca94dSKalle Valo RT2X00_TASKLET_INIT(rxdone_tasklet);
118833aca94dSKalle Valo RT2X00_TASKLET_INIT(autowake_tasklet);
118933aca94dSKalle Valo
119033aca94dSKalle Valo #undef RT2X00_TASKLET_INIT
119133aca94dSKalle Valo
119247c40fd2SDavid Bauer ieee80211_create_tpt_led_trigger(rt2x00dev->hw,
119347c40fd2SDavid Bauer IEEE80211_TPT_LEDTRIG_FL_RADIO,
119447c40fd2SDavid Bauer rt2x00_tpt_blink,
119547c40fd2SDavid Bauer ARRAY_SIZE(rt2x00_tpt_blink));
119647c40fd2SDavid Bauer
119733aca94dSKalle Valo /*
119833aca94dSKalle Valo * Register HW.
119933aca94dSKalle Valo */
120033aca94dSKalle Valo status = ieee80211_register_hw(rt2x00dev->hw);
120133aca94dSKalle Valo if (status)
120233aca94dSKalle Valo return status;
120333aca94dSKalle Valo
120433aca94dSKalle Valo set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
120533aca94dSKalle Valo
120633aca94dSKalle Valo return 0;
120733aca94dSKalle Valo }
120833aca94dSKalle Valo
120933aca94dSKalle Valo /*
121033aca94dSKalle Valo * Initialization/uninitialization handlers.
121133aca94dSKalle Valo */
rt2x00lib_uninitialize(struct rt2x00_dev * rt2x00dev)121233aca94dSKalle Valo static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
121333aca94dSKalle Valo {
121433aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
121533aca94dSKalle Valo return;
121633aca94dSKalle Valo
121733aca94dSKalle Valo /*
121833aca94dSKalle Valo * Stop rfkill polling.
121933aca94dSKalle Valo */
122033aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
122133aca94dSKalle Valo rt2x00rfkill_unregister(rt2x00dev);
122233aca94dSKalle Valo
122333aca94dSKalle Valo /*
122433aca94dSKalle Valo * Allow the HW to uninitialize.
122533aca94dSKalle Valo */
122633aca94dSKalle Valo rt2x00dev->ops->lib->uninitialize(rt2x00dev);
122733aca94dSKalle Valo
122833aca94dSKalle Valo /*
122933aca94dSKalle Valo * Free allocated queue entries.
123033aca94dSKalle Valo */
123133aca94dSKalle Valo rt2x00queue_uninitialize(rt2x00dev);
123233aca94dSKalle Valo }
123333aca94dSKalle Valo
rt2x00lib_initialize(struct rt2x00_dev * rt2x00dev)123433aca94dSKalle Valo static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
123533aca94dSKalle Valo {
123633aca94dSKalle Valo int status;
123733aca94dSKalle Valo
123833aca94dSKalle Valo if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
123933aca94dSKalle Valo return 0;
124033aca94dSKalle Valo
124133aca94dSKalle Valo /*
124233aca94dSKalle Valo * Allocate all queue entries.
124333aca94dSKalle Valo */
124433aca94dSKalle Valo status = rt2x00queue_initialize(rt2x00dev);
124533aca94dSKalle Valo if (status)
124633aca94dSKalle Valo return status;
124733aca94dSKalle Valo
124833aca94dSKalle Valo /*
124933aca94dSKalle Valo * Initialize the device.
125033aca94dSKalle Valo */
125133aca94dSKalle Valo status = rt2x00dev->ops->lib->initialize(rt2x00dev);
125233aca94dSKalle Valo if (status) {
125333aca94dSKalle Valo rt2x00queue_uninitialize(rt2x00dev);
125433aca94dSKalle Valo return status;
125533aca94dSKalle Valo }
125633aca94dSKalle Valo
125733aca94dSKalle Valo set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
125833aca94dSKalle Valo
125933aca94dSKalle Valo /*
126033aca94dSKalle Valo * Start rfkill polling.
126133aca94dSKalle Valo */
126233aca94dSKalle Valo if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
126333aca94dSKalle Valo rt2x00rfkill_register(rt2x00dev);
126433aca94dSKalle Valo
126533aca94dSKalle Valo return 0;
126633aca94dSKalle Valo }
126733aca94dSKalle Valo
rt2x00lib_start(struct rt2x00_dev * rt2x00dev)126833aca94dSKalle Valo int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
126933aca94dSKalle Valo {
127095844124SStanislaw Gruszka int retval = 0;
127133aca94dSKalle Valo
127233aca94dSKalle Valo /*
127333aca94dSKalle Valo * If this is the first interface which is added,
127433aca94dSKalle Valo * we should load the firmware now.
127533aca94dSKalle Valo */
127633aca94dSKalle Valo retval = rt2x00lib_load_firmware(rt2x00dev);
127733aca94dSKalle Valo if (retval)
127895844124SStanislaw Gruszka goto out;
127933aca94dSKalle Valo
128033aca94dSKalle Valo /*
128133aca94dSKalle Valo * Initialize the device.
128233aca94dSKalle Valo */
128333aca94dSKalle Valo retval = rt2x00lib_initialize(rt2x00dev);
128433aca94dSKalle Valo if (retval)
128595844124SStanislaw Gruszka goto out;
128633aca94dSKalle Valo
128733aca94dSKalle Valo rt2x00dev->intf_ap_count = 0;
128833aca94dSKalle Valo rt2x00dev->intf_sta_count = 0;
128933aca94dSKalle Valo rt2x00dev->intf_associated = 0;
1290*04cfe4a5SShiji Yang rt2x00dev->intf_beaconing = 0;
129133aca94dSKalle Valo
129233aca94dSKalle Valo /* Enable the radio */
129333aca94dSKalle Valo retval = rt2x00lib_enable_radio(rt2x00dev);
129433aca94dSKalle Valo if (retval)
129595844124SStanislaw Gruszka goto out;
129633aca94dSKalle Valo
129733aca94dSKalle Valo set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
129833aca94dSKalle Valo
129995844124SStanislaw Gruszka out:
130095844124SStanislaw Gruszka return retval;
130133aca94dSKalle Valo }
130233aca94dSKalle Valo
rt2x00lib_stop(struct rt2x00_dev * rt2x00dev)130333aca94dSKalle Valo void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
130433aca94dSKalle Valo {
130533aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
130633aca94dSKalle Valo return;
130733aca94dSKalle Valo
130833aca94dSKalle Valo /*
130933aca94dSKalle Valo * Perhaps we can add something smarter here,
131033aca94dSKalle Valo * but for now just disabling the radio should do.
131133aca94dSKalle Valo */
131233aca94dSKalle Valo rt2x00lib_disable_radio(rt2x00dev);
131333aca94dSKalle Valo
131433aca94dSKalle Valo rt2x00dev->intf_ap_count = 0;
131533aca94dSKalle Valo rt2x00dev->intf_sta_count = 0;
131633aca94dSKalle Valo rt2x00dev->intf_associated = 0;
1317*04cfe4a5SShiji Yang rt2x00dev->intf_beaconing = 0;
131833aca94dSKalle Valo }
131933aca94dSKalle Valo
rt2x00lib_set_if_combinations(struct rt2x00_dev * rt2x00dev)132033aca94dSKalle Valo static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev)
132133aca94dSKalle Valo {
132233aca94dSKalle Valo struct ieee80211_iface_limit *if_limit;
132333aca94dSKalle Valo struct ieee80211_iface_combination *if_combination;
132433aca94dSKalle Valo
132533aca94dSKalle Valo if (rt2x00dev->ops->max_ap_intf < 2)
132633aca94dSKalle Valo return;
132733aca94dSKalle Valo
132833aca94dSKalle Valo /*
132933aca94dSKalle Valo * Build up AP interface limits structure.
133033aca94dSKalle Valo */
133133aca94dSKalle Valo if_limit = &rt2x00dev->if_limits_ap;
133233aca94dSKalle Valo if_limit->max = rt2x00dev->ops->max_ap_intf;
133333aca94dSKalle Valo if_limit->types = BIT(NL80211_IFTYPE_AP);
133433aca94dSKalle Valo #ifdef CONFIG_MAC80211_MESH
133533aca94dSKalle Valo if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT);
133633aca94dSKalle Valo #endif
133733aca94dSKalle Valo
133833aca94dSKalle Valo /*
133933aca94dSKalle Valo * Build up AP interface combinations structure.
134033aca94dSKalle Valo */
134133aca94dSKalle Valo if_combination = &rt2x00dev->if_combinations[IF_COMB_AP];
134233aca94dSKalle Valo if_combination->limits = if_limit;
134333aca94dSKalle Valo if_combination->n_limits = 1;
134433aca94dSKalle Valo if_combination->max_interfaces = if_limit->max;
134533aca94dSKalle Valo if_combination->num_different_channels = 1;
134633aca94dSKalle Valo
134733aca94dSKalle Valo /*
134833aca94dSKalle Valo * Finally, specify the possible combinations to mac80211.
134933aca94dSKalle Valo */
135033aca94dSKalle Valo rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations;
135133aca94dSKalle Valo rt2x00dev->hw->wiphy->n_iface_combinations = 1;
135233aca94dSKalle Valo }
135333aca94dSKalle Valo
rt2x00dev_extra_tx_headroom(struct rt2x00_dev * rt2x00dev)135433aca94dSKalle Valo static unsigned int rt2x00dev_extra_tx_headroom(struct rt2x00_dev *rt2x00dev)
135533aca94dSKalle Valo {
135633aca94dSKalle Valo if (WARN_ON(!rt2x00dev->tx))
135733aca94dSKalle Valo return 0;
135833aca94dSKalle Valo
135933aca94dSKalle Valo if (rt2x00_is_usb(rt2x00dev))
136033aca94dSKalle Valo return rt2x00dev->tx[0].winfo_size + rt2x00dev->tx[0].desc_size;
136133aca94dSKalle Valo
136233aca94dSKalle Valo return rt2x00dev->tx[0].winfo_size;
136333aca94dSKalle Valo }
136433aca94dSKalle Valo
136533aca94dSKalle Valo /*
136633aca94dSKalle Valo * driver allocation handlers.
136733aca94dSKalle Valo */
rt2x00lib_probe_dev(struct rt2x00_dev * rt2x00dev)136833aca94dSKalle Valo int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
136933aca94dSKalle Valo {
137033aca94dSKalle Valo int retval = -ENOMEM;
137133aca94dSKalle Valo
137233aca94dSKalle Valo /*
137333aca94dSKalle Valo * Set possible interface combinations.
137433aca94dSKalle Valo */
137533aca94dSKalle Valo rt2x00lib_set_if_combinations(rt2x00dev);
137633aca94dSKalle Valo
137733aca94dSKalle Valo /*
137833aca94dSKalle Valo * Allocate the driver data memory, if necessary.
137933aca94dSKalle Valo */
138033aca94dSKalle Valo if (rt2x00dev->ops->drv_data_size > 0) {
138133aca94dSKalle Valo rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size,
138233aca94dSKalle Valo GFP_KERNEL);
138333aca94dSKalle Valo if (!rt2x00dev->drv_data) {
138433aca94dSKalle Valo retval = -ENOMEM;
138533aca94dSKalle Valo goto exit;
138633aca94dSKalle Valo }
138733aca94dSKalle Valo }
138833aca94dSKalle Valo
138933aca94dSKalle Valo spin_lock_init(&rt2x00dev->irqmask_lock);
139033aca94dSKalle Valo mutex_init(&rt2x00dev->csr_mutex);
1391c7d1c777SStanislaw Gruszka mutex_init(&rt2x00dev->conf_mutex);
139233aca94dSKalle Valo INIT_LIST_HEAD(&rt2x00dev->bar_list);
139333aca94dSKalle Valo spin_lock_init(&rt2x00dev->bar_list_lock);
1394e5ceab9dSStanislaw Gruszka hrtimer_init(&rt2x00dev->txstatus_timer, CLOCK_MONOTONIC,
1395e5ceab9dSStanislaw Gruszka HRTIMER_MODE_REL);
139633aca94dSKalle Valo
139733aca94dSKalle Valo set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
139833aca94dSKalle Valo
139933aca94dSKalle Valo /*
140033aca94dSKalle Valo * Make room for rt2x00_intf inside the per-interface
140133aca94dSKalle Valo * structure ieee80211_vif.
140233aca94dSKalle Valo */
140333aca94dSKalle Valo rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
140433aca94dSKalle Valo
140533aca94dSKalle Valo /*
140633aca94dSKalle Valo * rt2x00 devices can only use the last n bits of the MAC address
140733aca94dSKalle Valo * for virtual interfaces.
140833aca94dSKalle Valo */
140933aca94dSKalle Valo rt2x00dev->hw->wiphy->addr_mask[ETH_ALEN - 1] =
141033aca94dSKalle Valo (rt2x00dev->ops->max_ap_intf - 1);
141133aca94dSKalle Valo
141233aca94dSKalle Valo /*
141333aca94dSKalle Valo * Initialize work.
141433aca94dSKalle Valo */
141533aca94dSKalle Valo rt2x00dev->workqueue =
141633aca94dSKalle Valo alloc_ordered_workqueue("%s", 0, wiphy_name(rt2x00dev->hw->wiphy));
141733aca94dSKalle Valo if (!rt2x00dev->workqueue) {
141833aca94dSKalle Valo retval = -ENOMEM;
141933aca94dSKalle Valo goto exit;
142033aca94dSKalle Valo }
142133aca94dSKalle Valo
142233aca94dSKalle Valo INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
142333aca94dSKalle Valo INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
142433aca94dSKalle Valo INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep);
142533aca94dSKalle Valo
142633aca94dSKalle Valo /*
142733aca94dSKalle Valo * Let the driver probe the device to detect the capabilities.
142833aca94dSKalle Valo */
142933aca94dSKalle Valo retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
143033aca94dSKalle Valo if (retval) {
143133aca94dSKalle Valo rt2x00_err(rt2x00dev, "Failed to allocate device\n");
143233aca94dSKalle Valo goto exit;
143333aca94dSKalle Valo }
143433aca94dSKalle Valo
143533aca94dSKalle Valo /*
143633aca94dSKalle Valo * Allocate queue array.
143733aca94dSKalle Valo */
143833aca94dSKalle Valo retval = rt2x00queue_allocate(rt2x00dev);
143933aca94dSKalle Valo if (retval)
144033aca94dSKalle Valo goto exit;
144133aca94dSKalle Valo
144233aca94dSKalle Valo /* Cache TX headroom value */
144333aca94dSKalle Valo rt2x00dev->extra_tx_headroom = rt2x00dev_extra_tx_headroom(rt2x00dev);
144433aca94dSKalle Valo
144533aca94dSKalle Valo /*
144633aca94dSKalle Valo * Determine which operating modes are supported, all modes
144733aca94dSKalle Valo * which require beaconing, depend on the availability of
144833aca94dSKalle Valo * beacon entries.
144933aca94dSKalle Valo */
145033aca94dSKalle Valo rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
145133aca94dSKalle Valo if (rt2x00dev->bcn->limit > 0)
145233aca94dSKalle Valo rt2x00dev->hw->wiphy->interface_modes |=
145333aca94dSKalle Valo BIT(NL80211_IFTYPE_ADHOC) |
145433aca94dSKalle Valo #ifdef CONFIG_MAC80211_MESH
145533aca94dSKalle Valo BIT(NL80211_IFTYPE_MESH_POINT) |
145633aca94dSKalle Valo #endif
14578f205423SJohannes Berg BIT(NL80211_IFTYPE_AP);
145833aca94dSKalle Valo
145933aca94dSKalle Valo rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
146033aca94dSKalle Valo
1461ae44b502SAndrew Zaborowski wiphy_ext_feature_set(rt2x00dev->hw->wiphy,
1462ae44b502SAndrew Zaborowski NL80211_EXT_FEATURE_CQM_RSSI_LIST);
1463ae44b502SAndrew Zaborowski
146433aca94dSKalle Valo /*
146533aca94dSKalle Valo * Initialize ieee80211 structure.
146633aca94dSKalle Valo */
146733aca94dSKalle Valo retval = rt2x00lib_probe_hw(rt2x00dev);
146833aca94dSKalle Valo if (retval) {
146933aca94dSKalle Valo rt2x00_err(rt2x00dev, "Failed to initialize hw\n");
147033aca94dSKalle Valo goto exit;
147133aca94dSKalle Valo }
147233aca94dSKalle Valo
147333aca94dSKalle Valo /*
147433aca94dSKalle Valo * Register extra components.
147533aca94dSKalle Valo */
147633aca94dSKalle Valo rt2x00link_register(rt2x00dev);
147733aca94dSKalle Valo rt2x00leds_register(rt2x00dev);
147833aca94dSKalle Valo rt2x00debug_register(rt2x00dev);
147933aca94dSKalle Valo
148033aca94dSKalle Valo /*
148133aca94dSKalle Valo * Start rfkill polling.
148233aca94dSKalle Valo */
148333aca94dSKalle Valo if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
148433aca94dSKalle Valo rt2x00rfkill_register(rt2x00dev);
148533aca94dSKalle Valo
148633aca94dSKalle Valo return 0;
148733aca94dSKalle Valo
148833aca94dSKalle Valo exit:
148933aca94dSKalle Valo rt2x00lib_remove_dev(rt2x00dev);
149033aca94dSKalle Valo
149133aca94dSKalle Valo return retval;
149233aca94dSKalle Valo }
149333aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
149433aca94dSKalle Valo
rt2x00lib_remove_dev(struct rt2x00_dev * rt2x00dev)149533aca94dSKalle Valo void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
149633aca94dSKalle Valo {
149733aca94dSKalle Valo clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
149833aca94dSKalle Valo
149933aca94dSKalle Valo /*
150033aca94dSKalle Valo * Stop rfkill polling.
150133aca94dSKalle Valo */
150233aca94dSKalle Valo if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
150333aca94dSKalle Valo rt2x00rfkill_unregister(rt2x00dev);
150433aca94dSKalle Valo
150533aca94dSKalle Valo /*
150633aca94dSKalle Valo * Disable radio.
150733aca94dSKalle Valo */
150833aca94dSKalle Valo rt2x00lib_disable_radio(rt2x00dev);
150933aca94dSKalle Valo
151033aca94dSKalle Valo /*
151133aca94dSKalle Valo * Stop all work.
151233aca94dSKalle Valo */
151333aca94dSKalle Valo cancel_work_sync(&rt2x00dev->intf_work);
151433aca94dSKalle Valo cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
151533aca94dSKalle Valo cancel_work_sync(&rt2x00dev->sleep_work);
151633aca94dSKalle Valo
1517e5ceab9dSStanislaw Gruszka hrtimer_cancel(&rt2x00dev->txstatus_timer);
1518e5ceab9dSStanislaw Gruszka
151933aca94dSKalle Valo /*
152033aca94dSKalle Valo * Kill the tx status tasklet.
152133aca94dSKalle Valo */
152233aca94dSKalle Valo tasklet_kill(&rt2x00dev->txstatus_tasklet);
152333aca94dSKalle Valo tasklet_kill(&rt2x00dev->pretbtt_tasklet);
152433aca94dSKalle Valo tasklet_kill(&rt2x00dev->tbtt_tasklet);
152533aca94dSKalle Valo tasklet_kill(&rt2x00dev->rxdone_tasklet);
152633aca94dSKalle Valo tasklet_kill(&rt2x00dev->autowake_tasklet);
152733aca94dSKalle Valo
152833aca94dSKalle Valo /*
152933aca94dSKalle Valo * Uninitialize device.
153033aca94dSKalle Valo */
153133aca94dSKalle Valo rt2x00lib_uninitialize(rt2x00dev);
153233aca94dSKalle Valo
15336232c174SStanislaw Gruszka if (rt2x00dev->workqueue)
15346232c174SStanislaw Gruszka destroy_workqueue(rt2x00dev->workqueue);
15356232c174SStanislaw Gruszka
15366232c174SStanislaw Gruszka /*
15376232c174SStanislaw Gruszka * Free the tx status fifo.
15386232c174SStanislaw Gruszka */
15396232c174SStanislaw Gruszka kfifo_free(&rt2x00dev->txstatus_fifo);
15406232c174SStanislaw Gruszka
154133aca94dSKalle Valo /*
154233aca94dSKalle Valo * Free extra components
154333aca94dSKalle Valo */
154433aca94dSKalle Valo rt2x00debug_deregister(rt2x00dev);
154533aca94dSKalle Valo rt2x00leds_unregister(rt2x00dev);
154633aca94dSKalle Valo
154733aca94dSKalle Valo /*
154833aca94dSKalle Valo * Free ieee80211_hw memory.
154933aca94dSKalle Valo */
155033aca94dSKalle Valo rt2x00lib_remove_hw(rt2x00dev);
155133aca94dSKalle Valo
155233aca94dSKalle Valo /*
155333aca94dSKalle Valo * Free firmware image.
155433aca94dSKalle Valo */
155533aca94dSKalle Valo rt2x00lib_free_firmware(rt2x00dev);
155633aca94dSKalle Valo
155733aca94dSKalle Valo /*
155833aca94dSKalle Valo * Free queue structures.
155933aca94dSKalle Valo */
156033aca94dSKalle Valo rt2x00queue_free(rt2x00dev);
156133aca94dSKalle Valo
156233aca94dSKalle Valo /*
156333aca94dSKalle Valo * Free the driver data.
156433aca94dSKalle Valo */
156533aca94dSKalle Valo kfree(rt2x00dev->drv_data);
156633aca94dSKalle Valo }
156733aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
156833aca94dSKalle Valo
156933aca94dSKalle Valo /*
157033aca94dSKalle Valo * Device state handlers
157133aca94dSKalle Valo */
rt2x00lib_suspend(struct rt2x00_dev * rt2x00dev)1572560a218dSVaibhav Gupta int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev)
157333aca94dSKalle Valo {
157433aca94dSKalle Valo rt2x00_dbg(rt2x00dev, "Going to sleep\n");
157533aca94dSKalle Valo
157633aca94dSKalle Valo /*
157733aca94dSKalle Valo * Prevent mac80211 from accessing driver while suspended.
157833aca94dSKalle Valo */
157933aca94dSKalle Valo if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
158033aca94dSKalle Valo return 0;
158133aca94dSKalle Valo
158233aca94dSKalle Valo /*
158333aca94dSKalle Valo * Cleanup as much as possible.
158433aca94dSKalle Valo */
158533aca94dSKalle Valo rt2x00lib_uninitialize(rt2x00dev);
158633aca94dSKalle Valo
158733aca94dSKalle Valo /*
158833aca94dSKalle Valo * Suspend/disable extra components.
158933aca94dSKalle Valo */
159033aca94dSKalle Valo rt2x00leds_suspend(rt2x00dev);
159133aca94dSKalle Valo rt2x00debug_deregister(rt2x00dev);
159233aca94dSKalle Valo
159333aca94dSKalle Valo /*
159433aca94dSKalle Valo * Set device mode to sleep for power management,
159533aca94dSKalle Valo * on some hardware this call seems to consistently fail.
159633aca94dSKalle Valo * From the specifications it is hard to tell why it fails,
159733aca94dSKalle Valo * and if this is a "bad thing".
159833aca94dSKalle Valo * Overall it is safe to just ignore the failure and
159933aca94dSKalle Valo * continue suspending. The only downside is that the
160033aca94dSKalle Valo * device will not be in optimal power save mode, but with
160133aca94dSKalle Valo * the radio and the other components already disabled the
160233aca94dSKalle Valo * device is as good as disabled.
160333aca94dSKalle Valo */
160433aca94dSKalle Valo if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
160533aca94dSKalle Valo rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n");
160633aca94dSKalle Valo
160733aca94dSKalle Valo return 0;
160833aca94dSKalle Valo }
160933aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
161033aca94dSKalle Valo
rt2x00lib_resume(struct rt2x00_dev * rt2x00dev)161133aca94dSKalle Valo int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
161233aca94dSKalle Valo {
161333aca94dSKalle Valo rt2x00_dbg(rt2x00dev, "Waking up\n");
161433aca94dSKalle Valo
161533aca94dSKalle Valo /*
161633aca94dSKalle Valo * Restore/enable extra components.
161733aca94dSKalle Valo */
161833aca94dSKalle Valo rt2x00debug_register(rt2x00dev);
161933aca94dSKalle Valo rt2x00leds_resume(rt2x00dev);
162033aca94dSKalle Valo
162133aca94dSKalle Valo /*
162233aca94dSKalle Valo * We are ready again to receive requests from mac80211.
162333aca94dSKalle Valo */
162433aca94dSKalle Valo set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
162533aca94dSKalle Valo
162633aca94dSKalle Valo return 0;
162733aca94dSKalle Valo }
162833aca94dSKalle Valo EXPORT_SYMBOL_GPL(rt2x00lib_resume);
162933aca94dSKalle Valo
163033aca94dSKalle Valo /*
163133aca94dSKalle Valo * rt2x00lib module information.
163233aca94dSKalle Valo */
163333aca94dSKalle Valo MODULE_AUTHOR(DRV_PROJECT);
163433aca94dSKalle Valo MODULE_VERSION(DRV_VERSION);
163533aca94dSKalle Valo MODULE_DESCRIPTION("rt2x00 library");
163633aca94dSKalle Valo MODULE_LICENSE("GPL");
1637