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     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 }