Commit | Line | Data |
---|---|---|
13b81559 LR |
1 | /* |
2 | * Copyright (c) 2009 Atheros Communications Inc. | |
3 | * | |
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. | |
7 | * | |
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. | |
15 | */ | |
16 | ||
ee40fa06 | 17 | #include <linux/export.h> |
13b81559 LR |
18 | #include <asm/unaligned.h> |
19 | ||
20 | #include "ath.h" | |
21 | #include "reg.h" | |
22 | ||
037fd9b6 SE |
23 | #define REG_READ (common->ops->read) |
24 | #define REG_WRITE(_ah, _reg, _val) (common->ops->write)(_ah, _val, _reg) | |
13b81559 LR |
25 | |
26 | /** | |
27 | * ath_hw_set_bssid_mask - filter out bssids we listen | |
28 | * | |
29 | * @common: the ath_common struct for the device. | |
30 | * | |
31 | * BSSID masking is a method used by AR5212 and newer hardware to inform PCU | |
32 | * which bits of the interface's MAC address should be looked at when trying | |
33 | * to decide which packets to ACK. In station mode and AP mode with a single | |
34 | * BSS every bit matters since we lock to only one BSS. In AP mode with | |
35 | * multiple BSSes (virtual interfaces) not every bit matters because hw must | |
36 | * accept frames for all BSSes and so we tweak some bits of our mac address | |
37 | * in order to have multiple BSSes. | |
38 | * | |
39 | * NOTE: This is a simple filter and does *not* filter out all | |
40 | * relevant frames. Some frames that are not for us might get ACKed from us | |
41 | * by PCU because they just match the mask. | |
42 | * | |
43 | * When handling multiple BSSes you can get the BSSID mask by computing the | |
44 | * set of ~ ( MAC XOR BSSID ) for all bssids we handle. | |
45 | * | |
46 | * When you do this you are essentially computing the common bits of all your | |
a455c57e | 47 | * BSSes. Later it is assumed the hardware will "and" (&) the BSSID mask with |
13b81559 LR |
48 | * the MAC address to obtain the relevant bits and compare the result with |
49 | * (frame's BSSID & mask) to see if they match. | |
50 | * | |
51 | * Simple example: on your card you have have two BSSes you have created with | |
52 | * BSSID-01 and BSSID-02. Lets assume BSSID-01 will not use the MAC address. | |
53 | * There is another BSSID-03 but you are not part of it. For simplicity's sake, | |
54 | * assuming only 4 bits for a mac address and for BSSIDs you can then have: | |
55 | * | |
56 | * \ | |
57 | * MAC: 0001 | | |
58 | * BSSID-01: 0100 | --> Belongs to us | |
59 | * BSSID-02: 1001 | | |
60 | * / | |
61 | * ------------------- | |
62 | * BSSID-03: 0110 | --> External | |
63 | * ------------------- | |
64 | * | |
65 | * Our bssid_mask would then be: | |
66 | * | |
67 | * On loop iteration for BSSID-01: | |
68 | * ~(0001 ^ 0100) -> ~(0101) | |
69 | * -> 1010 | |
70 | * bssid_mask = 1010 | |
71 | * | |
72 | * On loop iteration for BSSID-02: | |
73 | * bssid_mask &= ~(0001 ^ 1001) | |
74 | * bssid_mask = (1010) & ~(0001 ^ 1001) | |
a455c57e MSS |
75 | * bssid_mask = (1010) & ~(1000) |
76 | * bssid_mask = (1010) & (0111) | |
13b81559 LR |
77 | * bssid_mask = 0010 |
78 | * | |
79 | * A bssid_mask of 0010 means "only pay attention to the second least | |
80 | * significant bit". This is because its the only bit common | |
81 | * amongst the MAC and all BSSIDs we support. To findout what the real | |
82 | * common bit is we can simply "&" the bssid_mask now with any BSSID we have | |
83 | * or our MAC address (we assume the hardware uses the MAC address). | |
84 | * | |
85 | * Now, suppose there's an incoming frame for BSSID-03: | |
86 | * | |
87 | * IFRAME-01: 0110 | |
88 | * | |
89 | * An easy eye-inspeciton of this already should tell you that this frame | |
25985edc | 90 | * will not pass our check. This is because the bssid_mask tells the |
13b81559 LR |
91 | * hardware to only look at the second least significant bit and the |
92 | * common bit amongst the MAC and BSSIDs is 0, this frame has the 2nd LSB | |
93 | * as 1, which does not match 0. | |
94 | * | |
95 | * So with IFRAME-01 we *assume* the hardware will do: | |
96 | * | |
97 | * allow = (IFRAME-01 & bssid_mask) == (bssid_mask & MAC) ? 1 : 0; | |
98 | * --> allow = (0110 & 0010) == (0010 & 0001) ? 1 : 0; | |
99 | * --> allow = (0010) == 0000 ? 1 : 0; | |
100 | * --> allow = 0 | |
101 | * | |
102 | * Lets now test a frame that should work: | |
103 | * | |
104 | * IFRAME-02: 0001 (we should allow) | |
105 | * | |
13b81559 LR |
106 | * allow = (IFRAME-02 & bssid_mask) == (bssid_mask & MAC) ? 1 : 0; |
107 | * --> allow = (0001 & 0010) == (0010 & 0001) ? 1 :0; | |
a455c57e | 108 | * --> allow = (0000) == (0000) |
13b81559 LR |
109 | * --> allow = 1 |
110 | * | |
111 | * Other examples: | |
112 | * | |
113 | * IFRAME-03: 0100 --> allowed | |
114 | * IFRAME-04: 1001 --> allowed | |
115 | * IFRAME-05: 1101 --> allowed but its not for us!!! | |
116 | * | |
117 | */ | |
118 | void ath_hw_setbssidmask(struct ath_common *common) | |
119 | { | |
120 | void *ah = common->ah; | |
ecbbed32 FF |
121 | u32 id1; |
122 | ||
123 | REG_WRITE(ah, AR_STA_ID0, get_unaligned_le32(common->macaddr)); | |
124 | id1 = REG_READ(ah, AR_STA_ID1) & ~AR_STA_ID1_SADH_MASK; | |
125 | id1 |= get_unaligned_le16(common->macaddr + 4); | |
126 | REG_WRITE(ah, AR_STA_ID1, id1); | |
13b81559 | 127 | |
037fd9b6 SE |
128 | REG_WRITE(ah, AR_BSSMSKL, get_unaligned_le32(common->bssidmask)); |
129 | REG_WRITE(ah, AR_BSSMSKU, get_unaligned_le16(common->bssidmask + 4)); | |
13b81559 LR |
130 | } |
131 | EXPORT_SYMBOL(ath_hw_setbssidmask); | |
b5bfc568 FF |
132 | |
133 | ||
134 | /** | |
135 | * ath_hw_cycle_counters_update - common function to update cycle counters | |
136 | * | |
137 | * @common: the ath_common struct for the device. | |
138 | * | |
139 | * This function is used to update all cycle counters in one place. | |
140 | * It has to be called while holding common->cc_lock! | |
141 | */ | |
142 | void ath_hw_cycle_counters_update(struct ath_common *common) | |
143 | { | |
144 | u32 cycles, busy, rx, tx; | |
145 | void *ah = common->ah; | |
146 | ||
147 | /* freeze */ | |
037fd9b6 | 148 | REG_WRITE(ah, AR_MIBC, AR_MIBC_FMC); |
b5bfc568 FF |
149 | |
150 | /* read */ | |
151 | cycles = REG_READ(ah, AR_CCCNT); | |
152 | busy = REG_READ(ah, AR_RCCNT); | |
153 | rx = REG_READ(ah, AR_RFCNT); | |
154 | tx = REG_READ(ah, AR_TFCNT); | |
155 | ||
156 | /* clear */ | |
037fd9b6 SE |
157 | REG_WRITE(ah, AR_CCCNT, 0); |
158 | REG_WRITE(ah, AR_RFCNT, 0); | |
159 | REG_WRITE(ah, AR_RCCNT, 0); | |
160 | REG_WRITE(ah, AR_TFCNT, 0); | |
b5bfc568 FF |
161 | |
162 | /* unfreeze */ | |
037fd9b6 | 163 | REG_WRITE(ah, AR_MIBC, 0); |
b5bfc568 FF |
164 | |
165 | /* update all cycle counters here */ | |
166 | common->cc_ani.cycles += cycles; | |
167 | common->cc_ani.rx_busy += busy; | |
168 | common->cc_ani.rx_frame += rx; | |
169 | common->cc_ani.tx_frame += tx; | |
170 | ||
171 | common->cc_survey.cycles += cycles; | |
172 | common->cc_survey.rx_busy += busy; | |
173 | common->cc_survey.rx_frame += rx; | |
174 | common->cc_survey.tx_frame += tx; | |
175 | } | |
176 | EXPORT_SYMBOL(ath_hw_cycle_counters_update); | |
177 | ||
178 | int32_t ath_hw_get_listen_time(struct ath_common *common) | |
179 | { | |
180 | struct ath_cycle_counters *cc = &common->cc_ani; | |
181 | int32_t listen_time; | |
182 | ||
183 | listen_time = (cc->cycles - cc->rx_frame - cc->tx_frame) / | |
184 | (common->clockrate * 1000); | |
185 | ||
186 | memset(cc, 0, sizeof(*cc)); | |
187 | ||
188 | return listen_time; | |
189 | } | |
190 | EXPORT_SYMBOL(ath_hw_get_listen_time); |