2 * Copyright (c) 2009 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 * Module for common driver code between ath9k and ath9k_htc
21 #include <linux/kernel.h>
22 #include <linux/module.h>
26 MODULE_AUTHOR("Atheros Communications");
27 MODULE_DESCRIPTION("Shared library for Atheros wireless 802.11n LAN cards.");
28 MODULE_LICENSE("Dual BSD/GPL");
30 /* Common RX processing */
32 /* Assumes you've already done the endian to CPU conversion */
33 static bool ath9k_rx_accept(struct ath_common
*common
,
35 struct ieee80211_rx_status
*rxs
,
36 struct ath_rx_status
*rx_stats
,
39 struct ath_hw
*ah
= common
->ah
;
40 struct ieee80211_hdr
*hdr
;
43 hdr
= (struct ieee80211_hdr
*) skb
->data
;
44 fc
= hdr
->frame_control
;
46 if (!rx_stats
->rs_datalen
)
49 * rs_status follows rs_datalen so if rs_datalen is too large
50 * we can take a hint that hardware corrupted it, so ignore
53 if (rx_stats
->rs_datalen
> common
->rx_bufsize
)
57 * rs_more indicates chained descriptors which can be used
58 * to link buffers together for a sort of scatter-gather
61 * The rx_stats->rs_status will not be set until the end of the
62 * chained descriptors so it can be ignored if rs_more is set. The
63 * rs_more will be false at the last element of the chained
66 if (!rx_stats
->rs_more
&& rx_stats
->rs_status
!= 0) {
67 if (rx_stats
->rs_status
& ATH9K_RXERR_CRC
)
68 rxs
->flag
|= RX_FLAG_FAILED_FCS_CRC
;
69 if (rx_stats
->rs_status
& ATH9K_RXERR_PHY
)
72 if (rx_stats
->rs_status
& ATH9K_RXERR_DECRYPT
) {
73 *decrypt_error
= true;
74 } else if (rx_stats
->rs_status
& ATH9K_RXERR_MIC
) {
75 if (ieee80211_is_ctl(fc
))
77 * Sometimes, we get invalid
78 * MIC failures on valid control frames.
79 * Remove these mic errors.
81 rx_stats
->rs_status
&= ~ATH9K_RXERR_MIC
;
83 rxs
->flag
|= RX_FLAG_MMIC_ERROR
;
86 * Reject error frames with the exception of
87 * decryption and MIC failures. For monitor mode,
88 * we also ignore the CRC error.
90 if (ah
->opmode
== NL80211_IFTYPE_MONITOR
) {
91 if (rx_stats
->rs_status
&
92 ~(ATH9K_RXERR_DECRYPT
| ATH9K_RXERR_MIC
|
96 if (rx_stats
->rs_status
&
97 ~(ATH9K_RXERR_DECRYPT
| ATH9K_RXERR_MIC
)) {
105 static u8
ath9k_process_rate(struct ath_common
*common
,
106 struct ieee80211_hw
*hw
,
107 struct ath_rx_status
*rx_stats
,
108 struct ieee80211_rx_status
*rxs
,
111 struct ieee80211_supported_band
*sband
;
112 enum ieee80211_band band
;
115 band
= hw
->conf
.channel
->band
;
116 sband
= hw
->wiphy
->bands
[band
];
118 if (rx_stats
->rs_rate
& 0x80) {
120 rxs
->flag
|= RX_FLAG_HT
;
121 if (rx_stats
->rs_flags
& ATH9K_RX_2040
)
122 rxs
->flag
|= RX_FLAG_40MHZ
;
123 if (rx_stats
->rs_flags
& ATH9K_RX_GI
)
124 rxs
->flag
|= RX_FLAG_SHORT_GI
;
125 return rx_stats
->rs_rate
& 0x7f;
128 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
129 if (sband
->bitrates
[i
].hw_value
== rx_stats
->rs_rate
)
131 if (sband
->bitrates
[i
].hw_value_short
== rx_stats
->rs_rate
) {
132 rxs
->flag
|= RX_FLAG_SHORTPRE
;
137 /* No valid hardware bitrate found -- we should not get here */
138 ath_print(common
, ATH_DBG_XMIT
, "unsupported hw bitrate detected "
139 "0x%02x using 1 Mbit\n", rx_stats
->rs_rate
);
140 if ((common
->debug_mask
& ATH_DBG_XMIT
))
141 print_hex_dump_bytes("", DUMP_PREFIX_NONE
, skb
->data
, skb
->len
);
146 static void ath9k_process_rssi(struct ath_common
*common
,
147 struct ieee80211_hw
*hw
,
149 struct ath_rx_status
*rx_stats
)
151 struct ath_hw
*ah
= common
->ah
;
152 struct ieee80211_sta
*sta
;
153 struct ieee80211_hdr
*hdr
;
155 int last_rssi
= ATH_RSSI_DUMMY_MARKER
;
158 hdr
= (struct ieee80211_hdr
*)skb
->data
;
159 fc
= hdr
->frame_control
;
163 * XXX: use ieee80211_find_sta! This requires quite a bit of work
164 * under the current ath9k virtual wiphy implementation as we have
165 * no way of tying a vif to wiphy. Typically vifs are attached to
166 * at least one sdata of a wiphy on mac80211 but with ath9k virtual
167 * wiphy you'd have to iterate over every wiphy and each sdata.
169 sta
= ieee80211_find_sta_by_hw(hw
, hdr
->addr2
);
171 an
= (struct ath_node
*) sta
->drv_priv
;
172 if (rx_stats
->rs_rssi
!= ATH9K_RSSI_BAD
&&
173 !rx_stats
->rs_moreaggr
)
174 ATH_RSSI_LPF(an
->last_rssi
, rx_stats
->rs_rssi
);
175 last_rssi
= an
->last_rssi
;
179 if (likely(last_rssi
!= ATH_RSSI_DUMMY_MARKER
))
180 rx_stats
->rs_rssi
= ATH_EP_RND(last_rssi
,
181 ATH_RSSI_EP_MULTIPLIER
);
182 if (rx_stats
->rs_rssi
< 0)
183 rx_stats
->rs_rssi
= 0;
185 /* Update Beacon RSSI, this is used by ANI. */
186 if (ieee80211_is_beacon(fc
))
187 ah
->stats
.avgbrssi
= rx_stats
->rs_rssi
;
191 * For Decrypt or Demic errors, we only mark packet status here and always push
192 * up the frame up to let mac80211 handle the actual error case, be it no
193 * decryption key or real decryption error. This let us keep statistics there.
195 int ath9k_cmn_rx_skb_preprocess(struct ath_common
*common
,
196 struct ieee80211_hw
*hw
,
198 struct ath_rx_status
*rx_stats
,
199 struct ieee80211_rx_status
*rx_status
,
202 struct ath_hw
*ah
= common
->ah
;
204 memset(rx_status
, 0, sizeof(struct ieee80211_rx_status
));
205 if (!ath9k_rx_accept(common
, skb
, rx_status
, rx_stats
, decrypt_error
))
208 ath9k_process_rssi(common
, hw
, skb
, rx_stats
);
210 rx_status
->rate_idx
= ath9k_process_rate(common
, hw
,
211 rx_stats
, rx_status
, skb
);
212 rx_status
->mactime
= ath9k_hw_extend_tsf(ah
, rx_stats
->rs_tstamp
);
213 rx_status
->band
= hw
->conf
.channel
->band
;
214 rx_status
->freq
= hw
->conf
.channel
->center_freq
;
215 rx_status
->noise
= common
->ani
.noise_floor
;
216 rx_status
->signal
= ATH_DEFAULT_NOISE_FLOOR
+ rx_stats
->rs_rssi
;
217 rx_status
->antenna
= rx_stats
->rs_antenna
;
218 rx_status
->flag
|= RX_FLAG_TSFT
;
222 EXPORT_SYMBOL(ath9k_cmn_rx_skb_preprocess
);
224 void ath9k_cmn_rx_skb_postprocess(struct ath_common
*common
,
226 struct ath_rx_status
*rx_stats
,
227 struct ieee80211_rx_status
*rxs
,
230 struct ath_hw
*ah
= common
->ah
;
231 struct ieee80211_hdr
*hdr
;
232 int hdrlen
, padpos
, padsize
;
236 /* see if any padding is done by the hw and remove it */
237 hdr
= (struct ieee80211_hdr
*) skb
->data
;
238 hdrlen
= ieee80211_get_hdrlen_from_skb(skb
);
239 fc
= hdr
->frame_control
;
240 padpos
= ath9k_cmn_padpos(hdr
->frame_control
);
242 /* The MAC header is padded to have 32-bit boundary if the
243 * packet payload is non-zero. The general calculation for
244 * padsize would take into account odd header lengths:
245 * padsize = (4 - padpos % 4) % 4; However, since only
246 * even-length headers are used, padding can only be 0 or 2
247 * bytes and we can optimize this a bit. In addition, we must
248 * not try to remove padding from short control frames that do
249 * not have payload. */
250 padsize
= padpos
& 3;
251 if (padsize
&& skb
->len
>=padpos
+padsize
+FCS_LEN
) {
252 memmove(skb
->data
+ padsize
, skb
->data
, padpos
);
253 skb_pull(skb
, padsize
);
256 keyix
= rx_stats
->rs_keyix
;
258 if (!(keyix
== ATH9K_RXKEYIX_INVALID
) && !decrypt_error
&&
259 ieee80211_has_protected(fc
)) {
260 rxs
->flag
|= RX_FLAG_DECRYPTED
;
261 } else if (ieee80211_has_protected(fc
)
262 && !decrypt_error
&& skb
->len
>= hdrlen
+ 4) {
263 keyix
= skb
->data
[hdrlen
+ 3] >> 6;
265 if (test_bit(keyix
, common
->keymap
))
266 rxs
->flag
|= RX_FLAG_DECRYPTED
;
268 if (ah
->sw_mgmt_crypto
&&
269 (rxs
->flag
& RX_FLAG_DECRYPTED
) &&
270 ieee80211_is_mgmt(fc
))
271 /* Use software decrypt for management frames. */
272 rxs
->flag
&= ~RX_FLAG_DECRYPTED
;
274 EXPORT_SYMBOL(ath9k_cmn_rx_skb_postprocess
);
276 int ath9k_cmn_padpos(__le16 frame_control
)
279 if (ieee80211_has_a4(frame_control
)) {
282 if (ieee80211_is_data_qos(frame_control
)) {
283 padpos
+= IEEE80211_QOS_CTL_LEN
;
288 EXPORT_SYMBOL(ath9k_cmn_padpos
);
290 int ath9k_cmn_get_hw_crypto_keytype(struct sk_buff
*skb
)
292 struct ieee80211_tx_info
*tx_info
= IEEE80211_SKB_CB(skb
);
294 if (tx_info
->control
.hw_key
) {
295 if (tx_info
->control
.hw_key
->alg
== ALG_WEP
)
296 return ATH9K_KEY_TYPE_WEP
;
297 else if (tx_info
->control
.hw_key
->alg
== ALG_TKIP
)
298 return ATH9K_KEY_TYPE_TKIP
;
299 else if (tx_info
->control
.hw_key
->alg
== ALG_CCMP
)
300 return ATH9K_KEY_TYPE_AES
;
303 return ATH9K_KEY_TYPE_CLEAR
;
305 EXPORT_SYMBOL(ath9k_cmn_get_hw_crypto_keytype
);
307 static u32
ath9k_get_extchanmode(struct ieee80211_channel
*chan
,
308 enum nl80211_channel_type channel_type
)
312 switch (chan
->band
) {
313 case IEEE80211_BAND_2GHZ
:
314 switch (channel_type
) {
315 case NL80211_CHAN_NO_HT
:
316 case NL80211_CHAN_HT20
:
317 chanmode
= CHANNEL_G_HT20
;
319 case NL80211_CHAN_HT40PLUS
:
320 chanmode
= CHANNEL_G_HT40PLUS
;
322 case NL80211_CHAN_HT40MINUS
:
323 chanmode
= CHANNEL_G_HT40MINUS
;
327 case IEEE80211_BAND_5GHZ
:
328 switch (channel_type
) {
329 case NL80211_CHAN_NO_HT
:
330 case NL80211_CHAN_HT20
:
331 chanmode
= CHANNEL_A_HT20
;
333 case NL80211_CHAN_HT40PLUS
:
334 chanmode
= CHANNEL_A_HT40PLUS
;
336 case NL80211_CHAN_HT40MINUS
:
337 chanmode
= CHANNEL_A_HT40MINUS
;
349 * Update internal channel flags.
351 void ath9k_cmn_update_ichannel(struct ieee80211_hw
*hw
,
352 struct ath9k_channel
*ichan
)
354 struct ieee80211_channel
*chan
= hw
->conf
.channel
;
355 struct ieee80211_conf
*conf
= &hw
->conf
;
357 ichan
->channel
= chan
->center_freq
;
360 if (chan
->band
== IEEE80211_BAND_2GHZ
) {
361 ichan
->chanmode
= CHANNEL_G
;
362 ichan
->channelFlags
= CHANNEL_2GHZ
| CHANNEL_OFDM
| CHANNEL_G
;
364 ichan
->chanmode
= CHANNEL_A
;
365 ichan
->channelFlags
= CHANNEL_5GHZ
| CHANNEL_OFDM
;
368 if (conf_is_ht(conf
))
369 ichan
->chanmode
= ath9k_get_extchanmode(chan
,
372 EXPORT_SYMBOL(ath9k_cmn_update_ichannel
);
375 * Get the internal channel reference.
377 struct ath9k_channel
*ath9k_cmn_get_curchannel(struct ieee80211_hw
*hw
,
380 struct ieee80211_channel
*curchan
= hw
->conf
.channel
;
381 struct ath9k_channel
*channel
;
384 chan_idx
= curchan
->hw_value
;
385 channel
= &ah
->channels
[chan_idx
];
386 ath9k_cmn_update_ichannel(hw
, channel
);
390 EXPORT_SYMBOL(ath9k_cmn_get_curchannel
);
392 static int ath_setkey_tkip(struct ath_common
*common
, u16 keyix
, const u8
*key
,
393 struct ath9k_keyval
*hk
, const u8
*addr
,
396 struct ath_hw
*ah
= common
->ah
;
400 key_txmic
= key
+ NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY
;
401 key_rxmic
= key
+ NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY
;
405 * Group key installation - only two key cache entries are used
406 * regardless of splitmic capability since group key is only
407 * used either for TX or RX.
410 memcpy(hk
->kv_mic
, key_txmic
, sizeof(hk
->kv_mic
));
411 memcpy(hk
->kv_txmic
, key_txmic
, sizeof(hk
->kv_mic
));
413 memcpy(hk
->kv_mic
, key_rxmic
, sizeof(hk
->kv_mic
));
414 memcpy(hk
->kv_txmic
, key_rxmic
, sizeof(hk
->kv_mic
));
416 return ath9k_hw_set_keycache_entry(ah
, keyix
, hk
, addr
);
418 if (!common
->splitmic
) {
419 /* TX and RX keys share the same key cache entry. */
420 memcpy(hk
->kv_mic
, key_rxmic
, sizeof(hk
->kv_mic
));
421 memcpy(hk
->kv_txmic
, key_txmic
, sizeof(hk
->kv_txmic
));
422 return ath9k_hw_set_keycache_entry(ah
, keyix
, hk
, addr
);
425 /* Separate key cache entries for TX and RX */
427 /* TX key goes at first index, RX key at +32. */
428 memcpy(hk
->kv_mic
, key_txmic
, sizeof(hk
->kv_mic
));
429 if (!ath9k_hw_set_keycache_entry(ah
, keyix
, hk
, NULL
)) {
430 /* TX MIC entry failed. No need to proceed further */
431 ath_print(common
, ATH_DBG_FATAL
,
432 "Setting TX MIC Key Failed\n");
436 memcpy(hk
->kv_mic
, key_rxmic
, sizeof(hk
->kv_mic
));
437 /* XXX delete tx key on failure? */
438 return ath9k_hw_set_keycache_entry(ah
, keyix
+ 32, hk
, addr
);
441 static int ath_reserve_key_cache_slot_tkip(struct ath_common
*common
)
445 for (i
= IEEE80211_WEP_NKID
; i
< common
->keymax
/ 2; i
++) {
446 if (test_bit(i
, common
->keymap
) ||
447 test_bit(i
+ 64, common
->keymap
))
448 continue; /* At least one part of TKIP key allocated */
449 if (common
->splitmic
&&
450 (test_bit(i
+ 32, common
->keymap
) ||
451 test_bit(i
+ 64 + 32, common
->keymap
)))
452 continue; /* At least one part of TKIP key allocated */
454 /* Found a free slot for a TKIP key */
460 static int ath_reserve_key_cache_slot(struct ath_common
*common
)
464 /* First, try to find slots that would not be available for TKIP. */
465 if (common
->splitmic
) {
466 for (i
= IEEE80211_WEP_NKID
; i
< common
->keymax
/ 4; i
++) {
467 if (!test_bit(i
, common
->keymap
) &&
468 (test_bit(i
+ 32, common
->keymap
) ||
469 test_bit(i
+ 64, common
->keymap
) ||
470 test_bit(i
+ 64 + 32, common
->keymap
)))
472 if (!test_bit(i
+ 32, common
->keymap
) &&
473 (test_bit(i
, common
->keymap
) ||
474 test_bit(i
+ 64, common
->keymap
) ||
475 test_bit(i
+ 64 + 32, common
->keymap
)))
477 if (!test_bit(i
+ 64, common
->keymap
) &&
478 (test_bit(i
, common
->keymap
) ||
479 test_bit(i
+ 32, common
->keymap
) ||
480 test_bit(i
+ 64 + 32, common
->keymap
)))
482 if (!test_bit(i
+ 64 + 32, common
->keymap
) &&
483 (test_bit(i
, common
->keymap
) ||
484 test_bit(i
+ 32, common
->keymap
) ||
485 test_bit(i
+ 64, common
->keymap
)))
489 for (i
= IEEE80211_WEP_NKID
; i
< common
->keymax
/ 2; i
++) {
490 if (!test_bit(i
, common
->keymap
) &&
491 test_bit(i
+ 64, common
->keymap
))
493 if (test_bit(i
, common
->keymap
) &&
494 !test_bit(i
+ 64, common
->keymap
))
499 /* No partially used TKIP slots, pick any available slot */
500 for (i
= IEEE80211_WEP_NKID
; i
< common
->keymax
; i
++) {
501 /* Do not allow slots that could be needed for TKIP group keys
502 * to be used. This limitation could be removed if we know that
503 * TKIP will not be used. */
504 if (i
>= 64 && i
< 64 + IEEE80211_WEP_NKID
)
506 if (common
->splitmic
) {
507 if (i
>= 32 && i
< 32 + IEEE80211_WEP_NKID
)
509 if (i
>= 64 + 32 && i
< 64 + 32 + IEEE80211_WEP_NKID
)
513 if (!test_bit(i
, common
->keymap
))
514 return i
; /* Found a free slot for a key */
517 /* No free slot found */
522 * Configure encryption in the HW.
524 int ath9k_cmn_key_config(struct ath_common
*common
,
525 struct ieee80211_vif
*vif
,
526 struct ieee80211_sta
*sta
,
527 struct ieee80211_key_conf
*key
)
529 struct ath_hw
*ah
= common
->ah
;
530 struct ath9k_keyval hk
;
531 const u8
*mac
= NULL
;
535 memset(&hk
, 0, sizeof(hk
));
539 hk
.kv_type
= ATH9K_CIPHER_WEP
;
542 hk
.kv_type
= ATH9K_CIPHER_TKIP
;
545 hk
.kv_type
= ATH9K_CIPHER_AES_CCM
;
551 hk
.kv_len
= key
->keylen
;
552 memcpy(hk
.kv_val
, key
->key
, key
->keylen
);
554 if (!(key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
)) {
555 /* For now, use the default keys for broadcast keys. This may
556 * need to change with virtual interfaces. */
558 } else if (key
->keyidx
) {
563 if (vif
->type
!= NL80211_IFTYPE_AP
) {
564 /* Only keyidx 0 should be used with unicast key, but
565 * allow this for client mode for now. */
574 if (key
->alg
== ALG_TKIP
)
575 idx
= ath_reserve_key_cache_slot_tkip(common
);
577 idx
= ath_reserve_key_cache_slot(common
);
579 return -ENOSPC
; /* no free key cache entries */
582 if (key
->alg
== ALG_TKIP
)
583 ret
= ath_setkey_tkip(common
, idx
, key
->key
, &hk
, mac
,
584 vif
->type
== NL80211_IFTYPE_AP
);
586 ret
= ath9k_hw_set_keycache_entry(ah
, idx
, &hk
, mac
);
591 set_bit(idx
, common
->keymap
);
592 if (key
->alg
== ALG_TKIP
) {
593 set_bit(idx
+ 64, common
->keymap
);
594 if (common
->splitmic
) {
595 set_bit(idx
+ 32, common
->keymap
);
596 set_bit(idx
+ 64 + 32, common
->keymap
);
602 EXPORT_SYMBOL(ath9k_cmn_key_config
);
607 void ath9k_cmn_key_delete(struct ath_common
*common
,
608 struct ieee80211_key_conf
*key
)
610 struct ath_hw
*ah
= common
->ah
;
612 ath9k_hw_keyreset(ah
, key
->hw_key_idx
);
613 if (key
->hw_key_idx
< IEEE80211_WEP_NKID
)
616 clear_bit(key
->hw_key_idx
, common
->keymap
);
617 if (key
->alg
!= ALG_TKIP
)
620 clear_bit(key
->hw_key_idx
+ 64, common
->keymap
);
621 if (common
->splitmic
) {
622 ath9k_hw_keyreset(ah
, key
->hw_key_idx
+ 32);
623 clear_bit(key
->hw_key_idx
+ 32, common
->keymap
);
624 clear_bit(key
->hw_key_idx
+ 64 + 32, common
->keymap
);
627 EXPORT_SYMBOL(ath9k_cmn_key_delete
);
629 static int __init
ath9k_cmn_init(void)
633 module_init(ath9k_cmn_init
);
635 static void __exit
ath9k_cmn_exit(void)
639 module_exit(ath9k_cmn_exit
);