Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003     Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
0004     Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
0005     <http://rt2x00.serialmonkey.com>
0006 
0007  */
0008 
0009 /*
0010     Module: rt2x00lib
0011     Abstract: rt2x00 generic device routines.
0012  */
0013 
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/slab.h>
0017 #include <linux/log2.h>
0018 #include <linux/of.h>
0019 #include <linux/of_net.h>
0020 
0021 #include "rt2x00.h"
0022 #include "rt2x00lib.h"
0023 
0024 /*
0025  * Utility functions.
0026  */
0027 u32 rt2x00lib_get_bssidx(struct rt2x00_dev *rt2x00dev,
0028              struct ieee80211_vif *vif)
0029 {
0030     /*
0031      * When in STA mode, bssidx is always 0 otherwise local_address[5]
0032      * contains the bss number, see BSS_ID_MASK comments for details.
0033      */
0034     if (rt2x00dev->intf_sta_count)
0035         return 0;
0036     return vif->addr[5] & (rt2x00dev->ops->max_ap_intf - 1);
0037 }
0038 EXPORT_SYMBOL_GPL(rt2x00lib_get_bssidx);
0039 
0040 /*
0041  * Radio control handlers.
0042  */
0043 int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
0044 {
0045     int status;
0046 
0047     /*
0048      * Don't enable the radio twice.
0049      * And check if the hardware button has been disabled.
0050      */
0051     if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0052         return 0;
0053 
0054     /*
0055      * Initialize all data queues.
0056      */
0057     rt2x00queue_init_queues(rt2x00dev);
0058 
0059     /*
0060      * Enable radio.
0061      */
0062     status =
0063         rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
0064     if (status)
0065         return status;
0066 
0067     rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
0068 
0069     rt2x00leds_led_radio(rt2x00dev, true);
0070     rt2x00led_led_activity(rt2x00dev, true);
0071 
0072     set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags);
0073 
0074     /*
0075      * Enable queues.
0076      */
0077     rt2x00queue_start_queues(rt2x00dev);
0078     rt2x00link_start_tuner(rt2x00dev);
0079 
0080     /*
0081      * Start watchdog monitoring.
0082      */
0083     rt2x00link_start_watchdog(rt2x00dev);
0084 
0085     return 0;
0086 }
0087 
0088 void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
0089 {
0090     if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0091         return;
0092 
0093     /*
0094      * Stop watchdog monitoring.
0095      */
0096     rt2x00link_stop_watchdog(rt2x00dev);
0097 
0098     /*
0099      * Stop all queues
0100      */
0101     rt2x00link_stop_tuner(rt2x00dev);
0102     rt2x00queue_stop_queues(rt2x00dev);
0103     rt2x00queue_flush_queues(rt2x00dev, true);
0104 
0105     /*
0106      * Disable radio.
0107      */
0108     rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
0109     rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
0110     rt2x00led_led_activity(rt2x00dev, false);
0111     rt2x00leds_led_radio(rt2x00dev, false);
0112 }
0113 
0114 static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
0115                       struct ieee80211_vif *vif)
0116 {
0117     struct rt2x00_dev *rt2x00dev = data;
0118     struct rt2x00_intf *intf = vif_to_intf(vif);
0119 
0120     /*
0121      * It is possible the radio was disabled while the work had been
0122      * scheduled. If that happens we should return here immediately,
0123      * note that in the spinlock protected area above the delayed_flags
0124      * have been cleared correctly.
0125      */
0126     if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0127         return;
0128 
0129     if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags)) {
0130         mutex_lock(&intf->beacon_skb_mutex);
0131         rt2x00queue_update_beacon(rt2x00dev, vif);
0132         mutex_unlock(&intf->beacon_skb_mutex);
0133     }
0134 }
0135 
0136 static void rt2x00lib_intf_scheduled(struct work_struct *work)
0137 {
0138     struct rt2x00_dev *rt2x00dev =
0139         container_of(work, struct rt2x00_dev, intf_work);
0140 
0141     /*
0142      * Iterate over each interface and perform the
0143      * requested configurations.
0144      */
0145     ieee80211_iterate_active_interfaces(rt2x00dev->hw,
0146                         IEEE80211_IFACE_ITER_RESUME_ALL,
0147                         rt2x00lib_intf_scheduled_iter,
0148                         rt2x00dev);
0149 }
0150 
0151 static void rt2x00lib_autowakeup(struct work_struct *work)
0152 {
0153     struct rt2x00_dev *rt2x00dev =
0154         container_of(work, struct rt2x00_dev, autowakeup_work.work);
0155 
0156     if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
0157         return;
0158 
0159     if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
0160         rt2x00_err(rt2x00dev, "Device failed to wakeup\n");
0161     clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
0162 }
0163 
0164 /*
0165  * Interrupt context handlers.
0166  */
0167 static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
0168                      struct ieee80211_vif *vif)
0169 {
0170     struct ieee80211_tx_control control = {};
0171     struct rt2x00_dev *rt2x00dev = data;
0172     struct sk_buff *skb;
0173 
0174     /*
0175      * Only AP mode interfaces do broad- and multicast buffering
0176      */
0177     if (vif->type != NL80211_IFTYPE_AP)
0178         return;
0179 
0180     /*
0181      * Send out buffered broad- and multicast frames
0182      */
0183     skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
0184     while (skb) {
0185         rt2x00mac_tx(rt2x00dev->hw, &control, skb);
0186         skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
0187     }
0188 }
0189 
0190 static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
0191                     struct ieee80211_vif *vif)
0192 {
0193     struct rt2x00_dev *rt2x00dev = data;
0194 
0195     if (vif->type != NL80211_IFTYPE_AP &&
0196         vif->type != NL80211_IFTYPE_ADHOC &&
0197         vif->type != NL80211_IFTYPE_MESH_POINT)
0198         return;
0199 
0200     /*
0201      * Update the beacon without locking. This is safe on PCI devices
0202      * as they only update the beacon periodically here. This should
0203      * never be called for USB devices.
0204      */
0205     WARN_ON(rt2x00_is_usb(rt2x00dev));
0206     rt2x00queue_update_beacon(rt2x00dev, vif);
0207 }
0208 
0209 void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
0210 {
0211     if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0212         return;
0213 
0214     /* send buffered bc/mc frames out for every bssid */
0215     ieee80211_iterate_active_interfaces_atomic(
0216         rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
0217         rt2x00lib_bc_buffer_iter, rt2x00dev);
0218     /*
0219      * Devices with pre tbtt interrupt don't need to update the beacon
0220      * here as they will fetch the next beacon directly prior to
0221      * transmission.
0222      */
0223     if (rt2x00_has_cap_pre_tbtt_interrupt(rt2x00dev))
0224         return;
0225 
0226     /* fetch next beacon */
0227     ieee80211_iterate_active_interfaces_atomic(
0228         rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
0229         rt2x00lib_beaconupdate_iter, rt2x00dev);
0230 }
0231 EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
0232 
0233 void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
0234 {
0235     if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0236         return;
0237 
0238     /* fetch next beacon */
0239     ieee80211_iterate_active_interfaces_atomic(
0240         rt2x00dev->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
0241         rt2x00lib_beaconupdate_iter, rt2x00dev);
0242 }
0243 EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);
0244 
0245 void rt2x00lib_dmastart(struct queue_entry *entry)
0246 {
0247     set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
0248     rt2x00queue_index_inc(entry, Q_INDEX);
0249 }
0250 EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);
0251 
0252 void rt2x00lib_dmadone(struct queue_entry *entry)
0253 {
0254     set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
0255     clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
0256     rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE);
0257 }
0258 EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);
0259 
0260 static inline int rt2x00lib_txdone_bar_status(struct queue_entry *entry)
0261 {
0262     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
0263     struct ieee80211_bar *bar = (void *) entry->skb->data;
0264     struct rt2x00_bar_list_entry *bar_entry;
0265     int ret;
0266 
0267     if (likely(!ieee80211_is_back_req(bar->frame_control)))
0268         return 0;
0269 
0270     /*
0271      * Unlike all other frames, the status report for BARs does
0272      * not directly come from the hardware as it is incapable of
0273      * matching a BA to a previously send BAR. The hardware will
0274      * report all BARs as if they weren't acked at all.
0275      *
0276      * Instead the RX-path will scan for incoming BAs and set the
0277      * block_acked flag if it sees one that was likely caused by
0278      * a BAR from us.
0279      *
0280      * Remove remaining BARs here and return their status for
0281      * TX done processing.
0282      */
0283     ret = 0;
0284     rcu_read_lock();
0285     list_for_each_entry_rcu(bar_entry, &rt2x00dev->bar_list, list) {
0286         if (bar_entry->entry != entry)
0287             continue;
0288 
0289         spin_lock_bh(&rt2x00dev->bar_list_lock);
0290         /* Return whether this BAR was blockacked or not */
0291         ret = bar_entry->block_acked;
0292         /* Remove the BAR from our checklist */
0293         list_del_rcu(&bar_entry->list);
0294         spin_unlock_bh(&rt2x00dev->bar_list_lock);
0295         kfree_rcu(bar_entry, head);
0296 
0297         break;
0298     }
0299     rcu_read_unlock();
0300 
0301     return ret;
0302 }
0303 
0304 static void rt2x00lib_fill_tx_status(struct rt2x00_dev *rt2x00dev,
0305                      struct ieee80211_tx_info *tx_info,
0306                      struct skb_frame_desc *skbdesc,
0307                      struct txdone_entry_desc *txdesc,
0308                      bool success)
0309 {
0310     u8 rate_idx, rate_flags, retry_rates;
0311     int i;
0312 
0313     rate_idx = skbdesc->tx_rate_idx;
0314     rate_flags = skbdesc->tx_rate_flags;
0315     retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
0316         (txdesc->retry + 1) : 1;
0317 
0318     /*
0319      * Initialize TX status
0320      */
0321     memset(&tx_info->status, 0, sizeof(tx_info->status));
0322     tx_info->status.ack_signal = 0;
0323 
0324     /*
0325      * Frame was send with retries, hardware tried
0326      * different rates to send out the frame, at each
0327      * retry it lowered the rate 1 step except when the
0328      * lowest rate was used.
0329      */
0330     for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
0331         tx_info->status.rates[i].idx = rate_idx - i;
0332         tx_info->status.rates[i].flags = rate_flags;
0333 
0334         if (rate_idx - i == 0) {
0335             /*
0336              * The lowest rate (index 0) was used until the
0337              * number of max retries was reached.
0338              */
0339             tx_info->status.rates[i].count = retry_rates - i;
0340             i++;
0341             break;
0342         }
0343         tx_info->status.rates[i].count = 1;
0344     }
0345     if (i < (IEEE80211_TX_MAX_RATES - 1))
0346         tx_info->status.rates[i].idx = -1; /* terminate */
0347 
0348     if (test_bit(TXDONE_NO_ACK_REQ, &txdesc->flags))
0349         tx_info->flags |= IEEE80211_TX_CTL_NO_ACK;
0350 
0351     if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
0352         if (success)
0353             tx_info->flags |= IEEE80211_TX_STAT_ACK;
0354         else
0355             rt2x00dev->low_level_stats.dot11ACKFailureCount++;
0356     }
0357 
0358     /*
0359      * Every single frame has it's own tx status, hence report
0360      * every frame as ampdu of size 1.
0361      *
0362      * TODO: if we can find out how many frames were aggregated
0363      * by the hw we could provide the real ampdu_len to mac80211
0364      * which would allow the rc algorithm to better decide on
0365      * which rates are suitable.
0366      */
0367     if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
0368         tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
0369         tx_info->flags |= IEEE80211_TX_STAT_AMPDU |
0370                   IEEE80211_TX_CTL_AMPDU;
0371         tx_info->status.ampdu_len = 1;
0372         tx_info->status.ampdu_ack_len = success ? 1 : 0;
0373     }
0374 
0375     if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
0376         if (success)
0377             rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
0378         else
0379             rt2x00dev->low_level_stats.dot11RTSFailureCount++;
0380     }
0381 }
0382 
0383 static void rt2x00lib_clear_entry(struct rt2x00_dev *rt2x00dev,
0384                   struct queue_entry *entry)
0385 {
0386     /*
0387      * Make this entry available for reuse.
0388      */
0389     entry->skb = NULL;
0390     entry->flags = 0;
0391 
0392     rt2x00dev->ops->lib->clear_entry(entry);
0393 
0394     rt2x00queue_index_inc(entry, Q_INDEX_DONE);
0395 
0396     /*
0397      * If the data queue was below the threshold before the txdone
0398      * handler we must make sure the packet queue in the mac80211 stack
0399      * is reenabled when the txdone handler has finished. This has to be
0400      * serialized with rt2x00mac_tx(), otherwise we can wake up queue
0401      * before it was stopped.
0402      */
0403     spin_lock_bh(&entry->queue->tx_lock);
0404     if (!rt2x00queue_threshold(entry->queue))
0405         rt2x00queue_unpause_queue(entry->queue);
0406     spin_unlock_bh(&entry->queue->tx_lock);
0407 }
0408 
0409 void rt2x00lib_txdone_nomatch(struct queue_entry *entry,
0410                   struct txdone_entry_desc *txdesc)
0411 {
0412     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
0413     struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
0414     struct ieee80211_tx_info txinfo = {};
0415     bool success;
0416 
0417     /*
0418      * Unmap the skb.
0419      */
0420     rt2x00queue_unmap_skb(entry);
0421 
0422     /*
0423      * Signal that the TX descriptor is no longer in the skb.
0424      */
0425     skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
0426 
0427     /*
0428      * Send frame to debugfs immediately, after this call is completed
0429      * we are going to overwrite the skb->cb array.
0430      */
0431     rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry);
0432 
0433     /*
0434      * Determine if the frame has been successfully transmitted and
0435      * remove BARs from our check list while checking for their
0436      * TX status.
0437      */
0438     success =
0439         rt2x00lib_txdone_bar_status(entry) ||
0440         test_bit(TXDONE_SUCCESS, &txdesc->flags);
0441 
0442     if (!test_bit(TXDONE_UNKNOWN, &txdesc->flags)) {
0443         /*
0444          * Update TX statistics.
0445          */
0446         rt2x00dev->link.qual.tx_success += success;
0447         rt2x00dev->link.qual.tx_failed += !success;
0448 
0449         rt2x00lib_fill_tx_status(rt2x00dev, &txinfo, skbdesc, txdesc,
0450                      success);
0451         ieee80211_tx_status_noskb(rt2x00dev->hw, skbdesc->sta, &txinfo);
0452     }
0453 
0454     dev_kfree_skb_any(entry->skb);
0455     rt2x00lib_clear_entry(rt2x00dev, entry);
0456 }
0457 EXPORT_SYMBOL_GPL(rt2x00lib_txdone_nomatch);
0458 
0459 void rt2x00lib_txdone(struct queue_entry *entry,
0460               struct txdone_entry_desc *txdesc)
0461 {
0462     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
0463     struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
0464     struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
0465     u8 skbdesc_flags = skbdesc->flags;
0466     unsigned int header_length;
0467     bool success;
0468 
0469     /*
0470      * Unmap the skb.
0471      */
0472     rt2x00queue_unmap_skb(entry);
0473 
0474     /*
0475      * Remove the extra tx headroom from the skb.
0476      */
0477     skb_pull(entry->skb, rt2x00dev->extra_tx_headroom);
0478 
0479     /*
0480      * Signal that the TX descriptor is no longer in the skb.
0481      */
0482     skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;
0483 
0484     /*
0485      * Determine the length of 802.11 header.
0486      */
0487     header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
0488 
0489     /*
0490      * Remove L2 padding which was added during
0491      */
0492     if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
0493         rt2x00queue_remove_l2pad(entry->skb, header_length);
0494 
0495     /*
0496      * If the IV/EIV data was stripped from the frame before it was
0497      * passed to the hardware, we should now reinsert it again because
0498      * mac80211 will expect the same data to be present it the
0499      * frame as it was passed to us.
0500      */
0501     if (rt2x00_has_cap_hw_crypto(rt2x00dev))
0502         rt2x00crypto_tx_insert_iv(entry->skb, header_length);
0503 
0504     /*
0505      * Send frame to debugfs immediately, after this call is completed
0506      * we are going to overwrite the skb->cb array.
0507      */
0508     rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry);
0509 
0510     /*
0511      * Determine if the frame has been successfully transmitted and
0512      * remove BARs from our check list while checking for their
0513      * TX status.
0514      */
0515     success =
0516         rt2x00lib_txdone_bar_status(entry) ||
0517         test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
0518         test_bit(TXDONE_UNKNOWN, &txdesc->flags);
0519 
0520     /*
0521      * Update TX statistics.
0522      */
0523     rt2x00dev->link.qual.tx_success += success;
0524     rt2x00dev->link.qual.tx_failed += !success;
0525 
0526     rt2x00lib_fill_tx_status(rt2x00dev, tx_info, skbdesc, txdesc, success);
0527 
0528     /*
0529      * Only send the status report to mac80211 when it's a frame
0530      * that originated in mac80211. If this was a extra frame coming
0531      * through a mac80211 library call (RTS/CTS) then we should not
0532      * send the status report back.
0533      */
0534     if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
0535         if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TASKLET_CONTEXT))
0536             ieee80211_tx_status(rt2x00dev->hw, entry->skb);
0537         else
0538             ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
0539     } else {
0540         dev_kfree_skb_any(entry->skb);
0541     }
0542 
0543     rt2x00lib_clear_entry(rt2x00dev, entry);
0544 }
0545 EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
0546 
0547 void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
0548 {
0549     struct txdone_entry_desc txdesc;
0550 
0551     txdesc.flags = 0;
0552     __set_bit(status, &txdesc.flags);
0553     txdesc.retry = 0;
0554 
0555     rt2x00lib_txdone(entry, &txdesc);
0556 }
0557 EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo);
0558 
0559 static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
0560 {
0561     struct ieee80211_mgmt *mgmt = (void *)data;
0562     u8 *pos, *end;
0563 
0564     pos = (u8 *)mgmt->u.beacon.variable;
0565     end = data + len;
0566     while (pos < end) {
0567         if (pos + 2 + pos[1] > end)
0568             return NULL;
0569 
0570         if (pos[0] == ie)
0571             return pos;
0572 
0573         pos += 2 + pos[1];
0574     }
0575 
0576     return NULL;
0577 }
0578 
0579 static void rt2x00lib_sleep(struct work_struct *work)
0580 {
0581     struct rt2x00_dev *rt2x00dev =
0582         container_of(work, struct rt2x00_dev, sleep_work);
0583 
0584     if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
0585         return;
0586 
0587     /*
0588      * Check again is powersaving is enabled, to prevent races from delayed
0589      * work execution.
0590      */
0591     if (!test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
0592         rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
0593                  IEEE80211_CONF_CHANGE_PS);
0594 }
0595 
0596 static void rt2x00lib_rxdone_check_ba(struct rt2x00_dev *rt2x00dev,
0597                       struct sk_buff *skb,
0598                       struct rxdone_entry_desc *rxdesc)
0599 {
0600     struct rt2x00_bar_list_entry *entry;
0601     struct ieee80211_bar *ba = (void *)skb->data;
0602 
0603     if (likely(!ieee80211_is_back(ba->frame_control)))
0604         return;
0605 
0606     if (rxdesc->size < sizeof(*ba) + FCS_LEN)
0607         return;
0608 
0609     rcu_read_lock();
0610     list_for_each_entry_rcu(entry, &rt2x00dev->bar_list, list) {
0611 
0612         if (ba->start_seq_num != entry->start_seq_num)
0613             continue;
0614 
0615 #define TID_CHECK(a, b) (                       \
0616     ((a) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)) ==    \
0617     ((b) & cpu_to_le16(IEEE80211_BAR_CTRL_TID_INFO_MASK)))      \
0618 
0619         if (!TID_CHECK(ba->control, entry->control))
0620             continue;
0621 
0622 #undef TID_CHECK
0623 
0624         if (!ether_addr_equal_64bits(ba->ra, entry->ta))
0625             continue;
0626 
0627         if (!ether_addr_equal_64bits(ba->ta, entry->ra))
0628             continue;
0629 
0630         /* Mark BAR since we received the according BA */
0631         spin_lock_bh(&rt2x00dev->bar_list_lock);
0632         entry->block_acked = 1;
0633         spin_unlock_bh(&rt2x00dev->bar_list_lock);
0634         break;
0635     }
0636     rcu_read_unlock();
0637 
0638 }
0639 
0640 static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
0641                       struct sk_buff *skb,
0642                       struct rxdone_entry_desc *rxdesc)
0643 {
0644     struct ieee80211_hdr *hdr = (void *) skb->data;
0645     struct ieee80211_tim_ie *tim_ie;
0646     u8 *tim;
0647     u8 tim_len;
0648     bool cam;
0649 
0650     /* If this is not a beacon, or if mac80211 has no powersaving
0651      * configured, or if the device is already in powersaving mode
0652      * we can exit now. */
0653     if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
0654            !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
0655         return;
0656 
0657     /* min. beacon length + FCS_LEN */
0658     if (skb->len <= 40 + FCS_LEN)
0659         return;
0660 
0661     /* and only beacons from the associated BSSID, please */
0662     if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
0663         !rt2x00dev->aid)
0664         return;
0665 
0666     rt2x00dev->last_beacon = jiffies;
0667 
0668     tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
0669     if (!tim)
0670         return;
0671 
0672     if (tim[1] < sizeof(*tim_ie))
0673         return;
0674 
0675     tim_len = tim[1];
0676     tim_ie = (struct ieee80211_tim_ie *) &tim[2];
0677 
0678     /* Check whenever the PHY can be turned off again. */
0679 
0680     /* 1. What about buffered unicast traffic for our AID? */
0681     cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);
0682 
0683     /* 2. Maybe the AP wants to send multicast/broadcast data? */
0684     cam |= (tim_ie->bitmap_ctrl & 0x01);
0685 
0686     if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
0687         queue_work(rt2x00dev->workqueue, &rt2x00dev->sleep_work);
0688 }
0689 
0690 static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
0691                     struct rxdone_entry_desc *rxdesc)
0692 {
0693     struct ieee80211_supported_band *sband;
0694     const struct rt2x00_rate *rate;
0695     unsigned int i;
0696     int signal = rxdesc->signal;
0697     int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);
0698 
0699     switch (rxdesc->rate_mode) {
0700     case RATE_MODE_CCK:
0701     case RATE_MODE_OFDM:
0702         /*
0703          * For non-HT rates the MCS value needs to contain the
0704          * actually used rate modulation (CCK or OFDM).
0705          */
0706         if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
0707             signal = RATE_MCS(rxdesc->rate_mode, signal);
0708 
0709         sband = &rt2x00dev->bands[rt2x00dev->curr_band];
0710         for (i = 0; i < sband->n_bitrates; i++) {
0711             rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
0712             if (((type == RXDONE_SIGNAL_PLCP) &&
0713                  (rate->plcp == signal)) ||
0714                 ((type == RXDONE_SIGNAL_BITRATE) &&
0715                   (rate->bitrate == signal)) ||
0716                 ((type == RXDONE_SIGNAL_MCS) &&
0717                   (rate->mcs == signal))) {
0718                 return i;
0719             }
0720         }
0721         break;
0722     case RATE_MODE_HT_MIX:
0723     case RATE_MODE_HT_GREENFIELD:
0724         if (signal >= 0 && signal <= 76)
0725             return signal;
0726         break;
0727     default:
0728         break;
0729     }
0730 
0731     rt2x00_warn(rt2x00dev, "Frame received with unrecognized signal, mode=0x%.4x, signal=0x%.4x, type=%d\n",
0732             rxdesc->rate_mode, signal, type);
0733     return 0;
0734 }
0735 
0736 void rt2x00lib_rxdone(struct queue_entry *entry, gfp_t gfp)
0737 {
0738     struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
0739     struct rxdone_entry_desc rxdesc;
0740     struct sk_buff *skb;
0741     struct ieee80211_rx_status *rx_status;
0742     unsigned int header_length;
0743     int rate_idx;
0744 
0745     if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
0746         !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0747         goto submit_entry;
0748 
0749     if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
0750         goto submit_entry;
0751 
0752     /*
0753      * Allocate a new sk_buffer. If no new buffer available, drop the
0754      * received frame and reuse the existing buffer.
0755      */
0756     skb = rt2x00queue_alloc_rxskb(entry, gfp);
0757     if (!skb)
0758         goto submit_entry;
0759 
0760     /*
0761      * Unmap the skb.
0762      */
0763     rt2x00queue_unmap_skb(entry);
0764 
0765     /*
0766      * Extract the RXD details.
0767      */
0768     memset(&rxdesc, 0, sizeof(rxdesc));
0769     rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
0770 
0771     /*
0772      * Check for valid size in case we get corrupted descriptor from
0773      * hardware.
0774      */
0775     if (unlikely(rxdesc.size == 0 ||
0776              rxdesc.size > entry->queue->data_size)) {
0777         rt2x00_err(rt2x00dev, "Wrong frame size %d max %d\n",
0778                rxdesc.size, entry->queue->data_size);
0779         dev_kfree_skb(entry->skb);
0780         goto renew_skb;
0781     }
0782 
0783     /*
0784      * The data behind the ieee80211 header must be
0785      * aligned on a 4 byte boundary.
0786      */
0787     header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
0788 
0789     /*
0790      * Hardware might have stripped the IV/EIV/ICV data,
0791      * in that case it is possible that the data was
0792      * provided separately (through hardware descriptor)
0793      * in which case we should reinsert the data into the frame.
0794      */
0795     if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
0796         (rxdesc.flags & RX_FLAG_IV_STRIPPED))
0797         rt2x00crypto_rx_insert_iv(entry->skb, header_length,
0798                       &rxdesc);
0799     else if (header_length &&
0800          (rxdesc.size > header_length) &&
0801          (rxdesc.dev_flags & RXDONE_L2PAD))
0802         rt2x00queue_remove_l2pad(entry->skb, header_length);
0803 
0804     /* Trim buffer to correct size */
0805     skb_trim(entry->skb, rxdesc.size);
0806 
0807     /*
0808      * Translate the signal to the correct bitrate index.
0809      */
0810     rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
0811     if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
0812         rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
0813         rxdesc.encoding = RX_ENC_HT;
0814 
0815     /*
0816      * Check if this is a beacon, and more frames have been
0817      * buffered while we were in powersaving mode.
0818      */
0819     rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);
0820 
0821     /*
0822      * Check for incoming BlockAcks to match to the BlockAckReqs
0823      * we've send out.
0824      */
0825     rt2x00lib_rxdone_check_ba(rt2x00dev, entry->skb, &rxdesc);
0826 
0827     /*
0828      * Update extra components
0829      */
0830     rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
0831     rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
0832     rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry);
0833 
0834     /*
0835      * Initialize RX status information, and send frame
0836      * to mac80211.
0837      */
0838     rx_status = IEEE80211_SKB_RXCB(entry->skb);
0839 
0840     /* Ensure that all fields of rx_status are initialized
0841      * properly. The skb->cb array was used for driver
0842      * specific informations, so rx_status might contain
0843      * garbage.
0844      */
0845     memset(rx_status, 0, sizeof(*rx_status));
0846 
0847     rx_status->mactime = rxdesc.timestamp;
0848     rx_status->band = rt2x00dev->curr_band;
0849     rx_status->freq = rt2x00dev->curr_freq;
0850     rx_status->rate_idx = rate_idx;
0851     rx_status->signal = rxdesc.rssi;
0852     rx_status->flag = rxdesc.flags;
0853     rx_status->enc_flags = rxdesc.enc_flags;
0854     rx_status->encoding = rxdesc.encoding;
0855     rx_status->bw = rxdesc.bw;
0856     rx_status->antenna = rt2x00dev->link.ant.active.rx;
0857 
0858     ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
0859 
0860 renew_skb:
0861     /*
0862      * Replace the skb with the freshly allocated one.
0863      */
0864     entry->skb = skb;
0865 
0866 submit_entry:
0867     entry->flags = 0;
0868     rt2x00queue_index_inc(entry, Q_INDEX_DONE);
0869     if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
0870         test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
0871         rt2x00dev->ops->lib->clear_entry(entry);
0872 }
0873 EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
0874 
0875 /*
0876  * Driver initialization handlers.
0877  */
0878 const struct rt2x00_rate rt2x00_supported_rates[12] = {
0879     {
0880         .flags = DEV_RATE_CCK,
0881         .bitrate = 10,
0882         .ratemask = BIT(0),
0883         .plcp = 0x00,
0884         .mcs = RATE_MCS(RATE_MODE_CCK, 0),
0885     },
0886     {
0887         .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
0888         .bitrate = 20,
0889         .ratemask = BIT(1),
0890         .plcp = 0x01,
0891         .mcs = RATE_MCS(RATE_MODE_CCK, 1),
0892     },
0893     {
0894         .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
0895         .bitrate = 55,
0896         .ratemask = BIT(2),
0897         .plcp = 0x02,
0898         .mcs = RATE_MCS(RATE_MODE_CCK, 2),
0899     },
0900     {
0901         .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
0902         .bitrate = 110,
0903         .ratemask = BIT(3),
0904         .plcp = 0x03,
0905         .mcs = RATE_MCS(RATE_MODE_CCK, 3),
0906     },
0907     {
0908         .flags = DEV_RATE_OFDM,
0909         .bitrate = 60,
0910         .ratemask = BIT(4),
0911         .plcp = 0x0b,
0912         .mcs = RATE_MCS(RATE_MODE_OFDM, 0),
0913     },
0914     {
0915         .flags = DEV_RATE_OFDM,
0916         .bitrate = 90,
0917         .ratemask = BIT(5),
0918         .plcp = 0x0f,
0919         .mcs = RATE_MCS(RATE_MODE_OFDM, 1),
0920     },
0921     {
0922         .flags = DEV_RATE_OFDM,
0923         .bitrate = 120,
0924         .ratemask = BIT(6),
0925         .plcp = 0x0a,
0926         .mcs = RATE_MCS(RATE_MODE_OFDM, 2),
0927     },
0928     {
0929         .flags = DEV_RATE_OFDM,
0930         .bitrate = 180,
0931         .ratemask = BIT(7),
0932         .plcp = 0x0e,
0933         .mcs = RATE_MCS(RATE_MODE_OFDM, 3),
0934     },
0935     {
0936         .flags = DEV_RATE_OFDM,
0937         .bitrate = 240,
0938         .ratemask = BIT(8),
0939         .plcp = 0x09,
0940         .mcs = RATE_MCS(RATE_MODE_OFDM, 4),
0941     },
0942     {
0943         .flags = DEV_RATE_OFDM,
0944         .bitrate = 360,
0945         .ratemask = BIT(9),
0946         .plcp = 0x0d,
0947         .mcs = RATE_MCS(RATE_MODE_OFDM, 5),
0948     },
0949     {
0950         .flags = DEV_RATE_OFDM,
0951         .bitrate = 480,
0952         .ratemask = BIT(10),
0953         .plcp = 0x08,
0954         .mcs = RATE_MCS(RATE_MODE_OFDM, 6),
0955     },
0956     {
0957         .flags = DEV_RATE_OFDM,
0958         .bitrate = 540,
0959         .ratemask = BIT(11),
0960         .plcp = 0x0c,
0961         .mcs = RATE_MCS(RATE_MODE_OFDM, 7),
0962     },
0963 };
0964 
0965 static void rt2x00lib_channel(struct ieee80211_channel *entry,
0966                   const int channel, const int tx_power,
0967                   const int value)
0968 {
0969     /* XXX: this assumption about the band is wrong for 802.11j */
0970     entry->band = channel <= 14 ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
0971     entry->center_freq = ieee80211_channel_to_frequency(channel,
0972                                 entry->band);
0973     entry->hw_value = value;
0974     entry->max_power = tx_power;
0975     entry->max_antenna_gain = 0xff;
0976 }
0977 
0978 static void rt2x00lib_rate(struct ieee80211_rate *entry,
0979                const u16 index, const struct rt2x00_rate *rate)
0980 {
0981     entry->flags = 0;
0982     entry->bitrate = rate->bitrate;
0983     entry->hw_value = index;
0984     entry->hw_value_short = index;
0985 
0986     if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
0987         entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
0988 }
0989 
0990 void rt2x00lib_set_mac_address(struct rt2x00_dev *rt2x00dev, u8 *eeprom_mac_addr)
0991 {
0992     of_get_mac_address(rt2x00dev->dev->of_node, eeprom_mac_addr);
0993 
0994     if (!is_valid_ether_addr(eeprom_mac_addr)) {
0995         eth_random_addr(eeprom_mac_addr);
0996         rt2x00_eeprom_dbg(rt2x00dev, "MAC: %pM\n", eeprom_mac_addr);
0997     }
0998 }
0999 EXPORT_SYMBOL_GPL(rt2x00lib_set_mac_address);
1000 
1001 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
1002                     struct hw_mode_spec *spec)
1003 {
1004     struct ieee80211_hw *hw = rt2x00dev->hw;
1005     struct ieee80211_channel *channels;
1006     struct ieee80211_rate *rates;
1007     unsigned int num_rates;
1008     unsigned int i;
1009 
1010     num_rates = 0;
1011     if (spec->supported_rates & SUPPORT_RATE_CCK)
1012         num_rates += 4;
1013     if (spec->supported_rates & SUPPORT_RATE_OFDM)
1014         num_rates += 8;
1015 
1016     channels = kcalloc(spec->num_channels, sizeof(*channels), GFP_KERNEL);
1017     if (!channels)
1018         return -ENOMEM;
1019 
1020     rates = kcalloc(num_rates, sizeof(*rates), GFP_KERNEL);
1021     if (!rates)
1022         goto exit_free_channels;
1023 
1024     /*
1025      * Initialize Rate list.
1026      */
1027     for (i = 0; i < num_rates; i++)
1028         rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
1029 
1030     /*
1031      * Initialize Channel list.
1032      */
1033     for (i = 0; i < spec->num_channels; i++) {
1034         rt2x00lib_channel(&channels[i],
1035                   spec->channels[i].channel,
1036                   spec->channels_info[i].max_power, i);
1037     }
1038 
1039     /*
1040      * Intitialize 802.11b, 802.11g
1041      * Rates: CCK, OFDM.
1042      * Channels: 2.4 GHz
1043      */
1044     if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
1045         rt2x00dev->bands[NL80211_BAND_2GHZ].n_channels = 14;
1046         rt2x00dev->bands[NL80211_BAND_2GHZ].n_bitrates = num_rates;
1047         rt2x00dev->bands[NL80211_BAND_2GHZ].channels = channels;
1048         rt2x00dev->bands[NL80211_BAND_2GHZ].bitrates = rates;
1049         hw->wiphy->bands[NL80211_BAND_2GHZ] =
1050             &rt2x00dev->bands[NL80211_BAND_2GHZ];
1051         memcpy(&rt2x00dev->bands[NL80211_BAND_2GHZ].ht_cap,
1052                &spec->ht, sizeof(spec->ht));
1053     }
1054 
1055     /*
1056      * Intitialize 802.11a
1057      * Rates: OFDM.
1058      * Channels: OFDM, UNII, HiperLAN2.
1059      */
1060     if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
1061         rt2x00dev->bands[NL80211_BAND_5GHZ].n_channels =
1062             spec->num_channels - 14;
1063         rt2x00dev->bands[NL80211_BAND_5GHZ].n_bitrates =
1064             num_rates - 4;
1065         rt2x00dev->bands[NL80211_BAND_5GHZ].channels = &channels[14];
1066         rt2x00dev->bands[NL80211_BAND_5GHZ].bitrates = &rates[4];
1067         hw->wiphy->bands[NL80211_BAND_5GHZ] =
1068             &rt2x00dev->bands[NL80211_BAND_5GHZ];
1069         memcpy(&rt2x00dev->bands[NL80211_BAND_5GHZ].ht_cap,
1070                &spec->ht, sizeof(spec->ht));
1071     }
1072 
1073     return 0;
1074 
1075  exit_free_channels:
1076     kfree(channels);
1077     rt2x00_err(rt2x00dev, "Allocation ieee80211 modes failed\n");
1078     return -ENOMEM;
1079 }
1080 
1081 static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
1082 {
1083     if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
1084         ieee80211_unregister_hw(rt2x00dev->hw);
1085 
1086     if (likely(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ])) {
1087         kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels);
1088         kfree(rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ]->bitrates);
1089         rt2x00dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
1090         rt2x00dev->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
1091     }
1092 
1093     kfree(rt2x00dev->spec.channels_info);
1094 }
1095 
1096 static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
1097 {
1098     struct hw_mode_spec *spec = &rt2x00dev->spec;
1099     int status;
1100 
1101     if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
1102         return 0;
1103 
1104     /*
1105      * Initialize HW modes.
1106      */
1107     status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
1108     if (status)
1109         return status;
1110 
1111     /*
1112      * Initialize HW fields.
1113      */
1114     rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
1115 
1116     /*
1117      * Initialize extra TX headroom required.
1118      */
1119     rt2x00dev->hw->extra_tx_headroom =
1120         max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
1121               rt2x00dev->extra_tx_headroom);
1122 
1123     /*
1124      * Take TX headroom required for alignment into account.
1125      */
1126     if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_L2PAD))
1127         rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
1128     else if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DMA))
1129         rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
1130 
1131     /*
1132      * Tell mac80211 about the size of our private STA structure.
1133      */
1134     rt2x00dev->hw->sta_data_size = sizeof(struct rt2x00_sta);
1135 
1136     /*
1137      * Allocate tx status FIFO for driver use.
1138      */
1139     if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_TXSTATUS_FIFO)) {
1140         /*
1141          * Allocate the txstatus fifo. In the worst case the tx
1142          * status fifo has to hold the tx status of all entries
1143          * in all tx queues. Hence, calculate the kfifo size as
1144          * tx_queues * entry_num and round up to the nearest
1145          * power of 2.
1146          */
1147         int kfifo_size =
1148             roundup_pow_of_two(rt2x00dev->ops->tx_queues *
1149                        rt2x00dev->tx->limit *
1150                        sizeof(u32));
1151 
1152         status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
1153                      GFP_KERNEL);
1154         if (status)
1155             return status;
1156     }
1157 
1158     /*
1159      * Initialize tasklets if used by the driver. Tasklets are
1160      * disabled until the interrupts are turned on. The driver
1161      * has to handle that.
1162      */
1163 #define RT2X00_TASKLET_INIT(taskletname) \
1164     if (rt2x00dev->ops->lib->taskletname) { \
1165         tasklet_setup(&rt2x00dev->taskletname, \
1166                  rt2x00dev->ops->lib->taskletname); \
1167     }
1168 
1169     RT2X00_TASKLET_INIT(txstatus_tasklet);
1170     RT2X00_TASKLET_INIT(pretbtt_tasklet);
1171     RT2X00_TASKLET_INIT(tbtt_tasklet);
1172     RT2X00_TASKLET_INIT(rxdone_tasklet);
1173     RT2X00_TASKLET_INIT(autowake_tasklet);
1174 
1175 #undef RT2X00_TASKLET_INIT
1176 
1177     /*
1178      * Register HW.
1179      */
1180     status = ieee80211_register_hw(rt2x00dev->hw);
1181     if (status)
1182         return status;
1183 
1184     set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
1185 
1186     return 0;
1187 }
1188 
1189 /*
1190  * Initialization/uninitialization handlers.
1191  */
1192 static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
1193 {
1194     if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1195         return;
1196 
1197     /*
1198      * Stop rfkill polling.
1199      */
1200     if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
1201         rt2x00rfkill_unregister(rt2x00dev);
1202 
1203     /*
1204      * Allow the HW to uninitialize.
1205      */
1206     rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1207 
1208     /*
1209      * Free allocated queue entries.
1210      */
1211     rt2x00queue_uninitialize(rt2x00dev);
1212 }
1213 
1214 static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1215 {
1216     int status;
1217 
1218     if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1219         return 0;
1220 
1221     /*
1222      * Allocate all queue entries.
1223      */
1224     status = rt2x00queue_initialize(rt2x00dev);
1225     if (status)
1226         return status;
1227 
1228     /*
1229      * Initialize the device.
1230      */
1231     status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1232     if (status) {
1233         rt2x00queue_uninitialize(rt2x00dev);
1234         return status;
1235     }
1236 
1237     set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
1238 
1239     /*
1240      * Start rfkill polling.
1241      */
1242     if (rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
1243         rt2x00rfkill_register(rt2x00dev);
1244 
1245     return 0;
1246 }
1247 
1248 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1249 {
1250     int retval = 0;
1251 
1252     /*
1253      * If this is the first interface which is added,
1254      * we should load the firmware now.
1255      */
1256     retval = rt2x00lib_load_firmware(rt2x00dev);
1257     if (retval)
1258         goto out;
1259 
1260     /*
1261      * Initialize the device.
1262      */
1263     retval = rt2x00lib_initialize(rt2x00dev);
1264     if (retval)
1265         goto out;
1266 
1267     rt2x00dev->intf_ap_count = 0;
1268     rt2x00dev->intf_sta_count = 0;
1269     rt2x00dev->intf_associated = 0;
1270 
1271     /* Enable the radio */
1272     retval = rt2x00lib_enable_radio(rt2x00dev);
1273     if (retval)
1274         goto out;
1275 
1276     set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
1277 
1278 out:
1279     return retval;
1280 }
1281 
1282 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1283 {
1284     if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1285         return;
1286 
1287     /*
1288      * Perhaps we can add something smarter here,
1289      * but for now just disabling the radio should do.
1290      */
1291     rt2x00lib_disable_radio(rt2x00dev);
1292 
1293     rt2x00dev->intf_ap_count = 0;
1294     rt2x00dev->intf_sta_count = 0;
1295     rt2x00dev->intf_associated = 0;
1296 }
1297 
1298 static inline void rt2x00lib_set_if_combinations(struct rt2x00_dev *rt2x00dev)
1299 {
1300     struct ieee80211_iface_limit *if_limit;
1301     struct ieee80211_iface_combination *if_combination;
1302 
1303     if (rt2x00dev->ops->max_ap_intf < 2)
1304         return;
1305 
1306     /*
1307      * Build up AP interface limits structure.
1308      */
1309     if_limit = &rt2x00dev->if_limits_ap;
1310     if_limit->max = rt2x00dev->ops->max_ap_intf;
1311     if_limit->types = BIT(NL80211_IFTYPE_AP);
1312 #ifdef CONFIG_MAC80211_MESH
1313     if_limit->types |= BIT(NL80211_IFTYPE_MESH_POINT);
1314 #endif
1315 
1316     /*
1317      * Build up AP interface combinations structure.
1318      */
1319     if_combination = &rt2x00dev->if_combinations[IF_COMB_AP];
1320     if_combination->limits = if_limit;
1321     if_combination->n_limits = 1;
1322     if_combination->max_interfaces = if_limit->max;
1323     if_combination->num_different_channels = 1;
1324 
1325     /*
1326      * Finally, specify the possible combinations to mac80211.
1327      */
1328     rt2x00dev->hw->wiphy->iface_combinations = rt2x00dev->if_combinations;
1329     rt2x00dev->hw->wiphy->n_iface_combinations = 1;
1330 }
1331 
1332 static unsigned int rt2x00dev_extra_tx_headroom(struct rt2x00_dev *rt2x00dev)
1333 {
1334     if (WARN_ON(!rt2x00dev->tx))
1335         return 0;
1336 
1337     if (rt2x00_is_usb(rt2x00dev))
1338         return rt2x00dev->tx[0].winfo_size + rt2x00dev->tx[0].desc_size;
1339 
1340     return rt2x00dev->tx[0].winfo_size;
1341 }
1342 
1343 /*
1344  * driver allocation handlers.
1345  */
1346 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1347 {
1348     int retval = -ENOMEM;
1349 
1350     /*
1351      * Set possible interface combinations.
1352      */
1353     rt2x00lib_set_if_combinations(rt2x00dev);
1354 
1355     /*
1356      * Allocate the driver data memory, if necessary.
1357      */
1358     if (rt2x00dev->ops->drv_data_size > 0) {
1359         rt2x00dev->drv_data = kzalloc(rt2x00dev->ops->drv_data_size,
1360                                   GFP_KERNEL);
1361         if (!rt2x00dev->drv_data) {
1362             retval = -ENOMEM;
1363             goto exit;
1364         }
1365     }
1366 
1367     spin_lock_init(&rt2x00dev->irqmask_lock);
1368     mutex_init(&rt2x00dev->csr_mutex);
1369     mutex_init(&rt2x00dev->conf_mutex);
1370     INIT_LIST_HEAD(&rt2x00dev->bar_list);
1371     spin_lock_init(&rt2x00dev->bar_list_lock);
1372     hrtimer_init(&rt2x00dev->txstatus_timer, CLOCK_MONOTONIC,
1373              HRTIMER_MODE_REL);
1374 
1375     set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1376 
1377     /*
1378      * Make room for rt2x00_intf inside the per-interface
1379      * structure ieee80211_vif.
1380      */
1381     rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1382 
1383     /*
1384      * rt2x00 devices can only use the last n bits of the MAC address
1385      * for virtual interfaces.
1386      */
1387     rt2x00dev->hw->wiphy->addr_mask[ETH_ALEN - 1] =
1388         (rt2x00dev->ops->max_ap_intf - 1);
1389 
1390     /*
1391      * Initialize work.
1392      */
1393     rt2x00dev->workqueue =
1394         alloc_ordered_workqueue("%s", 0, wiphy_name(rt2x00dev->hw->wiphy));
1395     if (!rt2x00dev->workqueue) {
1396         retval = -ENOMEM;
1397         goto exit;
1398     }
1399 
1400     INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1401     INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
1402     INIT_WORK(&rt2x00dev->sleep_work, rt2x00lib_sleep);
1403 
1404     /*
1405      * Let the driver probe the device to detect the capabilities.
1406      */
1407     retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1408     if (retval) {
1409         rt2x00_err(rt2x00dev, "Failed to allocate device\n");
1410         goto exit;
1411     }
1412 
1413     /*
1414      * Allocate queue array.
1415      */
1416     retval = rt2x00queue_allocate(rt2x00dev);
1417     if (retval)
1418         goto exit;
1419 
1420     /* Cache TX headroom value */
1421     rt2x00dev->extra_tx_headroom = rt2x00dev_extra_tx_headroom(rt2x00dev);
1422 
1423     /*
1424      * Determine which operating modes are supported, all modes
1425      * which require beaconing, depend on the availability of
1426      * beacon entries.
1427      */
1428     rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1429     if (rt2x00dev->bcn->limit > 0)
1430         rt2x00dev->hw->wiphy->interface_modes |=
1431             BIT(NL80211_IFTYPE_ADHOC) |
1432 #ifdef CONFIG_MAC80211_MESH
1433             BIT(NL80211_IFTYPE_MESH_POINT) |
1434 #endif
1435             BIT(NL80211_IFTYPE_AP);
1436 
1437     rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
1438 
1439     wiphy_ext_feature_set(rt2x00dev->hw->wiphy,
1440                   NL80211_EXT_FEATURE_CQM_RSSI_LIST);
1441 
1442     /*
1443      * Initialize ieee80211 structure.
1444      */
1445     retval = rt2x00lib_probe_hw(rt2x00dev);
1446     if (retval) {
1447         rt2x00_err(rt2x00dev, "Failed to initialize hw\n");
1448         goto exit;
1449     }
1450 
1451     /*
1452      * Register extra components.
1453      */
1454     rt2x00link_register(rt2x00dev);
1455     rt2x00leds_register(rt2x00dev);
1456     rt2x00debug_register(rt2x00dev);
1457 
1458     /*
1459      * Start rfkill polling.
1460      */
1461     if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
1462         rt2x00rfkill_register(rt2x00dev);
1463 
1464     return 0;
1465 
1466 exit:
1467     rt2x00lib_remove_dev(rt2x00dev);
1468 
1469     return retval;
1470 }
1471 EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1472 
1473 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1474 {
1475     clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1476 
1477     /*
1478      * Stop rfkill polling.
1479      */
1480     if (!rt2x00_has_cap_flag(rt2x00dev, REQUIRE_DELAYED_RFKILL))
1481         rt2x00rfkill_unregister(rt2x00dev);
1482 
1483     /*
1484      * Disable radio.
1485      */
1486     rt2x00lib_disable_radio(rt2x00dev);
1487 
1488     /*
1489      * Stop all work.
1490      */
1491     cancel_work_sync(&rt2x00dev->intf_work);
1492     cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
1493     cancel_work_sync(&rt2x00dev->sleep_work);
1494 
1495     hrtimer_cancel(&rt2x00dev->txstatus_timer);
1496 
1497     /*
1498      * Kill the tx status tasklet.
1499      */
1500     tasklet_kill(&rt2x00dev->txstatus_tasklet);
1501     tasklet_kill(&rt2x00dev->pretbtt_tasklet);
1502     tasklet_kill(&rt2x00dev->tbtt_tasklet);
1503     tasklet_kill(&rt2x00dev->rxdone_tasklet);
1504     tasklet_kill(&rt2x00dev->autowake_tasklet);
1505 
1506     /*
1507      * Uninitialize device.
1508      */
1509     rt2x00lib_uninitialize(rt2x00dev);
1510 
1511     if (rt2x00dev->workqueue)
1512         destroy_workqueue(rt2x00dev->workqueue);
1513 
1514     /*
1515      * Free the tx status fifo.
1516      */
1517     kfifo_free(&rt2x00dev->txstatus_fifo);
1518 
1519     /*
1520      * Free extra components
1521      */
1522     rt2x00debug_deregister(rt2x00dev);
1523     rt2x00leds_unregister(rt2x00dev);
1524 
1525     /*
1526      * Free ieee80211_hw memory.
1527      */
1528     rt2x00lib_remove_hw(rt2x00dev);
1529 
1530     /*
1531      * Free firmware image.
1532      */
1533     rt2x00lib_free_firmware(rt2x00dev);
1534 
1535     /*
1536      * Free queue structures.
1537      */
1538     rt2x00queue_free(rt2x00dev);
1539 
1540     /*
1541      * Free the driver data.
1542      */
1543     kfree(rt2x00dev->drv_data);
1544 }
1545 EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1546 
1547 /*
1548  * Device state handlers
1549  */
1550 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev)
1551 {
1552     rt2x00_dbg(rt2x00dev, "Going to sleep\n");
1553 
1554     /*
1555      * Prevent mac80211 from accessing driver while suspended.
1556      */
1557     if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
1558         return 0;
1559 
1560     /*
1561      * Cleanup as much as possible.
1562      */
1563     rt2x00lib_uninitialize(rt2x00dev);
1564 
1565     /*
1566      * Suspend/disable extra components.
1567      */
1568     rt2x00leds_suspend(rt2x00dev);
1569     rt2x00debug_deregister(rt2x00dev);
1570 
1571     /*
1572      * Set device mode to sleep for power management,
1573      * on some hardware this call seems to consistently fail.
1574      * From the specifications it is hard to tell why it fails,
1575      * and if this is a "bad thing".
1576      * Overall it is safe to just ignore the failure and
1577      * continue suspending. The only downside is that the
1578      * device will not be in optimal power save mode, but with
1579      * the radio and the other components already disabled the
1580      * device is as good as disabled.
1581      */
1582     if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
1583         rt2x00_warn(rt2x00dev, "Device failed to enter sleep state, continue suspending\n");
1584 
1585     return 0;
1586 }
1587 EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1588 
1589 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1590 {
1591     rt2x00_dbg(rt2x00dev, "Waking up\n");
1592 
1593     /*
1594      * Restore/enable extra components.
1595      */
1596     rt2x00debug_register(rt2x00dev);
1597     rt2x00leds_resume(rt2x00dev);
1598 
1599     /*
1600      * We are ready again to receive requests from mac80211.
1601      */
1602     set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1603 
1604     return 0;
1605 }
1606 EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1607 
1608 /*
1609  * rt2x00lib module information.
1610  */
1611 MODULE_AUTHOR(DRV_PROJECT);
1612 MODULE_VERSION(DRV_VERSION);
1613 MODULE_DESCRIPTION("rt2x00 library");
1614 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!