projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix common misspellings
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / rtl8192e / r819xE_phy.c
1 #include "r8192E.h"
2 #include "r8192E_hw.h"
3 #include "r819xE_phyreg.h"
4 #include "r8190_rtl8256.h"
5 #include "r819xE_phy.h"
6 #include "r8192E_dm.h"
7 #ifdef ENABLE_DOT11D
8 #include "ieee80211/dot11d.h"
9 #endif
10 static const u32 RF_CHANNEL_TABLE_ZEBRA[] = {
11 0,
12 0x085c, //2412 1
13 0x08dc, //2417 2
14 0x095c, //2422 3
15 0x09dc, //2427 4
16 0x0a5c, //2432 5
17 0x0adc, //2437 6
18 0x0b5c, //2442 7
19 0x0bdc, //2447 8
20 0x0c5c, //2452 9
21 0x0cdc, //2457 10
22 0x0d5c, //2462 11
23 0x0ddc, //2467 12
24 0x0e5c, //2472 13
25 0x0f72, //2484
26 };
27
28 static u32 Rtl8192PciEMACPHY_Array[] = {
29 0x03c,0xffff0000,0x00000f0f,
30 0x340,0xffffffff,0x161a1a1a,
31 0x344,0xffffffff,0x12121416,
32 0x348,0x0000ffff,0x00001818,
33 0x12c,0xffffffff,0x04000802,
34 0x318,0x00000fff,0x00000100,
35 };
36 static u32 Rtl8192PciEMACPHY_Array_PG[] = {
37 0x03c,0xffff0000,0x00000f0f,
38 0xe00,0xffffffff,0x06090909,
39 0xe04,0xffffffff,0x00030306,
40 0xe08,0x0000ff00,0x00000000,
41 0xe10,0xffffffff,0x0a0c0d0f,
42 0xe14,0xffffffff,0x06070809,
43 0xe18,0xffffffff,0x0a0c0d0f,
44 0xe1c,0xffffffff,0x06070809,
45 0x12c,0xffffffff,0x04000802,
46 0x318,0x00000fff,0x00000800,
47 };
48 static u32 Rtl8192PciEAGCTAB_Array[AGCTAB_ArrayLength] = {
49 0xc78,0x7d000001,
50 0xc78,0x7d010001,
51 0xc78,0x7d020001,
52 0xc78,0x7d030001,
53 0xc78,0x7d040001,
54 0xc78,0x7d050001,
55 0xc78,0x7c060001,
56 0xc78,0x7b070001,
57 0xc78,0x7a080001,
58 0xc78,0x79090001,
59 0xc78,0x780a0001,
60 0xc78,0x770b0001,
61 0xc78,0x760c0001,
62 0xc78,0x750d0001,
63 0xc78,0x740e0001,
64 0xc78,0x730f0001,
65 0xc78,0x72100001,
66 0xc78,0x71110001,
67 0xc78,0x70120001,
68 0xc78,0x6f130001,
69 0xc78,0x6e140001,
70 0xc78,0x6d150001,
71 0xc78,0x6c160001,
72 0xc78,0x6b170001,
73 0xc78,0x6a180001,
74 0xc78,0x69190001,
75 0xc78,0x681a0001,
76 0xc78,0x671b0001,
77 0xc78,0x661c0001,
78 0xc78,0x651d0001,
79 0xc78,0x641e0001,
80 0xc78,0x491f0001,
81 0xc78,0x48200001,
82 0xc78,0x47210001,
83 0xc78,0x46220001,
84 0xc78,0x45230001,
85 0xc78,0x44240001,
86 0xc78,0x43250001,
87 0xc78,0x28260001,
88 0xc78,0x27270001,
89 0xc78,0x26280001,
90 0xc78,0x25290001,
91 0xc78,0x242a0001,
92 0xc78,0x232b0001,
93 0xc78,0x222c0001,
94 0xc78,0x212d0001,
95 0xc78,0x202e0001,
96 0xc78,0x0a2f0001,
97 0xc78,0x08300001,
98 0xc78,0x06310001,
99 0xc78,0x05320001,
100 0xc78,0x04330001,
101 0xc78,0x03340001,
102 0xc78,0x02350001,
103 0xc78,0x01360001,
104 0xc78,0x00370001,
105 0xc78,0x00380001,
106 0xc78,0x00390001,
107 0xc78,0x003a0001,
108 0xc78,0x003b0001,
109 0xc78,0x003c0001,
110 0xc78,0x003d0001,
111 0xc78,0x003e0001,
112 0xc78,0x003f0001,
113 0xc78,0x7d400001,
114 0xc78,0x7d410001,
115 0xc78,0x7d420001,
116 0xc78,0x7d430001,
117 0xc78,0x7d440001,
118 0xc78,0x7d450001,
119 0xc78,0x7c460001,
120 0xc78,0x7b470001,
121 0xc78,0x7a480001,
122 0xc78,0x79490001,
123 0xc78,0x784a0001,
124 0xc78,0x774b0001,
125 0xc78,0x764c0001,
126 0xc78,0x754d0001,
127 0xc78,0x744e0001,
128 0xc78,0x734f0001,
129 0xc78,0x72500001,
130 0xc78,0x71510001,
131 0xc78,0x70520001,
132 0xc78,0x6f530001,
133 0xc78,0x6e540001,
134 0xc78,0x6d550001,
135 0xc78,0x6c560001,
136 0xc78,0x6b570001,
137 0xc78,0x6a580001,
138 0xc78,0x69590001,
139 0xc78,0x685a0001,
140 0xc78,0x675b0001,
141 0xc78,0x665c0001,
142 0xc78,0x655d0001,
143 0xc78,0x645e0001,
144 0xc78,0x495f0001,
145 0xc78,0x48600001,
146 0xc78,0x47610001,
147 0xc78,0x46620001,
148 0xc78,0x45630001,
149 0xc78,0x44640001,
150 0xc78,0x43650001,
151 0xc78,0x28660001,
152 0xc78,0x27670001,
153 0xc78,0x26680001,
154 0xc78,0x25690001,
155 0xc78,0x246a0001,
156 0xc78,0x236b0001,
157 0xc78,0x226c0001,
158 0xc78,0x216d0001,
159 0xc78,0x206e0001,
160 0xc78,0x0a6f0001,
161 0xc78,0x08700001,
162 0xc78,0x06710001,
163 0xc78,0x05720001,
164 0xc78,0x04730001,
165 0xc78,0x03740001,
166 0xc78,0x02750001,
167 0xc78,0x01760001,
168 0xc78,0x00770001,
169 0xc78,0x00780001,
170 0xc78,0x00790001,
171 0xc78,0x007a0001,
172 0xc78,0x007b0001,
173 0xc78,0x007c0001,
174 0xc78,0x007d0001,
175 0xc78,0x007e0001,
176 0xc78,0x007f0001,
177 0xc78,0x2e00001e,
178 0xc78,0x2e01001e,
179 0xc78,0x2e02001e,
180 0xc78,0x2e03001e,
181 0xc78,0x2e04001e,
182 0xc78,0x2e05001e,
183 0xc78,0x3006001e,
184 0xc78,0x3407001e,
185 0xc78,0x3908001e,
186 0xc78,0x3c09001e,
187 0xc78,0x3f0a001e,
188 0xc78,0x420b001e,
189 0xc78,0x440c001e,
190 0xc78,0x450d001e,
191 0xc78,0x460e001e,
192 0xc78,0x460f001e,
193 0xc78,0x4710001e,
194 0xc78,0x4811001e,
195 0xc78,0x4912001e,
196 0xc78,0x4a13001e,
197 0xc78,0x4b14001e,
198 0xc78,0x4b15001e,
199 0xc78,0x4c16001e,
200 0xc78,0x4d17001e,
201 0xc78,0x4e18001e,
202 0xc78,0x4f19001e,
203 0xc78,0x4f1a001e,
204 0xc78,0x501b001e,
205 0xc78,0x511c001e,
206 0xc78,0x521d001e,
207 0xc78,0x521e001e,
208 0xc78,0x531f001e,
209 0xc78,0x5320001e,
210 0xc78,0x5421001e,
211 0xc78,0x5522001e,
212 0xc78,0x5523001e,
213 0xc78,0x5624001e,
214 0xc78,0x5725001e,
215 0xc78,0x5726001e,
216 0xc78,0x5827001e,
217 0xc78,0x5828001e,
218 0xc78,0x5929001e,
219 0xc78,0x592a001e,
220 0xc78,0x5a2b001e,
221 0xc78,0x5b2c001e,
222 0xc78,0x5c2d001e,
223 0xc78,0x5c2e001e,
224 0xc78,0x5d2f001e,
225 0xc78,0x5e30001e,
226 0xc78,0x5f31001e,
227 0xc78,0x6032001e,
228 0xc78,0x6033001e,
229 0xc78,0x6134001e,
230 0xc78,0x6235001e,
231 0xc78,0x6336001e,
232 0xc78,0x6437001e,
233 0xc78,0x6438001e,
234 0xc78,0x6539001e,
235 0xc78,0x663a001e,
236 0xc78,0x673b001e,
237 0xc78,0x673c001e,
238 0xc78,0x683d001e,
239 0xc78,0x693e001e,
240 0xc78,0x6a3f001e,
241 };
242 static u32 Rtl8192PciEPHY_REGArray[PHY_REGArrayLength] = {
243 0x0, };
244 static u32 Rtl8192PciEPHY_REG_1T2RArray[PHY_REG_1T2RArrayLength] = {
245 0x800,0x00000000,
246 0x804,0x00000001,
247 0x808,0x0000fc00,
248 0x80c,0x0000001c,
249 0x810,0x801010aa,
250 0x814,0x008514d0,
251 0x818,0x00000040,
252 0x81c,0x00000000,
253 0x820,0x00000004,
254 0x824,0x00690000,
255 0x828,0x00000004,
256 0x82c,0x00e90000,
257 0x830,0x00000004,
258 0x834,0x00690000,
259 0x838,0x00000004,
260 0x83c,0x00e90000,
261 0x840,0x00000000,
262 0x844,0x00000000,
263 0x848,0x00000000,
264 0x84c,0x00000000,
265 0x850,0x00000000,
266 0x854,0x00000000,
267 0x858,0x65a965a9,
268 0x85c,0x65a965a9,
269 0x860,0x001f0010,
270 0x864,0x007f0010,
271 0x868,0x001f0010,
272 0x86c,0x007f0010,
273 0x870,0x0f100f70,
274 0x874,0x0f100f70,
275 0x878,0x00000000,
276 0x87c,0x00000000,
277 0x880,0x6870e36c,
278 0x884,0xe3573600,
279 0x888,0x4260c340,
280 0x88c,0x0000ff00,
281 0x890,0x00000000,
282 0x894,0xfffffffe,
283 0x898,0x4c42382f,
284 0x89c,0x00656056,
285 0x8b0,0x00000000,
286 0x8e0,0x00000000,
287 0x8e4,0x00000000,
288 0x900,0x00000000,
289 0x904,0x00000023,
290 0x908,0x00000000,
291 0x90c,0x31121311,
292 0xa00,0x00d0c7d8,
293 0xa04,0x811f0008,
294 0xa08,0x80cd8300,
295 0xa0c,0x2e62740f,
296 0xa10,0x95009b78,
297 0xa14,0x11145008,
298 0xa18,0x00881117,
299 0xa1c,0x89140fa0,
300 0xa20,0x1a1b0000,
301 0xa24,0x090e1317,
302 0xa28,0x00000204,
303 0xa2c,0x00000000,
304 0xc00,0x00000040,
305 0xc04,0x00005433,
306 0xc08,0x000000e4,
307 0xc0c,0x6c6c6c6c,
308 0xc10,0x08800000,
309 0xc14,0x40000100,
310 0xc18,0x08000000,
311 0xc1c,0x40000100,
312 0xc20,0x08000000,
313 0xc24,0x40000100,
314 0xc28,0x08000000,
315 0xc2c,0x40000100,
316 0xc30,0x6de9ac44,
317 0xc34,0x465c52cd,
318 0xc38,0x497f5994,
319 0xc3c,0x0a969764,
320 0xc40,0x1f7c403f,
321 0xc44,0x000100b7,
322 0xc48,0xec020000,
323 0xc4c,0x00000300,
324 0xc50,0x69543420,
325 0xc54,0x433c0094,
326 0xc58,0x69543420,
327 0xc5c,0x433c0094,
328 0xc60,0x69543420,
329 0xc64,0x433c0094,
330 0xc68,0x69543420,
331 0xc6c,0x433c0094,
332 0xc70,0x2c7f000d,
333 0xc74,0x0186175b,
334 0xc78,0x0000001f,
335 0xc7c,0x00b91612,
336 0xc80,0x40000100,
337 0xc84,0x20000000,
338 0xc88,0x40000100,
339 0xc8c,0x20200000,
340 0xc90,0x40000100,
341 0xc94,0x00000000,
342 0xc98,0x40000100,
343 0xc9c,0x00000000,
344 0xca0,0x00492492,
345 0xca4,0x00000000,
346 0xca8,0x00000000,
347 0xcac,0x00000000,
348 0xcb0,0x00000000,
349 0xcb4,0x00000000,
350 0xcb8,0x00000000,
351 0xcbc,0x00492492,
352 0xcc0,0x00000000,
353 0xcc4,0x00000000,
354 0xcc8,0x00000000,
355 0xccc,0x00000000,
356 0xcd0,0x00000000,
357 0xcd4,0x00000000,
358 0xcd8,0x64b22427,
359 0xcdc,0x00766932,
360 0xce0,0x00222222,
361 0xd00,0x00000750,
362 0xd04,0x00000403,
363 0xd08,0x0000907f,
364 0xd0c,0x00000001,
365 0xd10,0xa0633333,
366 0xd14,0x33333c63,
367 0xd18,0x6a8f5b6b,
368 0xd1c,0x00000000,
369 0xd20,0x00000000,
370 0xd24,0x00000000,
371 0xd28,0x00000000,
372 0xd2c,0xcc979975,
373 0xd30,0x00000000,
374 0xd34,0x00000000,
375 0xd38,0x00000000,
376 0xd3c,0x00027293,
377 0xd40,0x00000000,
378 0xd44,0x00000000,
379 0xd48,0x00000000,
380 0xd4c,0x00000000,
381 0xd50,0x6437140a,
382 0xd54,0x024dbd02,
383 0xd58,0x00000000,
384 0xd5c,0x04032064,
385 0xe00,0x161a1a1a,
386 0xe04,0x12121416,
387 0xe08,0x00001800,
388 0xe0c,0x00000000,
389 0xe10,0x161a1a1a,
390 0xe14,0x12121416,
391 0xe18,0x161a1a1a,
392 0xe1c,0x12121416,
393 };
394 static u32 Rtl8192PciERadioA_Array[RadioA_ArrayLength] = {
395 0x019,0x00000003,
396 0x000,0x000000bf,
397 0x001,0x00000ee0,
398 0x002,0x0000004c,
399 0x003,0x000007f1,
400 0x004,0x00000975,
401 0x005,0x00000c58,
402 0x006,0x00000ae6,
403 0x007,0x000000ca,
404 0x008,0x00000e1c,
405 0x009,0x000007f0,
406 0x00a,0x000009d0,
407 0x00b,0x000001ba,
408 0x00c,0x00000240,
409 0x00e,0x00000020,
410 0x00f,0x00000990,
411 0x012,0x00000806,
412 0x014,0x000005ab,
413 0x015,0x00000f80,
414 0x016,0x00000020,
415 0x017,0x00000597,
416 0x018,0x0000050a,
417 0x01a,0x00000f80,
418 0x01b,0x00000f5e,
419 0x01c,0x00000008,
420 0x01d,0x00000607,
421 0x01e,0x000006cc,
422 0x01f,0x00000000,
423 0x020,0x000001a5,
424 0x01f,0x00000001,
425 0x020,0x00000165,
426 0x01f,0x00000002,
427 0x020,0x000000c6,
428 0x01f,0x00000003,
429 0x020,0x00000086,
430 0x01f,0x00000004,
431 0x020,0x00000046,
432 0x01f,0x00000005,
433 0x020,0x000001e6,
434 0x01f,0x00000006,
435 0x020,0x000001a6,
436 0x01f,0x00000007,
437 0x020,0x00000166,
438 0x01f,0x00000008,
439 0x020,0x000000c7,
440 0x01f,0x00000009,
441 0x020,0x00000087,
442 0x01f,0x0000000a,
443 0x020,0x000000f7,
444 0x01f,0x0000000b,
445 0x020,0x000000d7,
446 0x01f,0x0000000c,
447 0x020,0x000000b7,
448 0x01f,0x0000000d,
449 0x020,0x00000097,
450 0x01f,0x0000000e,
451 0x020,0x00000077,
452 0x01f,0x0000000f,
453 0x020,0x00000057,
454 0x01f,0x00000010,
455 0x020,0x00000037,
456 0x01f,0x00000011,
457 0x020,0x000000fb,
458 0x01f,0x00000012,
459 0x020,0x000000db,
460 0x01f,0x00000013,
461 0x020,0x000000bb,
462 0x01f,0x00000014,
463 0x020,0x000000ff,
464 0x01f,0x00000015,
465 0x020,0x000000e3,
466 0x01f,0x00000016,
467 0x020,0x000000c3,
468 0x01f,0x00000017,
469 0x020,0x000000a3,
470 0x01f,0x00000018,
471 0x020,0x00000083,
472 0x01f,0x00000019,
473 0x020,0x00000063,
474 0x01f,0x0000001a,
475 0x020,0x00000043,
476 0x01f,0x0000001b,
477 0x020,0x00000023,
478 0x01f,0x0000001c,
479 0x020,0x00000003,
480 0x01f,0x0000001d,
481 0x020,0x000001e3,
482 0x01f,0x0000001e,
483 0x020,0x000001c3,
484 0x01f,0x0000001f,
485 0x020,0x000001a3,
486 0x01f,0x00000020,
487 0x020,0x00000183,
488 0x01f,0x00000021,
489 0x020,0x00000163,
490 0x01f,0x00000022,
491 0x020,0x00000143,
492 0x01f,0x00000023,
493 0x020,0x00000123,
494 0x01f,0x00000024,
495 0x020,0x00000103,
496 0x023,0x00000203,
497 0x024,0x00000100,
498 0x00b,0x000001ba,
499 0x02c,0x000003d7,
500 0x02d,0x00000ff0,
501 0x000,0x00000037,
502 0x004,0x00000160,
503 0x007,0x00000080,
504 0x002,0x0000088d,
505 0x0fe,0x00000000,
506 0x0fe,0x00000000,
507 0x016,0x00000200,
508 0x016,0x00000380,
509 0x016,0x00000020,
510 0x016,0x000001a0,
511 0x000,0x000000bf,
512 0x00d,0x0000001f,
513 0x00d,0x00000c9f,
514 0x002,0x0000004d,
515 0x000,0x00000cbf,
516 0x004,0x00000975,
517 0x007,0x00000700,
518 };
519 static u32 Rtl8192PciERadioB_Array[RadioB_ArrayLength] = {
520 0x019,0x00000003,
521 0x000,0x000000bf,
522 0x001,0x000006e0,
523 0x002,0x0000004c,
524 0x003,0x000007f1,
525 0x004,0x00000975,
526 0x005,0x00000c58,
527 0x006,0x00000ae6,
528 0x007,0x000000ca,
529 0x008,0x00000e1c,
530 0x000,0x000000b7,
531 0x00a,0x00000850,
532 0x000,0x000000bf,
533 0x00b,0x000001ba,
534 0x00c,0x00000240,
535 0x00e,0x00000020,
536 0x015,0x00000f80,
537 0x016,0x00000020,
538 0x017,0x00000597,
539 0x018,0x0000050a,
540 0x01a,0x00000e00,
541 0x01b,0x00000f5e,
542 0x01d,0x00000607,
543 0x01e,0x000006cc,
544 0x00b,0x000001ba,
545 0x023,0x00000203,
546 0x024,0x00000100,
547 0x000,0x00000037,
548 0x004,0x00000160,
549 0x016,0x00000200,
550 0x016,0x00000380,
551 0x016,0x00000020,
552 0x016,0x000001a0,
553 0x00d,0x00000ccc,
554 0x000,0x000000bf,
555 0x002,0x0000004d,
556 0x000,0x00000cbf,
557 0x004,0x00000975,
558 0x007,0x00000700,
559 };
560 static u32 Rtl8192PciERadioC_Array[RadioC_ArrayLength] = {
561 0x0, };
562 static u32 Rtl8192PciERadioD_Array[RadioD_ArrayLength] = {
563 0x0, };
564
565 /*************************Define local function prototype**********************/
566
567 static u32 phy_FwRFSerialRead(struct r8192_priv *priv, RF90_RADIO_PATH_E eRFPath, u32 Offset);
568 static void phy_FwRFSerialWrite(struct r8192_priv *priv, RF90_RADIO_PATH_E eRFPath, u32 Offset, u32 Data);
569
570 /*************************Define local function prototype**********************/
571 /******************************************************************************
572 *function: This function read BB parameters from Header file we gen,
573 * and do register read/write
574 * input: u32 dwBitMask //taget bit pos in the addr to be modified
575 * output: none
576 * return: u32 return the shift bit bit position of the mask
577 * ****************************************************************************/
578 static u32 rtl8192_CalculateBitShift(u32 dwBitMask)
579 {
580 u32 i;
581 for (i=0; i<=31; i++)
582 {
583 if (((dwBitMask>>i)&0x1) == 1)
584 break;
585 }
586 return i;
587 }
588 /******************************************************************************
589 *function: This function check different RF type to execute legal judgement. If RF Path is illegal, we will return false.
590 * input: none
591 * output: none
592 * return: 0(illegal, false), 1(legal,true)
593 * ***************************************************************************/
594 u8 rtl8192_phy_CheckIsLegalRFPath(struct r8192_priv *priv, u32 eRFPath)
595 {
596 u8 ret = 1;
597
598 if (priv->rf_type == RF_2T4R)
599 ret = 0;
600 else if (priv->rf_type == RF_1T2R)
601 {
602 if (eRFPath == RF90_PATH_A || eRFPath == RF90_PATH_B)
603 ret = 1;
604 else if (eRFPath == RF90_PATH_C || eRFPath == RF90_PATH_D)
605 ret = 0;
606 }
607
608 return ret;
609 }
610 /******************************************************************************
611 *function: This function set specific bits to BB register
612 * input: net_device dev
613 * u32 dwRegAddr //target addr to be modified
614 * u32 dwBitMask //taget bit pos in the addr to be modified
615 * u32 dwData //value to be write
616 * output: none
617 * return: none
618 * notice:
619 * ****************************************************************************/
620 void rtl8192_setBBreg(struct r8192_priv *priv, u32 dwRegAddr, u32 dwBitMask, u32 dwData)
621 {
622 u32 OriginalValue, BitShift, NewValue;
623
624 if(dwBitMask!= bMaskDWord)
625 {//if not "double word" write
626 OriginalValue = read_nic_dword(priv, dwRegAddr);
627 BitShift = rtl8192_CalculateBitShift(dwBitMask);
628 NewValue = (((OriginalValue) & (~dwBitMask)) | (dwData << BitShift));
629 write_nic_dword(priv, dwRegAddr, NewValue);
630 }else
631 write_nic_dword(priv, dwRegAddr, dwData);
632 }
633 /******************************************************************************
634 *function: This function reads specific bits from BB register
635 * input: net_device dev
636 * u32 dwRegAddr //target addr to be readback
637 * u32 dwBitMask //taget bit pos in the addr to be readback
638 * output: none
639 * return: u32 Data //the readback register value
640 * notice:
641 * ****************************************************************************/
642 u32 rtl8192_QueryBBReg(struct r8192_priv *priv, u32 dwRegAddr, u32 dwBitMask)
643 {
644 u32 OriginalValue, BitShift;
645
646 OriginalValue = read_nic_dword(priv, dwRegAddr);
647 BitShift = rtl8192_CalculateBitShift(dwBitMask);
648 return (OriginalValue & dwBitMask) >> BitShift;
649 }
650 /******************************************************************************
651 *function: This function read register from RF chip
652 * input: net_device dev
653 * RF90_RADIO_PATH_E eRFPath //radio path of A/B/C/D
654 * u32 Offset //target address to be read
655 * output: none
656 * return: u32 readback value
657 * notice: There are three types of serial operations:(1) Software serial write.(2)Hardware LSSI-Low Speed Serial Interface.(3)Hardware HSSI-High speed serial write. Driver here need to implement (1) and (2)---need more spec for this information.
658 * ****************************************************************************/
659 static u32 rtl8192_phy_RFSerialRead(struct r8192_priv *priv,
660 RF90_RADIO_PATH_E eRFPath, u32 Offset)
661 {
662 u32 ret = 0;
663 u32 NewOffset = 0;
664 BB_REGISTER_DEFINITION_T* pPhyReg = &priv->PHYRegDef[eRFPath];
665 //rtl8192_setBBreg(dev, pPhyReg->rfLSSIReadBack, bLSSIReadBackData, 0);
666 //make sure RF register offset is correct
667 Offset &= 0x3f;
668
669 //switch page for 8256 RF IC
670 //analog to digital off, for protection
671 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter4, 0xf00, 0x0);// 0x88c[11:8]
672 if (Offset >= 31)
673 {
674 priv->RfReg0Value[eRFPath] |= 0x140;
675 //Switch to Reg_Mode2 for Reg 31-45
676 rtl8192_setBBreg(priv, pPhyReg->rf3wireOffset, bMaskDWord, (priv->RfReg0Value[eRFPath]<<16) );
677 //modify offset
678 NewOffset = Offset -30;
679 }
680 else if (Offset >= 16)
681 {
682 priv->RfReg0Value[eRFPath] |= 0x100;
683 priv->RfReg0Value[eRFPath] &= (~0x40);
684 //Switch to Reg_Mode 1 for Reg16-30
685 rtl8192_setBBreg(priv, pPhyReg->rf3wireOffset, bMaskDWord, (priv->RfReg0Value[eRFPath]<<16) );
686
687 NewOffset = Offset - 15;
688 }
689 else
690 NewOffset = Offset;
691
692 //put desired read addr to LSSI control Register
693 rtl8192_setBBreg(priv, pPhyReg->rfHSSIPara2, bLSSIReadAddress, NewOffset);
694 //Issue a posedge trigger
695 //
696 rtl8192_setBBreg(priv, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x0);
697 rtl8192_setBBreg(priv, pPhyReg->rfHSSIPara2, bLSSIReadEdge, 0x1);
698
699
700 // TODO: we should not delay such a long time. Ask help from SD3
701 msleep(1);
702
703 ret = rtl8192_QueryBBReg(priv, pPhyReg->rfLSSIReadBack, bLSSIReadBackData);
704
705
706 // Switch back to Reg_Mode0;
707 priv->RfReg0Value[eRFPath] &= 0xebf;
708
709 rtl8192_setBBreg(
710 priv,
711 pPhyReg->rf3wireOffset,
712 bMaskDWord,
713 (priv->RfReg0Value[eRFPath] << 16));
714
715 //analog to digital on
716 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter4, 0x300, 0x3);// 0x88c[9:8]
717
718 return ret;
719 }
720
721 /******************************************************************************
722 *function: This function write data to RF register
723 * input: net_device dev
724 * RF90_RADIO_PATH_E eRFPath //radio path of A/B/C/D
725 * u32 Offset //target address to be written
726 * u32 Data //The new register data to be written
727 * output: none
728 * return: none
729 * notice: For RF8256 only.
730 ===========================================================
731 *Reg Mode RegCTL[1] RegCTL[0] Note
732 * (Reg00[12]) (Reg00[10])
733 *===========================================================
734 *Reg_Mode0 0 x Reg 0 ~15(0x0 ~ 0xf)
735 *------------------------------------------------------------------
736 *Reg_Mode1 1 0 Reg 16 ~30(0x1 ~ 0xf)
737 *------------------------------------------------------------------
738 * Reg_Mode2 1 1 Reg 31 ~ 45(0x1 ~ 0xf)
739 *------------------------------------------------------------------
740 * ****************************************************************************/
741 static void rtl8192_phy_RFSerialWrite(struct r8192_priv *priv,
742 RF90_RADIO_PATH_E eRFPath, u32 Offset,
743 u32 Data)
744 {
745 u32 DataAndAddr = 0, NewOffset = 0;
746 BB_REGISTER_DEFINITION_T *pPhyReg = &priv->PHYRegDef[eRFPath];
747
748 Offset &= 0x3f;
749
750 //analog to digital off, for protection
751 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter4, 0xf00, 0x0);// 0x88c[11:8]
752
753 if (Offset >= 31)
754 {
755 priv->RfReg0Value[eRFPath] |= 0x140;
756 rtl8192_setBBreg(priv, pPhyReg->rf3wireOffset, bMaskDWord, (priv->RfReg0Value[eRFPath] << 16));
757 NewOffset = Offset - 30;
758 }
759 else if (Offset >= 16)
760 {
761 priv->RfReg0Value[eRFPath] |= 0x100;
762 priv->RfReg0Value[eRFPath] &= (~0x40);
763 rtl8192_setBBreg(priv, pPhyReg->rf3wireOffset, bMaskDWord, (priv->RfReg0Value[eRFPath]<<16));
764 NewOffset = Offset - 15;
765 }
766 else
767 NewOffset = Offset;
768
769 // Put write addr in [5:0] and write data in [31:16]
770 DataAndAddr = (Data<<16) | (NewOffset&0x3f);
771
772 // Write Operation
773 rtl8192_setBBreg(priv, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr);
774
775
776 if(Offset==0x0)
777 priv->RfReg0Value[eRFPath] = Data;
778
779 // Switch back to Reg_Mode0;
780 if(Offset != 0)
781 {
782 priv->RfReg0Value[eRFPath] &= 0xebf;
783 rtl8192_setBBreg(
784 priv,
785 pPhyReg->rf3wireOffset,
786 bMaskDWord,
787 (priv->RfReg0Value[eRFPath] << 16));
788 }
789 //analog to digital on
790 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter4, 0x300, 0x3);// 0x88c[9:8]
791 }
792
793 /******************************************************************************
794 *function: This function set specific bits to RF register
795 * input: RF90_RADIO_PATH_E eRFPath //radio path of A/B/C/D
796 * u32 RegAddr //target addr to be modified
797 * u32 BitMask //taget bit pos in the addr to be modified
798 * u32 Data //value to be write
799 * output: none
800 * return: none
801 * notice:
802 * ****************************************************************************/
803 void rtl8192_phy_SetRFReg(struct r8192_priv *priv, RF90_RADIO_PATH_E eRFPath,
804 u32 RegAddr, u32 BitMask, u32 Data)
805 {
806 u32 Original_Value, BitShift, New_Value;
807 // u8 time = 0;
808
809 if (!rtl8192_phy_CheckIsLegalRFPath(priv, eRFPath))
810 return;
811 if (priv->eRFPowerState != eRfOn && !priv->being_init_adapter)
812 return;
813 //down(&priv->rf_sem);
814
815 RT_TRACE(COMP_PHY, "FW RF CTRL is not ready now\n");
816 if (priv->Rf_Mode == RF_OP_By_FW)
817 {
818 if (BitMask != bMask12Bits) // RF data is 12 bits only
819 {
820 Original_Value = phy_FwRFSerialRead(priv, eRFPath, RegAddr);
821 BitShift = rtl8192_CalculateBitShift(BitMask);
822 New_Value = (((Original_Value) & (~BitMask)) | (Data<< BitShift));
823
824 phy_FwRFSerialWrite(priv, eRFPath, RegAddr, New_Value);
825 }else
826 phy_FwRFSerialWrite(priv, eRFPath, RegAddr, Data);
827 udelay(200);
828
829 }
830 else
831 {
832 if (BitMask != bMask12Bits) // RF data is 12 bits only
833 {
834 Original_Value = rtl8192_phy_RFSerialRead(priv, eRFPath, RegAddr);
835 BitShift = rtl8192_CalculateBitShift(BitMask);
836 New_Value = (((Original_Value) & (~BitMask)) | (Data<< BitShift));
837
838 rtl8192_phy_RFSerialWrite(priv, eRFPath, RegAddr, New_Value);
839 }else
840 rtl8192_phy_RFSerialWrite(priv, eRFPath, RegAddr, Data);
841 }
842 //up(&priv->rf_sem);
843 }
844
845 /******************************************************************************
846 *function: This function reads specific bits from RF register
847 * input: net_device dev
848 * u32 RegAddr //target addr to be readback
849 * u32 BitMask //taget bit pos in the addr to be readback
850 * output: none
851 * return: u32 Data //the readback register value
852 * notice:
853 * ****************************************************************************/
854 u32 rtl8192_phy_QueryRFReg(struct r8192_priv *priv, RF90_RADIO_PATH_E eRFPath,
855 u32 RegAddr, u32 BitMask)
856 {
857 u32 Original_Value, Readback_Value, BitShift;
858
859 if (!rtl8192_phy_CheckIsLegalRFPath(priv, eRFPath))
860 return 0;
861 if (priv->eRFPowerState != eRfOn && !priv->being_init_adapter)
862 return 0;
863 down(&priv->rf_sem);
864 if (priv->Rf_Mode == RF_OP_By_FW)
865 {
866 Original_Value = phy_FwRFSerialRead(priv, eRFPath, RegAddr);
867 udelay(200);
868 }
869 else
870 {
871 Original_Value = rtl8192_phy_RFSerialRead(priv, eRFPath, RegAddr);
872
873 }
874 BitShift = rtl8192_CalculateBitShift(BitMask);
875 Readback_Value = (Original_Value & BitMask) >> BitShift;
876 up(&priv->rf_sem);
877 // udelay(200);
878 return Readback_Value;
879 }
880
881 /******************************************************************************
882 *function: We support firmware to execute RF-R/W.
883 * input: dev
884 * output: none
885 * return: none
886 * notice:
887 * ***************************************************************************/
888 static u32 phy_FwRFSerialRead(struct r8192_priv *priv,
889 RF90_RADIO_PATH_E eRFPath, u32 Offset)
890 {
891 u32 Data = 0;
892 u8 time = 0;
893 //DbgPrint("FW RF CTRL\n\r");
894 /* 2007/11/02 MH Firmware RF Write control. By Francis' suggestion, we can
895 not execute the scheme in the initial step. Otherwise, RF-R/W will waste
896 much time. This is only for site survey. */
897 // 1. Read operation need not insert data. bit 0-11
898 //Data &= bMask12Bits;
899 // 2. Write RF register address. Bit 12-19
900 Data |= ((Offset&0xFF)<<12);
901 // 3. Write RF path. bit 20-21
902 Data |= ((eRFPath&0x3)<<20);
903 // 4. Set RF read indicator. bit 22=0
904 //Data |= 0x00000;
905 // 5. Trigger Fw to operate the command. bit 31
906 Data |= 0x80000000;
907 // 6. We can not execute read operation if bit 31 is 1.
908 while (read_nic_dword(priv, QPNR)&0x80000000)
909 {
910 // If FW can not finish RF-R/W for more than ?? times. We must reset FW.
911 if (time++ < 100)
912 {
913 //DbgPrint("FW not finish RF-R Time=%d\n\r", time);
914 udelay(10);
915 }
916 else
917 break;
918 }
919 // 7. Execute read operation.
920 write_nic_dword(priv, QPNR, Data);
921 // 8. Check if firmawre send back RF content.
922 while (read_nic_dword(priv, QPNR)&0x80000000)
923 {
924 // If FW can not finish RF-R/W for more than ?? times. We must reset FW.
925 if (time++ < 100)
926 {
927 //DbgPrint("FW not finish RF-W Time=%d\n\r", time);
928 udelay(10);
929 }
930 else
931 return 0;
932 }
933 return read_nic_dword(priv, RF_DATA);
934 }
935
936 /******************************************************************************
937 *function: We support firmware to execute RF-R/W.
938 * input: dev
939 * output: none
940 * return: none
941 * notice:
942 * ***************************************************************************/
943 static void phy_FwRFSerialWrite(struct r8192_priv *priv,
944 RF90_RADIO_PATH_E eRFPath, u32 Offset, u32 Data)
945 {
946 u8 time = 0;
947
948 //DbgPrint("N FW RF CTRL RF-%d OF%02x DATA=%03x\n\r", eRFPath, Offset, Data);
949 /* 2007/11/02 MH Firmware RF Write control. By Francis' suggestion, we can
950 not execute the scheme in the initial step. Otherwise, RF-R/W will waste
951 much time. This is only for site survey. */
952
953 // 1. Set driver write bit and 12 bit data. bit 0-11
954 //Data &= bMask12Bits; // Done by uper layer.
955 // 2. Write RF register address. bit 12-19
956 Data |= ((Offset&0xFF)<<12);
957 // 3. Write RF path. bit 20-21
958 Data |= ((eRFPath&0x3)<<20);
959 // 4. Set RF write indicator. bit 22=1
960 Data |= 0x400000;
961 // 5. Trigger Fw to operate the command. bit 31=1
962 Data |= 0x80000000;
963
964 // 6. Write operation. We can not write if bit 31 is 1.
965 while (read_nic_dword(priv, QPNR)&0x80000000)
966 {
967 // If FW can not finish RF-R/W for more than ?? times. We must reset FW.
968 if (time++ < 100)
969 {
970 //DbgPrint("FW not finish RF-W Time=%d\n\r", time);
971 udelay(10);
972 }
973 else
974 break;
975 }
976 // 7. No matter check bit. We always force the write. Because FW will
977 // not accept the command.
978 write_nic_dword(priv, QPNR, Data);
979 /* 2007/11/02 MH Acoording to test, we must delay 20us to wait firmware
980 to finish RF write operation. */
981 /* 2008/01/17 MH We support delay in firmware side now. */
982 //delay_us(20);
983
984 }
985
986
987 /******************************************************************************
988 *function: This function read BB parameters from Header file we gen,
989 * and do register read/write
990 * input: dev
991 * output: none
992 * return: none
993 * notice: BB parameters may change all the time, so please make
994 * sure it has been synced with the newest.
995 * ***************************************************************************/
996 void rtl8192_phy_configmac(struct r8192_priv *priv)
997 {
998 u32 dwArrayLen = 0, i = 0;
999 u32* pdwArray = NULL;
1000 #ifdef TO_DO_LIST
1001 if(Adapter->bInHctTest)
1002 {
1003 RT_TRACE(COMP_PHY, "Rtl819XMACPHY_ArrayDTM\n");
1004 dwArrayLen = MACPHY_ArrayLengthDTM;
1005 pdwArray = Rtl819XMACPHY_ArrayDTM;
1006 }
1007 else if(priv->bTXPowerDataReadFromEEPORM)
1008 #endif
1009 if(priv->bTXPowerDataReadFromEEPORM)
1010 {
1011 RT_TRACE(COMP_PHY, "Rtl819XMACPHY_Array_PG\n");
1012 dwArrayLen = MACPHY_Array_PGLength;
1013 pdwArray = Rtl819XMACPHY_Array_PG;
1014
1015 }
1016 else
1017 {
1018 RT_TRACE(COMP_PHY,"Read rtl819XMACPHY_Array\n");
1019 dwArrayLen = MACPHY_ArrayLength;
1020 pdwArray = Rtl819XMACPHY_Array;
1021 }
1022 for(i = 0; i<dwArrayLen; i=i+3){
1023 RT_TRACE(COMP_DBG, "The Rtl8190MACPHY_Array[0] is %x Rtl8190MACPHY_Array[1] is %x Rtl8190MACPHY_Array[2] is %x\n",
1024 pdwArray[i], pdwArray[i+1], pdwArray[i+2]);
1025 if(pdwArray[i] == 0x318)
1026 {
1027 pdwArray[i+2] = 0x00000800;
1028 //DbgPrint("ptrArray[i], ptrArray[i+1], ptrArray[i+2] = %x, %x, %x\n",
1029 // ptrArray[i], ptrArray[i+1], ptrArray[i+2]);
1030 }
1031 rtl8192_setBBreg(priv, pdwArray[i], pdwArray[i+1], pdwArray[i+2]);
1032 }
1033 }
1034
1035 /******************************************************************************
1036 *function: This function do dirty work
1037 * input: dev
1038 * output: none
1039 * return: none
1040 * notice: BB parameters may change all the time, so please make
1041 * sure it has been synced with the newest.
1042 * ***************************************************************************/
1043
1044 void rtl8192_phyConfigBB(struct r8192_priv *priv, u8 ConfigType)
1045 {
1046 int i;
1047 //u8 ArrayLength;
1048 u32* Rtl819XPHY_REGArray_Table = NULL;
1049 u32* Rtl819XAGCTAB_Array_Table = NULL;
1050 u16 AGCTAB_ArrayLen, PHY_REGArrayLen = 0;
1051 #ifdef TO_DO_LIST
1052 u32 *rtl8192PhyRegArrayTable = NULL, *rtl8192AgcTabArrayTable = NULL;
1053 if(Adapter->bInHctTest)
1054 {
1055 AGCTAB_ArrayLen = AGCTAB_ArrayLengthDTM;
1056 Rtl819XAGCTAB_Array_Table = Rtl819XAGCTAB_ArrayDTM;
1057
1058 if(priv->RF_Type == RF_2T4R)
1059 {
1060 PHY_REGArrayLen = PHY_REGArrayLengthDTM;
1061 Rtl819XPHY_REGArray_Table = Rtl819XPHY_REGArrayDTM;
1062 }
1063 else if (priv->RF_Type == RF_1T2R)
1064 {
1065 PHY_REGArrayLen = PHY_REG_1T2RArrayLengthDTM;
1066 Rtl819XPHY_REGArray_Table = Rtl819XPHY_REG_1T2RArrayDTM;
1067 }
1068 }
1069 else
1070 #endif
1071 {
1072 AGCTAB_ArrayLen = AGCTAB_ArrayLength;
1073 Rtl819XAGCTAB_Array_Table = Rtl819XAGCTAB_Array;
1074 if(priv->rf_type == RF_2T4R)
1075 {
1076 PHY_REGArrayLen = PHY_REGArrayLength;
1077 Rtl819XPHY_REGArray_Table = Rtl819XPHY_REGArray;
1078 }
1079 else if (priv->rf_type == RF_1T2R)
1080 {
1081 PHY_REGArrayLen = PHY_REG_1T2RArrayLength;
1082 Rtl819XPHY_REGArray_Table = Rtl819XPHY_REG_1T2RArray;
1083 }
1084 }
1085
1086 if (ConfigType == BaseBand_Config_PHY_REG)
1087 {
1088 for (i=0; i<PHY_REGArrayLen; i+=2)
1089 {
1090 rtl8192_setBBreg(priv, Rtl819XPHY_REGArray_Table[i], bMaskDWord, Rtl819XPHY_REGArray_Table[i+1]);
1091 RT_TRACE(COMP_DBG, "i: %x, The Rtl819xUsbPHY_REGArray[0] is %x Rtl819xUsbPHY_REGArray[1] is %x\n",i, Rtl819XPHY_REGArray_Table[i], Rtl819XPHY_REGArray_Table[i+1]);
1092 }
1093 }
1094 else if (ConfigType == BaseBand_Config_AGC_TAB)
1095 {
1096 for (i=0; i<AGCTAB_ArrayLen; i+=2)
1097 {
1098 rtl8192_setBBreg(priv, Rtl819XAGCTAB_Array_Table[i], bMaskDWord, Rtl819XAGCTAB_Array_Table[i+1]);
1099 RT_TRACE(COMP_DBG, "i:%x, The rtl819XAGCTAB_Array[0] is %x rtl819XAGCTAB_Array[1] is %x\n",i, Rtl819XAGCTAB_Array_Table[i], Rtl819XAGCTAB_Array_Table[i+1]);
1100 }
1101 }
1102 }
1103 /******************************************************************************
1104 *function: This function initialize Register definition offset for Radio Path
1105 * A/B/C/D
1106 * input: net_device dev
1107 * output: none
1108 * return: none
1109 * notice: Initialization value here is constant and it should never be changed
1110 * ***************************************************************************/
1111 static void rtl8192_InitBBRFRegDef(struct r8192_priv *priv)
1112 {
1113 // RF Interface Sowrtware Control
1114 priv->PHYRegDef[RF90_PATH_A].rfintfs = rFPGA0_XAB_RFInterfaceSW; // 16 LSBs if read 32-bit from 0x870
1115 priv->PHYRegDef[RF90_PATH_B].rfintfs = rFPGA0_XAB_RFInterfaceSW; // 16 MSBs if read 32-bit from 0x870 (16-bit for 0x872)
1116 priv->PHYRegDef[RF90_PATH_C].rfintfs = rFPGA0_XCD_RFInterfaceSW;// 16 LSBs if read 32-bit from 0x874
1117 priv->PHYRegDef[RF90_PATH_D].rfintfs = rFPGA0_XCD_RFInterfaceSW;// 16 MSBs if read 32-bit from 0x874 (16-bit for 0x876)
1118
1119 // RF Interface Readback Value
1120 priv->PHYRegDef[RF90_PATH_A].rfintfi = rFPGA0_XAB_RFInterfaceRB; // 16 LSBs if read 32-bit from 0x8E0
1121 priv->PHYRegDef[RF90_PATH_B].rfintfi = rFPGA0_XAB_RFInterfaceRB;// 16 MSBs if read 32-bit from 0x8E0 (16-bit for 0x8E2)
1122 priv->PHYRegDef[RF90_PATH_C].rfintfi = rFPGA0_XCD_RFInterfaceRB;// 16 LSBs if read 32-bit from 0x8E4
1123 priv->PHYRegDef[RF90_PATH_D].rfintfi = rFPGA0_XCD_RFInterfaceRB;// 16 MSBs if read 32-bit from 0x8E4 (16-bit for 0x8E6)
1124
1125 // RF Interface Output (and Enable)
1126 priv->PHYRegDef[RF90_PATH_A].rfintfo = rFPGA0_XA_RFInterfaceOE; // 16 LSBs if read 32-bit from 0x860
1127 priv->PHYRegDef[RF90_PATH_B].rfintfo = rFPGA0_XB_RFInterfaceOE; // 16 LSBs if read 32-bit from 0x864
1128 priv->PHYRegDef[RF90_PATH_C].rfintfo = rFPGA0_XC_RFInterfaceOE;// 16 LSBs if read 32-bit from 0x868
1129 priv->PHYRegDef[RF90_PATH_D].rfintfo = rFPGA0_XD_RFInterfaceOE;// 16 LSBs if read 32-bit from 0x86C
1130
1131 // RF Interface (Output and) Enable
1132 priv->PHYRegDef[RF90_PATH_A].rfintfe = rFPGA0_XA_RFInterfaceOE; // 16 MSBs if read 32-bit from 0x860 (16-bit for 0x862)
1133 priv->PHYRegDef[RF90_PATH_B].rfintfe = rFPGA0_XB_RFInterfaceOE; // 16 MSBs if read 32-bit from 0x864 (16-bit for 0x866)
1134 priv->PHYRegDef[RF90_PATH_C].rfintfe = rFPGA0_XC_RFInterfaceOE;// 16 MSBs if read 32-bit from 0x86A (16-bit for 0x86A)
1135 priv->PHYRegDef[RF90_PATH_D].rfintfe = rFPGA0_XD_RFInterfaceOE;// 16 MSBs if read 32-bit from 0x86C (16-bit for 0x86E)
1136
1137 //Addr of LSSI. Wirte RF register by driver
1138 priv->PHYRegDef[RF90_PATH_A].rf3wireOffset = rFPGA0_XA_LSSIParameter; //LSSI Parameter
1139 priv->PHYRegDef[RF90_PATH_B].rf3wireOffset = rFPGA0_XB_LSSIParameter;
1140 priv->PHYRegDef[RF90_PATH_C].rf3wireOffset = rFPGA0_XC_LSSIParameter;
1141 priv->PHYRegDef[RF90_PATH_D].rf3wireOffset = rFPGA0_XD_LSSIParameter;
1142
1143 // RF parameter
1144 priv->PHYRegDef[RF90_PATH_A].rfLSSI_Select = rFPGA0_XAB_RFParameter; //BB Band Select
1145 priv->PHYRegDef[RF90_PATH_B].rfLSSI_Select = rFPGA0_XAB_RFParameter;
1146 priv->PHYRegDef[RF90_PATH_C].rfLSSI_Select = rFPGA0_XCD_RFParameter;
1147 priv->PHYRegDef[RF90_PATH_D].rfLSSI_Select = rFPGA0_XCD_RFParameter;
1148
1149 // Tx AGC Gain Stage (same for all path. Should we remove this?)
1150 priv->PHYRegDef[RF90_PATH_A].rfTxGainStage = rFPGA0_TxGainStage; //Tx gain stage
1151 priv->PHYRegDef[RF90_PATH_B].rfTxGainStage = rFPGA0_TxGainStage; //Tx gain stage
1152 priv->PHYRegDef[RF90_PATH_C].rfTxGainStage = rFPGA0_TxGainStage; //Tx gain stage
1153 priv->PHYRegDef[RF90_PATH_D].rfTxGainStage = rFPGA0_TxGainStage; //Tx gain stage
1154
1155 // Tranceiver A~D HSSI Parameter-1
1156 priv->PHYRegDef[RF90_PATH_A].rfHSSIPara1 = rFPGA0_XA_HSSIParameter1; //wire control parameter1
1157 priv->PHYRegDef[RF90_PATH_B].rfHSSIPara1 = rFPGA0_XB_HSSIParameter1; //wire control parameter1
1158 priv->PHYRegDef[RF90_PATH_C].rfHSSIPara1 = rFPGA0_XC_HSSIParameter1; //wire control parameter1
1159 priv->PHYRegDef[RF90_PATH_D].rfHSSIPara1 = rFPGA0_XD_HSSIParameter1; //wire control parameter1
1160
1161 // Tranceiver A~D HSSI Parameter-2
1162 priv->PHYRegDef[RF90_PATH_A].rfHSSIPara2 = rFPGA0_XA_HSSIParameter2; //wire control parameter2
1163 priv->PHYRegDef[RF90_PATH_B].rfHSSIPara2 = rFPGA0_XB_HSSIParameter2; //wire control parameter2
1164 priv->PHYRegDef[RF90_PATH_C].rfHSSIPara2 = rFPGA0_XC_HSSIParameter2; //wire control parameter2
1165 priv->PHYRegDef[RF90_PATH_D].rfHSSIPara2 = rFPGA0_XD_HSSIParameter2; //wire control parameter1
1166
1167 // RF switch Control
1168 priv->PHYRegDef[RF90_PATH_A].rfSwitchControl = rFPGA0_XAB_SwitchControl; //TR/Ant switch control
1169 priv->PHYRegDef[RF90_PATH_B].rfSwitchControl = rFPGA0_XAB_SwitchControl;
1170 priv->PHYRegDef[RF90_PATH_C].rfSwitchControl = rFPGA0_XCD_SwitchControl;
1171 priv->PHYRegDef[RF90_PATH_D].rfSwitchControl = rFPGA0_XCD_SwitchControl;
1172
1173 // AGC control 1
1174 priv->PHYRegDef[RF90_PATH_A].rfAGCControl1 = rOFDM0_XAAGCCore1;
1175 priv->PHYRegDef[RF90_PATH_B].rfAGCControl1 = rOFDM0_XBAGCCore1;
1176 priv->PHYRegDef[RF90_PATH_C].rfAGCControl1 = rOFDM0_XCAGCCore1;
1177 priv->PHYRegDef[RF90_PATH_D].rfAGCControl1 = rOFDM0_XDAGCCore1;
1178
1179 // AGC control 2
1180 priv->PHYRegDef[RF90_PATH_A].rfAGCControl2 = rOFDM0_XAAGCCore2;
1181 priv->PHYRegDef[RF90_PATH_B].rfAGCControl2 = rOFDM0_XBAGCCore2;
1182 priv->PHYRegDef[RF90_PATH_C].rfAGCControl2 = rOFDM0_XCAGCCore2;
1183 priv->PHYRegDef[RF90_PATH_D].rfAGCControl2 = rOFDM0_XDAGCCore2;
1184
1185 // RX AFE control 1
1186 priv->PHYRegDef[RF90_PATH_A].rfRxIQImbalance = rOFDM0_XARxIQImbalance;
1187 priv->PHYRegDef[RF90_PATH_B].rfRxIQImbalance = rOFDM0_XBRxIQImbalance;
1188 priv->PHYRegDef[RF90_PATH_C].rfRxIQImbalance = rOFDM0_XCRxIQImbalance;
1189 priv->PHYRegDef[RF90_PATH_D].rfRxIQImbalance = rOFDM0_XDRxIQImbalance;
1190
1191 // RX AFE control 1
1192 priv->PHYRegDef[RF90_PATH_A].rfRxAFE = rOFDM0_XARxAFE;
1193 priv->PHYRegDef[RF90_PATH_B].rfRxAFE = rOFDM0_XBRxAFE;
1194 priv->PHYRegDef[RF90_PATH_C].rfRxAFE = rOFDM0_XCRxAFE;
1195 priv->PHYRegDef[RF90_PATH_D].rfRxAFE = rOFDM0_XDRxAFE;
1196
1197 // Tx AFE control 1
1198 priv->PHYRegDef[RF90_PATH_A].rfTxIQImbalance = rOFDM0_XATxIQImbalance;
1199 priv->PHYRegDef[RF90_PATH_B].rfTxIQImbalance = rOFDM0_XBTxIQImbalance;
1200 priv->PHYRegDef[RF90_PATH_C].rfTxIQImbalance = rOFDM0_XCTxIQImbalance;
1201 priv->PHYRegDef[RF90_PATH_D].rfTxIQImbalance = rOFDM0_XDTxIQImbalance;
1202
1203 // Tx AFE control 2
1204 priv->PHYRegDef[RF90_PATH_A].rfTxAFE = rOFDM0_XATxAFE;
1205 priv->PHYRegDef[RF90_PATH_B].rfTxAFE = rOFDM0_XBTxAFE;
1206 priv->PHYRegDef[RF90_PATH_C].rfTxAFE = rOFDM0_XCTxAFE;
1207 priv->PHYRegDef[RF90_PATH_D].rfTxAFE = rOFDM0_XDTxAFE;
1208
1209 // Tranceiver LSSI Readback
1210 priv->PHYRegDef[RF90_PATH_A].rfLSSIReadBack = rFPGA0_XA_LSSIReadBack;
1211 priv->PHYRegDef[RF90_PATH_B].rfLSSIReadBack = rFPGA0_XB_LSSIReadBack;
1212 priv->PHYRegDef[RF90_PATH_C].rfLSSIReadBack = rFPGA0_XC_LSSIReadBack;
1213 priv->PHYRegDef[RF90_PATH_D].rfLSSIReadBack = rFPGA0_XD_LSSIReadBack;
1214
1215 }
1216 /******************************************************************************
1217 *function: This function is to write register and then readback to make sure whether BB and RF is OK
1218 * input: net_device dev
1219 * HW90_BLOCK_E CheckBlock
1220 * RF90_RADIO_PATH_E eRFPath //only used when checkblock is HW90_BLOCK_RF
1221 * output: none
1222 * return: return whether BB and RF is ok(0:OK; 1:Fail)
1223 * notice: This function may be removed in the ASIC
1224 * ***************************************************************************/
1225 RT_STATUS rtl8192_phy_checkBBAndRF(struct r8192_priv *priv,
1226 HW90_BLOCK_E CheckBlock,
1227 RF90_RADIO_PATH_E eRFPath)
1228 {
1229 // BB_REGISTER_DEFINITION_T *pPhyReg = &priv->PHYRegDef[eRFPath];
1230 RT_STATUS ret = RT_STATUS_SUCCESS;
1231 u32 i, CheckTimes = 4, dwRegRead = 0;
1232 u32 WriteAddr[4];
1233 u32 WriteData[] = {0xfffff027, 0xaa55a02f, 0x00000027, 0x55aa502f};
1234 // Initialize register address offset to be checked
1235 WriteAddr[HW90_BLOCK_MAC] = 0x100;
1236 WriteAddr[HW90_BLOCK_PHY0] = 0x900;
1237 WriteAddr[HW90_BLOCK_PHY1] = 0x800;
1238 WriteAddr[HW90_BLOCK_RF] = 0x3;
1239 RT_TRACE(COMP_PHY, "=======>%s(), CheckBlock:%d\n", __FUNCTION__, CheckBlock);
1240 for(i=0 ; i < CheckTimes ; i++)
1241 {
1242
1243 //
1244 // Write Data to register and readback
1245 //
1246 switch(CheckBlock)
1247 {
1248 case HW90_BLOCK_MAC:
1249 RT_TRACE(COMP_ERR, "PHY_CheckBBRFOK(): Never Write 0x100 here!\n");
1250 break;
1251
1252 case HW90_BLOCK_PHY0:
1253 case HW90_BLOCK_PHY1:
1254 write_nic_dword(priv, WriteAddr[CheckBlock], WriteData[i]);
1255 dwRegRead = read_nic_dword(priv, WriteAddr[CheckBlock]);
1256 break;
1257
1258 case HW90_BLOCK_RF:
1259 WriteData[i] &= 0xfff;
1260 rtl8192_phy_SetRFReg(priv, eRFPath, WriteAddr[HW90_BLOCK_RF], bMask12Bits, WriteData[i]);
1261 // TODO: we should not delay for such a long time. Ask SD3
1262 mdelay(10);
1263 dwRegRead = rtl8192_phy_QueryRFReg(priv, eRFPath, WriteAddr[HW90_BLOCK_RF], bMaskDWord);
1264 mdelay(10);
1265 break;
1266
1267 default:
1268 ret = RT_STATUS_FAILURE;
1269 break;
1270 }
1271
1272
1273 //
1274 // Check whether readback data is correct
1275 //
1276 if(dwRegRead != WriteData[i])
1277 {
1278 RT_TRACE(COMP_ERR, "====>error=====dwRegRead: %x, WriteData: %x\n", dwRegRead, WriteData[i]);
1279 ret = RT_STATUS_FAILURE;
1280 break;
1281 }
1282 }
1283
1284 return ret;
1285 }
1286
1287
1288 /******************************************************************************
1289 *function: This function initialize BB&RF
1290 * input: net_device dev
1291 * output: none
1292 * return: none
1293 * notice: Initialization value may change all the time, so please make
1294 * sure it has been synced with the newest.
1295 * ***************************************************************************/
1296 static RT_STATUS rtl8192_BB_Config_ParaFile(struct r8192_priv *priv)
1297 {
1298 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
1299
1300 u8 bRegValue = 0, eCheckItem = 0;
1301 u32 dwRegValue = 0;
1302 /**************************************
1303 //<1>Initialize BaseBand
1304 **************************************/
1305
1306 /*--set BB Global Reset--*/
1307 bRegValue = read_nic_byte(priv, BB_GLOBAL_RESET);
1308 write_nic_byte(priv, BB_GLOBAL_RESET,(bRegValue|BB_GLOBAL_RESET_BIT));
1309
1310 /*---set BB reset Active---*/
1311 dwRegValue = read_nic_dword(priv, CPU_GEN);
1312 write_nic_dword(priv, CPU_GEN, (dwRegValue&(~CPU_GEN_BB_RST)));
1313
1314 /*----Ckeck FPGAPHY0 and PHY1 board is OK----*/
1315 // TODO: this function should be removed on ASIC , Emily 2007.2.2
1316 for(eCheckItem=(HW90_BLOCK_E)HW90_BLOCK_PHY0; eCheckItem<=HW90_BLOCK_PHY1; eCheckItem++)
1317 {
1318 rtStatus = rtl8192_phy_checkBBAndRF(priv, (HW90_BLOCK_E)eCheckItem, (RF90_RADIO_PATH_E)0); //don't care RF path
1319 if(rtStatus != RT_STATUS_SUCCESS)
1320 {
1321 RT_TRACE((COMP_ERR | COMP_PHY), "PHY_RF8256_Config():Check PHY%d Fail!!\n", eCheckItem-1);
1322 return rtStatus;
1323 }
1324 }
1325 /*---- Set CCK and OFDM Block "OFF"----*/
1326 rtl8192_setBBreg(priv, rFPGA0_RFMOD, bCCKEn|bOFDMEn, 0x0);
1327 /*----BB Register Initilazation----*/
1328 //==m==>Set PHY REG From Header<==m==
1329 rtl8192_phyConfigBB(priv, BaseBand_Config_PHY_REG);
1330
1331 /*----Set BB reset de-Active----*/
1332 dwRegValue = read_nic_dword(priv, CPU_GEN);
1333 write_nic_dword(priv, CPU_GEN, (dwRegValue|CPU_GEN_BB_RST));
1334
1335 /*----BB AGC table Initialization----*/
1336 //==m==>Set PHY REG From Header<==m==
1337 rtl8192_phyConfigBB(priv, BaseBand_Config_AGC_TAB);
1338
1339 if (priv->card_8192_version > VERSION_8190_BD)
1340 {
1341 if(priv->rf_type == RF_2T4R)
1342 {
1343 // Antenna gain offset from B/C/D to A
1344 dwRegValue = ( priv->AntennaTxPwDiff[2]<<8 |
1345 priv->AntennaTxPwDiff[1]<<4 |
1346 priv->AntennaTxPwDiff[0]);
1347 }
1348 else
1349 dwRegValue = 0x0; //Antenna gain offset doesn't make sense in RF 1T2R.
1350 rtl8192_setBBreg(priv, rFPGA0_TxGainStage,
1351 (bXBTxAGC|bXCTxAGC|bXDTxAGC), dwRegValue);
1352
1353
1354 //XSTALLCap
1355 dwRegValue = priv->CrystalCap;
1356 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter1, bXtalCap92x, dwRegValue);
1357 }
1358
1359 // Check if the CCK HighPower is turned ON.
1360 // This is used to calculate PWDB.
1361 // priv->bCckHighPower = (u8)(rtl8192_QueryBBReg(dev, rFPGA0_XA_HSSIParameter2, 0x200));
1362 return rtStatus;
1363 }
1364 /******************************************************************************
1365 *function: This function initialize BB&RF
1366 * input: net_device dev
1367 * output: none
1368 * return: none
1369 * notice: Initialization value may change all the time, so please make
1370 * sure it has been synced with the newest.
1371 * ***************************************************************************/
1372 RT_STATUS rtl8192_BBConfig(struct r8192_priv *priv)
1373 {
1374 rtl8192_InitBBRFRegDef(priv);
1375 //config BB&RF. As hardCode based initialization has not been well
1376 //implemented, so use file first.FIXME:should implement it for hardcode?
1377 return rtl8192_BB_Config_ParaFile(priv);
1378 }
1379
1380 /******************************************************************************
1381 *function: This function obtains the initialization value of Tx power Level offset
1382 * input: net_device dev
1383 * output: none
1384 * return: none
1385 * ***************************************************************************/
1386 void rtl8192_phy_getTxPower(struct r8192_priv *priv)
1387 {
1388 priv->MCSTxPowerLevelOriginalOffset[0] =
1389 read_nic_dword(priv, rTxAGC_Rate18_06);
1390 priv->MCSTxPowerLevelOriginalOffset[1] =
1391 read_nic_dword(priv, rTxAGC_Rate54_24);
1392 priv->MCSTxPowerLevelOriginalOffset[2] =
1393 read_nic_dword(priv, rTxAGC_Mcs03_Mcs00);
1394 priv->MCSTxPowerLevelOriginalOffset[3] =
1395 read_nic_dword(priv, rTxAGC_Mcs07_Mcs04);
1396 priv->MCSTxPowerLevelOriginalOffset[4] =
1397 read_nic_dword(priv, rTxAGC_Mcs11_Mcs08);
1398 priv->MCSTxPowerLevelOriginalOffset[5] =
1399 read_nic_dword(priv, rTxAGC_Mcs15_Mcs12);
1400
1401 // read rx initial gain
1402 priv->DefaultInitialGain[0] = read_nic_byte(priv, rOFDM0_XAAGCCore1);
1403 priv->DefaultInitialGain[1] = read_nic_byte(priv, rOFDM0_XBAGCCore1);
1404 priv->DefaultInitialGain[2] = read_nic_byte(priv, rOFDM0_XCAGCCore1);
1405 priv->DefaultInitialGain[3] = read_nic_byte(priv, rOFDM0_XDAGCCore1);
1406 RT_TRACE(COMP_INIT, "Default initial gain (c50=0x%x, c58=0x%x, c60=0x%x, c68=0x%x)\n",
1407 priv->DefaultInitialGain[0], priv->DefaultInitialGain[1],
1408 priv->DefaultInitialGain[2], priv->DefaultInitialGain[3]);
1409
1410 // read framesync
1411 priv->framesync = read_nic_byte(priv, rOFDM0_RxDetector3);
1412 priv->framesyncC34 = read_nic_dword(priv, rOFDM0_RxDetector2);
1413 RT_TRACE(COMP_INIT, "Default framesync (0x%x) = 0x%x\n",
1414 rOFDM0_RxDetector3, priv->framesync);
1415 // read SIFS (save the value read fome MACPHY_REG.txt)
1416 priv->SifsTime = read_nic_word(priv, SIFS);
1417 }
1418
1419 /******************************************************************************
1420 *function: This function obtains the initialization value of Tx power Level offset
1421 * input: net_device dev
1422 * output: none
1423 * return: none
1424 * ***************************************************************************/
1425 void rtl8192_phy_setTxPower(struct r8192_priv *priv, u8 channel)
1426 {
1427 u8 powerlevel = 0,powerlevelOFDM24G = 0;
1428 char ant_pwr_diff;
1429 u32 u4RegValue;
1430
1431 if(priv->epromtype == EPROM_93c46)
1432 {
1433 powerlevel = priv->TxPowerLevelCCK[channel-1];
1434 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1];
1435 }
1436 else if(priv->epromtype == EPROM_93c56)
1437 {
1438 if(priv->rf_type == RF_1T2R)
1439 {
1440 powerlevel = priv->TxPowerLevelCCK_C[channel-1];
1441 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_C[channel-1];
1442 }
1443 else if(priv->rf_type == RF_2T4R)
1444 {
1445 // Mainly we use RF-A Tx Power to write the Tx Power registers, but the RF-C Tx
1446 // Power must be calculated by the antenna diff.
1447 // So we have to rewrite Antenna gain offset register here.
1448 powerlevel = priv->TxPowerLevelCCK_A[channel-1];
1449 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G_A[channel-1];
1450
1451 ant_pwr_diff = priv->TxPowerLevelOFDM24G_C[channel-1]
1452 -priv->TxPowerLevelOFDM24G_A[channel-1];
1453 ant_pwr_diff &= 0xf;
1454
1455 priv->AntennaTxPwDiff[2] = 0;// RF-D, don't care
1456 priv->AntennaTxPwDiff[1] = (u8)(ant_pwr_diff);// RF-C
1457 priv->AntennaTxPwDiff[0] = 0;// RF-B, don't care
1458
1459 // Antenna gain offset from B/C/D to A
1460 u4RegValue = ( priv->AntennaTxPwDiff[2]<<8 |
1461 priv->AntennaTxPwDiff[1]<<4 |
1462 priv->AntennaTxPwDiff[0]);
1463
1464 rtl8192_setBBreg(priv, rFPGA0_TxGainStage,
1465 (bXBTxAGC|bXCTxAGC|bXDTxAGC), u4RegValue);
1466 }
1467 }
1468 #ifdef TODO
1469 //
1470 // CCX 2 S31, AP control of client transmit power:
1471 // 1. We shall not exceed Cell Power Limit as possible as we can.
1472 // 2. Tolerance is +/- 5dB.
1473 // 3. 802.11h Power Contraint takes higher precedence over CCX Cell Power Limit.
1474 //
1475 // TODO:
1476 // 1. 802.11h power contraint
1477 //
1478 // 071011, by rcnjko.
1479 //
1480 if( pMgntInfo->OpMode == RT_OP_MODE_INFRASTRUCTURE &&
1481 pMgntInfo->bWithCcxCellPwr &&
1482 channel == pMgntInfo->dot11CurrentChannelNumber)
1483 {
1484 u8 CckCellPwrIdx = DbmToTxPwrIdx(Adapter, WIRELESS_MODE_B, pMgntInfo->CcxCellPwr);
1485 u8 LegacyOfdmCellPwrIdx = DbmToTxPwrIdx(Adapter, WIRELESS_MODE_G, pMgntInfo->CcxCellPwr);
1486 u8 OfdmCellPwrIdx = DbmToTxPwrIdx(Adapter, WIRELESS_MODE_N_24G, pMgntInfo->CcxCellPwr);
1487
1488 RT_TRACE(COMP_TXAGC, DBG_LOUD,
1489 ("CCX Cell Limit: %d dbm => CCK Tx power index : %d, Legacy OFDM Tx power index : %d, OFDM Tx power index: %d\n",
1490 pMgntInfo->CcxCellPwr, CckCellPwrIdx, LegacyOfdmCellPwrIdx, OfdmCellPwrIdx));
1491 RT_TRACE(COMP_TXAGC, DBG_LOUD,
1492 ("EEPROM channel(%d) => CCK Tx power index: %d, Legacy OFDM Tx power index : %d, OFDM Tx power index: %d\n",
1493 channel, powerlevel, powerlevelOFDM24G + pHalData->LegacyHTTxPowerDiff, powerlevelOFDM24G));
1494
1495 // CCK
1496 if(powerlevel > CckCellPwrIdx)
1497 powerlevel = CckCellPwrIdx;
1498 // Legacy OFDM, HT OFDM
1499 if(powerlevelOFDM24G + pHalData->LegacyHTTxPowerDiff > OfdmCellPwrIdx)
1500 {
1501 if((OfdmCellPwrIdx - pHalData->LegacyHTTxPowerDiff) > 0)
1502 {
1503 powerlevelOFDM24G = OfdmCellPwrIdx - pHalData->LegacyHTTxPowerDiff;
1504 }
1505 else
1506 {
1507 LegacyOfdmCellPwrIdx = 0;
1508 }
1509 }
1510
1511 RT_TRACE(COMP_TXAGC, DBG_LOUD,
1512 ("Altered CCK Tx power index : %d, Legacy OFDM Tx power index: %d, OFDM Tx power index: %d\n",
1513 powerlevel, powerlevelOFDM24G + pHalData->LegacyHTTxPowerDiff, powerlevelOFDM24G));
1514 }
1515
1516 pHalData->CurrentCckTxPwrIdx = powerlevel;
1517 pHalData->CurrentOfdm24GTxPwrIdx = powerlevelOFDM24G;
1518 #endif
1519 PHY_SetRF8256CCKTxPower(priv, powerlevel); //need further implement
1520 PHY_SetRF8256OFDMTxPower(priv, powerlevelOFDM24G);
1521 }
1522
1523 /******************************************************************************
1524 *function: This function check Rf chip to do RF config
1525 * input: net_device dev
1526 * output: none
1527 * return: only 8256 is supported
1528 * ***************************************************************************/
1529 RT_STATUS rtl8192_phy_RFConfig(struct r8192_priv *priv)
1530 {
1531 return PHY_RF8256_Config(priv);
1532 }
1533
1534 /******************************************************************************
1535 *function: This function update Initial gain
1536 * input: net_device dev
1537 * output: none
1538 * return: As Windows has not implemented this, wait for complement
1539 * ***************************************************************************/
1540 void rtl8192_phy_updateInitGain(struct r8192_priv *priv)
1541 {
1542 }
1543
1544 /******************************************************************************
1545 *function: This function read RF parameters from general head file, and do RF 3-wire
1546 * input: net_device dev
1547 * output: none
1548 * return: return code show if RF configuration is successful(0:pass, 1:fail)
1549 * Note: Delay may be required for RF configuration
1550 * ***************************************************************************/
1551 u8 rtl8192_phy_ConfigRFWithHeaderFile(struct r8192_priv *priv,
1552 RF90_RADIO_PATH_E eRFPath)
1553 {
1554
1555 int i;
1556 //u32* pRFArray;
1557 u8 ret = 0;
1558
1559 switch(eRFPath){
1560 case RF90_PATH_A:
1561 for(i = 0;i<RadioA_ArrayLength; i=i+2){
1562
1563 if(Rtl819XRadioA_Array[i] == 0xfe){
1564 msleep(100);
1565 continue;
1566 }
1567 rtl8192_phy_SetRFReg(priv, eRFPath, Rtl819XRadioA_Array[i], bMask12Bits, Rtl819XRadioA_Array[i+1]);
1568 //msleep(1);
1569
1570 }
1571 break;
1572 case RF90_PATH_B:
1573 for(i = 0;i<RadioB_ArrayLength; i=i+2){
1574
1575 if(Rtl819XRadioB_Array[i] == 0xfe){
1576 msleep(100);
1577 continue;
1578 }
1579 rtl8192_phy_SetRFReg(priv, eRFPath, Rtl819XRadioB_Array[i], bMask12Bits, Rtl819XRadioB_Array[i+1]);
1580 //msleep(1);
1581
1582 }
1583 break;
1584 case RF90_PATH_C:
1585 for(i = 0;i<RadioC_ArrayLength; i=i+2){
1586
1587 if(Rtl819XRadioC_Array[i] == 0xfe){
1588 msleep(100);
1589 continue;
1590 }
1591 rtl8192_phy_SetRFReg(priv, eRFPath, Rtl819XRadioC_Array[i], bMask12Bits, Rtl819XRadioC_Array[i+1]);
1592 //msleep(1);
1593
1594 }
1595 break;
1596 case RF90_PATH_D:
1597 for(i = 0;i<RadioD_ArrayLength; i=i+2){
1598
1599 if(Rtl819XRadioD_Array[i] == 0xfe){
1600 msleep(100);
1601 continue;
1602 }
1603 rtl8192_phy_SetRFReg(priv, eRFPath, Rtl819XRadioD_Array[i], bMask12Bits, Rtl819XRadioD_Array[i+1]);
1604 //msleep(1);
1605
1606 }
1607 break;
1608 default:
1609 break;
1610 }
1611
1612 return ret;
1613
1614 }
1615 /******************************************************************************
1616 *function: This function set Tx Power of the channel
1617 * input: struct net_device *dev
1618 * u8 channel
1619 * output: none
1620 * return: none
1621 * Note:
1622 * ***************************************************************************/
1623 static void rtl8192_SetTxPowerLevel(struct r8192_priv *priv, u8 channel)
1624 {
1625 u8 powerlevel = priv->TxPowerLevelCCK[channel-1];
1626 u8 powerlevelOFDM24G = priv->TxPowerLevelOFDM24G[channel-1];
1627
1628 PHY_SetRF8256CCKTxPower(priv, powerlevel);
1629 PHY_SetRF8256OFDMTxPower(priv, powerlevelOFDM24G);
1630 }
1631
1632 /****************************************************************************************
1633 *function: This function set command table variable(struct SwChnlCmd).
1634 * input: SwChnlCmd* CmdTable //table to be set.
1635 * u32 CmdTableIdx //variable index in table to be set
1636 * u32 CmdTableSz //table size.
1637 * SwChnlCmdID CmdID //command ID to set.
1638 * u32 Para1
1639 * u32 Para2
1640 * u32 msDelay
1641 * output:
1642 * return: true if finished, false otherwise
1643 * Note:
1644 * ************************************************************************************/
1645 static u8 rtl8192_phy_SetSwChnlCmdArray(
1646 SwChnlCmd* CmdTable,
1647 u32 CmdTableIdx,
1648 u32 CmdTableSz,
1649 SwChnlCmdID CmdID,
1650 u32 Para1,
1651 u32 Para2,
1652 u32 msDelay
1653 )
1654 {
1655 SwChnlCmd* pCmd;
1656
1657 if(CmdTable == NULL)
1658 {
1659 RT_TRACE(COMP_ERR, "phy_SetSwChnlCmdArray(): CmdTable cannot be NULL.\n");
1660 return false;
1661 }
1662 if(CmdTableIdx >= CmdTableSz)
1663 {
1664 RT_TRACE(COMP_ERR, "phy_SetSwChnlCmdArray(): Access invalid index, please check size of the table, CmdTableIdx:%d, CmdTableSz:%d\n",
1665 CmdTableIdx, CmdTableSz);
1666 return false;
1667 }
1668
1669 pCmd = CmdTable + CmdTableIdx;
1670 pCmd->CmdID = CmdID;
1671 pCmd->Para1 = Para1;
1672 pCmd->Para2 = Para2;
1673 pCmd->msDelay = msDelay;
1674
1675 return true;
1676 }
1677 /******************************************************************************
1678 *function: This function set channel step by step
1679 * input: struct net_device *dev
1680 * u8 channel
1681 * u8* stage //3 stages
1682 * u8* step //
1683 * u32* delay //whether need to delay
1684 * output: store new stage, step and delay for next step(combine with function above)
1685 * return: true if finished, false otherwise
1686 * Note: Wait for simpler function to replace it //wb
1687 * ***************************************************************************/
1688 static u8 rtl8192_phy_SwChnlStepByStep(struct r8192_priv *priv, u8 channel,
1689 u8* stage, u8* step, u32* delay)
1690 {
1691 // PCHANNEL_ACCESS_SETTING pChnlAccessSetting;
1692 SwChnlCmd PreCommonCmd[MAX_PRECMD_CNT];
1693 u32 PreCommonCmdCnt;
1694 SwChnlCmd PostCommonCmd[MAX_POSTCMD_CNT];
1695 u32 PostCommonCmdCnt;
1696 SwChnlCmd RfDependCmd[MAX_RFDEPENDCMD_CNT];
1697 u32 RfDependCmdCnt;
1698 SwChnlCmd *CurrentCmd = NULL;
1699 //RF90_RADIO_PATH_E eRFPath;
1700 u8 eRFPath;
1701 // u32 RfRetVal;
1702 // u8 RetryCnt;
1703
1704 RT_TRACE(COMP_TRACE, "====>%s()====stage:%d, step:%d, channel:%d\n", __FUNCTION__, *stage, *step, channel);
1705 // RT_ASSERT(IsLegalChannel(Adapter, channel), ("illegal channel: %d\n", channel));
1706
1707 #ifdef ENABLE_DOT11D
1708 if (!IsLegalChannel(priv->ieee80211, channel))
1709 {
1710 RT_TRACE(COMP_ERR, "=============>set to illegal channel:%d\n", channel);
1711 return true; //return true to tell upper caller function this channel setting is finished! Or it will in while loop.
1712 }
1713 #endif
1714
1715 //for(eRFPath = RF90_PATH_A; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
1716 //for(eRFPath = 0; eRFPath <RF90_PATH_MAX; eRFPath++)
1717 {
1718 //if (!rtl8192_phy_CheckIsLegalRFPath(dev, eRFPath))
1719 // return false;
1720 // <1> Fill up pre common command.
1721 PreCommonCmdCnt = 0;
1722 rtl8192_phy_SetSwChnlCmdArray(PreCommonCmd, PreCommonCmdCnt++, MAX_PRECMD_CNT,
1723 CmdID_SetTxPowerLevel, 0, 0, 0);
1724 rtl8192_phy_SetSwChnlCmdArray(PreCommonCmd, PreCommonCmdCnt++, MAX_PRECMD_CNT,
1725 CmdID_End, 0, 0, 0);
1726
1727 // <2> Fill up post common command.
1728 PostCommonCmdCnt = 0;
1729
1730 rtl8192_phy_SetSwChnlCmdArray(PostCommonCmd, PostCommonCmdCnt++, MAX_POSTCMD_CNT,
1731 CmdID_End, 0, 0, 0);
1732
1733 // <3> Fill up RF dependent command.
1734 RfDependCmdCnt = 0;
1735
1736 // TEST!! This is not the table for 8256!!
1737 if (!(channel >= 1 && channel <= 14))
1738 {
1739 RT_TRACE(COMP_ERR, "illegal channel for Zebra 8256: %d\n", channel);
1740 return false;
1741 }
1742 rtl8192_phy_SetSwChnlCmdArray(RfDependCmd, RfDependCmdCnt++, MAX_RFDEPENDCMD_CNT,
1743 CmdID_RF_WriteReg, rZebra1_Channel, channel, 10);
1744 rtl8192_phy_SetSwChnlCmdArray(RfDependCmd, RfDependCmdCnt++, MAX_RFDEPENDCMD_CNT,
1745 CmdID_End, 0, 0, 0);
1746
1747 do{
1748 switch(*stage)
1749 {
1750 case 0:
1751 CurrentCmd=&PreCommonCmd[*step];
1752 break;
1753 case 1:
1754 CurrentCmd=&RfDependCmd[*step];
1755 break;
1756 case 2:
1757 CurrentCmd=&PostCommonCmd[*step];
1758 break;
1759 }
1760
1761 if(CurrentCmd->CmdID==CmdID_End)
1762 {
1763 if((*stage)==2)
1764 {
1765 return true;
1766 }
1767 else
1768 {
1769 (*stage)++;
1770 (*step)=0;
1771 continue;
1772 }
1773 }
1774
1775 switch(CurrentCmd->CmdID)
1776 {
1777 case CmdID_SetTxPowerLevel:
1778 if(priv->card_8192_version > (u8)VERSION_8190_BD) //xiong: consider it later!
1779 rtl8192_SetTxPowerLevel(priv, channel);
1780 break;
1781 case CmdID_WritePortUlong:
1782 write_nic_dword(priv, CurrentCmd->Para1, CurrentCmd->Para2);
1783 break;
1784 case CmdID_WritePortUshort:
1785 write_nic_word(priv, CurrentCmd->Para1, (u16)CurrentCmd->Para2);
1786 break;
1787 case CmdID_WritePortUchar:
1788 write_nic_byte(priv, CurrentCmd->Para1, (u8)CurrentCmd->Para2);
1789 break;
1790 case CmdID_RF_WriteReg:
1791 for(eRFPath = 0; eRFPath <priv->NumTotalRFPath; eRFPath++)
1792 rtl8192_phy_SetRFReg(priv, (RF90_RADIO_PATH_E)eRFPath, CurrentCmd->Para1, bMask12Bits, CurrentCmd->Para2<<7);
1793 break;
1794 default:
1795 break;
1796 }
1797
1798 break;
1799 }while(true);
1800 }/*for(Number of RF paths)*/
1801
1802 (*delay)=CurrentCmd->msDelay;
1803 (*step)++;
1804 return false;
1805 }
1806
1807 /******************************************************************************
1808 *function: This function does acturally set channel work
1809 * input: struct net_device *dev
1810 * u8 channel
1811 * output: none
1812 * return: noin
1813 * Note: We should not call this function directly
1814 * ***************************************************************************/
1815 static void rtl8192_phy_FinishSwChnlNow(struct r8192_priv *priv, u8 channel)
1816 {
1817 u32 delay = 0;
1818
1819 while (!rtl8192_phy_SwChnlStepByStep(priv, channel, &priv->SwChnlStage, &priv->SwChnlStep, &delay))
1820 {
1821 if(delay>0)
1822 msleep(delay);//or mdelay? need further consideration
1823 if(!priv->up)
1824 break;
1825 }
1826 }
1827 /******************************************************************************
1828 *function: Callback routine of the work item for switch channel.
1829 * input:
1830 *
1831 * output: none
1832 * return: noin
1833 * ***************************************************************************/
1834 void rtl8192_SwChnl_WorkItem(struct r8192_priv *priv)
1835 {
1836 RT_TRACE(COMP_TRACE, "==> SwChnlCallback819xUsbWorkItem()\n");
1837
1838 RT_TRACE(COMP_TRACE, "=====>--%s(), set chan:%d, priv:%p\n", __FUNCTION__, priv->chan, priv);
1839
1840 rtl8192_phy_FinishSwChnlNow(priv, priv->chan);
1841
1842 RT_TRACE(COMP_TRACE, "<== SwChnlCallback819xUsbWorkItem()\n");
1843 }
1844
1845 /******************************************************************************
1846 *function: This function scheduled actural workitem to set channel
1847 * input: net_device dev
1848 * u8 channel //channel to set
1849 * output: none
1850 * return: return code show if workitem is scheduled(1:pass, 0:fail)
1851 * Note: Delay may be required for RF configuration
1852 * ***************************************************************************/
1853 u8 rtl8192_phy_SwChnl(struct ieee80211_device *ieee80211, u8 channel)
1854 {
1855 struct r8192_priv *priv = ieee80211_priv(ieee80211->dev);
1856
1857 RT_TRACE(COMP_PHY, "=====>%s()\n", __FUNCTION__);
1858 if(!priv->up)
1859 return false;
1860 if(priv->SwChnlInProgress)
1861 return false;
1862
1863 // if(pHalData->SetBWModeInProgress)
1864 // return;
1865
1866 //--------------------------------------------
1867 switch(priv->ieee80211->mode)
1868 {
1869 case WIRELESS_MODE_A:
1870 case WIRELESS_MODE_N_5G:
1871 if (channel<=14){
1872 RT_TRACE(COMP_ERR, "WIRELESS_MODE_A but channel<=14\n");
1873 return false;
1874 }
1875 break;
1876 case WIRELESS_MODE_B:
1877 if (channel>14){
1878 RT_TRACE(COMP_ERR, "WIRELESS_MODE_B but channel>14\n");
1879 return false;
1880 }
1881 break;
1882 case WIRELESS_MODE_G:
1883 case WIRELESS_MODE_N_24G:
1884 if (channel>14){
1885 RT_TRACE(COMP_ERR, "WIRELESS_MODE_G but channel>14\n");
1886 return false;
1887 }
1888 break;
1889 }
1890 //--------------------------------------------
1891
1892 priv->SwChnlInProgress = true;
1893 if(channel == 0)
1894 channel = 1;
1895
1896 priv->chan=channel;
1897
1898 priv->SwChnlStage=0;
1899 priv->SwChnlStep=0;
1900 if (priv->up)
1901 rtl8192_SwChnl_WorkItem(priv);
1902
1903 priv->SwChnlInProgress = false;
1904 return true;
1905 }
1906
1907 static void CCK_Tx_Power_Track_BW_Switch_TSSI(struct r8192_priv *priv)
1908 {
1909 switch(priv->CurrentChannelBW)
1910 {
1911 /* 20 MHz channel*/
1912 case HT_CHANNEL_WIDTH_20:
1913 //added by vivi, cck,tx power track, 20080703
1914 priv->CCKPresentAttentuation =
1915 priv->CCKPresentAttentuation_20Mdefault + priv->CCKPresentAttentuation_difference;
1916
1917 if(priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
1918 priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
1919 if(priv->CCKPresentAttentuation < 0)
1920 priv->CCKPresentAttentuation = 0;
1921
1922 RT_TRACE(COMP_POWER_TRACKING, "20M, priv->CCKPresentAttentuation = %d\n", priv->CCKPresentAttentuation);
1923
1924 if(priv->ieee80211->current_network.channel== 14 && !priv->bcck_in_ch14)
1925 {
1926 priv->bcck_in_ch14 = TRUE;
1927 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1928 }
1929 else if(priv->ieee80211->current_network.channel != 14 && priv->bcck_in_ch14)
1930 {
1931 priv->bcck_in_ch14 = FALSE;
1932 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1933 }
1934 else
1935 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1936 break;
1937
1938 /* 40 MHz channel*/
1939 case HT_CHANNEL_WIDTH_20_40:
1940 //added by vivi, cck,tx power track, 20080703
1941 priv->CCKPresentAttentuation =
1942 priv->CCKPresentAttentuation_40Mdefault + priv->CCKPresentAttentuation_difference;
1943
1944 RT_TRACE(COMP_POWER_TRACKING, "40M, priv->CCKPresentAttentuation = %d\n", priv->CCKPresentAttentuation);
1945 if(priv->CCKPresentAttentuation > (CCKTxBBGainTableLength-1))
1946 priv->CCKPresentAttentuation = CCKTxBBGainTableLength-1;
1947 if(priv->CCKPresentAttentuation < 0)
1948 priv->CCKPresentAttentuation = 0;
1949
1950 if(priv->ieee80211->current_network.channel == 14 && !priv->bcck_in_ch14)
1951 {
1952 priv->bcck_in_ch14 = TRUE;
1953 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1954 }
1955 else if(priv->ieee80211->current_network.channel != 14 && priv->bcck_in_ch14)
1956 {
1957 priv->bcck_in_ch14 = FALSE;
1958 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1959 }
1960 else
1961 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1962 break;
1963 }
1964 }
1965
1966 static void CCK_Tx_Power_Track_BW_Switch_ThermalMeter(struct r8192_priv *priv)
1967 {
1968 if(priv->ieee80211->current_network.channel == 14 && !priv->bcck_in_ch14)
1969 priv->bcck_in_ch14 = TRUE;
1970 else if(priv->ieee80211->current_network.channel != 14 && priv->bcck_in_ch14)
1971 priv->bcck_in_ch14 = FALSE;
1972
1973 //write to default index and tx power track will be done in dm.
1974 switch(priv->CurrentChannelBW)
1975 {
1976 /* 20 MHz channel*/
1977 case HT_CHANNEL_WIDTH_20:
1978 if(priv->Record_CCK_20Mindex == 0)
1979 priv->Record_CCK_20Mindex = 6; //set default value.
1980 priv->CCK_index = priv->Record_CCK_20Mindex;//6;
1981 RT_TRACE(COMP_POWER_TRACKING, "20MHz, CCK_Tx_Power_Track_BW_Switch_ThermalMeter(),CCK_index = %d\n", priv->CCK_index);
1982 break;
1983
1984 /* 40 MHz channel*/
1985 case HT_CHANNEL_WIDTH_20_40:
1986 priv->CCK_index = priv->Record_CCK_40Mindex;//0;
1987 RT_TRACE(COMP_POWER_TRACKING, "40MHz, CCK_Tx_Power_Track_BW_Switch_ThermalMeter(), CCK_index = %d\n", priv->CCK_index);
1988 break;
1989 }
1990 dm_cck_txpower_adjust(priv, priv->bcck_in_ch14);
1991 }
1992
1993 static void CCK_Tx_Power_Track_BW_Switch(struct r8192_priv *priv)
1994 {
1995
1996 //if(pHalData->bDcut == TRUE)
1997 if(priv->IC_Cut >= IC_VersionCut_D)
1998 CCK_Tx_Power_Track_BW_Switch_TSSI(priv);
1999 else
2000 CCK_Tx_Power_Track_BW_Switch_ThermalMeter(priv);
2001 }
2002
2003
2004 //
2005 /******************************************************************************
2006 *function: Callback routine of the work item for set bandwidth mode.
2007 * input: struct net_device *dev
2008 * HT_CHANNEL_WIDTH Bandwidth //20M or 40M
2009 * HT_EXTCHNL_OFFSET Offset //Upper, Lower, or Don't care
2010 * output: none
2011 * return: none
2012 * Note: I doubt whether SetBWModeInProgress flag is necessary as we can
2013 * test whether current work in the queue or not.//do I?
2014 * ***************************************************************************/
2015 void rtl8192_SetBWModeWorkItem(struct r8192_priv *priv)
2016 {
2017 u8 regBwOpMode;
2018
2019 RT_TRACE(COMP_SWBW, "==>rtl8192_SetBWModeWorkItem() Switch to %s bandwidth\n",
2020 priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20?"20MHz":"40MHz")
2021
2022
2023 if(!priv->up)
2024 {
2025 priv->SetBWModeInProgress= false;
2026 return;
2027 }
2028 //<1>Set MAC register
2029 regBwOpMode = read_nic_byte(priv, BW_OPMODE);
2030
2031 switch(priv->CurrentChannelBW)
2032 {
2033 case HT_CHANNEL_WIDTH_20:
2034 regBwOpMode |= BW_OPMODE_20MHZ;
2035 // 2007/02/07 Mark by Emily because we have not verify whether this register works
2036 write_nic_byte(priv, BW_OPMODE, regBwOpMode);
2037 break;
2038
2039 case HT_CHANNEL_WIDTH_20_40:
2040 regBwOpMode &= ~BW_OPMODE_20MHZ;
2041 // 2007/02/07 Mark by Emily because we have not verify whether this register works
2042 write_nic_byte(priv, BW_OPMODE, regBwOpMode);
2043 break;
2044
2045 default:
2046 RT_TRACE(COMP_ERR, "SetChannelBandwidth819xUsb(): unknown Bandwidth: %#X\n",priv->CurrentChannelBW);
2047 break;
2048 }
2049
2050 //<2>Set PHY related register
2051 switch(priv->CurrentChannelBW)
2052 {
2053 case HT_CHANNEL_WIDTH_20:
2054 // Add by Vivi 20071119
2055 rtl8192_setBBreg(priv, rFPGA0_RFMOD, bRFMOD, 0x0);
2056 rtl8192_setBBreg(priv, rFPGA1_RFMOD, bRFMOD, 0x0);
2057 // rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x00100000, 1);
2058
2059 // Correct the tx power for CCK rate in 20M. Suggest by YN, 20071207
2060 // write_nic_dword(dev, rCCK0_TxFilter1, 0x1a1b0000);
2061 // write_nic_dword(dev, rCCK0_TxFilter2, 0x090e1317);
2062 // write_nic_dword(dev, rCCK0_DebugPort, 0x00000204);
2063 if(!priv->btxpower_tracking)
2064 {
2065 write_nic_dword(priv, rCCK0_TxFilter1, 0x1a1b0000);
2066 write_nic_dword(priv, rCCK0_TxFilter2, 0x090e1317);
2067 write_nic_dword(priv, rCCK0_DebugPort, 0x00000204);
2068 }
2069 else
2070 CCK_Tx_Power_Track_BW_Switch(priv);
2071
2072 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter1, 0x00100000, 1);
2073 break;
2074 case HT_CHANNEL_WIDTH_20_40:
2075 // Add by Vivi 20071119
2076 rtl8192_setBBreg(priv, rFPGA0_RFMOD, bRFMOD, 0x1);
2077 rtl8192_setBBreg(priv, rFPGA1_RFMOD, bRFMOD, 0x1);
2078 //rtl8192_setBBreg(dev, rCCK0_System, bCCKSideBand, (priv->nCur40MhzPrimeSC>>1));
2079 //rtl8192_setBBreg(dev, rFPGA0_AnalogParameter1, 0x00100000, 0);
2080 //rtl8192_setBBreg(dev, rOFDM1_LSTF, 0xC00, priv->nCur40MhzPrimeSC);
2081
2082 // Correct the tx power for CCK rate in 40M. Suggest by YN, 20071207
2083 //write_nic_dword(dev, rCCK0_TxFilter1, 0x35360000);
2084 //write_nic_dword(dev, rCCK0_TxFilter2, 0x121c252e);
2085 //write_nic_dword(dev, rCCK0_DebugPort, 0x00000409);
2086 if(!priv->btxpower_tracking)
2087 {
2088 write_nic_dword(priv, rCCK0_TxFilter1, 0x35360000);
2089 write_nic_dword(priv, rCCK0_TxFilter2, 0x121c252e);
2090 write_nic_dword(priv, rCCK0_DebugPort, 0x00000409);
2091 }
2092 else
2093 CCK_Tx_Power_Track_BW_Switch(priv);
2094
2095 // Set Control channel to upper or lower. These settings are required only for 40MHz
2096 rtl8192_setBBreg(priv, rCCK0_System, bCCKSideBand, (priv->nCur40MhzPrimeSC>>1));
2097 rtl8192_setBBreg(priv, rOFDM1_LSTF, 0xC00, priv->nCur40MhzPrimeSC);
2098
2099
2100 rtl8192_setBBreg(priv, rFPGA0_AnalogParameter1, 0x00100000, 0);
2101 break;
2102 default:
2103 RT_TRACE(COMP_ERR, "SetChannelBandwidth819xUsb(): unknown Bandwidth: %#X\n" ,priv->CurrentChannelBW);
2104 break;
2105
2106 }
2107 //Skip over setting of J-mode in BB register here. Default value is "None J mode". Emily 20070315
2108
2109 //<3>Set RF related register
2110 PHY_SetRF8256Bandwidth(priv, priv->CurrentChannelBW);
2111
2112 atomic_dec(&(priv->ieee80211->atm_swbw));
2113 priv->SetBWModeInProgress= false;
2114
2115 RT_TRACE(COMP_SWBW, "<==SetBWMode819xUsb()\n");
2116 }
2117
2118 /******************************************************************************
2119 *function: This function schedules bandwidth switch work.
2120 * input: struct net_device *dev
2121 * HT_CHANNEL_WIDTH Bandwidth //20M or 40M
2122 * HT_EXTCHNL_OFFSET Offset //Upper, Lower, or Don't care
2123 * output: none
2124 * return: none
2125 * Note: I doubt whether SetBWModeInProgress flag is necessary as we can
2126 * test whether current work in the queue or not.//do I?
2127 * ***************************************************************************/
2128 void rtl8192_SetBWMode(struct ieee80211_device *ieee, HT_CHANNEL_WIDTH Bandwidth, HT_EXTCHNL_OFFSET Offset)
2129 {
2130 struct r8192_priv *priv = ieee80211_priv(ieee->dev);
2131
2132
2133 if(priv->SetBWModeInProgress)
2134 return;
2135
2136 atomic_inc(&(priv->ieee80211->atm_swbw));
2137 priv->SetBWModeInProgress= true;
2138
2139 priv->CurrentChannelBW = Bandwidth;
2140
2141 if(Offset==HT_EXTCHNL_OFFSET_LOWER)
2142 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_UPPER;
2143 else if(Offset==HT_EXTCHNL_OFFSET_UPPER)
2144 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_LOWER;
2145 else
2146 priv->nCur40MhzPrimeSC = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2147
2148 //queue_work(priv->priv_wq, &(priv->SetBWModeWorkItem));
2149 // schedule_work(&(priv->SetBWModeWorkItem));
2150 rtl8192_SetBWModeWorkItem(priv);
2151
2152 }
2153
2154
2155 void InitialGain819xPci(struct ieee80211_device *ieee, u8 Operation)
2156 {
2157 #define SCAN_RX_INITIAL_GAIN 0x17
2158 #define POWER_DETECTION_TH 0x08
2159 struct r8192_priv *priv = ieee80211_priv(ieee->dev);
2160 u32 BitMask;
2161 u8 initial_gain;
2162
2163 if(priv->up)
2164 {
2165 switch(Operation)
2166 {
2167 case IG_Backup:
2168 RT_TRACE(COMP_SCAN, "IG_Backup, backup the initial gain.\n");
2169 initial_gain = SCAN_RX_INITIAL_GAIN;//pHalData->DefaultInitialGain[0];//
2170 BitMask = bMaskByte0;
2171 if(dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM)
2172 rtl8192_setBBreg(priv, UFWP, bMaskByte1, 0x8); // FW DIG OFF
2173 priv->initgain_backup.xaagccore1 = (u8)rtl8192_QueryBBReg(priv, rOFDM0_XAAGCCore1, BitMask);
2174 priv->initgain_backup.xbagccore1 = (u8)rtl8192_QueryBBReg(priv, rOFDM0_XBAGCCore1, BitMask);
2175 priv->initgain_backup.xcagccore1 = (u8)rtl8192_QueryBBReg(priv, rOFDM0_XCAGCCore1, BitMask);
2176 priv->initgain_backup.xdagccore1 = (u8)rtl8192_QueryBBReg(priv, rOFDM0_XDAGCCore1, BitMask);
2177 BitMask = bMaskByte2;
2178 priv->initgain_backup.cca = (u8)rtl8192_QueryBBReg(priv, rCCK0_CCA, BitMask);
2179
2180 RT_TRACE(COMP_SCAN, "Scan InitialGainBackup 0xc50 is %x\n",priv->initgain_backup.xaagccore1);
2181 RT_TRACE(COMP_SCAN, "Scan InitialGainBackup 0xc58 is %x\n",priv->initgain_backup.xbagccore1);
2182 RT_TRACE(COMP_SCAN, "Scan InitialGainBackup 0xc60 is %x\n",priv->initgain_backup.xcagccore1);
2183 RT_TRACE(COMP_SCAN, "Scan InitialGainBackup 0xc68 is %x\n",priv->initgain_backup.xdagccore1);
2184 RT_TRACE(COMP_SCAN, "Scan InitialGainBackup 0xa0a is %x\n",priv->initgain_backup.cca);
2185
2186 RT_TRACE(COMP_SCAN, "Write scan initial gain = 0x%x \n", initial_gain);
2187 write_nic_byte(priv, rOFDM0_XAAGCCore1, initial_gain);
2188 write_nic_byte(priv, rOFDM0_XBAGCCore1, initial_gain);
2189 write_nic_byte(priv, rOFDM0_XCAGCCore1, initial_gain);
2190 write_nic_byte(priv, rOFDM0_XDAGCCore1, initial_gain);
2191 RT_TRACE(COMP_SCAN, "Write scan 0xa0a = 0x%x \n", POWER_DETECTION_TH);
2192 write_nic_byte(priv, 0xa0a, POWER_DETECTION_TH);
2193 break;
2194 case IG_Restore:
2195 RT_TRACE(COMP_SCAN, "IG_Restore, restore the initial gain.\n");
2196 BitMask = 0x7f; //Bit0~ Bit6
2197 if(dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM)
2198 rtl8192_setBBreg(priv, UFWP, bMaskByte1, 0x8); // FW DIG OFF
2199
2200 rtl8192_setBBreg(priv, rOFDM0_XAAGCCore1, BitMask, (u32)priv->initgain_backup.xaagccore1);
2201 rtl8192_setBBreg(priv, rOFDM0_XBAGCCore1, BitMask, (u32)priv->initgain_backup.xbagccore1);
2202 rtl8192_setBBreg(priv, rOFDM0_XCAGCCore1, BitMask, (u32)priv->initgain_backup.xcagccore1);
2203 rtl8192_setBBreg(priv, rOFDM0_XDAGCCore1, BitMask, (u32)priv->initgain_backup.xdagccore1);
2204 BitMask = bMaskByte2;
2205 rtl8192_setBBreg(priv, rCCK0_CCA, BitMask, (u32)priv->initgain_backup.cca);
2206
2207 RT_TRACE(COMP_SCAN, "Scan BBInitialGainRestore 0xc50 is %x\n",priv->initgain_backup.xaagccore1);
2208 RT_TRACE(COMP_SCAN, "Scan BBInitialGainRestore 0xc58 is %x\n",priv->initgain_backup.xbagccore1);
2209 RT_TRACE(COMP_SCAN, "Scan BBInitialGainRestore 0xc60 is %x\n",priv->initgain_backup.xcagccore1);
2210 RT_TRACE(COMP_SCAN, "Scan BBInitialGainRestore 0xc68 is %x\n",priv->initgain_backup.xdagccore1);
2211 RT_TRACE(COMP_SCAN, "Scan BBInitialGainRestore 0xa0a is %x\n",priv->initgain_backup.cca);
2212
2213 rtl8192_phy_setTxPower(priv, priv->ieee80211->current_network.channel);
2214
2215
2216 if(dm_digtable.dig_algorithm == DIG_ALGO_BY_FALSE_ALARM)
2217 rtl8192_setBBreg(priv, UFWP, bMaskByte1, 0x1); // FW DIG ON
2218 break;
2219 default:
2220 RT_TRACE(COMP_SCAN, "Unknown IG Operation.\n");
2221 break;
2222 }
2223 }
2224 }
2225
kernel source for telekom puls (alcatel/mediatek)