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 40static u8 adhoc_rates_b[B_SUPPORTED_RATES] = { 0x82, 0x84, 0x8b, 0x96, 0 }; 41 42static u8 adhoc_rates_g[G_SUPPORTED_RATES] = { 0x8c, 0x12, 0x98, 0x24, 43 0xb0, 0x48, 0x60, 0x6c, 0 }; 44 45static u8 adhoc_rates_bg[BG_SUPPORTED_RATES] = { 0x82, 0x84, 0x8b, 0x96, 46 0x0c, 0x12, 0x18, 0x24, 47 0x30, 0x48, 0x60, 0x6c, 0 }; 48 49static u8 adhoc_rates_a[A_SUPPORTED_RATES] = { 0x8c, 0x12, 0x98, 0x24, 50 0xb0, 0x48, 0x60, 0x6c, 0 }; 51static u8 supported_rates_a[A_SUPPORTED_RATES] = { 0x0c, 0x12, 0x18, 0x24, 52 0xb0, 0x48, 0x60, 0x6c, 0 }; 53static 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 60static u8 supported_rates_b[B_SUPPORTED_RATES] = { 0x02, 0x04, 0x0b, 0x16, 0 }; 61 62static u8 supported_rates_g[G_SUPPORTED_RATES] = { 0x0c, 0x12, 0x18, 0x24, 63 0x30, 0x48, 0x60, 0x6c, 0 }; 64 65static u8 supported_rates_bg[BG_SUPPORTED_RATES] = { 0x02, 0x04, 0x0b, 0x0c, 66 0x12, 0x16, 0x18, 0x24, 0x30, 0x48, 67 0x60, 0x6c, 0 }; 68 69u16 region_code_index[MWIFIEX_MAX_REGION_CODE] = { 0x10, 0x20, 0x30, 70 0x32, 0x40, 0x41, 0xff }; 71 72static u8 supported_rates_n[N_SUPPORTED_RATES] = { 0x02, 0x04, 0 }; 73 74/* 75 * This function maps an index in supported rates table into 76 * the corresponding data rate. 77 */ 78u32 mwifiex_index_to_data_rate(struct mwifiex_private *priv, u8 index, 79 u8 ht_info) 80{ 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; 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 */ 112 } else if (index < mcs_num_supp) { 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 */ 142u8 mwifiex_data_rate_to_index(u32 rate) 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 */ 160u32 mwifiex_get_active_data_rates(struct mwifiex_private *priv, u8 *rates) 161{ 162 if (!priv->media_connected) 163 return mwifiex_get_supported_rates(priv, rates); 164 else 165 return mwifiex_copy_rates(rates, 0, 166 priv->curr_bss_params.data_rates, 167 priv->curr_bss_params.num_of_rates); 168} 169 170/* 171 * This function locates the Channel-Frequency-Power triplet based upon 172 * band and channel/frequency parameters. 173 */ 174struct mwifiex_chan_freq_power * 175mwifiex_get_cfp(struct mwifiex_private *priv, u8 band, u16 channel, u32 freq) 176{ 177 struct mwifiex_chan_freq_power *cfp = NULL; 178 struct ieee80211_supported_band *sband; 179 struct ieee80211_channel *ch = NULL; 180 int i; 181 182 if (!channel && !freq) 183 return cfp; 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) { 191 dev_err(priv->adapter->dev, "%s: cannot find cfp by band %d\n", 192 __func__, band); 193 return cfp; 194 } 195 196 for (i = 0; i < sband->n_channels; i++) { 197 ch = &sband->channels[i]; 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; 210 } 211 } 212 if (i == sband->n_channels) { 213 dev_err(priv->adapter->dev, "%s: cannot find cfp by band %d" 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 } 225 226 return cfp; 227} 228 229/* 230 * This function checks if the data rate is set to auto. 231 */ 232u8 233mwifiex_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 */ 251int mwifiex_get_rate_index(u16 *rate_bitmap, int size) 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 */ 268u32 mwifiex_get_supported_rates(struct mwifiex_private *priv, u8 *rates) 269{ 270 u32 k = 0; 271 struct mwifiex_adapter *adapter = priv->adapter; 272 if (priv->bss_mode == NL80211_IFTYPE_STATION) { 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} 349