1 /*
2 * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for
5 * any purpose with or without fee is hereby granted, provided that the
6 * above copyright notice and this permission notice appear in all
7 * copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
16 * PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 /*
20 *
21 * This file utils_parser.cc contains the code for parsing
22 * 802.11 messages.
23 * Author: Pierre Vandwalle
24 * Date: 03/18/02
25 * History:-
26 * Date Modified by Modification Information
27 * --------------------------------------------------------------------
28 *
29 */
30
31 #include "ani_global.h"
32 #include "utils_parser.h"
33 #include "lim_ser_des_utils.h"
34
convert_ssid(struct mac_context * mac,tSirMacSSid * pOld,tDot11fIESSID * pNew)35 void convert_ssid(struct mac_context *mac, tSirMacSSid *pOld, tDot11fIESSID *pNew)
36 {
37 pOld->length = pNew->num_ssid;
38 qdf_mem_copy(pOld->ssId, pNew->ssid, pNew->num_ssid);
39 }
40
convert_supp_rates(struct mac_context * mac,tSirMacRateSet * pOld,tDot11fIESuppRates * pNew)41 void convert_supp_rates(struct mac_context *mac,
42 tSirMacRateSet *pOld, tDot11fIESuppRates *pNew)
43 {
44 pOld->numRates = pNew->num_rates;
45 qdf_mem_copy(pOld->rate, pNew->rates, pNew->num_rates);
46 }
47
convert_ext_supp_rates(struct mac_context * mac,tSirMacRateSet * pOld,tDot11fIEExtSuppRates * pNew)48 void convert_ext_supp_rates(struct mac_context *mac,
49 tSirMacRateSet *pOld, tDot11fIEExtSuppRates *pNew)
50 {
51 pOld->numRates = pNew->num_rates;
52 qdf_mem_copy(pOld->rate, pNew->rates, pNew->num_rates);
53 }
54
convert_qos_caps(struct mac_context * mac,tSirMacQosCapabilityIE * pOld,tDot11fIEQOSCapsAp * pNew)55 void convert_qos_caps(struct mac_context *mac,
56 tSirMacQosCapabilityIE *pOld, tDot11fIEQOSCapsAp *pNew)
57 {
58 pOld->type = 46;
59 pOld->length = 1;
60
61 pOld->qosInfo.count = pNew->count;
62 }
63
convert_qos_caps_station(struct mac_context * mac,tSirMacQosCapabilityStaIE * pOld,tDot11fIEQOSCapsStation * pNew)64 void convert_qos_caps_station(struct mac_context *mac,
65 tSirMacQosCapabilityStaIE *pOld,
66 tDot11fIEQOSCapsStation *pNew)
67 {
68 pOld->type = 46;
69 pOld->length = 1;
70
71 pOld->qosInfo.moreDataAck = pNew->more_data_ack;
72 pOld->qosInfo.maxSpLen = pNew->max_sp_length;
73 pOld->qosInfo.qack = pNew->qack;
74 pOld->qosInfo.acbe_uapsd = pNew->acbe_uapsd;
75 pOld->qosInfo.acbk_uapsd = pNew->acbk_uapsd;
76 pOld->qosInfo.acvi_uapsd = pNew->acvi_uapsd;
77 pOld->qosInfo.acvo_uapsd = pNew->acvo_uapsd;
78 }
79
convert_wpa(struct mac_context * mac,tSirMacWpaInfo * pOld,tDot11fIEWPA * pNew)80 QDF_STATUS convert_wpa(struct mac_context *mac,
81 tSirMacWpaInfo *pOld, tDot11fIEWPA *pNew)
82 {
83 /* This is awful, I know, but the old code just rammed the IE into an */
84 /* array... */
85 uint8_t buffer[257];
86 uint32_t status, written = 0, nbuffer = 257;
87
88 status = dot11f_pack_ie_wpa(mac, pNew, buffer, nbuffer, &written);
89 if (DOT11F_FAILED(status)) {
90 pe_err("Failed to re-pack the WPA IE (0x%0x8)", status);
91 return QDF_STATUS_E_FAILURE;
92 }
93
94 pOld->length = (uint8_t) written - 2;
95 qdf_mem_copy(pOld->info, buffer + 2, pOld->length);
96
97 return QDF_STATUS_SUCCESS;
98 }
99
convert_wpa_opaque(struct mac_context * mac,tSirMacWpaInfo * pOld,tDot11fIEWPAOpaque * pNew)100 QDF_STATUS convert_wpa_opaque(struct mac_context *mac,
101 tSirMacWpaInfo *pOld, tDot11fIEWPAOpaque *pNew)
102 {
103 /* This is awful, I know, but the old code just rammed the IE into */
104 /* an opaque array. Note that we need to explicitly add the OUI! */
105 pOld->length = pNew->num_data + 4;
106 pOld->info[0] = 0x00;
107 pOld->info[1] = 0x50;
108 pOld->info[2] = 0xf2;
109 pOld->info[3] = 0x01;
110 qdf_mem_copy(pOld->info + 4, pNew->data, pNew->num_data);
111
112 return QDF_STATUS_SUCCESS;
113 }
114
115 #ifdef FEATURE_WLAN_WAPI
convert_wapi_opaque(struct mac_context * mac,tSirMacWapiInfo * pOld,tDot11fIEWAPIOpaque * pNew)116 QDF_STATUS convert_wapi_opaque(struct mac_context *mac,
117 tSirMacWapiInfo *pOld,
118 tDot11fIEWAPIOpaque *pNew)
119 {
120 /* This is awful, I know, but the old code just rammed the IE into */
121 /* an opaque array. Note that we need to explicitly add the OUI! */
122 pOld->length = pNew->num_data;
123 qdf_mem_copy(pOld->info, pNew->data, pNew->num_data);
124
125 return QDF_STATUS_SUCCESS;
126 }
127 #endif
128
convert_wsc_opaque(struct mac_context * mac,tSirAddie * pOld,tDot11fIEWscIEOpaque * pNew)129 QDF_STATUS convert_wsc_opaque(struct mac_context *mac,
130 tSirAddie *pOld, tDot11fIEWscIEOpaque *pNew)
131 {
132 /* This is awful, I know, but the old code just rammed the IE into */
133 /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */
134 uint16_t curAddIELen = pOld->length;
135
136 pOld->length = curAddIELen + pNew->num_data + 6;
137 pOld->addIEdata[curAddIELen++] = 0xdd;
138 pOld->addIEdata[curAddIELen++] = pNew->num_data + 4;
139 pOld->addIEdata[curAddIELen++] = 0x00;
140 pOld->addIEdata[curAddIELen++] = 0x50;
141 pOld->addIEdata[curAddIELen++] = 0xf2;
142 pOld->addIEdata[curAddIELen++] = 0x04;
143 qdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data);
144
145 return QDF_STATUS_SUCCESS;
146 }
147
convert_p2p_opaque(struct mac_context * mac,tSirAddie * pOld,tDot11fIEP2PIEOpaque * pNew)148 QDF_STATUS convert_p2p_opaque(struct mac_context *mac,
149 tSirAddie *pOld, tDot11fIEP2PIEOpaque *pNew)
150 {
151 /* This is awful, I know, but the old code just rammed the IE into */
152 /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */
153 uint16_t curAddIELen = pOld->length;
154
155 pOld->length = curAddIELen + pNew->num_data + 6;
156 pOld->addIEdata[curAddIELen++] = 0xdd;
157 pOld->addIEdata[curAddIELen++] = pNew->num_data + 4;
158 pOld->addIEdata[curAddIELen++] = 0x50;
159 pOld->addIEdata[curAddIELen++] = 0x6f;
160 pOld->addIEdata[curAddIELen++] = 0x9A;
161 pOld->addIEdata[curAddIELen++] = 0x09;
162 qdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data);
163
164 return QDF_STATUS_SUCCESS;
165 }
166
167 #ifdef WLAN_FEATURE_WFD
convert_wfd_opaque(struct mac_context * mac,tSirAddie * pOld,tDot11fIEWFDIEOpaque * pNew)168 QDF_STATUS convert_wfd_opaque(struct mac_context *mac,
169 tSirAddie *pOld, tDot11fIEWFDIEOpaque *pNew)
170 {
171 /* This is awful, I know, but the old code just rammed the IE into */
172 /* an opaque array. Note that we need to explicitly add the vendorIE and OUI ! */
173 uint16_t curAddIELen = pOld->length;
174
175 pOld->length = curAddIELen + pNew->num_data + 6;
176 pOld->addIEdata[curAddIELen++] = 0xdd;
177 pOld->addIEdata[curAddIELen++] = pNew->num_data + 4;
178 pOld->addIEdata[curAddIELen++] = 0x50;
179 pOld->addIEdata[curAddIELen++] = 0x6f;
180 pOld->addIEdata[curAddIELen++] = 0x9A;
181 pOld->addIEdata[curAddIELen++] = 0x0a;
182 qdf_mem_copy(pOld->addIEdata + curAddIELen, pNew->data, pNew->num_data);
183
184 return QDF_STATUS_SUCCESS;
185 }
186 #endif
187
convert_rsn(struct mac_context * mac,tSirMacRsnInfo * pOld,tDot11fIERSN * pNew)188 QDF_STATUS convert_rsn(struct mac_context *mac,
189 tSirMacRsnInfo *pOld, tDot11fIERSN *pNew)
190 {
191 uint8_t buffer[257];
192 uint32_t status, written = 0, nbuffer = 257;
193
194 status = dot11f_pack_ie_rsn(mac, pNew, buffer, nbuffer, &written);
195 if (DOT11F_FAILED(status)) {
196 pe_err("Failed to re-pack the RSN IE (0x%0x8)", status);
197 return QDF_STATUS_E_FAILURE;
198 }
199
200 pOld->length = (uint8_t) written - 2;
201 qdf_mem_copy(pOld->info, buffer + 2, pOld->length);
202
203 return QDF_STATUS_SUCCESS;
204 }
205
convert_rsn_opaque(struct mac_context * mac,tSirMacRsnInfo * pOld,tDot11fIERSNOpaque * pNew)206 QDF_STATUS convert_rsn_opaque(struct mac_context *mac,
207 tSirMacRsnInfo *pOld, tDot11fIERSNOpaque *pNew)
208 {
209 /* This is awful, I know, but the old code just rammed the IE into */
210 /* an opaque array. */
211 pOld->length = pNew->num_data;
212 qdf_mem_copy(pOld->info, pNew->data, pOld->length);
213
214 return QDF_STATUS_SUCCESS;
215 }
216
convert_power_caps(struct mac_context * mac,tSirMacPowerCapabilityIE * pOld,tDot11fIEPowerCaps * pNew)217 void convert_power_caps(struct mac_context *mac,
218 tSirMacPowerCapabilityIE *pOld,
219 tDot11fIEPowerCaps *pNew)
220 {
221 pOld->type = 33;
222 pOld->length = 2;
223 pOld->minTxPower = pNew->minTxPower;
224 pOld->maxTxPower = pNew->maxTxPower;
225 }
226
convert_supp_channels(struct mac_context * mac,tSirMacSupportedChannelIE * pOld,tDot11fIESuppChannels * pNew)227 void convert_supp_channels(struct mac_context *mac,
228 tSirMacSupportedChannelIE *pOld,
229 tDot11fIESuppChannels *pNew)
230 {
231 pOld->type = 36;
232 pOld->length = (pNew->num_bands * 2);
233 qdf_mem_copy((uint8_t *) pOld->supportedChannels,
234 (uint8_t *) pNew->bands, pOld->length);
235 }
236
convert_cf_params(struct mac_context * mac,tSirMacCfParamSet * pOld,tDot11fIECFParams * pNew)237 void convert_cf_params(struct mac_context *mac,
238 tSirMacCfParamSet *pOld, tDot11fIECFParams *pNew)
239 {
240 pOld->cfpCount = pNew->cfp_count;
241 pOld->cfpPeriod = pNew->cfp_period;
242 pOld->cfpMaxDuration = pNew->cfp_maxduration;
243 pOld->cfpDurRemaining = pNew->cfp_durremaining;
244 }
245
convert_fh_params(struct mac_context * mac,tSirMacFHParamSet * pOld,tDot11fIEFHParamSet * pNew)246 void convert_fh_params(struct mac_context *mac,
247 tSirMacFHParamSet *pOld, tDot11fIEFHParamSet *pNew)
248 {
249 pOld->dwellTime = pNew->dwell_time;
250 pOld->hopSet = pNew->hop_set;
251 pOld->hopPattern = pNew->hop_pattern;
252 pOld->hopIndex = pNew->hop_index;
253 }
254
convert_tim(struct mac_context * mac,tSirMacTim * pOld,tDot11fIETIM * pNew)255 void convert_tim(struct mac_context *mac, tSirMacTim *pOld, tDot11fIETIM *pNew)
256 {
257 pOld->dtimCount = pNew->dtim_count;
258 pOld->dtimPeriod = pNew->dtim_period;
259 pOld->bitmapControl = pNew->bmpctl;
260 pOld->bitmapLength = pNew->num_vbmp;
261
262 qdf_mem_copy(pOld->bitmap, pNew->vbmp, pNew->num_vbmp);
263 }
264
convert_country(struct mac_context * mac,tSirCountryInformation * pOld,tDot11fIECountry * pNew)265 void convert_country(struct mac_context *mac,
266 tSirCountryInformation *pOld, tDot11fIECountry *pNew)
267 {
268 uint8_t i = 0;
269
270 qdf_mem_copy(pOld->countryString, pNew->country, COUNTRY_STRING_LENGTH);
271
272 pOld->numIntervals = pNew->num_more_triplets;
273
274 pOld->channelTransmitPower[i].channelNumber = pNew->first_triplet[0];
275 pOld->channelTransmitPower[i].numChannel = pNew->first_triplet[1];
276 pOld->channelTransmitPower[i].maxTransmitPower = pNew->first_triplet[2];
277
278 for (i = 0; i < pNew->num_more_triplets; i++) {
279 pOld->channelTransmitPower[i+1].channelNumber =
280 pNew->more_triplets[i][0];
281 pOld->channelTransmitPower[i+1].numChannel =
282 pNew->more_triplets[i][1];
283 pOld->channelTransmitPower[i+1].maxTransmitPower =
284 pNew->more_triplets[i][2];
285 }
286 }
287
convert_wmm_params(struct mac_context * mac,tSirMacEdcaParamSetIE * pOld,tDot11fIEWMMParams * pNew)288 void convert_wmm_params(struct mac_context *mac,
289 tSirMacEdcaParamSetIE *pOld, tDot11fIEWMMParams *pNew)
290 {
291 pOld->type = 221;
292 pOld->length = 24;
293
294 qdf_mem_copy((uint8_t *) &pOld->qosInfo, (uint8_t *) &pNew->qosInfo,
295 1);
296
297 pOld->acbe.aci.aifsn = pNew->acbe_aifsn;
298 pOld->acbe.aci.acm = pNew->acbe_acm;
299 pOld->acbe.aci.aci = pNew->acbe_aci;
300 pOld->acbe.cw.min = pNew->acbe_acwmin;
301 pOld->acbe.cw.max = pNew->acbe_acwmax;
302 pOld->acbe.txoplimit = pNew->acbe_txoplimit;
303
304 pOld->acbk.aci.aifsn = pNew->acbk_aifsn;
305 pOld->acbk.aci.acm = pNew->acbk_acm;
306 pOld->acbk.aci.aci = pNew->acbk_aci;
307 pOld->acbk.cw.min = pNew->acbk_acwmin;
308 pOld->acbk.cw.max = pNew->acbk_acwmax;
309 pOld->acbk.txoplimit = pNew->acbk_txoplimit;
310
311 pOld->acvi.aci.aifsn = pNew->acvi_aifsn;
312 pOld->acvi.aci.acm = pNew->acvi_acm;
313 pOld->acvi.aci.aci = pNew->acvi_aci;
314 pOld->acvi.cw.min = pNew->acvi_acwmin;
315 pOld->acvi.cw.max = pNew->acvi_acwmax;
316 pOld->acvi.txoplimit = pNew->acvi_txoplimit;
317
318 pOld->acvo.aci.aifsn = pNew->acvo_aifsn;
319 pOld->acvo.aci.acm = pNew->acvo_acm;
320 pOld->acvo.aci.aci = pNew->acvo_aci;
321 pOld->acvo.cw.min = pNew->acvo_acwmin;
322 pOld->acvo.cw.max = pNew->acvo_acwmax;
323 pOld->acvo.txoplimit = pNew->acvo_txoplimit;
324 }
325
convert_erp_info(struct mac_context * mac,tSirMacErpInfo * pOld,tDot11fIEERPInfo * pNew)326 void convert_erp_info(struct mac_context *mac,
327 tSirMacErpInfo *pOld, tDot11fIEERPInfo *pNew)
328 {
329 pOld->nonErpPresent = pNew->non_erp_present;
330 pOld->useProtection = pNew->use_prot;
331 pOld->barkerPreambleMode = pNew->barker_preamble;
332 }
333
convert_edca_param(struct mac_context * mac,tSirMacEdcaParamSetIE * pOld,tDot11fIEEDCAParamSet * pNew)334 void convert_edca_param(struct mac_context *mac,
335 tSirMacEdcaParamSetIE *pOld,
336 tDot11fIEEDCAParamSet *pNew)
337 {
338 pOld->type = 12;
339 pOld->length = 20;
340
341 qdf_mem_copy((uint8_t *) &pOld->qosInfo, (uint8_t *) &pNew->qos, 1);
342
343 pOld->acbe.aci.aifsn = pNew->acbe_aifsn;
344 pOld->acbe.aci.acm = pNew->acbe_acm;
345 pOld->acbe.aci.aci = pNew->acbe_aci;
346 pOld->acbe.cw.min = pNew->acbe_acwmin;
347 pOld->acbe.cw.max = pNew->acbe_acwmax;
348 pOld->acbe.txoplimit = pNew->acbe_txoplimit;
349
350 pOld->acbk.aci.aifsn = pNew->acbk_aifsn;
351 pOld->acbk.aci.acm = pNew->acbk_acm;
352 pOld->acbk.aci.aci = pNew->acbk_aci;
353 pOld->acbk.cw.min = pNew->acbk_acwmin;
354 pOld->acbk.cw.max = pNew->acbk_acwmax;
355 pOld->acbk.txoplimit = pNew->acbk_txoplimit;
356
357 pOld->acvi.aci.aifsn = pNew->acvi_aifsn;
358 pOld->acvi.aci.acm = pNew->acvi_acm;
359 pOld->acvi.aci.aci = pNew->acvi_aci;
360 pOld->acvi.cw.min = pNew->acvi_acwmin;
361 pOld->acvi.cw.max = pNew->acvi_acwmax;
362 pOld->acvi.txoplimit = pNew->acvi_txoplimit;
363
364 pOld->acvo.aci.aifsn = pNew->acvo_aifsn;
365 pOld->acvo.aci.acm = pNew->acvo_acm;
366 pOld->acvo.aci.aci = pNew->acvo_aci;
367 pOld->acvo.cw.min = pNew->acvo_acwmin;
368 pOld->acvo.cw.max = pNew->acvo_acwmax;
369 pOld->acvo.txoplimit = pNew->acvo_txoplimit;
370
371 }
372
convert_mu_edca_param(struct mac_context * mac_ctx,tSirMacEdcaParamSetIE * mu_edca,tDot11fIEmu_edca_param_set * ie)373 void convert_mu_edca_param(struct mac_context *mac_ctx,
374 tSirMacEdcaParamSetIE *mu_edca,
375 tDot11fIEmu_edca_param_set *ie)
376 {
377 qdf_mem_copy((uint8_t *) &mu_edca->qosInfo, (uint8_t *) &ie->qos, 1);
378
379 mu_edca->acbe.aci.aifsn = ie->acbe_aifsn;
380 mu_edca->acbe.aci.acm = ie->acbe_acm;
381 mu_edca->acbe.aci.aci = ie->acbe_aci;
382 mu_edca->acbe.cw.min = ie->acbe_acwmin;
383 mu_edca->acbe.cw.max = ie->acbe_acwmax;
384 mu_edca->acbe.mu_edca_timer = ie->acbe_muedca_timer;
385
386 mu_edca->acbk.aci.aifsn = ie->acbk_aifsn;
387 mu_edca->acbk.aci.acm = ie->acbk_acm;
388 mu_edca->acbk.aci.aci = ie->acbk_aci;
389 mu_edca->acbk.cw.min = ie->acbk_acwmin;
390 mu_edca->acbk.cw.max = ie->acbk_acwmax;
391 mu_edca->acbk.mu_edca_timer = ie->acbk_muedca_timer;
392
393 mu_edca->acvi.aci.aifsn = ie->acvi_aifsn;
394 mu_edca->acvi.aci.acm = ie->acvi_acm;
395 mu_edca->acvi.aci.aci = ie->acvi_aci;
396 mu_edca->acvi.cw.min = ie->acvi_acwmin;
397 mu_edca->acvi.cw.max = ie->acvi_acwmax;
398 mu_edca->acvi.mu_edca_timer = ie->acvi_muedca_timer;
399
400 mu_edca->acvo.aci.aifsn = ie->acvo_aifsn;
401 mu_edca->acvo.aci.acm = ie->acvo_acm;
402 mu_edca->acvo.aci.aci = ie->acvo_aci;
403 mu_edca->acvo.cw.min = ie->acvo_acwmin;
404 mu_edca->acvo.cw.max = ie->acvo_acwmax;
405 mu_edca->acvo.mu_edca_timer = ie->acvo_muedca_timer;
406
407 }
408
convert_tspec(struct mac_context * mac,struct mac_tspec_ie * pOld,tDot11fIETSPEC * pNew)409 void convert_tspec(struct mac_context *mac,
410 struct mac_tspec_ie *pOld, tDot11fIETSPEC *pNew)
411 {
412 pOld->tsinfo.traffic.trafficType = (uint16_t) pNew->traffic_type;
413 pOld->tsinfo.traffic.tsid = (uint16_t) pNew->tsid;
414 pOld->tsinfo.traffic.direction = (uint16_t) pNew->direction;
415 pOld->tsinfo.traffic.accessPolicy = (uint16_t) pNew->access_policy;
416 pOld->tsinfo.traffic.aggregation = (uint16_t) pNew->aggregation;
417 pOld->tsinfo.traffic.psb = (uint16_t) pNew->psb;
418 pOld->tsinfo.traffic.userPrio = (uint16_t) pNew->user_priority;
419 pOld->tsinfo.traffic.ackPolicy = (uint16_t) pNew->tsinfo_ack_pol;
420
421 pOld->tsinfo.schedule.schedule = (uint8_t) pNew->schedule;
422
423 pOld->nomMsduSz = pNew->size;
424 pOld->maxMsduSz = pNew->max_msdu_size;
425 pOld->minSvcInterval = pNew->min_service_int;
426 pOld->maxSvcInterval = pNew->max_service_int;
427 pOld->inactInterval = pNew->inactivity_int;
428 pOld->suspendInterval = pNew->suspension_int;
429 pOld->svcStartTime = pNew->service_start_time;
430 pOld->minDataRate = pNew->min_data_rate;
431 pOld->meanDataRate = pNew->mean_data_rate;
432 pOld->peakDataRate = pNew->peak_data_rate;
433 pOld->maxBurstSz = pNew->burst_size;
434 pOld->delayBound = pNew->delay_bound;
435 pOld->minPhyRate = pNew->min_phy_rate;
436 pOld->surplusBw = pNew->surplus_bw_allowance;
437 pOld->mediumTime = pNew->medium_time;
438 }
439
convert_tclas(struct mac_context * mac,tSirTclasInfo * pOld,tDot11fIETCLAS * pNew)440 QDF_STATUS convert_tclas(struct mac_context *mac,
441 tSirTclasInfo *pOld, tDot11fIETCLAS *pNew)
442 {
443 uint32_t length = 0;
444
445 if (DOT11F_FAILED(dot11f_get_packed_ietclas(mac, pNew, &length))) {
446 return QDF_STATUS_E_FAILURE;
447 }
448
449 pOld->tclas.type = DOT11F_EID_TCLAS;
450 pOld->tclas.length = (uint8_t) length;
451 pOld->tclas.userPrio = pNew->user_priority;
452 pOld->tclas.classifierType = pNew->classifier_type;
453 pOld->tclas.classifierMask = pNew->classifier_mask;
454
455 switch (pNew->classifier_type) {
456 case 0:
457 qdf_mem_copy(pOld->tclasParams.eth.srcAddr,
458 pNew->info.EthParams.source, 6);
459 qdf_mem_copy(pOld->tclasParams.eth.dstAddr,
460 pNew->info.EthParams.dest, 6);
461 pOld->tclasParams.eth.type = pNew->info.EthParams.type;
462 break;
463 case 1:
464 pOld->version = pNew->info.IpParams.version;
465 if (4 == pNew->info.IpParams.version) {
466 pOld->tclasParams.ipv4.version = 4;
467 qdf_mem_copy(pOld->tclasParams.ipv4.srcIpAddr,
468 pNew->info.IpParams.params.IpV4Params.
469 source, 4);
470 qdf_mem_copy(pOld->tclasParams.ipv4.dstIpAddr,
471 pNew->info.IpParams.params.IpV4Params.dest,
472 4);
473 pOld->tclasParams.ipv4.srcPort =
474 pNew->info.IpParams.params.IpV4Params.src_port;
475 pOld->tclasParams.ipv4.dstPort =
476 pNew->info.IpParams.params.IpV4Params.dest_port;
477 pOld->tclasParams.ipv4.dscp =
478 pNew->info.IpParams.params.IpV4Params.DSCP;
479 pOld->tclasParams.ipv4.protocol =
480 pNew->info.IpParams.params.IpV4Params.proto;
481 pOld->tclasParams.ipv4.rsvd =
482 pNew->info.IpParams.params.IpV4Params.reserved;
483 } else if (6 == pNew->info.IpParams.version) {
484 pOld->tclasParams.ipv6.version = 6;
485 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
486 srcIpAddr,
487 (uint8_t *) pNew->info.IpParams.params.
488 IpV6Params.source, 16);
489 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
490 dstIpAddr,
491 (uint8_t *) pNew->info.IpParams.params.
492 IpV6Params.dest, 16);
493 pOld->tclasParams.ipv6.srcPort =
494 pNew->info.IpParams.params.IpV6Params.src_port;
495 pOld->tclasParams.ipv6.dstPort =
496 pNew->info.IpParams.params.IpV6Params.dest_port;
497 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
498 flowLabel,
499 (uint8_t *) pNew->info.IpParams.params.
500 IpV6Params.flow_label, 3);
501 } else {
502 return QDF_STATUS_E_FAILURE;
503 }
504 break;
505 case 2:
506 pOld->tclasParams.t8021dq.tag =
507 pNew->info.Params8021dq.tag_type;
508 break;
509 default:
510 return QDF_STATUS_E_FAILURE;
511 }
512
513 return QDF_STATUS_SUCCESS;
514 }
515
convert_wmmtspec(struct mac_context * mac,struct mac_tspec_ie * pOld,tDot11fIEWMMTSPEC * pNew)516 void convert_wmmtspec(struct mac_context *mac,
517 struct mac_tspec_ie *pOld, tDot11fIEWMMTSPEC *pNew)
518 {
519 pOld->tsinfo.traffic.trafficType = (uint16_t) pNew->traffic_type;
520 pOld->tsinfo.traffic.tsid = (uint16_t) pNew->tsid;
521 pOld->tsinfo.traffic.direction = (uint16_t) pNew->direction;
522 pOld->tsinfo.traffic.accessPolicy = (uint16_t) pNew->access_policy;
523 pOld->tsinfo.traffic.aggregation = (uint16_t) pNew->aggregation;
524 pOld->tsinfo.traffic.psb = (uint16_t) pNew->psb;
525 pOld->tsinfo.traffic.userPrio = (uint16_t) pNew->user_priority;
526 pOld->tsinfo.traffic.ackPolicy = (uint16_t) pNew->tsinfo_ack_pol;
527 pOld->nomMsduSz = (pNew->fixed << 15) | pNew->size;
528 pOld->maxMsduSz = pNew->max_msdu_size;
529 pOld->minSvcInterval = pNew->min_service_int;
530 pOld->maxSvcInterval = pNew->max_service_int;
531 pOld->inactInterval = pNew->inactivity_int;
532 pOld->suspendInterval = pNew->suspension_int;
533 pOld->svcStartTime = pNew->service_start_time;
534 pOld->minDataRate = pNew->min_data_rate;
535 pOld->meanDataRate = pNew->mean_data_rate;
536 pOld->peakDataRate = pNew->peak_data_rate;
537 pOld->maxBurstSz = pNew->burst_size;
538 pOld->delayBound = pNew->delay_bound;
539 pOld->minPhyRate = pNew->min_phy_rate;
540 pOld->surplusBw = pNew->surplus_bw_allowance;
541 pOld->mediumTime = pNew->medium_time;
542 }
543
convert_wmmtclas(struct mac_context * mac,tSirTclasInfo * pOld,tDot11fIEWMMTCLAS * pNew)544 QDF_STATUS convert_wmmtclas(struct mac_context *mac,
545 tSirTclasInfo *pOld, tDot11fIEWMMTCLAS *pNew)
546 {
547 uint32_t length = 0;
548
549 if (DOT11F_FAILED(dot11f_get_packed_iewmmtclas(mac, pNew, &length))) {
550 return QDF_STATUS_E_FAILURE;
551 }
552
553 pOld->tclas.type = DOT11F_EID_WMMTCLAS;
554 pOld->tclas.length = (uint8_t) length;
555 pOld->tclas.userPrio = pNew->user_priority;
556 pOld->tclas.classifierType = pNew->classifier_type;
557 pOld->tclas.classifierMask = pNew->classifier_mask;
558
559 switch (pNew->classifier_type) {
560 case 0:
561 qdf_mem_copy(pOld->tclasParams.eth.srcAddr,
562 pNew->info.EthParams.source, 6);
563 qdf_mem_copy(pOld->tclasParams.eth.dstAddr,
564 pNew->info.EthParams.dest, 6);
565 pOld->tclasParams.eth.type = pNew->info.EthParams.type;
566 break;
567 case 1:
568 pOld->version = pNew->info.IpParams.version;
569 if (4 == pNew->info.IpParams.version) {
570 pOld->tclasParams.ipv4.version = 4;
571 qdf_mem_copy(pOld->tclasParams.ipv4.srcIpAddr,
572 pNew->info.IpParams.params.IpV4Params.
573 source, 4);
574 qdf_mem_copy(pOld->tclasParams.ipv4.dstIpAddr,
575 pNew->info.IpParams.params.IpV4Params.dest,
576 4);
577 pOld->tclasParams.ipv4.srcPort =
578 pNew->info.IpParams.params.IpV4Params.src_port;
579 pOld->tclasParams.ipv4.dstPort =
580 pNew->info.IpParams.params.IpV4Params.dest_port;
581 pOld->tclasParams.ipv4.dscp =
582 pNew->info.IpParams.params.IpV4Params.DSCP;
583 pOld->tclasParams.ipv4.protocol =
584 pNew->info.IpParams.params.IpV4Params.proto;
585 pOld->tclasParams.ipv4.rsvd =
586 pNew->info.IpParams.params.IpV4Params.reserved;
587 } else if (6 == pNew->info.IpParams.version) {
588 pOld->tclasParams.ipv6.version = 6;
589 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
590 srcIpAddr,
591 (uint8_t *) pNew->info.IpParams.params.
592 IpV6Params.source, 16);
593 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
594 dstIpAddr,
595 (uint8_t *) pNew->info.IpParams.params.
596 IpV6Params.dest, 16);
597 pOld->tclasParams.ipv6.srcPort =
598 pNew->info.IpParams.params.IpV6Params.src_port;
599 pOld->tclasParams.ipv6.dstPort =
600 pNew->info.IpParams.params.IpV6Params.dest_port;
601 qdf_mem_copy((uint8_t *) pOld->tclasParams.ipv6.
602 flowLabel,
603 (uint8_t *) pNew->info.IpParams.params.
604 IpV6Params.flow_label, 3);
605 } else {
606 return QDF_STATUS_E_FAILURE;
607 }
608 break;
609 case 2:
610 pOld->tclasParams.t8021dq.tag =
611 pNew->info.Params8021dq.tag_type;
612 break;
613 default:
614 return QDF_STATUS_E_FAILURE;
615 }
616
617 return QDF_STATUS_SUCCESS;
618 }
619
convert_ts_delay(struct mac_context * mac,tSirMacTsDelayIE * pOld,tDot11fIETSDelay * pNew)620 void convert_ts_delay(struct mac_context *mac,
621 tSirMacTsDelayIE *pOld, tDot11fIETSDelay *pNew)
622 {
623 pOld->type = DOT11F_EID_TSDELAY;
624 pOld->length = 4U;
625 pOld->delay = pNew->delay;
626 }
627
convert_schedule(struct mac_context * mac,tSirMacScheduleIE * pOld,tDot11fIESchedule * pNew)628 void convert_schedule(struct mac_context *mac,
629 tSirMacScheduleIE *pOld, tDot11fIESchedule *pNew)
630 {
631 pOld->type = DOT11F_EID_SCHEDULE;
632 pOld->length = DOT11F_IE_SCHEDULE_MIN_LEN;
633
634 pOld->info.aggregation = pNew->aggregation;
635 pOld->info.tsid = pNew->tsid;
636 pOld->info.direction = pNew->direction;
637
638 pOld->svcStartTime = pNew->service_start_time;
639 pOld->svcInterval = pNew->service_interval;
640 pOld->specInterval = pNew->spec_interval;
641 }
642
convert_wmm_schedule(struct mac_context * mac,tSirMacScheduleIE * pOld,tDot11fIEWMMSchedule * pNew)643 void convert_wmm_schedule(struct mac_context *mac,
644 tSirMacScheduleIE *pOld, tDot11fIEWMMSchedule *pNew)
645 {
646 pOld->type = DOT11F_EID_WMMSCHEDULE;
647 pOld->length = DOT11F_IE_WMMSCHEDULE_MIN_LEN;
648
649 pOld->info.aggregation = pNew->aggregation;
650 pOld->info.tsid = pNew->tsid;
651 pOld->info.direction = pNew->direction;
652
653 pOld->svcStartTime = pNew->service_start_time;
654 pOld->svcInterval = pNew->service_interval;
655 pOld->specInterval = pNew->spec_interval;
656 }
657
convert_qos_mapset_frame(struct mac_context * mac,struct qos_map_set * qos,tDot11fIEQosMapSet * dot11f_ie)658 void convert_qos_mapset_frame(struct mac_context *mac, struct qos_map_set *qos,
659 tDot11fIEQosMapSet *dot11f_ie)
660 {
661 uint8_t i, j = 0;
662 uint8_t dot11_dscp_exception_sz;
663
664 if (dot11f_ie->num_dscp_exceptions < DOT11F_IE_QOSMAPSET_MIN_LEN ||
665 dot11f_ie->num_dscp_exceptions % 2) {
666 pe_debug("Invalid num_dscp_exceptions %d",
667 dot11f_ie->num_dscp_exceptions);
668 return;
669 }
670
671 dot11_dscp_exception_sz = dot11f_ie->num_dscp_exceptions -
672 DOT11F_IE_QOSMAPSET_MIN_LEN;
673 qos->num_dscp_exceptions = dot11_dscp_exception_sz / 2;
674 if (qos->num_dscp_exceptions > QOS_MAP_MAX_EX)
675 qos->num_dscp_exceptions = QOS_MAP_MAX_EX;
676
677 for (i = 0; i < qos->num_dscp_exceptions &&
678 j < dot11_dscp_exception_sz - 1; i++) {
679 qos->dscp_exceptions[i][0] = dot11f_ie->dscp_exceptions[j++];
680 qos->dscp_exceptions[i][1] = dot11f_ie->dscp_exceptions[j++];
681 }
682
683 for (i = 0; i < QOS_MAP_RANGE_NUM &&
684 j < dot11f_ie->num_dscp_exceptions - 1; i++) {
685 qos->dscp_range[i][0] = dot11f_ie->dscp_exceptions[j++];
686 qos->dscp_range[i][1] = dot11f_ie->dscp_exceptions[j++];
687 }
688 }
689
690 /* utils_parser.c ends here. */
691