92b9679711
Add pristine upstream vt6656 driver sources to drivers/staging/vt6656. These files were copied from the driver directory in the upstream source archive, available here: http://www.viaarena.com/Driver/VT6656_Linux_src_v1.19_12_x86.zip After copying, trailing whitespace was stripped. This is GPL-licensed code. Signed-off-by: Forest Bond <forest@alittletooquiet.net> Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
501 lines
12 KiB
C
501 lines
12 KiB
C
/*
|
|
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*
|
|
* File: mac.c
|
|
*
|
|
* Purpose: MAC routines
|
|
*
|
|
* Author: Tevin Chen
|
|
*
|
|
* Date: May 21, 1996
|
|
*
|
|
* Functions:
|
|
*
|
|
* Revision History:
|
|
*/
|
|
|
|
|
|
|
|
#if !defined(__TMACRO_H__)
|
|
#include "tmacro.h"
|
|
#endif
|
|
#if !defined(__TBIT_H__)
|
|
#include "tbit.h"
|
|
#endif
|
|
#if !defined(__TETHER_H__)
|
|
#include "tether.h"
|
|
#endif
|
|
#if !defined(__DESC_H__)
|
|
#include "desc.h"
|
|
#endif
|
|
#if !defined(__MAC_H__)
|
|
#include "mac.h"
|
|
#endif
|
|
#if !defined(__80211hdr_H__)
|
|
#include "80211hdr.h"
|
|
#endif
|
|
#if !defined(__RNDIS_H__)
|
|
#include "rndis.h"
|
|
#endif
|
|
#if !defined(__CONTROL_H__)
|
|
#include "control.h"
|
|
#endif
|
|
/*--------------------- Static Definitions -------------------------*/
|
|
//static int msglevel =MSG_LEVEL_DEBUG;
|
|
static int msglevel =MSG_LEVEL_INFO;
|
|
/*--------------------- Static Classes ----------------------------*/
|
|
|
|
/*--------------------- Static Variables --------------------------*/
|
|
|
|
/*--------------------- Static Functions --------------------------*/
|
|
|
|
/*--------------------- Export Variables --------------------------*/
|
|
|
|
/*--------------------- Export Functions --------------------------*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Description:
|
|
* Set this hash index into multicast address register bit
|
|
*
|
|
* Parameters:
|
|
* In:
|
|
* byHashIdx - Hash index to set
|
|
* Out:
|
|
* none
|
|
*
|
|
* Return Value: none
|
|
*
|
|
*/
|
|
void MACvSetMultiAddrByHash (PSDevice pDevice, BYTE byHashIdx)
|
|
{
|
|
UINT uByteIdx;
|
|
BYTE byBitMask;
|
|
BYTE pbyData[2];
|
|
|
|
|
|
// calculate byte position
|
|
uByteIdx = byHashIdx / 8;
|
|
|
|
// calculate bit position
|
|
byBitMask = 1;
|
|
byBitMask <<= (byHashIdx % 8);
|
|
// turn on the bit
|
|
|
|
pbyData[0] = byBitMask;
|
|
pbyData[1] = byBitMask;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
(WORD) (MAC_REG_MAR0 + uByteIdx),
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Description:
|
|
* Write MAC Multicast Address Mask
|
|
*
|
|
* Parameters:
|
|
* In:
|
|
* uByteidx - Index of Mask
|
|
* byData - Mask Value to write
|
|
* Out:
|
|
* none
|
|
*
|
|
* Return Value: none
|
|
*
|
|
*/
|
|
VOID MACvWriteMultiAddr (PSDevice pDevice, UINT uByteIdx, BYTE byData)
|
|
{
|
|
BYTE byData1;
|
|
|
|
byData1 = byData;
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE,
|
|
(WORD) (MAC_REG_MAR0 + uByteIdx),
|
|
MESSAGE_REQUEST_MACREG,
|
|
1,
|
|
&byData1);
|
|
}
|
|
|
|
|
|
/*
|
|
* Description:
|
|
* Shut Down MAC
|
|
*
|
|
* Parameters:
|
|
* In:
|
|
* Out:
|
|
* none
|
|
*
|
|
* Return Value: TRUE if success; otherwise FALSE
|
|
*
|
|
*/
|
|
BOOL MACbShutdown (PSDevice pDevice)
|
|
{
|
|
CONTROLnsRequestOutAsyn(pDevice,
|
|
MESSAGE_TYPE_MACSHUTDOWN,
|
|
0,
|
|
0,
|
|
0,
|
|
NULL
|
|
);
|
|
return TRUE;
|
|
}
|
|
|
|
void MACvSetBBType(PSDevice pDevice,BYTE byType)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = byType;
|
|
pbyData[1] = EnCFG_BBType_MASK;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
MAC_REG_ENCFG0,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvSetMISCFifo (PSDevice pDevice, WORD wOffset, DWORD dwData)
|
|
{
|
|
BYTE pbyData[4];
|
|
|
|
if (wOffset > 273)
|
|
return;
|
|
pbyData[0] = (BYTE)dwData;
|
|
pbyData[1] = (BYTE)(dwData>>8);
|
|
pbyData[2] = (BYTE)(dwData>>16);
|
|
pbyData[3] = (BYTE)(dwData>>24);
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MISCFF,
|
|
wOffset,
|
|
0,
|
|
4,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
/*
|
|
* Description:
|
|
* Disable the Key Entry by MISCFIFO
|
|
*
|
|
* Parameters:
|
|
* In:
|
|
* dwIoBase - Base Address for MAC
|
|
*
|
|
* Out:
|
|
* none
|
|
*
|
|
* Return Value: none
|
|
*
|
|
*/
|
|
void MACvDisableKeyEntry (PSDevice pDevice, UINT uEntryIdx)
|
|
{
|
|
WORD wOffset;
|
|
BYTE byData;
|
|
|
|
|
|
byData = (BYTE) uEntryIdx;
|
|
|
|
wOffset = MISCFIFO_KEYETRY0;
|
|
wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
|
|
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
|
|
//VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, 0);
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
|
|
|
|
//issue write misc fifo command to device
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_CLRKEYENTRY,
|
|
0,
|
|
0,
|
|
1,
|
|
&byData
|
|
);
|
|
}
|
|
|
|
|
|
/*
|
|
* Description:
|
|
* Set the Key by MISCFIFO
|
|
*
|
|
* Parameters:
|
|
* In:
|
|
* dwIoBase - Base Address for MAC
|
|
*
|
|
* Out:
|
|
* none
|
|
*
|
|
* Return Value: none
|
|
*
|
|
*/
|
|
void MACvSetKeyEntry (PSDevice pDevice, WORD wKeyCtl, UINT uEntryIdx, UINT uKeyIdx, PBYTE pbyAddr, PDWORD pdwKey)
|
|
{
|
|
PBYTE pbyKey;
|
|
WORD wOffset;
|
|
DWORD dwData1,dwData2;
|
|
int ii;
|
|
BYTE pbyData[24];
|
|
|
|
|
|
|
|
|
|
|
|
if ( pDevice->byLocalID <= MAC_REVISION_A1 ) {
|
|
if ( pDevice->sMgmtObj.byCSSPK == KEY_CTL_CCMP )
|
|
return;
|
|
}
|
|
|
|
wOffset = MISCFIFO_KEYETRY0;
|
|
wOffset += (uEntryIdx * MISCFIFO_KEYENTRYSIZE);
|
|
|
|
dwData1 = 0;
|
|
dwData1 |= wKeyCtl;
|
|
dwData1 <<= 16;
|
|
dwData1 |= MAKEWORD(*(pbyAddr+4), *(pbyAddr+5));
|
|
|
|
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"1. wOffset: %d, Data: %lX, KeyCtl:%X\n", wOffset, dwData1, wKeyCtl);
|
|
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
|
|
//VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
|
|
|
|
//wOffset++;
|
|
|
|
dwData2 = 0;
|
|
dwData2 |= *(pbyAddr+3);
|
|
dwData2 <<= 8;
|
|
dwData2 |= *(pbyAddr+2);
|
|
dwData2 <<= 8;
|
|
dwData2 |= *(pbyAddr+1);
|
|
dwData2 <<= 8;
|
|
dwData2 |= *(pbyAddr+0);
|
|
|
|
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"2. wOffset: %d, Data: %lX\n", wOffset, dwData2);
|
|
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset);
|
|
//VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, dwData);
|
|
//VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
|
|
|
|
//wOffset++;
|
|
|
|
//wOffset += (uKeyIdx * 4);
|
|
/* for (ii=0;ii<4;ii++) {
|
|
// alway push 128 bits
|
|
DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"3.(%d) wOffset: %d, Data: %lX\n", ii, wOffset+ii, *pdwKey);
|
|
VNSvOutPortW(dwIoBase + MAC_REG_MISCFFNDEX, wOffset+ii);
|
|
VNSvOutPortD(dwIoBase + MAC_REG_MISCFFDATA, *pdwKey++);
|
|
VNSvOutPortW(dwIoBase + MAC_REG_MISCFFCTL, MISCFFCTL_WRITE);
|
|
}
|
|
*/
|
|
pbyKey = (PBYTE)pdwKey;
|
|
|
|
pbyData[0] = (BYTE)dwData1;
|
|
pbyData[1] = (BYTE)(dwData1>>8);
|
|
pbyData[2] = (BYTE)(dwData1>>16);
|
|
pbyData[3] = (BYTE)(dwData1>>24);
|
|
pbyData[4] = (BYTE)dwData2;
|
|
pbyData[5] = (BYTE)(dwData2>>8);
|
|
pbyData[6] = (BYTE)(dwData2>>16);
|
|
pbyData[7] = (BYTE)(dwData2>>24);
|
|
for(ii=8;ii<24;ii++)
|
|
pbyData[ii] = *pbyKey++;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_SETKEY,
|
|
wOffset,
|
|
(WORD)uKeyIdx,
|
|
24,
|
|
pbyData
|
|
);
|
|
|
|
|
|
}
|
|
|
|
|
|
void MACvRegBitsOff(PSDevice pDevice, BYTE byRegOfs, BYTE byBits)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
pbyData[0] = 0;
|
|
pbyData[1] = byBits;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
byRegOfs,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
|
|
void MACvRegBitsOn(PSDevice pDevice, BYTE byRegOfs, BYTE byBits)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = byBits;
|
|
pbyData[1] = byBits;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
byRegOfs,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvWriteWord(PSDevice pDevice, BYTE byRegOfs, WORD wData)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = (BYTE)(wData & 0xff);
|
|
pbyData[1] = (BYTE)(wData >> 8);
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE,
|
|
byRegOfs,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
|
|
}
|
|
|
|
void MACvWriteBSSIDAddress(PSDevice pDevice, PBYTE pbyEtherAddr)
|
|
{
|
|
BYTE pbyData[6];
|
|
|
|
|
|
pbyData[0] = *((PBYTE)pbyEtherAddr);
|
|
pbyData[1] = *((PBYTE)pbyEtherAddr+1);
|
|
pbyData[2] = *((PBYTE)pbyEtherAddr+2);
|
|
pbyData[3] = *((PBYTE)pbyEtherAddr+3);
|
|
pbyData[4] = *((PBYTE)pbyEtherAddr+4);
|
|
pbyData[5] = *((PBYTE)pbyEtherAddr+5);
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE,
|
|
MAC_REG_BSSID0,
|
|
MESSAGE_REQUEST_MACREG,
|
|
6,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvEnableProtectMD(PSDevice pDevice)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = EnCFG_ProtectMd;
|
|
pbyData[1] = EnCFG_ProtectMd;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
MAC_REG_ENCFG0,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvDisableProtectMD(PSDevice pDevice)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = 0;
|
|
pbyData[1] = EnCFG_ProtectMd;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
MAC_REG_ENCFG0,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvEnableBarkerPreambleMd(PSDevice pDevice)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = EnCFG_BarkerPream;
|
|
pbyData[1] = EnCFG_BarkerPream;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
MAC_REG_ENCFG2,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
void MACvDisableBarkerPreambleMd(PSDevice pDevice)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
|
|
pbyData[0] = 0;
|
|
pbyData[1] = EnCFG_BarkerPream;
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE_MASK,
|
|
MAC_REG_ENCFG2,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|
|
|
|
|
|
void MACvWriteBeaconInterval(PSDevice pDevice, WORD wInterval)
|
|
{
|
|
BYTE pbyData[2];
|
|
|
|
pbyData[0] = (BYTE) (wInterval & 0xff);
|
|
pbyData[1] = (BYTE) (wInterval >> 8);
|
|
|
|
CONTROLnsRequestOut(pDevice,
|
|
MESSAGE_TYPE_WRITE,
|
|
MAC_REG_BI,
|
|
MESSAGE_REQUEST_MACREG,
|
|
2,
|
|
pbyData
|
|
);
|
|
}
|