Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Oleksij Rempel | 924 | 58.37% | 4 | 7.55% |
Sujith Manoharan | 177 | 11.18% | 11 | 20.75% |
Luis R. Rodriguez | 152 | 9.60% | 12 | 22.64% |
Felix Fietkau | 122 | 7.71% | 8 | 15.09% |
Rajkumar Manoharan | 92 | 5.81% | 2 | 3.77% |
Johannes Berg | 45 | 2.84% | 6 | 11.32% |
Simon Wunderlich | 45 | 2.84% | 2 | 3.77% |
Jouni Malinen | 14 | 0.88% | 3 | 5.66% |
Stanislaw Gruszka | 4 | 0.25% | 1 | 1.89% |
Karl Beldan | 4 | 0.25% | 1 | 1.89% |
Gabor Juhos | 2 | 0.13% | 1 | 1.89% |
Vasanthakumar Thiagarajan | 1 | 0.06% | 1 | 1.89% |
Chun-Yeow Yeoh | 1 | 0.06% | 1 | 1.89% |
Total | 1583 | 53 |
/* * Copyright (c) 2009-2011 Atheros Communications Inc. * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Module for common driver code between ath9k and ath9k_htc */ #include <linux/kernel.h> #include <linux/module.h> #include "common.h" MODULE_AUTHOR("Atheros Communications"); MODULE_DESCRIPTION("Shared library for Atheros wireless 802.11n LAN cards."); MODULE_LICENSE("Dual BSD/GPL"); /* Assumes you've already done the endian to CPU conversion */ bool ath9k_cmn_rx_accept(struct ath_common *common, struct ieee80211_hdr *hdr, struct ieee80211_rx_status *rxs, struct ath_rx_status *rx_stats, bool *decrypt_error, unsigned int rxfilter) { struct ath_hw *ah = common->ah; bool is_mc, is_valid_tkip, strip_mic, mic_error; __le16 fc; fc = hdr->frame_control; is_mc = !!is_multicast_ether_addr(hdr->addr1); is_valid_tkip = rx_stats->rs_keyix != ATH9K_RXKEYIX_INVALID && test_bit(rx_stats->rs_keyix, common->tkip_keymap); strip_mic = is_valid_tkip && ieee80211_is_data(fc) && ieee80211_has_protected(fc) && !(rx_stats->rs_status & (ATH9K_RXERR_DECRYPT | ATH9K_RXERR_CRC | ATH9K_RXERR_MIC | ATH9K_RXERR_KEYMISS)); /* * Key miss events are only relevant for pairwise keys where the * descriptor does contain a valid key index. This has been observed * mostly with CCMP encryption. */ if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID || !test_bit(rx_stats->rs_keyix, common->ccmp_keymap)) rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS; mic_error = is_valid_tkip && !ieee80211_is_ctl(fc) && !ieee80211_has_morefrags(fc) && !(le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG) && (rx_stats->rs_status & ATH9K_RXERR_MIC); /* * The rx_stats->rs_status will not be set until the end of the * chained descriptors so it can be ignored if rs_more is set. The * rs_more will be false at the last element of the chained * descriptors. */ if (rx_stats->rs_status != 0) { u8 status_mask; if (rx_stats->rs_status & ATH9K_RXERR_CRC) { rxs->flag |= RX_FLAG_FAILED_FCS_CRC; mic_error = false; } if ((rx_stats->rs_status & ATH9K_RXERR_DECRYPT) || (!is_mc && (rx_stats->rs_status & ATH9K_RXERR_KEYMISS))) { *decrypt_error = true; mic_error = false; } /* * Reject error frames with the exception of * decryption and MIC failures. For monitor mode, * we also ignore the CRC error. */ status_mask = ATH9K_RXERR_DECRYPT | ATH9K_RXERR_MIC | ATH9K_RXERR_KEYMISS; if (ah->is_monitoring && (rxfilter & FIF_FCSFAIL)) status_mask |= ATH9K_RXERR_CRC; if (rx_stats->rs_status & ~status_mask) return false; } /* * For unicast frames the MIC error bit can have false positives, * so all MIC error reports need to be validated in software. * False negatives are not common, so skip software verification * if the hardware considers the MIC valid. */ if (strip_mic) rxs->flag |= RX_FLAG_MMIC_STRIPPED; else if (is_mc && mic_error) rxs->flag |= RX_FLAG_MMIC_ERROR; return true; } EXPORT_SYMBOL(ath9k_cmn_rx_accept); void ath9k_cmn_rx_skb_postprocess(struct ath_common *common, struct sk_buff *skb, struct ath_rx_status *rx_stats, struct ieee80211_rx_status *rxs, bool decrypt_error) { struct ath_hw *ah = common->ah; struct ieee80211_hdr *hdr; int hdrlen, padpos, padsize; u8 keyix; __le16 fc; /* see if any padding is done by the hw and remove it */ hdr = (struct ieee80211_hdr *) skb->data; hdrlen = ieee80211_get_hdrlen_from_skb(skb); fc = hdr->frame_control; padpos = ieee80211_hdrlen(fc); /* The MAC header is padded to have 32-bit boundary if the * packet payload is non-zero. The general calculation for * padsize would take into account odd header lengths: * padsize = (4 - padpos % 4) % 4; However, since only * even-length headers are used, padding can only be 0 or 2 * bytes and we can optimize this a bit. In addition, we must * not try to remove padding from short control frames that do * not have payload. */ padsize = padpos & 3; if (padsize && skb->len>=padpos+padsize+FCS_LEN) { memmove(skb->data + padsize, skb->data, padpos); skb_pull(skb, padsize); } keyix = rx_stats->rs_keyix; if (!(keyix == ATH9K_RXKEYIX_INVALID) && !decrypt_error && ieee80211_has_protected(fc)) { rxs->flag |= RX_FLAG_DECRYPTED; } else if (ieee80211_has_protected(fc) && !decrypt_error && skb->len >= hdrlen + 4) { keyix = skb->data[hdrlen + 3] >> 6; if (test_bit(keyix, common->keymap)) rxs->flag |= RX_FLAG_DECRYPTED; } if (ah->sw_mgmt_crypto_rx && (rxs->flag & RX_FLAG_DECRYPTED) && ieee80211_is_mgmt(fc)) /* Use software decrypt for management frames. */ rxs->flag &= ~RX_FLAG_DECRYPTED; } EXPORT_SYMBOL(ath9k_cmn_rx_skb_postprocess); int ath9k_cmn_process_rate(struct ath_common *common, struct ieee80211_hw *hw, struct ath_rx_status *rx_stats, struct ieee80211_rx_status *rxs) { struct ieee80211_supported_band *sband; enum nl80211_band band; unsigned int i = 0; struct ath_hw *ah = common->ah; band = ah->curchan->chan->band; sband = hw->wiphy->bands[band]; if (IS_CHAN_QUARTER_RATE(ah->curchan)) rxs->bw = RATE_INFO_BW_5; else if (IS_CHAN_HALF_RATE(ah->curchan)) rxs->bw = RATE_INFO_BW_10; if (rx_stats->rs_rate & 0x80) { /* HT rate */ rxs->encoding = RX_ENC_HT; rxs->enc_flags |= rx_stats->enc_flags; rxs->bw = rx_stats->bw; rxs->rate_idx = rx_stats->rs_rate & 0x7f; return 0; } for (i = 0; i < sband->n_bitrates; i++) { if (sband->bitrates[i].hw_value == rx_stats->rs_rate) { rxs->rate_idx = i; return 0; } if (sband->bitrates[i].hw_value_short == rx_stats->rs_rate) { rxs->enc_flags |= RX_ENC_FLAG_SHORTPRE; rxs->rate_idx = i; return 0; } } return -EINVAL; } EXPORT_SYMBOL(ath9k_cmn_process_rate); void ath9k_cmn_process_rssi(struct ath_common *common, struct ieee80211_hw *hw, struct ath_rx_status *rx_stats, struct ieee80211_rx_status *rxs) { struct ath_hw *ah = common->ah; int last_rssi; int rssi = rx_stats->rs_rssi; int i, j; /* * RSSI is not available for subframes in an A-MPDU. */ if (rx_stats->rs_moreaggr) { rxs->flag |= RX_FLAG_NO_SIGNAL_VAL; return; } /* * Check if the RSSI for the last subframe in an A-MPDU * or an unaggregated frame is valid. */ if (rx_stats->rs_rssi == ATH9K_RSSI_BAD) { rxs->flag |= RX_FLAG_NO_SIGNAL_VAL; return; } for (i = 0, j = 0; i < ARRAY_SIZE(rx_stats->rs_rssi_ctl); i++) { s8 rssi; if (!(ah->rxchainmask & BIT(i))) continue; rssi = rx_stats->rs_rssi_ctl[i]; if (rssi != ATH9K_RSSI_BAD) { rxs->chains |= BIT(j); rxs->chain_signal[j] = ah->noise + rssi; } j++; } /* * Update Beacon RSSI, this is used by ANI. */ if (rx_stats->is_mybeacon && ((ah->opmode == NL80211_IFTYPE_STATION) || (ah->opmode == NL80211_IFTYPE_ADHOC))) { ATH_RSSI_LPF(common->last_rssi, rx_stats->rs_rssi); last_rssi = common->last_rssi; if (likely(last_rssi != ATH_RSSI_DUMMY_MARKER)) rssi = ATH_EP_RND(last_rssi, ATH_RSSI_EP_MULTIPLIER); if (rssi < 0) rssi = 0; ah->stats.avgbrssi = rssi; } rxs->signal = ah->noise + rx_stats->rs_rssi; } EXPORT_SYMBOL(ath9k_cmn_process_rssi); int ath9k_cmn_get_hw_crypto_keytype(struct sk_buff *skb) { struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); if (tx_info->control.hw_key) { switch (tx_info->control.hw_key->cipher) { case WLAN_CIPHER_SUITE_WEP40: case WLAN_CIPHER_SUITE_WEP104: return ATH9K_KEY_TYPE_WEP; case WLAN_CIPHER_SUITE_TKIP: return ATH9K_KEY_TYPE_TKIP; case WLAN_CIPHER_SUITE_CCMP: return ATH9K_KEY_TYPE_AES; default: break; } } return ATH9K_KEY_TYPE_CLEAR; } EXPORT_SYMBOL(ath9k_cmn_get_hw_crypto_keytype); /* * Update internal channel flags. */ static void ath9k_cmn_update_ichannel(struct ath9k_channel *ichan, struct cfg80211_chan_def *chandef) { struct ieee80211_channel *chan = chandef->chan; u16 flags = 0; ichan->channel = chan->center_freq; ichan->chan = chan; if (chan->band == NL80211_BAND_5GHZ) flags |= CHANNEL_5GHZ; switch (chandef->width) { case NL80211_CHAN_WIDTH_5: flags |= CHANNEL_QUARTER; break; case NL80211_CHAN_WIDTH_10: flags |= CHANNEL_HALF; break; case NL80211_CHAN_WIDTH_20_NOHT: break; case NL80211_CHAN_WIDTH_20: flags |= CHANNEL_HT; break; case NL80211_CHAN_WIDTH_40: if (chandef->center_freq1 > chandef->chan->center_freq) flags |= CHANNEL_HT40PLUS | CHANNEL_HT; else flags |= CHANNEL_HT40MINUS | CHANNEL_HT; break; default: WARN_ON(1); } ichan->channelFlags = flags; } /* * Get the internal channel reference. */ struct ath9k_channel *ath9k_cmn_get_channel(struct ieee80211_hw *hw, struct ath_hw *ah, struct cfg80211_chan_def *chandef) { struct ieee80211_channel *curchan = chandef->chan; struct ath9k_channel *channel; channel = &ah->channels[curchan->hw_value]; ath9k_cmn_update_ichannel(channel, chandef); return channel; } EXPORT_SYMBOL(ath9k_cmn_get_channel); int ath9k_cmn_count_streams(unsigned int chainmask, int max) { int streams = 0; do { if (++streams == max) break; } while ((chainmask = chainmask & (chainmask - 1))); return streams; } EXPORT_SYMBOL(ath9k_cmn_count_streams); void ath9k_cmn_update_txpow(struct ath_hw *ah, u16 cur_txpow, u16 new_txpow, u16 *txpower) { struct ath_regulatory *reg = ath9k_hw_regulatory(ah); if (ah->curchan && reg->power_limit != new_txpow) ath9k_hw_set_txpowerlimit(ah, new_txpow, false); /* read back in case value is clamped */ *txpower = reg->max_power_level; } EXPORT_SYMBOL(ath9k_cmn_update_txpow); void ath9k_cmn_init_crypto(struct ath_hw *ah) { struct ath_common *common = ath9k_hw_common(ah); int i = 0; /* Get the hardware key cache size. */ common->keymax = AR_KEYTABLE_SIZE; /* * Check whether the separate key cache entries * are required to handle both tx+rx MIC keys. * With split mic keys the number of stations is limited * to 27 otherwise 59. */ if (ah->misc_mode & AR_PCU_MIC_NEW_LOC_ENA) common->crypt_caps |= ATH_CRYPT_CAP_MIC_COMBINED; /* * Reset the key cache since some parts do not * reset the contents on initial power up. */ for (i = 0; i < common->keymax; i++) ath_hw_keyreset(common, (u16) i); } EXPORT_SYMBOL(ath9k_cmn_init_crypto); static int __init ath9k_cmn_init(void) { return 0; } module_init(ath9k_cmn_init); static void __exit ath9k_cmn_exit(void) { return; } module_exit(ath9k_cmn_exit);
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1