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
33 #include "tmacro.h"
34 #include "tether.h"
35 #include "desc.h"
36 #include "mac.h"
37 #include "80211hdr.h"
38 #include "rndis.h"
39 #include "control.h"
40
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 */
MACvSetMultiAddrByHash(PSDevice pDevice,BYTE byHashIdx)71 void MACvSetMultiAddrByHash (PSDevice pDevice, BYTE byHashIdx)
72 {
73 unsigned int 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 */
MACvWriteMultiAddr(PSDevice pDevice,unsigned int uByteIdx,BYTE byData)113 void MACvWriteMultiAddr(PSDevice pDevice, unsigned int 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 */
MACbShutdown(PSDevice pDevice)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
MACvSetBBType(PSDevice pDevice,BYTE byType)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
MACvSetMISCFifo(PSDevice pDevice,WORD wOffset,DWORD dwData)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 */
MACvDisableKeyEntry(PSDevice pDevice,unsigned int uEntryIdx)202 void MACvDisableKeyEntry(PSDevice pDevice, unsigned int 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 */
MACvSetKeyEntry(PSDevice pDevice,WORD wKeyCtl,unsigned int uEntryIdx,unsigned int uKeyIdx,PBYTE pbyAddr,PDWORD pdwKey)242 void MACvSetKeyEntry(PSDevice pDevice, WORD wKeyCtl,
243 unsigned int uEntryIdx, unsigned int uKeyIdx,
244 PBYTE pbyAddr, PDWORD pdwKey)
245 {
246 PBYTE pbyKey;
247 WORD wOffset;
248 DWORD dwData1,dwData2;
249 int ii;
250 BYTE pbyData[24];
251
252 if ( pDevice->byLocalID <= MAC_REVISION_A1 ) {
253 if ( pDevice->sMgmtObj.byCSSPK == KEY_CTL_CCMP )
254 return;
255 }
256
257 wOffset = MISCFIFO_KEYETRY0;
258 wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
259
260 dwData1 = 0;
261 dwData1 |= wKeyCtl;
262 dwData1 <<= 16;
263 dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
264
265 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData1, wKeyCtl);
266
267 //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
268 //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
269 //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
270
271 //wOffset++;
272
273 dwData2 = 0;
274 dwData2 |= *(pbyAddr+3);
275 dwData2 <<= 8;
276 dwData2 |= *(pbyAddr+2);
277 dwData2 <<= 8;
278 dwData2 |= *(pbyAddr+1);
279 dwData2 <<= 8;
280 dwData2 |= *(pbyAddr+0);
281
282 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %lX\n", wOffset, dwData2);
283
284 //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
285 //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
286 //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
287
288 //wOffset++;
289
290 //wOffset += (uKeyIdx * 4);
291 /* for (ii=0;ii<4;ii++) {
292 // alway push 128 bits
293 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
294 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
295 VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
296 VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
297 }
298 */
299 pbyKey = (PBYTE)pdwKey;
300
301 pbyData[0] = (BYTE)dwData1;
302 pbyData[1] = (BYTE)(dwData1>>8);
303 pbyData[2] = (BYTE)(dwData1>>16);
304 pbyData[3] = (BYTE)(dwData1>>24);
305 pbyData[4] = (BYTE)dwData2;
306 pbyData[5] = (BYTE)(dwData2>>8);
307 pbyData[6] = (BYTE)(dwData2>>16);
308 pbyData[7] = (BYTE)(dwData2>>24);
309 for (ii = 8; ii < 24; ii++)
310 pbyData[ii] = *pbyKey++;
311
312 CONTROLnsRequestOut(pDevice,
313 MESSAGE_TYPE_SETKEY,
314 wOffset,
315 (WORD)uKeyIdx,
316 24,
317 pbyData
318 );
319
320
321 }
322
323
MACvRegBitsOff(PSDevice pDevice,BYTE byRegOfs,BYTE byBits)324 void MACvRegBitsOff(PSDevice pDevice, BYTE byRegOfs, BYTE byBits)
325 {
326 BYTE pbyData[2];
327
328 pbyData[0] = 0;
329 pbyData[1] = byBits;
330
331 CONTROLnsRequestOut(pDevice,
332 MESSAGE_TYPE_WRITE_MASK,
333 byRegOfs,
334 MESSAGE_REQUEST_MACREG,
335 2,
336 pbyData
337 );
338 }
339
340
MACvRegBitsOn(PSDevice pDevice,BYTE byRegOfs,BYTE byBits)341 void MACvRegBitsOn(PSDevice pDevice, BYTE byRegOfs, BYTE byBits)
342 {
343 BYTE pbyData[2];
344
345
346 pbyData[0] = byBits;
347 pbyData[1] = byBits;
348
349 CONTROLnsRequestOut(pDevice,
350 MESSAGE_TYPE_WRITE_MASK,
351 byRegOfs,
352 MESSAGE_REQUEST_MACREG,
353 2,
354 pbyData
355 );
356 }
357
MACvWriteWord(PSDevice pDevice,BYTE byRegOfs,WORD wData)358 void MACvWriteWord(PSDevice pDevice, BYTE byRegOfs, WORD wData)
359 {
360 BYTE pbyData[2];
361
362
363 pbyData[0] = (BYTE)(wData & 0xff);
364 pbyData[1] = (BYTE)(wData >> 8);
365
366 CONTROLnsRequestOut(pDevice,
367 MESSAGE_TYPE_WRITE,
368 byRegOfs,
369 MESSAGE_REQUEST_MACREG,
370 2,
371 pbyData
372 );
373
374 }
375
MACvWriteBSSIDAddress(PSDevice pDevice,PBYTE pbyEtherAddr)376 void MACvWriteBSSIDAddress(PSDevice pDevice, PBYTE pbyEtherAddr)
377 {
378 BYTE pbyData[6];
379
380
381 pbyData[0] = *((PBYTE)pbyEtherAddr);
382 pbyData[1] = *((PBYTE)pbyEtherAddr+1);
383 pbyData[2] = *((PBYTE)pbyEtherAddr+2);
384 pbyData[3] = *((PBYTE)pbyEtherAddr+3);
385 pbyData[4] = *((PBYTE)pbyEtherAddr+4);
386 pbyData[5] = *((PBYTE)pbyEtherAddr+5);
387
388 CONTROLnsRequestOut(pDevice,
389 MESSAGE_TYPE_WRITE,
390 MAC_REG_BSSID0,
391 MESSAGE_REQUEST_MACREG,
392 6,
393 pbyData
394 );
395 }
396
MACvEnableProtectMD(PSDevice pDevice)397 void MACvEnableProtectMD(PSDevice pDevice)
398 {
399 BYTE pbyData[2];
400
401
402 pbyData[0] = EnCFG_ProtectMd;
403 pbyData[1] = EnCFG_ProtectMd;
404
405 CONTROLnsRequestOut(pDevice,
406 MESSAGE_TYPE_WRITE_MASK,
407 MAC_REG_ENCFG0,
408 MESSAGE_REQUEST_MACREG,
409 2,
410 pbyData
411 );
412 }
413
MACvDisableProtectMD(PSDevice pDevice)414 void MACvDisableProtectMD(PSDevice pDevice)
415 {
416 BYTE pbyData[2];
417
418
419 pbyData[0] = 0;
420 pbyData[1] = EnCFG_ProtectMd;
421
422 CONTROLnsRequestOut(pDevice,
423 MESSAGE_TYPE_WRITE_MASK,
424 MAC_REG_ENCFG0,
425 MESSAGE_REQUEST_MACREG,
426 2,
427 pbyData
428 );
429 }
430
MACvEnableBarkerPreambleMd(PSDevice pDevice)431 void MACvEnableBarkerPreambleMd(PSDevice pDevice)
432 {
433 BYTE pbyData[2];
434
435
436 pbyData[0] = EnCFG_BarkerPream;
437 pbyData[1] = EnCFG_BarkerPream;
438
439 CONTROLnsRequestOut(pDevice,
440 MESSAGE_TYPE_WRITE_MASK,
441 MAC_REG_ENCFG2,
442 MESSAGE_REQUEST_MACREG,
443 2,
444 pbyData
445 );
446 }
447
MACvDisableBarkerPreambleMd(PSDevice pDevice)448 void MACvDisableBarkerPreambleMd(PSDevice pDevice)
449 {
450 BYTE pbyData[2];
451
452
453 pbyData[0] = 0;
454 pbyData[1] = EnCFG_BarkerPream;
455
456 CONTROLnsRequestOut(pDevice,
457 MESSAGE_TYPE_WRITE_MASK,
458 MAC_REG_ENCFG2,
459 MESSAGE_REQUEST_MACREG,
460 2,
461 pbyData
462 );
463 }
464
465
MACvWriteBeaconInterval(PSDevice pDevice,WORD wInterval)466 void MACvWriteBeaconInterval(PSDevice pDevice, WORD wInterval)
467 {
468 BYTE pbyData[2];
469
470 pbyData[0] = (BYTE) (wInterval & 0xff);
471 pbyData[1] = (BYTE) (wInterval >> 8);
472
473 CONTROLnsRequestOut(pDevice,
474 MESSAGE_TYPE_WRITE,
475 MAC_REG_BI,
476 MESSAGE_REQUEST_MACREG,
477 2,
478 pbyData
479 );
480 }
481