Commit | Line | Data |
---|---|---|
5e6e3a92 BZ |
1 | /* |
2 | * Marvell Wireless LAN device driver: Channel, Frequence and Power | |
3 | * | |
4 | * Copyright (C) 2011, Marvell International Ltd. | |
5 | * | |
6 | * This software file (the "File") is distributed by Marvell International | |
7 | * Ltd. under the terms of the GNU General Public License Version 2, June 1991 | |
8 | * (the "License"). You may use, redistribute and/or modify this File in | |
9 | * accordance with the terms and conditions of the License, a copy of which | |
10 | * is available by writing to the Free Software Foundation, Inc., | |
11 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the | |
12 | * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. | |
13 | * | |
14 | * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE | |
15 | * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE | |
16 | * ARE EXPRESSLY DISCLAIMED. The License provides additional details about | |
17 | * this warranty disclaimer. | |
18 | */ | |
19 | ||
20 | #include "decl.h" | |
21 | #include "ioctl.h" | |
22 | #include "util.h" | |
23 | #include "fw.h" | |
24 | #include "main.h" | |
25 | #include "cfg80211.h" | |
26 | ||
27 | /* 100mW */ | |
28 | #define MWIFIEX_TX_PWR_DEFAULT 20 | |
29 | /* 100mW */ | |
30 | #define MWIFIEX_TX_PWR_US_DEFAULT 20 | |
31 | /* 50mW */ | |
32 | #define MWIFIEX_TX_PWR_JP_DEFAULT 16 | |
33 | /* 100mW */ | |
34 | #define MWIFIEX_TX_PWR_FR_100MW 20 | |
35 | /* 10mW */ | |
36 | #define MWIFIEX_TX_PWR_FR_10MW 10 | |
37 | /* 100mW */ | |
38 | #define MWIFIEX_TX_PWR_EMEA_DEFAULT 20 | |
39 | ||
40 | static u8 adhoc_rates_b[B_SUPPORTED_RATES] = { 0x82, 0x84, 0x8b, 0x96, 0 }; | |
41 | ||
42 | static u8 adhoc_rates_g[G_SUPPORTED_RATES] = { 0x8c, 0x12, 0x98, 0x24, | |
43 | 0xb0, 0x48, 0x60, 0x6c, 0 }; | |
44 | ||
45 | static u8 adhoc_rates_bg[BG_SUPPORTED_RATES] = { 0x82, 0x84, 0x8b, 0x96, | |
46 | 0x0c, 0x12, 0x18, 0x24, | |
47 | 0x30, 0x48, 0x60, 0x6c, 0 }; | |
48 | ||
49 | static u8 adhoc_rates_a[A_SUPPORTED_RATES] = { 0x8c, 0x12, 0x98, 0x24, | |
50 | 0xb0, 0x48, 0x60, 0x6c, 0 }; | |
711825a0 | 51 | static u8 supported_rates_a[A_SUPPORTED_RATES] = { 0x0c, 0x12, 0x18, 0x24, |
5e6e3a92 BZ |
52 | 0xb0, 0x48, 0x60, 0x6c, 0 }; |
53 | static u16 mwifiex_data_rates[MWIFIEX_SUPPORTED_RATES_EXT] = { 0x02, 0x04, | |
54 | 0x0B, 0x16, 0x00, 0x0C, 0x12, 0x18, | |
55 | 0x24, 0x30, 0x48, 0x60, 0x6C, 0x90, | |
56 | 0x0D, 0x1A, 0x27, 0x34, 0x4E, 0x68, | |
57 | 0x75, 0x82, 0x0C, 0x1B, 0x36, 0x51, | |
58 | 0x6C, 0xA2, 0xD8, 0xF3, 0x10E, 0x00 }; | |
59 | ||
711825a0 | 60 | static u8 supported_rates_b[B_SUPPORTED_RATES] = { 0x02, 0x04, 0x0b, 0x16, 0 }; |
5e6e3a92 | 61 | |
711825a0 | 62 | static u8 supported_rates_g[G_SUPPORTED_RATES] = { 0x0c, 0x12, 0x18, 0x24, |
5e6e3a92 BZ |
63 | 0x30, 0x48, 0x60, 0x6c, 0 }; |
64 | ||
711825a0 | 65 | static u8 supported_rates_bg[BG_SUPPORTED_RATES] = { 0x02, 0x04, 0x0b, 0x0c, |
5e6e3a92 BZ |
66 | 0x12, 0x16, 0x18, 0x24, 0x30, 0x48, |
67 | 0x60, 0x6c, 0 }; | |
68 | ||
69 | u16 region_code_index[MWIFIEX_MAX_REGION_CODE] = { 0x10, 0x20, 0x30, | |
70 | 0x32, 0x40, 0x41, 0xff }; | |
71 | ||
711825a0 | 72 | static u8 supported_rates_n[N_SUPPORTED_RATES] = { 0x02, 0x04, 0 }; |
5e6e3a92 BZ |
73 | |
74 | /* | |
75 | * This function maps an index in supported rates table into | |
76 | * the corresponding data rate. | |
77 | */ | |
e3bea1c8 BZ |
78 | u32 mwifiex_index_to_data_rate(struct mwifiex_private *priv, u8 index, |
79 | u8 ht_info) | |
5e6e3a92 | 80 | { |
e3bea1c8 BZ |
81 | /* |
82 | * For every mcs_rate line, the first 8 bytes are for stream 1x1, | |
83 | * and all 16 bytes are for stream 2x2. | |
84 | */ | |
85 | u16 mcs_rate[4][16] = { | |
86 | /* LGI 40M */ | |
87 | { 0x1b, 0x36, 0x51, 0x6c, 0xa2, 0xd8, 0xf3, 0x10e, | |
88 | 0x36, 0x6c, 0xa2, 0xd8, 0x144, 0x1b0, 0x1e6, 0x21c }, | |
89 | ||
90 | /* SGI 40M */ | |
91 | { 0x1e, 0x3c, 0x5a, 0x78, 0xb4, 0xf0, 0x10e, 0x12c, | |
92 | 0x3c, 0x78, 0xb4, 0xf0, 0x168, 0x1e0, 0x21c, 0x258 }, | |
93 | ||
94 | /* LGI 20M */ | |
95 | { 0x0d, 0x1a, 0x27, 0x34, 0x4e, 0x68, 0x75, 0x82, | |
96 | 0x1a, 0x34, 0x4e, 0x68, 0x9c, 0xd0, 0xea, 0x104 }, | |
97 | ||
98 | /* SGI 20M */ | |
99 | { 0x0e, 0x1c, 0x2b, 0x39, 0x56, 0x73, 0x82, 0x90, | |
100 | 0x1c, 0x39, 0x56, 0x73, 0xad, 0xe7, 0x104, 0x120 } | |
101 | }; | |
102 | u32 mcs_num_supp = | |
103 | (priv->adapter->hw_dev_mcs_support == HT_STREAM_2X2) ? 16 : 8; | |
5e6e3a92 BZ |
104 | u32 rate; |
105 | ||
106 | if (ht_info & BIT(0)) { | |
107 | if (index == MWIFIEX_RATE_BITMAP_MCS0) { | |
108 | if (ht_info & BIT(2)) | |
109 | rate = 0x0D; /* MCS 32 SGI rate */ | |
110 | else | |
111 | rate = 0x0C; /* MCS 32 LGI rate */ | |
e3bea1c8 | 112 | } else if (index < mcs_num_supp) { |
5e6e3a92 BZ |
113 | if (ht_info & BIT(1)) { |
114 | if (ht_info & BIT(2)) | |
115 | /* SGI, 40M */ | |
116 | rate = mcs_rate[1][index]; | |
117 | else | |
118 | /* LGI, 40M */ | |
119 | rate = mcs_rate[0][index]; | |
120 | } else { | |
121 | if (ht_info & BIT(2)) | |
122 | /* SGI, 20M */ | |
123 | rate = mcs_rate[3][index]; | |
124 | else | |
125 | /* LGI, 20M */ | |
126 | rate = mcs_rate[2][index]; | |
127 | } | |
128 | } else | |
129 | rate = mwifiex_data_rates[0]; | |
130 | } else { | |
131 | if (index >= MWIFIEX_SUPPORTED_RATES_EXT) | |
132 | index = 0; | |
133 | rate = mwifiex_data_rates[index]; | |
134 | } | |
135 | return rate; | |
136 | } | |
137 | ||
138 | /* | |
139 | * This function maps a data rate value into corresponding index in supported | |
140 | * rates table. | |
141 | */ | |
572e8f3e | 142 | u8 mwifiex_data_rate_to_index(u32 rate) |
5e6e3a92 BZ |
143 | { |
144 | u16 *ptr; | |
145 | ||
146 | if (rate) { | |
147 | ptr = memchr(mwifiex_data_rates, rate, | |
148 | sizeof(mwifiex_data_rates)); | |
149 | if (ptr) | |
150 | return (u8) (ptr - mwifiex_data_rates); | |
151 | } | |
152 | return 0; | |
153 | } | |
154 | ||
155 | /* | |
156 | * This function returns the current active data rates. | |
157 | * | |
158 | * The result may vary depending upon connection status. | |
159 | */ | |
160 | u32 mwifiex_get_active_data_rates(struct mwifiex_private *priv, u8 *rates) | |
161 | { | |
5e6e3a92 | 162 | if (!priv->media_connected) |
636c4598 | 163 | return mwifiex_get_supported_rates(priv, rates); |
5e6e3a92 | 164 | else |
636c4598 | 165 | return mwifiex_copy_rates(rates, 0, |
aea0701e YAP |
166 | priv->curr_bss_params.data_rates, |
167 | priv->curr_bss_params.num_of_rates); | |
5e6e3a92 BZ |
168 | } |
169 | ||
170 | /* | |
171 | * This function locates the Channel-Frequency-Power triplet based upon | |
6685d109 | 172 | * band and channel/frequency parameters. |
5e6e3a92 BZ |
173 | */ |
174 | struct mwifiex_chan_freq_power * | |
6685d109 | 175 | mwifiex_get_cfp(struct mwifiex_private *priv, u8 band, u16 channel, u32 freq) |
5e6e3a92 BZ |
176 | { |
177 | struct mwifiex_chan_freq_power *cfp = NULL; | |
178 | struct ieee80211_supported_band *sband; | |
6685d109 | 179 | struct ieee80211_channel *ch = NULL; |
5e6e3a92 BZ |
180 | int i; |
181 | ||
6685d109 | 182 | if (!channel && !freq) |
5e6e3a92 | 183 | return cfp; |
5e6e3a92 BZ |
184 | |
185 | if (mwifiex_band_to_radio_type(band) == HostCmd_SCAN_RADIO_TYPE_BG) | |
186 | sband = priv->wdev->wiphy->bands[IEEE80211_BAND_2GHZ]; | |
187 | else | |
188 | sband = priv->wdev->wiphy->bands[IEEE80211_BAND_5GHZ]; | |
189 | ||
190 | if (!sband) { | |
6685d109 YAP |
191 | dev_err(priv->adapter->dev, "%s: cannot find cfp by band %d\n", |
192 | __func__, band); | |
5e6e3a92 BZ |
193 | return cfp; |
194 | } | |
195 | ||
196 | for (i = 0; i < sband->n_channels; i++) { | |
197 | ch = &sband->channels[i]; | |
6685d109 YAP |
198 | |
199 | if (ch->flags & IEEE80211_CHAN_DISABLED) | |
200 | continue; | |
201 | ||
202 | if (freq) { | |
203 | if (ch->center_freq == freq) | |
204 | break; | |
205 | } else { | |
206 | /* find by valid channel*/ | |
207 | if (ch->hw_value == channel || | |
208 | channel == FIRST_VALID_CHANNEL) | |
209 | break; | |
5e6e3a92 BZ |
210 | } |
211 | } | |
6685d109 | 212 | if (i == sband->n_channels) { |
5e6e3a92 | 213 | dev_err(priv->adapter->dev, "%s: cannot find cfp by band %d" |
6685d109 YAP |
214 | " & channel=%d freq=%d\n", __func__, band, channel, |
215 | freq); | |
216 | } else { | |
217 | if (!ch) | |
218 | return cfp; | |
219 | ||
220 | priv->cfp.channel = ch->hw_value; | |
221 | priv->cfp.freq = ch->center_freq; | |
222 | priv->cfp.max_tx_power = ch->max_power; | |
223 | cfp = &priv->cfp; | |
224 | } | |
5e6e3a92 BZ |
225 | |
226 | return cfp; | |
227 | } | |
228 | ||
229 | /* | |
230 | * This function checks if the data rate is set to auto. | |
231 | */ | |
232 | u8 | |
233 | mwifiex_is_rate_auto(struct mwifiex_private *priv) | |
234 | { | |
235 | u32 i; | |
236 | int rate_num = 0; | |
237 | ||
238 | for (i = 0; i < ARRAY_SIZE(priv->bitmap_rates); i++) | |
239 | if (priv->bitmap_rates[i]) | |
240 | rate_num++; | |
241 | ||
242 | if (rate_num > 1) | |
243 | return true; | |
244 | else | |
245 | return false; | |
246 | } | |
247 | ||
248 | /* | |
249 | * This function converts rate bitmap into rate index. | |
250 | */ | |
572e8f3e | 251 | int mwifiex_get_rate_index(u16 *rate_bitmap, int size) |
5e6e3a92 BZ |
252 | { |
253 | int i; | |
254 | ||
255 | for (i = 0; i < size * 8; i++) | |
256 | if (rate_bitmap[i / 16] & (1 << (i % 16))) | |
257 | return i; | |
258 | ||
259 | return 0; | |
260 | } | |
261 | ||
262 | /* | |
263 | * This function gets the supported data rates. | |
264 | * | |
265 | * The function works in both Ad-Hoc and infra mode by printing the | |
266 | * band and returning the data rates. | |
267 | */ | |
268 | u32 mwifiex_get_supported_rates(struct mwifiex_private *priv, u8 *rates) | |
269 | { | |
270 | u32 k = 0; | |
271 | struct mwifiex_adapter *adapter = priv->adapter; | |
eecd8250 | 272 | if (priv->bss_mode == NL80211_IFTYPE_STATION) { |
5e6e3a92 BZ |
273 | switch (adapter->config_bands) { |
274 | case BAND_B: | |
275 | dev_dbg(adapter->dev, "info: infra band=%d " | |
276 | "supported_rates_b\n", adapter->config_bands); | |
277 | k = mwifiex_copy_rates(rates, k, supported_rates_b, | |
278 | sizeof(supported_rates_b)); | |
279 | break; | |
280 | case BAND_G: | |
281 | case BAND_G | BAND_GN: | |
282 | dev_dbg(adapter->dev, "info: infra band=%d " | |
283 | "supported_rates_g\n", adapter->config_bands); | |
284 | k = mwifiex_copy_rates(rates, k, supported_rates_g, | |
285 | sizeof(supported_rates_g)); | |
286 | break; | |
287 | case BAND_B | BAND_G: | |
288 | case BAND_A | BAND_B | BAND_G: | |
289 | case BAND_A | BAND_B: | |
290 | case BAND_A | BAND_B | BAND_G | BAND_GN | BAND_AN: | |
291 | case BAND_B | BAND_G | BAND_GN: | |
292 | dev_dbg(adapter->dev, "info: infra band=%d " | |
293 | "supported_rates_bg\n", adapter->config_bands); | |
294 | k = mwifiex_copy_rates(rates, k, supported_rates_bg, | |
295 | sizeof(supported_rates_bg)); | |
296 | break; | |
297 | case BAND_A: | |
298 | case BAND_A | BAND_G: | |
299 | dev_dbg(adapter->dev, "info: infra band=%d " | |
300 | "supported_rates_a\n", adapter->config_bands); | |
301 | k = mwifiex_copy_rates(rates, k, supported_rates_a, | |
302 | sizeof(supported_rates_a)); | |
303 | break; | |
304 | case BAND_A | BAND_AN: | |
305 | case BAND_A | BAND_G | BAND_AN | BAND_GN: | |
306 | dev_dbg(adapter->dev, "info: infra band=%d " | |
307 | "supported_rates_a\n", adapter->config_bands); | |
308 | k = mwifiex_copy_rates(rates, k, supported_rates_a, | |
309 | sizeof(supported_rates_a)); | |
310 | break; | |
311 | case BAND_GN: | |
312 | dev_dbg(adapter->dev, "info: infra band=%d " | |
313 | "supported_rates_n\n", adapter->config_bands); | |
314 | k = mwifiex_copy_rates(rates, k, supported_rates_n, | |
315 | sizeof(supported_rates_n)); | |
316 | break; | |
317 | } | |
318 | } else { | |
319 | /* Ad-hoc mode */ | |
320 | switch (adapter->adhoc_start_band) { | |
321 | case BAND_B: | |
322 | dev_dbg(adapter->dev, "info: adhoc B\n"); | |
323 | k = mwifiex_copy_rates(rates, k, adhoc_rates_b, | |
324 | sizeof(adhoc_rates_b)); | |
325 | break; | |
326 | case BAND_G: | |
327 | case BAND_G | BAND_GN: | |
328 | dev_dbg(adapter->dev, "info: adhoc G only\n"); | |
329 | k = mwifiex_copy_rates(rates, k, adhoc_rates_g, | |
330 | sizeof(adhoc_rates_g)); | |
331 | break; | |
332 | case BAND_B | BAND_G: | |
333 | case BAND_B | BAND_G | BAND_GN: | |
334 | dev_dbg(adapter->dev, "info: adhoc BG\n"); | |
335 | k = mwifiex_copy_rates(rates, k, adhoc_rates_bg, | |
336 | sizeof(adhoc_rates_bg)); | |
337 | break; | |
338 | case BAND_A: | |
339 | case BAND_A | BAND_AN: | |
340 | dev_dbg(adapter->dev, "info: adhoc A\n"); | |
341 | k = mwifiex_copy_rates(rates, k, adhoc_rates_a, | |
342 | sizeof(adhoc_rates_a)); | |
343 | break; | |
344 | } | |
345 | } | |
346 | ||
347 | return k; | |
348 | } |