?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: add rt2870 wireless driver
[linux-2.6/mini2440.git] / drivers / staging / rt2870 / common / rtmp_init.c
blob87028fd60bc2ee189be951f936428476167214f5
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26
27 Module Name:
28 rtmp_init.c
29
30 Abstract:
31 Miniport generic portion header file
32
33 Revision History:
34 Who When What
35 -------- ---------- ----------------------------------------------
36 Paul Lin 2002-08-01 created
37 John Chang 2004-08-20 RT2561/2661 use scatter-gather scheme
38 Jan Lee 2006-09-15 RT2860. Change for 802.11n , EEPROM, Led, BA, HT.
39 */
40 #include "../rt_config.h"
41 #include "firmware.h"
42
43 //#define BIN_IN_FILE /* use *.bin firmware */
44
45 UCHAR BIT8[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
46 ULONG BIT32[] = {0x00000001, 0x00000002, 0x00000004, 0x00000008,
47 0x00000010, 0x00000020, 0x00000040, 0x00000080,
48 0x00000100, 0x00000200, 0x00000400, 0x00000800,
49 0x00001000, 0x00002000, 0x00004000, 0x00008000,
50 0x00010000, 0x00020000, 0x00040000, 0x00080000,
51 0x00100000, 0x00200000, 0x00400000, 0x00800000,
52 0x01000000, 0x02000000, 0x04000000, 0x08000000,
53 0x10000000, 0x20000000, 0x40000000, 0x80000000};
54
55 char* CipherName[] = {"none","wep64","wep128","TKIP","AES","CKIP64","CKIP128"};
56
57 const unsigned short ccitt_16Table[] = {
58 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
59 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
60 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
61 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
62 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
63 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
64 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
65 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
66 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
67 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
68 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
69 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
70 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
71 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
72 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
73 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
74 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
75 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
76 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
77 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
78 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
79 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
80 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
81 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
82 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
83 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
84 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
85 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
86 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
87 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
88 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
89 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
90 };
91 #define ByteCRC16(v, crc) \
92 (unsigned short)((crc << 8) ^ ccitt_16Table[((crc >> 8) ^ (v)) & 255])
93
94 unsigned char BitReverse(unsigned char x)
95 {
96 int i;
97 unsigned char Temp=0;
98 for(i=0; ; i++)
99 {
100 if(x & 0x80) Temp |= 0x80;
101 if(i==7) break;
102 x <<= 1;
103 Temp >>= 1;
104 }
105 return Temp;
106 }
107
108 //
109 // BBP register initialization set
110 //
111 REG_PAIR BBPRegTable[] = {
112 {BBP_R65, 0x2C}, // fix rssi issue
113 {BBP_R66, 0x38}, // Also set this default value to pAd->BbpTuning.R66CurrentValue at initial
114 {BBP_R69, 0x12},
115 {BBP_R70, 0xa}, // BBP_R70 will change to 0x8 in ApStartUp and LinkUp for rt2860C, otherwise value is 0xa
116 {BBP_R73, 0x10},
117 {BBP_R81, 0x37},
118 {BBP_R82, 0x62},
119 {BBP_R83, 0x6A},
120 {BBP_R84, 0x99}, // 0x19 is for rt2860E and after. This is for extension channel overlapping IOT. 0x99 is for rt2860D and before
121 {BBP_R86, 0x00}, // middle range issue, Rory @2008-01-28
122 {BBP_R91, 0x04}, // middle range issue, Rory @2008-01-28
123 {BBP_R92, 0x00}, // middle range issue, Rory @2008-01-28
124 {BBP_R103, 0x00}, // near range high-power issue, requested from Gary @2008-0528
125 {BBP_R105, 0x05}, // 0x05 is for rt2860E to turn on FEQ control. It is safe for rt2860D and before, because Bit 7:2 are reserved in rt2860D and before.
126 };
127 #define NUM_BBP_REG_PARMS (sizeof(BBPRegTable) / sizeof(REG_PAIR))
128
129 //
130 // RF register initialization set
131 //
132 #ifdef RT2870
133 REG_PAIR RT30xx_RFRegTable[] = {
134 {RF_R04, 0x40},
135 {RF_R05, 0x03},
136 {RF_R06, 0x02},
137 {RF_R07, 0x70},
138 {RF_R09, 0x0F},
139 {RF_R10, 0x71},
140 {RF_R11, 0x21},
141 {RF_R12, 0x7B},
142 {RF_R14, 0x90},
143 {RF_R15, 0x58},
144 {RF_R16, 0xB3},
145 {RF_R17, 0x92},
146 {RF_R18, 0x2C},
147 {RF_R19, 0x02},
148 {RF_R20, 0xBA},
149 {RF_R21, 0xDB},
150 {RF_R24, 0x16},
151 {RF_R25, 0x01},
152 {RF_R27, 0x03},
153 {RF_R29, 0x1F},
154 };
155 #define NUM_RF_REG_PARMS (sizeof(RT30xx_RFRegTable) / sizeof(REG_PAIR))
156 #endif // RT2870 //
157
158 //
159 // ASIC register initialization sets
160 //
161
162 RTMP_REG_PAIR MACRegTable[] = {
163 #if defined(HW_BEACON_OFFSET) && (HW_BEACON_OFFSET == 0x200)
164 {BCN_OFFSET0, 0xf8f0e8e0}, /* 0x3800(e0), 0x3A00(e8), 0x3C00(f0), 0x3E00(f8), 512B for each beacon */
165 {BCN_OFFSET1, 0x6f77d0c8}, /* 0x3200(c8), 0x3400(d0), 0x1DC0(77), 0x1BC0(6f), 512B for each beacon */
166 #elif defined(HW_BEACON_OFFSET) && (HW_BEACON_OFFSET == 0x100)
167 {BCN_OFFSET0, 0xece8e4e0}, /* 0x3800, 0x3A00, 0x3C00, 0x3E00, 512B for each beacon */
168 {BCN_OFFSET1, 0xfcf8f4f0}, /* 0x3800, 0x3A00, 0x3C00, 0x3E00, 512B for each beacon */
169 #else
170 #error You must re-calculate new value for BCN_OFFSET0 & BCN_OFFSET1 in MACRegTable[]!!!
171 #endif // HW_BEACON_OFFSET //
172
173 {LEGACY_BASIC_RATE, 0x0000013f}, // Basic rate set bitmap
174 {HT_BASIC_RATE, 0x00008003}, // Basic HT rate set , 20M, MCS=3, MM. Format is the same as in TXWI.
175 {MAC_SYS_CTRL, 0x00}, // 0x1004, , default Disable RX
176 {RX_FILTR_CFG, 0x17f97}, //0x1400 , RX filter control,
177 {BKOFF_SLOT_CFG, 0x209}, // default set short slot time, CC_DELAY_TIME should be 2
178 {TX_SW_CFG0, 0x0}, // Gary,2008-05-21 for CWC test
179 {TX_SW_CFG1, 0x80606}, // Gary,2006-08-23
180 {TX_LINK_CFG, 0x1020}, // Gary,2006-08-23
181 //{TX_TIMEOUT_CFG, 0x00182090}, // CCK has some problem. So increase timieout value. 2006-10-09// MArvek RT
182 {TX_TIMEOUT_CFG, 0x000a2090}, // CCK has some problem. So increase timieout value. 2006-10-09// MArvek RT , Modify for 2860E ,2007-08-01
183 {MAX_LEN_CFG, MAX_AGGREGATION_SIZE | 0x00001000}, // 0x3018, MAX frame length. Max PSDU = 16kbytes.
184 {LED_CFG, 0x7f031e46}, // Gary, 2006-08-23
185 {PBF_MAX_PCNT, 0x1F3FBF9F}, //0x1F3f7f9f}, //Jan, 2006/04/20
186 //{TX_RTY_CFG, 0x6bb80408}, // Jan, 2006/11/16
187 {TX_RTY_CFG, 0x47d01f0f}, // Jan, 2006/11/16, Set TxWI->ACK =0 in Probe Rsp Modify for 2860E ,2007-08-03
188 {AUTO_RSP_CFG, 0x00000013}, // Initial Auto_Responder, because QA will turn off Auto-Responder
189 {CCK_PROT_CFG, 0x05740003 /*0x01740003*/}, // Initial Auto_Responder, because QA will turn off Auto-Responder. And RTS threshold is enabled.
190 {OFDM_PROT_CFG, 0x05740003 /*0x01740003*/}, // Initial Auto_Responder, because QA will turn off Auto-Responder. And RTS threshold is enabled.
191 #ifdef RT2870
192 {PBF_CFG, 0xf40006}, // Only enable Queue 2
193 {MM40_PROT_CFG, 0x3F44084}, // Initial Auto_Responder, because QA will turn off Auto-Responder
194 {WPDMA_GLO_CFG, 0x00000030},
195 #endif // RT2870 //
196 {GF20_PROT_CFG, 0x01744004}, // set 19:18 --> Short NAV for MIMO PS
197 {GF40_PROT_CFG, 0x03F44084},
198 {MM20_PROT_CFG, 0x01744004},
199 {TXOP_CTRL_CFG, 0x0000583f, /*0x0000243f*/ /*0x000024bf*/}, //Extension channel backoff.
200 {TX_RTS_CFG, 0x00092b20},
201 //#ifdef WIFI_TEST
202 {EXP_ACK_TIME, 0x002400ca}, // default value
203 //#else
204 // {EXP_ACK_TIME, 0x005400ca}, // suggested by Gray @ 20070323 for 11n intel-sta throughput
205 //#endif // end - WIFI_TEST //
206 {TXOP_HLDR_ET, 0x00000002},
207
208 /* Jerry comments 2008/01/16: we use SIFS = 10us in CCK defaultly, but it seems that 10us
209 is too small for INTEL 2200bg card, so in MBSS mode, the delta time between beacon0
210 and beacon1 is SIFS (10us), so if INTEL 2200bg card connects to BSS0, the ping
211 will always lost. So we change the SIFS of CCK from 10us to 16us. */
212 {XIFS_TIME_CFG, 0x33a41010},
213 {PWR_PIN_CFG, 0x00000003}, // patch for 2880-E
214 };
215
216
217 #ifdef CONFIG_STA_SUPPORT
218 RTMP_REG_PAIR STAMACRegTable[] = {
219 {WMM_AIFSN_CFG, 0x00002273},
220 {WMM_CWMIN_CFG, 0x00002344},
221 {WMM_CWMAX_CFG, 0x000034aa},
222 };
223 #endif // CONFIG_STA_SUPPORT //
224
225 #define NUM_MAC_REG_PARMS (sizeof(MACRegTable) / sizeof(RTMP_REG_PAIR))
226 #ifdef CONFIG_STA_SUPPORT
227 #define NUM_STA_MAC_REG_PARMS (sizeof(STAMACRegTable) / sizeof(RTMP_REG_PAIR))
228 #endif // CONFIG_STA_SUPPORT //
229
230 #ifdef RT2870
231 //
232 // RT2870 Firmware Spec only used 1 oct for version expression
233 //
234 #define FIRMWARE_MINOR_VERSION 7
235
236 #endif // RT2870 //
237
238 // New 8k byte firmware size for RT3071/RT3072
239 #define FIRMWAREIMAGE_MAX_LENGTH 0x2000
240 #define FIRMWAREIMAGE_LENGTH (sizeof (FirmwareImage) / sizeof(UCHAR))
241 #define FIRMWARE_MAJOR_VERSION 0
242
243 #define FIRMWAREIMAGEV1_LENGTH 0x1000
244 #define FIRMWAREIMAGEV2_LENGTH 0x1000
245
246
247
248 /*
249 ========================================================================
250
251 Routine Description:
252 Allocate RTMP_ADAPTER data block and do some initialization
253
254 Arguments:
255 Adapter Pointer to our adapter
256
257 Return Value:
258 NDIS_STATUS_SUCCESS
259 NDIS_STATUS_FAILURE
260
261 IRQL = PASSIVE_LEVEL
262
263 Note:
264
265 ========================================================================
266 */
267 NDIS_STATUS RTMPAllocAdapterBlock(
268 IN PVOID handle,
269 OUT PRTMP_ADAPTER *ppAdapter)
270 {
271 PRTMP_ADAPTER pAd;
272 NDIS_STATUS Status;
273 INT index;
274 UCHAR *pBeaconBuf = NULL;
275
276 DBGPRINT(RT_DEBUG_TRACE, ("--> RTMPAllocAdapterBlock\n"));
277
278 *ppAdapter = NULL;
279
280 do
281 {
282 // Allocate RTMP_ADAPTER memory block
283 pBeaconBuf = kmalloc(MAX_BEACON_SIZE, MEM_ALLOC_FLAG);
284 if (pBeaconBuf == NULL)
285 {
286 Status = NDIS_STATUS_FAILURE;
287 DBGPRINT_ERR(("Failed to allocate memory - BeaconBuf!\n"));
288 break;
289 }
290
291 Status = AdapterBlockAllocateMemory(handle, (PVOID *)&pAd);
292 if (Status != NDIS_STATUS_SUCCESS)
293 {
294 DBGPRINT_ERR(("Failed to allocate memory - ADAPTER\n"));
295 break;
296 }
297 pAd->BeaconBuf = pBeaconBuf;
298 printk("\n\n=== pAd = %p, size = %d ===\n\n", pAd, (UINT32)sizeof(RTMP_ADAPTER));
299
300
301 // Init spin locks
302 NdisAllocateSpinLock(&pAd->MgmtRingLock);
303
304 for (index =0 ; index < NUM_OF_TX_RING; index++)
305 {
306 NdisAllocateSpinLock(&pAd->TxSwQueueLock[index]);
307 NdisAllocateSpinLock(&pAd->DeQueueLock[index]);
308 pAd->DeQueueRunning[index] = FALSE;
309 }
310
311 NdisAllocateSpinLock(&pAd->irq_lock);
312
313 } while (FALSE);
314
315 if ((Status != NDIS_STATUS_SUCCESS) && (pBeaconBuf))
316 kfree(pBeaconBuf);
317
318 *ppAdapter = pAd;
319
320 DBGPRINT_S(Status, ("<-- RTMPAllocAdapterBlock, Status=%x\n", Status));
321 return Status;
322 }
323
324 /*
325 ========================================================================
326
327 Routine Description:
328 Read initial Tx power per MCS and BW from EEPROM
329
330 Arguments:
331 Adapter Pointer to our adapter
332
333 Return Value:
334 None
335
336 IRQL = PASSIVE_LEVEL
337
338 Note:
339
340 ========================================================================
341 */
342 VOID RTMPReadTxPwrPerRate(
343 IN PRTMP_ADAPTER pAd)
344 {
345 ULONG data, Adata, Gdata;
346 USHORT i, value, value2;
347 INT Apwrdelta, Gpwrdelta;
348 UCHAR t1,t2,t3,t4;
349 BOOLEAN bValid, bApwrdeltaMinus = TRUE, bGpwrdeltaMinus = TRUE;
350
351 //
352 // Get power delta for 20MHz and 40MHz.
353 //
354 DBGPRINT(RT_DEBUG_TRACE, ("Txpower per Rate\n"));
355 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_DELTA, value2);
356 Apwrdelta = 0;
357 Gpwrdelta = 0;
358
359 if ((value2 & 0xff) != 0xff)
360 {
361 if ((value2 & 0x80))
362 Gpwrdelta = (value2&0xf);
363
364 if ((value2 & 0x40))
365 bGpwrdeltaMinus = FALSE;
366 else
367 bGpwrdeltaMinus = TRUE;
368 }
369 if ((value2 & 0xff00) != 0xff00)
370 {
371 if ((value2 & 0x8000))
372 Apwrdelta = ((value2&0xf00)>>8);
373
374 if ((value2 & 0x4000))
375 bApwrdeltaMinus = FALSE;
376 else
377 bApwrdeltaMinus = TRUE;
378 }
379 DBGPRINT(RT_DEBUG_TRACE, ("Gpwrdelta = %x, Apwrdelta = %x .\n", Gpwrdelta, Apwrdelta));
380
381 //
382 // Get Txpower per MCS for 20MHz in 2.4G.
383 //
384 for (i=0; i<5; i++)
385 {
386 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_2_4G + i*4, value);
387 data = value;
388 if (bApwrdeltaMinus == FALSE)
389 {
390 t1 = (value&0xf)+(Apwrdelta);
391 if (t1 > 0xf)
392 t1 = 0xf;
393 t2 = ((value&0xf0)>>4)+(Apwrdelta);
394 if (t2 > 0xf)
395 t2 = 0xf;
396 t3 = ((value&0xf00)>>8)+(Apwrdelta);
397 if (t3 > 0xf)
398 t3 = 0xf;
399 t4 = ((value&0xf000)>>12)+(Apwrdelta);
400 if (t4 > 0xf)
401 t4 = 0xf;
402 }
403 else
404 {
405 if ((value&0xf) > Apwrdelta)
406 t1 = (value&0xf)-(Apwrdelta);
407 else
408 t1 = 0;
409 if (((value&0xf0)>>4) > Apwrdelta)
410 t2 = ((value&0xf0)>>4)-(Apwrdelta);
411 else
412 t2 = 0;
413 if (((value&0xf00)>>8) > Apwrdelta)
414 t3 = ((value&0xf00)>>8)-(Apwrdelta);
415 else
416 t3 = 0;
417 if (((value&0xf000)>>12) > Apwrdelta)
418 t4 = ((value&0xf000)>>12)-(Apwrdelta);
419 else
420 t4 = 0;
421 }
422 Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
423 if (bGpwrdeltaMinus == FALSE)
424 {
425 t1 = (value&0xf)+(Gpwrdelta);
426 if (t1 > 0xf)
427 t1 = 0xf;
428 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
429 if (t2 > 0xf)
430 t2 = 0xf;
431 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
432 if (t3 > 0xf)
433 t3 = 0xf;
434 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
435 if (t4 > 0xf)
436 t4 = 0xf;
437 }
438 else
439 {
440 if ((value&0xf) > Gpwrdelta)
441 t1 = (value&0xf)-(Gpwrdelta);
442 else
443 t1 = 0;
444 if (((value&0xf0)>>4) > Gpwrdelta)
445 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
446 else
447 t2 = 0;
448 if (((value&0xf00)>>8) > Gpwrdelta)
449 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
450 else
451 t3 = 0;
452 if (((value&0xf000)>>12) > Gpwrdelta)
453 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
454 else
455 t4 = 0;
456 }
457 Gdata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
458
459 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_2_4G + i*4 + 2, value);
460 if (bApwrdeltaMinus == FALSE)
461 {
462 t1 = (value&0xf)+(Apwrdelta);
463 if (t1 > 0xf)
464 t1 = 0xf;
465 t2 = ((value&0xf0)>>4)+(Apwrdelta);
466 if (t2 > 0xf)
467 t2 = 0xf;
468 t3 = ((value&0xf00)>>8)+(Apwrdelta);
469 if (t3 > 0xf)
470 t3 = 0xf;
471 t4 = ((value&0xf000)>>12)+(Apwrdelta);
472 if (t4 > 0xf)
473 t4 = 0xf;
474 }
475 else
476 {
477 if ((value&0xf) > Apwrdelta)
478 t1 = (value&0xf)-(Apwrdelta);
479 else
480 t1 = 0;
481 if (((value&0xf0)>>4) > Apwrdelta)
482 t2 = ((value&0xf0)>>4)-(Apwrdelta);
483 else
484 t2 = 0;
485 if (((value&0xf00)>>8) > Apwrdelta)
486 t3 = ((value&0xf00)>>8)-(Apwrdelta);
487 else
488 t3 = 0;
489 if (((value&0xf000)>>12) > Apwrdelta)
490 t4 = ((value&0xf000)>>12)-(Apwrdelta);
491 else
492 t4 = 0;
493 }
494 Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
495 if (bGpwrdeltaMinus == FALSE)
496 {
497 t1 = (value&0xf)+(Gpwrdelta);
498 if (t1 > 0xf)
499 t1 = 0xf;
500 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
501 if (t2 > 0xf)
502 t2 = 0xf;
503 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
504 if (t3 > 0xf)
505 t3 = 0xf;
506 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
507 if (t4 > 0xf)
508 t4 = 0xf;
509 }
510 else
511 {
512 if ((value&0xf) > Gpwrdelta)
513 t1 = (value&0xf)-(Gpwrdelta);
514 else
515 t1 = 0;
516 if (((value&0xf0)>>4) > Gpwrdelta)
517 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
518 else
519 t2 = 0;
520 if (((value&0xf00)>>8) > Gpwrdelta)
521 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
522 else
523 t3 = 0;
524 if (((value&0xf000)>>12) > Gpwrdelta)
525 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
526 else
527 t4 = 0;
528 }
529 Gdata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
530 data |= (value<<16);
531
532 pAd->Tx20MPwrCfgABand[i] = pAd->Tx40MPwrCfgABand[i] = Adata;
533 pAd->Tx20MPwrCfgGBand[i] = pAd->Tx40MPwrCfgGBand[i] = Gdata;
534
535 if (data != 0xffffffff)
536 RTMP_IO_WRITE32(pAd, TX_PWR_CFG_0 + i*4, data);
537 DBGPRINT_RAW(RT_DEBUG_TRACE, ("20MHz BW, 2.4G band-%lx, Adata = %lx, Gdata = %lx \n", data, Adata, Gdata));
538 }
539
540 //
541 // Check this block is valid for 40MHz in 2.4G. If invalid, use parameter for 20MHz in 2.4G
542 //
543 bValid = TRUE;
544 for (i=0; i<6; i++)
545 {
546 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + 2 + i*2, value);
547 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
548 {
549 bValid = FALSE;
550 break;
551 }
552 }
553
554 //
555 // Get Txpower per MCS for 40MHz in 2.4G.
556 //
557 if (bValid)
558 {
559 for (i=0; i<4; i++)
560 {
561 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + i*4, value);
562 if (bGpwrdeltaMinus == FALSE)
563 {
564 t1 = (value&0xf)+(Gpwrdelta);
565 if (t1 > 0xf)
566 t1 = 0xf;
567 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
568 if (t2 > 0xf)
569 t2 = 0xf;
570 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
571 if (t3 > 0xf)
572 t3 = 0xf;
573 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
574 if (t4 > 0xf)
575 t4 = 0xf;
576 }
577 else
578 {
579 if ((value&0xf) > Gpwrdelta)
580 t1 = (value&0xf)-(Gpwrdelta);
581 else
582 t1 = 0;
583 if (((value&0xf0)>>4) > Gpwrdelta)
584 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
585 else
586 t2 = 0;
587 if (((value&0xf00)>>8) > Gpwrdelta)
588 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
589 else
590 t3 = 0;
591 if (((value&0xf000)>>12) > Gpwrdelta)
592 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
593 else
594 t4 = 0;
595 }
596 Gdata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
597
598 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_2_4G + i*4 + 2, value);
599 if (bGpwrdeltaMinus == FALSE)
600 {
601 t1 = (value&0xf)+(Gpwrdelta);
602 if (t1 > 0xf)
603 t1 = 0xf;
604 t2 = ((value&0xf0)>>4)+(Gpwrdelta);
605 if (t2 > 0xf)
606 t2 = 0xf;
607 t3 = ((value&0xf00)>>8)+(Gpwrdelta);
608 if (t3 > 0xf)
609 t3 = 0xf;
610 t4 = ((value&0xf000)>>12)+(Gpwrdelta);
611 if (t4 > 0xf)
612 t4 = 0xf;
613 }
614 else
615 {
616 if ((value&0xf) > Gpwrdelta)
617 t1 = (value&0xf)-(Gpwrdelta);
618 else
619 t1 = 0;
620 if (((value&0xf0)>>4) > Gpwrdelta)
621 t2 = ((value&0xf0)>>4)-(Gpwrdelta);
622 else
623 t2 = 0;
624 if (((value&0xf00)>>8) > Gpwrdelta)
625 t3 = ((value&0xf00)>>8)-(Gpwrdelta);
626 else
627 t3 = 0;
628 if (((value&0xf000)>>12) > Gpwrdelta)
629 t4 = ((value&0xf000)>>12)-(Gpwrdelta);
630 else
631 t4 = 0;
632 }
633 Gdata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
634
635 if (i == 0)
636 pAd->Tx40MPwrCfgGBand[i+1] = (pAd->Tx40MPwrCfgGBand[i+1] & 0x0000FFFF) | (Gdata & 0xFFFF0000);
637 else
638 pAd->Tx40MPwrCfgGBand[i+1] = Gdata;
639
640 DBGPRINT_RAW(RT_DEBUG_TRACE, ("40MHz BW, 2.4G band, Gdata = %lx \n", Gdata));
641 }
642 }
643
644 //
645 // Check this block is valid for 20MHz in 5G. If invalid, use parameter for 20MHz in 2.4G
646 //
647 bValid = TRUE;
648 for (i=0; i<8; i++)
649 {
650 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + 2 + i*2, value);
651 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
652 {
653 bValid = FALSE;
654 break;
655 }
656 }
657
658 //
659 // Get Txpower per MCS for 20MHz in 5G.
660 //
661 if (bValid)
662 {
663 for (i=0; i<5; i++)
664 {
665 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + i*4, value);
666 if (bApwrdeltaMinus == FALSE)
667 {
668 t1 = (value&0xf)+(Apwrdelta);
669 if (t1 > 0xf)
670 t1 = 0xf;
671 t2 = ((value&0xf0)>>4)+(Apwrdelta);
672 if (t2 > 0xf)
673 t2 = 0xf;
674 t3 = ((value&0xf00)>>8)+(Apwrdelta);
675 if (t3 > 0xf)
676 t3 = 0xf;
677 t4 = ((value&0xf000)>>12)+(Apwrdelta);
678 if (t4 > 0xf)
679 t4 = 0xf;
680 }
681 else
682 {
683 if ((value&0xf) > Apwrdelta)
684 t1 = (value&0xf)-(Apwrdelta);
685 else
686 t1 = 0;
687 if (((value&0xf0)>>4) > Apwrdelta)
688 t2 = ((value&0xf0)>>4)-(Apwrdelta);
689 else
690 t2 = 0;
691 if (((value&0xf00)>>8) > Apwrdelta)
692 t3 = ((value&0xf00)>>8)-(Apwrdelta);
693 else
694 t3 = 0;
695 if (((value&0xf000)>>12) > Apwrdelta)
696 t4 = ((value&0xf000)>>12)-(Apwrdelta);
697 else
698 t4 = 0;
699 }
700 Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
701
702 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_20MHZ_5G + i*4 + 2, value);
703 if (bApwrdeltaMinus == FALSE)
704 {
705 t1 = (value&0xf)+(Apwrdelta);
706 if (t1 > 0xf)
707 t1 = 0xf;
708 t2 = ((value&0xf0)>>4)+(Apwrdelta);
709 if (t2 > 0xf)
710 t2 = 0xf;
711 t3 = ((value&0xf00)>>8)+(Apwrdelta);
712 if (t3 > 0xf)
713 t3 = 0xf;
714 t4 = ((value&0xf000)>>12)+(Apwrdelta);
715 if (t4 > 0xf)
716 t4 = 0xf;
717 }
718 else
719 {
720 if ((value&0xf) > Apwrdelta)
721 t1 = (value&0xf)-(Apwrdelta);
722 else
723 t1 = 0;
724 if (((value&0xf0)>>4) > Apwrdelta)
725 t2 = ((value&0xf0)>>4)-(Apwrdelta);
726 else
727 t2 = 0;
728 if (((value&0xf00)>>8) > Apwrdelta)
729 t3 = ((value&0xf00)>>8)-(Apwrdelta);
730 else
731 t3 = 0;
732 if (((value&0xf000)>>12) > Apwrdelta)
733 t4 = ((value&0xf000)>>12)-(Apwrdelta);
734 else
735 t4 = 0;
736 }
737 Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
738
739 if (i == 0)
740 pAd->Tx20MPwrCfgABand[i] = (pAd->Tx20MPwrCfgABand[i] & 0x0000FFFF) | (Adata & 0xFFFF0000);
741 else
742 pAd->Tx20MPwrCfgABand[i] = Adata;
743
744 DBGPRINT_RAW(RT_DEBUG_TRACE, ("20MHz BW, 5GHz band, Adata = %lx \n", Adata));
745 }
746 }
747
748 //
749 // Check this block is valid for 40MHz in 5G. If invalid, use parameter for 20MHz in 2.4G
750 //
751 bValid = TRUE;
752 for (i=0; i<6; i++)
753 {
754 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + 2 + i*2, value);
755 if (((value & 0x00FF) == 0x00FF) || ((value & 0xFF00) == 0xFF00))
756 {
757 bValid = FALSE;
758 break;
759 }
760 }
761
762 //
763 // Get Txpower per MCS for 40MHz in 5G.
764 //
765 if (bValid)
766 {
767 for (i=0; i<4; i++)
768 {
769 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + i*4, value);
770 if (bApwrdeltaMinus == FALSE)
771 {
772 t1 = (value&0xf)+(Apwrdelta);
773 if (t1 > 0xf)
774 t1 = 0xf;
775 t2 = ((value&0xf0)>>4)+(Apwrdelta);
776 if (t2 > 0xf)
777 t2 = 0xf;
778 t3 = ((value&0xf00)>>8)+(Apwrdelta);
779 if (t3 > 0xf)
780 t3 = 0xf;
781 t4 = ((value&0xf000)>>12)+(Apwrdelta);
782 if (t4 > 0xf)
783 t4 = 0xf;
784 }
785 else
786 {
787 if ((value&0xf) > Apwrdelta)
788 t1 = (value&0xf)-(Apwrdelta);
789 else
790 t1 = 0;
791 if (((value&0xf0)>>4) > Apwrdelta)
792 t2 = ((value&0xf0)>>4)-(Apwrdelta);
793 else
794 t2 = 0;
795 if (((value&0xf00)>>8) > Apwrdelta)
796 t3 = ((value&0xf00)>>8)-(Apwrdelta);
797 else
798 t3 = 0;
799 if (((value&0xf000)>>12) > Apwrdelta)
800 t4 = ((value&0xf000)>>12)-(Apwrdelta);
801 else
802 t4 = 0;
803 }
804 Adata = t1 + (t2<<4) + (t3<<8) + (t4<<12);
805
806 RT28xx_EEPROM_READ16(pAd, EEPROM_TXPOWER_BYRATE_40MHZ_5G + i*4 + 2, value);
807 if (bApwrdeltaMinus == FALSE)
808 {
809 t1 = (value&0xf)+(Apwrdelta);
810 if (t1 > 0xf)
811 t1 = 0xf;
812 t2 = ((value&0xf0)>>4)+(Apwrdelta);
813 if (t2 > 0xf)
814 t2 = 0xf;
815 t3 = ((value&0xf00)>>8)+(Apwrdelta);
816 if (t3 > 0xf)
817 t3 = 0xf;
818 t4 = ((value&0xf000)>>12)+(Apwrdelta);
819 if (t4 > 0xf)
820 t4 = 0xf;
821 }
822 else
823 {
824 if ((value&0xf) > Apwrdelta)
825 t1 = (value&0xf)-(Apwrdelta);
826 else
827 t1 = 0;
828 if (((value&0xf0)>>4) > Apwrdelta)
829 t2 = ((value&0xf0)>>4)-(Apwrdelta);
830 else
831 t2 = 0;
832 if (((value&0xf00)>>8) > Apwrdelta)
833 t3 = ((value&0xf00)>>8)-(Apwrdelta);
834 else
835 t3 = 0;
836 if (((value&0xf000)>>12) > Apwrdelta)
837 t4 = ((value&0xf000)>>12)-(Apwrdelta);
838 else
839 t4 = 0;
840 }
841 Adata |= ((t1<<16) + (t2<<20) + (t3<<24) + (t4<<28));
842
843 if (i == 0)
844 pAd->Tx40MPwrCfgABand[i+1] = (pAd->Tx40MPwrCfgABand[i+1] & 0x0000FFFF) | (Adata & 0xFFFF0000);
845 else
846 pAd->Tx40MPwrCfgABand[i+1] = Adata;
847
848 DBGPRINT_RAW(RT_DEBUG_TRACE, ("40MHz BW, 5GHz band, Adata = %lx \n", Adata));
849 }
850 }
851 }
852
853
854 /*
855 ========================================================================
856
857 Routine Description:
858 Read initial channel power parameters from EEPROM
859
860 Arguments:
861 Adapter Pointer to our adapter
862
863 Return Value:
864 None
865
866 IRQL = PASSIVE_LEVEL
867
868 Note:
869
870 ========================================================================
871 */
872 VOID RTMPReadChannelPwr(
873 IN PRTMP_ADAPTER pAd)
874 {
875 UCHAR i, choffset;
876 EEPROM_TX_PWR_STRUC Power;
877 EEPROM_TX_PWR_STRUC Power2;
878
879 // Read Tx power value for all channels
880 // Value from 1 - 0x7f. Default value is 24.
881 // Power value : 2.4G 0x00 (0) ~ 0x1F (31)
882 // : 5.5G 0xF9 (-7) ~ 0x0F (15)
883
884 // 0. 11b/g, ch1 - ch 14
885 for (i = 0; i < 7; i++)
886 {
887 // Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_G_TX_PWR_OFFSET + i * 2);
888 // Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_G_TX2_PWR_OFFSET + i * 2);
889 RT28xx_EEPROM_READ16(pAd, EEPROM_G_TX_PWR_OFFSET + i * 2, Power.word);
890 RT28xx_EEPROM_READ16(pAd, EEPROM_G_TX2_PWR_OFFSET + i * 2, Power2.word);
891 pAd->TxPower[i * 2].Channel = i * 2 + 1;
892 pAd->TxPower[i * 2 + 1].Channel = i * 2 + 2;
893
894 if ((Power.field.Byte0 > 31) || (Power.field.Byte0 < 0))
895 pAd->TxPower[i * 2].Power = DEFAULT_RF_TX_POWER;
896 else
897 pAd->TxPower[i * 2].Power = Power.field.Byte0;
898
899 if ((Power.field.Byte1 > 31) || (Power.field.Byte1 < 0))
900 pAd->TxPower[i * 2 + 1].Power = DEFAULT_RF_TX_POWER;
901 else
902 pAd->TxPower[i * 2 + 1].Power = Power.field.Byte1;
903
904 if ((Power2.field.Byte0 > 31) || (Power2.field.Byte0 < 0))
905 pAd->TxPower[i * 2].Power2 = DEFAULT_RF_TX_POWER;
906 else
907 pAd->TxPower[i * 2].Power2 = Power2.field.Byte0;
908
909 if ((Power2.field.Byte1 > 31) || (Power2.field.Byte1 < 0))
910 pAd->TxPower[i * 2 + 1].Power2 = DEFAULT_RF_TX_POWER;
911 else
912 pAd->TxPower[i * 2 + 1].Power2 = Power2.field.Byte1;
913 }
914
915 // 1. U-NII lower/middle band: 36, 38, 40; 44, 46, 48; 52, 54, 56; 60, 62, 64 (including central frequency in BW 40MHz)
916 // 1.1 Fill up channel
917 choffset = 14;
918 for (i = 0; i < 4; i++)
919 {
920 pAd->TxPower[3 * i + choffset + 0].Channel = 36 + i * 8 + 0;
921 pAd->TxPower[3 * i + choffset + 0].Power = DEFAULT_RF_TX_POWER;
922 pAd->TxPower[3 * i + choffset + 0].Power2 = DEFAULT_RF_TX_POWER;
923
924 pAd->TxPower[3 * i + choffset + 1].Channel = 36 + i * 8 + 2;
925 pAd->TxPower[3 * i + choffset + 1].Power = DEFAULT_RF_TX_POWER;
926 pAd->TxPower[3 * i + choffset + 1].Power2 = DEFAULT_RF_TX_POWER;
927
928 pAd->TxPower[3 * i + choffset + 2].Channel = 36 + i * 8 + 4;
929 pAd->TxPower[3 * i + choffset + 2].Power = DEFAULT_RF_TX_POWER;
930 pAd->TxPower[3 * i + choffset + 2].Power2 = DEFAULT_RF_TX_POWER;
931 }
932
933 // 1.2 Fill up power
934 for (i = 0; i < 6; i++)
935 {
936 // Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + i * 2);
937 // Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + i * 2);
938 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + i * 2, Power.word);
939 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + i * 2, Power2.word);
940
941 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
942 pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
943
944 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
945 pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
946
947 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
948 pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
949
950 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
951 pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
952 }
953
954 // 2. HipperLAN 2 100, 102 ,104; 108, 110, 112; 116, 118, 120; 124, 126, 128; 132, 134, 136; 140 (including central frequency in BW 40MHz)
955 // 2.1 Fill up channel
956 choffset = 14 + 12;
957 for (i = 0; i < 5; i++)
958 {
959 pAd->TxPower[3 * i + choffset + 0].Channel = 100 + i * 8 + 0;
960 pAd->TxPower[3 * i + choffset + 0].Power = DEFAULT_RF_TX_POWER;
961 pAd->TxPower[3 * i + choffset + 0].Power2 = DEFAULT_RF_TX_POWER;
962
963 pAd->TxPower[3 * i + choffset + 1].Channel = 100 + i * 8 + 2;
964 pAd->TxPower[3 * i + choffset + 1].Power = DEFAULT_RF_TX_POWER;
965 pAd->TxPower[3 * i + choffset + 1].Power2 = DEFAULT_RF_TX_POWER;
966
967 pAd->TxPower[3 * i + choffset + 2].Channel = 100 + i * 8 + 4;
968 pAd->TxPower[3 * i + choffset + 2].Power = DEFAULT_RF_TX_POWER;
969 pAd->TxPower[3 * i + choffset + 2].Power2 = DEFAULT_RF_TX_POWER;
970 }
971 pAd->TxPower[3 * 5 + choffset + 0].Channel = 140;
972 pAd->TxPower[3 * 5 + choffset + 0].Power = DEFAULT_RF_TX_POWER;
973 pAd->TxPower[3 * 5 + choffset + 0].Power2 = DEFAULT_RF_TX_POWER;
974
975 // 2.2 Fill up power
976 for (i = 0; i < 8; i++)
977 {
978 // Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2);
979 // Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2);
980 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2, Power.word);
981 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2, Power2.word);
982
983 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
984 pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
985
986 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
987 pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
988
989 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
990 pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
991
992 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
993 pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
994 }
995
996 // 3. U-NII upper band: 149, 151, 153; 157, 159, 161; 165 (including central frequency in BW 40MHz)
997 // 3.1 Fill up channel
998 choffset = 14 + 12 + 16;
999 for (i = 0; i < 2; i++)
1000 {
1001 pAd->TxPower[3 * i + choffset + 0].Channel = 149 + i * 8 + 0;
1002 pAd->TxPower[3 * i + choffset + 0].Power = DEFAULT_RF_TX_POWER;
1003 pAd->TxPower[3 * i + choffset + 0].Power2 = DEFAULT_RF_TX_POWER;
1004
1005 pAd->TxPower[3 * i + choffset + 1].Channel = 149 + i * 8 + 2;
1006 pAd->TxPower[3 * i + choffset + 1].Power = DEFAULT_RF_TX_POWER;
1007 pAd->TxPower[3 * i + choffset + 1].Power2 = DEFAULT_RF_TX_POWER;
1008
1009 pAd->TxPower[3 * i + choffset + 2].Channel = 149 + i * 8 + 4;
1010 pAd->TxPower[3 * i + choffset + 2].Power = DEFAULT_RF_TX_POWER;
1011 pAd->TxPower[3 * i + choffset + 2].Power2 = DEFAULT_RF_TX_POWER;
1012 }
1013 pAd->TxPower[3 * 2 + choffset + 0].Channel = 165;
1014 pAd->TxPower[3 * 2 + choffset + 0].Power = DEFAULT_RF_TX_POWER;
1015 pAd->TxPower[3 * 2 + choffset + 0].Power2 = DEFAULT_RF_TX_POWER;
1016
1017 // 3.2 Fill up power
1018 for (i = 0; i < 4; i++)
1019 {
1020 // Power.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2);
1021 // Power2.word = RTMP_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2);
1022 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX_PWR_OFFSET + (choffset - 14) + i * 2, Power.word);
1023 RT28xx_EEPROM_READ16(pAd, EEPROM_A_TX2_PWR_OFFSET + (choffset - 14) + i * 2, Power2.word);
1024
1025 if ((Power.field.Byte0 < 16) && (Power.field.Byte0 >= -7))
1026 pAd->TxPower[i * 2 + choffset + 0].Power = Power.field.Byte0;
1027
1028 if ((Power.field.Byte1 < 16) && (Power.field.Byte1 >= -7))
1029 pAd->TxPower[i * 2 + choffset + 1].Power = Power.field.Byte1;
1030
1031 if ((Power2.field.Byte0 < 16) && (Power2.field.Byte0 >= -7))
1032 pAd->TxPower[i * 2 + choffset + 0].Power2 = Power2.field.Byte0;
1033
1034 if ((Power2.field.Byte1 < 16) && (Power2.field.Byte1 >= -7))
1035 pAd->TxPower[i * 2 + choffset + 1].Power2 = Power2.field.Byte1;
1036 }
1037
1038 // 4. Print and Debug
1039 choffset = 14 + 12 + 16 + 7;
1040
1041 }
1042
1043 /*
1044 ========================================================================
1045
1046 Routine Description:
1047 Read the following from the registry
1048 1. All the parameters
1049 2. NetworkAddres
1050
1051 Arguments:
1052 Adapter Pointer to our adapter
1053 WrapperConfigurationContext For use by NdisOpenConfiguration
1054
1055 Return Value:
1056 NDIS_STATUS_SUCCESS
1057 NDIS_STATUS_FAILURE
1058 NDIS_STATUS_RESOURCES
1059
1060 IRQL = PASSIVE_LEVEL
1061
1062 Note:
1063
1064 ========================================================================
1065 */
1066 NDIS_STATUS NICReadRegParameters(
1067 IN PRTMP_ADAPTER pAd,
1068 IN NDIS_HANDLE WrapperConfigurationContext
1069 )
1070 {
1071 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
1072 DBGPRINT_S(Status, ("<-- NICReadRegParameters, Status=%x\n", Status));
1073 return Status;
1074 }
1075
1076
1077 #ifdef RT2870
1078 /*
1079 ========================================================================
1080
1081 Routine Description:
1082 For RF filter calibration purpose
1083
1084 Arguments:
1085 pAd Pointer to our adapter
1086
1087 Return Value:
1088 None
1089
1090 IRQL = PASSIVE_LEVEL
1091
1092 ========================================================================
1093 */
1094 VOID RTUSBFilterCalibration(
1095 IN PRTMP_ADAPTER pAd)
1096 {
1097 UCHAR R55x = 0, value, FilterTarget = 0x1E, BBPValue;
1098 UINT loop = 0, count = 0, loopcnt = 0, ReTry = 0;
1099 UCHAR RF_R24_Value = 0;
1100
1101 // Give bbp filter initial value
1102 pAd->Mlme.CaliBW20RfR24 = 0x16;
1103 pAd->Mlme.CaliBW40RfR24 = 0x36; //Bit[5] must be 1 for BW 40
1104
1105 do
1106 {
1107 if (loop == 1) //BandWidth = 40 MHz
1108 {
1109 // Write 0x27 to RF_R24 to program filter
1110 RF_R24_Value = 0x27;
1111 RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1112 FilterTarget = 0x19;
1113
1114 // when calibrate BW40, BBP mask must set to BW40.
1115 RTUSBReadBBPRegister(pAd, BBP_R4, &BBPValue);
1116 BBPValue&= (~0x18);
1117 BBPValue|= (0x10);
1118 RTUSBWriteBBPRegister(pAd, BBP_R4, BBPValue);
1119 }
1120 else //BandWidth = 20 MHz
1121 {
1122 // Write 0x07 to RF_R24 to program filter
1123 RF_R24_Value = 0x07;
1124 RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1125 FilterTarget = 0x16;
1126 }
1127
1128 // Write 0x01 to RF_R22 to enable baseband loopback mode
1129 RT30xxReadRFRegister(pAd, RF_R22, &value);
1130 value |= 0x01;
1131 RT30xxWriteRFRegister(pAd, RF_R22, value);
1132
1133 // Write 0x00 to BBP_R24 to set power & frequency of passband test tone
1134 RTUSBWriteBBPRegister(pAd, BBP_R24, 0);
1135
1136 do
1137 {
1138 // Write 0x90 to BBP_R25 to transmit test tone
1139 RTUSBWriteBBPRegister(pAd, BBP_R25, 0x90);
1140
1141 RTMPusecDelay(1000);
1142 // Read BBP_R55[6:0] for received power, set R55x = BBP_R55[6:0]
1143 RTUSBReadBBPRegister(pAd, BBP_R55, &value);
1144 R55x = value & 0xFF;
1145
1146 } while ((ReTry++ < 100) && (R55x == 0));
1147
1148 // Write 0x06 to BBP_R24 to set power & frequency of stopband test tone
1149 RTUSBWriteBBPRegister(pAd, BBP_R24, 0x06);
1150
1151 while(TRUE)
1152 {
1153 // Write 0x90 to BBP_R25 to transmit test tone
1154 RTUSBWriteBBPRegister(pAd, BBP_R25, 0x90);
1155
1156 //We need to wait for calibration
1157 RTMPusecDelay(1000);
1158 RTUSBReadBBPRegister(pAd, BBP_R55, &value);
1159 value &= 0xFF;
1160 if ((R55x - value) < FilterTarget)
1161 {
1162 RF_R24_Value ++;
1163 }
1164 else if ((R55x - value) == FilterTarget)
1165 {
1166 RF_R24_Value ++;
1167 count ++;
1168 }
1169 else
1170 {
1171 break;
1172 }
1173
1174 // prevent infinite loop cause driver hang.
1175 if (loopcnt++ > 100)
1176 {
1177 DBGPRINT(RT_DEBUG_ERROR, ("RTUSBFilterCalibration - can't find a valid value, loopcnt=%d stop calibrating", loopcnt));
1178 break;
1179 }
1180
1181 // Write RF_R24 to program filter
1182 RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1183 }
1184
1185 if (count > 0)
1186 {
1187 RF_R24_Value = RF_R24_Value - ((count) ? (1) : (0));
1188 }
1189
1190 // Store for future usage
1191 if (loopcnt < 100)
1192 {
1193 if (loop++ == 0)
1194 {
1195 //BandWidth = 20 MHz
1196 pAd->Mlme.CaliBW20RfR24 = (UCHAR)RF_R24_Value;
1197 }
1198 else
1199 {
1200 //BandWidth = 40 MHz
1201 pAd->Mlme.CaliBW40RfR24 = (UCHAR)RF_R24_Value;
1202 break;
1203 }
1204 }
1205 else
1206 break;
1207
1208 RT30xxWriteRFRegister(pAd, RF_R24, RF_R24_Value);
1209
1210 // reset count
1211 count = 0;
1212 } while(TRUE);
1213
1214 //
1215 // Set back to initial state
1216 //
1217 RTUSBWriteBBPRegister(pAd, BBP_R24, 0);
1218
1219 RT30xxReadRFRegister(pAd, RF_R22, &value);
1220 value &= ~(0x01);
1221 RT30xxWriteRFRegister(pAd, RF_R22, value);
1222
1223 // set BBP back to BW20
1224 RTUSBReadBBPRegister(pAd, BBP_R4, &BBPValue);
1225 BBPValue&= (~0x18);
1226 RTUSBWriteBBPRegister(pAd, BBP_R4, BBPValue);
1227
1228 DBGPRINT(RT_DEBUG_TRACE, ("RTUSBFilterCalibration - CaliBW20RfR24=0x%x, CaliBW40RfR24=0x%x\n", pAd->Mlme.CaliBW20RfR24, pAd->Mlme.CaliBW40RfR24));
1229 }
1230
1231
1232 VOID NICInitRT30xxRFRegisters(IN PRTMP_ADAPTER pAd)
1233 {
1234 INT i;
1235 // Driver must read EEPROM to get RfIcType before initial RF registers
1236 // Initialize RF register to default value
1237 if (IS_RT3070(pAd) && ((pAd->RfIcType == RFIC_3020) ||(pAd->RfIcType == RFIC_2020)))
1238 {
1239 // Init RF calibration
1240 // Driver should toggle RF R30 bit7 before init RF registers
1241 ULONG RfReg = 0;
1242 RT30xxReadRFRegister(pAd, RF_R30, (PUCHAR)&RfReg);
1243 RfReg |= 0x80;
1244 RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR)RfReg);
1245 RTMPusecDelay(1000);
1246 RfReg &= 0x7F;
1247 RT30xxWriteRFRegister(pAd, RF_R30, (UCHAR)RfReg);
1248
1249 // Initialize RF register to default value
1250 for (i = 0; i < NUM_RF_REG_PARMS; i++)
1251 {
1252 RT30xxWriteRFRegister(pAd, RT30xx_RFRegTable[i].Register, RT30xx_RFRegTable[i].Value);
1253 }
1254
1255 //For RF filter Calibration
1256 RTUSBFilterCalibration(pAd);
1257 }
1258
1259 }
1260 #endif // RT2870 //
1261
1262
1263 /*
1264 ========================================================================
1265
1266 Routine Description:
1267 Read initial parameters from EEPROM
1268
1269 Arguments:
1270 Adapter Pointer to our adapter
1271
1272 Return Value:
1273 None
1274
1275 IRQL = PASSIVE_LEVEL
1276
1277 Note:
1278
1279 ========================================================================
1280 */
1281 VOID NICReadEEPROMParameters(
1282 IN PRTMP_ADAPTER pAd,
1283 IN PUCHAR mac_addr)
1284 {
1285 UINT32 data = 0;
1286 USHORT i, value, value2;
1287 UCHAR TmpPhy;
1288 EEPROM_TX_PWR_STRUC Power;
1289 EEPROM_VERSION_STRUC Version;
1290 EEPROM_ANTENNA_STRUC Antenna;
1291 EEPROM_NIC_CONFIG2_STRUC NicConfig2;
1292
1293 DBGPRINT(RT_DEBUG_TRACE, ("--> NICReadEEPROMParameters\n"));
1294
1295 // Init EEPROM Address Number, before access EEPROM; if 93c46, EEPROMAddressNum=6, else if 93c66, EEPROMAddressNum=8
1296 RTMP_IO_READ32(pAd, E2PROM_CSR, &data);
1297 DBGPRINT(RT_DEBUG_TRACE, ("--> E2PROM_CSR = 0x%x\n", data));
1298
1299 if((data & 0x30) == 0)
1300 pAd->EEPROMAddressNum = 6; // 93C46
1301 else if((data & 0x30) == 0x10)
1302 pAd->EEPROMAddressNum = 8; // 93C66
1303 else
1304 pAd->EEPROMAddressNum = 8; // 93C86
1305 DBGPRINT(RT_DEBUG_TRACE, ("--> EEPROMAddressNum = %d\n", pAd->EEPROMAddressNum ));
1306
1307 // RT2860 MAC no longer auto load MAC address from E2PROM. Driver has to intialize
1308 // MAC address registers according to E2PROM setting
1309 if (mac_addr == NULL ||
1310 strlen(mac_addr) != 17 ||
1311 mac_addr[2] != ':' || mac_addr[5] != ':' || mac_addr[8] != ':' ||
1312 mac_addr[11] != ':' || mac_addr[14] != ':')
1313 {
1314 USHORT Addr01,Addr23,Addr45 ;
1315
1316 RT28xx_EEPROM_READ16(pAd, 0x04, Addr01);
1317 RT28xx_EEPROM_READ16(pAd, 0x06, Addr23);
1318 RT28xx_EEPROM_READ16(pAd, 0x08, Addr45);
1319
1320 pAd->PermanentAddress[0] = (UCHAR)(Addr01 & 0xff);
1321 pAd->PermanentAddress[1] = (UCHAR)(Addr01 >> 8);
1322 pAd->PermanentAddress[2] = (UCHAR)(Addr23 & 0xff);
1323 pAd->PermanentAddress[3] = (UCHAR)(Addr23 >> 8);
1324 pAd->PermanentAddress[4] = (UCHAR)(Addr45 & 0xff);
1325 pAd->PermanentAddress[5] = (UCHAR)(Addr45 >> 8);
1326
1327 DBGPRINT(RT_DEBUG_TRACE, ("Initialize MAC Address from E2PROM \n"));
1328 }
1329 else
1330 {
1331 INT j;
1332 PUCHAR macptr;
1333
1334 macptr = mac_addr;
1335
1336 for (j=0; j<MAC_ADDR_LEN; j++)
1337 {
1338 AtoH(macptr, &pAd->PermanentAddress[j], 1);
1339 macptr=macptr+3;
1340 }
1341
1342 DBGPRINT(RT_DEBUG_TRACE, ("Initialize MAC Address from module parameter \n"));
1343 }
1344
1345
1346 {
1347 #if 0
1348 USHORT Addr01,Addr23,Addr45 ;
1349
1350 Addr01=RTMP_EEPROM_READ16(pAd, 0x04);
1351 Addr23=RTMP_EEPROM_READ16(pAd, 0x06);
1352 Addr45=RTMP_EEPROM_READ16(pAd, 0x08);
1353
1354 pAd->PermanentAddress[0] = (UCHAR)(Addr01 & 0xff);
1355 pAd->PermanentAddress[1] = (UCHAR)(Addr01 >> 8);
1356 pAd->PermanentAddress[2] = (UCHAR)(Addr23 & 0xff);
1357 pAd->PermanentAddress[3] = (UCHAR)(Addr23 >> 8);
1358 pAd->PermanentAddress[4] = (UCHAR)(Addr45 & 0xff);
1359 pAd->PermanentAddress[5] = (UCHAR)(Addr45 >> 8);
1360 #endif
1361 //more conveninet to test mbssid, so ap's bssid &0xf1
1362 if (pAd->PermanentAddress[0] == 0xff)
1363 pAd->PermanentAddress[0] = RandomByte(pAd)&0xf8;
1364
1365 //if (pAd->PermanentAddress[5] == 0xff)
1366 // pAd->PermanentAddress[5] = RandomByte(pAd)&0xf8;
1367
1368 DBGPRINT_RAW(RT_DEBUG_TRACE,("E2PROM MAC: =%02x:%02x:%02x:%02x:%02x:%02x\n",
1369 pAd->PermanentAddress[0], pAd->PermanentAddress[1],
1370 pAd->PermanentAddress[2], pAd->PermanentAddress[3],
1371 pAd->PermanentAddress[4], pAd->PermanentAddress[5]));
1372 if (pAd->bLocalAdminMAC == FALSE)
1373 {
1374 MAC_DW0_STRUC csr2;
1375 MAC_DW1_STRUC csr3;
1376 COPY_MAC_ADDR(pAd->CurrentAddress, pAd->PermanentAddress);
1377 csr2.field.Byte0 = pAd->CurrentAddress[0];
1378 csr2.field.Byte1 = pAd->CurrentAddress[1];
1379 csr2.field.Byte2 = pAd->CurrentAddress[2];
1380 csr2.field.Byte3 = pAd->CurrentAddress[3];
1381 RTMP_IO_WRITE32(pAd, MAC_ADDR_DW0, csr2.word);
1382 csr3.word = 0;
1383 csr3.field.Byte4 = pAd->CurrentAddress[4];
1384 csr3.field.Byte5 = pAd->CurrentAddress[5];
1385 csr3.field.U2MeMask = 0xff;
1386 RTMP_IO_WRITE32(pAd, MAC_ADDR_DW1, csr3.word);
1387 DBGPRINT_RAW(RT_DEBUG_TRACE,("E2PROM MAC: =%02x:%02x:%02x:%02x:%02x:%02x\n",
1388 pAd->PermanentAddress[0], pAd->PermanentAddress[1],
1389 pAd->PermanentAddress[2], pAd->PermanentAddress[3],
1390 pAd->PermanentAddress[4], pAd->PermanentAddress[5]));
1391 }
1392 }
1393
1394 // if not return early. cause fail at emulation.
1395 // Init the channel number for TX channel power
1396 RTMPReadChannelPwr(pAd);
1397
1398 // if E2PROM version mismatch with driver's expectation, then skip
1399 // all subsequent E2RPOM retieval and set a system error bit to notify GUI
1400 RT28xx_EEPROM_READ16(pAd, EEPROM_VERSION_OFFSET, Version.word);
1401 pAd->EepromVersion = Version.field.Version + Version.field.FaeReleaseNumber * 256;
1402 DBGPRINT(RT_DEBUG_TRACE, ("E2PROM: Version = %d, FAE release #%d\n", Version.field.Version, Version.field.FaeReleaseNumber));
1403
1404 if (Version.field.Version > VALID_EEPROM_VERSION)
1405 {
1406 DBGPRINT_ERR(("E2PROM: WRONG VERSION 0x%x, should be %d\n",Version.field.Version, VALID_EEPROM_VERSION));
1407 /*pAd->SystemErrorBitmap |= 0x00000001;
1408
1409 // hard-code default value when no proper E2PROM installed
1410 pAd->bAutoTxAgcA = FALSE;
1411 pAd->bAutoTxAgcG = FALSE;
1412
1413 // Default the channel power
1414 for (i = 0; i < MAX_NUM_OF_CHANNELS; i++)
1415 pAd->TxPower[i].Power = DEFAULT_RF_TX_POWER;
1416
1417 // Default the channel power
1418 for (i = 0; i < MAX_NUM_OF_11JCHANNELS; i++)
1419 pAd->TxPower11J[i].Power = DEFAULT_RF_TX_POWER;
1420
1421 for(i = 0; i < NUM_EEPROM_BBP_PARMS; i++)
1422 pAd->EEPROMDefaultValue[i] = 0xffff;
1423 return; */
1424 }
1425
1426 // Read BBP default value from EEPROM and store to array(EEPROMDefaultValue) in pAd
1427 RT28xx_EEPROM_READ16(pAd, EEPROM_NIC1_OFFSET, value);
1428 pAd->EEPROMDefaultValue[0] = value;
1429
1430 RT28xx_EEPROM_READ16(pAd, EEPROM_NIC2_OFFSET, value);
1431 pAd->EEPROMDefaultValue[1] = value;
1432
1433 RT28xx_EEPROM_READ16(pAd, 0x38, value); // Country Region
1434 pAd->EEPROMDefaultValue[2] = value;
1435
1436 for(i = 0; i < 8; i++)
1437 {
1438 RT28xx_EEPROM_READ16(pAd, EEPROM_BBP_BASE_OFFSET + i*2, value);
1439 pAd->EEPROMDefaultValue[i+3] = value;
1440 }
1441
1442 // We have to parse NIC configuration 0 at here.
1443 // If TSSI did not have preloaded value, it should reset the TxAutoAgc to false
1444 // Therefore, we have to read TxAutoAgc control beforehand.
1445 // Read Tx AGC control bit
1446 Antenna.word = pAd->EEPROMDefaultValue[0];
1447 if (Antenna.word == 0xFFFF)
1448 {
1449 Antenna.word = 0;
1450 Antenna.field.RfIcType = RFIC_2820;
1451 Antenna.field.TxPath = 1;
1452 Antenna.field.RxPath = 2;
1453 DBGPRINT(RT_DEBUG_WARN, ("E2PROM error, hard code as 0x%04x\n", Antenna.word));
1454 }
1455
1456 // Choose the desired Tx&Rx stream.
1457 if ((pAd->CommonCfg.TxStream == 0) || (pAd->CommonCfg.TxStream > Antenna.field.TxPath))
1458 pAd->CommonCfg.TxStream = Antenna.field.TxPath;
1459
1460 if ((pAd->CommonCfg.RxStream == 0) || (pAd->CommonCfg.RxStream > Antenna.field.RxPath))
1461 {
1462 pAd->CommonCfg.RxStream = Antenna.field.RxPath;
1463
1464 if ((pAd->MACVersion < RALINK_2883_VERSION) &&
1465 (pAd->CommonCfg.RxStream > 2))
1466 {
1467 // only 2 Rx streams for RT2860 series
1468 pAd->CommonCfg.RxStream = 2;
1469 }
1470 }
1471
1472 // 3*3
1473 // read value from EEPROM and set them to CSR174 ~ 177 in chain0 ~ chain2
1474 // yet implement
1475 for(i=0; i<3; i++)
1476 {
1477 }
1478
1479 NicConfig2.word = pAd->EEPROMDefaultValue[1];
1480
1481
1482
1483 #ifdef CONFIG_STA_SUPPORT
1484 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1485 {
1486 NicConfig2.word = 0;
1487 if ((NicConfig2.word & 0x00ff) == 0xff)
1488 {
1489 NicConfig2.word &= 0xff00;
1490 }
1491
1492 if ((NicConfig2.word >> 8) == 0xff)
1493 {
1494 NicConfig2.word &= 0x00ff;
1495 }
1496 }
1497 #endif // CONFIG_STA_SUPPORT //
1498
1499 if (NicConfig2.field.DynamicTxAgcControl == 1)
1500 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = TRUE;
1501 else
1502 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = FALSE;
1503
1504 DBGPRINT_RAW(RT_DEBUG_TRACE, ("NICReadEEPROMParameters: RxPath = %d, TxPath = %d\n", Antenna.field.RxPath, Antenna.field.TxPath));
1505
1506 // Save the antenna for future use
1507 pAd->Antenna.word = Antenna.word;
1508
1509 //
1510 // Reset PhyMode if we don't support 802.11a
1511 // Only RFIC_2850 & RFIC_2750 support 802.11a
1512 //
1513 if ((Antenna.field.RfIcType != RFIC_2850) && (Antenna.field.RfIcType != RFIC_2750))
1514 {
1515 if ((pAd->CommonCfg.PhyMode == PHY_11ABG_MIXED) ||
1516 (pAd->CommonCfg.PhyMode == PHY_11A))
1517 pAd->CommonCfg.PhyMode = PHY_11BG_MIXED;
1518 #ifdef DOT11_N_SUPPORT
1519 else if ((pAd->CommonCfg.PhyMode == PHY_11ABGN_MIXED) ||
1520 (pAd->CommonCfg.PhyMode == PHY_11AN_MIXED) ||
1521 (pAd->CommonCfg.PhyMode == PHY_11AGN_MIXED) ||
1522 (pAd->CommonCfg.PhyMode == PHY_11N_5G))
1523 pAd->CommonCfg.PhyMode = PHY_11BGN_MIXED;
1524 #endif // DOT11_N_SUPPORT //
1525 }
1526
1527 // Read TSSI reference and TSSI boundary for temperature compensation. This is ugly
1528 // 0. 11b/g
1529 {
1530 /* these are tempature reference value (0x00 ~ 0xFE)
1531 ex: 0x00 0x15 0x25 0x45 0x88 0xA0 0xB5 0xD0 0xF0
1532 TssiPlusBoundaryG [4] [3] [2] [1] [0] (smaller) +
1533 TssiMinusBoundaryG[0] [1] [2] [3] [4] (larger) */
1534 RT28xx_EEPROM_READ16(pAd, 0x6E, Power.word);
1535 pAd->TssiMinusBoundaryG[4] = Power.field.Byte0;
1536 pAd->TssiMinusBoundaryG[3] = Power.field.Byte1;
1537 RT28xx_EEPROM_READ16(pAd, 0x70, Power.word);
1538 pAd->TssiMinusBoundaryG[2] = Power.field.Byte0;
1539 pAd->TssiMinusBoundaryG[1] = Power.field.Byte1;
1540 RT28xx_EEPROM_READ16(pAd, 0x72, Power.word);
1541 pAd->TssiRefG = Power.field.Byte0; /* reference value [0] */
1542 pAd->TssiPlusBoundaryG[1] = Power.field.Byte1;
1543 RT28xx_EEPROM_READ16(pAd, 0x74, Power.word);
1544 pAd->TssiPlusBoundaryG[2] = Power.field.Byte0;
1545 pAd->TssiPlusBoundaryG[3] = Power.field.Byte1;
1546 RT28xx_EEPROM_READ16(pAd, 0x76, Power.word);
1547 pAd->TssiPlusBoundaryG[4] = Power.field.Byte0;
1548 pAd->TxAgcStepG = Power.field.Byte1;
1549 pAd->TxAgcCompensateG = 0;
1550 pAd->TssiMinusBoundaryG[0] = pAd->TssiRefG;
1551 pAd->TssiPlusBoundaryG[0] = pAd->TssiRefG;
1552
1553 // Disable TxAgc if the based value is not right
1554 if (pAd->TssiRefG == 0xff)
1555 pAd->bAutoTxAgcG = FALSE;
1556
1557 DBGPRINT(RT_DEBUG_TRACE,("E2PROM: G Tssi[-4 .. +4] = %d %d %d %d - %d -%d %d %d %d, step=%d, tuning=%d\n",
1558 pAd->TssiMinusBoundaryG[4], pAd->TssiMinusBoundaryG[3], pAd->TssiMinusBoundaryG[2], pAd->TssiMinusBoundaryG[1],
1559 pAd->TssiRefG,
1560 pAd->TssiPlusBoundaryG[1], pAd->TssiPlusBoundaryG[2], pAd->TssiPlusBoundaryG[3], pAd->TssiPlusBoundaryG[4],
1561 pAd->TxAgcStepG, pAd->bAutoTxAgcG));
1562 }
1563 // 1. 11a
1564 {
1565 RT28xx_EEPROM_READ16(pAd, 0xD4, Power.word);
1566 pAd->TssiMinusBoundaryA[4] = Power.field.Byte0;
1567 pAd->TssiMinusBoundaryA[3] = Power.field.Byte1;
1568 RT28xx_EEPROM_READ16(pAd, 0xD6, Power.word);
1569 pAd->TssiMinusBoundaryA[2] = Power.field.Byte0;
1570 pAd->TssiMinusBoundaryA[1] = Power.field.Byte1;
1571 RT28xx_EEPROM_READ16(pAd, 0xD8, Power.word);
1572 pAd->TssiRefA = Power.field.Byte0;
1573 pAd->TssiPlusBoundaryA[1] = Power.field.Byte1;
1574 RT28xx_EEPROM_READ16(pAd, 0xDA, Power.word);
1575 pAd->TssiPlusBoundaryA[2] = Power.field.Byte0;
1576 pAd->TssiPlusBoundaryA[3] = Power.field.Byte1;
1577 RT28xx_EEPROM_READ16(pAd, 0xDC, Power.word);
1578 pAd->TssiPlusBoundaryA[4] = Power.field.Byte0;
1579 pAd->TxAgcStepA = Power.field.Byte1;
1580 pAd->TxAgcCompensateA = 0;
1581 pAd->TssiMinusBoundaryA[0] = pAd->TssiRefA;
1582 pAd->TssiPlusBoundaryA[0] = pAd->TssiRefA;
1583
1584 // Disable TxAgc if the based value is not right
1585 if (pAd->TssiRefA == 0xff)
1586 pAd->bAutoTxAgcA = FALSE;
1587
1588 DBGPRINT(RT_DEBUG_TRACE,("E2PROM: A Tssi[-4 .. +4] = %d %d %d %d - %d -%d %d %d %d, step=%d, tuning=%d\n",
1589 pAd->TssiMinusBoundaryA[4], pAd->TssiMinusBoundaryA[3], pAd->TssiMinusBoundaryA[2], pAd->TssiMinusBoundaryA[1],
1590 pAd->TssiRefA,
1591 pAd->TssiPlusBoundaryA[1], pAd->TssiPlusBoundaryA[2], pAd->TssiPlusBoundaryA[3], pAd->TssiPlusBoundaryA[4],
1592 pAd->TxAgcStepA, pAd->bAutoTxAgcA));
1593 }
1594 pAd->BbpRssiToDbmDelta = 0x0;
1595
1596 // Read frequency offset setting for RF
1597 RT28xx_EEPROM_READ16(pAd, EEPROM_FREQ_OFFSET, value);
1598 if ((value & 0x00FF) != 0x00FF)
1599 pAd->RfFreqOffset = (ULONG) (value & 0x00FF);
1600 else
1601 pAd->RfFreqOffset = 0;
1602 DBGPRINT(RT_DEBUG_TRACE, ("E2PROM: RF FreqOffset=0x%lx \n", pAd->RfFreqOffset));
1603
1604 //CountryRegion byte offset (38h)
1605 value = pAd->EEPROMDefaultValue[2] >> 8; // 2.4G band
1606 value2 = pAd->EEPROMDefaultValue[2] & 0x00FF; // 5G band
1607
1608 if ((value <= REGION_MAXIMUM_BG_BAND) && (value2 <= REGION_MAXIMUM_A_BAND))
1609 {
1610 pAd->CommonCfg.CountryRegion = ((UCHAR) value) | 0x80;
1611 pAd->CommonCfg.CountryRegionForABand = ((UCHAR) value2) | 0x80;
1612 TmpPhy = pAd->CommonCfg.PhyMode;
1613 pAd->CommonCfg.PhyMode = 0xff;
1614 RTMPSetPhyMode(pAd, TmpPhy);
1615 #ifdef DOT11_N_SUPPORT
1616 SetCommonHT(pAd);
1617 #endif // DOT11_N_SUPPORT //
1618 }
1619
1620 //
1621 // Get RSSI Offset on EEPROM 0x9Ah & 0x9Ch.
1622 // The valid value are (-10 ~ 10)
1623 //
1624 RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET, value);
1625 pAd->BGRssiOffset0 = value & 0x00ff;
1626 pAd->BGRssiOffset1 = (value >> 8);
1627 RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_BG_OFFSET+2, value);
1628 pAd->BGRssiOffset2 = value & 0x00ff;
1629 pAd->ALNAGain1 = (value >> 8);
1630 RT28xx_EEPROM_READ16(pAd, EEPROM_LNA_OFFSET, value);
1631 pAd->BLNAGain = value & 0x00ff;
1632 pAd->ALNAGain0 = (value >> 8);
1633
1634 // Validate 11b/g RSSI_0 offset.
1635 if ((pAd->BGRssiOffset0 < -10) || (pAd->BGRssiOffset0 > 10))
1636 pAd->BGRssiOffset0 = 0;
1637
1638 // Validate 11b/g RSSI_1 offset.
1639 if ((pAd->BGRssiOffset1 < -10) || (pAd->BGRssiOffset1 > 10))
1640 pAd->BGRssiOffset1 = 0;
1641
1642 // Validate 11b/g RSSI_2 offset.
1643 if ((pAd->BGRssiOffset2 < -10) || (pAd->BGRssiOffset2 > 10))
1644 pAd->BGRssiOffset2 = 0;
1645
1646 RT28xx_EEPROM_READ16(pAd, EEPROM_RSSI_A_OFFSET, value);
1647 pAd->ARssiOffset0 = value & 0x00ff;
1648 pAd->ARssiOffset1 = (value >> 8);
1649 RT28xx_EEPROM_READ16(pAd, (EEPROM_RSSI_A_OFFSET+2), value);
1650 pAd->ARssiOffset2 = value & 0x00ff;
1651 pAd->ALNAGain2 = (value >> 8);
1652
1653 if (((UCHAR)pAd->ALNAGain1 == 0xFF) || (pAd->ALNAGain1 == 0x00))
1654 pAd->ALNAGain1 = pAd->ALNAGain0;
1655 if (((UCHAR)pAd->ALNAGain2 == 0xFF) || (pAd->ALNAGain2 == 0x00))
1656 pAd->ALNAGain2 = pAd->ALNAGain0;
1657
1658 // Validate 11a RSSI_0 offset.
1659 if ((pAd->ARssiOffset0 < -10) || (pAd->ARssiOffset0 > 10))
1660 pAd->ARssiOffset0 = 0;
1661
1662 // Validate 11a RSSI_1 offset.
1663 if ((pAd->ARssiOffset1 < -10) || (pAd->ARssiOffset1 > 10))
1664 pAd->ARssiOffset1 = 0;
1665
1666 //Validate 11a RSSI_2 offset.
1667 if ((pAd->ARssiOffset2 < -10) || (pAd->ARssiOffset2 > 10))
1668 pAd->ARssiOffset2 = 0;
1669
1670 //
1671 // Get LED Setting.
1672 //
1673 RT28xx_EEPROM_READ16(pAd, 0x3a, value);
1674 pAd->LedCntl.word = (value&0xff00) >> 8;
1675 RT28xx_EEPROM_READ16(pAd, EEPROM_LED1_OFFSET, value);
1676 pAd->Led1 = value;
1677 RT28xx_EEPROM_READ16(pAd, EEPROM_LED2_OFFSET, value);
1678 pAd->Led2 = value;
1679 RT28xx_EEPROM_READ16(pAd, EEPROM_LED3_OFFSET, value);
1680 pAd->Led3 = value;
1681
1682 RTMPReadTxPwrPerRate(pAd);
1683
1684 #ifdef SINGLE_SKU
1685 //pAd->CommonCfg.DefineMaxTxPwr = RTMP_EEPROM_READ16(pAd, EEPROM_DEFINE_MAX_TXPWR);
1686 RT28xx_EEPROM_READ16(pAd, EEPROM_DEFINE_MAX_TXPWR, pAd->CommonCfg.DefineMaxTxPwr);
1687 #endif // SINGLE_SKU //
1688
1689 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICReadEEPROMParameters\n"));
1690 }
1691
1692 /*
1693 ========================================================================
1694
1695 Routine Description:
1696 Set default value from EEPROM
1697
1698 Arguments:
1699 Adapter Pointer to our adapter
1700
1701 Return Value:
1702 None
1703
1704 IRQL = PASSIVE_LEVEL
1705
1706 Note:
1707
1708 ========================================================================
1709 */
1710 VOID NICInitAsicFromEEPROM(
1711 IN PRTMP_ADAPTER pAd)
1712 {
1713 #ifdef CONFIG_STA_SUPPORT
1714 UINT32 data = 0;
1715 UCHAR BBPR1 = 0;
1716 #endif // CONFIG_STA_SUPPORT //
1717 USHORT i;
1718 EEPROM_ANTENNA_STRUC Antenna;
1719 EEPROM_NIC_CONFIG2_STRUC NicConfig2;
1720 UCHAR BBPR3 = 0;
1721
1722 DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitAsicFromEEPROM\n"));
1723 for(i = 3; i < NUM_EEPROM_BBP_PARMS; i++)
1724 {
1725 UCHAR BbpRegIdx, BbpValue;
1726
1727 if ((pAd->EEPROMDefaultValue[i] != 0xFFFF) && (pAd->EEPROMDefaultValue[i] != 0))
1728 {
1729 BbpRegIdx = (UCHAR)(pAd->EEPROMDefaultValue[i] >> 8);
1730 BbpValue = (UCHAR)(pAd->EEPROMDefaultValue[i] & 0xff);
1731 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BbpRegIdx, BbpValue);
1732 }
1733 }
1734
1735 Antenna.word = pAd->Antenna.word;
1736 pAd->Mlme.RealRxPath = (UCHAR) Antenna.field.RxPath;
1737 pAd->RfIcType = (UCHAR) Antenna.field.RfIcType;
1738
1739 NicConfig2.word = pAd->EEPROMDefaultValue[1];
1740
1741
1742 // Save the antenna for future use
1743 pAd->NicConfig2.word = NicConfig2.word;
1744
1745 //
1746 // Send LED Setting to MCU.
1747 //
1748 if (pAd->LedCntl.word == 0xFF)
1749 {
1750 pAd->LedCntl.word = 0x01;
1751 pAd->Led1 = 0x5555;
1752 pAd->Led2 = 0x2221;
1753
1754 #ifdef RT2870
1755 pAd->Led3 = 0x5627;
1756 #endif // RT2870 //
1757 }
1758
1759 AsicSendCommandToMcu(pAd, 0x52, 0xff, (UCHAR)pAd->Led1, (UCHAR)(pAd->Led1 >> 8));
1760 AsicSendCommandToMcu(pAd, 0x53, 0xff, (UCHAR)pAd->Led2, (UCHAR)(pAd->Led2 >> 8));
1761 AsicSendCommandToMcu(pAd, 0x54, 0xff, (UCHAR)pAd->Led3, (UCHAR)(pAd->Led3 >> 8));
1762 pAd->LedIndicatorStregth = 0xFF;
1763 RTMPSetSignalLED(pAd, -100); // Force signal strength Led to be turned off, before link up
1764
1765 #ifdef CONFIG_STA_SUPPORT
1766 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1767 {
1768 // Read Hardware controlled Radio state enable bit
1769 if (NicConfig2.field.HardwareRadioControl == 1)
1770 {
1771 pAd->StaCfg.bHardwareRadio = TRUE;
1772
1773 // Read GPIO pin2 as Hardware controlled radio state
1774 RTMP_IO_READ32(pAd, GPIO_CTRL_CFG, &data);
1775 if ((data & 0x04) == 0)
1776 {
1777 pAd->StaCfg.bHwRadio = FALSE;
1778 pAd->StaCfg.bRadio = FALSE;
1779 // RTMP_IO_WRITE32(pAd, PWR_PIN_CFG, 0x00001818);
1780 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
1781 }
1782 }
1783 else
1784 pAd->StaCfg.bHardwareRadio = FALSE;
1785
1786 if (pAd->StaCfg.bRadio == FALSE)
1787 {
1788 RTMPSetLED(pAd, LED_RADIO_OFF);
1789 }
1790 else
1791 {
1792 RTMPSetLED(pAd, LED_RADIO_ON);
1793 }
1794 }
1795 #endif // CONFIG_STA_SUPPORT //
1796
1797 // Turn off patching for cardbus controller
1798 if (NicConfig2.field.CardbusAcceleration == 1)
1799 {
1800 // pAd->bTest1 = TRUE;
1801 }
1802
1803 if (NicConfig2.field.DynamicTxAgcControl == 1)
1804 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = TRUE;
1805 else
1806 pAd->bAutoTxAgcA = pAd->bAutoTxAgcG = FALSE;
1807 //
1808 // Since BBP has been progamed, to make sure BBP setting will be
1809 // upate inside of AsicAntennaSelect, so reset to UNKNOWN_BAND!!
1810 //
1811 pAd->CommonCfg.BandState = UNKNOWN_BAND;
1812
1813 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R3, &BBPR3);
1814 BBPR3 &= (~0x18);
1815 if(pAd->Antenna.field.RxPath == 3)
1816 {
1817 BBPR3 |= (0x10);
1818 }
1819 else if(pAd->Antenna.field.RxPath == 2)
1820 {
1821 BBPR3 |= (0x8);
1822 }
1823 else if(pAd->Antenna.field.RxPath == 1)
1824 {
1825 BBPR3 |= (0x0);
1826 }
1827 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R3, BBPR3);
1828
1829 #ifdef CONFIG_STA_SUPPORT
1830 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1831 {
1832 // Handle the difference when 1T
1833 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R1, &BBPR1);
1834 if(pAd->Antenna.field.TxPath == 1)
1835 {
1836 BBPR1 &= (~0x18);
1837 }
1838 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R1, BBPR1);
1839
1840 DBGPRINT(RT_DEBUG_TRACE, ("Use Hw Radio Control Pin=%d; if used Pin=%d;\n", pAd->CommonCfg.bHardwareRadio, pAd->CommonCfg.bHardwareRadio));
1841 }
1842 #endif // CONFIG_STA_SUPPORT //
1843 DBGPRINT(RT_DEBUG_TRACE, ("TxPath = %d, RxPath = %d, RFIC=%d, Polar+LED mode=%x\n", pAd->Antenna.field.TxPath, pAd->Antenna.field.RxPath, pAd->RfIcType, pAd->LedCntl.word));
1844 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitAsicFromEEPROM\n"));
1845 }
1846
1847 /*
1848 ========================================================================
1849
1850 Routine Description:
1851 Initialize NIC hardware
1852
1853 Arguments:
1854 Adapter Pointer to our adapter
1855
1856 Return Value:
1857 None
1858
1859 IRQL = PASSIVE_LEVEL
1860
1861 Note:
1862
1863 ========================================================================
1864 */
1865 NDIS_STATUS NICInitializeAdapter(
1866 IN PRTMP_ADAPTER pAd,
1867 IN BOOLEAN bHardReset)
1868 {
1869 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
1870 WPDMA_GLO_CFG_STRUC GloCfg;
1871 // INT_MASK_CSR_STRUC IntMask;
1872 ULONG i =0, j=0;
1873 AC_TXOP_CSR0_STRUC csr0;
1874
1875 DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitializeAdapter\n"));
1876
1877 // 3. Set DMA global configuration except TX_DMA_EN and RX_DMA_EN bits:
1878 retry:
1879 i = 0;
1880 do
1881 {
1882 RTMP_IO_READ32(pAd, WPDMA_GLO_CFG, &GloCfg.word);
1883 if ((GloCfg.field.TxDMABusy == 0) && (GloCfg.field.RxDMABusy == 0))
1884 break;
1885
1886 RTMPusecDelay(1000);
1887 i++;
1888 }while ( i<100);
1889 DBGPRINT(RT_DEBUG_TRACE, ("<== DMA offset 0x208 = 0x%x\n", GloCfg.word));
1890 GloCfg.word &= 0xff0;
1891 GloCfg.field.EnTXWriteBackDDONE =1;
1892 RTMP_IO_WRITE32(pAd, WPDMA_GLO_CFG, GloCfg.word);
1893
1894 // Record HW Beacon offset
1895 pAd->BeaconOffset[0] = HW_BEACON_BASE0;
1896 pAd->BeaconOffset[1] = HW_BEACON_BASE1;
1897 pAd->BeaconOffset[2] = HW_BEACON_BASE2;
1898 pAd->BeaconOffset[3] = HW_BEACON_BASE3;
1899 pAd->BeaconOffset[4] = HW_BEACON_BASE4;
1900 pAd->BeaconOffset[5] = HW_BEACON_BASE5;
1901 pAd->BeaconOffset[6] = HW_BEACON_BASE6;
1902 pAd->BeaconOffset[7] = HW_BEACON_BASE7;
1903
1904 //
1905 // write all shared Ring's base address into ASIC
1906 //
1907
1908 // asic simulation sequence put this ahead before loading firmware.
1909 // pbf hardware reset
1910
1911 // Initialze ASIC for TX & Rx operation
1912 if (NICInitializeAsic(pAd , bHardReset) != NDIS_STATUS_SUCCESS)
1913 {
1914 if (j++ == 0)
1915 {
1916 NICLoadFirmware(pAd);
1917 goto retry;
1918 }
1919 return NDIS_STATUS_FAILURE;
1920 }
1921
1922
1923
1924
1925 // WMM parameter
1926 csr0.word = 0;
1927 RTMP_IO_WRITE32(pAd, WMM_TXOP0_CFG, csr0.word);
1928 if (pAd->CommonCfg.PhyMode == PHY_11B)
1929 {
1930 csr0.field.Ac0Txop = 192; // AC_VI: 192*32us ~= 6ms
1931 csr0.field.Ac1Txop = 96; // AC_VO: 96*32us ~= 3ms
1932 }
1933 else
1934 {
1935 csr0.field.Ac0Txop = 96; // AC_VI: 96*32us ~= 3ms
1936 csr0.field.Ac1Txop = 48; // AC_VO: 48*32us ~= 1.5ms
1937 }
1938 RTMP_IO_WRITE32(pAd, WMM_TXOP1_CFG, csr0.word);
1939
1940
1941
1942
1943 // reset action
1944 // Load firmware
1945 // Status = NICLoadFirmware(pAd);
1946
1947 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitializeAdapter\n"));
1948 return Status;
1949 }
1950
1951 /*
1952 ========================================================================
1953
1954 Routine Description:
1955 Initialize ASIC
1956
1957 Arguments:
1958 Adapter Pointer to our adapter
1959
1960 Return Value:
1961 None
1962
1963 IRQL = PASSIVE_LEVEL
1964
1965 Note:
1966
1967 ========================================================================
1968 */
1969 NDIS_STATUS NICInitializeAsic(
1970 IN PRTMP_ADAPTER pAd,
1971 IN BOOLEAN bHardReset)
1972 {
1973 ULONG Index = 0;
1974 UCHAR R0 = 0xff;
1975 UINT32 MacCsr12 = 0, Counter = 0;
1976 #ifdef RT2870
1977 UINT32 MacCsr0 = 0;
1978 NTSTATUS Status;
1979 UCHAR Value = 0xff;
1980 #endif // RT2870 //
1981 USHORT KeyIdx;
1982 INT i,apidx;
1983
1984 DBGPRINT(RT_DEBUG_TRACE, ("--> NICInitializeAsic\n"));
1985
1986
1987 #ifdef RT2870
1988 //
1989 // Make sure MAC gets ready after NICLoadFirmware().
1990 //
1991 Index = 0;
1992
1993 //To avoid hang-on issue when interface up in kernel 2.4,
1994 //we use a local variable "MacCsr0" instead of using "pAd->MACVersion" directly.
1995 do
1996 {
1997 RTMP_IO_READ32(pAd, MAC_CSR0, &MacCsr0);
1998
1999 if ((MacCsr0 != 0x00) && (MacCsr0 != 0xFFFFFFFF))
2000 break;
2001
2002 RTMPusecDelay(10);
2003 } while (Index++ < 100);
2004
2005 pAd->MACVersion = MacCsr0;
2006 DBGPRINT(RT_DEBUG_TRACE, ("MAC_CSR0 [ Ver:Rev=0x%08x]\n", pAd->MACVersion));
2007 // turn on bit13 (set to zero) after rt2860D. This is to solve high-current issue.
2008 RTMP_IO_READ32(pAd, PBF_SYS_CTRL, &MacCsr12);
2009 MacCsr12 &= (~0x2000);
2010 RTMP_IO_WRITE32(pAd, PBF_SYS_CTRL, MacCsr12);
2011
2012 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x3);
2013 RTMP_IO_WRITE32(pAd, USB_DMA_CFG, 0x0);
2014 Status = RTUSBVenderReset(pAd);
2015
2016 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x0);
2017
2018 // Initialize MAC register to default value
2019 for(Index=0; Index<NUM_MAC_REG_PARMS; Index++)
2020 {
2021 RTMP_IO_WRITE32(pAd, (USHORT)MACRegTable[Index].Register, MACRegTable[Index].Value);
2022 }
2023
2024 if(IS_RT3070(pAd))
2025 {
2026 // According to Frank Hsu (from Gary Tsao)
2027 RTMP_IO_WRITE32(pAd, (USHORT)TX_SW_CFG0, 0x00000400);
2028
2029 // Initialize RT3070 serial MAC registers which is different from RT2870 serial
2030 RTUSBWriteMACRegister(pAd, TX_SW_CFG1, 0);
2031 RTUSBWriteMACRegister(pAd, TX_SW_CFG2, 0);
2032 }
2033
2034
2035 #ifdef CONFIG_STA_SUPPORT
2036 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2037 {
2038 for (Index = 0; Index < NUM_STA_MAC_REG_PARMS; Index++)
2039 {
2040 RTMP_IO_WRITE32(pAd, (USHORT)STAMACRegTable[Index].Register, STAMACRegTable[Index].Value);
2041 }
2042 }
2043 #endif // CONFIG_STA_SUPPORT //
2044 #endif // RT2870 //
2045
2046 //
2047 // Before program BBP, we need to wait BBP/RF get wake up.
2048 //
2049 Index = 0;
2050 do
2051 {
2052 RTMP_IO_READ32(pAd, MAC_STATUS_CFG, &MacCsr12);
2053
2054 if ((MacCsr12 & 0x03) == 0) // if BB.RF is stable
2055 break;
2056
2057 DBGPRINT(RT_DEBUG_TRACE, ("Check MAC_STATUS_CFG = Busy = %x\n", MacCsr12));
2058 RTMPusecDelay(1000);
2059 } while (Index++ < 100);
2060
2061 // The commands to firmware should be after these commands, these commands will init firmware
2062 // PCI and USB are not the same because PCI driver needs to wait for PCI bus ready
2063 RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, 0); // initialize BBP R/W access agent
2064 RTMP_IO_WRITE32(pAd, H2M_MAILBOX_CSR, 0);
2065 RTMPusecDelay(1000);
2066
2067 // Read BBP register, make sure BBP is up and running before write new data
2068 Index = 0;
2069 do
2070 {
2071 RTMP_BBP_IO_READ8_BY_REG_ID(pAd, BBP_R0, &R0);
2072 DBGPRINT(RT_DEBUG_TRACE, ("BBP version = %x\n", R0));
2073 } while ((++Index < 20) && ((R0 == 0xff) || (R0 == 0x00)));
2074 //ASSERT(Index < 20); //this will cause BSOD on Check-build driver
2075
2076 if ((R0 == 0xff) || (R0 == 0x00))
2077 return NDIS_STATUS_FAILURE;
2078
2079 // Initialize BBP register to default value
2080 for (Index = 0; Index < NUM_BBP_REG_PARMS; Index++)
2081 {
2082 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBPRegTable[Index].Register, BBPRegTable[Index].Value);
2083 }
2084
2085 // for rt2860E and after, init BBP_R84 with 0x19. This is for extension channel overlapping IOT.
2086 if ((pAd->MACVersion&0xffff) != 0x0101)
2087 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R84, 0x19);
2088
2089 #ifdef RT2870
2090 //write RT3070 BBP wchich different with 2870 after write RT2870 BBP
2091 if (IS_RT3070(pAd))
2092 {
2093 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R70, 0x0a);
2094 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R84, 0x99);
2095 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R105, 0x05);
2096 }
2097 #endif // RT2870 //
2098
2099 if (pAd->MACVersion == 0x28600100)
2100 {
2101 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R69, 0x16);
2102 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R73, 0x12);
2103 }
2104
2105 if (pAd->MACVersion >= RALINK_2880E_VERSION && pAd->MACVersion < RALINK_3070_VERSION) // 3*3
2106 {
2107 // enlarge MAX_LEN_CFG
2108 UINT32 csr;
2109 RTMP_IO_READ32(pAd, MAX_LEN_CFG, &csr);
2110 csr &= 0xFFF;
2111 csr |= 0x2000;
2112 RTMP_IO_WRITE32(pAd, MAX_LEN_CFG, csr);
2113 }
2114
2115 #ifdef RT2870
2116 {
2117 UCHAR MAC_Value[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0,0};
2118
2119 //Initialize WCID table
2120 Value = 0xff;
2121 for(Index =0 ;Index < 254;Index++)
2122 {
2123 RTUSBMultiWrite(pAd, (USHORT)(MAC_WCID_BASE + Index * 8), MAC_Value, 8);
2124 }
2125 }
2126 #endif // RT2870 //
2127
2128 // Add radio off control
2129 #ifdef CONFIG_STA_SUPPORT
2130 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2131 {
2132 if (pAd->StaCfg.bRadio == FALSE)
2133 {
2134 // RTMP_IO_WRITE32(pAd, PWR_PIN_CFG, 0x00001818);
2135 RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
2136 DBGPRINT(RT_DEBUG_TRACE, ("Set Radio Off\n"));
2137 }
2138 }
2139 #endif // CONFIG_STA_SUPPORT //
2140
2141 // Clear raw counters
2142 RTMP_IO_READ32(pAd, RX_STA_CNT0, &Counter);
2143 RTMP_IO_READ32(pAd, RX_STA_CNT1, &Counter);
2144 RTMP_IO_READ32(pAd, RX_STA_CNT2, &Counter);
2145 RTMP_IO_READ32(pAd, TX_STA_CNT0, &Counter);
2146 RTMP_IO_READ32(pAd, TX_STA_CNT1, &Counter);
2147 RTMP_IO_READ32(pAd, TX_STA_CNT2, &Counter);
2148
2149 // ASIC will keep garbage value after boot
2150 // Clear all seared key table when initial
2151 // This routine can be ignored in radio-ON/OFF operation.
2152 if (bHardReset)
2153 {
2154 for (KeyIdx = 0; KeyIdx < 4; KeyIdx++)
2155 {
2156 RTMP_IO_WRITE32(pAd, SHARED_KEY_MODE_BASE + 4*KeyIdx, 0);
2157 }
2158
2159 // Clear all pairwise key table when initial
2160 for (KeyIdx = 0; KeyIdx < 256; KeyIdx++)
2161 {
2162 RTMP_IO_WRITE32(pAd, MAC_WCID_ATTRIBUTE_BASE + (KeyIdx * HW_WCID_ATTRI_SIZE), 1);
2163 }
2164 }
2165
2166 // assert HOST ready bit
2167 // RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x0); // 2004-09-14 asked by Mark
2168 // RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x4);
2169
2170 // It isn't necessary to clear this space when not hard reset.
2171 if (bHardReset == TRUE)
2172 {
2173 // clear all on-chip BEACON frame space
2174 for (apidx = 0; apidx < HW_BEACON_MAX_COUNT; apidx++)
2175 {
2176 for (i = 0; i < HW_BEACON_OFFSET>>2; i+=4)
2177 RTMP_IO_WRITE32(pAd, pAd->BeaconOffset[apidx] + i, 0x00);
2178 }
2179 }
2180 #ifdef RT2870
2181 AsicDisableSync(pAd);
2182 // Clear raw counters
2183 RTMP_IO_READ32(pAd, RX_STA_CNT0, &Counter);
2184 RTMP_IO_READ32(pAd, RX_STA_CNT1, &Counter);
2185 RTMP_IO_READ32(pAd, RX_STA_CNT2, &Counter);
2186 RTMP_IO_READ32(pAd, TX_STA_CNT0, &Counter);
2187 RTMP_IO_READ32(pAd, TX_STA_CNT1, &Counter);
2188 RTMP_IO_READ32(pAd, TX_STA_CNT2, &Counter);
2189 // Default PCI clock cycle per ms is different as default setting, which is based on PCI.
2190 RTMP_IO_READ32(pAd, USB_CYC_CFG, &Counter);
2191 Counter&=0xffffff00;
2192 Counter|=0x000001e;
2193 RTMP_IO_WRITE32(pAd, USB_CYC_CFG, Counter);
2194 #endif // RT2870 //
2195
2196 #ifdef CONFIG_STA_SUPPORT
2197 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
2198 {
2199 // for rt2860E and after, init TXOP_CTRL_CFG with 0x583f. This is for extension channel overlapping IOT.
2200 if ((pAd->MACVersion&0xffff) != 0x0101)
2201 RTMP_IO_WRITE32(pAd, TXOP_CTRL_CFG, 0x583f);
2202 }
2203 #endif // CONFIG_STA_SUPPORT //
2204
2205 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICInitializeAsic\n"));
2206 return NDIS_STATUS_SUCCESS;
2207 }
2208
2209 /*
2210 ========================================================================
2211
2212 Routine Description:
2213 Reset NIC Asics
2214
2215 Arguments:
2216 Adapter Pointer to our adapter
2217
2218 Return Value:
2219 None
2220
2221 IRQL = PASSIVE_LEVEL
2222
2223 Note:
2224 Reset NIC to initial state AS IS system boot up time.
2225
2226 ========================================================================
2227 */
2228 VOID NICIssueReset(
2229 IN PRTMP_ADAPTER pAd)
2230 {
2231 UINT32 Value = 0;
2232 DBGPRINT(RT_DEBUG_TRACE, ("--> NICIssueReset\n"));
2233
2234 // Abort Tx, prevent ASIC from writing to Host memory
2235 //RTMP_IO_WRITE32(pAd, TX_CNTL_CSR, 0x001f0000);
2236
2237 // Disable Rx, register value supposed will remain after reset
2238 RTMP_IO_READ32(pAd, MAC_SYS_CTRL, &Value);
2239 Value &= (0xfffffff3);
2240 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, Value);
2241
2242 // Issue reset and clear from reset state
2243 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x03); // 2004-09-17 change from 0x01
2244 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x00);
2245
2246 DBGPRINT(RT_DEBUG_TRACE, ("<-- NICIssueReset\n"));
2247 }
2248
2249 /*
2250 ========================================================================
2251
2252 Routine Description:
2253 Check ASIC registers and find any reason the system might hang
2254
2255 Arguments:
2256 Adapter Pointer to our adapter
2257
2258 Return Value:
2259 None
2260
2261 IRQL = DISPATCH_LEVEL
2262
2263 ========================================================================
2264 */
2265 BOOLEAN NICCheckForHang(
2266 IN PRTMP_ADAPTER pAd)
2267 {
2268 return (FALSE);
2269 }
2270
2271 VOID NICUpdateFifoStaCounters(
2272 IN PRTMP_ADAPTER pAd)
2273 {
2274 TX_STA_FIFO_STRUC StaFifo;
2275 MAC_TABLE_ENTRY *pEntry;
2276 UCHAR i = 0;
2277 UCHAR pid = 0, wcid = 0;
2278 CHAR reTry;
2279 UCHAR succMCS;
2280
2281 #ifdef RALINK_ATE
2282 /* Nothing to do in ATE mode */
2283 if (ATE_ON(pAd))
2284 return;
2285 #endif // RALINK_ATE //
2286
2287 do
2288 {
2289 RTMP_IO_READ32(pAd, TX_STA_FIFO, &StaFifo.word);
2290
2291 if (StaFifo.field.bValid == 0)
2292 break;
2293
2294 wcid = (UCHAR)StaFifo.field.wcid;
2295
2296
2297 /* ignore NoACK and MGMT frame use 0xFF as WCID */
2298 if ((StaFifo.field.TxAckRequired == 0) || (wcid >= MAX_LEN_OF_MAC_TABLE))
2299 {
2300 i++;
2301 continue;
2302 }
2303
2304 /* PID store Tx MCS Rate */
2305 pid = (UCHAR)StaFifo.field.PidType;
2306
2307 pEntry = &pAd->MacTab.Content[wcid];
2308
2309 pEntry->DebugFIFOCount++;
2310
2311 #ifdef DOT11_N_SUPPORT
2312 if (StaFifo.field.TxBF) // 3*3
2313 pEntry->TxBFCount++;
2314 #endif // DOT11_N_SUPPORT //
2315
2316 #ifdef UAPSD_AP_SUPPORT
2317 UAPSD_SP_AUE_Handle(pAd, pEntry, StaFifo.field.TxSuccess);
2318 #endif // UAPSD_AP_SUPPORT //
2319
2320 if (!StaFifo.field.TxSuccess)
2321 {
2322 pEntry->FIFOCount++;
2323 pEntry->OneSecTxFailCount++;
2324
2325 if (pEntry->FIFOCount >= 1)
2326 {
2327 DBGPRINT(RT_DEBUG_TRACE, ("#"));
2328 #if 0
2329 SendRefreshBAR(pAd, pEntry);
2330 pEntry->NoBADataCountDown = 64;
2331 #else
2332 #ifdef DOT11_N_SUPPORT
2333 pEntry->NoBADataCountDown = 64;
2334 #endif // DOT11_N_SUPPORT //
2335
2336 if(pEntry->PsMode == PWR_ACTIVE)
2337 {
2338 #ifdef DOT11_N_SUPPORT
2339 int tid;
2340 for (tid=0; tid<NUM_OF_TID; tid++)
2341 {
2342 BAOriSessionTearDown(pAd, pEntry->Aid, tid, FALSE, FALSE);
2343 }
2344 #endif // DOT11_N_SUPPORT //
2345
2346 // Update the continuous transmission counter except PS mode
2347 pEntry->ContinueTxFailCnt++;
2348 }
2349 else
2350 {
2351 // Clear the FIFOCount when sta in Power Save mode. Basically we assume
2352 // this tx error happened due to sta just go to sleep.
2353 pEntry->FIFOCount = 0;
2354 pEntry->ContinueTxFailCnt = 0;
2355 }
2356 #endif
2357 //pEntry->FIFOCount = 0;
2358 }
2359 //pEntry->bSendBAR = TRUE;
2360 }
2361 else
2362 {
2363 #ifdef DOT11_N_SUPPORT
2364 if ((pEntry->PsMode != PWR_SAVE) && (pEntry->NoBADataCountDown > 0))
2365 {
2366 pEntry->NoBADataCountDown--;
2367 if (pEntry->NoBADataCountDown==0)
2368 {
2369 DBGPRINT(RT_DEBUG_TRACE, ("@\n"));
2370 }
2371 }
2372 #endif // DOT11_N_SUPPORT //
2373 pEntry->FIFOCount = 0;
2374 pEntry->OneSecTxNoRetryOkCount++;
2375 // update NoDataIdleCount when sucessful send packet to STA.
2376 pEntry->NoDataIdleCount = 0;
2377 pEntry->ContinueTxFailCnt = 0;
2378 }
2379
2380 succMCS = StaFifo.field.SuccessRate & 0x7F;
2381
2382 reTry = pid - succMCS;
2383
2384 if (StaFifo.field.TxSuccess)
2385 {
2386 pEntry->TXMCSExpected[pid]++;
2387 if (pid == succMCS)
2388 {
2389 pEntry->TXMCSSuccessful[pid]++;
2390 }
2391 else
2392 {
2393 pEntry->TXMCSAutoFallBack[pid][succMCS]++;
2394 }
2395 }
2396 else
2397 {
2398 pEntry->TXMCSFailed[pid]++;
2399 }
2400
2401 if (reTry > 0)
2402 {
2403 if ((pid >= 12) && succMCS <=7)
2404 {
2405 reTry -= 4;
2406 }
2407 pEntry->OneSecTxRetryOkCount += reTry;
2408 }
2409
2410 i++;
2411 // ASIC store 16 stack
2412 } while ( i < (2*TX_RING_SIZE) );
2413
2414 }
2415
2416 /*
2417 ========================================================================
2418
2419 Routine Description:
2420 Read statistical counters from hardware registers and record them
2421 in software variables for later on query
2422
2423 Arguments:
2424 pAd Pointer to our adapter
2425
2426 Return Value:
2427 None
2428
2429 IRQL = DISPATCH_LEVEL
2430
2431 ========================================================================
2432 */
2433 VOID NICUpdateRawCounters(
2434 IN PRTMP_ADAPTER pAd)
2435 {
2436 UINT32 OldValue;
2437 RX_STA_CNT0_STRUC RxStaCnt0;
2438 RX_STA_CNT1_STRUC RxStaCnt1;
2439 RX_STA_CNT2_STRUC RxStaCnt2;
2440 TX_STA_CNT0_STRUC TxStaCnt0;
2441 TX_STA_CNT1_STRUC StaTx1;
2442 TX_STA_CNT2_STRUC StaTx2;
2443 TX_AGG_CNT_STRUC TxAggCnt;
2444 TX_AGG_CNT0_STRUC TxAggCnt0;
2445 TX_AGG_CNT1_STRUC TxAggCnt1;
2446 TX_AGG_CNT2_STRUC TxAggCnt2;
2447 TX_AGG_CNT3_STRUC TxAggCnt3;
2448 TX_AGG_CNT4_STRUC TxAggCnt4;
2449 TX_AGG_CNT5_STRUC TxAggCnt5;
2450 TX_AGG_CNT6_STRUC TxAggCnt6;
2451 TX_AGG_CNT7_STRUC TxAggCnt7;
2452
2453
2454 RTMP_IO_READ32(pAd, RX_STA_CNT0, &RxStaCnt0.word);
2455 RTMP_IO_READ32(pAd, RX_STA_CNT2, &RxStaCnt2.word);
2456
2457 {
2458 RTMP_IO_READ32(pAd, RX_STA_CNT1, &RxStaCnt1.word);
2459 // Update RX PLCP error counter
2460 pAd->PrivateInfo.PhyRxErrCnt += RxStaCnt1.field.PlcpErr;
2461 // Update False CCA counter
2462 pAd->RalinkCounters.OneSecFalseCCACnt += RxStaCnt1.field.FalseCca;
2463 }
2464
2465 // Update FCS counters
2466 OldValue= pAd->WlanCounters.FCSErrorCount.u.LowPart;
2467 pAd->WlanCounters.FCSErrorCount.u.LowPart += (RxStaCnt0.field.CrcErr); // >> 7);
2468 if (pAd->WlanCounters.FCSErrorCount.u.LowPart < OldValue)
2469 pAd->WlanCounters.FCSErrorCount.u.HighPart++;
2470
2471 // Add FCS error count to private counters
2472 pAd->RalinkCounters.OneSecRxFcsErrCnt += RxStaCnt0.field.CrcErr;
2473 OldValue = pAd->RalinkCounters.RealFcsErrCount.u.LowPart;
2474 pAd->RalinkCounters.RealFcsErrCount.u.LowPart += RxStaCnt0.field.CrcErr;
2475 if (pAd->RalinkCounters.RealFcsErrCount.u.LowPart < OldValue)
2476 pAd->RalinkCounters.RealFcsErrCount.u.HighPart++;
2477
2478 // Update Duplicate Rcv check
2479 pAd->RalinkCounters.DuplicateRcv += RxStaCnt2.field.RxDupliCount;
2480 pAd->WlanCounters.FrameDuplicateCount.u.LowPart += RxStaCnt2.field.RxDupliCount;
2481 // Update RX Overflow counter
2482 pAd->Counters8023.RxNoBuffer += (RxStaCnt2.field.RxFifoOverflowCount);
2483
2484 //pAd->RalinkCounters.RxCount = 0;
2485 #ifdef RT2870
2486 if (pAd->RalinkCounters.RxCount != pAd->watchDogRxCnt)
2487 {
2488 pAd->watchDogRxCnt = pAd->RalinkCounters.RxCount;
2489 pAd->watchDogRxOverFlowCnt = 0;
2490 }
2491 else
2492 {
2493 if (RxStaCnt2.field.RxFifoOverflowCount)
2494 pAd->watchDogRxOverFlowCnt++;
2495 else
2496 pAd->watchDogRxOverFlowCnt = 0;
2497 }
2498 #endif // RT2870 //
2499
2500
2501 //if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED) ||
2502 // (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_TX_RATE_SWITCH_ENABLED) && (pAd->MacTab.Size != 1)))
2503 if (!pAd->bUpdateBcnCntDone)
2504 {
2505 // Update BEACON sent count
2506 RTMP_IO_READ32(pAd, TX_STA_CNT0, &TxStaCnt0.word);
2507 RTMP_IO_READ32(pAd, TX_STA_CNT1, &StaTx1.word);
2508 RTMP_IO_READ32(pAd, TX_STA_CNT2, &StaTx2.word);
2509 pAd->RalinkCounters.OneSecBeaconSentCnt += TxStaCnt0.field.TxBeaconCount;
2510 pAd->RalinkCounters.OneSecTxRetryOkCount += StaTx1.field.TxRetransmit;
2511 pAd->RalinkCounters.OneSecTxNoRetryOkCount += StaTx1.field.TxSuccess;
2512 pAd->RalinkCounters.OneSecTxFailCount += TxStaCnt0.field.TxFailCount;
2513 pAd->WlanCounters.TransmittedFragmentCount.u.LowPart += StaTx1.field.TxSuccess;
2514 pAd->WlanCounters.RetryCount.u.LowPart += StaTx1.field.TxRetransmit;
2515 pAd->WlanCounters.FailedCount.u.LowPart += TxStaCnt0.field.TxFailCount;
2516 }
2517
2518 #if 0
2519 Retry = StaTx1.field.TxRetransmit;
2520 Fail = TxStaCnt0.field.TxFailCount;
2521 TxErrorRatio = 0;
2522 OneSecTransmitCount = pAd->WlanCounters.TransmittedFragmentCount.u.LowPart- pAd->WlanCounters.LastTransmittedFragmentCount.u.LowPart;
2523 if ((OneSecTransmitCount+Retry + Fail) > 0)
2524 TxErrorRatio = (( Retry + Fail) *100) / (OneSecTransmitCount+Retry + Fail);
2525
2526 if ((OneSecTransmitCount+Retry + Fail) > 0)
2527 TxErrorRatio = (( Retry + Fail) *100) / (OneSecTransmitCount+Retry + Fail);
2528 DBGPRINT(RT_DEBUG_INFO, ("TX ERROR Rate = %ld %%, Retry = %ld, Fail = %ld, Total = %ld \n",TxErrorRatio, Retry, Fail, (OneSecTransmitCount+Retry + Fail)));
2529 pAd->WlanCounters.LastTransmittedFragmentCount.u.LowPart = pAd->WlanCounters.TransmittedFragmentCount.u.LowPart;
2530 #endif
2531
2532 //if (pAd->bStaFifoTest == TRUE)
2533 {
2534 RTMP_IO_READ32(pAd, TX_AGG_CNT, &TxAggCnt.word);
2535 RTMP_IO_READ32(pAd, TX_AGG_CNT0, &TxAggCnt0.word);
2536 RTMP_IO_READ32(pAd, TX_AGG_CNT1, &TxAggCnt1.word);
2537 RTMP_IO_READ32(pAd, TX_AGG_CNT2, &TxAggCnt2.word);
2538 RTMP_IO_READ32(pAd, TX_AGG_CNT3, &TxAggCnt3.word);
2539 RTMP_IO_READ32(pAd, TX_AGG_CNT4, &TxAggCnt4.word);
2540 RTMP_IO_READ32(pAd, TX_AGG_CNT5, &TxAggCnt5.word);
2541 RTMP_IO_READ32(pAd, TX_AGG_CNT6, &TxAggCnt6.word);
2542 RTMP_IO_READ32(pAd, TX_AGG_CNT7, &TxAggCnt7.word);
2543 pAd->RalinkCounters.TxAggCount += TxAggCnt.field.AggTxCount;
2544 pAd->RalinkCounters.TxNonAggCount += TxAggCnt.field.NonAggTxCount;
2545 pAd->RalinkCounters.TxAgg1MPDUCount += TxAggCnt0.field.AggSize1Count;
2546 pAd->RalinkCounters.TxAgg2MPDUCount += TxAggCnt0.field.AggSize2Count;
2547
2548 pAd->RalinkCounters.TxAgg3MPDUCount += TxAggCnt1.field.AggSize3Count;
2549 pAd->RalinkCounters.TxAgg4MPDUCount += TxAggCnt1.field.AggSize4Count;
2550 pAd->RalinkCounters.TxAgg5MPDUCount += TxAggCnt2.field.AggSize5Count;
2551 pAd->RalinkCounters.TxAgg6MPDUCount += TxAggCnt2.field.AggSize6Count;
2552
2553 pAd->RalinkCounters.TxAgg7MPDUCount += TxAggCnt3.field.AggSize7Count;
2554 pAd->RalinkCounters.TxAgg8MPDUCount += TxAggCnt3.field.AggSize8Count;
2555 pAd->RalinkCounters.TxAgg9MPDUCount += TxAggCnt4.field.AggSize9Count;
2556 pAd->RalinkCounters.TxAgg10MPDUCount += TxAggCnt4.field.AggSize10Count;
2557
2558 pAd->RalinkCounters.TxAgg11MPDUCount += TxAggCnt5.field.AggSize11Count;
2559 pAd->RalinkCounters.TxAgg12MPDUCount += TxAggCnt5.field.AggSize12Count;
2560 pAd->RalinkCounters.TxAgg13MPDUCount += TxAggCnt6.field.AggSize13Count;
2561 pAd->RalinkCounters.TxAgg14MPDUCount += TxAggCnt6.field.AggSize14Count;
2562
2563 pAd->RalinkCounters.TxAgg15MPDUCount += TxAggCnt7.field.AggSize15Count;
2564 pAd->RalinkCounters.TxAgg16MPDUCount += TxAggCnt7.field.AggSize16Count;
2565
2566 // Calculate the transmitted A-MPDU count
2567 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += TxAggCnt0.field.AggSize1Count;
2568 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt0.field.AggSize2Count / 2);
2569
2570 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt1.field.AggSize3Count / 3);
2571 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt1.field.AggSize4Count / 4);
2572
2573 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt2.field.AggSize5Count / 5);
2574 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt2.field.AggSize6Count / 6);
2575
2576 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt3.field.AggSize7Count / 7);
2577 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt3.field.AggSize8Count / 8);
2578
2579 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt4.field.AggSize9Count / 9);
2580 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt4.field.AggSize10Count / 10);
2581
2582 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt5.field.AggSize11Count / 11);
2583 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt5.field.AggSize12Count / 12);
2584
2585 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt6.field.AggSize13Count / 13);
2586 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt6.field.AggSize14Count / 14);
2587
2588 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt7.field.AggSize15Count / 15);
2589 pAd->RalinkCounters.TransmittedAMPDUCount.u.LowPart += (TxAggCnt7.field.AggSize16Count / 16);
2590 }
2591
2592 #ifdef DBG_DIAGNOSE
2593 {
2594 RtmpDiagStruct *pDiag;
2595 COUNTER_RALINK *pRalinkCounters;
2596 UCHAR ArrayCurIdx, i;
2597
2598 pDiag = &pAd->DiagStruct;
2599 pRalinkCounters = &pAd->RalinkCounters;
2600 ArrayCurIdx = pDiag->ArrayCurIdx;
2601
2602 if (pDiag->inited == 0)
2603 {
2604 NdisZeroMemory(pDiag, sizeof(struct _RtmpDiagStrcut_));
2605 pDiag->ArrayStartIdx = pDiag->ArrayCurIdx = 0;
2606 pDiag->inited = 1;
2607 }
2608 else
2609 {
2610 // Tx
2611 pDiag->TxFailCnt[ArrayCurIdx] = TxStaCnt0.field.TxFailCount;
2612 pDiag->TxAggCnt[ArrayCurIdx] = TxAggCnt.field.AggTxCount;
2613 pDiag->TxNonAggCnt[ArrayCurIdx] = TxAggCnt.field.NonAggTxCount;
2614 pDiag->TxAMPDUCnt[ArrayCurIdx][0] = TxAggCnt0.field.AggSize1Count;
2615 pDiag->TxAMPDUCnt[ArrayCurIdx][1] = TxAggCnt0.field.AggSize2Count;
2616 pDiag->TxAMPDUCnt[ArrayCurIdx][2] = TxAggCnt1.field.AggSize3Count;
2617 pDiag->TxAMPDUCnt[ArrayCurIdx][3] = TxAggCnt1.field.AggSize4Count;
2618 pDiag->TxAMPDUCnt[ArrayCurIdx][4] = TxAggCnt2.field.AggSize5Count;
2619 pDiag->TxAMPDUCnt[ArrayCurIdx][5] = TxAggCnt2.field.AggSize6Count;
2620 pDiag->TxAMPDUCnt[ArrayCurIdx][6] = TxAggCnt3.field.AggSize7Count;
2621 pDiag->TxAMPDUCnt[ArrayCurIdx][7] = TxAggCnt3.field.AggSize8Count;
2622 pDiag->TxAMPDUCnt[ArrayCurIdx][8] = TxAggCnt4.field.AggSize9Count;
2623 pDiag->TxAMPDUCnt[ArrayCurIdx][9] = TxAggCnt4.field.AggSize10Count;
2624 pDiag->TxAMPDUCnt[ArrayCurIdx][10] = TxAggCnt5.field.AggSize11Count;
2625 pDiag->TxAMPDUCnt[ArrayCurIdx][11] = TxAggCnt5.field.AggSize12Count;
2626 pDiag->TxAMPDUCnt[ArrayCurIdx][12] = TxAggCnt6.field.AggSize13Count;
2627 pDiag->TxAMPDUCnt[ArrayCurIdx][13] = TxAggCnt6.field.AggSize14Count;
2628 pDiag->TxAMPDUCnt[ArrayCurIdx][14] = TxAggCnt7.field.AggSize15Count;
2629 pDiag->TxAMPDUCnt[ArrayCurIdx][15] = TxAggCnt7.field.AggSize16Count;
2630
2631 pDiag->RxCrcErrCnt[ArrayCurIdx] = RxStaCnt0.field.CrcErr;
2632
2633 INC_RING_INDEX(pDiag->ArrayCurIdx, DIAGNOSE_TIME);
2634 ArrayCurIdx = pDiag->ArrayCurIdx;
2635 for (i =0; i < 9; i++)
2636 {
2637 pDiag->TxDescCnt[ArrayCurIdx][i]= 0;
2638 pDiag->TxSWQueCnt[ArrayCurIdx][i] =0;
2639 pDiag->TxMcsCnt[ArrayCurIdx][i] = 0;
2640 pDiag->RxMcsCnt[ArrayCurIdx][i] = 0;
2641 }
2642 pDiag->TxDataCnt[ArrayCurIdx] = 0;
2643 pDiag->TxFailCnt[ArrayCurIdx] = 0;
2644 pDiag->RxDataCnt[ArrayCurIdx] = 0;
2645 pDiag->RxCrcErrCnt[ArrayCurIdx] = 0;
2646 // for (i = 9; i < 16; i++)
2647 for (i = 9; i < 24; i++) // 3*3
2648 {
2649 pDiag->TxDescCnt[ArrayCurIdx][i] = 0;
2650 pDiag->TxMcsCnt[ArrayCurIdx][i] = 0;
2651 pDiag->RxMcsCnt[ArrayCurIdx][i] = 0;
2652 }
2653
2654 if (pDiag->ArrayCurIdx == pDiag->ArrayStartIdx)
2655 INC_RING_INDEX(pDiag->ArrayStartIdx, DIAGNOSE_TIME);
2656 }
2657
2658 }
2659 #endif // DBG_DIAGNOSE //
2660
2661
2662 }
2663
2664
2665 /*
2666 ========================================================================
2667
2668 Routine Description:
2669 Reset NIC from error
2670
2671 Arguments:
2672 Adapter Pointer to our adapter
2673
2674 Return Value:
2675 None
2676
2677 IRQL = PASSIVE_LEVEL
2678
2679 Note:
2680 Reset NIC from error state
2681
2682 ========================================================================
2683 */
2684 VOID NICResetFromError(
2685 IN PRTMP_ADAPTER pAd)
2686 {
2687 // Reset BBP (according to alex, reset ASIC will force reset BBP
2688 // Therefore, skip the reset BBP
2689 // RTMP_IO_WRITE32(pAd, MAC_CSR1, 0x2);
2690
2691 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x1);
2692 // Remove ASIC from reset state
2693 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x0);
2694
2695 NICInitializeAdapter(pAd, FALSE);
2696 NICInitAsicFromEEPROM(pAd);
2697
2698 // Switch to current channel, since during reset process, the connection should remains on.
2699 AsicSwitchChannel(pAd, pAd->CommonCfg.CentralChannel, FALSE);
2700 AsicLockChannel(pAd, pAd->CommonCfg.CentralChannel);
2701 }
2702
2703 /*
2704 ========================================================================
2705
2706 Routine Description:
2707 erase 8051 firmware image in MAC ASIC
2708
2709 Arguments:
2710 Adapter Pointer to our adapter
2711
2712 IRQL = PASSIVE_LEVEL
2713
2714 ========================================================================
2715 */
2716 VOID NICEraseFirmware(
2717 IN PRTMP_ADAPTER pAd)
2718 {
2719 ULONG i;
2720
2721 for(i=0; i<MAX_FIRMWARE_IMAGE_SIZE; i+=4)
2722 RTMP_IO_WRITE32(pAd, FIRMWARE_IMAGE_BASE + i, 0);
2723
2724 }/* End of NICEraseFirmware */
2725
2726 /*
2727 ========================================================================
2728
2729 Routine Description:
2730 Load 8051 firmware RT2561.BIN file into MAC ASIC
2731
2732 Arguments:
2733 Adapter Pointer to our adapter
2734
2735 Return Value:
2736 NDIS_STATUS_SUCCESS firmware image load ok
2737 NDIS_STATUS_FAILURE image not found
2738
2739 IRQL = PASSIVE_LEVEL
2740
2741 ========================================================================
2742 */
2743 NDIS_STATUS NICLoadFirmware(
2744 IN PRTMP_ADAPTER pAd)
2745 {
2746 #ifdef BIN_IN_FILE
2747 #define NICLF_DEFAULT_USE() \
2748 flg_default_firm_use = TRUE; \
2749 printk("%s - Use default firmware!\n", __FUNCTION__);
2750
2751 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
2752 PUCHAR src;
2753 struct file *srcf;
2754 INT retval, orgfsuid, orgfsgid, i;
2755 mm_segment_t orgfs;
2756 PUCHAR pFirmwareImage;
2757 UINT FileLength = 0;
2758 UINT32 MacReg;
2759 ULONG Index;
2760 ULONG firm;
2761 BOOLEAN flg_default_firm_use = FALSE;
2762
2763
2764 DBGPRINT(RT_DEBUG_TRACE, ("===> %s\n", __FUNCTION__));
2765
2766 /* init */
2767 pFirmwareImage = NULL;
2768 src = RTMP_FIRMWARE_FILE_NAME;
2769
2770 /* save uid and gid used for filesystem access.
2771 set user and group to 0 (root) */
2772 orgfsuid = current->fsuid;
2773 orgfsgid = current->fsgid;
2774 current->fsuid = current->fsgid = 0;
2775 orgfs = get_fs();
2776 set_fs(KERNEL_DS);
2777
2778 pAd->FirmwareVersion = (FIRMWARE_MAJOR_VERSION << 8) + \
2779 FIRMWARE_MINOR_VERSION;
2780
2781
2782 /* allocate firmware buffer */
2783 pFirmwareImage = kmalloc(MAX_FIRMWARE_IMAGE_SIZE, MEM_ALLOC_FLAG);
2784 if (pFirmwareImage == NULL)
2785 {
2786 /* allocate fail, use default firmware array in firmware.h */
2787 printk("%s - Allocate memory fail!\n", __FUNCTION__);
2788 NICLF_DEFAULT_USE();
2789 }
2790 else
2791 {
2792 /* allocate ok! zero the firmware buffer */
2793 memset(pFirmwareImage, 0x00, MAX_FIRMWARE_IMAGE_SIZE);
2794 } /* End of if */
2795
2796
2797 /* if ok, read firmware file from *.bin file */
2798 if (flg_default_firm_use == FALSE)
2799 {
2800 do
2801 {
2802 /* open the bin file */
2803 srcf = filp_open(src, O_RDONLY, 0);
2804
2805 if (IS_ERR(srcf))
2806 {
2807 printk("%s - Error %ld opening %s\n",
2808 __FUNCTION__, -PTR_ERR(srcf), src);
2809 NICLF_DEFAULT_USE();
2810 break;
2811 } /* End of if */
2812
2813 /* the object must have a read method */
2814 if ((srcf->f_op == NULL) || (srcf->f_op->read == NULL))
2815 {
2816 printk("%s - %s does not have a write method\n", __FUNCTION__, src);
2817 NICLF_DEFAULT_USE();
2818 break;
2819 } /* End of if */
2820
2821 /* read the firmware from the file *.bin */
2822 FileLength = srcf->f_op->read(srcf,
2823 pFirmwareImage,
2824 MAX_FIRMWARE_IMAGE_SIZE,
2825 &srcf->f_pos);
2826
2827 if (FileLength != MAX_FIRMWARE_IMAGE_SIZE)
2828 {
2829 printk("%s: error file length (=%d) in RT2860AP.BIN\n",
2830 __FUNCTION__, FileLength);
2831 NICLF_DEFAULT_USE();
2832 break;
2833 }
2834 else
2835 {
2836 PUCHAR ptr = pFirmwareImage;
2837 USHORT crc = 0xffff;
2838
2839
2840 /* calculate firmware CRC */
2841 for(i=0; i<(MAX_FIRMWARE_IMAGE_SIZE-2); i++, ptr++)
2842 crc = ByteCRC16(BitReverse(*ptr), crc);
2843 /* End of for */
2844
2845 if ((pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-2] != \
2846 (UCHAR)BitReverse((UCHAR)(crc>>8))) ||
2847 (pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-1] != \
2848 (UCHAR)BitReverse((UCHAR)crc)))
2849 {
2850 /* CRC fail */
2851 printk("%s: CRC = 0x%02x 0x%02x "
2852 "error, should be 0x%02x 0x%02x\n",
2853 __FUNCTION__,
2854 pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-2],
2855 pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-1],
2856 (UCHAR)(crc>>8), (UCHAR)(crc));
2857 NICLF_DEFAULT_USE();
2858 break;
2859 }
2860 else
2861 {
2862 /* firmware is ok */
2863 pAd->FirmwareVersion = \
2864 (pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4] << 8) +
2865 pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3];
2866
2867 /* check if firmware version of the file is too old */
2868 if ((pAd->FirmwareVersion) < \
2869 ((FIRMWARE_MAJOR_VERSION << 8) +
2870 FIRMWARE_MINOR_VERSION))
2871 {
2872 printk("%s: firmware version too old!\n", __FUNCTION__);
2873 NICLF_DEFAULT_USE();
2874 break;
2875 } /* End of if */
2876 } /* End of if */
2877
2878 DBGPRINT(RT_DEBUG_TRACE,
2879 ("NICLoadFirmware: CRC ok, ver=%d.%d\n",
2880 pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4],
2881 pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3]));
2882 } /* End of if (FileLength == MAX_FIRMWARE_IMAGE_SIZE) */
2883 break;
2884 } while(TRUE);
2885
2886 /* close firmware file */
2887 if (IS_ERR(srcf))
2888 ;
2889 else
2890 {
2891 retval = filp_close(srcf, NULL);
2892 if (retval)
2893 {
2894 DBGPRINT(RT_DEBUG_ERROR,
2895 ("--> Error %d closing %s\n", -retval, src));
2896 } /* End of if */
2897 } /* End of if */
2898 } /* End of if */
2899
2900
2901 /* write firmware to ASIC */
2902 if (flg_default_firm_use == TRUE)
2903 {
2904 /* use default fimeware, free allocated buffer */
2905 if (pFirmwareImage != NULL)
2906 kfree(pFirmwareImage);
2907 /* End of if */
2908
2909 /* use default *.bin array */
2910 pFirmwareImage = FirmwareImage;
2911 FileLength = sizeof(FirmwareImage);
2912 } /* End of if */
2913
2914 /* enable Host program ram write selection */
2915 RTMP_IO_WRITE32(pAd, PBF_SYS_CTRL, 0x10000);
2916
2917 for(i=0; i<FileLength; i+=4)
2918 {
2919 firm = pFirmwareImage[i] +
2920 (pFirmwareImage[i+3] << 24) +
2921 (pFirmwareImage[i+2] << 16) +
2922 (pFirmwareImage[i+1] << 8);
2923
2924 RTMP_IO_WRITE32(pAd, FIRMWARE_IMAGE_BASE + i, firm);
2925 } /* End of for */
2926
2927 RTMP_IO_WRITE32(pAd, PBF_SYS_CTRL, 0x00000);
2928 RTMP_IO_WRITE32(pAd, PBF_SYS_CTRL, 0x00001);
2929
2930 /* initialize BBP R/W access agent */
2931 RTMP_IO_WRITE32(pAd, H2M_BBP_AGENT, 0);
2932 RTMP_IO_WRITE32(pAd, H2M_MAILBOX_CSR, 0);
2933
2934 if (flg_default_firm_use == FALSE)
2935 {
2936 /* use file firmware, free allocated buffer */
2937 if (pFirmwareImage != NULL)
2938 kfree(pFirmwareImage);
2939 /* End of if */
2940 } /* End of if */
2941
2942 set_fs(orgfs);
2943 current->fsuid = orgfsuid;
2944 current->fsgid = orgfsgid;
2945 #else
2946
2947 NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
2948 PUCHAR pFirmwareImage;
2949 ULONG FileLength, Index;
2950 //ULONG firm;
2951 UINT32 MacReg = 0;
2952 #ifdef RT2870
2953 UINT32 Version = (pAd->MACVersion >> 16);
2954 #endif // RT2870 //
2955
2956 pFirmwareImage = FirmwareImage;
2957 FileLength = sizeof(FirmwareImage);
2958 #ifdef RT2870
2959 // New 8k byte firmware size for RT3071/RT3072
2960 //printk("Usb Chip\n");
2961 if (FIRMWAREIMAGE_LENGTH == FIRMWAREIMAGE_MAX_LENGTH)
2962 //The firmware image consists of two parts. One is the origianl and the other is the new.
2963 //Use Second Part
2964 {
2965 if ((Version != 0x2860) && (Version != 0x2872) && (Version != 0x3070))
2966 { // Use Firmware V2.
2967 //printk("KH:Use New Version,part2\n");
2968 pFirmwareImage = (PUCHAR)&FirmwareImage[FIRMWAREIMAGEV1_LENGTH];
2969 FileLength = FIRMWAREIMAGEV2_LENGTH;
2970 }
2971 else
2972 {
2973 //printk("KH:Use New Version,part1\n");
2974 pFirmwareImage = FirmwareImage;
2975 FileLength = FIRMWAREIMAGEV1_LENGTH;
2976 }
2977 }
2978 else
2979 {
2980 DBGPRINT(RT_DEBUG_ERROR, ("KH: bin file should be 8KB.\n"));
2981 Status = NDIS_STATUS_FAILURE;
2982 }
2983
2984 #endif // RT2870 //
2985
2986 #if 0
2987 /* enable Host program ram write selection */
2988 RT28XX_FIRMUD_INIT(pAd);
2989
2990 for(i=0; i<FileLength; i+=4)
2991 {
2992 firm = pFirmwareImage[i] +
2993 (pFirmwareImage[i+3] << 24) +
2994 (pFirmwareImage[i+2] << 16) +
2995 (pFirmwareImage[i+1] << 8);
2996
2997 RTMP_IO_WRITE32(pAd, FIRMWARE_IMAGE_BASE + i, firm);
2998 } /* End of for */
2999
3000 RT28XX_FIRMUD_END(pAd);
3001 #else
3002 RT28XX_WRITE_FIRMWARE(pAd, pFirmwareImage, FileLength);
3003 #endif
3004
3005 #endif
3006
3007 /* check if MCU is ready */
3008 Index = 0;
3009 do
3010 {
3011 RTMP_IO_READ32(pAd, PBF_SYS_CTRL, &MacReg);
3012
3013 if (MacReg & 0x80)
3014 break;
3015
3016 RTMPusecDelay(1000);
3017 } while (Index++ < 1000);
3018
3019 if (Index >= 1000)
3020 {
3021 Status = NDIS_STATUS_FAILURE;
3022 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadFirmware: MCU is not ready\n\n\n"));
3023 } /* End of if */
3024
3025 #if 0
3026 DBGPRINT(RT_DEBUG_TRACE,
3027 ("<=== %s (src=%s, status=%d)\n", __FUNCTION__, src, Status));
3028 #else
3029 DBGPRINT(RT_DEBUG_TRACE,
3030 ("<=== %s (status=%d)\n", __FUNCTION__, Status));
3031 #endif
3032 return Status;
3033 } /* End of NICLoadFirmware */
3034
3035
3036 /*
3037 ========================================================================
3038
3039 Routine Description:
3040 Load Tx rate switching parameters
3041
3042 Arguments:
3043 Adapter Pointer to our adapter
3044
3045 Return Value:
3046 NDIS_STATUS_SUCCESS firmware image load ok
3047 NDIS_STATUS_FAILURE image not found
3048
3049 IRQL = PASSIVE_LEVEL
3050
3051 Rate Table Format:
3052 1. (B0: Valid Item number) (B1:Initial item from zero)
3053 2. Item Number(Dec) Mode(Hex) Current MCS(Dec) TrainUp(Dec) TrainDown(Dec)
3054
3055 ========================================================================
3056 */
3057 NDIS_STATUS NICLoadRateSwitchingParams(
3058 IN PRTMP_ADAPTER pAd)
3059 {
3060 #if 0
3061 NDIS_STATUS Status;
3062
3063 NDIS_HANDLE FileHandle;
3064 UINT FileLength = 0, i, j;
3065 PUCHAR pFirmwareImage;
3066 NDIS_STRING FileName;
3067 NDIS_PHYSICAL_ADDRESS HighestAcceptableMax = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
3068
3069 DBGPRINT(RT_DEBUG_TRACE,("===> NICLoadRateSwitchingParams \n"));
3070 pAd->CommonCfg.TxRateTableSize = 0;
3071
3072 if ((pAd->DeviceID == NIC2860_PCI_DEVICE_ID) || (pAd->DeviceID == NIC2860_PCIe_DEVICE_ID))
3073 {
3074 NdisInitializeString(&FileName,"rate.bin");
3075 DBGPRINT(RT_DEBUG_TRACE, ("NICLoadRateSwitchingParams: load file - rate.bin for tx rate switch \n"));
3076 }
3077 else
3078 {
3079 DBGPRINT_ERR(("NICLoadRateSwitchingParams: wrong DeviceID = 0x%04x, can't find Tx rate switch parameters file\n", pAd->DeviceID));
3080 return NDIS_STATUS_SUCCESS;
3081 }
3082 NdisOpenFile(&Status, &FileHandle, &FileLength, &FileName, HighestAcceptableMax);
3083 NdisFreeString(FileName);
3084
3085 if (Status != NDIS_STATUS_SUCCESS)
3086 {
3087 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadRateSwitchingParams: NdisOpenFile() failed, used RateSwitchTable instead\n"));
3088 return NDIS_STATUS_SUCCESS;
3089 }
3090
3091 if ((FileLength == 0) || (FileLength > (MAX_STEP_OF_TX_RATE_SWITCH+1)*16))
3092 {
3093 DBGPRINT(RT_DEBUG_ERROR, ("NICLoadRateSwitchingParams: file size is not reasonable, used RateSwitchTable instead\n"));
3094
3095 NdisCloseFile(FileHandle);
3096 return NDIS_STATUS_SUCCESS;
3097 }
3098 else
3099 {
3100 //
3101 // NDIS_STATUS_SUCCESS means
3102 // The handle at FileHandle is valid for a subsequent call to NdisMapFile.
3103 //
3104 NdisMapFile(&Status, &pFirmwareImage, FileHandle);
3105 DBGPRINT(RT_DEBUG_TRACE, ("NdisMapFile FileLength=%d\n", FileLength));
3106 }
3107
3108 for (i=0, j=0; i<FileLength; i++)
3109 {
3110 if ((i%16) <= 4) // trim reserved field
3111 {
3112 if (i%16 == 1) // deal with DEC and HEX, only row0 is Hex, others are Dec
3113 {
3114 RateSwitchTable[j] = *(pFirmwareImage + i);
3115 }
3116 else
3117 {
3118 RateSwitchTable[j] = (*(pFirmwareImage + i)>>4) * 10 + (*(pFirmwareImage + i) & 0x0F);
3119 }
3120
3121 j++;
3122 }
3123 }
3124
3125 pAd->CommonCfg.TxRateTableSize = RateSwitchTable[0]; // backup table size
3126
3127 if (Status == NDIS_STATUS_SUCCESS)
3128 {
3129 NdisUnmapFile(FileHandle);
3130 NdisCloseFile(FileHandle);
3131 }
3132
3133 DBGPRINT(RT_DEBUG_TRACE,("<=== NICLoadRateSwitchingParams(Valid TxRateTable item number=%d)\n", pAd->CommonCfg.TxRateTableSize));
3134 #endif
3135 return NDIS_STATUS_SUCCESS;
3136 }
3137
3138 /*
3139 ========================================================================
3140
3141 Routine Description:
3142 if pSrc1 all zero with length Length, return 0.
3143 If not all zero, return 1
3144
3145 Arguments:
3146 pSrc1
3147
3148 Return Value:
3149 1: not all zero
3150 0: all zero
3151
3152 IRQL = DISPATCH_LEVEL
3153
3154 Note:
3155
3156 ========================================================================
3157 */
3158 ULONG RTMPNotAllZero(
3159 IN PVOID pSrc1,
3160 IN ULONG Length)
3161 {
3162 PUCHAR pMem1;
3163 ULONG Index = 0;
3164
3165 pMem1 = (PUCHAR) pSrc1;
3166
3167 for (Index = 0; Index < Length; Index++)
3168 {
3169 if (pMem1[Index] != 0x0)
3170 {
3171 break;
3172 }
3173 }
3174
3175 if (Index == Length)
3176 {
3177 return (0);
3178 }
3179 else
3180 {
3181 return (1);
3182 }
3183 }
3184
3185 /*
3186 ========================================================================
3187
3188 Routine Description:
3189 Compare two memory block
3190
3191 Arguments:
3192 pSrc1 Pointer to first memory address
3193 pSrc2 Pointer to second memory address
3194
3195 Return Value:
3196 0: memory is equal
3197 1: pSrc1 memory is larger
3198 2: pSrc2 memory is larger
3199
3200 IRQL = DISPATCH_LEVEL
3201
3202 Note:
3203
3204 ========================================================================
3205 */
3206 ULONG RTMPCompareMemory(
3207 IN PVOID pSrc1,
3208 IN PVOID pSrc2,
3209 IN ULONG Length)
3210 {
3211 PUCHAR pMem1;
3212 PUCHAR pMem2;
3213 ULONG Index = 0;
3214
3215 pMem1 = (PUCHAR) pSrc1;
3216 pMem2 = (PUCHAR) pSrc2;
3217
3218 for (Index = 0; Index < Length; Index++)
3219 {
3220 if (pMem1[Index] > pMem2[Index])
3221 return (1);
3222 else if (pMem1[Index] < pMem2[Index])
3223 return (2);
3224 }
3225
3226 // Equal
3227 return (0);
3228 }
3229
3230 /*
3231 ========================================================================
3232
3233 Routine Description:
3234 Zero out memory block
3235
3236 Arguments:
3237 pSrc1 Pointer to memory address
3238 Length Size
3239
3240 Return Value:
3241 None
3242
3243 IRQL = PASSIVE_LEVEL
3244 IRQL = DISPATCH_LEVEL
3245
3246 Note:
3247
3248 ========================================================================
3249 */
3250 VOID RTMPZeroMemory(
3251 IN PVOID pSrc,
3252 IN ULONG Length)
3253 {
3254 PUCHAR pMem;
3255 ULONG Index = 0;
3256
3257 pMem = (PUCHAR) pSrc;
3258
3259 for (Index = 0; Index < Length; Index++)
3260 {
3261 pMem[Index] = 0x00;
3262 }
3263 }
3264
3265 VOID RTMPFillMemory(
3266 IN PVOID pSrc,
3267 IN ULONG Length,
3268 IN UCHAR Fill)
3269 {
3270 PUCHAR pMem;
3271 ULONG Index = 0;
3272
3273 pMem = (PUCHAR) pSrc;
3274
3275 for (Index = 0; Index < Length; Index++)
3276 {
3277 pMem[Index] = Fill;
3278 }
3279 }
3280
3281 /*
3282 ========================================================================
3283
3284 Routine Description:
3285 Copy data from memory block 1 to memory block 2
3286
3287 Arguments:
3288 pDest Pointer to destination memory address
3289 pSrc Pointer to source memory address
3290 Length Copy size
3291
3292 Return Value:
3293 None
3294
3295 IRQL = PASSIVE_LEVEL
3296 IRQL = DISPATCH_LEVEL
3297
3298 Note:
3299
3300 ========================================================================
3301 */
3302 VOID RTMPMoveMemory(
3303 OUT PVOID pDest,
3304 IN PVOID pSrc,
3305 IN ULONG Length)
3306 {
3307 PUCHAR pMem1;
3308 PUCHAR pMem2;
3309 UINT Index;
3310
3311 ASSERT((Length==0) || (pDest && pSrc));
3312
3313 pMem1 = (PUCHAR) pDest;
3314 pMem2 = (PUCHAR) pSrc;
3315
3316 for (Index = 0; Index < Length; Index++)
3317 {
3318 pMem1[Index] = pMem2[Index];
3319 }
3320 }
3321
3322 /*
3323 ========================================================================
3324
3325 Routine Description:
3326 Initialize port configuration structure
3327
3328 Arguments:
3329 Adapter Pointer to our adapter
3330
3331 Return Value:
3332 None
3333
3334 IRQL = PASSIVE_LEVEL
3335
3336 Note:
3337
3338 ========================================================================
3339 */
3340 VOID UserCfgInit(
3341 IN PRTMP_ADAPTER pAd)
3342 {
3343 // EDCA_PARM DefaultEdcaParm;
3344 UINT key_index, bss_index;
3345
3346 DBGPRINT(RT_DEBUG_TRACE, ("--> UserCfgInit\n"));
3347
3348 //
3349 // part I. intialize common configuration
3350 //
3351 #ifdef RT2870
3352 pAd->BulkOutReq = 0;
3353
3354 pAd->BulkOutComplete = 0;
3355 pAd->BulkOutCompleteOther = 0;
3356 pAd->BulkOutCompleteCancel = 0;
3357 pAd->BulkInReq = 0;
3358 pAd->BulkInComplete = 0;
3359 pAd->BulkInCompleteFail = 0;
3360
3361 //pAd->QuickTimerP = 100;
3362 //pAd->TurnAggrBulkInCount = 0;
3363 pAd->bUsbTxBulkAggre = 0;
3364
3365 // init as unsed value to ensure driver will set to MCU once.
3366 pAd->LedIndicatorStregth = 0xFF;
3367
3368 pAd->CommonCfg.MaxPktOneTxBulk = 2;
3369 pAd->CommonCfg.TxBulkFactor = 1;
3370 pAd->CommonCfg.RxBulkFactor =1;
3371
3372 pAd->CommonCfg.TxPower = 100; //mW
3373
3374 NdisZeroMemory(&pAd->CommonCfg.IOTestParm, sizeof(pAd->CommonCfg.IOTestParm));
3375 #endif // RT2870 //
3376
3377 for(key_index=0; key_index<SHARE_KEY_NUM; key_index++)
3378 {
3379 for(bss_index = 0; bss_index < MAX_MBSSID_NUM; bss_index++)
3380 {
3381 pAd->SharedKey[bss_index][key_index].KeyLen = 0;
3382 pAd->SharedKey[bss_index][key_index].CipherAlg = CIPHER_NONE;
3383 }
3384 }
3385
3386 pAd->Antenna.word = 0;
3387 pAd->CommonCfg.BBPCurrentBW = BW_20;
3388
3389 pAd->LedCntl.word = 0;
3390
3391 pAd->bAutoTxAgcA = FALSE; // Default is OFF
3392 pAd->bAutoTxAgcG = FALSE; // Default is OFF
3393 pAd->RfIcType = RFIC_2820;
3394
3395 // Init timer for reset complete event
3396 pAd->CommonCfg.CentralChannel = 1;
3397 pAd->bForcePrintTX = FALSE;
3398 pAd->bForcePrintRX = FALSE;
3399 pAd->bStaFifoTest = FALSE;
3400 pAd->bProtectionTest = FALSE;
3401 pAd->bHCCATest = FALSE;
3402 pAd->bGenOneHCCA = FALSE;
3403 pAd->CommonCfg.Dsifs = 10; // in units of usec
3404 pAd->CommonCfg.TxPower = 100; //mW
3405 pAd->CommonCfg.TxPowerPercentage = 0xffffffff; // AUTO
3406 pAd->CommonCfg.TxPowerDefault = 0xffffffff; // AUTO
3407 pAd->CommonCfg.TxPreamble = Rt802_11PreambleAuto; // use Long preamble on TX by defaut
3408 pAd->CommonCfg.bUseZeroToDisableFragment = FALSE;
3409 pAd->CommonCfg.RtsThreshold = 2347;
3410 pAd->CommonCfg.FragmentThreshold = 2346;
3411 pAd->CommonCfg.UseBGProtection = 0; // 0: AUTO
3412 pAd->CommonCfg.bEnableTxBurst = TRUE; //0;
3413 pAd->CommonCfg.PhyMode = 0xff; // unknown
3414 pAd->CommonCfg.BandState = UNKNOWN_BAND;
3415 pAd->CommonCfg.RadarDetect.CSPeriod = 10;
3416 pAd->CommonCfg.RadarDetect.CSCount = 0;
3417 pAd->CommonCfg.RadarDetect.RDMode = RD_NORMAL_MODE;
3418 pAd->CommonCfg.RadarDetect.ChMovingTime = 65;
3419 pAd->CommonCfg.RadarDetect.LongPulseRadarTh = 3;
3420 pAd->CommonCfg.bAPSDCapable = FALSE;
3421 pAd->CommonCfg.bNeedSendTriggerFrame = FALSE;
3422 pAd->CommonCfg.TriggerTimerCount = 0;
3423 pAd->CommonCfg.bAPSDForcePowerSave = FALSE;
3424 pAd->CommonCfg.bCountryFlag = FALSE;
3425 pAd->CommonCfg.TxStream = 0;
3426 pAd->CommonCfg.RxStream = 0;
3427
3428 NdisZeroMemory(&pAd->BeaconTxWI, sizeof(pAd->BeaconTxWI));
3429
3430 #ifdef DOT11_N_SUPPORT
3431 NdisZeroMemory(&pAd->CommonCfg.HtCapability, sizeof(pAd->CommonCfg.HtCapability));
3432 pAd->HTCEnable = FALSE;
3433 pAd->bBroadComHT = FALSE;
3434 pAd->CommonCfg.bRdg = FALSE;
3435
3436 #ifdef DOT11N_DRAFT3
3437 pAd->CommonCfg.Dot11OBssScanPassiveDwell = dot11OBSSScanPassiveDwell; // Unit : TU. 5~1000
3438 pAd->CommonCfg.Dot11OBssScanActiveDwell = dot11OBSSScanActiveDwell; // Unit : TU. 10~1000
3439 pAd->CommonCfg.Dot11BssWidthTriggerScanInt = dot11BSSWidthTriggerScanInterval; // Unit : Second
3440 pAd->CommonCfg.Dot11OBssScanPassiveTotalPerChannel = dot11OBSSScanPassiveTotalPerChannel; // Unit : TU. 200~10000
3441 pAd->CommonCfg.Dot11OBssScanActiveTotalPerChannel = dot11OBSSScanActiveTotalPerChannel; // Unit : TU. 20~10000
3442 pAd->CommonCfg.Dot11BssWidthChanTranDelayFactor = dot11BSSWidthChannelTransactionDelayFactor;
3443 pAd->CommonCfg.Dot11OBssScanActivityThre = dot11BSSScanActivityThreshold; // Unit : percentage
3444 pAd->CommonCfg.Dot11BssWidthChanTranDelay = (pAd->CommonCfg.Dot11BssWidthTriggerScanInt * pAd->CommonCfg.Dot11BssWidthChanTranDelayFactor);
3445 #endif // DOT11N_DRAFT3 //
3446
3447 NdisZeroMemory(&pAd->CommonCfg.AddHTInfo, sizeof(pAd->CommonCfg.AddHTInfo));
3448 pAd->CommonCfg.BACapability.field.MMPSmode = MMPS_ENABLE;
3449 pAd->CommonCfg.BACapability.field.MpduDensity = 0;
3450 pAd->CommonCfg.BACapability.field.Policy = IMMED_BA;
3451 pAd->CommonCfg.BACapability.field.RxBAWinLimit = 64; //32;
3452 pAd->CommonCfg.BACapability.field.TxBAWinLimit = 64; //32;
3453 DBGPRINT(RT_DEBUG_TRACE, ("--> UserCfgInit. BACapability = 0x%x\n", pAd->CommonCfg.BACapability.word));
3454
3455 pAd->CommonCfg.BACapability.field.AutoBA = FALSE;
3456 BATableInit(pAd, &pAd->BATable);
3457
3458 pAd->CommonCfg.bExtChannelSwitchAnnouncement = 1;
3459 pAd->CommonCfg.bHTProtect = 1;
3460 pAd->CommonCfg.bMIMOPSEnable = TRUE;
3461 pAd->CommonCfg.bBADecline = FALSE;
3462 pAd->CommonCfg.bDisableReordering = FALSE;
3463
3464 pAd->CommonCfg.TxBASize = 7;
3465
3466 pAd->CommonCfg.REGBACapability.word = pAd->CommonCfg.BACapability.word;
3467 #endif // DOT11_N_SUPPORT //
3468
3469 //pAd->CommonCfg.HTPhyMode.field.BW = BW_20;
3470 //pAd->CommonCfg.HTPhyMode.field.MCS = MCS_AUTO;
3471 //pAd->CommonCfg.HTPhyMode.field.ShortGI = GI_800;
3472 //pAd->CommonCfg.HTPhyMode.field.STBC = STBC_NONE;
3473 pAd->CommonCfg.TxRate = RATE_6;
3474
3475 pAd->CommonCfg.MlmeTransmit.field.MCS = MCS_RATE_6;
3476 pAd->CommonCfg.MlmeTransmit.field.BW = BW_20;
3477 pAd->CommonCfg.MlmeTransmit.field.MODE = MODE_OFDM;
3478
3479 pAd->CommonCfg.BeaconPeriod = 100; // in mSec
3480
3481 //
3482 // part II. intialize STA specific configuration
3483 //
3484 #ifdef CONFIG_STA_SUPPORT
3485 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3486 {
3487 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_DIRECT);
3488 RX_FILTER_CLEAR_FLAG(pAd, fRX_FILTER_ACCEPT_MULTICAST);
3489 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_BROADCAST);
3490 RX_FILTER_SET_FLAG(pAd, fRX_FILTER_ACCEPT_ALL_MULTICAST);
3491
3492 pAd->StaCfg.Psm = PWR_ACTIVE;
3493
3494 pAd->StaCfg.OrigWepStatus = Ndis802_11EncryptionDisabled;
3495 pAd->StaCfg.PairCipher = Ndis802_11EncryptionDisabled;
3496 pAd->StaCfg.GroupCipher = Ndis802_11EncryptionDisabled;
3497 pAd->StaCfg.bMixCipher = FALSE;
3498 pAd->StaCfg.DefaultKeyId = 0;
3499
3500 // 802.1x port control
3501 pAd->StaCfg.PrivacyFilter = Ndis802_11PrivFilter8021xWEP;
3502 pAd->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
3503 pAd->StaCfg.LastMicErrorTime = 0;
3504 pAd->StaCfg.MicErrCnt = 0;
3505 pAd->StaCfg.bBlockAssoc = FALSE;
3506 pAd->StaCfg.WpaState = SS_NOTUSE;
3507
3508 pAd->CommonCfg.NdisRadioStateOff = FALSE; // New to support microsoft disable radio with OID command
3509
3510 pAd->StaCfg.RssiTrigger = 0;
3511 NdisZeroMemory(&pAd->StaCfg.RssiSample, sizeof(RSSI_SAMPLE));
3512 pAd->StaCfg.RssiTriggerMode = RSSI_TRIGGERED_UPON_BELOW_THRESHOLD;
3513 pAd->StaCfg.AtimWin = 0;
3514 pAd->StaCfg.DefaultListenCount = 3;//default listen count;
3515 pAd->StaCfg.BssType = BSS_INFRA; // BSS_INFRA or BSS_ADHOC or BSS_MONITOR
3516 pAd->StaCfg.bScanReqIsFromWebUI = FALSE;
3517 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_DOZE);
3518 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_WAKEUP_NOW);
3519
3520 pAd->StaCfg.bAutoTxRateSwitch = TRUE;
3521 pAd->StaCfg.DesiredTransmitSetting.field.MCS = MCS_AUTO;
3522 }
3523
3524 #ifdef EXT_BUILD_CHANNEL_LIST
3525 pAd->StaCfg.IEEE80211dClientMode = Rt802_11_D_None;
3526 #endif // EXT_BUILD_CHANNEL_LIST //
3527 #endif // CONFIG_STA_SUPPORT //
3528
3529 // global variables mXXXX used in MAC protocol state machines
3530 OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
3531 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_ADHOC_ON);
3532 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_INFRA_ON);
3533
3534 // PHY specification
3535 pAd->CommonCfg.PhyMode = PHY_11BG_MIXED; // default PHY mode
3536 OPSTATUS_CLEAR_FLAG(pAd, fOP_STATUS_SHORT_PREAMBLE_INUSED); // CCK use LONG preamble
3537
3538 #ifdef CONFIG_STA_SUPPORT
3539 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
3540 {
3541 // user desired power mode
3542 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeCAM;
3543 pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeCAM;
3544 pAd->StaCfg.bWindowsACCAMEnable = FALSE;
3545
3546 #ifdef LEAP_SUPPORT
3547 // CCX v1.0 releated init value
3548 RTMPInitTimer(pAd, &pAd->StaCfg.LeapAuthTimer, GET_TIMER_FUNCTION(LeapAuthTimeout), pAd, FALSE);
3549 pAd->StaCfg.LeapAuthMode = CISCO_AuthModeLEAPNone;
3550 pAd->StaCfg.bCkipOn = FALSE;
3551 #endif // LEAP_SUPPORT //
3552
3553 RTMPInitTimer(pAd, &pAd->StaCfg.StaQuickResponeForRateUpTimer, GET_TIMER_FUNCTION(StaQuickResponeForRateUpExec), pAd, FALSE);
3554 pAd->StaCfg.StaQuickResponeForRateUpTimerRunning = FALSE;
3555
3556 // Patch for Ndtest
3557 pAd->StaCfg.ScanCnt = 0;
3558
3559 // CCX 2.0 control flag init
3560 pAd->StaCfg.CCXEnable = FALSE;
3561 pAd->StaCfg.CCXReqType = MSRN_TYPE_UNUSED;
3562 pAd->StaCfg.CCXQosECWMin = 4;
3563 pAd->StaCfg.CCXQosECWMax = 10;
3564
3565 pAd->StaCfg.bHwRadio = TRUE; // Default Hardware Radio status is On
3566 pAd->StaCfg.bSwRadio = TRUE; // Default Software Radio status is On
3567 pAd->StaCfg.bRadio = TRUE; // bHwRadio && bSwRadio
3568 pAd->StaCfg.bHardwareRadio = FALSE; // Default is OFF
3569 pAd->StaCfg.bShowHiddenSSID = FALSE; // Default no show
3570
3571 // Nitro mode control
3572 pAd->StaCfg.bAutoReconnect = TRUE;
3573
3574 // Save the init time as last scan time, the system should do scan after 2 seconds.
3575 // This patch is for driver wake up from standby mode, system will do scan right away.
3576 pAd->StaCfg.LastScanTime = 0;
3577 NdisZeroMemory(pAd->nickname, IW_ESSID_MAX_SIZE+1);
3578 sprintf(pAd->nickname, "%s", STA_NIC_DEVICE_NAME);
3579 RTMPInitTimer(pAd, &pAd->StaCfg.WpaDisassocAndBlockAssocTimer, GET_TIMER_FUNCTION(WpaDisassocApAndBlockAssoc), pAd, FALSE);
3580 #ifdef WPA_SUPPLICANT_SUPPORT
3581 pAd->StaCfg.IEEE8021X = FALSE;
3582 pAd->StaCfg.IEEE8021x_required_keys = FALSE;
3583 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_DISABLE;
3584 #ifdef NATIVE_WPA_SUPPLICANT_SUPPORT
3585 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_ENABLE;
3586 #endif // NATIVE_WPA_SUPPLICANT_SUPPORT //
3587 #endif // WPA_SUPPLICANT_SUPPORT //
3588
3589 }
3590 #endif // CONFIG_STA_SUPPORT //
3591
3592 // Default for extra information is not valid
3593 pAd->ExtraInfo = EXTRA_INFO_CLEAR;
3594
3595 // Default Config change flag
3596 pAd->bConfigChanged = FALSE;
3597
3598 //
3599 // part III. AP configurations
3600 //
3601
3602
3603 //
3604 // part IV. others
3605 //
3606 // dynamic BBP R66:sensibity tuning to overcome background noise
3607 pAd->BbpTuning.bEnable = TRUE;
3608 pAd->BbpTuning.FalseCcaLowerThreshold = 100;
3609 pAd->BbpTuning.FalseCcaUpperThreshold = 512;
3610 pAd->BbpTuning.R66Delta = 4;
3611 pAd->Mlme.bEnableAutoAntennaCheck = TRUE;
3612
3613 //
3614 // Also initial R66CurrentValue, RTUSBResumeMsduTransmission might use this value.
3615 // if not initial this value, the default value will be 0.
3616 //
3617 pAd->BbpTuning.R66CurrentValue = 0x38;
3618
3619 pAd->Bbp94 = BBPR94_DEFAULT;
3620 pAd->BbpForCCK = FALSE;
3621
3622 // Default is FALSE for test bit 1
3623 //pAd->bTest1 = FALSE;
3624
3625 // initialize MAC table and allocate spin lock
3626 NdisZeroMemory(&pAd->MacTab, sizeof(MAC_TABLE));
3627 InitializeQueueHeader(&pAd->MacTab.McastPsQueue);
3628 NdisAllocateSpinLock(&pAd->MacTabLock);
3629
3630 //RTMPInitTimer(pAd, &pAd->RECBATimer, RECBATimerTimeout, pAd, TRUE);
3631 //RTMPSetTimer(&pAd->RECBATimer, REORDER_EXEC_INTV);
3632
3633 #ifdef RALINK_ATE
3634 NdisZeroMemory(&pAd->ate, sizeof(ATE_INFO));
3635 pAd->ate.Mode = ATE_STOP;
3636 pAd->ate.TxCount = 200;/* to exceed TX_RING_SIZE ... */
3637 pAd->ate.TxLength = 1024;
3638 pAd->ate.TxWI.ShortGI = 0;// LONG GI : 800 ns
3639 pAd->ate.TxWI.PHYMODE = MODE_CCK;
3640 pAd->ate.TxWI.MCS = 3;
3641 pAd->ate.TxWI.BW = BW_20;
3642 pAd->ate.Channel = 1;
3643 pAd->ate.QID = QID_AC_BE;
3644 pAd->ate.Addr1[0] = 0x00;
3645 pAd->ate.Addr1[1] = 0x11;
3646 pAd->ate.Addr1[2] = 0x22;
3647 pAd->ate.Addr1[3] = 0xAA;
3648 pAd->ate.Addr1[4] = 0xBB;
3649 pAd->ate.Addr1[5] = 0xCC;
3650 NdisMoveMemory(pAd->ate.Addr2, pAd->ate.Addr1, ETH_LENGTH_OF_ADDRESS);
3651 NdisMoveMemory(pAd->ate.Addr3, pAd->ate.Addr1, ETH_LENGTH_OF_ADDRESS);
3652 pAd->ate.bRxFer = 0;
3653 pAd->ate.bQATxStart = FALSE;
3654 pAd->ate.bQARxStart = FALSE;
3655 #ifdef RALINK_28xx_QA
3656 //pAd->ate.Repeat = 0;
3657 pAd->ate.TxStatus = 0;
3658 pAd->ate.AtePid = THREAD_PID_INIT_VALUE;
3659 #endif // RALINK_28xx_QA //
3660 #endif // RALINK_ATE //
3661
3662
3663 pAd->CommonCfg.bWiFiTest = FALSE;
3664
3665
3666 DBGPRINT(RT_DEBUG_TRACE, ("<-- UserCfgInit\n"));
3667 }
3668
3669 // IRQL = PASSIVE_LEVEL
3670 UCHAR BtoH(char ch)
3671 {
3672 if (ch >= '0' && ch <= '9') return (ch - '0'); // Handle numerals
3673 if (ch >= 'A' && ch <= 'F') return (ch - 'A' + 0xA); // Handle capitol hex digits
3674 if (ch >= 'a' && ch <= 'f') return (ch - 'a' + 0xA); // Handle small hex digits
3675 return(255);
3676 }
3677
3678 //
3679 // FUNCTION: AtoH(char *, UCHAR *, int)
3680 //
3681 // PURPOSE: Converts ascii string to network order hex
3682 //
3683 // PARAMETERS:
3684 // src - pointer to input ascii string
3685 // dest - pointer to output hex
3686 // destlen - size of dest
3687 //
3688 // COMMENTS:
3689 //
3690 // 2 ascii bytes make a hex byte so must put 1st ascii byte of pair
3691 // into upper nibble and 2nd ascii byte of pair into lower nibble.
3692 //
3693 // IRQL = PASSIVE_LEVEL
3694
3695 void AtoH(char * src, UCHAR * dest, int destlen)
3696 {
3697 char * srcptr;
3698 PUCHAR destTemp;
3699
3700 srcptr = src;
3701 destTemp = (PUCHAR) dest;
3702
3703 while(destlen--)
3704 {
3705 *destTemp = BtoH(*srcptr++) << 4; // Put 1st ascii byte in upper nibble.
3706 *destTemp += BtoH(*srcptr++); // Add 2nd ascii byte to above.
3707 destTemp++;
3708 }
3709 }
3710
3711 VOID RTMPPatchMacBbpBug(
3712 IN PRTMP_ADAPTER pAd)
3713 {
3714 ULONG Index;
3715
3716 // Initialize BBP register to default value
3717 for (Index = 0; Index < NUM_BBP_REG_PARMS; Index++)
3718 {
3719 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAd, BBPRegTable[Index].Register, (UCHAR)BBPRegTable[Index].Value);
3720 }
3721
3722 // Initialize RF register to default value
3723 AsicSwitchChannel(pAd, pAd->CommonCfg.Channel, FALSE);
3724 AsicLockChannel(pAd, pAd->CommonCfg.Channel);
3725
3726 // Re-init BBP register from EEPROM value
3727 NICInitAsicFromEEPROM(pAd);
3728 }
3729
3730 /*
3731 ========================================================================
3732
3733 Routine Description:
3734 Init timer objects
3735
3736 Arguments:
3737 pAd Pointer to our adapter
3738 pTimer Timer structure
3739 pTimerFunc Function to execute when timer expired
3740 Repeat Ture for period timer
3741
3742 Return Value:
3743 None
3744
3745 Note:
3746
3747 ========================================================================
3748 */
3749 VOID RTMPInitTimer(
3750 IN PRTMP_ADAPTER pAd,
3751 IN PRALINK_TIMER_STRUCT pTimer,
3752 IN PVOID pTimerFunc,
3753 IN PVOID pData,
3754 IN BOOLEAN Repeat)
3755 {
3756 //
3757 // Set Valid to TRUE for later used.
3758 // It will crash if we cancel a timer or set a timer
3759 // that we haven't initialize before.
3760 //
3761 pTimer->Valid = TRUE;
3762
3763 pTimer->PeriodicType = Repeat;
3764 pTimer->State = FALSE;
3765 pTimer->cookie = (ULONG) pData;
3766
3767 #ifdef RT2870
3768 pTimer->pAd = pAd;
3769 #endif // RT2870 //
3770
3771 RTMP_OS_Init_Timer(pAd, &pTimer->TimerObj, pTimerFunc, (PVOID) pTimer);
3772 }
3773
3774 /*
3775 ========================================================================
3776
3777 Routine Description:
3778 Init timer objects
3779
3780 Arguments:
3781 pTimer Timer structure
3782 Value Timer value in milliseconds
3783
3784 Return Value:
3785 None
3786
3787 Note:
3788 To use this routine, must call RTMPInitTimer before.
3789
3790 ========================================================================
3791 */
3792 VOID RTMPSetTimer(
3793 IN PRALINK_TIMER_STRUCT pTimer,
3794 IN ULONG Value)
3795 {
3796 if (pTimer->Valid)
3797 {
3798 pTimer->TimerValue = Value;
3799 pTimer->State = FALSE;
3800 if (pTimer->PeriodicType == TRUE)
3801 {
3802 pTimer->Repeat = TRUE;
3803 RTMP_SetPeriodicTimer(&pTimer->TimerObj, Value);
3804 }
3805 else
3806 {
3807 pTimer->Repeat = FALSE;
3808 RTMP_OS_Add_Timer(&pTimer->TimerObj, Value);
3809 }
3810 }
3811 else
3812 {
3813 DBGPRINT_ERR(("RTMPSetTimer failed, Timer hasn't been initialize!\n"));
3814 }
3815 }
3816
3817
3818 /*
3819 ========================================================================
3820
3821 Routine Description:
3822 Init timer objects
3823
3824 Arguments:
3825 pTimer Timer structure
3826 Value Timer value in milliseconds
3827
3828 Return Value:
3829 None
3830
3831 Note:
3832 To use this routine, must call RTMPInitTimer before.
3833
3834 ========================================================================
3835 */
3836 VOID RTMPModTimer(
3837 IN PRALINK_TIMER_STRUCT pTimer,
3838 IN ULONG Value)
3839 {
3840 BOOLEAN Cancel;
3841
3842 if (pTimer->Valid)
3843 {
3844 pTimer->TimerValue = Value;
3845 pTimer->State = FALSE;
3846 if (pTimer->PeriodicType == TRUE)
3847 {
3848 RTMPCancelTimer(pTimer, &Cancel);
3849 RTMPSetTimer(pTimer, Value);
3850 }
3851 else
3852 {
3853 RTMP_OS_Mod_Timer(&pTimer->TimerObj, Value);
3854 }
3855 }
3856 else
3857 {
3858 DBGPRINT_ERR(("RTMPModTimer failed, Timer hasn't been initialize!\n"));
3859 }
3860 }
3861
3862 /*
3863 ========================================================================
3864
3865 Routine Description:
3866 Cancel timer objects
3867
3868 Arguments:
3869 Adapter Pointer to our adapter
3870
3871 Return Value:
3872 None
3873
3874 IRQL = PASSIVE_LEVEL
3875 IRQL = DISPATCH_LEVEL
3876
3877 Note:
3878 1.) To use this routine, must call RTMPInitTimer before.
3879 2.) Reset NIC to initial state AS IS system boot up time.
3880
3881 ========================================================================
3882 */
3883 VOID RTMPCancelTimer(
3884 IN PRALINK_TIMER_STRUCT pTimer,
3885 OUT BOOLEAN *pCancelled)
3886 {
3887 if (pTimer->Valid)
3888 {
3889 if (pTimer->State == FALSE)
3890 pTimer->Repeat = FALSE;
3891 RTMP_OS_Del_Timer(&pTimer->TimerObj, pCancelled);
3892
3893 if (*pCancelled == TRUE)
3894 pTimer->State = TRUE;
3895
3896 #ifdef RT2870
3897 // We need to go-through the TimerQ to findout this timer handler and remove it if
3898 // it's still waiting for execution.
3899
3900 RT2870_TimerQ_Remove(pTimer->pAd, pTimer);
3901 #endif // RT2870 //
3902 }
3903 else
3904 {
3905 //
3906 // NdisMCancelTimer just canced the timer and not mean release the timer.
3907 // And don't set the "Valid" to False. So that we can use this timer again.
3908 //
3909 DBGPRINT_ERR(("RTMPCancelTimer failed, Timer hasn't been initialize!\n"));
3910 }
3911 }
3912
3913 /*
3914 ========================================================================
3915
3916 Routine Description:
3917 Set LED Status
3918
3919 Arguments:
3920 pAd Pointer to our adapter
3921 Status LED Status
3922
3923 Return Value:
3924 None
3925
3926 IRQL = PASSIVE_LEVEL
3927 IRQL = DISPATCH_LEVEL
3928
3929 Note:
3930
3931 ========================================================================
3932 */
3933 VOID RTMPSetLED(
3934 IN PRTMP_ADAPTER pAd,
3935 IN UCHAR Status)
3936 {
3937 //ULONG data;
3938 UCHAR HighByte = 0;
3939 UCHAR LowByte;
3940
3941 // In ATE mode of RT2860 AP/STA, we have erased 8051 firmware.
3942 // So LED mode is not supported when ATE is running.
3943 #ifdef RALINK_ATE
3944 if (ATE_ON(pAd))
3945 return;
3946 #endif // RALINK_ATE //
3947
3948 LowByte = pAd->LedCntl.field.LedMode&0x7f;
3949 switch (Status)
3950 {
3951 case LED_LINK_DOWN:
3952 HighByte = 0x20;
3953 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3954 pAd->LedIndicatorStregth = 0;
3955 break;
3956 case LED_LINK_UP:
3957 if (pAd->CommonCfg.Channel > 14)
3958 HighByte = 0xa0;
3959 else
3960 HighByte = 0x60;
3961 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3962 break;
3963 case LED_RADIO_ON:
3964 HighByte = 0x20;
3965 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3966 break;
3967 case LED_HALT:
3968 LowByte = 0; // Driver sets MAC register and MAC controls LED
3969 case LED_RADIO_OFF:
3970 HighByte = 0;
3971 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3972 break;
3973 case LED_WPS:
3974 HighByte = 0x10;
3975 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3976 break;
3977 case LED_ON_SITE_SURVEY:
3978 HighByte = 0x08;
3979 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3980 break;
3981 case LED_POWER_UP:
3982 HighByte = 0x04;
3983 AsicSendCommandToMcu(pAd, 0x50, 0xff, LowByte, HighByte);
3984 break;
3985 default:
3986 DBGPRINT(RT_DEBUG_WARN, ("RTMPSetLED::Unknown Status %d\n", Status));
3987 break;
3988 }
3989
3990 //
3991 // Keep LED status for LED SiteSurvey mode.
3992 // After SiteSurvey, we will set the LED mode to previous status.
3993 //
3994 if ((Status != LED_ON_SITE_SURVEY) && (Status != LED_POWER_UP))
3995 pAd->LedStatus = Status;
3996
3997 DBGPRINT(RT_DEBUG_TRACE, ("RTMPSetLED::Mode=%d,HighByte=0x%02x,LowByte=0x%02x\n", pAd->LedCntl.field.LedMode, HighByte, LowByte));
3998 }
3999
4000 /*
4001 ========================================================================
4002
4003 Routine Description:
4004 Set LED Signal Stregth
4005
4006 Arguments:
4007 pAd Pointer to our adapter
4008 Dbm Signal Stregth
4009
4010 Return Value:
4011 None
4012
4013 IRQL = PASSIVE_LEVEL
4014
4015 Note:
4016 Can be run on any IRQL level.
4017
4018 According to Microsoft Zero Config Wireless Signal Stregth definition as belows.
4019 <= -90 No Signal
4020 <= -81 Very Low
4021 <= -71 Low
4022 <= -67 Good
4023 <= -57 Very Good
4024 > -57 Excellent
4025 ========================================================================
4026 */
4027 VOID RTMPSetSignalLED(
4028 IN PRTMP_ADAPTER pAd,
4029 IN NDIS_802_11_RSSI Dbm)
4030 {
4031 UCHAR nLed = 0;
4032
4033 //
4034 // if not Signal Stregth, then do nothing.
4035 //
4036 if (pAd->LedCntl.field.LedMode != LED_MODE_SIGNAL_STREGTH)
4037 {
4038 return;
4039 }
4040
4041 if (Dbm <= -90)
4042 nLed = 0;
4043 else if (Dbm <= -81)
4044 nLed = 1;
4045 else if (Dbm <= -71)
4046 nLed = 3;
4047 else if (Dbm <= -67)
4048 nLed = 7;
4049 else if (Dbm <= -57)
4050 nLed = 15;
4051 else
4052 nLed = 31;
4053
4054 //
4055 // Update Signal Stregth to firmware if changed.
4056 //
4057 if (pAd->LedIndicatorStregth != nLed)
4058 {
4059 AsicSendCommandToMcu(pAd, 0x51, 0xff, nLed, pAd->LedCntl.field.Polarity);
4060 pAd->LedIndicatorStregth = nLed;
4061 }
4062 }
4063
4064 /*
4065 ========================================================================
4066
4067 Routine Description:
4068 Enable RX
4069
4070 Arguments:
4071 pAd Pointer to our adapter
4072
4073 Return Value:
4074 None
4075
4076 IRQL <= DISPATCH_LEVEL
4077
4078 Note:
4079 Before Enable RX, make sure you have enabled Interrupt.
4080 ========================================================================
4081 */
4082 VOID RTMPEnableRxTx(
4083 IN PRTMP_ADAPTER pAd)
4084 {
4085 // WPDMA_GLO_CFG_STRUC GloCfg;
4086 // ULONG i = 0;
4087
4088 DBGPRINT(RT_DEBUG_TRACE, ("==> RTMPEnableRxTx\n"));
4089
4090 #if 0
4091 // Enable Rx DMA.
4092 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0x4);
4093 do
4094 {
4095 RTMP_IO_READ32(pAd, WPDMA_GLO_CFG, &GloCfg.word);
4096 if ((GloCfg.field.TxDMABusy == 0) && (GloCfg.field.RxDMABusy == 0))
4097 break;
4098
4099 DBGPRINT(RT_DEBUG_TRACE, ("==> DMABusy\n"));
4100 RTMPusecDelay(1000);
4101 i++;
4102 }while ( i <200);
4103
4104 RTMPusecDelay(50);
4105 RT28XX_DMA_WRITE_INIT(GloCfg);
4106 DBGPRINT(RT_DEBUG_TRACE, ("<== WRITE DMA offset 0x208 = 0x%x\n", GloCfg.word));
4107 RTMP_IO_WRITE32(pAd, WPDMA_GLO_CFG, GloCfg.word);
4108
4109 RT28XX_DMA_POST_WRITE(pAd);
4110 #else
4111 // Enable Rx DMA.
4112 RT28XXDMAEnable(pAd);
4113 #endif
4114
4115 // enable RX of MAC block
4116 if (pAd->OpMode == OPMODE_AP)
4117 {
4118 UINT32 rx_filter_flag = APNORMAL;
4119
4120
4121 RTMP_IO_WRITE32(pAd, RX_FILTR_CFG, rx_filter_flag); // enable RX of DMA block
4122 }
4123 else
4124 {
4125 RTMP_IO_WRITE32(pAd, RX_FILTR_CFG, STANORMAL); // Staion not drop control frame will fail WiFi Certification.
4126 }
4127
4128 RTMP_IO_WRITE32(pAd, MAC_SYS_CTRL, 0xc);
4129 DBGPRINT(RT_DEBUG_TRACE, ("<== RTMPEnableRxTx\n"));
4130 }
4131
4132
Support for the Chinese Samsung S3C2440 based development boards