]>
Commit | Line | Data |
---|---|---|
92b96797 FB |
1 | /* |
2 | * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. | |
3 | * All rights reserved. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License along | |
16 | * with this program; if not, write to the Free Software Foundation, Inc., | |
17 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 | * | |
19 | * | |
20 | * File: mac.c | |
21 | * | |
22 | * Purpose: MAC routines | |
23 | * | |
24 | * Author: Tevin Chen | |
25 | * | |
26 | * Date: May 21, 1996 | |
27 | * | |
28 | * Functions: | |
29 | * | |
30 | * Revision History: | |
31 | */ | |
32 | ||
92b96797 | 33 | #include "tmacro.h" |
92b96797 | 34 | #include "tether.h" |
92b96797 | 35 | #include "desc.h" |
92b96797 | 36 | #include "mac.h" |
92b96797 | 37 | #include "80211hdr.h" |
92b96797 | 38 | #include "rndis.h" |
92b96797 | 39 | #include "control.h" |
9d26d60f | 40 | |
92b96797 FB |
41 | /*--------------------- Static Definitions -------------------------*/ |
42 | //static int msglevel =MSG_LEVEL_DEBUG; | |
43 | static int msglevel =MSG_LEVEL_INFO; | |
44 | /*--------------------- Static Classes ----------------------------*/ | |
45 | ||
46 | /*--------------------- Static Variables --------------------------*/ | |
47 | ||
48 | /*--------------------- Static Functions --------------------------*/ | |
49 | ||
50 | /*--------------------- Export Variables --------------------------*/ | |
51 | ||
52 | /*--------------------- Export Functions --------------------------*/ | |
53 | ||
54 | ||
55 | ||
56 | ||
57 | ||
58 | /* | |
59 | * Description: | |
60 | * Set this hash index into multicast address register bit | |
61 | * | |
62 | * Parameters: | |
63 | * In: | |
64 | * byHashIdx - Hash index to set | |
65 | * Out: | |
66 | * none | |
67 | * | |
68 | * Return Value: none | |
69 | * | |
70 | */ | |
71 | void MACvSetMultiAddrByHash (PSDevice pDevice, BYTE byHashIdx) | |
72 | { | |
73 | UINT uByteIdx; | |
74 | BYTE byBitMask; | |
75 | BYTE pbyData[2]; | |
76 | ||
77 | ||
78 | // calculate byte position | |
79 | uByteIdx = byHashIdx / 8; | |
80 | ||
81 | // calculate bit position | |
82 | byBitMask = 1; | |
83 | byBitMask <<= (byHashIdx % 8); | |
84 | // turn on the bit | |
85 | ||
86 | pbyData[0] = byBitMask; | |
87 | pbyData[1] = byBitMask; | |
88 | ||
89 | CONTROLnsRequestOut(pDevice, | |
90 | MESSAGE_TYPE_WRITE_MASK, | |
91 | (WORD) (MAC_REG_MAR0 + uByteIdx), | |
92 | MESSAGE_REQUEST_MACREG, | |
93 | 2, | |
94 | pbyData); | |
95 | } | |
96 | ||
97 | ||
98 | ||
99 | /* | |
100 | * Description: | |
101 | * Write MAC Multicast Address Mask | |
102 | * | |
103 | * Parameters: | |
104 | * In: | |
105 | * uByteidx - Index of Mask | |
106 | * byData - Mask Value to write | |
107 | * Out: | |
108 | * none | |
109 | * | |
110 | * Return Value: none | |
111 | * | |
112 | */ | |
113 | VOID MACvWriteMultiAddr (PSDevice pDevice, UINT uByteIdx, BYTE byData) | |
114 | { | |
115 | BYTE byData1; | |
116 | ||
117 | byData1 = byData; | |
118 | CONTROLnsRequestOut(pDevice, | |
119 | MESSAGE_TYPE_WRITE, | |
120 | (WORD) (MAC_REG_MAR0 + uByteIdx), | |
121 | MESSAGE_REQUEST_MACREG, | |
122 | 1, | |
123 | &byData1); | |
124 | } | |
125 | ||
126 | ||
127 | /* | |
128 | * Description: | |
129 | * Shut Down MAC | |
130 | * | |
131 | * Parameters: | |
132 | * In: | |
133 | * Out: | |
134 | * none | |
135 | * | |
136 | * Return Value: TRUE if success; otherwise FALSE | |
137 | * | |
138 | */ | |
139 | BOOL MACbShutdown (PSDevice pDevice) | |
140 | { | |
141 | CONTROLnsRequestOutAsyn(pDevice, | |
142 | MESSAGE_TYPE_MACSHUTDOWN, | |
143 | 0, | |
144 | 0, | |
145 | 0, | |
146 | NULL | |
147 | ); | |
148 | return TRUE; | |
149 | } | |
150 | ||
151 | void MACvSetBBType(PSDevice pDevice,BYTE byType) | |
152 | { | |
153 | BYTE pbyData[2]; | |
154 | ||
155 | ||
156 | pbyData[0] = byType; | |
157 | pbyData[1] = EnCFG_BBType_MASK; | |
158 | ||
159 | CONTROLnsRequestOut(pDevice, | |
160 | MESSAGE_TYPE_WRITE_MASK, | |
161 | MAC_REG_ENCFG0, | |
162 | MESSAGE_REQUEST_MACREG, | |
163 | 2, | |
164 | pbyData | |
165 | ); | |
166 | } | |
167 | ||
168 | void MACvSetMISCFifo (PSDevice pDevice, WORD wOffset, DWORD dwData) | |
169 | { | |
170 | BYTE pbyData[4]; | |
171 | ||
172 | if (wOffset > 273) | |
173 | return; | |
174 | pbyData[0] = (BYTE)dwData; | |
175 | pbyData[1] = (BYTE)(dwData>>8); | |
176 | pbyData[2] = (BYTE)(dwData>>16); | |
177 | pbyData[3] = (BYTE)(dwData>>24); | |
178 | ||
179 | CONTROLnsRequestOut(pDevice, | |
180 | MESSAGE_TYPE_WRITE_MISCFF, | |
181 | wOffset, | |
182 | 0, | |
183 | 4, | |
184 | pbyData | |
185 | ); | |
186 | } | |
187 | ||
188 | /* | |
189 | * Description: | |
190 | * Disable the Key Entry by MISCFIFO | |
191 | * | |
192 | * Parameters: | |
193 | * In: | |
194 | * dwIoBase - Base Address for MAC | |
195 | * | |
196 | * Out: | |
197 | * none | |
198 | * | |
199 | * Return Value: none | |
200 | * | |
201 | */ | |
202 | void MACvDisableKeyEntry (PSDevice pDevice, UINT uEntryIdx) | |
203 | { | |
204 | WORD wOffset; | |
205 | BYTE byData; | |
206 | ||
207 | ||
208 | byData = (BYTE) uEntryIdx; | |
209 | ||
210 | wOffset = MISCFIFO_KEYETRY0; | |
211 | wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE); | |
212 | ||
213 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset); | |
214 | //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0); | |
215 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE); | |
216 | ||
217 | //issue write misc fifo command to device | |
218 | CONTROLnsRequestOut(pDevice, | |
219 | MESSAGE_TYPE_CLRKEYENTRY, | |
220 | 0, | |
221 | 0, | |
222 | 1, | |
223 | &byData | |
224 | ); | |
225 | } | |
226 | ||
227 | ||
228 | /* | |
229 | * Description: | |
230 | * Set the Key by MISCFIFO | |
231 | * | |
232 | * Parameters: | |
233 | * In: | |
234 | * dwIoBase - Base Address for MAC | |
235 | * | |
236 | * Out: | |
237 | * none | |
238 | * | |
239 | * Return Value: none | |
240 | * | |
241 | */ | |
242 | void MACvSetKeyEntry (PSDevice pDevice, WORD wKeyCtl, UINT uEntryIdx, UINT uKeyIdx, PBYTE pbyAddr, PDWORD pdwKey) | |
243 | { | |
244 | PBYTE pbyKey; | |
245 | WORD wOffset; | |
246 | DWORD dwData1,dwData2; | |
247 | int ii; | |
248 | BYTE pbyData[24]; | |
249 | ||
250 | ||
251 | ||
252 | ||
253 | ||
254 | if ( pDevice->byLocalID <= MAC_REVISION_A1 ) { | |
255 | if ( pDevice->sMgmtObj.byCSSPK == KEY_CTL_CCMP ) | |
256 | return; | |
257 | } | |
258 | ||
259 | wOffset = MISCFIFO_KEYETRY0; | |
260 | wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE); | |
261 | ||
262 | dwData1 = 0; | |
263 | dwData1 |= wKeyCtl; | |
264 | dwData1 <<= 16; | |
265 | dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5)); | |
266 | ||
267 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData1, wKeyCtl); | |
268 | ||
269 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset); | |
270 | //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData); | |
271 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE); | |
272 | ||
273 | //wOffset++; | |
274 | ||
275 | dwData2 = 0; | |
276 | dwData2 |= *(pbyAddr+3); | |
277 | dwData2 <<= 8; | |
278 | dwData2 |= *(pbyAddr+2); | |
279 | dwData2 <<= 8; | |
280 | dwData2 |= *(pbyAddr+1); | |
281 | dwData2 <<= 8; | |
282 | dwData2 |= *(pbyAddr+0); | |
283 | ||
284 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %lX\n", wOffset, dwData2); | |
285 | ||
286 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset); | |
287 | //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData); | |
288 | //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE); | |
289 | ||
290 | //wOffset++; | |
291 | ||
292 | //wOffset += (uKeyIdx * 4); | |
293 | /* for (ii=0;ii<4;ii++) { | |
294 | // alway push 128 bits | |
295 | DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey); | |
296 | VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii); | |
297 | VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++); | |
298 | VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE); | |
299 | } | |
300 | */ | |
301 | pbyKey = (PBYTE)pdwKey; | |
302 | ||
303 | pbyData[0] = (BYTE)dwData1; | |
304 | pbyData[1] = (BYTE)(dwData1>>8); | |
305 | pbyData[2] = (BYTE)(dwData1>>16); | |
306 | pbyData[3] = (BYTE)(dwData1>>24); | |
307 | pbyData[4] = (BYTE)dwData2; | |
308 | pbyData[5] = (BYTE)(dwData2>>8); | |
309 | pbyData[6] = (BYTE)(dwData2>>16); | |
310 | pbyData[7] = (BYTE)(dwData2>>24); | |
311 | for(ii=8;ii<24;ii++) | |
312 | pbyData[ii] = *pbyKey++; | |
313 | ||
314 | CONTROLnsRequestOut(pDevice, | |
315 | MESSAGE_TYPE_SETKEY, | |
316 | wOffset, | |
317 | (WORD)uKeyIdx, | |
318 | 24, | |
319 | pbyData | |
320 | ); | |
321 | ||
322 | ||
323 | } | |
324 | ||
325 | ||
326 | void MACvRegBitsOff(PSDevice pDevice, BYTE byRegOfs, BYTE byBits) | |
327 | { | |
328 | BYTE pbyData[2]; | |
329 | ||
330 | pbyData[0] = 0; | |
331 | pbyData[1] = byBits; | |
332 | ||
333 | CONTROLnsRequestOut(pDevice, | |
334 | MESSAGE_TYPE_WRITE_MASK, | |
335 | byRegOfs, | |
336 | MESSAGE_REQUEST_MACREG, | |
337 | 2, | |
338 | pbyData | |
339 | ); | |
340 | } | |
341 | ||
342 | ||
343 | void MACvRegBitsOn(PSDevice pDevice, BYTE byRegOfs, BYTE byBits) | |
344 | { | |
345 | BYTE pbyData[2]; | |
346 | ||
347 | ||
348 | pbyData[0] = byBits; | |
349 | pbyData[1] = byBits; | |
350 | ||
351 | CONTROLnsRequestOut(pDevice, | |
352 | MESSAGE_TYPE_WRITE_MASK, | |
353 | byRegOfs, | |
354 | MESSAGE_REQUEST_MACREG, | |
355 | 2, | |
356 | pbyData | |
357 | ); | |
358 | } | |
359 | ||
360 | void MACvWriteWord(PSDevice pDevice, BYTE byRegOfs, WORD wData) | |
361 | { | |
362 | BYTE pbyData[2]; | |
363 | ||
364 | ||
365 | pbyData[0] = (BYTE)(wData & 0xff); | |
366 | pbyData[1] = (BYTE)(wData >> 8); | |
367 | ||
368 | CONTROLnsRequestOut(pDevice, | |
369 | MESSAGE_TYPE_WRITE, | |
370 | byRegOfs, | |
371 | MESSAGE_REQUEST_MACREG, | |
372 | 2, | |
373 | pbyData | |
374 | ); | |
375 | ||
376 | } | |
377 | ||
378 | void MACvWriteBSSIDAddress(PSDevice pDevice, PBYTE pbyEtherAddr) | |
379 | { | |
380 | BYTE pbyData[6]; | |
381 | ||
382 | ||
383 | pbyData[0] = *((PBYTE)pbyEtherAddr); | |
384 | pbyData[1] = *((PBYTE)pbyEtherAddr+1); | |
385 | pbyData[2] = *((PBYTE)pbyEtherAddr+2); | |
386 | pbyData[3] = *((PBYTE)pbyEtherAddr+3); | |
387 | pbyData[4] = *((PBYTE)pbyEtherAddr+4); | |
388 | pbyData[5] = *((PBYTE)pbyEtherAddr+5); | |
389 | ||
390 | CONTROLnsRequestOut(pDevice, | |
391 | MESSAGE_TYPE_WRITE, | |
392 | MAC_REG_BSSID0, | |
393 | MESSAGE_REQUEST_MACREG, | |
394 | 6, | |
395 | pbyData | |
396 | ); | |
397 | } | |
398 | ||
399 | void MACvEnableProtectMD(PSDevice pDevice) | |
400 | { | |
401 | BYTE pbyData[2]; | |
402 | ||
403 | ||
404 | pbyData[0] = EnCFG_ProtectMd; | |
405 | pbyData[1] = EnCFG_ProtectMd; | |
406 | ||
407 | CONTROLnsRequestOut(pDevice, | |
408 | MESSAGE_TYPE_WRITE_MASK, | |
409 | MAC_REG_ENCFG0, | |
410 | MESSAGE_REQUEST_MACREG, | |
411 | 2, | |
412 | pbyData | |
413 | ); | |
414 | } | |
415 | ||
416 | void MACvDisableProtectMD(PSDevice pDevice) | |
417 | { | |
418 | BYTE pbyData[2]; | |
419 | ||
420 | ||
421 | pbyData[0] = 0; | |
422 | pbyData[1] = EnCFG_ProtectMd; | |
423 | ||
424 | CONTROLnsRequestOut(pDevice, | |
425 | MESSAGE_TYPE_WRITE_MASK, | |
426 | MAC_REG_ENCFG0, | |
427 | MESSAGE_REQUEST_MACREG, | |
428 | 2, | |
429 | pbyData | |
430 | ); | |
431 | } | |
432 | ||
433 | void MACvEnableBarkerPreambleMd(PSDevice pDevice) | |
434 | { | |
435 | BYTE pbyData[2]; | |
436 | ||
437 | ||
438 | pbyData[0] = EnCFG_BarkerPream; | |
439 | pbyData[1] = EnCFG_BarkerPream; | |
440 | ||
441 | CONTROLnsRequestOut(pDevice, | |
442 | MESSAGE_TYPE_WRITE_MASK, | |
443 | MAC_REG_ENCFG2, | |
444 | MESSAGE_REQUEST_MACREG, | |
445 | 2, | |
446 | pbyData | |
447 | ); | |
448 | } | |
449 | ||
450 | void MACvDisableBarkerPreambleMd(PSDevice pDevice) | |
451 | { | |
452 | BYTE pbyData[2]; | |
453 | ||
454 | ||
455 | pbyData[0] = 0; | |
456 | pbyData[1] = EnCFG_BarkerPream; | |
457 | ||
458 | CONTROLnsRequestOut(pDevice, | |
459 | MESSAGE_TYPE_WRITE_MASK, | |
460 | MAC_REG_ENCFG2, | |
461 | MESSAGE_REQUEST_MACREG, | |
462 | 2, | |
463 | pbyData | |
464 | ); | |
465 | } | |
466 | ||
467 | ||
468 | void MACvWriteBeaconInterval(PSDevice pDevice, WORD wInterval) | |
469 | { | |
470 | BYTE pbyData[2]; | |
471 | ||
472 | pbyData[0] = (BYTE) (wInterval & 0xff); | |
473 | pbyData[1] = (BYTE) (wInterval >> 8); | |
474 | ||
475 | CONTROLnsRequestOut(pDevice, | |
476 | MESSAGE_TYPE_WRITE, | |
477 | MAC_REG_BI, | |
478 | MESSAGE_REQUEST_MACREG, | |
479 | 2, | |
480 | pbyData | |
481 | ); | |
482 | } |