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 int          msglevel                =MSG_LEVEL_DEBUG;
  42 static int          msglevel                =MSG_LEVEL_INFO;
  43
  44 /*
  45  * Description:
  46  *      Write MAC Multicast Address Mask
  47  *
  48  * Parameters:
  49  *  In:
  50  *      uByteidx    - Index of Mask
  51  *      byData      - Mask Value to write
  52  *  Out:
  53  *      none
  54  *
  55  * Return Value: none
  56  *
  57  */
  58 void MACvWriteMultiAddr(struct vnt_private *pDevice, u32 uByteIdx, u8 byData)
  59 {
  60         u8 byData1;
  61
  62     byData1 = byData;
  63     CONTROLnsRequestOut(pDevice,
  64                         MESSAGE_TYPE_WRITE,
  65                         (u16) (MAC_REG_MAR0 + uByteIdx),
  66                         MESSAGE_REQUEST_MACREG,
  67                         1,
  68                         &byData1);
  69 }
  70
  71 /*
  72  * Description:
  73  *      Shut Down MAC
  74  *
  75  * Parameters:
  76  *  In:
  77  *  Out:
  78  *      none
  79  *
  80  *
  81  */
  82 void MACbShutdown(struct vnt_private *pDevice)
  83 {
  84     CONTROLnsRequestOutAsyn(pDevice,
  85                         MESSAGE_TYPE_MACSHUTDOWN,
  86                         0,
  87                         0,
  88                         0,
  89                         NULL
  90                         );
  91 }
  92
  93 void MACvSetBBType(struct vnt_private *pDevice, u8 byType)
  94 {
  95         u8 pbyData[2];
  96
  97     pbyData[0] = byType;
  98     pbyData[1] = EnCFG_BBType_MASK;
  99
 100     CONTROLnsRequestOut(pDevice,
 101                         MESSAGE_TYPE_WRITE_MASK,
 102                         MAC_REG_ENCFG0,
 103                         MESSAGE_REQUEST_MACREG,
 104                         2,
 105                         pbyData
 106                         );
 107 }
 108
 109 /*
 110  * Description:
 111  *      Disable the Key Entry by MISCFIFO
 112  *
 113  * Parameters:
 114  *  In:
 115  *      dwIoBase        - Base Address for MAC
 116  *
 117  *  Out:
 118  *      none
 119  *
 120  * Return Value: none
 121  *
 122  */
 123 void MACvDisableKeyEntry(struct vnt_private *pDevice, u32 uEntryIdx)
 124 {
 125         u16 wOffset;
 126         u8 byData;
 127
 128     byData = (u8) uEntryIdx;
 129
 130     wOffset = MISCFIFO_KEYETRY0;
 131     wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
 132
 133     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
 134     //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
 135     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
 136
 137     //issue write misc fifo command to device
 138     CONTROLnsRequestOut(pDevice,
 139                         MESSAGE_TYPE_CLRKEYENTRY,
 140                         0,
 141                         0,
 142                         1,
 143                         &byData
 144                         );
 145 }
 146
 147 /*
 148  * Description:
 149  *      Set the Key by MISCFIFO
 150  *
 151  * Parameters:
 152  *  In:
 153  *      dwIoBase        - Base Address for MAC
 154  *
 155  *  Out:
 156  *      none
 157  *
 158  * Return Value: none
 159  *
 160  */
 161 void MACvSetKeyEntry(struct vnt_private *pDevice, u16 wKeyCtl, u32 uEntryIdx,
 162         u32 uKeyIdx, u8 *pbyAddr, u32 *pdwKey)
 163 {
 164         u8 *pbyKey;
 165         u16 wOffset;
 166         u32 dwData1, dwData2;
 167         int ii;
 168         u8 pbyData[24];
 169
 170         if (pDevice->byLocalID <= MAC_REVISION_A1)
 171                 if (pDevice->vnt_mgmt.byCSSPK == KEY_CTL_CCMP)
 172                         return;
 173
 174     wOffset = MISCFIFO_KEYETRY0;
 175     wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
 176
 177     dwData1 = 0;
 178     dwData1 |= wKeyCtl;
 179     dwData1 <<= 16;
 180     dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
 181
 182         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %X,"\
 183                 " KeyCtl:%X\n", wOffset, dwData1, wKeyCtl);
 184
 185     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
 186     //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
 187     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
 188
 189     //wOffset++;
 190
 191     dwData2 = 0;
 192     dwData2 |= *(pbyAddr+3);
 193     dwData2 <<= 8;
 194     dwData2 |= *(pbyAddr+2);
 195     dwData2 <<= 8;
 196     dwData2 |= *(pbyAddr+1);
 197     dwData2 <<= 8;
 198     dwData2 |= *(pbyAddr+0);
 199
 200         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %X\n",
 201                 wOffset, dwData2);
 202
 203     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
 204     //VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
 205     //VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
 206
 207     //wOffset++;
 208
 209     //wOffset += (uKeyIdx * 4);
 210 /*    for (ii=0;ii<4;ii++) {
 211         // alway push 128 bits
 212         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
 213         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
 214         VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
 215         VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
 216     }
 217 */
 218     pbyKey = (u8 *)pdwKey;
 219
 220     pbyData[0] = (u8)dwData1;
 221     pbyData[1] = (u8)(dwData1>>8);
 222     pbyData[2] = (u8)(dwData1>>16);
 223     pbyData[3] = (u8)(dwData1>>24);
 224     pbyData[4] = (u8)dwData2;
 225     pbyData[5] = (u8)(dwData2>>8);
 226     pbyData[6] = (u8)(dwData2>>16);
 227     pbyData[7] = (u8)(dwData2>>24);
 228     for (ii = 8; ii < 24; ii++)
 229         pbyData[ii] = *pbyKey++;
 230
 231     CONTROLnsRequestOut(pDevice,
 232                         MESSAGE_TYPE_SETKEY,
 233                         wOffset,
 234                         (u16)uKeyIdx,
 235                         24,
 236                         pbyData
 237                         );
 238
 239 }
 240
 241 void MACvRegBitsOff(struct vnt_private *pDevice, u8 byRegOfs, u8 byBits)
 242 {
 243         u8 pbyData[2];
 244
 245     pbyData[0] = 0;
 246     pbyData[1] = byBits;
 247
 248     CONTROLnsRequestOut(pDevice,
 249                         MESSAGE_TYPE_WRITE_MASK,
 250                         byRegOfs,
 251                         MESSAGE_REQUEST_MACREG,
 252                         2,
 253                         pbyData
 254                         );
 255 }
 256
 257 void MACvRegBitsOn(struct vnt_private *pDevice, u8 byRegOfs, u8 byBits)
 258 {
 259         u8 pbyData[2];
 260
 261     pbyData[0] = byBits;
 262     pbyData[1] = byBits;
 263
 264     CONTROLnsRequestOut(pDevice,
 265                         MESSAGE_TYPE_WRITE_MASK,
 266                         byRegOfs,
 267                         MESSAGE_REQUEST_MACREG,
 268                         2,
 269                         pbyData
 270                         );
 271 }
 272
 273 void MACvWriteWord(struct vnt_private *pDevice, u8 byRegOfs, u16 wData)
 274 {
 275         u8 pbyData[2];
 276
 277     pbyData[0] = (u8)(wData & 0xff);
 278     pbyData[1] = (u8)(wData >> 8);
 279
 280     CONTROLnsRequestOut(pDevice,
 281                         MESSAGE_TYPE_WRITE,
 282                         byRegOfs,
 283                         MESSAGE_REQUEST_MACREG,
 284                         2,
 285                         pbyData
 286                         );
 287
 288 }
 289
 290 void MACvWriteBSSIDAddress(struct vnt_private *pDevice, u8 *pbyEtherAddr)
 291 {
 292         u8 pbyData[6];
 293
 294     pbyData[0] = *((u8 *)pbyEtherAddr);
 295     pbyData[1] = *((u8 *)pbyEtherAddr+1);
 296     pbyData[2] = *((u8 *)pbyEtherAddr+2);
 297     pbyData[3] = *((u8 *)pbyEtherAddr+3);
 298     pbyData[4] = *((u8 *)pbyEtherAddr+4);
 299     pbyData[5] = *((u8 *)pbyEtherAddr+5);
 300
 301     CONTROLnsRequestOut(pDevice,
 302                         MESSAGE_TYPE_WRITE,
 303                         MAC_REG_BSSID0,
 304                         MESSAGE_REQUEST_MACREG,
 305                         6,
 306                         pbyData
 307                         );
 308 }
 309
 310 void MACvEnableProtectMD(struct vnt_private *pDevice)
 311 {
 312         u8 pbyData[2];
 313
 314     pbyData[0] = EnCFG_ProtectMd;
 315     pbyData[1] = EnCFG_ProtectMd;
 316
 317     CONTROLnsRequestOut(pDevice,
 318                         MESSAGE_TYPE_WRITE_MASK,
 319                         MAC_REG_ENCFG0,
 320                         MESSAGE_REQUEST_MACREG,
 321                         2,
 322                         pbyData
 323                         );
 324 }
 325
 326 void MACvDisableProtectMD(struct vnt_private *pDevice)
 327 {
 328         u8 pbyData[2];
 329
 330     pbyData[0] = 0;
 331     pbyData[1] = EnCFG_ProtectMd;
 332
 333     CONTROLnsRequestOut(pDevice,
 334                         MESSAGE_TYPE_WRITE_MASK,
 335                         MAC_REG_ENCFG0,
 336                         MESSAGE_REQUEST_MACREG,
 337                         2,
 338                         pbyData
 339                         );
 340 }
 341
 342 void MACvEnableBarkerPreambleMd(struct vnt_private *pDevice)
 343 {
 344         u8 pbyData[2];
 345
 346     pbyData[0] = EnCFG_BarkerPream;
 347     pbyData[1] = EnCFG_BarkerPream;
 348
 349     CONTROLnsRequestOut(pDevice,
 350                         MESSAGE_TYPE_WRITE_MASK,
 351                         MAC_REG_ENCFG2,
 352                         MESSAGE_REQUEST_MACREG,
 353                         2,
 354                         pbyData
 355                         );
 356 }
 357
 358 void MACvDisableBarkerPreambleMd(struct vnt_private *pDevice)
 359 {
 360         u8 pbyData[2];
 361
 362     pbyData[0] = 0;
 363     pbyData[1] = EnCFG_BarkerPream;
 364
 365     CONTROLnsRequestOut(pDevice,
 366                         MESSAGE_TYPE_WRITE_MASK,
 367                         MAC_REG_ENCFG2,
 368                         MESSAGE_REQUEST_MACREG,
 369                         2,
 370                         pbyData
 371                         );
 372 }
 373
 374 void MACvWriteBeaconInterval(struct vnt_private *pDevice, u16 wInterval)
 375 {
 376         u8 pbyData[2];
 377
 378         pbyData[0] = (u8)(wInterval & 0xff);
 379         pbyData[1] = (u8)(wInterval >> 8);
 380
 381     CONTROLnsRequestOut(pDevice,
 382                         MESSAGE_TYPE_WRITE,
 383                         MAC_REG_BI,
 384                         MESSAGE_REQUEST_MACREG,
 385                         2,
 386                         pbyData
 387                         );
 388 }