]>
Commit | Line | Data |
---|---|---|
5e6e3a92 BZ |
1 | /* |
2 | * Marvell Wireless LAN device driver: Channel, Frequence and Power | |
3 | * | |
65da33f5 | 4 | * Copyright (C) 2011-2014, Marvell International Ltd. |
5e6e3a92 BZ |
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 | ||
658cb592 | 69 | u16 region_code_index[MWIFIEX_MAX_REGION_CODE] = { 0x00, 0x10, 0x20, 0x30, |
610d0af8 | 70 | 0x31, 0x32, 0x40, 0x41, 0x50 }; |
5e6e3a92 | 71 | |
711825a0 | 72 | static u8 supported_rates_n[N_SUPPORTED_RATES] = { 0x02, 0x04, 0 }; |
5e6e3a92 | 73 | |
89467d8c BZ |
74 | /* For every mcs_rate line, the first 8 bytes are for stream 1x1, |
75 | * and all 16 bytes are for stream 2x2. | |
76 | */ | |
77 | static const u16 mcs_rate[4][16] = { | |
78 | /* LGI 40M */ | |
79 | { 0x1b, 0x36, 0x51, 0x6c, 0xa2, 0xd8, 0xf3, 0x10e, | |
80 | 0x36, 0x6c, 0xa2, 0xd8, 0x144, 0x1b0, 0x1e6, 0x21c }, | |
81 | ||
82 | /* SGI 40M */ | |
83 | { 0x1e, 0x3c, 0x5a, 0x78, 0xb4, 0xf0, 0x10e, 0x12c, | |
84 | 0x3c, 0x78, 0xb4, 0xf0, 0x168, 0x1e0, 0x21c, 0x258 }, | |
85 | ||
86 | /* LGI 20M */ | |
87 | { 0x0d, 0x1a, 0x27, 0x34, 0x4e, 0x68, 0x75, 0x82, | |
88 | 0x1a, 0x34, 0x4e, 0x68, 0x9c, 0xd0, 0xea, 0x104 }, | |
89 | ||
90 | /* SGI 20M */ | |
91 | { 0x0e, 0x1c, 0x2b, 0x39, 0x56, 0x73, 0x82, 0x90, | |
92 | 0x1c, 0x39, 0x56, 0x73, 0xad, 0xe7, 0x104, 0x120 } | |
93 | }; | |
94 | ||
95 | /* AC rates */ | |
96 | static const u16 ac_mcs_rate_nss1[8][10] = { | |
97 | /* LG 160M */ | |
98 | { 0x75, 0xEA, 0x15F, 0x1D4, 0x2BE, 0x3A8, 0x41D, | |
99 | 0x492, 0x57C, 0x618 }, | |
100 | ||
101 | /* SG 160M */ | |
102 | { 0x82, 0x104, 0x186, 0x208, 0x30C, 0x410, 0x492, | |
103 | 0x514, 0x618, 0x6C6 }, | |
104 | ||
105 | /* LG 80M */ | |
106 | { 0x3B, 0x75, 0xB0, 0xEA, 0x15F, 0x1D4, 0x20F, | |
107 | 0x249, 0x2BE, 0x30C }, | |
108 | ||
109 | /* SG 80M */ | |
110 | { 0x41, 0x82, 0xC3, 0x104, 0x186, 0x208, 0x249, | |
111 | 0x28A, 0x30C, 0x363 }, | |
112 | ||
113 | /* LG 40M */ | |
114 | { 0x1B, 0x36, 0x51, 0x6C, 0xA2, 0xD8, 0xF3, | |
115 | 0x10E, 0x144, 0x168 }, | |
116 | ||
117 | /* SG 40M */ | |
118 | { 0x1E, 0x3C, 0x5A, 0x78, 0xB4, 0xF0, 0x10E, | |
119 | 0x12C, 0x168, 0x190 }, | |
120 | ||
121 | /* LG 20M */ | |
122 | { 0xD, 0x1A, 0x27, 0x34, 0x4E, 0x68, 0x75, 0x82, 0x9C, 0x00 }, | |
123 | ||
124 | /* SG 20M */ | |
125 | { 0xF, 0x1D, 0x2C, 0x3A, 0x57, 0x74, 0x82, 0x91, 0xAE, 0x00 }, | |
126 | }; | |
127 | ||
128 | /* NSS2 note: the value in the table is 2 multiplier of the actual rate */ | |
129 | static const u16 ac_mcs_rate_nss2[8][10] = { | |
130 | /* LG 160M */ | |
131 | { 0xEA, 0x1D4, 0x2BE, 0x3A8, 0x57C, 0x750, 0x83A, | |
132 | 0x924, 0xAF8, 0xC30 }, | |
133 | ||
134 | /* SG 160M */ | |
135 | { 0x104, 0x208, 0x30C, 0x410, 0x618, 0x820, 0x924, | |
136 | 0xA28, 0xC30, 0xD8B }, | |
137 | ||
138 | /* LG 80M */ | |
139 | { 0x75, 0xEA, 0x15F, 0x1D4, 0x2BE, 0x3A8, 0x41D, | |
140 | 0x492, 0x57C, 0x618 }, | |
141 | ||
142 | /* SG 80M */ | |
143 | { 0x82, 0x104, 0x186, 0x208, 0x30C, 0x410, 0x492, | |
144 | 0x514, 0x618, 0x6C6 }, | |
145 | ||
146 | /* LG 40M */ | |
147 | { 0x36, 0x6C, 0xA2, 0xD8, 0x144, 0x1B0, 0x1E6, | |
148 | 0x21C, 0x288, 0x2D0 }, | |
149 | ||
150 | /* SG 40M */ | |
151 | { 0x3C, 0x78, 0xB4, 0xF0, 0x168, 0x1E0, 0x21C, | |
152 | 0x258, 0x2D0, 0x320 }, | |
153 | ||
154 | /* LG 20M */ | |
155 | { 0x1A, 0x34, 0x4A, 0x68, 0x9C, 0xD0, 0xEA, 0x104, | |
156 | 0x138, 0x00 }, | |
157 | ||
158 | /* SG 20M */ | |
159 | { 0x1D, 0x3A, 0x57, 0x74, 0xAE, 0xE6, 0x104, 0x121, | |
160 | 0x15B, 0x00 }, | |
161 | }; | |
162 | ||
9e04a7c6 AK |
163 | struct region_code_mapping { |
164 | u8 code; | |
165 | u8 region[IEEE80211_COUNTRY_STRING_LEN]; | |
166 | }; | |
167 | ||
168 | static struct region_code_mapping region_code_mapping_t[] = { | |
169 | { 0x10, "US " }, /* US FCC */ | |
170 | { 0x20, "CA " }, /* IC Canada */ | |
7cfd829c | 171 | { 0x30, "FR " }, /* France */ |
9e04a7c6 AK |
172 | { 0x31, "ES " }, /* Spain */ |
173 | { 0x32, "FR " }, /* France */ | |
174 | { 0x40, "JP " }, /* Japan */ | |
175 | { 0x41, "JP " }, /* Japan */ | |
176 | { 0x50, "CN " }, /* China */ | |
177 | }; | |
178 | ||
179 | /* This function converts integer code to region string */ | |
180 | u8 *mwifiex_11d_code_2_region(u8 code) | |
181 | { | |
182 | u8 i; | |
9e04a7c6 AK |
183 | |
184 | /* Look for code in mapping table */ | |
8395fd9b | 185 | for (i = 0; i < ARRAY_SIZE(region_code_mapping_t); i++) |
9e04a7c6 AK |
186 | if (region_code_mapping_t[i].code == code) |
187 | return region_code_mapping_t[i].region; | |
188 | ||
189 | return NULL; | |
190 | } | |
191 | ||
5e6e3a92 BZ |
192 | /* |
193 | * This function maps an index in supported rates table into | |
194 | * the corresponding data rate. | |
195 | */ | |
a5f39056 YAP |
196 | u32 mwifiex_index_to_acs_data_rate(struct mwifiex_private *priv, |
197 | u8 index, u8 ht_info) | |
5e6e3a92 | 198 | { |
a5f39056 YAP |
199 | u32 rate = 0; |
200 | u8 mcs_index = 0; | |
201 | u8 bw = 0; | |
202 | u8 gi = 0; | |
203 | ||
204 | if ((ht_info & 0x3) == MWIFIEX_RATE_FORMAT_VHT) { | |
205 | mcs_index = min(index & 0xF, 9); | |
206 | ||
207 | /* 20M: bw=0, 40M: bw=1, 80M: bw=2, 160M: bw=3 */ | |
208 | bw = (ht_info & 0xC) >> 2; | |
209 | ||
210 | /* LGI: gi =0, SGI: gi = 1 */ | |
211 | gi = (ht_info & 0x10) >> 4; | |
212 | ||
213 | if ((index >> 4) == 1) /* NSS = 2 */ | |
214 | rate = ac_mcs_rate_nss2[2 * (3 - bw) + gi][mcs_index]; | |
215 | else /* NSS = 1 */ | |
216 | rate = ac_mcs_rate_nss1[2 * (3 - bw) + gi][mcs_index]; | |
217 | } else if ((ht_info & 0x3) == MWIFIEX_RATE_FORMAT_HT) { | |
218 | /* 20M: bw=0, 40M: bw=1 */ | |
219 | bw = (ht_info & 0xC) >> 2; | |
220 | ||
221 | /* LGI: gi =0, SGI: gi = 1 */ | |
222 | gi = (ht_info & 0x10) >> 4; | |
223 | ||
224 | if (index == MWIFIEX_RATE_BITMAP_MCS0) { | |
225 | if (gi == 1) | |
226 | rate = 0x0D; /* MCS 32 SGI rate */ | |
227 | else | |
228 | rate = 0x0C; /* MCS 32 LGI rate */ | |
229 | } else if (index < 16) { | |
230 | if ((bw == 1) || (bw == 0)) | |
231 | rate = mcs_rate[2 * (1 - bw) + gi][index]; | |
232 | else | |
233 | rate = mwifiex_data_rates[0]; | |
234 | } else { | |
235 | rate = mwifiex_data_rates[0]; | |
236 | } | |
237 | } else { | |
238 | /* 11n non-HT rates */ | |
239 | if (index >= MWIFIEX_SUPPORTED_RATES_EXT) | |
240 | index = 0; | |
241 | rate = mwifiex_data_rates[index]; | |
242 | } | |
243 | ||
244 | return rate; | |
245 | } | |
246 | ||
247 | /* This function maps an index in supported rates table into | |
248 | * the corresponding data rate. | |
249 | */ | |
250 | u32 mwifiex_index_to_data_rate(struct mwifiex_private *priv, | |
251 | u8 index, u8 ht_info) | |
252 | { | |
e3bea1c8 | 253 | u32 mcs_num_supp = |
a5333914 | 254 | (priv->adapter->user_dev_mcs_support == HT_STREAM_2X2) ? 16 : 8; |
5e6e3a92 BZ |
255 | u32 rate; |
256 | ||
a5f39056 YAP |
257 | if (priv->adapter->is_hw_11ac_capable) |
258 | return mwifiex_index_to_acs_data_rate(priv, index, ht_info); | |
259 | ||
5e6e3a92 BZ |
260 | if (ht_info & BIT(0)) { |
261 | if (index == MWIFIEX_RATE_BITMAP_MCS0) { | |
262 | if (ht_info & BIT(2)) | |
263 | rate = 0x0D; /* MCS 32 SGI rate */ | |
264 | else | |
265 | rate = 0x0C; /* MCS 32 LGI rate */ | |
e3bea1c8 | 266 | } else if (index < mcs_num_supp) { |
5e6e3a92 BZ |
267 | if (ht_info & BIT(1)) { |
268 | if (ht_info & BIT(2)) | |
269 | /* SGI, 40M */ | |
270 | rate = mcs_rate[1][index]; | |
271 | else | |
272 | /* LGI, 40M */ | |
273 | rate = mcs_rate[0][index]; | |
274 | } else { | |
275 | if (ht_info & BIT(2)) | |
276 | /* SGI, 20M */ | |
277 | rate = mcs_rate[3][index]; | |
278 | else | |
279 | /* LGI, 20M */ | |
280 | rate = mcs_rate[2][index]; | |
281 | } | |
282 | } else | |
283 | rate = mwifiex_data_rates[0]; | |
284 | } else { | |
285 | if (index >= MWIFIEX_SUPPORTED_RATES_EXT) | |
286 | index = 0; | |
287 | rate = mwifiex_data_rates[index]; | |
288 | } | |
289 | return rate; | |
290 | } | |
291 | ||
5e6e3a92 BZ |
292 | /* |
293 | * This function returns the current active data rates. | |
294 | * | |
295 | * The result may vary depending upon connection status. | |
296 | */ | |
297 | u32 mwifiex_get_active_data_rates(struct mwifiex_private *priv, u8 *rates) | |
298 | { | |
5e6e3a92 | 299 | if (!priv->media_connected) |
636c4598 | 300 | return mwifiex_get_supported_rates(priv, rates); |
5e6e3a92 | 301 | else |
636c4598 | 302 | return mwifiex_copy_rates(rates, 0, |
aea0701e YAP |
303 | priv->curr_bss_params.data_rates, |
304 | priv->curr_bss_params.num_of_rates); | |
5e6e3a92 BZ |
305 | } |
306 | ||
307 | /* | |
308 | * This function locates the Channel-Frequency-Power triplet based upon | |
6685d109 | 309 | * band and channel/frequency parameters. |
5e6e3a92 BZ |
310 | */ |
311 | struct mwifiex_chan_freq_power * | |
6685d109 | 312 | mwifiex_get_cfp(struct mwifiex_private *priv, u8 band, u16 channel, u32 freq) |
5e6e3a92 BZ |
313 | { |
314 | struct mwifiex_chan_freq_power *cfp = NULL; | |
315 | struct ieee80211_supported_band *sband; | |
6685d109 | 316 | struct ieee80211_channel *ch = NULL; |
5e6e3a92 BZ |
317 | int i; |
318 | ||
6685d109 | 319 | if (!channel && !freq) |
5e6e3a92 | 320 | return cfp; |
5e6e3a92 BZ |
321 | |
322 | if (mwifiex_band_to_radio_type(band) == HostCmd_SCAN_RADIO_TYPE_BG) | |
57fbcce3 | 323 | sband = priv->wdev.wiphy->bands[NL80211_BAND_2GHZ]; |
5e6e3a92 | 324 | else |
57fbcce3 | 325 | sband = priv->wdev.wiphy->bands[NL80211_BAND_5GHZ]; |
5e6e3a92 BZ |
326 | |
327 | if (!sband) { | |
acebe8c1 ZL |
328 | mwifiex_dbg(priv->adapter, ERROR, |
329 | "%s: cannot find cfp by band %d\n", | |
330 | __func__, band); | |
5e6e3a92 BZ |
331 | return cfp; |
332 | } | |
333 | ||
334 | for (i = 0; i < sband->n_channels; i++) { | |
335 | ch = &sband->channels[i]; | |
6685d109 YAP |
336 | |
337 | if (ch->flags & IEEE80211_CHAN_DISABLED) | |
338 | continue; | |
339 | ||
340 | if (freq) { | |
341 | if (ch->center_freq == freq) | |
342 | break; | |
343 | } else { | |
344 | /* find by valid channel*/ | |
345 | if (ch->hw_value == channel || | |
346 | channel == FIRST_VALID_CHANNEL) | |
347 | break; | |
5e6e3a92 BZ |
348 | } |
349 | } | |
6685d109 | 350 | if (i == sband->n_channels) { |
421ba82c | 351 | mwifiex_dbg(priv->adapter, WARN, |
acebe8c1 ZL |
352 | "%s: cannot find cfp by band %d\t" |
353 | "& channel=%d freq=%d\n", | |
354 | __func__, band, channel, freq); | |
6685d109 YAP |
355 | } else { |
356 | if (!ch) | |
357 | return cfp; | |
358 | ||
359 | priv->cfp.channel = ch->hw_value; | |
360 | priv->cfp.freq = ch->center_freq; | |
361 | priv->cfp.max_tx_power = ch->max_power; | |
362 | cfp = &priv->cfp; | |
363 | } | |
5e6e3a92 BZ |
364 | |
365 | return cfp; | |
366 | } | |
367 | ||
368 | /* | |
369 | * This function checks if the data rate is set to auto. | |
370 | */ | |
371 | u8 | |
372 | mwifiex_is_rate_auto(struct mwifiex_private *priv) | |
373 | { | |
374 | u32 i; | |
375 | int rate_num = 0; | |
376 | ||
377 | for (i = 0; i < ARRAY_SIZE(priv->bitmap_rates); i++) | |
378 | if (priv->bitmap_rates[i]) | |
379 | rate_num++; | |
380 | ||
381 | if (rate_num > 1) | |
382 | return true; | |
383 | else | |
384 | return false; | |
385 | } | |
386 | ||
78dfca62 AP |
387 | /* This function gets the supported data rates from bitmask inside |
388 | * cfg80211_scan_request. | |
389 | */ | |
390 | u32 mwifiex_get_rates_from_cfg80211(struct mwifiex_private *priv, | |
391 | u8 *rates, u8 radio_type) | |
392 | { | |
393 | struct wiphy *wiphy = priv->adapter->wiphy; | |
394 | struct cfg80211_scan_request *request = priv->scan_request; | |
395 | u32 num_rates, rate_mask; | |
396 | struct ieee80211_supported_band *sband; | |
397 | int i; | |
398 | ||
399 | if (radio_type) { | |
57fbcce3 | 400 | sband = wiphy->bands[NL80211_BAND_5GHZ]; |
78dfca62 AP |
401 | if (WARN_ON_ONCE(!sband)) |
402 | return 0; | |
57fbcce3 | 403 | rate_mask = request->rates[NL80211_BAND_5GHZ]; |
78dfca62 | 404 | } else { |
57fbcce3 | 405 | sband = wiphy->bands[NL80211_BAND_2GHZ]; |
78dfca62 AP |
406 | if (WARN_ON_ONCE(!sband)) |
407 | return 0; | |
57fbcce3 | 408 | rate_mask = request->rates[NL80211_BAND_2GHZ]; |
78dfca62 AP |
409 | } |
410 | ||
411 | num_rates = 0; | |
412 | for (i = 0; i < sband->n_bitrates; i++) { | |
413 | if ((BIT(i) & rate_mask) == 0) | |
414 | continue; /* skip rate */ | |
415 | rates[num_rates++] = (u8)(sband->bitrates[i].bitrate / 5); | |
416 | } | |
417 | ||
418 | return num_rates; | |
419 | } | |
420 | ||
421 | /* This function gets the supported data rates. The function works in | |
422 | * both Ad-Hoc and infra mode by printing the band and returning the | |
423 | * data rates. | |
5e6e3a92 BZ |
424 | */ |
425 | u32 mwifiex_get_supported_rates(struct mwifiex_private *priv, u8 *rates) | |
426 | { | |
427 | u32 k = 0; | |
428 | struct mwifiex_adapter *adapter = priv->adapter; | |
a5f39056 | 429 | |
237b2ac8 AP |
430 | if (priv->bss_mode == NL80211_IFTYPE_STATION || |
431 | priv->bss_mode == NL80211_IFTYPE_P2P_CLIENT) { | |
5e6e3a92 BZ |
432 | switch (adapter->config_bands) { |
433 | case BAND_B: | |
acebe8c1 ZL |
434 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
435 | "supported_rates_b\n", | |
436 | adapter->config_bands); | |
5e6e3a92 BZ |
437 | k = mwifiex_copy_rates(rates, k, supported_rates_b, |
438 | sizeof(supported_rates_b)); | |
439 | break; | |
440 | case BAND_G: | |
441 | case BAND_G | BAND_GN: | |
acebe8c1 ZL |
442 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
443 | "supported_rates_g\n", | |
444 | adapter->config_bands); | |
5e6e3a92 BZ |
445 | k = mwifiex_copy_rates(rates, k, supported_rates_g, |
446 | sizeof(supported_rates_g)); | |
447 | break; | |
448 | case BAND_B | BAND_G: | |
449 | case BAND_A | BAND_B | BAND_G: | |
450 | case BAND_A | BAND_B: | |
451 | case BAND_A | BAND_B | BAND_G | BAND_GN | BAND_AN: | |
a5f39056 | 452 | case BAND_A | BAND_B | BAND_G | BAND_GN | BAND_AN | BAND_AAC: |
5e6e3a92 | 453 | case BAND_B | BAND_G | BAND_GN: |
acebe8c1 ZL |
454 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
455 | "supported_rates_bg\n", | |
456 | adapter->config_bands); | |
5e6e3a92 BZ |
457 | k = mwifiex_copy_rates(rates, k, supported_rates_bg, |
458 | sizeof(supported_rates_bg)); | |
459 | break; | |
460 | case BAND_A: | |
461 | case BAND_A | BAND_G: | |
acebe8c1 ZL |
462 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
463 | "supported_rates_a\n", | |
464 | adapter->config_bands); | |
5e6e3a92 BZ |
465 | k = mwifiex_copy_rates(rates, k, supported_rates_a, |
466 | sizeof(supported_rates_a)); | |
467 | break; | |
a5f39056 | 468 | case BAND_AN: |
5e6e3a92 | 469 | case BAND_A | BAND_AN: |
a5f39056 | 470 | case BAND_A | BAND_AN | BAND_AAC: |
5e6e3a92 | 471 | case BAND_A | BAND_G | BAND_AN | BAND_GN: |
a5f39056 | 472 | case BAND_A | BAND_G | BAND_AN | BAND_GN | BAND_AAC: |
acebe8c1 ZL |
473 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
474 | "supported_rates_a\n", | |
475 | adapter->config_bands); | |
5e6e3a92 BZ |
476 | k = mwifiex_copy_rates(rates, k, supported_rates_a, |
477 | sizeof(supported_rates_a)); | |
478 | break; | |
479 | case BAND_GN: | |
acebe8c1 ZL |
480 | mwifiex_dbg(adapter, INFO, "info: infra band=%d\t" |
481 | "supported_rates_n\n", | |
482 | adapter->config_bands); | |
5e6e3a92 BZ |
483 | k = mwifiex_copy_rates(rates, k, supported_rates_n, |
484 | sizeof(supported_rates_n)); | |
485 | break; | |
486 | } | |
487 | } else { | |
488 | /* Ad-hoc mode */ | |
489 | switch (adapter->adhoc_start_band) { | |
490 | case BAND_B: | |
acebe8c1 | 491 | mwifiex_dbg(adapter, INFO, "info: adhoc B\n"); |
5e6e3a92 BZ |
492 | k = mwifiex_copy_rates(rates, k, adhoc_rates_b, |
493 | sizeof(adhoc_rates_b)); | |
494 | break; | |
495 | case BAND_G: | |
496 | case BAND_G | BAND_GN: | |
acebe8c1 | 497 | mwifiex_dbg(adapter, INFO, "info: adhoc G only\n"); |
5e6e3a92 BZ |
498 | k = mwifiex_copy_rates(rates, k, adhoc_rates_g, |
499 | sizeof(adhoc_rates_g)); | |
500 | break; | |
501 | case BAND_B | BAND_G: | |
502 | case BAND_B | BAND_G | BAND_GN: | |
acebe8c1 | 503 | mwifiex_dbg(adapter, INFO, "info: adhoc BG\n"); |
5e6e3a92 BZ |
504 | k = mwifiex_copy_rates(rates, k, adhoc_rates_bg, |
505 | sizeof(adhoc_rates_bg)); | |
506 | break; | |
507 | case BAND_A: | |
508 | case BAND_A | BAND_AN: | |
acebe8c1 | 509 | mwifiex_dbg(adapter, INFO, "info: adhoc A\n"); |
5e6e3a92 BZ |
510 | k = mwifiex_copy_rates(rates, k, adhoc_rates_a, |
511 | sizeof(adhoc_rates_a)); | |
512 | break; | |
513 | } | |
514 | } | |
515 | ||
516 | return k; | |
517 | } | |
cbf6e055 XH |
518 | |
519 | u8 mwifiex_adjust_data_rate(struct mwifiex_private *priv, | |
520 | u8 rx_rate, u8 rate_info) | |
521 | { | |
522 | u8 rate_index = 0; | |
523 | ||
524 | /* HT40 */ | |
525 | if ((rate_info & BIT(0)) && (rate_info & BIT(1))) | |
526 | rate_index = MWIFIEX_RATE_INDEX_MCS0 + | |
527 | MWIFIEX_BW20_MCS_NUM + rx_rate; | |
528 | else if (rate_info & BIT(0)) /* HT20 */ | |
529 | rate_index = MWIFIEX_RATE_INDEX_MCS0 + rx_rate; | |
530 | else | |
531 | rate_index = (rx_rate > MWIFIEX_RATE_INDEX_OFDM0) ? | |
532 | rx_rate - 1 : rx_rate; | |
533 | ||
534 | return rate_index; | |
535 | } |