Prakash Dhavali | 7090c5f | 2015-11-02 17:55:19 -0800 | [diff] [blame^] | 1 | /* |
| 2 | * Copyright (c) 2011-2014 The Linux Foundation. All rights reserved. |
| 3 | * |
| 4 | * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| 5 | * |
| 6 | * |
| 7 | * Permission to use, copy, modify, and/or distribute this software for |
| 8 | * any purpose with or without fee is hereby granted, provided that the |
| 9 | * above copyright notice and this permission notice appear in all |
| 10 | * copies. |
| 11 | * |
| 12 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| 13 | * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| 14 | * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| 15 | * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| 16 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| 17 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 18 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 19 | * PERFORMANCE OF THIS SOFTWARE. |
| 20 | */ |
| 21 | |
| 22 | /* |
| 23 | * This file was originally distributed by Qualcomm Atheros, Inc. |
| 24 | * under proprietary terms before Copyright ownership was assigned |
| 25 | * to the Linux Foundation. |
| 26 | */ |
| 27 | |
| 28 | /* |
| 29 | * |
| 30 | * This file utils_parser.cc contains the code for parsing |
| 31 | * 802.11 messages. |
| 32 | * Author: Pierre Vandwalle |
| 33 | * Date: 03/18/02 |
| 34 | * History:- |
| 35 | * Date Modified by Modification Information |
| 36 | * -------------------------------------------------------------------- |
| 37 | * |
| 38 | */ |
| 39 | |
| 40 | #include "ani_global.h" |
| 41 | #include "utils_parser.h" |
| 42 | #include "lim_ser_des_utils.h" |
| 43 | |
| 44 | void convert_ssid(tpAniSirGlobal pMac, tSirMacSSid *pOld, tDot11fIESSID *pNew) |
| 45 | { |
| 46 | pOld->length = pNew->num_ssid; |
| 47 | cdf_mem_copy(pOld->ssId, pNew->ssid, pNew->num_ssid); |
| 48 | } |
| 49 | |
| 50 | void convert_supp_rates(tpAniSirGlobal pMac, |
| 51 | tSirMacRateSet *pOld, tDot11fIESuppRates *pNew) |
| 52 | { |
| 53 | pOld->numRates = pNew->num_rates; |
| 54 | cdf_mem_copy(pOld->rate, pNew->rates, pNew->num_rates); |
| 55 | } |
| 56 | |
| 57 | void convert_ext_supp_rates(tpAniSirGlobal pMac, |
| 58 | tSirMacRateSet *pOld, tDot11fIEExtSuppRates *pNew) |
| 59 | { |
| 60 | pOld->numRates = pNew->num_rates; |
| 61 | cdf_mem_copy(pOld->rate, pNew->rates, pNew->num_rates); |
| 62 | } |
| 63 | |
| 64 | void convert_qos_caps(tpAniSirGlobal pMac, |
| 65 | tSirMacQosCapabilityIE *pOld, tDot11fIEQOSCapsAp *pNew) |
| 66 | { |
| 67 | pOld->type = 46; |
| 68 | pOld->length = 1; |
| 69 | |
| 70 | pOld->qosInfo.count = pNew->count; |
| 71 | } |
| 72 | |
| 73 | void convert_qos_caps_station(tpAniSirGlobal pMac, |
| 74 | tSirMacQosCapabilityStaIE *pOld, |
| 75 | tDot11fIEQOSCapsStation *pNew) |
| 76 | { |
| 77 | pOld->type = 46; |
| 78 | pOld->length = 1; |
| 79 | |
| 80 | pOld->qosInfo.moreDataAck = pNew->more_data_ack; |
| 81 | pOld->qosInfo.maxSpLen = pNew->max_sp_length; |
| 82 | pOld->qosInfo.qack = pNew->qack; |
| 83 | pOld->qosInfo.acbe_uapsd = pNew->acbe_uapsd; |
| 84 | pOld->qosInfo.acbk_uapsd = pNew->acbk_uapsd; |
| 85 | pOld->qosInfo.acvi_uapsd = pNew->acvi_uapsd; |
| 86 | pOld->qosInfo.acvo_uapsd = pNew->acvo_uapsd; |
| 87 | } |
| 88 | |
| 89 | tSirRetStatus convert_wpa(tpAniSirGlobal pMac, |
| 90 | tSirMacWpaInfo *pOld, tDot11fIEWPA *pNew) |
| 91 | { |
| 92 | /* This is awful, I know, but the old code just rammed the IE into an */ |
| 93 | /* array... */ |
| 94 | uint8_t buffer[257]; |
| 95 | uint32_t status, written = 0, nbuffer = 257; |
| 96 | status = dot11f_pack_ie_wpa(pMac, pNew, buffer, nbuffer, &written); |
| 97 | if (DOT11F_FAILED(status)) { |
| 98 | dot11f_log(pMac, LOG2, FL("Failed to re-pack the WPA IE (0x%0x" |
| 99 | "8).\n"), status); |
| 100 | return eSIR_FAILURE; |
| 101 | } |
| 102 | |
| 103 | pOld->length = (uint8_t) written - 2; |
| 104 | cdf_mem_copy(pOld->info, buffer + 2, pOld->length); |
| 105 | |
| 106 | return eSIR_SUCCESS; |
| 107 | } |
| 108 | |
| 109 | tSirRetStatus convert_wpa_opaque(tpAniSirGlobal pMac, |
| 110 | tSirMacWpaInfo *pOld, tDot11fIEWPAOpaque *pNew) |
| 111 | { |
| 112 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 113 | /* an opaque array. Note that we need to explicitly add the OUI! */ |
| 114 | pOld->length = pNew->num_data + 4; |
| 115 | pOld->info[0] = 0x00; |
| 116 | pOld->info[1] = 0x50; |
| 117 | pOld->info[2] = 0xf2; |
| 118 | pOld->info[3] = 0x01; |
| 119 | cdf_mem_copy(pOld->info + 4, pNew->data, pNew->num_data); |
| 120 | |
| 121 | return eSIR_SUCCESS; |
| 122 | } |
| 123 | |
| 124 | #ifdef FEATURE_WLAN_WAPI |
| 125 | tSirRetStatus convert_wapi_opaque(tpAniSirGlobal pMac, |
| 126 | tSirMacWapiInfo *pOld, |
| 127 | tDot11fIEWAPIOpaque *pNew) |
| 128 | { |
| 129 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 130 | /* an opaque array. Note that we need to explicitly add the OUI! */ |
| 131 | pOld->length = pNew->num_data; |
| 132 | cdf_mem_copy(pOld->info, pNew->data, pNew->num_data); |
| 133 | |
| 134 | return eSIR_SUCCESS; |
| 135 | } |
| 136 | #endif |
| 137 | |
| 138 | tSirRetStatus convert_wsc_opaque(tpAniSirGlobal pMac, |
| 139 | tSirAddie *pOld, tDot11fIEWscIEOpaque *pNew) |
| 140 | { |
| 141 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 142 | /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */ |
| 143 | uint8_t curAddIELen = pOld->length; |
| 144 | |
| 145 | pOld->length = curAddIELen + pNew->num_data + 6; |
| 146 | pOld->addIEdata[curAddIELen++] = 0xdd; |
| 147 | pOld->addIEdata[curAddIELen++] = pNew->num_data + 4; |
| 148 | pOld->addIEdata[curAddIELen++] = 0x00; |
| 149 | pOld->addIEdata[curAddIELen++] = 0x50; |
| 150 | pOld->addIEdata[curAddIELen++] = 0xf2; |
| 151 | pOld->addIEdata[curAddIELen++] = 0x04; |
| 152 | cdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data); |
| 153 | |
| 154 | return eSIR_SUCCESS; |
| 155 | } |
| 156 | |
| 157 | tSirRetStatus convert_p2p_opaque(tpAniSirGlobal pMac, |
| 158 | tSirAddie *pOld, tDot11fIEP2PIEOpaque *pNew) |
| 159 | { |
| 160 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 161 | /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */ |
| 162 | uint8_t curAddIELen = pOld->length; |
| 163 | |
| 164 | pOld->length = curAddIELen + pNew->num_data + 6; |
| 165 | pOld->addIEdata[curAddIELen++] = 0xdd; |
| 166 | pOld->addIEdata[curAddIELen++] = pNew->num_data + 4; |
| 167 | pOld->addIEdata[curAddIELen++] = 0x50; |
| 168 | pOld->addIEdata[curAddIELen++] = 0x6f; |
| 169 | pOld->addIEdata[curAddIELen++] = 0x9A; |
| 170 | pOld->addIEdata[curAddIELen++] = 0x09; |
| 171 | cdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data); |
| 172 | |
| 173 | return eSIR_SUCCESS; |
| 174 | } |
| 175 | |
| 176 | #ifdef WLAN_FEATURE_WFD |
| 177 | tSirRetStatus convert_wfd_opaque(tpAniSirGlobal pMac, |
| 178 | tSirAddie *pOld, tDot11fIEWFDIEOpaque *pNew) |
| 179 | { |
| 180 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 181 | /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */ |
| 182 | uint8_t curAddIELen = pOld->length; |
| 183 | |
| 184 | pOld->length = curAddIELen + pNew->num_data + 6; |
| 185 | pOld->addIEdata[curAddIELen++] = 0xdd; |
| 186 | pOld->addIEdata[curAddIELen++] = pNew->num_data + 4; |
| 187 | pOld->addIEdata[curAddIELen++] = 0x50; |
| 188 | pOld->addIEdata[curAddIELen++] = 0x6f; |
| 189 | pOld->addIEdata[curAddIELen++] = 0x9A; |
| 190 | pOld->addIEdata[curAddIELen++] = 0x0a; |
| 191 | cdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data); |
| 192 | |
| 193 | return eSIR_SUCCESS; |
| 194 | } |
| 195 | #endif |
| 196 | |
| 197 | tSirRetStatus convert_rsn(tpAniSirGlobal pMac, |
| 198 | tSirMacRsnInfo *pOld, tDot11fIERSN *pNew) |
| 199 | { |
| 200 | uint8_t buffer[257]; |
| 201 | uint32_t status, written = 0, nbuffer = 257; |
| 202 | status = dot11f_pack_ie_rsn(pMac, pNew, buffer, nbuffer, &written); |
| 203 | if (DOT11F_FAILED(status)) { |
| 204 | dot11f_log(pMac, LOG2, FL("Failed to re-pack the RSN IE (0x%0x" |
| 205 | "8).\n"), status); |
| 206 | return eSIR_FAILURE; |
| 207 | } |
| 208 | |
| 209 | pOld->length = (uint8_t) written - 2; |
| 210 | cdf_mem_copy(pOld->info, buffer + 2, pOld->length); |
| 211 | |
| 212 | return eSIR_SUCCESS; |
| 213 | } |
| 214 | |
| 215 | tSirRetStatus convert_rsn_opaque(tpAniSirGlobal pMac, |
| 216 | tSirMacRsnInfo *pOld, tDot11fIERSNOpaque *pNew) |
| 217 | { |
| 218 | /* This is awful, I know, but the old code just rammed the IE into */ |
| 219 | /* an opaque array. */ |
| 220 | pOld->length = pNew->num_data; |
| 221 | cdf_mem_copy(pOld->info, pNew->data, pOld->length); |
| 222 | |
| 223 | return eSIR_SUCCESS; |
| 224 | } |
| 225 | |
| 226 | void convert_power_caps(tpAniSirGlobal pMac, |
| 227 | tSirMacPowerCapabilityIE *pOld, |
| 228 | tDot11fIEPowerCaps *pNew) |
| 229 | { |
| 230 | pOld->type = 33; |
| 231 | pOld->length = 2; |
| 232 | pOld->minTxPower = pNew->minTxPower; |
| 233 | pOld->maxTxPower = pNew->maxTxPower; |
| 234 | } |
| 235 | |
| 236 | void convert_supp_channels(tpAniSirGlobal pMac, |
| 237 | tSirMacSupportedChannelIE *pOld, |
| 238 | tDot11fIESuppChannels *pNew) |
| 239 | { |
| 240 | pOld->type = 36; |
| 241 | pOld->length = (pNew->num_bands * 2); |
| 242 | cdf_mem_copy((uint8_t *) pOld->supportedChannels, |
| 243 | (uint8_t *) pNew->bands, pOld->length); |
| 244 | } |
| 245 | |
| 246 | void convert_cf_params(tpAniSirGlobal pMac, |
| 247 | tSirMacCfParamSet *pOld, tDot11fIECFParams *pNew) |
| 248 | { |
| 249 | pOld->cfpCount = pNew->cfp_count; |
| 250 | pOld->cfpPeriod = pNew->cfp_period; |
| 251 | pOld->cfpMaxDuration = pNew->cfp_maxduration; |
| 252 | pOld->cfpDurRemaining = pNew->cfp_durremaining; |
| 253 | } |
| 254 | |
| 255 | void convert_fh_params(tpAniSirGlobal pMac, |
| 256 | tSirMacFHParamSet *pOld, tDot11fIEFHParamSet *pNew) |
| 257 | { |
| 258 | pOld->dwellTime = pNew->dwell_time; |
| 259 | pOld->hopSet = pNew->hop_set; |
| 260 | pOld->hopPattern = pNew->hop_pattern; |
| 261 | pOld->hopIndex = pNew->hop_index; |
| 262 | } |
| 263 | |
| 264 | void convert_tim(tpAniSirGlobal pMac, tSirMacTim *pOld, tDot11fIETIM *pNew) |
| 265 | { |
| 266 | pOld->dtimCount = pNew->dtim_count; |
| 267 | pOld->dtimPeriod = pNew->dtim_period; |
| 268 | pOld->bitmapControl = pNew->bmpctl; |
| 269 | pOld->bitmapLength = pNew->num_vbmp; |
| 270 | |
| 271 | cdf_mem_copy(pOld->bitmap, pNew->vbmp, pNew->num_vbmp); |
| 272 | } |
| 273 | |
| 274 | void convert_country(tpAniSirGlobal pMac, |
| 275 | tSirCountryInformation *pOld, tDot11fIECountry *pNew) |
| 276 | { |
| 277 | int i; |
| 278 | |
| 279 | cdf_mem_copy(pOld->countryString, pNew->country, COUNTRY_STRING_LENGTH); |
| 280 | |
| 281 | pOld->numIntervals = pNew->num_triplets; |
| 282 | |
| 283 | for (i = 0; i < pNew->num_triplets; ++i) { |
| 284 | pOld->channelTransmitPower[i].channelNumber = |
| 285 | pNew->triplets[i][0]; |
| 286 | pOld->channelTransmitPower[i].numChannel = pNew->triplets[i][1]; |
| 287 | pOld->channelTransmitPower[i].maxTransmitPower = |
| 288 | pNew->triplets[i][2]; |
| 289 | } |
| 290 | } |
| 291 | |
| 292 | void convert_wmm_params(tpAniSirGlobal pMac, |
| 293 | tSirMacEdcaParamSetIE *pOld, tDot11fIEWMMParams *pNew) |
| 294 | { |
| 295 | pOld->type = 221; |
| 296 | pOld->length = 24; |
| 297 | |
| 298 | cdf_mem_copy((uint8_t *) &pOld->qosInfo, (uint8_t *) &pNew->qosInfo, |
| 299 | 1); |
| 300 | |
| 301 | pOld->acbe.aci.aifsn = pNew->acbe_aifsn; |
| 302 | pOld->acbe.aci.acm = pNew->acbe_acm; |
| 303 | pOld->acbe.aci.aci = pNew->acbe_aci; |
| 304 | pOld->acbe.cw.min = pNew->acbe_acwmin; |
| 305 | pOld->acbe.cw.max = pNew->acbe_acwmax; |
| 306 | pOld->acbe.txoplimit = pNew->acbe_txoplimit; |
| 307 | |
| 308 | pOld->acbk.aci.aifsn = pNew->acbk_aifsn; |
| 309 | pOld->acbk.aci.acm = pNew->acbk_acm; |
| 310 | pOld->acbk.aci.aci = pNew->acbk_aci; |
| 311 | pOld->acbk.cw.min = pNew->acbk_acwmin; |
| 312 | pOld->acbk.cw.max = pNew->acbk_acwmax; |
| 313 | pOld->acbk.txoplimit = pNew->acbk_txoplimit; |
| 314 | |
| 315 | pOld->acvi.aci.aifsn = pNew->acvi_aifsn; |
| 316 | pOld->acvi.aci.acm = pNew->acvi_acm; |
| 317 | pOld->acvi.aci.aci = pNew->acvi_aci; |
| 318 | pOld->acvi.cw.min = pNew->acvi_acwmin; |
| 319 | pOld->acvi.cw.max = pNew->acvi_acwmax; |
| 320 | pOld->acvi.txoplimit = pNew->acvi_txoplimit; |
| 321 | |
| 322 | pOld->acvo.aci.aifsn = pNew->acvo_aifsn; |
| 323 | pOld->acvo.aci.acm = pNew->acvo_acm; |
| 324 | pOld->acvo.aci.aci = pNew->acvo_aci; |
| 325 | pOld->acvo.cw.min = pNew->acvo_acwmin; |
| 326 | pOld->acvo.cw.max = pNew->acvo_acwmax; |
| 327 | pOld->acvo.txoplimit = pNew->acvo_txoplimit; |
| 328 | } |
| 329 | |
| 330 | void convert_erp_info(tpAniSirGlobal pMac, |
| 331 | tSirMacErpInfo *pOld, tDot11fIEERPInfo *pNew) |
| 332 | { |
| 333 | pOld->nonErpPresent = pNew->non_erp_present; |
| 334 | pOld->useProtection = pNew->use_prot; |
| 335 | pOld->barkerPreambleMode = pNew->barker_preamble; |
| 336 | } |
| 337 | |
| 338 | void convert_edca_param(tpAniSirGlobal pMac, |
| 339 | tSirMacEdcaParamSetIE *pOld, |
| 340 | tDot11fIEEDCAParamSet *pNew) |
| 341 | { |
| 342 | pOld->type = 12; |
| 343 | pOld->length = 20; |
| 344 | |
| 345 | cdf_mem_copy((uint8_t *) &pOld->qosInfo, (uint8_t *) &pNew->qos, 1); |
| 346 | |
| 347 | pOld->acbe.aci.aifsn = pNew->acbe_aifsn; |
| 348 | pOld->acbe.aci.acm = pNew->acbe_acm; |
| 349 | pOld->acbe.aci.aci = pNew->acbe_aci; |
| 350 | pOld->acbe.cw.min = pNew->acbe_acwmin; |
| 351 | pOld->acbe.cw.max = pNew->acbe_acwmax; |
| 352 | pOld->acbe.txoplimit = pNew->acbe_txoplimit; |
| 353 | |
| 354 | pOld->acbk.aci.aifsn = pNew->acbk_aifsn; |
| 355 | pOld->acbk.aci.acm = pNew->acbk_acm; |
| 356 | pOld->acbk.aci.aci = pNew->acbk_aci; |
| 357 | pOld->acbk.cw.min = pNew->acbk_acwmin; |
| 358 | pOld->acbk.cw.max = pNew->acbk_acwmax; |
| 359 | pOld->acbk.txoplimit = pNew->acbk_txoplimit; |
| 360 | |
| 361 | pOld->acvi.aci.aifsn = pNew->acvi_aifsn; |
| 362 | pOld->acvi.aci.acm = pNew->acvi_acm; |
| 363 | pOld->acvi.aci.aci = pNew->acvi_aci; |
| 364 | pOld->acvi.cw.min = pNew->acvi_acwmin; |
| 365 | pOld->acvi.cw.max = pNew->acvi_acwmax; |
| 366 | pOld->acvi.txoplimit = pNew->acvi_txoplimit; |
| 367 | |
| 368 | pOld->acvo.aci.aifsn = pNew->acvo_aifsn; |
| 369 | pOld->acvo.aci.acm = pNew->acvo_acm; |
| 370 | pOld->acvo.aci.aci = pNew->acvo_aci; |
| 371 | pOld->acvo.cw.min = pNew->acvo_acwmin; |
| 372 | pOld->acvo.cw.max = pNew->acvo_acwmax; |
| 373 | pOld->acvo.txoplimit = pNew->acvo_txoplimit; |
| 374 | |
| 375 | } |
| 376 | |
| 377 | void convert_tspec(tpAniSirGlobal pMac, |
| 378 | tSirMacTspecIE *pOld, tDot11fIETSPEC *pNew) |
| 379 | { |
| 380 | pOld->tsinfo.traffic.trafficType = (uint16_t) pNew->traffic_type; |
| 381 | pOld->tsinfo.traffic.tsid = (uint16_t) pNew->tsid; |
| 382 | pOld->tsinfo.traffic.direction = (uint16_t) pNew->direction; |
| 383 | pOld->tsinfo.traffic.accessPolicy = (uint16_t) pNew->access_policy; |
| 384 | pOld->tsinfo.traffic.aggregation = (uint16_t) pNew->aggregation; |
| 385 | pOld->tsinfo.traffic.psb = (uint16_t) pNew->psb; |
| 386 | pOld->tsinfo.traffic.userPrio = (uint16_t) pNew->user_priority; |
| 387 | pOld->tsinfo.traffic.ackPolicy = (uint16_t) pNew->tsinfo_ack_pol; |
| 388 | |
| 389 | pOld->tsinfo.schedule.schedule = (uint8_t) pNew->schedule; |
| 390 | |
| 391 | pOld->nomMsduSz = pNew->size; |
| 392 | pOld->maxMsduSz = pNew->max_msdu_size; |
| 393 | pOld->minSvcInterval = pNew->min_service_int; |
| 394 | pOld->maxSvcInterval = pNew->max_service_int; |
| 395 | pOld->inactInterval = pNew->inactivity_int; |
| 396 | pOld->suspendInterval = pNew->suspension_int; |
| 397 | pOld->svcStartTime = pNew->service_start_time; |
| 398 | pOld->minDataRate = pNew->min_data_rate; |
| 399 | pOld->meanDataRate = pNew->mean_data_rate; |
| 400 | pOld->peakDataRate = pNew->peak_data_rate; |
| 401 | pOld->maxBurstSz = pNew->burst_size; |
| 402 | pOld->delayBound = pNew->delay_bound; |
| 403 | pOld->minPhyRate = pNew->min_phy_rate; |
| 404 | pOld->surplusBw = pNew->surplus_bw_allowance; |
| 405 | pOld->mediumTime = pNew->medium_time; |
| 406 | } |
| 407 | |
| 408 | tSirRetStatus convert_tclas(tpAniSirGlobal pMac, |
| 409 | tSirTclasInfo *pOld, tDot11fIETCLAS *pNew) |
| 410 | { |
| 411 | uint32_t length = 0; |
| 412 | |
| 413 | if (DOT11F_FAILED(dot11f_get_packed_ietclas(pMac, pNew, &length))) { |
| 414 | return eSIR_FAILURE; |
| 415 | } |
| 416 | |
| 417 | pOld->tclas.type = DOT11F_EID_TCLAS; |
| 418 | pOld->tclas.length = (uint8_t) length; |
| 419 | pOld->tclas.userPrio = pNew->user_priority; |
| 420 | pOld->tclas.classifierType = pNew->classifier_type; |
| 421 | pOld->tclas.classifierMask = pNew->classifier_mask; |
| 422 | |
| 423 | switch (pNew->classifier_type) { |
| 424 | case 0: |
| 425 | cdf_mem_copy(pOld->tclasParams.eth.srcAddr, |
| 426 | pNew->info.EthParams.source, 6); |
| 427 | cdf_mem_copy(pOld->tclasParams.eth.dstAddr, |
| 428 | pNew->info.EthParams.dest, 6); |
| 429 | pOld->tclasParams.eth.type = pNew->info.EthParams.type; |
| 430 | break; |
| 431 | case 1: |
| 432 | pOld->version = pNew->info.IpParams.version; |
| 433 | if (4 == pNew->info.IpParams.version) { |
| 434 | pOld->tclasParams.ipv4.version = 4; |
| 435 | cdf_mem_copy(pOld->tclasParams.ipv4.srcIpAddr, |
| 436 | pNew->info.IpParams.params.IpV4Params. |
| 437 | source, 4); |
| 438 | cdf_mem_copy(pOld->tclasParams.ipv4.dstIpAddr, |
| 439 | pNew->info.IpParams.params.IpV4Params.dest, |
| 440 | 4); |
| 441 | pOld->tclasParams.ipv4.srcPort = |
| 442 | pNew->info.IpParams.params.IpV4Params.src_port; |
| 443 | pOld->tclasParams.ipv4.dstPort = |
| 444 | pNew->info.IpParams.params.IpV4Params.dest_port; |
| 445 | pOld->tclasParams.ipv4.dscp = |
| 446 | pNew->info.IpParams.params.IpV4Params.DSCP; |
| 447 | pOld->tclasParams.ipv4.protocol = |
| 448 | pNew->info.IpParams.params.IpV4Params.proto; |
| 449 | pOld->tclasParams.ipv4.rsvd = |
| 450 | pNew->info.IpParams.params.IpV4Params.reserved; |
| 451 | } else if (6 == pNew->info.IpParams.version) { |
| 452 | pOld->tclasParams.ipv6.version = 6; |
| 453 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 454 | srcIpAddr, |
| 455 | (uint8_t *) pNew->info.IpParams.params. |
| 456 | IpV6Params.source, 16); |
| 457 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 458 | dstIpAddr, |
| 459 | (uint8_t *) pNew->info.IpParams.params. |
| 460 | IpV6Params.dest, 16); |
| 461 | pOld->tclasParams.ipv6.srcPort = |
| 462 | pNew->info.IpParams.params.IpV6Params.src_port; |
| 463 | pOld->tclasParams.ipv6.dstPort = |
| 464 | pNew->info.IpParams.params.IpV6Params.dest_port; |
| 465 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 466 | flowLabel, |
| 467 | (uint8_t *) pNew->info.IpParams.params. |
| 468 | IpV6Params.flow_label, 3); |
| 469 | } else { |
| 470 | return eSIR_FAILURE; |
| 471 | } |
| 472 | break; |
| 473 | case 2: |
| 474 | pOld->tclasParams.t8021dq.tag = |
| 475 | pNew->info.Params8021dq.tag_type; |
| 476 | break; |
| 477 | default: |
| 478 | return eSIR_FAILURE; |
| 479 | } |
| 480 | |
| 481 | return eSIR_SUCCESS; |
| 482 | } |
| 483 | |
| 484 | void convert_wmmtspec(tpAniSirGlobal pMac, |
| 485 | tSirMacTspecIE *pOld, tDot11fIEWMMTSPEC *pNew) |
| 486 | { |
| 487 | pOld->tsinfo.traffic.trafficType = (uint16_t) pNew->traffic_type; |
| 488 | pOld->tsinfo.traffic.tsid = (uint16_t) pNew->tsid; |
| 489 | pOld->tsinfo.traffic.direction = (uint16_t) pNew->direction; |
| 490 | pOld->tsinfo.traffic.accessPolicy = (uint16_t) pNew->access_policy; |
| 491 | pOld->tsinfo.traffic.aggregation = (uint16_t) pNew->aggregation; |
| 492 | pOld->tsinfo.traffic.psb = (uint16_t) pNew->psb; |
| 493 | pOld->tsinfo.traffic.userPrio = (uint16_t) pNew->user_priority; |
| 494 | pOld->tsinfo.traffic.ackPolicy = (uint16_t) pNew->tsinfo_ack_pol; |
| 495 | pOld->nomMsduSz = (pNew->fixed << 15) | pNew->size; |
| 496 | pOld->maxMsduSz = pNew->max_msdu_size; |
| 497 | pOld->minSvcInterval = pNew->min_service_int; |
| 498 | pOld->maxSvcInterval = pNew->max_service_int; |
| 499 | pOld->inactInterval = pNew->inactivity_int; |
| 500 | pOld->suspendInterval = pNew->suspension_int; |
| 501 | pOld->svcStartTime = pNew->service_start_time; |
| 502 | pOld->minDataRate = pNew->min_data_rate; |
| 503 | pOld->meanDataRate = pNew->mean_data_rate; |
| 504 | pOld->peakDataRate = pNew->peak_data_rate; |
| 505 | pOld->maxBurstSz = pNew->burst_size; |
| 506 | pOld->delayBound = pNew->delay_bound; |
| 507 | pOld->minPhyRate = pNew->min_phy_rate; |
| 508 | pOld->surplusBw = pNew->surplus_bw_allowance; |
| 509 | pOld->mediumTime = pNew->medium_time; |
| 510 | } |
| 511 | |
| 512 | tSirRetStatus convert_wmmtclas(tpAniSirGlobal pMac, |
| 513 | tSirTclasInfo *pOld, tDot11fIEWMMTCLAS *pNew) |
| 514 | { |
| 515 | uint32_t length = 0; |
| 516 | |
| 517 | if (DOT11F_FAILED(dot11f_get_packed_iewmmtclas(pMac, pNew, &length))) { |
| 518 | return eSIR_FAILURE; |
| 519 | } |
| 520 | |
| 521 | pOld->tclas.type = DOT11F_EID_WMMTCLAS; |
| 522 | pOld->tclas.length = (uint8_t) length; |
| 523 | pOld->tclas.userPrio = pNew->user_priority; |
| 524 | pOld->tclas.classifierType = pNew->classifier_type; |
| 525 | pOld->tclas.classifierMask = pNew->classifier_mask; |
| 526 | |
| 527 | switch (pNew->classifier_type) { |
| 528 | case 0: |
| 529 | cdf_mem_copy(pOld->tclasParams.eth.srcAddr, |
| 530 | pNew->info.EthParams.source, 6); |
| 531 | cdf_mem_copy(pOld->tclasParams.eth.dstAddr, |
| 532 | pNew->info.EthParams.dest, 6); |
| 533 | pOld->tclasParams.eth.type = pNew->info.EthParams.type; |
| 534 | break; |
| 535 | case 1: |
| 536 | pOld->version = pNew->info.IpParams.version; |
| 537 | if (4 == pNew->info.IpParams.version) { |
| 538 | pOld->tclasParams.ipv4.version = 4; |
| 539 | cdf_mem_copy(pOld->tclasParams.ipv4.srcIpAddr, |
| 540 | pNew->info.IpParams.params.IpV4Params. |
| 541 | source, 4); |
| 542 | cdf_mem_copy(pOld->tclasParams.ipv4.dstIpAddr, |
| 543 | pNew->info.IpParams.params.IpV4Params.dest, |
| 544 | 4); |
| 545 | pOld->tclasParams.ipv4.srcPort = |
| 546 | pNew->info.IpParams.params.IpV4Params.src_port; |
| 547 | pOld->tclasParams.ipv4.dstPort = |
| 548 | pNew->info.IpParams.params.IpV4Params.dest_port; |
| 549 | pOld->tclasParams.ipv4.dscp = |
| 550 | pNew->info.IpParams.params.IpV4Params.DSCP; |
| 551 | pOld->tclasParams.ipv4.protocol = |
| 552 | pNew->info.IpParams.params.IpV4Params.proto; |
| 553 | pOld->tclasParams.ipv4.rsvd = |
| 554 | pNew->info.IpParams.params.IpV4Params.reserved; |
| 555 | } else if (6 == pNew->info.IpParams.version) { |
| 556 | pOld->tclasParams.ipv6.version = 6; |
| 557 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 558 | srcIpAddr, |
| 559 | (uint8_t *) pNew->info.IpParams.params. |
| 560 | IpV6Params.source, 16); |
| 561 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 562 | dstIpAddr, |
| 563 | (uint8_t *) pNew->info.IpParams.params. |
| 564 | IpV6Params.dest, 16); |
| 565 | pOld->tclasParams.ipv6.srcPort = |
| 566 | pNew->info.IpParams.params.IpV6Params.src_port; |
| 567 | pOld->tclasParams.ipv6.dstPort = |
| 568 | pNew->info.IpParams.params.IpV6Params.dest_port; |
| 569 | cdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6. |
| 570 | flowLabel, |
| 571 | (uint8_t *) pNew->info.IpParams.params. |
| 572 | IpV6Params.flow_label, 3); |
| 573 | } else { |
| 574 | return eSIR_FAILURE; |
| 575 | } |
| 576 | break; |
| 577 | case 2: |
| 578 | pOld->tclasParams.t8021dq.tag = |
| 579 | pNew->info.Params8021dq.tag_type; |
| 580 | break; |
| 581 | default: |
| 582 | return eSIR_FAILURE; |
| 583 | } |
| 584 | |
| 585 | return eSIR_SUCCESS; |
| 586 | } |
| 587 | |
| 588 | void convert_ts_delay(tpAniSirGlobal pMac, |
| 589 | tSirMacTsDelayIE *pOld, tDot11fIETSDelay *pNew) |
| 590 | { |
| 591 | pOld->type = DOT11F_EID_TSDELAY; |
| 592 | pOld->length = 4U; |
| 593 | pOld->delay = pNew->delay; |
| 594 | } |
| 595 | |
| 596 | void convert_schedule(tpAniSirGlobal pMac, |
| 597 | tSirMacScheduleIE *pOld, tDot11fIESchedule *pNew) |
| 598 | { |
| 599 | pOld->type = DOT11F_EID_SCHEDULE; |
| 600 | pOld->length = DOT11F_IE_SCHEDULE_MIN_LEN; |
| 601 | |
| 602 | pOld->info.aggregation = pNew->aggregation; |
| 603 | pOld->info.tsid = pNew->tsid; |
| 604 | pOld->info.direction = pNew->direction; |
| 605 | |
| 606 | pOld->svcStartTime = pNew->service_start_time; |
| 607 | pOld->svcInterval = pNew->service_interval; |
| 608 | pOld->specInterval = pNew->spec_interval; |
| 609 | } |
| 610 | |
| 611 | void convert_wmm_schedule(tpAniSirGlobal pMac, |
| 612 | tSirMacScheduleIE *pOld, tDot11fIEWMMSchedule *pNew) |
| 613 | { |
| 614 | pOld->type = DOT11F_EID_WMMSCHEDULE; |
| 615 | pOld->length = DOT11F_IE_WMMSCHEDULE_MIN_LEN; |
| 616 | |
| 617 | pOld->info.aggregation = pNew->aggregation; |
| 618 | pOld->info.tsid = pNew->tsid; |
| 619 | pOld->info.direction = pNew->direction; |
| 620 | |
| 621 | pOld->svcStartTime = pNew->service_start_time; |
| 622 | pOld->svcInterval = pNew->service_interval; |
| 623 | pOld->specInterval = pNew->spec_interval; |
| 624 | } |
| 625 | |
| 626 | /** |
| 627 | @brief : This functions converts the given buffer till given size to Big endian format assuming the |
| 628 | bus is 32 bit. The size should be four byte aligned. |
| 629 | @param : ptr to be converted, size |
| 630 | @return : void |
| 631 | */ |
| 632 | |
| 633 | void convertto_big_endian(void *ptr, uint16_t size) |
| 634 | { |
| 635 | uint8_t *temp_ptr; |
| 636 | uint32_t *dest_ptr; |
| 637 | |
| 638 | dest_ptr = (uint32_t *) ptr; |
| 639 | while (size) { |
| 640 | temp_ptr = (uint8_t *) dest_ptr; |
| 641 | *dest_ptr = |
| 642 | (temp_ptr[0] << 24) | (temp_ptr[1] << 16) | (temp_ptr[2] << |
| 643 | 8) | |
| 644 | temp_ptr[3]; |
| 645 | dest_ptr++; |
| 646 | size -= 4; |
| 647 | } |
| 648 | } |
| 649 | |
| 650 | void create_scan_data_null_frame(tpAniSirGlobal pMac, tSirMacMgmtHdr *macMgmtHdr, |
| 651 | uint8_t pwrMgmt, tSirMacAddr bssid, |
| 652 | tSirMacAddr selfMacAddr) |
| 653 | { |
| 654 | |
| 655 | macMgmtHdr->fc.type = SIR_MAC_DATA_FRAME; |
| 656 | macMgmtHdr->fc.subType = SIR_MAC_DATA_NULL; |
| 657 | macMgmtHdr->fc.protVer = SIR_MAC_PROTOCOL_VERSION; |
| 658 | macMgmtHdr->fc.order = 0; |
| 659 | macMgmtHdr->fc.wep = 0; |
| 660 | macMgmtHdr->fc.moreData = 0; |
| 661 | macMgmtHdr->fc.powerMgmt = pwrMgmt; |
| 662 | macMgmtHdr->fc.retry = 0; |
| 663 | macMgmtHdr->fc.moreFrag = 0; |
| 664 | macMgmtHdr->fc.fromDS = 0; |
| 665 | macMgmtHdr->fc.toDS = 0; |
| 666 | macMgmtHdr->durationLo = |
| 667 | (uint8_t) (SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff); |
| 668 | macMgmtHdr->durationHi = |
| 669 | (uint8_t) ((SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff00) >> 8); |
| 670 | macMgmtHdr->seqControl.fragNum = 0; |
| 671 | macMgmtHdr->seqControl.seqNumLo = 0; |
| 672 | macMgmtHdr->seqControl.seqNumHi = 2; |
| 673 | cdf_mem_copy((void *)&macMgmtHdr->da, |
| 674 | (void *)bssid, sizeof(tSirMacAddr)); |
| 675 | cdf_mem_copy((void *)&macMgmtHdr->sa, |
| 676 | (void *)selfMacAddr, sizeof(tSirMacAddr)); |
| 677 | cdf_mem_copy((void *)&macMgmtHdr->bssId, |
| 678 | (void *)bssid, sizeof(tSirMacAddr)); |
| 679 | |
| 680 | return; |
| 681 | } |
| 682 | |
| 683 | void create_scan_cts_frame(tpAniSirGlobal pMac, tSirMacMgmtHdr *macMgmtHdr, |
| 684 | tSirMacAddr selfMac) |
| 685 | { |
| 686 | macMgmtHdr->fc.type = SIR_MAC_CTRL_FRAME; |
| 687 | macMgmtHdr->fc.subType = SIR_MAC_CTRL_CTS; |
| 688 | macMgmtHdr->fc.order = 0; |
| 689 | macMgmtHdr->fc.wep = 0; |
| 690 | macMgmtHdr->fc.moreData = 0; |
| 691 | macMgmtHdr->fc.powerMgmt = 0; |
| 692 | macMgmtHdr->fc.retry = 0; |
| 693 | macMgmtHdr->fc.moreFrag = 0; |
| 694 | macMgmtHdr->fc.fromDS = 0; |
| 695 | macMgmtHdr->fc.toDS = 0; |
| 696 | macMgmtHdr->durationLo = |
| 697 | (uint8_t) (SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff); |
| 698 | macMgmtHdr->durationHi = |
| 699 | (uint8_t) ((SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff00) >> 8); |
| 700 | cdf_mem_copy((void *)macMgmtHdr->da, (void *)selfMac, |
| 701 | sizeof(tSirMacAddr)); |
| 702 | |
| 703 | return; |
| 704 | } |
| 705 | |
| 706 | void convert_qos_mapset_frame(tpAniSirGlobal pMac, tSirQosMapSet *Qos, |
| 707 | tDot11fIEQosMapSet *dot11fIE) |
| 708 | { |
| 709 | uint8_t i, j = 0; |
| 710 | Qos->num_dscp_exceptions = (dot11fIE->num_dscp_exceptions - 16) / 2; |
| 711 | for (i = 0; i < Qos->num_dscp_exceptions; i++) { |
| 712 | Qos->dscp_exceptions[i][0] = dot11fIE->dscp_exceptions[j]; |
| 713 | j++; |
| 714 | Qos->dscp_exceptions[i][1] = dot11fIE->dscp_exceptions[j]; |
| 715 | j++; |
| 716 | } |
| 717 | for (i = 0; i < 8; i++) { |
| 718 | Qos->dscp_range[i][0] = dot11fIE->dscp_exceptions[j]; |
| 719 | j++; |
| 720 | Qos->dscp_range[i][1] = dot11fIE->dscp_exceptions[j]; |
| 721 | j++; |
| 722 | } |
| 723 | } |
| 724 | |
| 725 | /** |
| 726 | @brief : This functions creates a DATA_NULL/CTS2SELF frame in Big endian format |
| 727 | @param : Global MAC structure, pointer to return the created packet, role which is Station/AP |
| 728 | @return : void |
| 729 | */ |
| 730 | |
| 731 | void create_init_scan_raw_frame(tpAniSirGlobal pMac, tSirMacMgmtHdr *macMgmtHdr, |
| 732 | tBssSystemRole role) |
| 733 | { |
| 734 | #if 0 |
| 735 | tpStaStruct pSta = (tpStaStruct) pMac->hal.halMac.staTable; |
| 736 | |
| 737 | if (role == eSYSTEM_STA_ROLE) { |
| 738 | macMgmtHdr->fc.type = SIR_MAC_DATA_FRAME; |
| 739 | macMgmtHdr->fc.subType = SIR_MAC_DATA_NULL; |
| 740 | macMgmtHdr->fc.protVer = SIR_MAC_PROTOCOL_VERSION; |
| 741 | macMgmtHdr->fc.order = 0; |
| 742 | macMgmtHdr->fc.wep = 0; |
| 743 | macMgmtHdr->fc.moreData = 0; |
| 744 | macMgmtHdr->fc.powerMgmt = 1; /* Needed for station */ |
| 745 | macMgmtHdr->fc.retry = 0; |
| 746 | macMgmtHdr->fc.moreFrag = 0; |
| 747 | macMgmtHdr->fc.fromDS = 0; |
| 748 | macMgmtHdr->fc.toDS = 1; |
| 749 | macMgmtHdr->durationLo = |
| 750 | (uint8_t) (SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff); |
| 751 | macMgmtHdr->durationHi = |
| 752 | (uint8_t) ((SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff00) >> |
| 753 | 8); |
| 754 | macMgmtHdr->seqControl.fragNum = 0; |
| 755 | macMgmtHdr->seqControl.seqNumLo = 0; |
| 756 | macMgmtHdr->seqControl.seqNumHi = 2; |
| 757 | cdf_mem_copy((void *)&macMgmtHdr->da, (void *)pSta[0].bssId, 6); |
| 758 | cdf_mem_copy(&macMgmtHdr->sa, pSta[0].staAddr, 6); |
| 759 | cdf_mem_copy((void *)&macMgmtHdr->bssId, (void *)pSta[0].bssId, |
| 760 | 6); |
| 761 | } else if (role == eSYSTEM_AP_ROLE || role == eSYSTEM_STA_IN_IBSS_ROLE) { |
| 762 | macMgmtHdr->fc.type = SIR_MAC_CTRL_FRAME; |
| 763 | macMgmtHdr->fc.subType = SIR_MAC_CTRL_CTS; |
| 764 | macMgmtHdr->fc.order = 0; |
| 765 | macMgmtHdr->fc.wep = 0; |
| 766 | macMgmtHdr->fc.moreData = 0; |
| 767 | macMgmtHdr->fc.powerMgmt = 0; /* Needed for station */ |
| 768 | macMgmtHdr->fc.retry = 0; |
| 769 | macMgmtHdr->fc.moreFrag = 0; |
| 770 | macMgmtHdr->fc.fromDS = 0; |
| 771 | macMgmtHdr->fc.toDS = 0; |
| 772 | macMgmtHdr->durationLo = |
| 773 | (uint8_t) (SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff); |
| 774 | macMgmtHdr->durationHi = |
| 775 | (uint8_t) ((SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff00) >> |
| 776 | 8); |
| 777 | cdf_mem_copy((void *)macMgmtHdr->da, (void *)pSta[0].staAddr, |
| 778 | 6); |
| 779 | } |
| 780 | return; |
| 781 | #endif |
| 782 | } |
| 783 | |
| 784 | /** |
| 785 | @brief : This functions creates a DATA_NULL frame in Big endian format |
| 786 | @param : Global MAC structure, pointer to return the created packet, role which is Station/AP |
| 787 | @return : void |
| 788 | */ |
| 789 | |
| 790 | void create_finish_scan_raw_frame(tpAniSirGlobal pMac, tSirMacMgmtHdr *macMgmtHdr, |
| 791 | tBssSystemRole role) |
| 792 | { |
| 793 | #if 0 |
| 794 | tpStaStruct pSta = (tpStaStruct) pMac->hal.halMac.staTable; |
| 795 | |
| 796 | if (role == eSYSTEM_STA_ROLE) { |
| 797 | macMgmtHdr->fc.type = SIR_MAC_DATA_FRAME; |
| 798 | macMgmtHdr->fc.subType = SIR_MAC_DATA_NULL; |
| 799 | macMgmtHdr->fc.protVer = SIR_MAC_PROTOCOL_VERSION; |
| 800 | macMgmtHdr->fc.order = 0; |
| 801 | macMgmtHdr->fc.wep = 0; |
| 802 | macMgmtHdr->fc.moreData = 0; |
| 803 | macMgmtHdr->fc.powerMgmt = 0; /* Needed for station */ |
| 804 | macMgmtHdr->fc.retry = 0; |
| 805 | macMgmtHdr->fc.moreFrag = 0; |
| 806 | macMgmtHdr->fc.fromDS = 0; |
| 807 | macMgmtHdr->fc.toDS = 1; |
| 808 | macMgmtHdr->durationLo = |
| 809 | (uint8_t) (SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff); |
| 810 | macMgmtHdr->durationHi = |
| 811 | (uint8_t) ((SIR_MAC_MAX_DURATION_MICRO_SECONDS & 0xff00) >> |
| 812 | 8); |
| 813 | macMgmtHdr->seqControl.fragNum = 0; |
| 814 | macMgmtHdr->seqControl.seqNumLo = 0; |
| 815 | macMgmtHdr->seqControl.seqNumHi = 2; |
| 816 | cdf_mem_copy((void *)macMgmtHdr->da, (void *)pSta[0].bssId, 6); |
| 817 | cdf_mem_copy(macMgmtHdr->sa, pSta[0].staAddr, 6); |
| 818 | cdf_mem_copy((void *)macMgmtHdr->bssId, (void *)pSta[0].bssId, |
| 819 | 6); |
| 820 | |
| 821 | } |
| 822 | |
| 823 | return; |
| 824 | #endif |
| 825 | } |
| 826 | |
| 827 | /* utils_parser.c ends here. */ |