staging: vt6656: 64 bit fixes: fix long warning messages.
[linux-2.6.git] / drivers / staging / vt6656 / mac.c
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  */
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  */
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  *
137  */
138 void MACbShutdown(PSDevice pDevice)
139 {
140     CONTROLnsRequestOutAsyn(pDevice,
141                         MESSAGE_TYPE_MACSHUTDOWN,
142                         0,
143                         0,
144                         0,
145                         NULL
146                         );
147 }
148
149 void MACvSetBBType(PSDevice pDevice,BYTE byType)
150 {
151 BYTE            pbyData[2];
152
153
154     pbyData[0] = byType;
155     pbyData[1] = EnCFG_BBType_MASK;
156
157     CONTROLnsRequestOut(pDevice,
158                         MESSAGE_TYPE_WRITE_MASK,
159                         MAC_REG_ENCFG0,
160                         MESSAGE_REQUEST_MACREG,
161                         2,
162                         pbyData
163                         );
164 }
165
166 void MACvSetMISCFifo (PSDevice pDevice, WORD wOffset, DWORD dwData)
167 {
168 BYTE    pbyData[4];
169
170     if (wOffset > 273)
171         return;
172     pbyData[0] = (BYTE)dwData;
173     pbyData[1] = (BYTE)(dwData>>8);
174     pbyData[2] = (BYTE)(dwData>>16);
175     pbyData[3] = (BYTE)(dwData>>24);
176
177     CONTROLnsRequestOut(pDevice,
178                         MESSAGE_TYPE_WRITE_MISCFF,
179                         wOffset,
180                         0,
181                         4,
182                         pbyData
183                         );
184 }
185
186 /*
187  * Description:
188  *      Disable the Key Entry by MISCFIFO
189  *
190  * Parameters:
191  *  In:
192  *      dwIoBase        - Base Address for MAC
193  *
194  *  Out:
195  *      none
196  *
197  * Return Value: none
198  *
199  */
200 void MACvDisableKeyEntry(PSDevice pDevice, unsigned int uEntryIdx)
201 {
202 WORD    wOffset;
203 BYTE            byData;
204
205
206     byData = (BYTE) uEntryIdx;
207
208     wOffset = MISCFIFO_KEYETRY0;
209     wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
210
211     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
212     //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
213     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
214
215     //issue write misc fifo command to device
216     CONTROLnsRequestOut(pDevice,
217                         MESSAGE_TYPE_CLRKEYENTRY,
218                         0,
219                         0,
220                         1,
221                         &byData
222                         );
223 }
224
225
226 /*
227  * Description:
228  *      Set the Key by MISCFIFO
229  *
230  * Parameters:
231  *  In:
232  *      dwIoBase        - Base Address for MAC
233  *
234  *  Out:
235  *      none
236  *
237  * Return Value: none
238  *
239  */
240 void MACvSetKeyEntry(PSDevice pDevice, WORD wKeyCtl,
241                      unsigned int uEntryIdx, unsigned int uKeyIdx,
242                      PBYTE pbyAddr, PDWORD pdwKey)
243 {
244 PBYTE           pbyKey;
245 WORD            wOffset;
246 DWORD           dwData1,dwData2;
247 int             ii;
248 BYTE            pbyData[24];
249
250     if ( pDevice->byLocalID <= MAC_REVISION_A1 ) {
251         if ( pDevice->sMgmtObj.byCSSPK == KEY_CTL_CCMP )
252             return;
253     }
254
255     wOffset = MISCFIFO_KEYETRY0;
256     wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
257
258     dwData1 = 0;
259     dwData1 |= wKeyCtl;
260     dwData1 <<= 16;
261     dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
262
263         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %X,"\
264                 " KeyCtl:%X\n", wOffset, dwData1, wKeyCtl);
265
266     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
267     //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
268     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
269
270     //wOffset++;
271
272     dwData2 = 0;
273     dwData2 |= *(pbyAddr+3);
274     dwData2 <<= 8;
275     dwData2 |= *(pbyAddr+2);
276     dwData2 <<= 8;
277     dwData2 |= *(pbyAddr+1);
278     dwData2 <<= 8;
279     dwData2 |= *(pbyAddr+0);
280
281         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %X\n",
282                 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
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
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
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
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
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
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
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
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
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 }