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