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