1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
5 **| All rights reserved. |**
6 **| |**
7 **| Redistribution and use in source and binary forms, with or without |**
8 **| modification, are permitted provided that the following conditions |**
9 **| are met: |**
10 **| |**
11 **| * Redistributions of source code must retain the above copyright |**
12 **| notice, this list of conditions and the following disclaimer. |**
13 **| * Redistributions in binary form must reproduce the above copyright |**
14 **| notice, this list of conditions and the following disclaimer in |**
15 **| the documentation and/or other materials provided with the |**
16 **| distribution. |**
17 **| * Neither the name Texas Instruments nor the names of its |**
18 **| contributors may be used to endorse or promote products derived |**
19 **| from this software without specific prior written permission. |**
20 **| |**
21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
32 **| |**
33 **+-----------------------------------------------------------------------+**
34 ****************************************************************************/
35 /**************************************************************************/
36 /* */
37 /* MODULE: whalHwEeprom.c */
38 /* PURPOSE: Wlan hardware EEPROM access routines implemenatation */
39 /* */
40 /**************************************************************************/
41 #include "whalCommon.h"
42 #include "whalHwDefs.h"
43 #include "whalHwEeprom.h"
44 #include "TNETWIF.h"
45
46
47 /****************************************************************************
48 * whal_hwEeprom_Create()
49 ****************************************************************************
50 * DESCRIPTION: Create the wlan hardware eeprom access object
51 *
52 * INPUTS:
53 *
54 * OUTPUT: None
55 *
56 * RETURNS: The Created object
57 ****************************************************************************/
whal_hwEeprom_Create(TI_HANDLE hOs)58 HwEeprom_T *whal_hwEeprom_Create(TI_HANDLE hOs)
59 {
60 HwEeprom_T *pObj;
61
62 pObj = os_memoryAlloc(hOs, sizeof(HwEeprom_T));
63 if (pObj == NULL)
64 return NULL;
65
66 os_memoryZero(hOs, pObj, sizeof(HwEeprom_T));
67
68 pObj->hOs = hOs;
69
70 return(pObj);
71 }
72
73 /****************************************************************************
74 * whal_hwEeprom_Destroy()
75 ****************************************************************************
76 * DESCRIPTION: Destroy the object
77 *
78 * INPUTS:
79 * pHwEeprom The object to free
80 *
81 * OUTPUT: None
82 *
83 * RETURNS: OK or NOK
84 ****************************************************************************/
whal_hwEeprom_Destroy(HwEeprom_T * pHwEeprom)85 int whal_hwEeprom_Destroy(HwEeprom_T *pHwEeprom)
86 {
87 if (pHwEeprom)
88 os_memoryFree(pHwEeprom->hOs, pHwEeprom, sizeof(HwEeprom_T));
89 return OK;
90 }
91
92 /****************************************************************************
93 * whal_hwEeprom_Config()
94 ****************************************************************************
95 * DESCRIPTION: Config the object
96 *
97 * INPUTS:
98 * pHwEeprom The object to free
99 * hTNETWIF hardware access object
100 *
101 * OUTPUT: None
102 *
103 * RETURNS: OK or NOK
104 ****************************************************************************/
whal_hwEeprom_Config(HwEeprom_T * pHwEeprom,TI_HANDLE hTNETWIF,TI_HANDLE hReport)105 int whal_hwEeprom_Config(HwEeprom_T *pHwEeprom, TI_HANDLE hTNETWIF, TI_HANDLE hReport)
106 {
107 pHwEeprom->hReport = hReport;
108 pHwEeprom->hTNETWIF = hTNETWIF;
109 return OK;
110 }
111
112 #ifdef USE_SYNC_API
113 /************************************************************************
114 * UINT32 whal_hwEepromReadByte(UINT16 wAddr,UINT8 *pbVal) *
115 *************************************************************************
116 * DESCRIPTION: Reads a single byte from EEPROM. *
117 * *
118 * INPUT: wAddr - 16-bits EEPROM addrress *
119 * pbVal - pointer the to output parameter - EEPROM value *
120 * *
121 * OUTPUT: *pbVal contains EEPROM value *
122 * *
123 * RETURN: OK - successful *
124 * NOK timeout *
125 *************************************************************************/
whal_hwEepromReadByte(HwEeprom_T * pHwEeprom,UINT16 wAddr,UINT8 * pbVal)126 UINT32 whal_hwEepromReadByte(HwEeprom_T *pHwEeprom, UINT16 wAddr,UINT8 *pbVal)
127 {
128 UINT32 data;
129 int i = 0x00;
130
131
132 wAddr &= 0x07ff;
133 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_EE_ADDR_REG,(UINT32)wAddr);
134 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_EE_CTL_REG, EE_READ);
135 while((TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,ACX_EE_CTL_REG,&data) & EE_READ) != 0x00)
136 {
137 if(i++ > EEPROM_ACCESS_TO)
138 {
139 return NOK; /* timeout */
140 }
141 }
142 *pbVal = TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,ACX_EE_DATA_REG,&data) & 0xff;
143 return OK;
144 }
145
146 /************************************************************************
147 * UINT32 whal_hwEepromWriteByteNoUnp(UINT16 wAddr,UINT8 bVal) *
148 *************************************************************************
149 * DESCRIPTION: Writes a single byte to EEPROM *
150 * *
151 * INPUT: wAddr - 16-bits EEPROM addrress *
152 * bVal - new value *
153 * *
154 * OUTPUT: N/A *
155 * *
156 * RETURN: OK - successful *
157 * NOK timeout *
158 *************************************************************************/
whal_hwEepromWriteByteNoUnp(HwEeprom_T * pHwEeprom,UINT16 wAddr,UINT8 bVal)159 UINT32 whal_hwEepromWriteByteNoUnp(HwEeprom_T *pHwEeprom, UINT16 wAddr,UINT8 bVal)
160 {
161 volatile int i=0;
162 UINT32 data;
163
164 wAddr &= 0x07ff;
165 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_EE_ADDR_REG,(UINT32)wAddr);
166 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_EE_DATA_REG,bVal);
167 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_EE_CTL_REG, EE_WRITE);
168 while((TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,ACX_EE_CTL_REG,&data)& EE_WRITE) != 0x00)
169 {
170 volatile int y=0;
171
172 for( ; y<100; y++) {}
173 if(i++ > EEPROM_ACCESS_TO)
174 {
175 return NOK; /* timeout */
176 }
177 }
178
179 return OK;
180 }
181
182 /************************************************************************
183 * void whal_hwEepromProtect(void) *
184 *************************************************************************
185 * DESCRIPTION: Set EEPROM write protection. *
186 * Inhibits writing to the EEPROM. *
187 * *
188 * INPUT: N/A *
189 * *
190 * OUTPUT: N/A *
191 * *
192 * RETURN: N/A *
193 *************************************************************************/
whal_hwEepromProtect(HwEeprom_T * pHwEeprom)194 void whal_hwEepromProtect(HwEeprom_T *pHwEeprom)
195 {
196 /* Set up write protect. Should be according to board type and SW patch
197 rather than according to Hardware EEPROM
198 */
199 TNETWIF_RegIsBitSet(pHwEeprom->hTNETWIF, ACX_GPIO_OUT_REG, 1ul << 9);
200 }
201
202 /************************************************************************
203 * void whal_hwEepromUnprotect(void) *
204 *************************************************************************
205 * DESCRIPTION: Remove EEPROM write protection. *
206 * Enables writing to the EEPROM. *
207 * *
208 * INPUT: N/A *
209 * *
210 * OUTPUT: N/A *
211 * *
212 * RETURN: N/A *
213 *************************************************************************/
whal_hwEepromUnprotect(HwEeprom_T * pHwEeprom)214 void whal_hwEepromUnprotect(HwEeprom_T *pHwEeprom)
215 {
216 /* Turn off write protect. Should be according to board type and SW patch
217 rather than according to Hardware EEPROM
218 */
219 TNETWIF_RegResetBitVal(pHwEeprom->hTNETWIF, ACX_GPIO_OUT_REG, 1ul << 9);
220 }
221
222 /************************************************************************
223 * UINT32 whal_hwEepromWriteByte(UINT16 wAddr,UINT8 bVal) *
224 *************************************************************************
225 * DESCRIPTION: Writes a single byte to EEPROM *
226 * *
227 * INPUT: wAddr - 16-bits EEPROM addrress *
228 * bVal - new value *
229 * *
230 * OUTPUT: N/A *
231 * *
232 * RETURN: OK - successful *
233 * NOK timeout *
234 *************************************************************************/
whal_hwEepromWriteByte(HwEeprom_T * pHwEeprom,UINT16 wAddr,UINT8 bVal)235 UINT32 whal_hwEepromWriteByte(HwEeprom_T *pHwEeprom, UINT16 wAddr,UINT8 bVal)
236 {
237 UINT32 retCode;
238
239 whal_hwEepromUnprotect(pHwEeprom);
240 os_StalluSec(pHwEeprom->hOs, 100000);
241 retCode = whal_hwEepromWriteByteNoUnp(pHwEeprom, wAddr, bVal);
242 os_StalluSec(pHwEeprom->hOs, 100000);
243 whal_hwEepromProtect(pHwEeprom);
244 return retCode;
245 }
246
247 /************************************************************************
248 * UINT32 whal_hwEepromGetCalValue(UINT8 *pbVal) *
249 *************************************************************************
250 * DESCRIPTION: Reads oscillator cal. value from EEPROM *
251 * *
252 * INPUT: N/A *
253 * *
254 * OUTPUT: pbVal - pointer to the output parameter *
255 * *
256 * RETURN: OK successful *
257 * NOK timeout *
258 *************************************************************************/
whal_hwEepromGetCalValue(HwEeprom_T * pHwEeprom,UINT8 * pbVal)259 UINT32 whal_hwEepromGetCalValue(HwEeprom_T *pHwEeprom, UINT8 *pbVal)
260 {
261 return whal_hwEepromReadByte(pHwEeprom, HW_EEPROM_OSC_ADDR,pbVal);
262 }
263
264 /************************************************************************
265 * UINT32 whal_hwEepromSetCalValue(UINT8 bVal) *
266 *************************************************************************
267 * DESCRIPTION: Writes new oscillator cal. value to EEPROM *
268 * *
269 * INPUT: bVal - new oscillator cal. value *
270 * *
271 * OUTPUT: N/A *
272 * *
273 * RETURN: OK successful *
274 * NOK timeout or invalid value *
275 *************************************************************************/
whal_hwEepromSetCalValue(HwEeprom_T * pHwEeprom,UINT8 bVal)276 UINT32 whal_hwEepromSetCalValue(HwEeprom_T *pHwEeprom, UINT8 bVal)
277 {
278 if(bVal > MAX_OSC_CAL)
279 {
280 return NOK;
281 }
282
283 return whal_hwEepromWriteByte(pHwEeprom, HW_EEPROM_OSC_ADDR,bVal);
284 }
285
286 /************************************************************************
287 * UINT32 whal_hwEepromGetBiasValue(UINT8 *pbVal) *
288 *************************************************************************
289 * DESCRIPTION: Reads bias value from EEPROM *
290 * *
291 * INPUT: N/A *
292 * *
293 * OUTPUT: pbVal - pointer to the output parameter *
294 * *
295 * RETURN: OK successful *
296 * NOK timeout *
297 *************************************************************************/
whal_hwEepromGetBiasValue(HwEeprom_T * pHwEeprom,UINT8 * pbVal)298 UINT32 whal_hwEepromGetBiasValue(HwEeprom_T *pHwEeprom, UINT8 *pbVal)
299 {
300 return whal_hwEepromReadByte(pHwEeprom, HW_EEPROM_BIAS_ADDR,pbVal);
301 }
302
303 /************************************************************************
304 * UINT32 whal_hwEepromSetBiasValue(UINT8 bVal) *
305 *************************************************************************
306 * DESCRIPTION: Writes new bias value to EEPROM *
307 * *
308 * INPUT: bVal - new bias value *
309 * *
310 * OUTPUT: N/A *
311 * *
312 * RETURN: OK successful *
313 * NOK timeout *
314 *************************************************************************/
whal_hwEepromSetBiasValue(HwEeprom_T * pHwEeprom,UINT8 bVal)315 UINT32 whal_hwEepromSetBiasValue(HwEeprom_T *pHwEeprom, UINT8 bVal)
316 {
317 return whal_hwEepromWriteByte(pHwEeprom, HW_EEPROM_BIAS_ADDR,bVal);
318 }
319
320 /************************************************************************
321 * UINT32 whal_hwEepromGetDACValue(UINT8 *pbVal) *
322 *************************************************************************
323 * DESCRIPTION: Reads DAC value from EEPROM *
324 * *
325 * INPUT: N/A *
326 * *
327 * OUTPUT: pbVal - pointer to the output parameter *
328 * *
329 * RETURN: OK successful *
330 * NOK timeout *
331 *************************************************************************/
whal_hwEepromGetDACValue(HwEeprom_T * pHwEeprom,UINT8 * pbVal)332 UINT32 whal_hwEepromGetDACValue(HwEeprom_T *pHwEeprom, UINT8 *pbVal)
333 {
334 return whal_hwEepromReadByte(pHwEeprom, HW_EEPROM_DAC_ADDR,pbVal);
335 }
336
337 /************************************************************************
338 * UINT32 whal_hwEepromSetDACValue(UINT8 bVal) *
339 *************************************************************************
340 * DESCRIPTION: Writes new DAC value to EEPROM *
341 * *
342 * INPUT: bVal - new DAC value *
343 * *
344 * OUTPUT: N/A *
345 * *
346 * RETURN: OK successful *
347 * NOK timeout *
348 *************************************************************************/
whal_hwEepromSetDACValue(HwEeprom_T * pHwEeprom,UINT8 bVal)349 UINT32 whal_hwEepromSetDACValue(HwEeprom_T *pHwEeprom, UINT8 bVal)
350 {
351 return whal_hwEepromWriteByte(pHwEeprom, HW_EEPROM_DAC_ADDR,bVal);
352 }
353
354 /************************************************************************
355 * int whal_hwEepromLoadBaseBandTable(void) *
356 *************************************************************************
357 * DESCRIPTION: Loads BB registers table from EEPROM *
358 * *
359 * INPUT: N/A *
360 * *
361 * OUTPUT: N/A *
362 * *
363 * RETURN: N/A *
364 *************************************************************************/
whal_hwEepromLoadBaseBandTable(HwEeprom_T * pHwEeprom)365 int whal_hwEepromLoadBaseBandTable(HwEeprom_T *pHwEeprom)
366 {
367 UINT8 bRegVal;
368 UINT16 wTableAddress;
369 UINT8 bNumberOfEntries;
370 UINT16 wTableEnd;
371 UINT8 bEntrySize;
372 UINT8 bbAddr;
373 UINT8 bbData;
374 int addr;
375
376 if(whal_hwEepromReadByte(pHwEeprom, 0x14a,&bRegVal) != OK)
377 {
378 return NOK;
379 }
380
381 wTableAddress = bRegVal;
382
383 if(whal_hwEepromReadByte(pHwEeprom, 0x14b,&bRegVal) != OK)
384 {
385 return NOK;
386 }
387
388 wTableAddress |= bRegVal << 8;
389
390 if(whal_hwEepromReadByte(pHwEeprom, wTableAddress,&bRegVal) != OK)
391 {
392 }
393
394 bNumberOfEntries = bRegVal;
395
396 if(whal_hwEepromReadByte(pHwEeprom, (UINT16)(wTableAddress+1),&bRegVal) != OK)
397 {
398 return NOK;
399 }
400
401 bEntrySize = bRegVal;
402
403 WLAN_REPORT_INFORMATION(pHwEeprom->hReport, HAL_HW_CTRL_MODULE_LOG,
404 ("\tTable Address: 0x%x\n\tNumber of elements: 0x%x\n\tEntry Size: 0x%x\n",
405 wTableAddress,bNumberOfEntries,bEntrySize));
406
407
408 wTableEnd = wTableAddress + (bEntrySize * (bNumberOfEntries + 1));
409
410 for(addr = wTableAddress + 2; addr < wTableEnd; addr+= bEntrySize)
411 {
412 if(whal_hwEepromReadByte(pHwEeprom, (UINT16)addr,&bbAddr)!= OK)
413 {
414 return NOK;
415 }
416
417 if(whal_hwEepromReadByte(pHwEeprom, (UINT16)(addr+1),&bbData)!= OK)
418 {
419 return NOK;
420 }
421
422 /*
423 whal_hwWritePHYReg(bbAddr,bbData);
424 -- the follwing 3 statements do the same thing
425 */
426 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_PHY_ADDR_REG, bbAddr);
427 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_PHY_DATA_REG, bbData);
428 TNETWIF_WriteRegSync(pHwEeprom->hTNETWIF, ACX_PHY_CTRL_REG, 1 /* write */);
429 }
430 return OK;
431 }/* END whal_hwEepromLoadBaseBandTable() */
432
433 /************************************************************************
434 * UINT32 whal_hwEepromGetAGCCell(UINT8 bTableOffset, UINT8 *pbVal) *
435 *************************************************************************
436 * DESCRIPTION: Reads one cell from ACG table *
437 * *
438 * INPUT: bTableOffset - zero-based offset of the cell in AGC *
439 * table *
440 * OUTPUT: pbVal - pointer to the output parameter *
441 * *
442 * RETURN: OK *
443 * NOK - EEPROM write error *
444 * INVALID_PARAMETER1 - invalid parameter 1 *
445 *************************************************************************/
whal_hwEepromGetAGCCell(HwEeprom_T * pHwEeprom,UINT8 bTableOffset,UINT8 * pbVal)446 UINT32 whal_hwEepromGetAGCCell(HwEeprom_T *pHwEeprom, UINT8 bTableOffset, UINT8 *pbVal)
447 {
448 if(bTableOffset > MAX_AGC_TABLE_ENTRIES)
449 {
450 *pbVal = 0x00;
451 return (UINT32)INVALID_PARAMETER1;
452 }
453
454 return whal_hwEepromReadByte(pHwEeprom, (UINT16)(HW_EEPROM_AGC_TABLE_ADDR+bTableOffset),pbVal);
455 }
456
457 /************************************************************************
458 * UINT32 whal_hwEepromSetAGCCell(UINT8 bTableOffset, UINT8 bVal) *
459 *************************************************************************
460 * DESCRIPTION: Writes one AGC table cell to EEPROM *
461 * *
462 * INPUT: bTableOffset - zero-based offset of the cell in AGC *
463 * table *
464 * bVal - new cell value *
465 * OUTPUT: N/A *
466 * *
467 * RETURN: OK *
468 * NOK - EEPROM write error *
469 * INVALID_PARAMETER1 - invalid parameter 1 *
470 *************************************************************************/
whal_hwEepromSetAGCCell(HwEeprom_T * pHwEeprom,UINT8 bTableOffset,UINT8 bVal)471 UINT32 whal_hwEepromSetAGCCell(HwEeprom_T *pHwEeprom, UINT8 bTableOffset, UINT8 bVal)
472 {
473 if(bTableOffset > MAX_AGC_TABLE_ENTRIES)
474 {
475 return (UINT32)INVALID_PARAMETER1;
476 }
477
478 return whal_hwEepromWriteByte(pHwEeprom, (UINT16)(HW_EEPROM_AGC_TABLE_ADDR+bTableOffset), bVal);
479 }
480
481
482
483 /****************************************************************************
484 * whal_hwCtrl_GetRadioTypeAndEEPROMversion()
485 ****************************************************************************
486 * DESCRIPTION:
487 *
488 * INPUTS: None
489 *
490 * OUTPUT: None
491 *
492 * RETURNS: OK or NOK
493 ****************************************************************************/
whal_hwEeprom_GetRadioTypeAndEEPROMversion(HwEeprom_T * pHwEeprom,UINT32 * major,UINT32 * minor,UINT32 * bugfix)494 int whal_hwEeprom_GetRadioTypeAndEEPROMversion(HwEeprom_T *pHwEeprom, UINT32 *major, UINT32 *minor, UINT32 *bugfix)
495 {
496 /*volatile */
497 UINT32 radioType;
498
499 /*volatile */
500 UINT32 eectl;
501 /*
502 * Read major eeprom version - offset 5
503 */
504 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_ADDR, 5);
505 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_CTL, 0x2);
506 do
507 {
508 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_CTL,&eectl);
509 if (eectl == 0xffffffff)
510 return -1;
511 } while (eectl &0x2);
512 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_DATA,major);
513 /*
514 * Read minor eeprom version - offset 9
515 */
516 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_ADDR, 9);
517 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_CTL, 0x2);
518 do
519 {
520 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_CTL,&eectl);
521 if (eectl == 0xffffffff)
522 return -1;
523 } while (eectl &0x2);
524 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_DATA,minor);
525
526 /*
527 * Read bugfix eeprom version - offset A
528 */
529 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_ADDR, 0xA);
530 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_CTL, 0x2);
531 do
532 {
533 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_CTL,&eectl);
534 if (eectl == 0xffffffff)
535 return -1;
536 } while (eectl &0x2);
537 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_DATA,bugfix);
538
539 /*
540 * Read radio type - offset 4
541 */
542 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_ADDR, 4);
543 TNETWIF_WriteRegSync( pHwEeprom->hTNETWIF, EE_CTL, 0x2);
544 do
545 {
546 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_CTL,&eectl);
547 if (eectl == 0xffffffff)
548 return -1;
549 } while (eectl &0x2);
550
551 TNETWIF_ReadRegSync(pHwEeprom->hTNETWIF,EE_DATA,&radioType);
552
553 return(int)radioType;
554 }
555
whal_hwEeprom_DumpEEPROM(HwEeprom_T * pHwEeprom)556 void whal_hwEeprom_DumpEEPROM(HwEeprom_T *pHwEeprom)
557 {
558 UINT16 wAddr;
559 UINT8 bVal;
560
561 WLAN_REPORT_REPLY(pHwEeprom->hReport, HAL_HW_CTRL_MODULE_LOG,
562 ("Dump EEPROM contents:"));
563 for ( wAddr = 0; wAddr < 0x2ff; wAddr++)
564 {
565 if (whal_hwEepromReadByte(pHwEeprom, wAddr, &bVal) == OK)
566 {
567 WLAN_REPORT_REPLY(pHwEeprom->hReport, HAL_HW_CTRL_MODULE_LOG,
568 ("\tEEPROM 0x%04X:\t0x%02X.\n", wAddr, bVal));
569 } else
570 {
571 WLAN_REPORT_REPLY(pHwEeprom->hReport, HAL_HW_CTRL_MODULE_LOG,
572 ("\tERROR: timeout"));
573 }
574 }
575 }
576
577 #endif /* USE_SYNC_API */
578