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