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