text: /*
   * 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: device.h
   *
   * Purpose: MAC Data structure
   *
   * Author: Tevin Chen
   *
   * Date: Mar 17, 1997
   *
   */
  
  #ifndef __DEVICE_H__
  #define __DEVICE_H__
  
  #include <linux/module.h>
  #include <linux/types.h>
  #include <linux/init.h>
  #include <linux/mm.h>
  #include <linux/errno.h>
  #include <linux/ioport.h>
  #include <linux/pci.h>
  #include <linux/kernel.h>
  #include <linux/netdevice.h>
  #include <linux/etherdevice.h>
  #include <linux/skbuff.h>
  #include <linux/delay.h>
  #include <linux/timer.h>
  #include <linux/slab.h>
  #include <linux/interrupt.h>
  #include <linux/string.h>
  #include <linux/wait.h>
  #include <linux/if_arp.h>
  #include <linux/sched.h>
  #include <asm/io.h>
  #include <linux/if.h>
  //#include <linux/config.h>
  #include <asm/uaccess.h>
  #include <linux/proc_fs.h>
  #include <linux/inetdevice.h>
  #include <linux/reboot.h>
  #ifdef SIOCETHTOOL
  #define DEVICE_ETHTOOL_IOCTL_SUPPORT
  #include <linux/ethtool.h>
  #else
  #undef DEVICE_ETHTOOL_IOCTL_SUPPORT
  #endif
  /* Include Wireless Extension definition and check version - Jean II */
  #include <linux/wireless.h>
  #include <net/iw_handler.h>	// New driver API
  
  //2008-0409-07, <Add> by Einsn Liu
  #ifndef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
  #define WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
  #endif
  //2008-4-14<add> by chester for led issue
  //#define FOR_LED_ON_NOTEBOOK
  //
  
  
  //
  // device specific
  //
  
  #include "device_cfg.h"
  #include "ttype.h"
  #include "80211hdr.h"
  #include "tether.h"
  #include "wmgr.h"
  #include "wcmd.h"
  #include "mib.h"
  #include "srom.h"
  #include "rc4.h"
  #include "desc.h"
  #include "key.h"
  #include "mac.h"
  
  //PLICE_DEBUG->
  //#define		THREAD
  
  //#define	TASK_LET
  //PLICE_DEBUG<-
  
  
  /*---------------------  Export Definitions -------------------------*/
  
  #define MAC_MAX_CONTEXT_REG     (256+128)
  
  #define MAX_MULTICAST_ADDRESS_NUM       32
  #define MULTICAST_ADDRESS_LIST_SIZE     (MAX_MULTICAST_ADDRESS_NUM * U_ETHER_ADDR_LEN)
  
  
  //#define OP_MODE_INFRASTRUCTURE  0
  //#define OP_MODE_ADHOC           1
  //#define OP_MODE_AP              2
  
  #define DUPLICATE_RX_CACHE_LENGTH       5
  
  #define NUM_KEY_ENTRY                   11
  
  #define TX_WEP_NONE                     0
  #define TX_WEP_OTF                      1
  #define TX_WEP_SW                       2
  #define TX_WEP_SWOTP                    3
  #define TX_WEP_OTPSW                    4
  #define TX_WEP_SW232                    5
  
  #define KEYSEL_WEP40                    0
  #define KEYSEL_WEP104                   1
  #define KEYSEL_TKIP                     2
  #define KEYSEL_CCMP                     3
  
  
  
  #define AUTO_FB_NONE            0
  #define AUTO_FB_0               1
  #define AUTO_FB_1               2
  
  #define FB_RATE0                0
  #define FB_RATE1                1
  
  // Antenna Mode
  #define ANT_A                   0
  #define ANT_B                   1
  #define ANT_DIVERSITY           2
  #define ANT_RXD_TXA             3
  #define ANT_RXD_TXB             4
  #define ANT_UNKNOWN             0xFF
  
  #define MAXCHECKHANGCNT         4
  
  #define BB_VGA_LEVEL            4
  #define BB_VGA_CHANGE_THRESHOLD 16
  
  
  
  #ifndef RUN_AT
  #define RUN_AT(x)                       (jiffies+(x))
  #endif
  
  // DMA related
  #define RESERV_AC0DMA                   4
  
  
  // BUILD OBJ mode
  
  
  #define	AVAIL_TD(p,q)	((p)->sOpts.nTxDescs[(q)]-((p)->iTDUsed[(q)]))
  
  //PLICE_DEBUG ->
  #define	NUM				64
  //PLICE_DEUBG <-
  
  
  
  #define PRIVATE_Message                 0
  
  /*---------------------  Export Types  ------------------------------*/
  
  
  #define DBG_PRT(l, p, args...) {if (l<=msglevel) printk( p ,##args);}
  #define PRINT_K(p, args...) {if (PRIVATE_Message) printk( p ,##args);}
  
  //0:11A 1:11B 2:11G
  typedef enum _VIA_BB_TYPE
  {
      BB_TYPE_11A=0,
      BB_TYPE_11B,
      BB_TYPE_11G
  } VIA_BB_TYPE, *PVIA_BB_TYPE;
  
  //0:11a,1:11b,2:11gb(only CCK in BasicRate),3:11ga(OFDM in Basic Rate)
  typedef enum _VIA_PKT_TYPE
  {
      PK_TYPE_11A=0,
      PK_TYPE_11B,
      PK_TYPE_11GB,
      PK_TYPE_11GA
  } VIA_PKT_TYPE, *PVIA_PKT_TYPE;
  
  
  typedef enum __device_msg_level {
      MSG_LEVEL_ERR=0,            //Errors that will cause abnormal operation.
      MSG_LEVEL_NOTICE=1,         //Some errors need users to be notified.
      MSG_LEVEL_INFO=2,           //Normal message.
      MSG_LEVEL_VERBOSE=3,        //Will report all trival errors.
      MSG_LEVEL_DEBUG=4           //Only for debug purpose.
  } DEVICE_MSG_LEVEL, *PDEVICE_MSG_LEVEL;
  
  typedef enum __device_init_type {
      DEVICE_INIT_COLD=0,         // cold init
      DEVICE_INIT_RESET,          // reset init or Dx to D0 power remain init
      DEVICE_INIT_DXPL            // Dx to D0 power lost init
  } DEVICE_INIT_TYPE, *PDEVICE_INIT_TYPE;
  
  
  //++ NDIS related
  
  #define MAX_BSSIDINFO_4_PMKID   16
  #define MAX_PMKIDLIST           5
  //Flags for PMKID Candidate list structure
  #define NDIS_802_11_PMKID_CANDIDATE_PREAUTH_ENABLED	0x01
  
  // PMKID Structures
  typedef UCHAR   NDIS_802_11_PMKID_VALUE[16];
  
  
  typedef enum _NDIS_802_11_WEP_STATUS
  {
      Ndis802_11WEPEnabled,
      Ndis802_11Encryption1Enabled = Ndis802_11WEPEnabled,
      Ndis802_11WEPDisabled,
      Ndis802_11EncryptionDisabled = Ndis802_11WEPDisabled,
      Ndis802_11WEPKeyAbsent,
      Ndis802_11Encryption1KeyAbsent = Ndis802_11WEPKeyAbsent,
      Ndis802_11WEPNotSupported,
      Ndis802_11EncryptionNotSupported = Ndis802_11WEPNotSupported,
      Ndis802_11Encryption2Enabled,
      Ndis802_11Encryption2KeyAbsent,
      Ndis802_11Encryption3Enabled,
      Ndis802_11Encryption3KeyAbsent
  } NDIS_802_11_WEP_STATUS, *PNDIS_802_11_WEP_STATUS,
    NDIS_802_11_ENCRYPTION_STATUS, *PNDIS_802_11_ENCRYPTION_STATUS;
  
  
  typedef enum _NDIS_802_11_STATUS_TYPE
  {
      Ndis802_11StatusType_Authentication,
      Ndis802_11StatusType_MediaStreamMode,
      Ndis802_11StatusType_PMKID_CandidateList,
      Ndis802_11StatusTypeMax    // not a real type, defined as an upper bound
  } NDIS_802_11_STATUS_TYPE, *PNDIS_802_11_STATUS_TYPE;
  
  //Added new types for PMKID Candidate lists.
  typedef struct _PMKID_CANDIDATE {
      NDIS_802_11_MAC_ADDRESS BSSID;
      ULONG Flags;
  } PMKID_CANDIDATE, *PPMKID_CANDIDATE;
  
  
  typedef struct _BSSID_INFO
  {
      NDIS_802_11_MAC_ADDRESS BSSID;
      NDIS_802_11_PMKID_VALUE PMKID;
  } BSSID_INFO, *PBSSID_INFO;
  
  typedef struct tagSPMKID {
      ULONG Length;
      ULONG BSSIDInfoCount;
      BSSID_INFO BSSIDInfo[MAX_BSSIDINFO_4_PMKID];
  } SPMKID, *PSPMKID;
  
  typedef struct tagSPMKIDCandidateEvent {
      NDIS_802_11_STATUS_TYPE     StatusType;
      ULONG Version;       // Version of the structure
      ULONG NumCandidates; // No. of pmkid candidates
      PMKID_CANDIDATE CandidateList[MAX_PMKIDLIST];
  } SPMKIDCandidateEvent, *PSPMKIDCandidateEvent;
  
  //--
  
  //++ 802.11h related
  #define MAX_QUIET_COUNT     8
  
  typedef struct tagSQuietControl {
      BOOL        bEnable;
      DWORD       dwStartTime;
      BYTE        byPeriod;
      WORD        wDuration;
  } SQuietControl, *PSQuietControl;
  
  //--
  typedef struct __chip_info_tbl{
      CHIP_TYPE   chip_id;
      char*       name;
      int         io_size;
      int         nTxQueue;
      U32         flags;
  } CHIP_INFO, *PCHIP_INFO;
  
  
  typedef enum {
      OWNED_BY_HOST=0,
      OWNED_BY_NIC=1
  } DEVICE_OWNER_TYPE, *PDEVICE_OWNER_TYPE;
  
  
  // The receive duplicate detection cache entry
  typedef struct tagSCacheEntry{
      WORD        wFmSequence;
      BYTE        abyAddr2[U_ETHER_ADDR_LEN];
  } SCacheEntry, *PSCacheEntry;
  
  typedef struct tagSCache{
  /* The receive cache is updated circularly.  The next entry to be written is
   * indexed by the "InPtr".
  */
      UINT            uInPtr;         // Place to use next
      SCacheEntry     asCacheEntry[DUPLICATE_RX_CACHE_LENGTH];
  } SCache, *PSCache;
  
  #define CB_MAX_RX_FRAG                 64
  // DeFragment Control Block, used for collecting fragments prior to reassembly
  typedef struct tagSDeFragControlBlock
  {
      WORD            wSequence;
      WORD            wFragNum;
      BYTE            abyAddr2[U_ETHER_ADDR_LEN];
  	UINT            uLifetime;
      struct sk_buff* skb;
      PBYTE           pbyRxBuffer;
      UINT            cbFrameLength;
      BOOL            bInUse;
  } SDeFragControlBlock, *PSDeFragControlBlock;
  
  
  
  //flags for options
  #define     DEVICE_FLAGS_IP_ALIGN        0x00000001UL
  #define     DEVICE_FLAGS_PREAMBLE_TYPE   0x00000002UL
  #define     DEVICE_FLAGS_OP_MODE         0x00000004UL
  #define     DEVICE_FLAGS_PS_MODE         0x00000008UL
  #define		DEVICE_FLAGS_80211h_MODE	 0x00000010UL
  #define		DEVICE_FLAGS_DiversityANT	 0x00000020UL
  
  //flags for driver status
  #define     DEVICE_FLAGS_OPENED          0x00010000UL
  #define     DEVICE_FLAGS_WOL_ENABLED     0x00080000UL
  //flags for capbilities
  #define     DEVICE_FLAGS_TX_ALIGN        0x01000000UL
  #define     DEVICE_FLAGS_HAVE_CAM        0x02000000UL
  #define     DEVICE_FLAGS_FLOW_CTRL       0x04000000UL
  
  //flags for MII status
  #define     DEVICE_LINK_FAIL             0x00000001UL
  #define     DEVICE_SPEED_10              0x00000002UL
  #define     DEVICE_SPEED_100             0x00000004UL
  #define     DEVICE_SPEED_1000            0x00000008UL
  #define     DEVICE_DUPLEX_FULL           0x00000010UL
  #define     DEVICE_AUTONEG_ENABLE        0x00000020UL
  #define     DEVICE_FORCED_BY_EEPROM      0x00000040UL
  //for device_set_media_duplex
  #define     DEVICE_LINK_CHANGE           0x00000001UL
  
  
  //PLICE_DEBUG->
  
  
  typedef	struct _RxManagementQueue
  {
  	int	packet_num;
  	int	head,tail;
  	PSRxMgmtPacket	Q[NUM];
  } RxManagementQueue,*PSRxManagementQueue;
  
  
  
  //PLICE_DEBUG<-
  
  
  typedef struct __device_opt {
      int         nRxDescs0;    //Number of RX descriptors0
      int         nRxDescs1;    //Number of RX descriptors1
      int         nTxDescs[2];  //Number of TX descriptors 0, 1
      int         int_works;    //interrupt limits
      int         rts_thresh;   //rts threshold
      int         frag_thresh;
      int         data_rate;
      int         channel_num;
      int         short_retry;
      int         long_retry;
      int         bbp_type;
      U32         flags;
  } OPTIONS, *POPTIONS;
  
  
  typedef struct __device_info {
      struct __device_info*        next;
      struct __device_info*        prev;
  
      struct pci_dev*             pcid;
  
  #if CONFIG_PM
      u32                         pci_state[16];
  #endif
  
  // netdev
      struct net_device*          dev;
      struct net_device*          next_module;
      struct net_device_stats     stats;
  
  //dma addr, rx/tx pool
      dma_addr_t                  pool_dma;
      dma_addr_t                  rd0_pool_dma;
      dma_addr_t                  rd1_pool_dma;
  
      dma_addr_t                  td0_pool_dma;
      dma_addr_t                  td1_pool_dma;
  
      dma_addr_t                  tx_bufs_dma0;
      dma_addr_t                  tx_bufs_dma1;
      dma_addr_t                  tx_beacon_dma;
  
      PBYTE                       tx0_bufs;
      PBYTE                       tx1_bufs;
      PBYTE                       tx_beacon_bufs;
  
      CHIP_TYPE                   chip_id;
  
      U32                         PortOffset;
      DWORD                       dwIsr;
      U32                         memaddr;
      U32                         ioaddr;
      U32                         io_size;
  
      BYTE                        byRevId;
      WORD                        SubSystemID;
      WORD                        SubVendorID;
  
      int                         nTxQueues;
      volatile int                iTDUsed[TYPE_MAXTD];
  
      volatile PSTxDesc           apCurrTD[TYPE_MAXTD];
      volatile PSTxDesc           apTailTD[TYPE_MAXTD];
  
      volatile PSTxDesc           apTD0Rings;
      volatile PSTxDesc           apTD1Rings;
  
      volatile PSRxDesc           aRD0Ring;
      volatile PSRxDesc           aRD1Ring;
      volatile PSRxDesc           pCurrRD[TYPE_MAXRD];
      SCache                      sDupRxCache;
  
      SDeFragControlBlock         sRxDFCB[CB_MAX_RX_FRAG];
      UINT                        cbDFCB;
      UINT                        cbFreeDFCB;
      UINT                        uCurrentDFCBIdx;
  
      OPTIONS                     sOpts;
  
      U32                         flags;
  
      U32                         rx_buf_sz;
      int                         multicast_limit;
      BYTE                        byRxMode;
  
      spinlock_t                  lock;
  //PLICE_DEBUG->
  	struct	tasklet_struct 		RxMngWorkItem;
  	RxManagementQueue	rxManeQueue;
  //PLICE_DEBUG<-
  //PLICE_DEBUG ->
  	pid_t				MLMEThr_pid;
  	struct 	completion	notify;
  	struct 	semaphore	mlme_semaphore;
  //PLICE_DEBUG <-
  
  
      U32                         rx_bytes;
  
      // Version control
      BYTE                        byLocalID;
      BYTE                        byRFType;
  
      BYTE                        byMaxPwrLevel;
      BYTE                        byZoneType;
      BOOL                        bZoneRegExist;
     BYTE                        byOriginalZonetype;
      BYTE                        abyMacContext[MAC_MAX_CONTEXT_REG];
      BOOL                        bLinkPass;          // link status: OK or fail
      BYTE                        abyCurrentNetAddr[U_ETHER_ADDR_LEN];
  
      // Adapter statistics
      SStatCounter                scStatistic;
      // 802.11 counter
      SDot11Counters              s802_11Counter;
  
  
      // 802.11 management
      PSMgmtObject                pMgmt;
      SMgmtObject                 sMgmtObj;
  
      // 802.11 MAC specific
      UINT                        uCurrRSSI;
      BYTE                        byCurrSQ;
  
      DWORD                       dwTxAntennaSel;
      DWORD                       dwRxAntennaSel;
      BYTE                        byAntennaCount;
      BYTE                        byRxAntennaMode;
      BYTE                        byTxAntennaMode;
      BOOL                        bTxRxAntInv;
  
      PBYTE                       pbyTmpBuff;
      UINT                        uSIFS;    //Current SIFS
      UINT                        uDIFS;    //Current DIFS
      UINT                        uEIFS;    //Current EIFS
      UINT                        uSlot;    //Current SlotTime
      UINT                        uCwMin;   //Current CwMin
      UINT                        uCwMax;   //CwMax is fixed on 1023.
      // PHY parameter
      BYTE                        bySIFS;
      BYTE                        byDIFS;
      BYTE                        byEIFS;
      BYTE                        bySlot;
      BYTE                        byCWMaxMin;
      CARD_PHY_TYPE               eCurrentPHYType;
  
  
      VIA_BB_TYPE                 byBBType; //0: 11A, 1:11B, 2:11G
      VIA_PKT_TYPE                byPacketType; //0:11a,1:11b,2:11gb(only CCK in BasicRate),3:11ga(OFDM in Basic Rate)
      WORD                        wBasicRate;
      BYTE                        byACKRate;
      BYTE                        byTopOFDMBasicRate;
      BYTE                        byTopCCKBasicRate;
  
      BYTE                        byMinChannel;
      BYTE                        byMaxChannel;
      UINT                        uConnectionRate;
  
      BYTE                        byPreambleType;
      BYTE                        byShortPreamble;
  
      WORD                        wCurrentRate;
      WORD                        wRTSThreshold;
      WORD                        wFragmentationThreshold;
      BYTE                        byShortRetryLimit;
      BYTE                        byLongRetryLimit;
      CARD_OP_MODE                eOPMode;
      BYTE                        byOpMode;
      BOOL                        bBSSIDFilter;
      WORD                        wMaxTransmitMSDULifetime;
      BYTE                        abyBSSID[U_ETHER_ADDR_LEN];
      BYTE                        abyDesireBSSID[U_ETHER_ADDR_LEN];
      WORD                        wCTSDuration;       // update while speed change
      WORD                        wACKDuration;       // update while speed change
      WORD                        wRTSTransmitLen;    // update while speed change
      BYTE                        byRTSServiceField;  // update while speed change
      BYTE                        byRTSSignalField;   // update while speed change
  
      DWORD                       dwMaxReceiveLifetime;       // dot11MaxReceiveLifetime
  
      BOOL                        bCCK;
      BOOL                        bEncryptionEnable;
      BOOL                        bLongHeader;
      BOOL                        bShortSlotTime;
      BOOL                        bProtectMode;
      BOOL                        bNonERPPresent;
      BOOL                        bBarkerPreambleMd;
  
      BYTE                        byERPFlag;
      WORD                        wUseProtectCntDown;
  
      BOOL                        bRadioControlOff;
      BOOL                        bRadioOff;
      BOOL                    bEnablePSMode;
      WORD                    wListenInterval;
      BOOL                    bPWBitOn;
      WMAC_POWER_MODE         ePSMode;
  
  
      // GPIO Radio Control
      BYTE                    byRadioCtl;
      BYTE                    byGPIO;
      BOOL                    bHWRadioOff;
      BOOL                    bPrvActive4RadioOFF;
      BOOL                    bGPIOBlockRead;
  
      // Beacon releated
      WORD                    wSeqCounter;
      WORD                    wBCNBufLen;
      BOOL                    bBeaconBufReady;
      BOOL                    bBeaconSent;
      BOOL                    bIsBeaconBufReadySet;
      UINT                    cbBeaconBufReadySetCnt;
      BOOL                    bFixRate;
      BYTE                    byCurrentCh;
      UINT                    uScanTime;
  
      CMD_STATE               eCommandState;
  
      CMD_CODE                eCommand;
      BOOL                    bBeaconTx;
  
      BOOL                    bStopBeacon;
      BOOL                    bStopDataPkt;
      BOOL                    bStopTx0Pkt;
      UINT                    uAutoReConnectTime;
  
      // 802.11 counter
  
      CMD_ITEM                eCmdQueue[CMD_Q_SIZE];
      UINT                    uCmdDequeueIdx;
      UINT                    uCmdEnqueueIdx;
      UINT                    cbFreeCmdQueue;
      BOOL                    bCmdRunning;
      BOOL                    bCmdClear;
  
  
  
      BOOL                    bRoaming;
      //WOW
      BYTE                    abyIPAddr[4];
  
      ULONG                   ulTxPower;
      NDIS_802_11_WEP_STATUS  eEncryptionStatus;
      BOOL                    bTransmitKey;
  //2007-0925-01<Add>by MikeLiu
  //mike add :save old Encryption
      NDIS_802_11_WEP_STATUS  eOldEncryptionStatus;
  
      SKeyManagement          sKey;
      DWORD                   dwIVCounter;
  
      QWORD                   qwPacketNumber; //For CCMP and TKIP as TSC(6 bytes)
      UINT                    uCurrentWEPMode;
  
      RC4Ext                  SBox;
      BYTE                    abyPRNG[WLAN_WEPMAX_KEYLEN+3];
      BYTE                    byKeyIndex;
      UINT                    uKeyLength;
      BYTE                    abyKey[WLAN_WEP232_KEYLEN];
  
      BOOL                    bAES;
      BYTE                    byCntMeasure;
  
      // for AP mode
      UINT                    uAssocCount;
      BOOL                    bMoreData;
  
      // QoS
      BOOL                    bGrpAckPolicy;
  
      // for OID_802_11_ASSOCIATION_INFORMATION
      BOOL                    bAssocInfoSet;
  
  
      BYTE                    byAutoFBCtrl;
  
      BOOL                    bTxMICFail;
      BOOL                    bRxMICFail;
  
  
      UINT                    uRATEIdx;
  
  
      // For Update BaseBand VGA Gain Offset
      BOOL                    bUpdateBBVGA;
      UINT                    uBBVGADiffCount;
      BYTE                    byBBVGANew;
      BYTE                    byBBVGACurrent;
      BYTE                    abyBBVGA[BB_VGA_LEVEL];
      LONG                    ldBmThreshold[BB_VGA_LEVEL];
  
      BYTE                    byBBPreEDRSSI;
      BYTE                    byBBPreEDIndex;
  
  
      BOOL                    bRadioCmd;
      DWORD                   dwDiagRefCount;
  
      // For FOE Tuning
      BYTE                    byFOETuning;
  
      // For Auto Power Tunning
  
      BYTE                    byAutoPwrTunning;
      SHORT                   sPSetPointCCK;
      SHORT                   sPSetPointOFDMG;
      SHORT                   sPSetPointOFDMA;
      LONG                    lPFormulaOffset;
      SHORT                   sPThreshold;
      CHAR                    cAdjustStep;
      CHAR                    cMinTxAGC;
  
      // For RF Power table
      BYTE                    byCCKPwr;
      BYTE                    byOFDMPwrG;
      BYTE                    byCurPwr;
      I8                      byCurPwrdBm;
      BYTE                    abyCCKPwrTbl[CB_MAX_CHANNEL_24G+1];
      BYTE                    abyOFDMPwrTbl[CB_MAX_CHANNEL+1];
      I8                      abyCCKDefaultPwr[CB_MAX_CHANNEL_24G+1];
      I8                      abyOFDMDefaultPwr[CB_MAX_CHANNEL+1];
      I8                      abyRegPwr[CB_MAX_CHANNEL+1];
      I8                      abyLocalPwr[CB_MAX_CHANNEL+1];
  
  
      // BaseBand Loopback Use
      BYTE                    byBBCR4d;
      BYTE                    byBBCRc9;
      BYTE                    byBBCR88;
      BYTE                    byBBCR09;
  
      // command timer
      struct timer_list       sTimerCommand;
  #ifdef TxInSleep
       struct timer_list       sTimerTxData;
       ULONG                       nTxDataTimeCout;
       BOOL  fTxDataInSleep;
       BOOL  IsTxDataTrigger;
  #endif
  
  #ifdef WPA_SM_Transtatus
      BOOL  fWPA_Authened;           //is WPA/WPA-PSK or WPA2/WPA2-PSK authen??
  #endif
      BYTE            byReAssocCount;   //mike add:re-association retry times!
      BYTE            byLinkWaitCount;
  
  
      BYTE                    abyNodeName[17];
  
      BOOL                    bDiversityRegCtlON;
      BOOL                    bDiversityEnable;
      ULONG                   ulDiversityNValue;
      ULONG                   ulDiversityMValue;
      BYTE                    byTMax;
      BYTE                    byTMax2;
      BYTE                    byTMax3;
      ULONG                   ulSQ3TH;
  
  // ANT diversity
      ULONG                   uDiversityCnt;
      BYTE                    byAntennaState;
      ULONG                   ulRatio_State0;
      ULONG                   ulRatio_State1;
  
      //SQ3 functions for antenna diversity
      struct timer_list           TimerSQ3Tmax1;
      struct timer_list           TimerSQ3Tmax2;
      struct timer_list           TimerSQ3Tmax3;
  
  
      ULONG                   uNumSQ3[MAX_RATE];
      WORD                    wAntDiversityMaxRate;
  
  
      SEthernetHeader         sTxEthHeader;
      SEthernetHeader         sRxEthHeader;
      BYTE                    abyBroadcastAddr[U_ETHER_ADDR_LEN];
      BYTE                    abySNAP_RFC1042[U_ETHER_ADDR_LEN];
      BYTE                    abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN];
       BYTE                        abyEEPROM[EEP_MAX_CONTEXT_SIZE];  //DWORD alignment
      // Pre-Authentication & PMK cache
      SPMKID                  gsPMKID;
      SPMKIDCandidateEvent    gsPMKIDCandidate;
  
  
      // for 802.11h
      BOOL                    b11hEnable;
      BYTE                    abyCountryCode[3];
      // for 802.11h DFS
      UINT                    uNumOfMeasureEIDs;
      PWLAN_IE_MEASURE_REQ    pCurrMeasureEID;
      BOOL                    bMeasureInProgress;
      BYTE                    byOrgChannel;
      BYTE                    byOrgRCR;
      DWORD                   dwOrgMAR0;
      DWORD                   dwOrgMAR4;
      BYTE                    byBasicMap;
      BYTE                    byCCAFraction;
      BYTE                    abyRPIs[8];
      DWORD                   dwRPIs[8];
      BOOL                    bChannelSwitch;
      BYTE                    byNewChannel;
      BYTE                    byChannelSwitchCount;
      BOOL                    bQuietEnable;
      BOOL                    bEnableFirstQuiet;
      BYTE                    byQuietStartCount;
      UINT                    uQuietEnqueue;
      DWORD                   dwCurrentQuietEndTime;
      SQuietControl           sQuiet[MAX_QUIET_COUNT];
      // for 802.11h TPC
      BOOL                    bCountryInfo5G;
      BOOL                    bCountryInfo24G;
  
      WORD                    wBeaconInterval;
  
      //WPA supplicant deamon
  	struct net_device       *wpadev;
  	BOOL                    bWPADEVUp;
      struct sk_buff          *skb;
  #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
  /*
          BOOL                 bwextstep0;
          BOOL                 bwextstep1;
          BOOL                 bwextstep2;
          BOOL                 bwextstep3;
          */
          UINT                   bwextcount;
          BOOL                 bWPASuppWextEnabled;
  #endif
  
      //--
  #ifdef HOSTAP
      // user space daemon: hostapd, is used for HOSTAP
  	BOOL                    bEnableHostapd;
  	BOOL                    bEnable8021x;
  	BOOL                    bEnableHostWEP;
  	struct net_device       *apdev;
  	int (*tx_80211)(struct sk_buff *skb, struct net_device *dev);
  #endif
      UINT                    uChannel;
      BOOL                    bMACSuspend;
  
  	struct iw_statistics	wstats;		// wireless stats
      BOOL                    bCommit;
  
  } DEVICE_INFO, *PSDevice;
  
  
  //PLICE_DEBUG->
  
  
   inline  static	VOID   EnQueue (PSDevice pDevice,PSRxMgmtPacket  pRxMgmtPacket)
  {
  	//printk("Enter EnQueue:tail is %d\n",pDevice->rxManeQueue.tail);
  	if ((pDevice->rxManeQueue.tail+1) % NUM == pDevice->rxManeQueue.head)
  	{
  		//printk("Queue is Full,tail is %d\n",pDevice->rxManeQueue.tail);
  		return ;
  	}
  	else
  	{
  		pDevice->rxManeQueue.tail = (pDevice->rxManeQueue.tail+1)% NUM;
  		pDevice->rxManeQueue.Q[pDevice->rxManeQueue.tail] = pRxMgmtPacket;
  		pDevice->rxManeQueue.packet_num++;
  		//printk("packet num is %d\n",pDevice->rxManeQueue.packet_num);
  	}
  }
  
  
  
  
  	inline  static  PSRxMgmtPacket DeQueue (PSDevice pDevice)
  {
  	PSRxMgmtPacket  pRxMgmtPacket;
  	if (pDevice->rxManeQueue.tail == pDevice->rxManeQueue.head)
  	{
  		printk("Queue is Empty\n");
  		return NULL;
  	}
  	else
  	{
  		int	x;
  		//x=pDevice->rxManeQueue.head = (pDevice->rxManeQueue.head+1)%NUM;
  		pDevice->rxManeQueue.head = (pDevice->rxManeQueue.head+1)%NUM;
  		x = pDevice->rxManeQueue.head;
  		//printk("Enter DeQueue:head is %d\n",x);
  		pRxMgmtPacket = pDevice->rxManeQueue.Q[x];
  		pDevice->rxManeQueue.packet_num--;
  		return pRxMgmtPacket;
  	}
  }
  
  VOID	InitRxManagementQueue(PSDevice   pDevice);
  
  
  
  //PLICE_DEBUG<-
  
  
  
  
  
  
  inline static BOOL device_get_ip(PSDevice pInfo) {
      struct in_device* in_dev=(struct in_device*) pInfo->dev->ip_ptr;
      struct in_ifaddr* ifa;
  
      if (in_dev!=NULL) {
          ifa=(struct in_ifaddr*) in_dev->ifa_list;
          if (ifa!=NULL) {
              memcpy(pInfo->abyIPAddr,&ifa->ifa_address,4);
              return TRUE;
          }
      }
      return FALSE;
  }
  
  
  
  static inline PDEVICE_RD_INFO alloc_rd_info(void) {
      PDEVICE_RD_INFO  ptr;
      if ((ptr = (PDEVICE_RD_INFO)kmalloc((int)sizeof(DEVICE_RD_INFO), (int)GFP_ATOMIC)) == NULL)
          return NULL;
      else {
          memset(ptr,0,sizeof(DEVICE_RD_INFO));
          return ptr;
      }
  }
  
  static inline PDEVICE_TD_INFO alloc_td_info(void) {
      PDEVICE_TD_INFO  ptr;
      if ((ptr = (PDEVICE_TD_INFO)kmalloc((int)sizeof(DEVICE_TD_INFO), (int)GFP_ATOMIC))==NULL)
          return NULL;
      else {
          memset(ptr,0,sizeof(DEVICE_TD_INFO));
          return ptr;
      }
  }
  
  /*---------------------  Export Functions  --------------------------*/
  
  BOOL device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, UINT uNodeIndex);
  BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF);
  int Config_FileOperation(PSDevice pDevice,BOOL fwrite,unsigned char *Parameter);
  #endif
  
  
  