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                         ARRAY_SIZE(pbyData),
 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         u8 byData;
 126
 127     byData = (u8) uEntryIdx;
 128
 129     //issue write misc fifo command to device
 130     CONTROLnsRequestOut(pDevice,
 131                         MESSAGE_TYPE_CLRKEYENTRY,
 132                         0,
 133                         0,
 134                         1,
 135                         &byData
 136                         );
 137 }
 138
 139 /*
 140  * Description:
 141  *      Set the Key by MISCFIFO
 142  *
 143  * Parameters:
 144  *  In:
 145  *      dwIoBase        - Base Address for MAC
 146  *
 147  *  Out:
 148  *      none
 149  *
 150  * Return Value: none
 151  *
 152  */
 153 void MACvSetKeyEntry(struct vnt_private *pDevice, u16 wKeyCtl, u32 uEntryIdx,
 154         u32 uKeyIdx, u8 *pbyAddr, u32 *pdwKey)
 155 {
 156         u8 *pbyKey;
 157         u16 wOffset;
 158         u32 dwData1, dwData2;
 159         int ii;
 160         u8 pbyData[24];
 161
 162         if (pDevice->byLocalID <= MAC_REVISION_A1)
 163                 if (pDevice->vnt_mgmt.byCSSPK == KEY_CTL_CCMP)
 164                         return;
 165
 166     wOffset = MISCFIFO_KEYETRY0;
 167     wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
 168
 169     dwData1 = 0;
 170     dwData1 |= wKeyCtl;
 171     dwData1 <<= 16;
 172     dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
 173
 174         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %X,"\
 175                 " KeyCtl:%X\n", wOffset, dwData1, wKeyCtl);
 176
 177     dwData2 = 0;
 178     dwData2 |= *(pbyAddr+3);
 179     dwData2 <<= 8;
 180     dwData2 |= *(pbyAddr+2);
 181     dwData2 <<= 8;
 182     dwData2 |= *(pbyAddr+1);
 183     dwData2 <<= 8;
 184     dwData2 |= *(pbyAddr+0);
 185
 186         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %X\n",
 187                 wOffset, dwData2);
 188
 189     pbyKey = (u8 *)pdwKey;
 190
 191     pbyData[0] = (u8)dwData1;
 192     pbyData[1] = (u8)(dwData1>>8);
 193     pbyData[2] = (u8)(dwData1>>16);
 194     pbyData[3] = (u8)(dwData1>>24);
 195     pbyData[4] = (u8)dwData2;
 196     pbyData[5] = (u8)(dwData2>>8);
 197     pbyData[6] = (u8)(dwData2>>16);
 198     pbyData[7] = (u8)(dwData2>>24);
 199     for (ii = 8; ii < 24; ii++)
 200         pbyData[ii] = *pbyKey++;
 201
 202     CONTROLnsRequestOut(pDevice,
 203                         MESSAGE_TYPE_SETKEY,
 204                         wOffset,
 205                         (u16)uKeyIdx,
 206                         ARRAY_SIZE(pbyData),
 207                         pbyData
 208                         );
 209
 210 }
 211
 212 void MACvRegBitsOff(struct vnt_private *pDevice, u8 byRegOfs, u8 byBits)
 213 {
 214         u8 pbyData[2];
 215
 216     pbyData[0] = 0;
 217     pbyData[1] = byBits;
 218
 219     CONTROLnsRequestOut(pDevice,
 220                         MESSAGE_TYPE_WRITE_MASK,
 221                         byRegOfs,
 222                         MESSAGE_REQUEST_MACREG,
 223                         ARRAY_SIZE(pbyData),
 224                         pbyData
 225                         );
 226 }
 227
 228 void MACvRegBitsOn(struct vnt_private *pDevice, u8 byRegOfs, u8 byBits)
 229 {
 230         u8 pbyData[2];
 231
 232     pbyData[0] = byBits;
 233     pbyData[1] = byBits;
 234
 235     CONTROLnsRequestOut(pDevice,
 236                         MESSAGE_TYPE_WRITE_MASK,
 237                         byRegOfs,
 238                         MESSAGE_REQUEST_MACREG,
 239                         ARRAY_SIZE(pbyData),
 240                         pbyData
 241                         );
 242 }
 243
 244 void MACvWriteWord(struct vnt_private *pDevice, u8 byRegOfs, u16 wData)
 245 {
 246         u8 pbyData[2];
 247
 248     pbyData[0] = (u8)(wData & 0xff);
 249     pbyData[1] = (u8)(wData >> 8);
 250
 251     CONTROLnsRequestOut(pDevice,
 252                         MESSAGE_TYPE_WRITE,
 253                         byRegOfs,
 254                         MESSAGE_REQUEST_MACREG,
 255                         ARRAY_SIZE(pbyData),
 256                         pbyData
 257                         );
 258
 259 }
 260
 261 void MACvWriteBSSIDAddress(struct vnt_private *pDevice, u8 *pbyEtherAddr)
 262 {
 263         u8 pbyData[6];
 264
 265     pbyData[0] = *((u8 *)pbyEtherAddr);
 266     pbyData[1] = *((u8 *)pbyEtherAddr+1);
 267     pbyData[2] = *((u8 *)pbyEtherAddr+2);
 268     pbyData[3] = *((u8 *)pbyEtherAddr+3);
 269     pbyData[4] = *((u8 *)pbyEtherAddr+4);
 270     pbyData[5] = *((u8 *)pbyEtherAddr+5);
 271
 272     CONTROLnsRequestOut(pDevice,
 273                         MESSAGE_TYPE_WRITE,
 274                         MAC_REG_BSSID0,
 275                         MESSAGE_REQUEST_MACREG,
 276                         ARRAY_SIZE(pbyData),
 277                         pbyData
 278                         );
 279 }
 280
 281 void MACvEnableProtectMD(struct vnt_private *pDevice)
 282 {
 283         u8 pbyData[2];
 284
 285     pbyData[0] = EnCFG_ProtectMd;
 286     pbyData[1] = EnCFG_ProtectMd;
 287
 288     CONTROLnsRequestOut(pDevice,
 289                         MESSAGE_TYPE_WRITE_MASK,
 290                         MAC_REG_ENCFG0,
 291                         MESSAGE_REQUEST_MACREG,
 292                         ARRAY_SIZE(pbyData),
 293                         pbyData
 294                         );
 295 }
 296
 297 void MACvDisableProtectMD(struct vnt_private *pDevice)
 298 {
 299         u8 pbyData[2];
 300
 301     pbyData[0] = 0;
 302     pbyData[1] = EnCFG_ProtectMd;
 303
 304     CONTROLnsRequestOut(pDevice,
 305                         MESSAGE_TYPE_WRITE_MASK,
 306                         MAC_REG_ENCFG0,
 307                         MESSAGE_REQUEST_MACREG,
 308                         ARRAY_SIZE(pbyData),
 309                         pbyData
 310                         );
 311 }
 312
 313 void MACvEnableBarkerPreambleMd(struct vnt_private *pDevice)
 314 {
 315         u8 pbyData[2];
 316
 317     pbyData[0] = EnCFG_BarkerPream;
 318     pbyData[1] = EnCFG_BarkerPream;
 319
 320     CONTROLnsRequestOut(pDevice,
 321                         MESSAGE_TYPE_WRITE_MASK,
 322                         MAC_REG_ENCFG2,
 323                         MESSAGE_REQUEST_MACREG,
 324                         ARRAY_SIZE(pbyData),
 325                         pbyData
 326                         );
 327 }
 328
 329 void MACvDisableBarkerPreambleMd(struct vnt_private *pDevice)
 330 {
 331         u8 pbyData[2];
 332
 333     pbyData[0] = 0;
 334     pbyData[1] = EnCFG_BarkerPream;
 335
 336     CONTROLnsRequestOut(pDevice,
 337                         MESSAGE_TYPE_WRITE_MASK,
 338                         MAC_REG_ENCFG2,
 339                         MESSAGE_REQUEST_MACREG,
 340                         ARRAY_SIZE(pbyData),
 341                         pbyData
 342                         );
 343 }
 344
 345 void MACvWriteBeaconInterval(struct vnt_private *pDevice, u16 wInterval)
 346 {
 347         u8 pbyData[2];
 348
 349         pbyData[0] = (u8)(wInterval & 0xff);
 350         pbyData[1] = (u8)(wInterval >> 8);
 351
 352     CONTROLnsRequestOut(pDevice,
 353                         MESSAGE_TYPE_WRITE,
 354                         MAC_REG_BI,
 355                         MESSAGE_REQUEST_MACREG,
 356                         ARRAY_SIZE(pbyData),
 357                         pbyData
 358                         );
 359 }