Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 32d95a31b726e02f560d3fe3328014d6590d68a5 / . / CORE / VOSS / src / vos_nvitem.c
blob: b18d133b6a5e16b1d93dbd83d18ffd1e486a3ede [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame^]2 * Copyright (c) 2012, The Linux Foundation. All rights reserved.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]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 FILE: vos_nvitem.c
24 OVERVIEW: This source file contains definitions for vOS NV Item APIs
25 DEPENDENCIES: NV, remote API client, WinCE REX
26 Copyright (c) 2008 QUALCOMM Incorporated.
27 All Rights Reserved.
28 Qualcomm Confidential and Proprietary
29============================================================================*/
30/*============================================================================
31 EDIT HISTORY FOR MODULE
32============================================================================*/
33// the following is used to disable warning for having too many labels in
34// the 'nv_items_enum_type'
35
36/*----------------------------------------------------------------------------
37 * Include Files
38 * -------------------------------------------------------------------------*/
39#include "vos_types.h"
40#include "aniGlobal.h"
41#include "vos_nvitem.h"
42#include "vos_trace.h"
43#include "vos_api.h"
44#include "wlan_hdd_misc.h"
45#include "vos_sched.h"
46
47/*----------------------------------------------------------------------------
48 * Preprocessor Definitions and Constants
49 * -------------------------------------------------------------------------*/
50#define VALIDITY_BITMAP_NV_ID NV_WLAN_VALIDITY_BITMAP_I
51#define VALIDITY_BITMAP_SIZE 32
52#define MAX_COUNTRY_COUNT 300
53//To be removed when NV support is fully functional
54#define VOS_HARD_CODED_MAC {0, 0x0a, 0xf5, 4, 5, 6}
55/*----------------------------------------------------------------------------
56 * Type Declarations
57 * -------------------------------------------------------------------------*/
58// this wrapper structure is identical to nv_cmd_type except the
59// data_ptr type is changed void* to avoid exceeding the debug information
60// module size as there are too many elements within nv_items_type union
61
62// structure for code and regulatory domain of a single country
63typedef struct
64{
65 v_U8_t regDomain;
66 v_COUNTRYCODE_t countryCode;
67} CountryInfo_t;
68// structure of table to map country code and regulatory domain
69typedef struct
70{
71 v_U16_t countryCount;
72 CountryInfo_t countryInfo[MAX_COUNTRY_COUNT];
73} CountryInfoTable_t;
74/*----------------------------------------------------------------------------
75 * Global Data Definitions
76 * -------------------------------------------------------------------------*/
77/*----------------------------------------------------------------------------
78 * Static Variable Definitions
79 * -------------------------------------------------------------------------*/
80// cache of country info table;
81// this is re-initialized from data on binary file
82// loaded on driver initialization if available
83static CountryInfoTable_t countryInfoTable =
84{
85 254,
86 {
87 { REGDOMAIN_FCC, {'U', 'S'}}, // USA - must be the first country code
88 { REGDOMAIN_WORLD, {'A', 'D'}}, //ANDORRA
89 { REGDOMAIN_WORLD,{'A', 'E'}}, //UAE
90 { REGDOMAIN_WORLD, {'A', 'F'}}, //AFGHANISTAN
91 { REGDOMAIN_NO_5GHZ, {'A', 'G'}}, //ANTIGUA AND BARBUDA
92 { REGDOMAIN_NO_5GHZ, {'A', 'I'}}, //ANGUILLA
93 { REGDOMAIN_WORLD, {'A', 'L'}}, //ALBANIA
94 { REGDOMAIN_NO_5GHZ, {'A', 'M'}}, //ARMENIA
95 { REGDOMAIN_WORLD, { 'A', 'N'}}, //NETHERLANDS ANTILLES
96 { REGDOMAIN_NO_5GHZ, { 'A', 'O'}}, //ANGOLA
97 { REGDOMAIN_WORLD, { 'A', 'Q'}}, //ANTARCTICA
98 { REGDOMAIN_HI_5GHZ,{ 'A', 'R'}}, //ARGENTINA
99 { REGDOMAIN_FCC, { 'A', 'S'}}, //AMERICAN SOMOA
100 { REGDOMAIN_ETSI, { 'A', 'T'}}, //AUSTRIA
101 { REGDOMAIN_APAC, { 'A', 'U'}}, //AUSTRALIA
102 { REGDOMAIN_NO_5GHZ, { 'A', 'W'}}, //ARUBA
103 { REGDOMAIN_WORLD, { 'A', 'X'}}, //ALAND ISLANDS
104 { REGDOMAIN_NO_5GHZ, { 'A', 'Z'}}, //AZERBAIJAN
105 { REGDOMAIN_WORLD, { 'B', 'A'}}, //BOSNIA AND HERZEGOVINA
106 { REGDOMAIN_WORLD, { 'B', 'B'}}, //BARBADOS
107 { REGDOMAIN_WORLD, { 'B', 'D'}}, //BANGLADESH
108 { REGDOMAIN_ETSI, {'B', 'E'}}, //BELGIUM
109 { REGDOMAIN_WORLD, { 'B', 'F'}}, //BURKINA FASO
110 { REGDOMAIN_HI_5GHZ, {'B', 'G'}}, //BULGARIA
111 { REGDOMAIN_WORLD, { 'B', 'H'}}, //BAHRAIN
112 { REGDOMAIN_WORLD, { 'B', 'I'}}, //BURUNDI
113 { REGDOMAIN_WORLD, { 'B', 'J'}}, //BENIN
114 { REGDOMAIN_ETSI, { 'B', 'M'}}, //BERMUDA
115 { REGDOMAIN_WORLD, { 'B', 'N'}}, //BRUNEI DARUSSALAM
116 { REGDOMAIN_WORLD,{ 'B', 'O'}}, //BOLIVIA
117 { REGDOMAIN_WORLD, {'B', 'R'}}, //BRAZIL
118 { REGDOMAIN_WORLD, { 'B', 'S'}}, //BAHAMAS
119 { REGDOMAIN_WORLD, { 'B', 'T'}}, //BHUTAN
120 { REGDOMAIN_WORLD, { 'B', 'V'}}, //BOUVET ISLAND
121 { REGDOMAIN_WORLD, { 'B', 'W'}}, //BOTSWANA
122 { REGDOMAIN_WORLD, { 'B', 'Y'}}, //BELARUS
123 { REGDOMAIN_WORLD, { 'B', 'Z'}}, //BELIZE
124 { REGDOMAIN_FCC, {'C', 'A'}}, //CANADA
125 { REGDOMAIN_WORLD, { 'C', 'C'}}, //COCOS (KEELING) ISLANDS
126 { REGDOMAIN_WORLD, { 'C', 'D'}}, //CONGO, THE DEMOCRATIC REPUBLIC OF THE
127 { REGDOMAIN_WORLD, { 'C', 'F'}}, //CENTRAL AFRICAN REPUBLIC
128 { REGDOMAIN_WORLD, { 'C', 'G'}}, //CONGO
129 { REGDOMAIN_ETSI, {'C', 'H'}}, //SWITZERLAND
130 { REGDOMAIN_WORLD, { 'C', 'I'}}, //COTE D'IVOIRE
131 { REGDOMAIN_WORLD, { 'C', 'K'}}, //COOK ISLANDS
132 { REGDOMAIN_WORLD, {'C', 'L'}}, //CHILE
133 { REGDOMAIN_WORLD, { 'C', 'M'}}, //CAMEROON
134 { REGDOMAIN_HI_5GHZ, {'C', 'N'}}, //CHINA
135 { REGDOMAIN_WORLD, {'C', 'O'}}, //COLOMBIA
136 { REGDOMAIN_WORLD, {'C', 'R'}}, //COSTA RICA
137 { REGDOMAIN_WORLD, { 'C', 'U'}}, //CUBA
138 { REGDOMAIN_WORLD, { 'C', 'V'}}, //CAPE VERDE
139 { REGDOMAIN_WORLD, { 'C', 'X'}}, //CHRISTMAS ISLAND
140 { REGDOMAIN_WORLD, {'C', 'Y'}}, //CYPRUS
141 { REGDOMAIN_HI_5GHZ, {'C', 'Z'}}, //CZECH REPUBLIC
142 { REGDOMAIN_ETSI, {'D', 'E'}}, //GERMANY
143 { REGDOMAIN_WORLD, { 'D', 'J'}}, //DJIBOUTI
144 { REGDOMAIN_ETSI, {'D', 'K'}}, //DENMARK
145 { REGDOMAIN_WORLD, { 'D', 'M'}}, //DOMINICA
146 { REGDOMAIN_NO_5GHZ,{ 'D', 'O'}}, //DOMINICAN REPUBLIC
147 { REGDOMAIN_WORLD, { 'D', 'Z'}}, //ALGERIA
148 { REGDOMAIN_WORLD,{ 'E', 'C'}}, //ECUADOR
149 { REGDOMAIN_HI_5GHZ, {'E', 'E'}}, //ESTONIA
150 { REGDOMAIN_WORLD, { 'E', 'G'}}, //EGYPT
151 { REGDOMAIN_WORLD, { 'E', 'H'}}, //WESTERN SAHARA
152 { REGDOMAIN_WORLD, { 'E', 'R'}}, //ERITREA
153 { REGDOMAIN_ETSI, {'E', 'S'}}, //SPAIN
154 { REGDOMAIN_WORLD, { 'E', 'T'}}, //ETHIOPIA
155 { REGDOMAIN_WORLD, {'F', 'I'}}, //FINLAND
156 { REGDOMAIN_WORLD, { 'F', 'J'}}, //FIJI
157 { REGDOMAIN_WORLD, { 'F', 'K'}}, //FALKLAND ISLANDS (MALVINAS)
158 { REGDOMAIN_WORLD, { 'F', 'M'}}, //MICRONESIA, FEDERATED STATES OF
159 { REGDOMAIN_WORLD, { 'F', 'O'}}, //FAROE ISLANDS
160 { REGDOMAIN_ETSI, {'F', 'R'}}, //FRANCE
161 { REGDOMAIN_WORLD, { 'G', 'A'}}, //GABON
162 { REGDOMAIN_ETSI, {'G', 'B'}}, //UNITED KINGDOM
163 { REGDOMAIN_WORLD, { 'G', 'D'}}, //GRENADA
164 { REGDOMAIN_HI_5GHZ, { 'G', 'E'}}, //GEORGIA
165 { REGDOMAIN_WORLD, { 'G', 'F'}}, //FRENCH GUIANA
166 { REGDOMAIN_ETSI, {'G', 'G'}}, //GUERNSEY
167 { REGDOMAIN_WORLD, { 'G', 'H'}}, //GHANA
168 { REGDOMAIN_WORLD, {'G', 'I'}}, //GIBRALTAR
169 { REGDOMAIN_WORLD, { 'G', 'L'}}, //GREENLAND
170 { REGDOMAIN_WORLD, { 'G', 'M'}}, //GAMBIA
171 { REGDOMAIN_WORLD, { 'G', 'N'}}, //GUINEA
172 { REGDOMAIN_WORLD, { 'G', 'P'}}, //GUADELOUPE
173 { REGDOMAIN_WORLD, { 'G', 'Q'}}, //EQUATORIAL GUINEA
174 { REGDOMAIN_ETSI, {'G', 'R'}}, //GREECE
175 { REGDOMAIN_WORLD, { 'G', 'S'}}, //SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS
176 { REGDOMAIN_WORLD,{ 'G', 'T'}}, //GUATEMALA
177 { REGDOMAIN_WORLD, { 'G', 'U'}}, //GUAM
178 { REGDOMAIN_WORLD, { 'G', 'W'}}, //GUINEA-BISSAU
179 { REGDOMAIN_WORLD, { 'G', 'Y'}}, //GUYANA
180 { REGDOMAIN_WORLD, {'H', 'K'}}, //HONGKONG
181 { REGDOMAIN_WORLD, { 'H', 'M'}}, //HEARD ISLAND AND MCDONALD ISLANDS
182 { REGDOMAIN_WORLD,{'H', 'N'}}, //HONDURAS
183 { REGDOMAIN_HI_5GHZ, {'H', 'R'}}, //CROATIA
184 { REGDOMAIN_WORLD, { 'H', 'T'}}, //HAITI
185 { REGDOMAIN_HI_5GHZ, {'H', 'U'}}, //HUNGARY
186 { REGDOMAIN_APAC, { 'I', 'D'}}, //INDONESIA
187 { REGDOMAIN_ETSI, {'I', 'E'}}, //IRELAND
188 { REGDOMAIN_WORLD, {'I', 'L'}}, //ISREAL
189 { REGDOMAIN_ETSI, {'I', 'M'}}, //ISLE OF MAN
190 { REGDOMAIN_APAC, {'I', 'N'}}, //INDIA
191 { REGDOMAIN_ETSI, { 'I', 'O'}}, //BRITISH INDIAN OCEAN TERRITORY
192 { REGDOMAIN_WORLD, { 'I', 'Q'}}, //IRAQ
193 { REGDOMAIN_WORLD, { 'I', 'R'}}, //IRAN, ISLAMIC REPUBLIC OF
194 { REGDOMAIN_WORLD, {'I', 'S'}}, //ICELAND
195 { REGDOMAIN_ETSI, {'I', 'T'}}, //ITALY
196 { REGDOMAIN_ETSI, {'J', 'E'}}, //JERSEY
197 { REGDOMAIN_WORLD, { 'J', 'M'}}, //JAMAICA
198 { REGDOMAIN_WORLD, { 'J', 'O'}}, //JORDAN
199 { REGDOMAIN_JAPAN, {'J', 'P'}}, //JAPAN
200 { REGDOMAIN_WORLD, { 'K', 'E'}}, //KENYA
201 { REGDOMAIN_WORLD, { 'K', 'G'}}, //KYRGYZSTAN
202 { REGDOMAIN_WORLD, { 'K', 'H'}}, //CAMBODIA
203 { REGDOMAIN_WORLD, { 'K', 'I'}}, //KIRIBATI
204 { REGDOMAIN_WORLD, { 'K', 'M'}}, //COMOROS
205 { REGDOMAIN_WORLD, { 'K', 'N'}}, //SAINT KITTS AND NEVIS
206 { REGDOMAIN_KOREA, { 'K', 'P'}}, //KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF
207 { REGDOMAIN_KOREA, {'K', 'R'}}, //KOREA, REPUBLIC OF
208 { REGDOMAIN_WORLD, { 'K', 'W'}}, //KUWAIT
209 { REGDOMAIN_WORLD, { 'K', 'Y'}}, //CAYMAN ISLANDS
210 { REGDOMAIN_WORLD, { 'K', 'Z'}}, //KAZAKHSTAN
211 { REGDOMAIN_WORLD, { 'L', 'A'}}, //LAO PEOPLE'S DEMOCRATIC REPUBLIC
212 { REGDOMAIN_WORLD, { 'L', 'B'}}, //LEBANON
213 { REGDOMAIN_WORLD, { 'L', 'C'}}, //SAINT LUCIA
214 { REGDOMAIN_ETSI, {'L', 'I'}}, //LIECHTENSTEIN
215 { REGDOMAIN_WORLD, { 'L', 'K'}}, //SRI LANKA
216 { REGDOMAIN_WORLD, { 'L', 'R'}}, //LIBERIA
217 { REGDOMAIN_WORLD, { 'L', 'S'}}, //LESOTHO
218 { REGDOMAIN_HI_5GHZ, {'L', 'T'}}, //LITHUANIA
219 { REGDOMAIN_ETSI, {'L', 'U'}}, //LUXEMBOURG
220 { REGDOMAIN_HI_5GHZ, {'L', 'V'}}, //LATVIA
221 { REGDOMAIN_WORLD, { 'L', 'Y'}}, //LIBYAN ARAB JAMAHIRIYA
222 { REGDOMAIN_WORLD, { 'M', 'A'}}, //MOROCCO
223 { REGDOMAIN_ETSI, {'M', 'C'}}, //MONACO
224 { REGDOMAIN_WORLD, { 'M', 'D'}}, //MOLDOVA, REPUBLIC OF
225 { REGDOMAIN_WORLD, { 'M', 'E'}}, //MONTENEGRO
226 { REGDOMAIN_WORLD, { 'M', 'G'}}, //MADAGASCAR
227 { REGDOMAIN_WORLD, { 'M', 'H'}}, //MARSHALL ISLANDS
228 { REGDOMAIN_WORLD, { 'M', 'K'}}, //MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF
229 { REGDOMAIN_WORLD, { 'M', 'L'}}, //MALI
230 { REGDOMAIN_WORLD, { 'M', 'M'}}, //MYANMAR
231 { REGDOMAIN_HI_5GHZ, { 'M', 'N'}}, //MONGOLIA
232 { REGDOMAIN_WORLD, { 'M', 'O'}}, //MACAO
233 { REGDOMAIN_WORLD, { 'M', 'P'}}, //NORTHERN MARIANA ISLANDS
234 { REGDOMAIN_WORLD, { 'M', 'Q'}}, //MARTINIQUE
235 { REGDOMAIN_WORLD, { 'M', 'R'}}, //MAURITANIA
236 { REGDOMAIN_WORLD, { 'M', 'S'}}, //MONTSERRAT
237 { REGDOMAIN_WORLD, {'M', 'T'}}, //MALTA
238 { REGDOMAIN_WORLD, { 'M', 'U'}}, //MAURITIUS
239 { REGDOMAIN_WORLD, { 'M', 'V'}}, //MALDIVES
240 { REGDOMAIN_WORLD, { 'M', 'W'}}, //MALAWI
241 { REGDOMAIN_WORLD, {'M', 'X'}}, //MEXICO
242 { REGDOMAIN_HI_5GHZ,{ 'M', 'Y'}}, //MALAYSIA
243 { REGDOMAIN_WORLD, { 'M', 'Z'}}, //MOZAMBIQUE
244 { REGDOMAIN_WORLD, { 'N', 'A'}}, //NAMIBIA
245 { REGDOMAIN_WORLD, { 'N', 'C'}}, //NEW CALEDONIA
246 { REGDOMAIN_WORLD, { 'N', 'E'}}, //NIGER
247 { REGDOMAIN_WORLD, { 'N', 'F'}}, //NORFOLD ISLAND
248 { REGDOMAIN_WORLD, { 'N', 'G'}}, //NIGERIA
249 { REGDOMAIN_WORLD,{ 'N', 'I'}}, //NICARAGUA
250 { REGDOMAIN_ETSI, {'N', 'L'}}, //NETHERLANDS
251 { REGDOMAIN_WORLD, {'N', 'O'}}, //NORWAY
252 { REGDOMAIN_WORLD, { 'N', 'P'}}, //NEPAL
253 { REGDOMAIN_WORLD, { 'N', 'R'}}, //NAURU
254 { REGDOMAIN_WORLD, { 'N', 'U'}}, //NIUE
255 { REGDOMAIN_ETSI, {'N', 'Z'}}, //NEW ZEALAND
256 { REGDOMAIN_WORLD, { 'O', 'M'}}, //OMAN
257 { REGDOMAIN_WORLD, {'P', 'A'}}, //PANAMA
258 { REGDOMAIN_WORLD,{ 'P', 'E'}}, //PERU
259 { REGDOMAIN_WORLD, { 'P', 'F'}}, //FRENCH POLYNESIA
260 { REGDOMAIN_WORLD, { 'P', 'G'}}, //PAPUA NEW GUINEA
261 { REGDOMAIN_WORLD, {'P', 'H'}}, //PHILIPPINES
262 { REGDOMAIN_WORLD, { 'P', 'K'}}, //PAKISTAN
263 { REGDOMAIN_ETSI, {'P', 'L'}}, //POLAND
264 { REGDOMAIN_WORLD, { 'P', 'M'}}, //SAINT PIERRE AND MIQUELON
265 { REGDOMAIN_WORLD, { 'P', 'N'}}, //WORLDPITCAIRN
266 { REGDOMAIN_FCC, {'P', 'R'}}, //PUERTO RICO
267 { REGDOMAIN_WORLD, {'P', 'S'}}, //PALESTINIAN TERRITORY, OCCUPIED
268 { REGDOMAIN_ETSI, {'P', 'T'}}, //PORTUGAL
269 { REGDOMAIN_WORLD, { 'P', 'W'}}, //PALAU
270 { REGDOMAIN_WORLD, { 'P', 'Y'}}, //PARAGUAY
271 { REGDOMAIN_WORLD, { 'Q', 'A'}}, //QATAR
272 { REGDOMAIN_WORLD, { 'R', 'E'}}, //REUNION
273 { REGDOMAIN_HI_5GHZ, {'R', 'O'}}, //ROMANIA
274 { REGDOMAIN_HI_5GHZ, {'R', 'S'}}, //SERBIA
275 { REGDOMAIN_WORLD, {'R', 'U'}}, //RUSSIA
276 { REGDOMAIN_WORLD, { 'R', 'W'}}, //RWANDA
277 { REGDOMAIN_WORLD, {'S', 'A'}}, //SAUDI ARABIA
278 { REGDOMAIN_WORLD, { 'S', 'B'}}, //SOLOMON ISLANDS
279 { REGDOMAIN_ETSI, {'S', 'C'}}, //SEYCHELLES
280 { REGDOMAIN_WORLD, { 'S', 'D'}}, //SUDAN
281 { REGDOMAIN_ETSI, {'S', 'E'}}, //SWEDEN
282 { REGDOMAIN_APAC, {'S', 'G'}}, //SINGAPORE
283 { REGDOMAIN_WORLD, { 'S', 'H'}}, //SAINT HELENA
284 { REGDOMAIN_HI_5GHZ, {'S', 'I'}}, //SLOVENNIA
285 { REGDOMAIN_WORLD, { 'S', 'J'}}, //SVALBARD AND JAN MAYEN
286 { REGDOMAIN_ETSI, {'S', 'K'}}, //SLOVAKIA
287 { REGDOMAIN_WORLD, { 'S', 'L'}}, //SIERRA LEONE
288 { REGDOMAIN_WORLD, { 'S', 'M'}}, //SAN MARINO
289 { REGDOMAIN_WORLD, { 'S', 'N'}}, //SENEGAL
290 { REGDOMAIN_WORLD, { 'S', 'O'}}, //SOMALIA
291 { REGDOMAIN_WORLD, { 'S', 'R'}}, //SURINAME
292 { REGDOMAIN_WORLD, { 'S', 'T'}}, //SAO TOME AND PRINCIPE
293 { REGDOMAIN_WORLD, {'S', 'V'}}, //EL SALVADOR
294 { REGDOMAIN_WORLD, { 'S', 'Y'}}, //SYRIAN ARAB REPUBLIC
295 { REGDOMAIN_WORLD, { 'S', 'Z'}}, //SWAZILAND
296 { REGDOMAIN_WORLD, { 'T', 'C'}}, //TURKS AND CAICOS ISLANDS
297 { REGDOMAIN_WORLD, { 'T', 'D'}}, //CHAD
298 { REGDOMAIN_WORLD, { 'T', 'F'}}, //FRENCH SOUTHERN TERRITORIES
299 { REGDOMAIN_WORLD, { 'T', 'G'}}, //TOGO
300 { REGDOMAIN_WORLD,{ 'T', 'H'}}, //THAILAND
301 { REGDOMAIN_WORLD, { 'T', 'J'}}, //TAJIKISTAN
302 { REGDOMAIN_WORLD, { 'T', 'K'}}, //TOKELAU
303 { REGDOMAIN_WORLD, { 'T', 'L'}}, //TIMOR-LESTE
304 { REGDOMAIN_WORLD, { 'T', 'M'}}, //TURKMENISTAN
305 { REGDOMAIN_WORLD, { 'T', 'N'}}, //TUNISIA
306 { REGDOMAIN_WORLD, { 'T', 'O'}}, //TONGA
307 { REGDOMAIN_WORLD, {'T', 'R'}}, //TURKEY
308 { REGDOMAIN_WORLD, { 'T', 'T'}}, //TRINIDAD AND TOBAGO
309 { REGDOMAIN_WORLD, { 'T', 'V'}}, //TUVALU
310 { REGDOMAIN_HI_5GHZ,{ 'T', 'W'}}, //TAIWAN, PROVINCE OF CHINA
311 { REGDOMAIN_WORLD, { 'T', 'Z'}}, //TANZANIA, UNITED REPUBLIC OF
312 { REGDOMAIN_HI_5GHZ,{ 'U', 'A'}}, //UKRAINE
313 { REGDOMAIN_WORLD, { 'U', 'G'}}, //UGANDA
314 { REGDOMAIN_FCC, {'U', 'M'}}, //UNITED STATES MINOR OUTLYING ISLANDS
315 { REGDOMAIN_WORLD,{ 'U', 'Y'}}, //URUGUAY
316 { REGDOMAIN_HI_5GHZ, { 'U', 'Z'}}, //UZBEKISTAN
317 { REGDOMAIN_ETSI, {'V', 'A'}}, //HOLY SEE (VATICAN CITY STATE)
318 { REGDOMAIN_WORLD, { 'V', 'C'}}, //SAINT VINCENT AND THE GRENADINES
319 { REGDOMAIN_HI_5GHZ,{ 'V', 'E'}}, //VENEZUELA
320 { REGDOMAIN_ETSI, {'V', 'G'}}, //VIRGIN ISLANDS, BRITISH
321 { REGDOMAIN_FCC, {'V', 'I'}}, //VIRGIN ISLANDS, US
322 { REGDOMAIN_WORLD, {'V', 'N'}}, //VIET NAM
323 { REGDOMAIN_WORLD, { 'V', 'U'}}, //VANUATU
324 { REGDOMAIN_WORLD, { 'W', 'F'}}, //WALLIS AND FUTUNA
325 { REGDOMAIN_WORLD, { 'W', 'S'}}, //SOMOA
326 { REGDOMAIN_WORLD, { 'Y', 'E'}}, //YEMEN
327 { REGDOMAIN_WORLD, { 'Y', 'T'}}, //MAYOTTE
328 { REGDOMAIN_WORLD, {'Z', 'A'}}, //SOUTH AFRICA
329 { REGDOMAIN_WORLD, { 'Z', 'M'}}, //ZAMBIA
330 { REGDOMAIN_WORLD, { 'Z', 'W'}}, //ZIMBABWE
331 { REGDOMAIN_KOREA, {'K', '1'}}, //Korea alternate 1
332 { REGDOMAIN_KOREA, {'K', '2'}}, //Korea alternate 2
333 { REGDOMAIN_KOREA, {'K', '3'}}, //Korea alternate 3
334 { REGDOMAIN_KOREA, {'K', '4'}}, //Korea alternate 4
335 { REGDOMAIN_ETSI, {'E', 'U'}}, //Europe (SSGFI)
336 { REGDOMAIN_JAPAN, {'J', '1'}}, //Japan alternate 1
337 { REGDOMAIN_JAPAN, {'J', '2'}}, //Japan alternate 2
338 { REGDOMAIN_JAPAN, {'J', '3'}}, //Japan alternate 3
339 { REGDOMAIN_JAPAN, {'J', '4'}}, //Japan alternate 4
340 { REGDOMAIN_JAPAN, {'J', '5'}} //Japan alternate 5
341 }
342};
343typedef struct nvEFSTable_s
344{
345 v_U32_t nvValidityBitmap;
346 sHalNv halnv;
347} nvEFSTable_t;
348nvEFSTable_t *gnvEFSTable=NULL;
349/* EFS Table to send the NV structure to HAL*/
350static nvEFSTable_t *pnvEFSTable =NULL;
351
352const tRfChannelProps rfChannels[NUM_RF_CHANNELS] =
353{
354 //RF_SUBBAND_2_4_GHZ
355 //freq, chan#, band
356 { 2412, 1 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_1,
357 { 2417, 2 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_2,
358 { 2422, 3 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_3,
359 { 2427, 4 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_4,
360 { 2432, 5 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_5,
361 { 2437, 6 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_6,
362 { 2442, 7 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_7,
363 { 2447, 8 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_8,
364 { 2452, 9 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_9,
365 { 2457, 10 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_10,
366 { 2462, 11 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_11,
367 { 2467, 12 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_12,
368 { 2472, 13 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_13,
369 { 2484, 14 , RF_SUBBAND_2_4_GHZ}, //RF_CHAN_14,
370#ifdef FEATURE_WLAN_INTEGRATED_SOC
371 { 0, 240, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_240,
372 { 0, 244, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_244,
373 { 0, 248, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_248,
374 { 0, 252, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_252,
375 { 0, 208, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_208,
376 { 0, 212, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_212,
377 { 0, 216, RF_SUBBAND_4_9_GHZ}, //RF_CHAN_216,
378 { 5180, 36 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_36,
379 { 5200, 40 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_40,
380 { 5220, 44 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_44,
381 { 5240, 48 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_48,
382 { 5260, 52 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_52,
383 { 5280, 56 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_56,
384 { 5300, 60 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_60,
385 { 5320, 64 , RF_SUBBAND_5_LOW_GHZ}, //RF_CHAN_64,
386 { 5500, 100, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_100,
387 { 5520, 104, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_104,
388 { 5540, 108, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_108,
389 { 5560, 112, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_112,
390 { 5580, 116, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_116,
391 { 5600, 120, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_120,
392 { 5620, 124, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_124,
393 { 5640, 128, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_128,
394 { 5660, 132, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_132,
395 { 5680, 136, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_136,
396 { 5700, 140, RF_SUBBAND_5_MID_GHZ}, //RF_CHAN_140,
397 { 5745, 149, RF_SUBBAND_5_HIGH_GHZ}, //RF_CHAN_149,
398 { 5765, 153, RF_SUBBAND_5_HIGH_GHZ}, //RF_CHAN_153,
399 { 5785, 157, RF_SUBBAND_5_HIGH_GHZ}, //RF_CHAN_157,
400 { 5805, 161, RF_SUBBAND_5_HIGH_GHZ}, //RF_CHAN_161,
401 { 5825, 165, RF_SUBBAND_5_HIGH_GHZ}, //RF_CHAN_165,
402 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_3,
403 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_4,
404 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_5,
405 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_6,
406 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_7,
407 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_8,
408 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_9,
409 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_10,
410 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_11,
411 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_242,
412 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_246,
413 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_250,
414 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_210,
415 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_214,
416 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_38,
417 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_42,
418 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_46,
419 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_50,
420 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_54,
421 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_58,
422 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_62,
423 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_102,
424 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_106,
425 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_110,
426 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_114,
427 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_118,
428 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_122,
429 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_126,
430 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_130,
431 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_134,
432 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_138,
433 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_151,
434 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_155,
435 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_159,
436 { 0 , 0 , NUM_RF_SUBBANDS}, //RF_CHAN_BOND_163,
437#endif
438};
439
440extern const sHalNv nvDefaults;
441
442const sRegulatoryChannel * regChannels = nvDefaults.tables.regDomains[0].channels;
443
444/*----------------------------------------------------------------------------
445 Function Definitions and Documentation
446 * -------------------------------------------------------------------------*/
447VOS_STATUS wlan_write_to_efs (v_U8_t *pData, v_U16_t data_len);
448/**------------------------------------------------------------------------
449 \brief vos_nv_init() - initialize the NV module
450 The \a vos_nv_init() initializes the NV module. This read the binary
451 file for country code and regulatory domain information.
452 \return VOS_STATUS_SUCCESS - module is initialized successfully
453 otherwise - module is not initialized
454 \sa
455 -------------------------------------------------------------------------*/
456VOS_STATUS vos_nv_init(void)
457{
458 return VOS_STATUS_SUCCESS;
459}
460
461VOS_STATUS vos_nv_open(void)
462{
463 VOS_STATUS status = VOS_STATUS_SUCCESS;
464 v_CONTEXT_t pVosContext= NULL;
465 v_SIZE_t bufSize;
466 v_BOOL_t itemIsValid = VOS_FALSE;
467
468 /*Get the global context */
469 pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL);
470 bufSize = sizeof(nvEFSTable_t);
471 status = hdd_request_firmware(WLAN_NV_FILE,
472 ((VosContextType*)(pVosContext))->pHDDContext,
473 (v_VOID_t**)&gnvEFSTable, &bufSize);
474
475 if ( (!VOS_IS_STATUS_SUCCESS( status )) || !gnvEFSTable)
476 {
477 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
478 "%s: unable to download NV file %s",
479 __FUNCTION__, WLAN_NV_FILE);
480 return VOS_STATUS_E_RESOURCES;
481 }
482
483 /* Copying the read nv data to the globa NV EFS table */
484 {
485 /* Allocate memory to global NV table */
486 pnvEFSTable = (nvEFSTable_t *)vos_mem_malloc(sizeof(nvEFSTable_t));
487 if (NULL == pnvEFSTable)
488 {
489 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
490 "%s : failed to allocate memory for NV", __FUNCTION__);
491 return VOS_STATUS_E_NOMEM;
492 }
493
494 /*Copying the NV defaults */
495 vos_mem_copy(&(pnvEFSTable->halnv),&nvDefaults,sizeof(sHalNv));
496 pnvEFSTable->nvValidityBitmap = gnvEFSTable->nvValidityBitmap;
497
498 /* Copy the valid fields to the NV Global structure */
499 if (vos_nv_getValidity(VNV_FIELD_IMAGE, &itemIsValid) ==
500 VOS_STATUS_SUCCESS)
501 {
502 if (itemIsValid == VOS_TRUE) {
503
504 if(vos_nv_read( VNV_FIELD_IMAGE, (v_VOID_t *)&pnvEFSTable->halnv.fields,
505 NULL, sizeof(sNvFields) ) != VOS_STATUS_SUCCESS)
506 return (eHAL_STATUS_FAILURE);
507 }
508 }
509
510 if (vos_nv_getValidity(VNV_RATE_TO_POWER_TABLE, &itemIsValid) ==
511 VOS_STATUS_SUCCESS)
512 {
513 if (itemIsValid == VOS_TRUE)
514 {
515 if(vos_nv_read( VNV_RATE_TO_POWER_TABLE,
516 (v_VOID_t *)&pnvEFSTable->halnv.tables.pwrOptimum[0],
517 NULL, sizeof(tRateGroupPwr) * NUM_RF_SUBBANDS ) != VOS_STATUS_SUCCESS)
518 return (eHAL_STATUS_FAILURE);
519 }
520 }
521
522 if (vos_nv_getValidity(VNV_REGULARTORY_DOMAIN_TABLE, &itemIsValid) ==
523 VOS_STATUS_SUCCESS)
524 {
525
526 if (itemIsValid == VOS_TRUE)
527 {
528 if(vos_nv_read( VNV_REGULARTORY_DOMAIN_TABLE,
529 (v_VOID_t *)&pnvEFSTable->halnv.tables.regDomains[0],
530 NULL, sizeof(sRegulatoryDomains) * NUM_REG_DOMAINS ) != VOS_STATUS_SUCCESS)
531 return (eHAL_STATUS_FAILURE);
532 }
533 }
534
535 if (vos_nv_getValidity(VNV_DEFAULT_LOCATION, &itemIsValid) ==
536 VOS_STATUS_SUCCESS)
537 {
538 if (itemIsValid == VOS_TRUE)
539 {
540 if(vos_nv_read( VNV_DEFAULT_LOCATION,
541 (v_VOID_t *)&pnvEFSTable->halnv.tables.defaultCountryTable,
542 NULL, sizeof(sDefaultCountry) ) != VOS_STATUS_SUCCESS)
543 return (eHAL_STATUS_FAILURE);
544 }
545 }
546
547 if (vos_nv_getValidity(VNV_TPC_POWER_TABLE, &itemIsValid) ==
548 VOS_STATUS_SUCCESS)
549 {
550 if (itemIsValid == VOS_TRUE)
551 {
552 if(vos_nv_read( VNV_TPC_POWER_TABLE,
553 (v_VOID_t *)&pnvEFSTable->halnv.tables.plutCharacterized[0],
554 NULL, sizeof(tTpcPowerTable) * NUM_RF_CHANNELS ) != VOS_STATUS_SUCCESS)
555 return (eHAL_STATUS_FAILURE);
556 }
557 }
558
559 if (vos_nv_getValidity(VNV_TPC_PDADC_OFFSETS, &itemIsValid) ==
560 VOS_STATUS_SUCCESS)
561 {
562 if (itemIsValid == VOS_TRUE)
563 {
564 if(vos_nv_read( VNV_TPC_PDADC_OFFSETS,
565 (v_VOID_t *)&pnvEFSTable->halnv.tables.plutPdadcOffset[0],
566 NULL, sizeof(tANI_U16) * NUM_RF_CHANNELS ) != VOS_STATUS_SUCCESS)
567 return (eHAL_STATUS_FAILURE);
568 }
569 }
570 if (vos_nv_getValidity(VNV_RSSI_CHANNEL_OFFSETS, &itemIsValid) ==
571 VOS_STATUS_SUCCESS)
572 {
573 if (itemIsValid == VOS_TRUE)
574 {
575 if(vos_nv_read( VNV_RSSI_CHANNEL_OFFSETS,
576 (v_VOID_t *)&pnvEFSTable->halnv.tables.rssiChanOffsets[0],
577 NULL, sizeof(sRssiChannelOffsets) * 2 ) != VOS_STATUS_SUCCESS)
578 return (eHAL_STATUS_FAILURE);
579 }
580 }
581
582 if (vos_nv_getValidity(VNV_RF_CAL_VALUES, &itemIsValid) ==
583 VOS_STATUS_SUCCESS)
584 {
585 if (itemIsValid == VOS_TRUE)
586 {
587 if(vos_nv_read( VNV_RF_CAL_VALUES, (v_VOID_t *)&pnvEFSTable->halnv
588 .tables.rFCalValues, NULL, sizeof(sRFCalValues) ) != VOS_STATUS_SUCCESS)
589 return (eHAL_STATUS_FAILURE);
590 }
591 }
592
593 if (vos_nv_getValidity(VNV_ANTENNA_PATH_LOSS, &itemIsValid) ==
594 VOS_STATUS_SUCCESS)
595 {
596 if (itemIsValid == VOS_TRUE)
597 {
598 if(vos_nv_read( VNV_ANTENNA_PATH_LOSS,
599 (v_VOID_t *)&pnvEFSTable->halnv.tables.antennaPathLoss[0], NULL,
600 sizeof(tANI_S16)*NUM_RF_CHANNELS ) != VOS_STATUS_SUCCESS)
601 return (eHAL_STATUS_FAILURE);
602 }
603 }
604 if (vos_nv_getValidity(VNV_PACKET_TYPE_POWER_LIMITS, &itemIsValid) ==
605 VOS_STATUS_SUCCESS)
606 {
607 if (itemIsValid == VOS_TRUE)
608 {
609 if(vos_nv_read( VNV_PACKET_TYPE_POWER_LIMITS,
610 (v_VOID_t *)&pnvEFSTable->halnv.tables.pktTypePwrLimits[0], NULL,
611 sizeof(tANI_S16)*NUM_802_11_MODES*NUM_RF_CHANNELS ) != VOS_STATUS_SUCCESS)
612 return (eHAL_STATUS_FAILURE);
613 }
614 }
615
616 if (vos_nv_getValidity(VNV_OFDM_CMD_PWR_OFFSET, &itemIsValid) ==
617 VOS_STATUS_SUCCESS)
618 {
619 if (itemIsValid == VOS_TRUE)
620 {
621 if(vos_nv_read( VNV_OFDM_CMD_PWR_OFFSET,
622 (v_VOID_t *)&pnvEFSTable->halnv.tables.ofdmCmdPwrOffset, NULL,
623 sizeof(sOfdmCmdPwrOffset)) != VOS_STATUS_SUCCESS)
624 return (eHAL_STATUS_FAILURE);
625 }
626 }
627
628 if (vos_nv_getValidity(VNV_TX_BB_FILTER_MODE, &itemIsValid) ==
629 VOS_STATUS_SUCCESS)
630 {
631 if (itemIsValid == VOS_TRUE)
632 {
633 if(vos_nv_read(VNV_TX_BB_FILTER_MODE,
634 (v_VOID_t *)&pnvEFSTable->halnv.tables.txbbFilterMode, NULL,
635 sizeof(sTxBbFilterMode)) != VOS_STATUS_SUCCESS)
636 return (eHAL_STATUS_FAILURE);
637 }
638 }
639 if (vos_nv_getValidity(VNV_TABLE_VIRTUAL_RATE, &itemIsValid) ==
640 VOS_STATUS_SUCCESS)
641 {
642 if (itemIsValid == VOS_TRUE)
643 {
644 if(vos_nv_read(VNV_TABLE_VIRTUAL_RATE,
645 (v_VOID_t *)&pnvEFSTable->halnv.tables.pwrOptimum_virtualRate, NULL,
646 sizeof(gnvEFSTable->halnv.tables.pwrOptimum_virtualRate)) != VOS_STATUS_SUCCESS)
647 return (eHAL_STATUS_FAILURE);
648 }
649 }
650 }
651
652 return VOS_STATUS_SUCCESS;
653}
654
655VOS_STATUS vos_nv_close(void)
656{
657 VOS_STATUS status = VOS_STATUS_SUCCESS;
658 v_CONTEXT_t pVosContext= NULL;
659 /*Get the global context */
660 pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS, NULL);
661 status = hdd_release_firmware(WLAN_NV_FILE, ((VosContextType*)(pVosContext))->pHDDContext);
662 if ( !VOS_IS_STATUS_SUCCESS( status ))
663 {
664 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
665 "%s : vos_open failed\n",__func__);
666 return VOS_STATUS_E_FAILURE;
667 }
668 vos_mem_free(pnvEFSTable);
669 gnvEFSTable=NULL;
670 return VOS_STATUS_SUCCESS;
671}
672/**------------------------------------------------------------------------
673 \brief vos_nv_getRegDomainFromCountryCode() - get the regulatory domain of
674 a country given its country code
675 The \a vos_nv_getRegDomainFromCountryCode() returns the regulatory domain of
676 a country given its country code. This is done from reading a cached
677 copy of the binary file.
678 \param pRegDomain - pointer to regulatory domain
679 \param countryCode - country code
680 \return VOS_STATUS_SUCCESS - regulatory domain is found for the given country
681 VOS_STATUS_E_FAULT - invalid pointer error
682 VOS_STATUS_E_EMPTY - country code table is empty
683 VOS_STATUS_E_EXISTS - given country code does not exist in table
684 \sa
685 -------------------------------------------------------------------------*/
686VOS_STATUS vos_nv_getRegDomainFromCountryCode( v_REGDOMAIN_t *pRegDomain,
687 const v_COUNTRYCODE_t countryCode )
688{
689 int i;
690 // sanity checks
691 if (NULL == pRegDomain)
692 {
693 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
694 ("Invalid reg domain pointer\r\n") );
695 return VOS_STATUS_E_FAULT;
696 }
697 *pRegDomain = REGDOMAIN_COUNT;
698
699 if (NULL == countryCode)
700 {
701 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
702 ("Country code array is NULL\r\n") );
703 return VOS_STATUS_E_FAULT;
704 }
705 if (0 == countryInfoTable.countryCount)
706 {
707 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
708 ("Reg domain table is empty\r\n") );
709 return VOS_STATUS_E_EMPTY;
710 }
711 // iterate the country info table until end of table or the country code
712 // is found
713 for (i = 0; i < countryInfoTable.countryCount &&
714 REGDOMAIN_COUNT == *pRegDomain; i++)
715 {
716 if (memcmp(countryCode, countryInfoTable.countryInfo[i].countryCode,
717 VOS_COUNTRY_CODE_LEN) == 0)
718 {
719 // country code is found
720 *pRegDomain = countryInfoTable.countryInfo[i].regDomain;
721 }
722 }
723 if (REGDOMAIN_COUNT != *pRegDomain)
724 {
725 return VOS_STATUS_SUCCESS;
726 }
727 else
728 {
729 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_WARN,
730 ("country code is not found\r\n"));
731 return VOS_STATUS_E_EXISTS;
732 }
733}
734/**------------------------------------------------------------------------
735 \brief vos_nv_getSupportedCountryCode() - get the list of supported
736 country codes
737 The \a vos_nv_getSupportedCountryCode() encodes the list of supported
738 country codes with paddings in the provided buffer
739 \param pBuffer - pointer to buffer where supported country codes
740 and paddings are encoded; this may be set to NULL
741 if user wishes to query the required buffer size to
742 get the country code list
743 \param pBufferSize - this is the provided buffer size on input;
744 this is the required or consumed buffer size on output
745 \return VOS_STATUS_SUCCESS - country codes are successfully encoded
746 VOS_STATUS_E_NOMEM - country codes are not encoded because either
747 the buffer is NULL or buffer size is
748 sufficient
749 \sa
750 -------------------------------------------------------------------------*/
751VOS_STATUS vos_nv_getSupportedCountryCode( v_BYTE_t *pBuffer, v_SIZE_t *pBufferSize,
752 v_SIZE_t paddingSize )
753{
754 v_SIZE_t providedBufferSize = *pBufferSize;
755 int i;
756 // pBufferSize now points to the required buffer size
757 *pBufferSize = countryInfoTable.countryCount * (VOS_COUNTRY_CODE_LEN + paddingSize );
758 if ( NULL == pBuffer || providedBufferSize < *pBufferSize )
759 {
760 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
761 ("Insufficient memory for country code list\r\n"));
762 return VOS_STATUS_E_NOMEM;
763 }
764 for (i = 0; i < countryInfoTable.countryCount; i++)
765 {
766 memcpy( pBuffer, countryInfoTable.countryInfo[i].countryCode, VOS_COUNTRY_CODE_LEN );
767 pBuffer += (VOS_COUNTRY_CODE_LEN + paddingSize );
768 }
769 return VOS_STATUS_SUCCESS;
770}
771/**------------------------------------------------------------------------
772 \brief vos_nv_readTxAntennaCount() - return number of TX antenna
773 \param pTxAntennaCount - antenna count
774 \return status of the NV read operation
775 \sa
776 -------------------------------------------------------------------------*/
777VOS_STATUS vos_nv_readTxAntennaCount( v_U8_t *pTxAntennaCount )
778{
779 sNvFields fieldImage;
780 VOS_STATUS status;
781 status = vos_nv_read( VNV_FIELD_IMAGE, &fieldImage, NULL,
782 sizeof(fieldImage) );
783 if (VOS_STATUS_SUCCESS == status)
784 {
785 *pTxAntennaCount = fieldImage.numOfTxChains;
786 }
787 return status;
788}
789/**------------------------------------------------------------------------
790 \brief vos_nv_readRxAntennaCount() - return number of RX antenna
791 \param pRxAntennaCount - antenna count
792 \return status of the NV read operation
793 \sa
794 -------------------------------------------------------------------------*/
795VOS_STATUS vos_nv_readRxAntennaCount( v_U8_t *pRxAntennaCount )
796{
797 sNvFields fieldImage;
798 VOS_STATUS status;
799 status = vos_nv_read( VNV_FIELD_IMAGE, &fieldImage, NULL,
800 sizeof(fieldImage) );
801 if (VOS_STATUS_SUCCESS == status)
802 {
803 *pRxAntennaCount = fieldImage.numOfRxChains;
804 }
805 return status;
806}
807
808/**------------------------------------------------------------------------
809 \brief vos_nv_readMacAddress() - return the MAC address
810 \param pMacAddress - MAC address
811 \return status of the NV read operation
812 \sa
813 -------------------------------------------------------------------------*/
814VOS_STATUS vos_nv_readMacAddress( v_MAC_ADDRESS_t pMacAddress )
815{
816 sNvFields fieldImage;
817 VOS_STATUS status;
818 status = vos_nv_read( VNV_FIELD_IMAGE, &fieldImage, NULL,
819 sizeof(fieldImage) );
820 if (VOS_STATUS_SUCCESS == status)
821 {
822 memcpy( pMacAddress, fieldImage.macAddr, VOS_MAC_ADDRESS_LEN );
823 }
824 else
825 {
826 //This part of the code can be removed when NV is programmed
827 const v_U8_t macAddr[VOS_MAC_ADDRESS_LEN] = VOS_HARD_CODED_MAC;
828 memcpy( pMacAddress, macAddr, VOS_MAC_ADDRESS_LEN );
829 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_WARN,
830 " fail to get MAC address from NV, hardcoded to %02X-%02X-%02X-%02X-%02X%02X",
831 macAddr[0], macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]);
832 status = VOS_STATUS_SUCCESS;
833 }
834 return status;
835}
836
837/**------------------------------------------------------------------------
838
839 \brief vos_nv_readMultiMacAddress() - return the Multiple MAC addresses
840
841 \param pMacAddress - MAC address
842 \param macCount - Count of valid MAC addresses to get from NV field
843
844 \return status of the NV read operation
845
846 \sa
847
848 -------------------------------------------------------------------------*/
849VOS_STATUS vos_nv_readMultiMacAddress( v_U8_t *pMacAddress,
850 v_U8_t macCount )
851{
852 sNvFields fieldImage;
853 VOS_STATUS status;
854 v_U8_t countLoop;
855 v_U8_t *pNVMacAddress;
856
857 if((0 == macCount) || (VOS_MAX_CONCURRENCY_PERSONA < macCount) ||
858 (NULL == pMacAddress))
859 {
860 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
861 " Invalid Parameter from NV Client macCount %d, pMacAddress 0x%x",
862 macCount, pMacAddress);
863 }
864
865 status = vos_nv_read( VNV_FIELD_IMAGE, &fieldImage, NULL,
866 sizeof(fieldImage) );
867 if (VOS_STATUS_SUCCESS == status)
868 {
869 pNVMacAddress = fieldImage.macAddr;
870 for(countLoop = 0; countLoop < macCount; countLoop++)
871 {
872 vos_mem_copy(pMacAddress + (countLoop * VOS_MAC_ADDRESS_LEN),
873 pNVMacAddress + (countLoop * VOS_MAC_ADDRESS_LEN),
874 VOS_MAC_ADDRESS_LEN);
875 }
876 }
877 else
878 {
879 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
880 "vos_nv_readMultiMacAddress Get NV Field Fail");
881 }
882
883 return status;
884}
885
886/**------------------------------------------------------------------------
887 \brief vos_nv_setValidity() - set the validity of an NV item.
888 The \a vos_nv_setValidity() validates and invalidates an NV item. The
889 validity information is stored in NV memory.
890 One would get the VOS_STATUS_E_EXISTS error when reading an invalid item.
891 An item becomes valid when one has written to it successfully.
892 \param type - NV item type
893 \param itemIsValid - boolean value indicating the item's validity
894 \return VOS_STATUS_SUCCESS - validity is set successfully
895 VOS_STATUS_E_INVAL - one of the parameters is invalid
896 VOS_STATUS_E_FAILURE - unknown error
897 \sa
898 -------------------------------------------------------------------------*/
899#ifndef WLAN_FTM_STUB
900
901VOS_STATUS vos_nv_setValidity( VNV_TYPE type, v_BOOL_t itemIsValid )
902{
903 v_U32_t lastNvValidityBitmap;
904 v_U32_t newNvValidityBitmap;
905 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]906
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]907 // check if the current NV type is valid
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]908 if (VNV_TYPE_COUNT <= type)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]909 {
910 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]911 ("%s: invalid type=%d"), __FUNCTION__, type );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]912 return VOS_STATUS_E_INVAL;
913 }
914 // read the validity bitmap
915 lastNvValidityBitmap = gnvEFSTable->nvValidityBitmap;
916 // modify the validity bitmap
917 if (itemIsValid)
918 {
919 newNvValidityBitmap = lastNvValidityBitmap | (1 << type);
920 // commit to NV store if bitmap has been modified
921 if (newNvValidityBitmap != lastNvValidityBitmap)
922 {
923 gnvEFSTable->nvValidityBitmap = newNvValidityBitmap;
924 }
925 }
926 else
927 {
928 newNvValidityBitmap = lastNvValidityBitmap & (~(1 << type));
929 if (newNvValidityBitmap != lastNvValidityBitmap)
930 {
931 gnvEFSTable->nvValidityBitmap = newNvValidityBitmap;
932 status = wlan_write_to_efs((v_U8_t*)gnvEFSTable,sizeof(nvEFSTable_t));
933 if (! VOS_IS_STATUS_SUCCESS(status)) {
934 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, ("vos_nv_write_to_efs failed!!!\r\n"));
935 status = VOS_STATUS_E_FAULT;
936 }
937 }
938 }
939
940 return status;
941}
942#endif
943/**------------------------------------------------------------------------
944 \brief vos_nv_getValidity() - get the validity of an NV item.
945 The \a vos_nv_getValidity() indicates if an NV item is valid. The
946 validity information is stored in NV memory.
947 One would get the VOS_STATUS_E_EXISTS error when reading an invalid item.
948 An item becomes valid when one has written to it successfully.
949 \param type - NV item type
950 \param pItemIsValid- pointer to the boolean value indicating the item's
951 validity
952 \return VOS_STATUS_SUCCESS - validity is determined successfully
953 VOS_STATUS_E_INVAL - one of the parameters is invalid
954 VOS_STATUS_E_FAILURE - unknown error
955 \sa
956 -------------------------------------------------------------------------*/
957VOS_STATUS vos_nv_getValidity( VNV_TYPE type, v_BOOL_t *pItemIsValid )
958{
959 v_U32_t nvValidityBitmap = gnvEFSTable->nvValidityBitmap;
960 // check if the current NV type is valid
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]961 if (VNV_TYPE_COUNT <= type)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]962 {
963 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]964 ("%s: invalid type=%d"), __FUNCTION__, type );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]965 return VOS_STATUS_E_INVAL;
966 }
967 *pItemIsValid = (v_BOOL_t)((nvValidityBitmap >> type) & 1);
968 return VOS_STATUS_SUCCESS;
969}
970/**------------------------------------------------------------------------
971 \brief vos_nv_read() - read a NV item to an output buffer
972 The \a vos_nv_read() reads a NV item to an output buffer. If the item is
973 an array, this function would read the entire array. One would get a
974 VOS_STATUS_E_EXISTS error when reading an invalid item.
975 For error conditions of VOS_STATUS_E_EXISTS and VOS_STATUS_E_FAILURE,
976 if a default buffer is provided (with a non-NULL value),
977 the default buffer content is copied to the output buffer.
978 \param type - NV item type
979 \param outputBuffer - output buffer
980 \param defaultBuffer - default buffer
981 \param bufferSize - output buffer size
982 \return VOS_STATUS_SUCCESS - NV item is read successfully
983 VOS_STATUS_E_INVAL - one of the parameters is invalid
984 VOS_STATUS_E_FAULT - defaultBuffer point is NULL
985 VOS_STATUS_E_EXISTS - NV type is unsupported
986 VOS_STATUS_E_FAILURE - unknown error
987 \sa
988 -------------------------------------------------------------------------*/
989VOS_STATUS vos_nv_read( VNV_TYPE type, v_VOID_t *outputVoidBuffer,
990 v_VOID_t *defaultBuffer, v_SIZE_t bufferSize )
991{
992 VOS_STATUS status = VOS_STATUS_SUCCESS;
993 v_SIZE_t itemSize;
994 v_BOOL_t itemIsValid = VOS_TRUE;
995
996 // sanity check
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]997 if (VNV_TYPE_COUNT <= type)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]998 {
999 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]1000 ("%s: invalid type=%d"), __FUNCTION__, type );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1001 return VOS_STATUS_E_INVAL;
1002 }
1003 if (NULL == outputVoidBuffer)
1004 {
1005 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1006 ("Buffer provided is NULL\r\n") );
1007 return VOS_STATUS_E_FAULT;
1008 }
1009 if (0 == bufferSize)
1010 {
1011 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1012 ("NV type=%d is invalid\r\n"), type );
1013 return VOS_STATUS_E_INVAL;
1014 }
1015 // check if the NV item has valid data
1016 status = vos_nv_getValidity( type, &itemIsValid );
1017 if (!itemIsValid)
1018 {
1019 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_WARN,
1020 "NV type=%d does not have valid data\r\n", type );
1021 return VOS_STATUS_E_EMPTY;
1022 }
1023 switch(type)
1024 {
1025 case VNV_FIELD_IMAGE:
1026 itemSize = sizeof(gnvEFSTable->halnv.fields);
1027 if(bufferSize != itemSize) {
1028 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1029 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1030 itemSize);
1031 status = VOS_STATUS_E_INVAL;
1032 }
1033 else {
1034 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.fields,bufferSize);
1035 }
1036 break;
1037 case VNV_RATE_TO_POWER_TABLE:
1038 itemSize = sizeof(gnvEFSTable->halnv.tables.pwrOptimum);
1039 if(bufferSize != itemSize) {
1040 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1041 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1042 itemSize);
1043 status = VOS_STATUS_E_INVAL;
1044 }
1045 else {
1046 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.pwrOptimum[0],bufferSize);
1047 }
1048 break;
1049 case VNV_REGULARTORY_DOMAIN_TABLE:
1050 itemSize = sizeof(gnvEFSTable->halnv.tables.regDomains);
1051 if(bufferSize != itemSize) {
1052 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1053 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1054 itemSize);
1055 status = VOS_STATUS_E_INVAL;
1056 }
1057 else {
1058 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.regDomains[0],bufferSize);
1059 }
1060 break;
1061 case VNV_DEFAULT_LOCATION:
1062 itemSize = sizeof(gnvEFSTable->halnv.tables.defaultCountryTable);
1063 if(bufferSize != itemSize) {
1064 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1065 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1066 itemSize);
1067 status = VOS_STATUS_E_INVAL;
1068 }
1069 else {
1070 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.defaultCountryTable,bufferSize);
1071 }
1072 break;
1073 case VNV_TPC_POWER_TABLE:
1074 itemSize = sizeof(gnvEFSTable->halnv.tables.plutCharacterized);
1075 if(bufferSize != itemSize) {
1076 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1077 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1078 itemSize);
1079 status = VOS_STATUS_E_INVAL;
1080 }
1081 else {
1082 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.plutCharacterized[0],bufferSize);
1083 }
1084 break;
1085 case VNV_TPC_PDADC_OFFSETS:
1086 itemSize = sizeof(gnvEFSTable->halnv.tables.plutPdadcOffset);
1087 if(bufferSize != itemSize) {
1088 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1089 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1090 itemSize);
1091 status = VOS_STATUS_E_INVAL;
1092 }
1093 else {
1094 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.plutPdadcOffset[0],bufferSize);
1095 }
1096 break;
1097 case VNV_RSSI_CHANNEL_OFFSETS:
1098
1099 itemSize = sizeof(gnvEFSTable->halnv.tables.rssiChanOffsets);
1100
1101 if(bufferSize != itemSize) {
1102
1103 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1104 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1105 itemSize);
1106 status = VOS_STATUS_E_INVAL;
1107 }
1108 else {
1109 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.rssiChanOffsets[0],bufferSize);
1110 }
1111 break;
1112 case VNV_RF_CAL_VALUES:
1113
1114 itemSize = sizeof(gnvEFSTable->halnv.tables.rFCalValues);
1115
1116 if(bufferSize != itemSize) {
1117
1118 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1119 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1120 itemSize);
1121 status = VOS_STATUS_E_INVAL;
1122 }
1123 else {
1124 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.rFCalValues,bufferSize);
1125 }
1126 break;
1127 case VNV_ANTENNA_PATH_LOSS:
1128 itemSize = sizeof(gnvEFSTable->halnv.tables.antennaPathLoss);
1129 if(bufferSize != itemSize) {
1130 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1131 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1132 itemSize);
1133 status = VOS_STATUS_E_INVAL;
1134 }
1135 else {
1136 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.antennaPathLoss[0],bufferSize);
1137 }
1138 break;
1139 case VNV_PACKET_TYPE_POWER_LIMITS:
1140 itemSize = sizeof(gnvEFSTable->halnv.tables.pktTypePwrLimits);
1141 if(bufferSize != itemSize) {
1142 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1143 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1144 itemSize);
1145 status = VOS_STATUS_E_INVAL;
1146 }
1147 else {
1148 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.pktTypePwrLimits[0][0],bufferSize);
1149 }
1150 break;
1151 case VNV_OFDM_CMD_PWR_OFFSET:
1152 itemSize = sizeof(gnvEFSTable->halnv.tables.ofdmCmdPwrOffset);
1153 if(bufferSize != itemSize) {
1154 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1155 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1156 itemSize);
1157 status = VOS_STATUS_E_INVAL;
1158 }
1159 else {
1160 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.ofdmCmdPwrOffset,bufferSize);
1161 }
1162 break;
1163 case VNV_TX_BB_FILTER_MODE:
1164 itemSize = sizeof(gnvEFSTable->halnv.tables.txbbFilterMode);
1165 if(bufferSize != itemSize) {
1166 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1167 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1168 itemSize);
1169 status = VOS_STATUS_E_INVAL;
1170 }
1171 else {
1172 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.txbbFilterMode,bufferSize);
1173 }
1174 break;
1175
1176#ifdef FEATURE_WLAN_NON_INTEGRATED_SOC
1177 case VNV_FREQUENCY_FOR_1_3V_SUPPLY:
1178 itemSize = sizeof(gnvEFSTable->halnv.tables.freqFor1p3VSupply);
1179 if(bufferSize != itemSize) {
1180 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1181 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1182 itemSize);
1183 status = VOS_STATUS_E_INVAL;
1184 }
1185 else {
1186 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.freqFor1p3VSupply,bufferSize);
1187 }
1188 break;
1189#endif /* FEATURE_WLAN_NON_INTEGRATED_SOC */
1190
1191 case VNV_TABLE_VIRTUAL_RATE:
1192 itemSize = sizeof(gnvEFSTable->halnv.tables.pwrOptimum_virtualRate);
1193 if(bufferSize != itemSize) {
1194 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1195 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1196 itemSize);
1197 status = VOS_STATUS_E_INVAL;
1198 }
1199 else {
1200 memcpy(outputVoidBuffer,&gnvEFSTable->halnv.tables.pwrOptimum_virtualRate,bufferSize);
1201 }
1202 break;
1203
1204 default:
1205 break;
1206 }
1207 return status;
1208}
1209#ifndef WLAN_FTM_STUB
1210
1211/**------------------------------------------------------------------------
1212 \brief vos_nv_write() - write to a NV item from an input buffer
1213 The \a vos_nv_write() writes to a NV item from an input buffer. This would
1214 validate the NV item if the write operation is successful.
1215 \param type - NV item type
1216 \param inputBuffer - input buffer
1217 \param inputBufferSize - input buffer size
1218 \return VOS_STATUS_SUCCESS - NV item is read successfully
1219 VOS_STATUS_E_INVAL - one of the parameters is invalid
1220 VOS_STATUS_E_FAULT - outputBuffer pointer is NULL
1221 VOS_STATUS_E_EXISTS - NV type is unsupported
1222 VOS_STATUS_E_FAILURE - unknown error
1223 \sa
1224 -------------------------------------------------------------------------*/
1225VOS_STATUS vos_nv_write( VNV_TYPE type, v_VOID_t *inputVoidBuffer,
1226 v_SIZE_t bufferSize )
1227{
1228 VOS_STATUS status = VOS_STATUS_SUCCESS;
1229 v_SIZE_t itemSize;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]1230
1231 // sanity check
1232 if (VNV_TYPE_COUNT <= type)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1233 {
1234 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]1235 ("%s: invalid type=%d"), __FUNCTION__, type );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1236 return VOS_STATUS_E_INVAL;
1237 }
1238 if (NULL == inputVoidBuffer)
1239 {
1240 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1241 ("Buffer provided is NULL\r\n") );
1242 return VOS_STATUS_E_FAULT;
1243 }
1244 if (0 == bufferSize)
1245 {
1246 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1247 ("NV type=%d is invalid\r\n"), type );
1248 return VOS_STATUS_E_INVAL;
1249 }
1250 switch(type)
1251 {
1252 case VNV_FIELD_IMAGE:
1253 itemSize = sizeof(gnvEFSTable->halnv.fields);
1254 if(bufferSize != itemSize) {
1255 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1256 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1257 itemSize);
1258 status = VOS_STATUS_E_INVAL;
1259 }
1260 else {
1261 memcpy(&gnvEFSTable->halnv.fields,inputVoidBuffer,bufferSize);
1262 }
1263 break;
1264 case VNV_RATE_TO_POWER_TABLE:
1265 itemSize = sizeof(gnvEFSTable->halnv.tables.pwrOptimum);
1266 if(bufferSize != itemSize) {
1267 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1268 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1269 itemSize);
1270 status = VOS_STATUS_E_INVAL;
1271 }
1272 else {
1273 memcpy(&gnvEFSTable->halnv.tables.pwrOptimum[0],inputVoidBuffer,bufferSize);
1274 }
1275 break;
1276 case VNV_REGULARTORY_DOMAIN_TABLE:
1277 itemSize = sizeof(gnvEFSTable->halnv.tables.regDomains);
1278 if(bufferSize != itemSize) {
1279 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1280 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1281 itemSize);
1282 status = VOS_STATUS_E_INVAL;
1283 }
1284 else {
1285 memcpy(&gnvEFSTable->halnv.tables.regDomains[0],inputVoidBuffer,bufferSize);
1286 }
1287 break;
1288 case VNV_DEFAULT_LOCATION:
1289 itemSize = sizeof(gnvEFSTable->halnv.tables.defaultCountryTable);
1290 if(bufferSize != itemSize) {
1291 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1292 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1293 itemSize);
1294 status = VOS_STATUS_E_INVAL;
1295 }
1296 else {
1297 memcpy(&gnvEFSTable->halnv.tables.defaultCountryTable,inputVoidBuffer,bufferSize);
1298 }
1299 break;
1300 case VNV_TPC_POWER_TABLE:
1301 itemSize = sizeof(gnvEFSTable->halnv.tables.plutCharacterized);
1302 if(bufferSize != itemSize) {
1303 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1304 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1305 itemSize);
1306 status = VOS_STATUS_E_INVAL;
1307 }
1308 else {
1309 memcpy(&gnvEFSTable->halnv.tables.plutCharacterized[0],inputVoidBuffer,bufferSize);
1310 }
1311 break;
1312 case VNV_TPC_PDADC_OFFSETS:
1313 itemSize = sizeof(gnvEFSTable->halnv.tables.plutPdadcOffset);
1314 if(bufferSize != itemSize) {
1315 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1316 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1317 itemSize);
1318 status = VOS_STATUS_E_INVAL;
1319 }
1320 else {
1321 memcpy(&gnvEFSTable->halnv.tables.plutPdadcOffset[0],inputVoidBuffer,bufferSize);
1322 }
1323 break;
1324 case VNV_RSSI_CHANNEL_OFFSETS:
1325
1326 itemSize = sizeof(gnvEFSTable->halnv.tables.rssiChanOffsets);
1327
1328 if(bufferSize != itemSize) {
1329
1330 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1331 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1332 itemSize);
1333 status = VOS_STATUS_E_INVAL;
1334 }
1335 else {
1336 memcpy(&gnvEFSTable->halnv.tables.rssiChanOffsets[0],inputVoidBuffer,bufferSize);
1337 }
1338 break;
1339 case VNV_RF_CAL_VALUES:
1340
1341 itemSize = sizeof(gnvEFSTable->halnv.tables.rFCalValues);
1342
1343 if(bufferSize != itemSize) {
1344
1345 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1346 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1347 itemSize);
1348 status = VOS_STATUS_E_INVAL;
1349 }
1350 else {
1351 memcpy(&gnvEFSTable->halnv.tables.rFCalValues,inputVoidBuffer,bufferSize);
1352 }
1353 break;
1354 case VNV_ANTENNA_PATH_LOSS:
1355 itemSize = sizeof(gnvEFSTable->halnv.tables.antennaPathLoss);
1356 if(bufferSize != itemSize) {
1357 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1358 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1359 itemSize);
1360 status = VOS_STATUS_E_INVAL;
1361 }
1362 else {
1363 memcpy(&gnvEFSTable->halnv.tables.antennaPathLoss[0],inputVoidBuffer,bufferSize);
1364 }
1365 break;
1366
1367 case VNV_PACKET_TYPE_POWER_LIMITS:
1368 itemSize = sizeof(gnvEFSTable->halnv.tables.pktTypePwrLimits);
1369 if(bufferSize != itemSize) {
1370 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1371 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1372 itemSize);
1373 status = VOS_STATUS_E_INVAL;
1374 }
1375 else {
1376 memcpy(&gnvEFSTable->halnv.tables.pktTypePwrLimits[0][0],inputVoidBuffer,bufferSize);
1377 }
1378 break;
1379
1380 case VNV_OFDM_CMD_PWR_OFFSET:
1381 itemSize = sizeof(gnvEFSTable->halnv.tables.ofdmCmdPwrOffset);
1382 if(bufferSize != itemSize) {
1383 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1384 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1385 itemSize);
1386 status = VOS_STATUS_E_INVAL;
1387 }
1388 else {
1389 memcpy(&gnvEFSTable->halnv.tables.ofdmCmdPwrOffset,inputVoidBuffer,bufferSize);
1390 }
1391 break;
1392
1393 case VNV_TX_BB_FILTER_MODE:
1394 itemSize = sizeof(gnvEFSTable->halnv.tables.txbbFilterMode);
1395 if(bufferSize != itemSize) {
1396 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1397 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1398 itemSize);
1399 status = VOS_STATUS_E_INVAL;
1400 }
1401 else {
1402 memcpy(&gnvEFSTable->halnv.tables.txbbFilterMode,inputVoidBuffer,bufferSize);
1403 }
1404 break;
1405
1406#ifdef FEATURE_WLAN_NON_INTEGRATED_SOC
1407 case VNV_FREQUENCY_FOR_1_3V_SUPPLY:
1408 itemSize = sizeof(gnvEFSTable->halnv.tables.freqFor1p3VSupply);
1409 if(bufferSize != itemSize) {
1410 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1411 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1412 itemSize);
1413 status = VOS_STATUS_E_INVAL;
1414 }
1415 else {
1416 memcpy(&gnvEFSTable->halnv.tables.freqFor1p3VSupply,inputVoidBuffer,bufferSize);
1417 }
1418 break;
1419#endif /* FEATURE_WLAN_NON_INTEGRATED_SOC */
1420
1421 case VNV_TABLE_VIRTUAL_RATE:
1422 itemSize = sizeof(gnvEFSTable->halnv.tables.pwrOptimum_virtualRate);
1423 if(bufferSize != itemSize) {
1424 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1425 ("type = %d buffer size=%d is less than data size=%d\r\n"),type, bufferSize,
1426 itemSize);
1427 status = VOS_STATUS_E_INVAL;
1428 }
1429 else {
1430 memcpy(&gnvEFSTable->halnv.tables.pwrOptimum_virtualRate,inputVoidBuffer,bufferSize);
1431 }
1432 break;
1433
1434 default:
1435 break;
1436 }
1437 if (VOS_STATUS_SUCCESS == status)
1438 {
1439 // set NV item to have valid data
1440 status = vos_nv_setValidity( type, VOS_TRUE );
1441 if (! VOS_IS_STATUS_SUCCESS(status)) {
1442 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, ("vos_nv_setValidity failed!!!\r\n"));
1443 status = VOS_STATUS_E_FAULT;
1444 }
1445 status = wlan_write_to_efs((v_U8_t*)gnvEFSTable,sizeof(nvEFSTable_t));
1446
1447 if (! VOS_IS_STATUS_SUCCESS(status)) {
1448 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, ("vos_nv_write_to_efs failed!!!\r\n"));
1449 status = VOS_STATUS_E_FAULT;
1450 }
1451 }
1452 return status;
1453}
1454#endif
1455
1456/**------------------------------------------------------------------------
1457 \brief vos_nv_getChannelListWithPower() - function to return the list of
1458 supported channels with the power limit info too.
1459 \param pChannels20MHz - list of 20 Mhz channels
1460 \param pNum20MHzChannelsFound - number of 20 Mhz channels
1461 \param pChannels40MHz - list of 20 Mhz channels
1462 \param pNum40MHzChannelsFound - number of 20 Mhz channels
1463 \return status of the NV read operation
1464 \Note: 40Mhz not currently supported
1465 \sa
1466 -------------------------------------------------------------------------*/
1467VOS_STATUS vos_nv_getChannelListWithPower(tChannelListWithPower *channels20MHz /*[NUM_LEGIT_RF_CHANNELS] */,
1468 tANI_U8 *num20MHzChannelsFound,
1469 tChannelListWithPower *channels40MHz /*[NUM_CHAN_BOND_CHANNELS] */,
1470 tANI_U8 *num40MHzChannelsFound
1471 )
1472{
1473 VOS_STATUS status = VOS_STATUS_SUCCESS;
1474 int i, count;
1475
1476 //TODO: Dont want to use pMac here...can we instead store the curRegDomain in NV
1477 // or pass it as a parameter to NV from SME?
1478
1479 if( channels20MHz && num20MHzChannelsFound )
1480 {
1481 count = 0;
1482 for( i = 0; i <= RF_CHAN_14; i++ )
1483 {
1484 if( regChannels[i].enabled )
1485 {
1486 channels20MHz[count].chanId = rfChannels[i].channelNum;
1487 channels20MHz[count++].pwr = regChannels[i].pwrLimit;
1488 }
1489 }
1490#ifdef FEATURE_WLAN_INTEGRATED_SOC
1491 for( i = RF_CHAN_36; i <= RF_CHAN_165; i++ )
1492 {
1493 if( regChannels[i].enabled )
1494 {
1495 channels20MHz[count].chanId = rfChannels[i].channelNum;
1496 channels20MHz[count++].pwr = regChannels[i].pwrLimit;
1497 }
1498 }
1499#endif
1500 *num20MHzChannelsFound = (tANI_U8)count;
1501 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]1502
1503 if( channels40MHz && num40MHzChannelsFound )
1504 {
1505 count = 0;
1506#ifdef FEATURE_WLAN_INTEGRATED_SOC
1507 //center channels for 2.4 Ghz 40 MHz channels
1508 for( i = RF_CHAN_BOND_3; i <= RF_CHAN_BOND_11; i++ )
1509 {
1510
1511 if( regChannels[i].enabled )
1512 {
1513 channels40MHz[count].chanId = rfChannels[i].channelNum;
1514 channels40MHz[count++].pwr = regChannels[i].pwrLimit;
1515 }
1516 }
1517 //center channels for 5 Ghz 40 MHz channels
1518 for( i = RF_CHAN_BOND_38; i <= RF_CHAN_BOND_163; i++ )
1519 {
1520
1521 if( regChannels[i].enabled )
1522 {
1523 channels40MHz[count].chanId = rfChannels[i].channelNum;
1524 channels40MHz[count++].pwr = regChannels[i].pwrLimit;
1525 }
1526 }
1527#endif
1528 *num40MHzChannelsFound = (tANI_U8)count;
1529 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1530 return (status);
1531}
1532
1533/**------------------------------------------------------------------------
1534 \brief vos_nv_getDefaultRegDomain() - return the default regulatory domain
1535 \return default regulatory domain
1536 \sa
1537 -------------------------------------------------------------------------*/
1538
1539v_REGDOMAIN_t vos_nv_getDefaultRegDomain( void )
1540{
1541 return countryInfoTable.countryInfo[0].regDomain;
1542}
1543
1544/**------------------------------------------------------------------------
1545 \brief vos_nv_getSupportedChannels() - function to return the list of
1546 supported channels
1547 \param p20MhzChannels - list of 20 Mhz channels
1548 \param pNum20MhzChannels - number of 20 Mhz channels
1549 \param p40MhzChannels - list of 40 Mhz channels
1550 \param pNum40MhzChannels - number of 40 Mhz channels
1551 \return status of the NV read operation
1552 \Note: 40Mhz not currently supported
1553 \sa
1554 -------------------------------------------------------------------------*/
1555VOS_STATUS vos_nv_getSupportedChannels( v_U8_t *p20MhzChannels, int *pNum20MhzChannels,
1556 v_U8_t *p40MhzChannels, int *pNum40MhzChannels)
1557{
1558 VOS_STATUS status = VOS_STATUS_E_INVAL;
1559 int i, count = 0;
1560
1561 if( p20MhzChannels && pNum20MhzChannels )
1562 {
1563 if( *pNum20MhzChannels >= NUM_RF_CHANNELS )
1564 {
1565 for( i = 0; i <= RF_CHAN_14; i++ )
1566 {
1567 p20MhzChannels[count++] = rfChannels[i].channelNum;
1568 }
1569#ifdef FEATURE_WLAN_INTEGRATED_SOC
1570 for( i = RF_CHAN_36; i <= RF_CHAN_165; i++ )
1571 {
1572 p20MhzChannels[count++] = rfChannels[i].channelNum;
1573 }
1574#endif
1575 status = VOS_STATUS_SUCCESS;
1576 }
1577 *pNum20MhzChannels = count;
1578 }
1579
1580 return (status);
1581}
1582
1583/**------------------------------------------------------------------------
1584 \brief vos_nv_readDefaultCountryTable() - return the default Country table
1585 \param table data - a union to return the default country table data in.
1586 \return status of the NV read operation
1587 \sa
1588 -------------------------------------------------------------------------*/
1589VOS_STATUS vos_nv_readDefaultCountryTable( uNvTables *tableData )
1590{
1591
1592 VOS_STATUS status;
1593
1594 status = vos_nv_read( VNV_DEFAULT_LOCATION, tableData, NULL, sizeof(sDefaultCountry) );
1595
1596 return status;
1597}
1598
1599/**------------------------------------------------------------------------
1600 \brief vos_nv_getBuffer -
1601 \param pBuffer - to return the buffer address
1602 pSize - buffer size.
1603 \return status of the NV read operation
1604 \sa
1605 -------------------------------------------------------------------------*/
1606VOS_STATUS vos_nv_getNVBuffer(v_VOID_t **pNvBuffer,v_SIZE_t *pSize)
1607{
1608
1609 /* Send the NV structure and size */
1610 *pNvBuffer = (v_VOID_t *)(&pnvEFSTable->halnv);
1611 *pSize = sizeof(sHalNv);
1612
1613 return VOS_STATUS_SUCCESS;
1614}
1615
1616#ifdef FEATURE_WLAN_INTEGRATED_SOC
1617/**------------------------------------------------------------------------
1618 \brief vos_nv_setRegDomain -
1619 \param clientCtxt - Client Context, Not used for PRIMA
1620 regId - Regulatory Domain ID
1621 \return status set REG domain operation
1622 \sa
1623 -------------------------------------------------------------------------*/
1624VOS_STATUS vos_nv_setRegDomain(void * clientCtxt, v_REGDOMAIN_t regId)
1625{
1626 /* Client Context Argumant not used for PRIMA */
1627 if(regId >= REGDOMAIN_COUNT)
1628 {
1629 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1630 "VOS set reg domain, invalid REG domain ID %d", regId);
1631 return VOS_STATUS_E_INVAL;
1632 }
1633
1634 /* Set correct channel information based on REG Domain */
1635 regChannels = pnvEFSTable->halnv.tables.regDomains[regId].channels;
1636
1637 return VOS_STATUS_SUCCESS;
1638}
1639
1640/**------------------------------------------------------------------------
1641 \brief vos_nv_getChannelEnabledState -
1642 \param rfChannel - input channel enum to know evabled state
1643 \return eNVChannelEnabledType enabled state for channel
1644 * enabled
1645 * disabled
1646 * DFS
1647 \sa
1648 -------------------------------------------------------------------------*/
1649eNVChannelEnabledType vos_nv_getChannelEnabledState
1650(
1651 v_U32_t rfChannel
1652)
1653{
1654 v_U32_t channelLoop;
1655 eRfChannels channelEnum = INVALID_RF_CHANNEL;
1656
1657 for(channelLoop = 0; channelLoop <= RF_CHAN_165; channelLoop++)
1658 {
1659 if(rfChannels[channelLoop].channelNum == rfChannel)
1660 {
1661 channelEnum = (eRfChannels)channelLoop;
1662 break;
1663 }
1664 }
1665
1666 if(INVALID_RF_CHANNEL == channelEnum)
1667 {
1668 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
1669 "vos_nv_getChannelEnabledState, invalid cahnnel %d", rfChannel);
1670 return NV_CHANNEL_INVALID;
1671 }
1672
1673 return regChannels[channelEnum].enabled;
1674}
1675#endif /* FEATURE_WLAN_NON_INTEGRATED_SOC */