drivers/staging/vt6655/device_main.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  * File: device_main.c
  20  *
  21  * Purpose: driver entry for initial, open, close, tx and rx.
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: Jan 8, 2003
  26  *
  27  * Functions:
  28  *
  29  *   vt6655_probe - module initial (insmod) driver entry
  30  *   vt6655_remove - module remove entry
  31  *   vt6655_init_info - device structure resource allocation function
  32  *   device_free_info - device structure resource free function
  33  *   device_get_pci_info - get allocated pci io/mem resource
  34  *   device_print_info - print out resource
  35  *   device_open - allocate dma/descripter resource & initial mac/bbp function
  36  *   device_xmit - asynchrous data tx function
  37  *   device_intr - interrupt handle function
  38  *   device_set_multi - set mac filter
  39  *   device_ioctl - ioctl entry
  40  *   device_close - shutdown mac/bbp & free dma/descripter resource
  41  *   device_rx_srv - rx service function
  42  *   device_receive_frame - rx data function
  43  *   device_alloc_rx_buf - rx buffer pre-allocated function
  44  *   device_alloc_frag_buf - rx fragement pre-allocated function
  45  *   device_free_tx_buf - free tx buffer function
  46  *   device_free_frag_buf- free de-fragement buffer
  47  *   device_dma0_tx_80211- tx 802.11 frame via dma0
  48  *   device_dma0_xmit- tx PS bufferred frame via dma0
  49  *   device_init_rd0_ring- initial rd dma0 ring
  50  *   device_init_rd1_ring- initial rd dma1 ring
  51  *   device_init_td0_ring- initial tx dma0 ring buffer
  52  *   device_init_td1_ring- initial tx dma1 ring buffer
  53  *   device_init_registers- initial MAC & BBP & RF internal registers.
  54  *   device_init_rings- initial tx/rx ring buffer
  55  *   device_init_defrag_cb- initial & allocate de-fragement buffer.
  56  *   device_free_rings- free all allocated ring buffer
  57  *   device_tx_srv- tx interrupt service function
  58  *
  59  * Revision History:
  60  */
  61 #undef __NO_VERSION__
  62
  63 #include <linux/file.h>
  64 #include "device.h"
  65 #include "card.h"
  66 #include "channel.h"
  67 #include "baseband.h"
  68 #include "mac.h"
  69 #include "tether.h"
  70 #include "wmgr.h"
  71 #include "wctl.h"
  72 #include "power.h"
  73 #include "wcmd.h"
  74 #include "iocmd.h"
  75 #include "tcrc.h"
  76 #include "rxtx.h"
  77 #include "wroute.h"
  78 #include "bssdb.h"
  79 #include "hostap.h"
  80 #include "wpactl.h"
  81 #include "ioctl.h"
  82 #include "iwctl.h"
  83 #include "dpc.h"
  84 #include "datarate.h"
  85 #include "rf.h"
  86 #include "iowpa.h"
  87 #include <linux/delay.h>
  88 #include <linux/kthread.h>
  89 #include <linux/slab.h>
  90
  91 /*---------------------  Static Definitions -------------------------*/
  92 static int          msglevel                =   MSG_LEVEL_INFO;
  93
  94 //
  95 // Define module options
  96 //
  97 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
  98 MODULE_LICENSE("GPL");
  99 MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
 100
 101 static int mlme_kill;
 102
 103 #define DEVICE_PARAM(N, D)
 104
 105 #define RX_DESC_MIN0     16
 106 #define RX_DESC_MAX0     128
 107 #define RX_DESC_DEF0     32
 108 DEVICE_PARAM(RxDescriptors0, "Number of receive descriptors0");
 109
 110 #define RX_DESC_MIN1     16
 111 #define RX_DESC_MAX1     128
 112 #define RX_DESC_DEF1     32
 113 DEVICE_PARAM(RxDescriptors1, "Number of receive descriptors1");
 114
 115 #define TX_DESC_MIN0     16
 116 #define TX_DESC_MAX0     128
 117 #define TX_DESC_DEF0     32
 118 DEVICE_PARAM(TxDescriptors0, "Number of transmit descriptors0");
 119
 120 #define TX_DESC_MIN1     16
 121 #define TX_DESC_MAX1     128
 122 #define TX_DESC_DEF1     64
 123 DEVICE_PARAM(TxDescriptors1, "Number of transmit descriptors1");
 124
 125 #define IP_ALIG_DEF     0
 126 /* IP_byte_align[] is used for IP header unsigned long byte aligned
 127    0: indicate the IP header won't be unsigned long byte aligned.(Default) .
 128    1: indicate the IP header will be unsigned long byte aligned.
 129    In some environment, the IP header should be unsigned long byte aligned,
 130    or the packet will be droped when we receive it. (eg: IPVS)
 131 */
 132 DEVICE_PARAM(IP_byte_align, "Enable IP header dword aligned");
 133
 134 #define INT_WORKS_DEF   20
 135 #define INT_WORKS_MIN   10
 136 #define INT_WORKS_MAX   64
 137
 138 DEVICE_PARAM(int_works, "Number of packets per interrupt services");
 139
 140 #define CHANNEL_MIN     1
 141 #define CHANNEL_MAX     14
 142 #define CHANNEL_DEF     6
 143
 144 DEVICE_PARAM(Channel, "Channel number");
 145
 146 /* PreambleType[] is the preamble length used for transmit.
 147    0: indicate allows long preamble type
 148    1: indicate allows short preamble type
 149 */
 150
 151 #define PREAMBLE_TYPE_DEF     1
 152
 153 DEVICE_PARAM(PreambleType, "Preamble Type");
 154
 155 #define RTS_THRESH_MIN     512
 156 #define RTS_THRESH_MAX     2347
 157 #define RTS_THRESH_DEF     2347
 158
 159 DEVICE_PARAM(RTSThreshold, "RTS threshold");
 160
 161 #define FRAG_THRESH_MIN     256
 162 #define FRAG_THRESH_MAX     2346
 163 #define FRAG_THRESH_DEF     2346
 164
 165 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
 166
 167 #define DATA_RATE_MIN     0
 168 #define DATA_RATE_MAX     13
 169 #define DATA_RATE_DEF     13
 170 /* datarate[] index
 171    0: indicate 1 Mbps   0x02
 172    1: indicate 2 Mbps   0x04
 173    2: indicate 5.5 Mbps 0x0B
 174    3: indicate 11 Mbps  0x16
 175    4: indicate 6 Mbps   0x0c
 176    5: indicate 9 Mbps   0x12
 177    6: indicate 12 Mbps  0x18
 178    7: indicate 18 Mbps  0x24
 179    8: indicate 24 Mbps  0x30
 180    9: indicate 36 Mbps  0x48
 181    10: indicate 48 Mbps  0x60
 182    11: indicate 54 Mbps  0x6c
 183    12: indicate 72 Mbps  0x90
 184    13: indicate auto rate
 185 */
 186
 187 DEVICE_PARAM(ConnectionRate, "Connection data rate");
 188
 189 #define OP_MODE_DEF     0
 190
 191 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
 192
 193 /* OpMode[] is used for transmit.
 194    0: indicate infrastruct mode used
 195    1: indicate adhoc mode used
 196    2: indicate AP mode used
 197 */
 198
 199 /* PSMode[]
 200    0: indicate disable power saving mode
 201    1: indicate enable power saving mode
 202 */
 203
 204 #define PS_MODE_DEF     0
 205
 206 DEVICE_PARAM(PSMode, "Power saving mode");
 207
 208 #define SHORT_RETRY_MIN     0
 209 #define SHORT_RETRY_MAX     31
 210 #define SHORT_RETRY_DEF     8
 211
 212 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
 213
 214 #define LONG_RETRY_MIN     0
 215 #define LONG_RETRY_MAX     15
 216 #define LONG_RETRY_DEF     4
 217
 218 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
 219
 220 /* BasebandType[] baseband type selected
 221    0: indicate 802.11a type
 222    1: indicate 802.11b type
 223    2: indicate 802.11g type
 224 */
 225 #define BBP_TYPE_MIN     0
 226 #define BBP_TYPE_MAX     2
 227 #define BBP_TYPE_DEF     2
 228
 229 DEVICE_PARAM(BasebandType, "baseband type");
 230
 231 /* 80211hEnable[]
 232    0: indicate disable 802.11h
 233    1: indicate enable 802.11h
 234 */
 235
 236 #define X80211h_MODE_DEF     0
 237
 238 DEVICE_PARAM(b80211hEnable, "802.11h mode");
 239
 240 /* 80211hEnable[]
 241    0: indicate disable 802.11h
 242    1: indicate enable 802.11h
 243 */
 244
 245 #define DIVERSITY_ANT_DEF     0
 246
 247 DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode");
 248
 249 //
 250 // Static vars definitions
 251 //
 252
 253 static int          device_nics             = 0;
 254 static PSDevice     pDevice_Infos           = NULL;
 255 static struct net_device *root_device_dev = NULL;
 256
 257 static CHIP_INFO chip_info_table[] = {
 258         { VT3253,       "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
 259           256, 1,     DEVICE_FLAGS_IP_ALIGN|DEVICE_FLAGS_TX_ALIGN },
 260         {0, NULL}
 261 };
 262
 263 const struct pci_device_id vt6655_pci_id_table[] = {
 264         { PCI_VDEVICE(VIA, 0x3253), (kernel_ulong_t)chip_info_table},
 265         { 0, }
 266 };
 267
 268 /*---------------------  Static Functions  --------------------------*/
 269
 270 static int  vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent);
 271 static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice, PCHIP_INFO);
 272 static void device_free_info(PSDevice pDevice);
 273 static bool device_get_pci_info(PSDevice, struct pci_dev *pcid);
 274 static void device_print_info(PSDevice pDevice);
 275 static struct net_device_stats *device_get_stats(struct net_device *dev);
 276 static void device_init_diversity_timer(PSDevice pDevice);
 277 static int  device_open(struct net_device *dev);
 278 static int  device_xmit(struct sk_buff *skb, struct net_device *dev);
 279 static  irqreturn_t  device_intr(int irq,  void *dev_instance);
 280 static void device_set_multi(struct net_device *dev);
 281 static int  device_close(struct net_device *dev);
 282 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 283
 284 #ifdef CONFIG_PM
 285 static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
 286 static int viawget_suspend(struct pci_dev *pcid, pm_message_t state);
 287 static int viawget_resume(struct pci_dev *pcid);
 288 struct notifier_block device_notifier = {
 289         .notifier_call = device_notify_reboot,
 290         .next = NULL,
 291         .priority = 0,
 292 };
 293 #endif
 294
 295 static void device_init_rd0_ring(PSDevice pDevice);
 296 static void device_init_rd1_ring(PSDevice pDevice);
 297 static void device_init_defrag_cb(PSDevice pDevice);
 298 static void device_init_td0_ring(PSDevice pDevice);
 299 static void device_init_td1_ring(PSDevice pDevice);
 300
 301 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 302 //2008-0714<Add>by Mike Liu
 303 static bool device_release_WPADEV(PSDevice pDevice);
 304
 305 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 306 static int  device_rx_srv(PSDevice pDevice, unsigned int uIdx);
 307 static int  device_tx_srv(PSDevice pDevice, unsigned int uIdx);
 308 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc);
 309 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
 310 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc);
 311 static void device_free_td0_ring(PSDevice pDevice);
 312 static void device_free_td1_ring(PSDevice pDevice);
 313 static void device_free_rd0_ring(PSDevice pDevice);
 314 static void device_free_rd1_ring(PSDevice pDevice);
 315 static void device_free_rings(PSDevice pDevice);
 316 static void device_free_frag_buf(PSDevice pDevice);
 317 static int Config_FileGetParameter(unsigned char *string,
 318                                    unsigned char *dest, unsigned char *source);
 319
 320 /*---------------------  Export Variables  --------------------------*/
 321
 322 /*---------------------  Export Functions  --------------------------*/
 323
 324 static char *get_chip_name(int chip_id)
 325 {
 326         int i;
 327         for (i = 0; chip_info_table[i].name != NULL; i++)
 328                 if (chip_info_table[i].chip_id == chip_id)
 329                         break;
 330         return chip_info_table[i].name;
 331 }
 332
 333 static void vt6655_remove(struct pci_dev *pcid)
 334 {
 335         PSDevice pDevice = pci_get_drvdata(pcid);
 336
 337         if (pDevice == NULL)
 338                 return;
 339         device_free_info(pDevice);
 340 }
 341
 342 static void device_get_options(PSDevice pDevice, int index, char *devname)
 343 {
 344         POPTIONS pOpts = &(pDevice->sOpts);
 345
 346         pOpts->nRxDescs0 = RX_DESC_DEF0;
 347         pOpts->nRxDescs1 = RX_DESC_DEF1;
 348         pOpts->nTxDescs[0] = TX_DESC_DEF0;
 349         pOpts->nTxDescs[1] = TX_DESC_DEF1;
 350         pOpts->flags |= DEVICE_FLAGS_IP_ALIGN;
 351         pOpts->int_works = INT_WORKS_DEF;
 352         pOpts->rts_thresh = RTS_THRESH_DEF;
 353         pOpts->frag_thresh = FRAG_THRESH_DEF;
 354         pOpts->data_rate = DATA_RATE_DEF;
 355         pOpts->channel_num = CHANNEL_DEF;
 356
 357         pOpts->flags |= DEVICE_FLAGS_PREAMBLE_TYPE;
 358         pOpts->flags |= DEVICE_FLAGS_OP_MODE;
 359         pOpts->short_retry = SHORT_RETRY_DEF;
 360         pOpts->long_retry = LONG_RETRY_DEF;
 361         pOpts->bbp_type = BBP_TYPE_DEF;
 362         pOpts->flags |= DEVICE_FLAGS_80211h_MODE;
 363         pOpts->flags |= DEVICE_FLAGS_DiversityANT;
 364 }
 365
 366 static void
 367 device_set_options(PSDevice pDevice) {
 368         unsigned char abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 369         unsigned char abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 370         unsigned char abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 371
 372         memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 373         memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 374         memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
 375
 376         pDevice->uChannel = pDevice->sOpts.channel_num;
 377         pDevice->wRTSThreshold = pDevice->sOpts.rts_thresh;
 378         pDevice->wFragmentationThreshold = pDevice->sOpts.frag_thresh;
 379         pDevice->byShortRetryLimit = pDevice->sOpts.short_retry;
 380         pDevice->byLongRetryLimit = pDevice->sOpts.long_retry;
 381         pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
 382         pDevice->byShortPreamble = (pDevice->sOpts.flags & DEVICE_FLAGS_PREAMBLE_TYPE) ? 1 : 0;
 383         pDevice->byOpMode = (pDevice->sOpts.flags & DEVICE_FLAGS_OP_MODE) ? 1 : 0;
 384         pDevice->ePSMode = (pDevice->sOpts.flags & DEVICE_FLAGS_PS_MODE) ? 1 : 0;
 385         pDevice->b11hEnable = (pDevice->sOpts.flags & DEVICE_FLAGS_80211h_MODE) ? 1 : 0;
 386         pDevice->bDiversityRegCtlON = (pDevice->sOpts.flags & DEVICE_FLAGS_DiversityANT) ? 1 : 0;
 387         pDevice->uConnectionRate = pDevice->sOpts.data_rate;
 388         if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
 389         pDevice->byBBType = pDevice->sOpts.bbp_type;
 390         pDevice->byPacketType = pDevice->byBBType;
 391
 392 //PLICE_DEBUG->
 393         pDevice->byAutoFBCtrl = AUTO_FB_0;
 394 //PLICE_DEBUG<-
 395         pDevice->bUpdateBBVGA = true;
 396         pDevice->byFOETuning = 0;
 397         pDevice->wCTSDuration = 0;
 398         pDevice->byPreambleType = 0;
 399
 400         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " uChannel= %d\n", (int)pDevice->uChannel);
 401         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byOpMode= %d\n", (int)pDevice->byOpMode);
 402         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ePSMode= %d\n", (int)pDevice->ePSMode);
 403         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " wRTSThreshold= %d\n", (int)pDevice->wRTSThreshold);
 404         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byShortRetryLimit= %d\n", (int)pDevice->byShortRetryLimit);
 405         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byLongRetryLimit= %d\n", (int)pDevice->byLongRetryLimit);
 406         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byPreambleType= %d\n", (int)pDevice->byPreambleType);
 407         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byShortPreamble= %d\n", (int)pDevice->byShortPreamble);
 408         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " uConnectionRate= %d\n", (int)pDevice->uConnectionRate);
 409         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byBBType= %d\n", (int)pDevice->byBBType);
 410         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " pDevice->b11hEnable= %d\n", (int)pDevice->b11hEnable);
 411         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " pDevice->bDiversityRegCtlON= %d\n", (int)pDevice->bDiversityRegCtlON);
 412 }
 413
 414 static void s_vCompleteCurrentMeasure(PSDevice pDevice, unsigned char byResult)
 415 {
 416         unsigned int ii;
 417         unsigned long dwDuration = 0;
 418         unsigned char byRPI0 = 0;
 419
 420         for (ii = 1; ii < 8; ii++) {
 421                 pDevice->dwRPIs[ii] *= 255;
 422                 dwDuration |= *((unsigned short *)(pDevice->pCurrMeasureEID->sReq.abyDuration));
 423                 dwDuration <<= 10;
 424                 pDevice->dwRPIs[ii] /= dwDuration;
 425                 pDevice->abyRPIs[ii] = (unsigned char)pDevice->dwRPIs[ii];
 426                 byRPI0 += pDevice->abyRPIs[ii];
 427         }
 428         pDevice->abyRPIs[0] = (0xFF - byRPI0);
 429
 430         if (pDevice->uNumOfMeasureEIDs == 0) {
 431                 VNTWIFIbMeasureReport(pDevice->pMgmt,
 432                                       true,
 433                                       pDevice->pCurrMeasureEID,
 434                                       byResult,
 435                                       pDevice->byBasicMap,
 436                                       pDevice->byCCAFraction,
 437                                       pDevice->abyRPIs
 438                         );
 439         } else {
 440                 VNTWIFIbMeasureReport(pDevice->pMgmt,
 441                                       false,
 442                                       pDevice->pCurrMeasureEID,
 443                                       byResult,
 444                                       pDevice->byBasicMap,
 445                                       pDevice->byCCAFraction,
 446                                       pDevice->abyRPIs
 447                         );
 448                 CARDbStartMeasure(pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs);
 449         }
 450 }
 451
 452 //
 453 // Initialisation of MAC & BBP registers
 454 //
 455
 456 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
 457 {
 458         unsigned int ii;
 459         unsigned char byValue;
 460         unsigned char byValue1;
 461         unsigned char byCCKPwrdBm = 0;
 462         unsigned char byOFDMPwrdBm = 0;
 463         int zonetype = 0;
 464         PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 465         MACbShutdown(pDevice->PortOffset);
 466         BBvSoftwareReset(pDevice->PortOffset);
 467
 468         if ((InitType == DEVICE_INIT_COLD) ||
 469             (InitType == DEVICE_INIT_DXPL)) {
 470                 // Do MACbSoftwareReset in MACvInitialize
 471                 MACbSoftwareReset(pDevice->PortOffset);
 472                 // force CCK
 473                 pDevice->bCCK = true;
 474                 pDevice->bAES = false;
 475                 pDevice->bProtectMode = false;      //Only used in 11g type, sync with ERP IE
 476                 pDevice->bNonERPPresent = false;
 477                 pDevice->bBarkerPreambleMd = false;
 478                 pDevice->wCurrentRate = RATE_1M;
 479                 pDevice->byTopOFDMBasicRate = RATE_24M;
 480                 pDevice->byTopCCKBasicRate = RATE_1M;
 481
 482                 pDevice->byRevId = 0;                   //Target to IF pin while programming to RF chip.
 483
 484                 // init MAC
 485                 MACvInitialize(pDevice->PortOffset);
 486
 487                 // Get Local ID
 488                 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID));
 489
 490                 spin_lock_irq(&pDevice->lock);
 491                 SROMvReadAllContents(pDevice->PortOffset, pDevice->abyEEPROM);
 492
 493                 spin_unlock_irq(&pDevice->lock);
 494
 495                 // Get Channel range
 496
 497                 pDevice->byMinChannel = 1;
 498                 pDevice->byMaxChannel = CB_MAX_CHANNEL;
 499
 500                 // Get Antena
 501                 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
 502                 if (byValue & EEP_ANTINV)
 503                         pDevice->bTxRxAntInv = true;
 504                 else
 505                         pDevice->bTxRxAntInv = false;
 506
 507                 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 508                 if (byValue == 0) // if not set default is All
 509                         byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 510
 511                 pDevice->ulDiversityNValue = 100*260;
 512                 pDevice->ulDiversityMValue = 100*16;
 513                 pDevice->byTMax = 1;
 514                 pDevice->byTMax2 = 4;
 515                 pDevice->ulSQ3TH = 0;
 516                 pDevice->byTMax3 = 64;
 517
 518                 if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
 519                         pDevice->byAntennaCount = 2;
 520                         pDevice->byTxAntennaMode = ANT_B;
 521                         pDevice->dwTxAntennaSel = 1;
 522                         pDevice->dwRxAntennaSel = 1;
 523                         if (pDevice->bTxRxAntInv)
 524                                 pDevice->byRxAntennaMode = ANT_A;
 525                         else
 526                                 pDevice->byRxAntennaMode = ANT_B;
 527                         // chester for antenna
 528                         byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
 529                         if ((byValue1 & 0x08) == 0)
 530                                 pDevice->bDiversityEnable = false;
 531                         else
 532                                 pDevice->bDiversityEnable = true;
 533                 } else  {
 534                         pDevice->bDiversityEnable = false;
 535                         pDevice->byAntennaCount = 1;
 536                         pDevice->dwTxAntennaSel = 0;
 537                         pDevice->dwRxAntennaSel = 0;
 538                         if (byValue & EEP_ANTENNA_AUX) {
 539                                 pDevice->byTxAntennaMode = ANT_A;
 540                                 if (pDevice->bTxRxAntInv)
 541                                         pDevice->byRxAntennaMode = ANT_B;
 542                                 else
 543                                         pDevice->byRxAntennaMode = ANT_A;
 544                         } else {
 545                                 pDevice->byTxAntennaMode = ANT_B;
 546                                 if (pDevice->bTxRxAntInv)
 547                                         pDevice->byRxAntennaMode = ANT_A;
 548                                 else
 549                                         pDevice->byRxAntennaMode = ANT_B;
 550                         }
 551                 }
 552                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
 553                         pDevice->bDiversityEnable, (int)pDevice->ulDiversityNValue, (int)pDevice->ulDiversityMValue, pDevice->byTMax, pDevice->byTMax2);
 554
 555 //2008-8-4 <add> by chester
 556 //zonetype initial
 557                 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
 558                 zonetype = Config_FileOperation(pDevice, false, NULL);
 559                 if (zonetype >= 0) {         //read zonetype file ok!
 560                         if ((zonetype == 0) &&
 561                             (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x00)) {          //for USA
 562                                 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0;
 563                                 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0B;
 564                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Init Zone Type :USA\n");
 565                         } else if ((zonetype == 1) &&
 566                                  (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x01)) {   //for Japan
 567                                 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x01;
 568                                 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
 569                         } else if ((zonetype == 2) &&
 570                                  (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x02)) {   //for Europe
 571                                 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x02;
 572                                 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
 573                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Init Zone Type :Europe\n");
 574                         }
 575
 576                         else {
 577                                 if (zonetype != pDevice->abyEEPROM[EEP_OFS_ZONETYPE])
 578                                         printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n", zonetype, pDevice->abyEEPROM[EEP_OFS_ZONETYPE]);
 579                                 else
 580                                         printk("Read Zonetype file success,use default zonetype setting[%02x]\n", zonetype);
 581                         }
 582                 } else
 583                         printk("Read Zonetype file fail,use default zonetype setting[%02x]\n", SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE));
 584
 585                 // Get RFType
 586                 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE);
 587
 588                 if ((pDevice->byRFType & RF_EMU) != 0) {
 589                         // force change RevID for VT3253 emu
 590                         pDevice->byRevId = 0x80;
 591                 }
 592
 593                 pDevice->byRFType &= RF_MASK;
 594                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType);
 595
 596                 if (!pDevice->bZoneRegExist)
 597                         pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
 598
 599                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType);
 600
 601                 //Init RF module
 602                 RFbInit(pDevice);
 603
 604                 //Get Desire Power Value
 605                 pDevice->byCurPwr = 0xFF;
 606                 pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK);
 607                 pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG);
 608
 609                 // Load power Table
 610
 611                 for (ii = 0; ii < CB_MAX_CHANNEL_24G; ii++) {
 612                         pDevice->abyCCKPwrTbl[ii + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_CCK_PWR_TBL));
 613                         if (pDevice->abyCCKPwrTbl[ii + 1] == 0)
 614                                 pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr;
 615
 616                         pDevice->abyOFDMPwrTbl[ii + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDM_PWR_TBL));
 617                         if (pDevice->abyOFDMPwrTbl[ii + 1] == 0)
 618                                 pDevice->abyOFDMPwrTbl[ii + 1] = pDevice->byOFDMPwrG;
 619
 620                         pDevice->abyCCKDefaultPwr[ii + 1] = byCCKPwrdBm;
 621                         pDevice->abyOFDMDefaultPwr[ii + 1] = byOFDMPwrdBm;
 622                 }
 623                 //2008-8-4 <add> by chester
 624                 //recover 12,13 ,14channel for EUROPE by 11 channel
 625                 if (((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
 626                      (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe)) &&
 627                     (pDevice->byOriginalZonetype == ZoneType_USA)) {
 628                         for (ii = 11; ii < 14; ii++) {
 629                                 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
 630                                 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
 631
 632                         }
 633                 }
 634
 635                 // Load OFDM A Power Table
 636                 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
 637                         pDevice->abyOFDMPwrTbl[ii + CB_MAX_CHANNEL_24G + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_TBL));
 638                         pDevice->abyOFDMDefaultPwr[ii + CB_MAX_CHANNEL_24G + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_dBm));
 639                 }
 640                 init_channel_table((void *)pDevice);
 641
 642                 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
 643                         MACvSelectPage1(pDevice->PortOffset);
 644                         VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN));
 645                         MACvSelectPage0(pDevice->PortOffset);
 646                 }
 647
 648                 // use relative tx timeout and 802.11i D4
 649                 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
 650
 651                 // set performance parameter by registry
 652                 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit);
 653                 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit);
 654
 655                 // reset TSF counter
 656                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
 657                 // enable TSF counter
 658                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
 659
 660                 // initialize BBP registers
 661                 BBbVT3253Init(pDevice);
 662
 663                 if (pDevice->bUpdateBBVGA) {
 664                         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 665                         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 666                         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 667                 }
 668                 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode);
 669                 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode);
 670
 671                 pDevice->byCurrentCh = 0;
 672
 673                 // Set BB and packet type at the same time.
 674                 // Set Short Slot Time, xIFS, and RSPINF.
 675                 if (pDevice->uConnectionRate == RATE_AUTO)
 676                         pDevice->wCurrentRate = RATE_54M;
 677                 else
 678                         pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
 679
 680                 // default G Mode
 681                 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G);
 682                 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO);
 683
 684                 pDevice->bRadioOff = false;
 685
 686                 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL);
 687                 pDevice->bHWRadioOff = false;
 688
 689                 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) {
 690                         // Get GPIO
 691                         MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO);
 692 //2008-4-14 <add> by chester for led issue
 693 #ifdef FOR_LED_ON_NOTEBOOK
 694                         if (pDevice->byGPIO & GPIO0_DATA)
 695                                 pDevice->bHWRadioOff = true;
 696
 697                         if (!(pDevice->byGPIO & GPIO0_DATA))
 698                                 pDevice->bHWRadioOff = false;
 699                 }
 700
 701                 if (pDevice->bRadioControlOff)
 702                         CARDbRadioPowerOff(pDevice);
 703                 else
 704                         CARDbRadioPowerOn(pDevice);
 705 #else
 706                 if (((pDevice->byGPIO & GPIO0_DATA) && !(pDevice->byRadioCtl & EEP_RADIOCTL_INV)) ||
 707                     (!(pDevice->byGPIO & GPIO0_DATA) && (pDevice->byRadioCtl & EEP_RADIOCTL_INV))) {
 708                         pDevice->bHWRadioOff = true;
 709                 }
 710         }
 711         if (pDevice->bHWRadioOff || pDevice->bRadioControlOff)
 712                 CARDbRadioPowerOff(pDevice);
 713
 714 #endif
 715 }
 716 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
 717 // get Permanent network address
 718 SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
 719 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Network address = %pM\n",
 720         pDevice->abyCurrentNetAddr);
 721
 722 // reset Tx pointer
 723 CARDvSafeResetRx(pDevice);
 724 // reset Rx pointer
 725 CARDvSafeResetTx(pDevice);
 726
 727 if (pDevice->byLocalID <= REV_ID_VT3253_A1)
 728         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
 729
 730 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 731
 732 // Turn On Rx DMA
 733 MACvReceive0(pDevice->PortOffset);
 734 MACvReceive1(pDevice->PortOffset);
 735
 736 // start the adapter
 737 MACvStart(pDevice->PortOffset);
 738
 739 netif_stop_queue(pDevice->dev);
 740 }
 741
 742 static void device_init_diversity_timer(PSDevice pDevice) {
 743         init_timer(&pDevice->TimerSQ3Tmax1);
 744         pDevice->TimerSQ3Tmax1.data = (unsigned long) pDevice;
 745         pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 746         pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 747
 748         init_timer(&pDevice->TimerSQ3Tmax2);
 749         pDevice->TimerSQ3Tmax2.data = (unsigned long) pDevice;
 750         pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 751         pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 752
 753         init_timer(&pDevice->TimerSQ3Tmax3);
 754         pDevice->TimerSQ3Tmax3.data = (unsigned long) pDevice;
 755         pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack;
 756         pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 757
 758         return;
 759 }
 760
 761 static bool device_release_WPADEV(PSDevice pDevice)
 762 {
 763         viawget_wpa_header *wpahdr;
 764         int ii = 0;
 765
 766         //send device close to wpa_supplicnat layer
 767         if (pDevice->bWPADEVUp) {
 768                 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 769                 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 770                 wpahdr->resp_ie_len = 0;
 771                 wpahdr->req_ie_len = 0;
 772                 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 773                 pDevice->skb->dev = pDevice->wpadev;
 774                 skb_reset_mac_header(pDevice->skb);
 775                 pDevice->skb->pkt_type = PACKET_HOST;
 776                 pDevice->skb->protocol = htons(ETH_P_802_2);
 777                 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 778                 netif_rx(pDevice->skb);
 779                 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 780
 781                 while (pDevice->bWPADEVUp) {
 782                         set_current_state(TASK_UNINTERRUPTIBLE);
 783                         schedule_timeout(HZ / 20);          //wait 50ms
 784                         ii++;
 785                         if (ii > 20)
 786                                 break;
 787                 }
 788         }
 789         return true;
 790 }
 791
 792 static const struct net_device_ops device_netdev_ops = {
 793         .ndo_open               = device_open,
 794         .ndo_stop               = device_close,
 795         .ndo_do_ioctl           = device_ioctl,
 796         .ndo_get_stats          = device_get_stats,
 797         .ndo_start_xmit         = device_xmit,
 798         .ndo_set_rx_mode        = device_set_multi,
 799 };
 800
 801 static int
 802 vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent)
 803 {
 804         static bool bFirst = true;
 805         struct net_device *dev = NULL;
 806         PCHIP_INFO  pChip_info = (PCHIP_INFO)ent->driver_data;
 807         PSDevice    pDevice;
 808         int         rc;
 809         if (device_nics++ >= MAX_UINTS) {
 810                 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
 811                 return -ENODEV;
 812         }
 813
 814         dev = alloc_etherdev(sizeof(DEVICE_INFO));
 815
 816         pDevice = (PSDevice) netdev_priv(dev);
 817
 818         if (dev == NULL) {
 819                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
 820                 return -ENOMEM;
 821         }
 822
 823         // Chain it all together
 824         SET_NETDEV_DEV(dev, &pcid->dev);
 825
 826         if (bFirst) {
 827                 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 828                 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
 829                 bFirst = false;
 830         }
 831
 832         vt6655_init_info(pcid, &pDevice, pChip_info);
 833         pDevice->dev = dev;
 834         pDevice->next_module = root_device_dev;
 835         root_device_dev = dev;
 836
 837         if (pci_enable_device(pcid)) {
 838                 device_free_info(pDevice);
 839                 return -ENODEV;
 840         }
 841         dev->irq = pcid->irq;
 842
 843 #ifdef  DEBUG
 844         printk("Before get pci_info memaddr is %x\n", pDevice->memaddr);
 845 #endif
 846         if (!device_get_pci_info(pDevice, pcid)) {
 847                 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
 848                 device_free_info(pDevice);
 849                 return -ENODEV;
 850         }
 851
 852 #if 1
 853
 854 #ifdef  DEBUG
 855
 856         printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n", pDevice->memaddr, pDevice->ioaddr, pDevice->io_size);
 857         {
 858                 int i;
 859                 u32 bar, len;
 860                 u32 address[] = {
 861                         PCI_BASE_ADDRESS_0,
 862                         PCI_BASE_ADDRESS_1,
 863                         PCI_BASE_ADDRESS_2,
 864                         PCI_BASE_ADDRESS_3,
 865                         PCI_BASE_ADDRESS_4,
 866                         PCI_BASE_ADDRESS_5,
 867                         0};
 868                 for (i = 0; address[i]; i++) {
 869                         pci_read_config_dword(pcid, address[i], &bar);
 870                         printk("bar %d is %x\n", i, bar);
 871                         if (!bar) {
 872                                 printk("bar %d not implemented\n", i);
 873                                 continue;
 874                         }
 875                         if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
 876                                 /* This is IO */
 877
 878                                 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
 879                                 len = len & ~(len - 1);
 880
 881                                 printk("IO space:  len in IO %x, BAR %d\n", len, i);
 882                         } else {
 883                                 len = bar & 0xFFFFFFF0;
 884                                 len = ~len + 1;
 885
 886                                 printk("len in MEM %x, BAR %d\n", len, i);
 887                         }
 888                 }
 889         }
 890 #endif
 891
 892 #endif
 893
 894         pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
 895
 896         if (pDevice->PortOffset == 0) {
 897                 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
 898                 device_free_info(pDevice);
 899                 return -ENODEV;
 900         }
 901
 902         rc = pci_request_regions(pcid, DEVICE_NAME);
 903         if (rc) {
 904                 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
 905                 device_free_info(pDevice);
 906                 return -ENODEV;
 907         }
 908
 909         dev->base_addr = pDevice->ioaddr;
 910 #ifdef  PLICE_DEBUG
 911         unsigned char value;
 912
 913         VNSvInPortB(pDevice->PortOffset+0x4F, &value);
 914         printk("Before write: value is %x\n", value);
 915         VNSvOutPortB(pDevice->PortOffset, value);
 916         VNSvInPortB(pDevice->PortOffset+0x4F, &value);
 917         printk("After write: value is %x\n", value);
 918 #endif
 919
 920 #ifdef IO_MAP
 921         pDevice->PortOffset = pDevice->ioaddr;
 922 #endif
 923         // do reset
 924         if (!MACbSoftwareReset(pDevice->PortOffset)) {
 925                 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
 926                 device_free_info(pDevice);
 927                 return -ENODEV;
 928         }
 929         // initial to reload eeprom
 930         MACvInitialize(pDevice->PortOffset);
 931         MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
 932
 933         device_get_options(pDevice, device_nics-1, dev->name);
 934         device_set_options(pDevice);
 935         //Mask out the options cannot be set to the chip
 936         pDevice->sOpts.flags &= pChip_info->flags;
 937
 938         //Enable the chip specified capabilities
 939         pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
 940         pDevice->tx_80211 = device_dma0_tx_80211;
 941         pDevice->sMgmtObj.pAdapter = (void *)pDevice;
 942         pDevice->pMgmt = &(pDevice->sMgmtObj);
 943
 944         dev->irq                = pcid->irq;
 945         dev->netdev_ops         = &device_netdev_ops;
 946
 947         dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
 948
 949         rc = register_netdev(dev);
 950         if (rc) {
 951                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 952                 device_free_info(pDevice);
 953                 return -ENODEV;
 954         }
 955         device_print_info(pDevice);
 956         pci_set_drvdata(pcid, pDevice);
 957         return 0;
 958 }
 959
 960 static void device_print_info(PSDevice pDevice)
 961 {
 962         struct net_device *dev = pDevice->dev;
 963
 964         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n", dev->name, get_chip_name(pDevice->chip_id));
 965         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%pM", dev->name, dev->dev_addr);
 966 #ifdef IO_MAP
 967         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IO=0x%lx  ", (unsigned long)pDevice->ioaddr);
 968         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IRQ=%d \n", pDevice->dev->irq);
 969 #else
 970         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IO=0x%lx Mem=0x%lx ",
 971                 (unsigned long)pDevice->ioaddr, (unsigned long)pDevice->PortOffset);
 972         DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IRQ=%d \n", pDevice->dev->irq);
 973 #endif
 974 }
 975
 976 static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice,
 977                              PCHIP_INFO pChip_info) {
 978         PSDevice p;
 979
 980         memset(*ppDevice, 0, sizeof(DEVICE_INFO));
 981
 982         if (pDevice_Infos == NULL) {
 983                 pDevice_Infos = *ppDevice;
 984         } else {
 985                 for (p = pDevice_Infos; p->next != NULL; p = p->next)
 986                         do {} while (0);
 987                 p->next = *ppDevice;
 988                 (*ppDevice)->prev = p;
 989         }
 990
 991         (*ppDevice)->pcid = pcid;
 992         (*ppDevice)->chip_id = pChip_info->chip_id;
 993         (*ppDevice)->io_size = pChip_info->io_size;
 994         (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
 995         (*ppDevice)->multicast_limit = 32;
 996
 997         spin_lock_init(&((*ppDevice)->lock));
 998 }
 999
1000 static bool device_get_pci_info(PSDevice pDevice, struct pci_dev *pcid) {
1001         u16 pci_cmd;
1002         u8  b;
1003         unsigned int cis_addr;
1004 #ifdef  PLICE_DEBUG
1005         unsigned char pci_config[256];
1006         unsigned char value = 0x00;
1007         int             ii, j;
1008         u16     max_lat = 0x0000;
1009         memset(pci_config, 0x00, 256);
1010 #endif
1011
1012         pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1013         pci_read_config_word(pcid, PCI_SUBSYSTEM_ID, &pDevice->SubSystemID);
1014         pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1015         pci_read_config_word(pcid, PCI_COMMAND, (u16 *)&(pci_cmd));
1016
1017         pci_set_master(pcid);
1018
1019         pDevice->memaddr = pci_resource_start(pcid, 0);
1020         pDevice->ioaddr = pci_resource_start(pcid, 1);
1021
1022         cis_addr = pci_resource_start(pcid, 2);
1023
1024         pDevice->pcid = pcid;
1025
1026         pci_read_config_byte(pcid, PCI_COMMAND, &b);
1027         pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1028
1029 #ifdef  PLICE_DEBUG
1030         for (ii = 0; ii < 0xFF; ii++) {
1031                 pci_read_config_byte(pcid, ii, &value);
1032                 pci_config[ii] = value;
1033         }
1034         for (ii = 0, j = 1; ii < 0x100; ii++, j++) {
1035                 if (j % 16 == 0) {
1036                         printk("%x:", pci_config[ii]);
1037                         printk("\n");
1038                 } else {
1039                         printk("%x:", pci_config[ii]);
1040                 }
1041         }
1042 #endif
1043         return true;
1044 }
1045
1046 static void device_free_info(PSDevice pDevice) {
1047         PSDevice         ptr;
1048         struct net_device *dev = pDevice->dev;
1049
1050         ASSERT(pDevice);
1051 //2008-0714-01<Add>by chester
1052         device_release_WPADEV(pDevice);
1053
1054 //2008-07-21-01<Add>by MikeLiu
1055 //unregister wpadev
1056         if (wpa_set_wpadev(pDevice, 0) != 0)
1057                 printk("unregister wpadev fail?\n");
1058
1059         if (pDevice_Infos == NULL)
1060                 return;
1061
1062         for (ptr = pDevice_Infos; ptr && (ptr != pDevice); ptr = ptr->next)
1063                 do {} while (0);
1064
1065         if (ptr == pDevice) {
1066                 if (ptr == pDevice_Infos)
1067                         pDevice_Infos = ptr->next;
1068                 else
1069                         ptr->prev->next = ptr->next;
1070         } else {
1071                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1072                 return;
1073         }
1074 #ifdef HOSTAP
1075         if (dev)
1076                 vt6655_hostap_set_hostapd(pDevice, 0, 0);
1077 #endif
1078         if (dev)
1079                 unregister_netdev(dev);
1080
1081         if (pDevice->PortOffset)
1082                 iounmap((void *)pDevice->PortOffset);
1083
1084         if (pDevice->pcid)
1085                 pci_release_regions(pDevice->pcid);
1086         if (dev)
1087                 free_netdev(dev);
1088 }
1089
1090 static bool device_init_rings(PSDevice pDevice) {
1091         void *vir_pool;
1092
1093         /*allocate all RD/TD rings a single pool*/
1094         vir_pool = pci_alloc_consistent(pDevice->pcid,
1095                                         pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1096                                         pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1097                                         pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1098                                         pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1099                                         &pDevice->pool_dma);
1100
1101         if (vir_pool == NULL) {
1102                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1103                 return false;
1104         }
1105
1106         memset(vir_pool, 0,
1107                pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1108                pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1109                pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1110                pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1111                 );
1112
1113         pDevice->aRD0Ring = vir_pool;
1114         pDevice->aRD1Ring = vir_pool +
1115                 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1116
1117         pDevice->rd0_pool_dma = pDevice->pool_dma;
1118         pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1119                 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1120
1121         pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1122                                                  pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1123                                                  pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1124                                                  CB_BEACON_BUF_SIZE +
1125                                                  CB_MAX_BUF_SIZE,
1126                                                  &pDevice->tx_bufs_dma0);
1127
1128         if (pDevice->tx0_bufs == NULL) {
1129                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1130                 pci_free_consistent(pDevice->pcid,
1131                                     pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1132                                     pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1133                                     pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1134                                     pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1135                                     vir_pool, pDevice->pool_dma
1136                         );
1137                 return false;
1138         }
1139
1140         memset(pDevice->tx0_bufs, 0,
1141                pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1142                pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1143                CB_BEACON_BUF_SIZE +
1144                CB_MAX_BUF_SIZE
1145                 );
1146
1147         pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1148                 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1149
1150         pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1151                 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1152
1153         // vir_pool: pvoid type
1154         pDevice->apTD0Rings = vir_pool
1155                 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1156                 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1157
1158         pDevice->apTD1Rings = vir_pool
1159                 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1160                 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1161                 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1162
1163         pDevice->tx1_bufs = pDevice->tx0_bufs +
1164                 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1165
1166         pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1167                 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1168
1169         pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1170                 CB_BEACON_BUF_SIZE;
1171
1172         pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1173                 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1174
1175         pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1176                 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1177
1178         return true;
1179 }
1180
1181 static void device_free_rings(PSDevice pDevice) {
1182         pci_free_consistent(pDevice->pcid,
1183                             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1184                             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1185                             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1186                             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1187                             ,
1188                             pDevice->aRD0Ring, pDevice->pool_dma
1189                 );
1190
1191         if (pDevice->tx0_bufs)
1192                 pci_free_consistent(pDevice->pcid,
1193                                     pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1194                                     pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1195                                     CB_BEACON_BUF_SIZE +
1196                                     CB_MAX_BUF_SIZE,
1197                                     pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1198                         );
1199 }
1200
1201 static void device_init_rd0_ring(PSDevice pDevice) {
1202         int i;
1203         dma_addr_t      curr = pDevice->rd0_pool_dma;
1204         PSRxDesc        pDesc;
1205
1206         /* Init the RD0 ring entries */
1207         for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1208                 pDesc = &(pDevice->aRD0Ring[i]);
1209                 pDesc->pRDInfo = alloc_rd_info();
1210                 ASSERT(pDesc->pRDInfo);
1211                 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1212                         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1213                                 pDevice->dev->name);
1214                 }
1215                 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1216                 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1217                 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1218         }
1219
1220         if (i > 0)
1221                 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1222         pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1223 }
1224
1225 static void device_init_rd1_ring(PSDevice pDevice) {
1226         int i;
1227         dma_addr_t      curr = pDevice->rd1_pool_dma;
1228         PSRxDesc        pDesc;
1229
1230         /* Init the RD1 ring entries */
1231         for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1232                 pDesc = &(pDevice->aRD1Ring[i]);
1233                 pDesc->pRDInfo = alloc_rd_info();
1234                 ASSERT(pDesc->pRDInfo);
1235                 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1236                         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1237                                 pDevice->dev->name);
1238                 }
1239                 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1240                 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1241                 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1242         }
1243
1244         if (i > 0)
1245                 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1246         pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1247 }
1248
1249 static void device_init_defrag_cb(PSDevice pDevice) {
1250         int i;
1251         PSDeFragControlBlock pDeF;
1252
1253         /* Init the fragment ctl entries */
1254         for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1255                 pDeF = &(pDevice->sRxDFCB[i]);
1256                 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1257                         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc frag bufs\n",
1258                                 pDevice->dev->name);
1259                 }
1260         }
1261         pDevice->cbDFCB = CB_MAX_RX_FRAG;
1262         pDevice->cbFreeDFCB = pDevice->cbDFCB;
1263 }
1264
1265 static void device_free_rd0_ring(PSDevice pDevice) {
1266         int i;
1267
1268         for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1269                 PSRxDesc        pDesc = &(pDevice->aRD0Ring[i]);
1270                 PDEVICE_RD_INFO  pRDInfo = pDesc->pRDInfo;
1271
1272                 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1273                                  pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1274
1275                 dev_kfree_skb(pRDInfo->skb);
1276
1277                 kfree((void *)pDesc->pRDInfo);
1278         }
1279 }
1280
1281 static void device_free_rd1_ring(PSDevice pDevice) {
1282         int i;
1283
1284         for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1285                 PSRxDesc        pDesc = &(pDevice->aRD1Ring[i]);
1286                 PDEVICE_RD_INFO  pRDInfo = pDesc->pRDInfo;
1287
1288                 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1289                                  pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1290
1291                 dev_kfree_skb(pRDInfo->skb);
1292
1293                 kfree((void *)pDesc->pRDInfo);
1294         }
1295 }
1296
1297 static void device_free_frag_buf(PSDevice pDevice) {
1298         PSDeFragControlBlock pDeF;
1299         int i;
1300
1301         for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1302                 pDeF = &(pDevice->sRxDFCB[i]);
1303
1304                 if (pDeF->skb)
1305                         dev_kfree_skb(pDeF->skb);
1306
1307         }
1308 }
1309
1310 static void device_init_td0_ring(PSDevice pDevice) {
1311         int i;
1312         dma_addr_t  curr;
1313         PSTxDesc        pDesc;
1314
1315         curr = pDevice->td0_pool_dma;
1316         for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1317                 pDesc = &(pDevice->apTD0Rings[i]);
1318                 pDesc->pTDInfo = alloc_td_info();
1319                 ASSERT(pDesc->pTDInfo);
1320                 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1321                         pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1322                         pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1323                 }
1324                 pDesc->next = &(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1325                 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1326                 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1327         }
1328
1329         if (i > 0)
1330                 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1331         pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
1332 }
1333
1334 static void device_init_td1_ring(PSDevice pDevice) {
1335         int i;
1336         dma_addr_t  curr;
1337         PSTxDesc    pDesc;
1338
1339         /* Init the TD ring entries */
1340         curr = pDevice->td1_pool_dma;
1341         for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr += sizeof(STxDesc)) {
1342                 pDesc = &(pDevice->apTD1Rings[i]);
1343                 pDesc->pTDInfo = alloc_td_info();
1344                 ASSERT(pDesc->pTDInfo);
1345                 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1346                         pDesc->pTDInfo->buf = pDevice->tx1_bufs + (i) * PKT_BUF_SZ;
1347                         pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma1 + (i) * PKT_BUF_SZ;
1348                 }
1349                 pDesc->next = &(pDevice->apTD1Rings[(i + 1) % pDevice->sOpts.nTxDescs[1]]);
1350                 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1351                 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1352         }
1353
1354         if (i > 0)
1355                 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1356         pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1357 }
1358
1359 static void device_free_td0_ring(PSDevice pDevice) {
1360         int i;
1361         for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1362                 PSTxDesc        pDesc = &(pDevice->apTD0Rings[i]);
1363                 PDEVICE_TD_INFO  pTDInfo = pDesc->pTDInfo;
1364
1365                 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1366                         pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1367                                          pTDInfo->skb->len, PCI_DMA_TODEVICE);
1368
1369                 if (pTDInfo->skb)
1370                         dev_kfree_skb(pTDInfo->skb);
1371
1372                 kfree((void *)pDesc->pTDInfo);
1373         }
1374 }
1375
1376 static void device_free_td1_ring(PSDevice pDevice) {
1377         int i;
1378
1379         for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1380                 PSTxDesc        pDesc = &(pDevice->apTD1Rings[i]);
1381                 PDEVICE_TD_INFO  pTDInfo = pDesc->pTDInfo;
1382
1383                 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1384                         pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1385                                          pTDInfo->skb->len, PCI_DMA_TODEVICE);
1386
1387                 if (pTDInfo->skb)
1388                         dev_kfree_skb(pTDInfo->skb);
1389
1390                 kfree((void *)pDesc->pTDInfo);
1391         }
1392 }
1393
1394 /*-----------------------------------------------------------------*/
1395
1396 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1397         PSRxDesc    pRD;
1398         int works = 0;
1399
1400         for (pRD = pDevice->pCurrRD[uIdx];
1401              pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1402              pRD = pRD->next) {
1403                 if (works++ > 15)
1404                         break;
1405                 if (device_receive_frame(pDevice, pRD)) {
1406                         if (!device_alloc_rx_buf(pDevice, pRD)) {
1407                                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1408                                         "%s: can not allocate rx buf\n", pDevice->dev->name);
1409                                 break;
1410                         }
1411                 }
1412                 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1413                 pDevice->dev->last_rx = jiffies;
1414         }
1415
1416         pDevice->pCurrRD[uIdx] = pRD;
1417
1418         return works;
1419 }
1420
1421 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1422         PDEVICE_RD_INFO pRDInfo = pRD->pRDInfo;
1423
1424         pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1425         if (pRDInfo->skb == NULL)
1426                 return false;
1427         ASSERT(pRDInfo->skb);
1428         pRDInfo->skb->dev = pDevice->dev;
1429         pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1430                                           pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1431         *((unsigned int *)&(pRD->m_rd0RD0)) = 0; /* FIX cast */
1432
1433         pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1434         pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1435         pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1436         pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1437
1438         return true;
1439 }
1440
1441 bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1442         pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1443         if (pDeF->skb == NULL)
1444                 return false;
1445         ASSERT(pDeF->skb);
1446         pDeF->skb->dev = pDevice->dev;
1447
1448         return true;
1449 }
1450
1451 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1452         PSTxDesc                 pTD;
1453         bool bFull = false;
1454         int                      works = 0;
1455         unsigned char byTsr0;
1456         unsigned char byTsr1;
1457         unsigned int    uFrameSize, uFIFOHeaderSize;
1458         PSTxBufHead              pTxBufHead;
1459         struct net_device_stats *pStats = &pDevice->stats;
1460         struct sk_buff *skb;
1461         unsigned int    uNodeIndex;
1462         PSMgmtObject             pMgmt = pDevice->pMgmt;
1463
1464         for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] > 0; pTD = pTD->next) {
1465                 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1466                         break;
1467                 if (works++ > 15)
1468                         break;
1469
1470                 byTsr0 = pTD->m_td0TD0.byTSR0;
1471                 byTsr1 = pTD->m_td0TD0.byTSR1;
1472
1473                 //Only the status of first TD in the chain is correct
1474                 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1475                         if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1476                                 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1477                                 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1478                                 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1479                                 // Update the statistics based on the Transmit status
1480                                 // now, we DONT check TSR0_CDH
1481
1482                                 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1483                                                         byTsr0, byTsr1,
1484                                                         (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1485                                                         uFrameSize, uIdx);
1486
1487                                 BSSvUpdateNodeTxCounter(pDevice,
1488                                                         byTsr0, byTsr1,
1489                                                         (unsigned char *)(pTD->pTDInfo->buf),
1490                                                         uFIFOHeaderSize
1491                                         );
1492
1493                                 if (!(byTsr1 & TSR1_TERR)) {
1494                                         if (byTsr0 != 0) {
1495                                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1496                                                         (int)uIdx, byTsr1, byTsr0);
1497                                         }
1498                                         if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG)
1499                                                 pDevice->s802_11Counter.TransmittedFragmentCount++;
1500
1501                                         pStats->tx_packets++;
1502                                         pStats->tx_bytes += pTD->pTDInfo->skb->len;
1503                                 } else {
1504                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1505                                                 (int)uIdx, byTsr1, byTsr0);
1506                                         pStats->tx_errors++;
1507                                         pStats->tx_dropped++;
1508                                 }
1509                         }
1510
1511                         if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1512                                 if (pDevice->bEnableHostapd) {
1513                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1514                                         skb = pTD->pTDInfo->skb;
1515                                         skb->dev = pDevice->apdev;
1516                                         skb_reset_mac_header(skb);
1517                                         skb->pkt_type = PACKET_OTHERHOST;
1518                                         memset(skb->cb, 0, sizeof(skb->cb));
1519                                         netif_rx(skb);
1520                                 }
1521                         }
1522
1523                         if (byTsr1 & TSR1_TERR) {
1524                                 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1525                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1526                                                 (int)uIdx, byTsr1, byTsr0);
1527                                 }
1528
1529
1530                                 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1531                                     (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1532                                         unsigned short wAID;
1533                                         unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1534
1535                                         skb = pTD->pTDInfo->skb;
1536                                         if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
1537                                                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1538                                                         skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1539                                                         pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1540                                                         // set tx map
1541                                                         wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1542                                                         pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
1543                                                         pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1544                                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1545                                                                 , (int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1546                                                         pStats->tx_errors--;
1547                                                         pStats->tx_dropped--;
1548                                                 }
1549                                         }
1550                                 }
1551                         }
1552                         device_free_tx_buf(pDevice, pTD);
1553                         pDevice->iTDUsed[uIdx]--;
1554                 }
1555         }
1556
1557         if (uIdx == TYPE_AC0DMA) {
1558                 // RESERV_AC0DMA reserved for relay
1559
1560                 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1561                         bFull = true;
1562                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1563                 }
1564                 if (netif_queue_stopped(pDevice->dev) && !bFull)
1565                         netif_wake_queue(pDevice->dev);
1566
1567         }
1568
1569         pDevice->apTailTD[uIdx] = pTD;
1570
1571         return works;
1572 }
1573
1574 static void device_error(PSDevice pDevice, unsigned short status) {
1575         if (status & ISR_FETALERR) {
1576                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1577                         "%s: Hardware fatal error.\n",
1578                         pDevice->dev->name);
1579                 netif_stop_queue(pDevice->dev);
1580                 del_timer(&pDevice->sTimerCommand);
1581                 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1582                 pDevice->bCmdRunning = false;
1583                 MACbShutdown(pDevice->PortOffset);
1584                 return;
1585         }
1586 }
1587
1588 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1589         PDEVICE_TD_INFO  pTDInfo = pDesc->pTDInfo;
1590         struct sk_buff *skb = pTDInfo->skb;
1591
1592         // pre-allocated buf_dma can't be unmapped.
1593         if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1594                 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, skb->len,
1595                                  PCI_DMA_TODEVICE);
1596         }
1597
1598         if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1599                 dev_kfree_skb_irq(skb);
1600
1601         pTDInfo->skb_dma = 0;
1602         pTDInfo->skb = 0;
1603         pTDInfo->byFlags = 0;
1604 }
1605
1606 //PLICE_DEBUG ->
1607 void    InitRxManagementQueue(PSDevice  pDevice)
1608 {
1609         pDevice->rxManeQueue.packet_num = 0;
1610         pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1611 }
1612 //PLICE_DEBUG<-
1613
1614 //PLICE_DEBUG ->
1615 int MlmeThread(
1616         void *Context)
1617 {
1618         PSDevice        pDevice =  (PSDevice) Context;
1619         PSRxMgmtPacket                  pRxMgmtPacket;
1620
1621         while (1) {
1622                 spin_lock_irq(&pDevice->lock);
1623                 while (pDevice->rxManeQueue.packet_num != 0) {
1624                         pRxMgmtPacket = DeQueue(pDevice);
1625                         vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1626                 }
1627                 spin_unlock_irq(&pDevice->lock);
1628                 if (mlme_kill == 0)
1629                         break;
1630
1631                 schedule();
1632                 if (mlme_kill == 0)
1633                         break;
1634         }
1635
1636         return 0;
1637 }
1638
1639 static int  device_open(struct net_device *dev) {
1640         PSDevice pDevice = (PSDevice)netdev_priv(dev);
1641         int i;
1642 #ifdef WPA_SM_Transtatus
1643         extern SWPAResult wpa_Result;
1644 #endif
1645
1646         pDevice->rx_buf_sz = PKT_BUF_SZ;
1647         if (!device_init_rings(pDevice))
1648                 return -ENOMEM;
1649
1650 //2008-5-13 <add> by chester
1651         i = request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1652         if (i)
1653                 return i;
1654
1655 #ifdef WPA_SM_Transtatus
1656         memset(wpa_Result.ifname, 0, sizeof(wpa_Result.ifname));
1657         wpa_Result.proto = 0;
1658         wpa_Result.key_mgmt = 0;
1659         wpa_Result.eap_type = 0;
1660         wpa_Result.authenticated = false;
1661         pDevice->fWPA_Authened = false;
1662 #endif
1663         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1664         device_init_rd0_ring(pDevice);
1665         device_init_rd1_ring(pDevice);
1666         device_init_defrag_cb(pDevice);
1667         device_init_td0_ring(pDevice);
1668         device_init_td1_ring(pDevice);
1669
1670         if (pDevice->bDiversityRegCtlON)
1671                 device_init_diversity_timer(pDevice);
1672
1673         vMgrObjectInit(pDevice);
1674         vMgrTimerInit(pDevice);
1675
1676 //PLICE_DEBUG->
1677 #ifdef  TASK_LET
1678         tasklet_init(&pDevice->RxMngWorkItem, (void *)MngWorkItem, (unsigned long)pDevice);
1679 #endif
1680 #ifdef  THREAD
1681         InitRxManagementQueue(pDevice);
1682         mlme_kill = 0;
1683         mlme_task = kthread_run(MlmeThread, (void *)pDevice, "MLME");
1684         if (IS_ERR(mlme_task)) {
1685                 printk("thread create fail\n");
1686                 return -1;
1687         }
1688
1689         mlme_kill = 1;
1690 #endif
1691
1692         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1693         device_init_registers(pDevice, DEVICE_INIT_COLD);
1694         MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1695         memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1696         device_set_multi(pDevice->dev);
1697
1698         // Init for Key Management
1699         KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1700         add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1701
1702 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1703         pDevice->bwextcount = 0;
1704         pDevice->bWPASuppWextEnabled = false;
1705 #endif
1706         pDevice->byReAssocCount = 0;
1707         pDevice->bWPADEVUp = false;
1708         // Patch: if WEP key already set by iwconfig but device not yet open
1709         if (pDevice->bEncryptionEnable && pDevice->bTransmitKey) {
1710                 KeybSetDefaultKey(&(pDevice->sKey),
1711                                   (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1712                                   pDevice->uKeyLength,
1713                                   NULL,
1714                                   pDevice->abyKey,
1715                                   KEY_CTL_WEP,
1716                                   pDevice->PortOffset,
1717                                   pDevice->byLocalID
1718                         );
1719                 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1720         }
1721
1722         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
1723         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
1724
1725         if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1726                 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
1727         } else {
1728                 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1729                 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
1730         }
1731         pDevice->flags |= DEVICE_FLAGS_OPENED;
1732
1733         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1734         return 0;
1735 }
1736
1737 static int  device_close(struct net_device *dev) {
1738         PSDevice  pDevice = (PSDevice)netdev_priv(dev);
1739         PSMgmtObject     pMgmt = pDevice->pMgmt;
1740         //PLICE_DEBUG->
1741 #ifdef  THREAD
1742         mlme_kill = 0;
1743 #endif
1744 //PLICE_DEBUG<-
1745 //2007-1121-02<Add>by EinsnLiu
1746         if (pDevice->bLinkPass) {
1747                 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1748                 mdelay(30);
1749         }
1750 #ifdef TxInSleep
1751         del_timer(&pDevice->sTimerTxData);
1752 #endif
1753         del_timer(&pDevice->sTimerCommand);
1754         del_timer(&pMgmt->sTimerSecondCallback);
1755         if (pDevice->bDiversityRegCtlON) {
1756                 del_timer(&pDevice->TimerSQ3Tmax1);
1757                 del_timer(&pDevice->TimerSQ3Tmax2);
1758                 del_timer(&pDevice->TimerSQ3Tmax3);
1759         }
1760
1761 #ifdef  TASK_LET
1762         tasklet_kill(&pDevice->RxMngWorkItem);
1763 #endif
1764         netif_stop_queue(dev);
1765         pDevice->bCmdRunning = false;
1766         MACbShutdown(pDevice->PortOffset);
1767         MACbSoftwareReset(pDevice->PortOffset);
1768         CARDbRadioPowerOff(pDevice);
1769
1770         pDevice->bLinkPass = false;
1771         memset(pMgmt->abyCurrBSSID, 0, 6);
1772         pMgmt->eCurrState = WMAC_STATE_IDLE;
1773         device_free_td0_ring(pDevice);
1774         device_free_td1_ring(pDevice);
1775         device_free_rd0_ring(pDevice);
1776         device_free_rd1_ring(pDevice);
1777         device_free_frag_buf(pDevice);
1778         device_free_rings(pDevice);
1779         BSSvClearNodeDBTable(pDevice, 0);
1780         free_irq(dev->irq, dev);
1781         pDevice->flags &= (~DEVICE_FLAGS_OPENED);
1782         //2008-0714-01<Add>by chester
1783         device_release_WPADEV(pDevice);
1784
1785         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
1786         return 0;
1787 }
1788
1789 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1790         PSDevice pDevice = netdev_priv(dev);
1791         unsigned char *pbMPDU;
1792         unsigned int cbMPDULen = 0;
1793
1794         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1795         spin_lock_irq(&pDevice->lock);
1796
1797         if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1798                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
1799                 dev_kfree_skb_irq(skb);
1800                 spin_unlock_irq(&pDevice->lock);
1801                 return 0;
1802         }
1803
1804         if (pDevice->bStopTx0Pkt) {
1805                 dev_kfree_skb_irq(skb);
1806                 spin_unlock_irq(&pDevice->lock);
1807                 return 0;
1808         }
1809
1810         cbMPDULen = skb->len;
1811         pbMPDU = skb->data;
1812
1813         vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
1814
1815         spin_unlock_irq(&pDevice->lock);
1816
1817         return 0;
1818 }
1819
1820 bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) {
1821         PSMgmtObject    pMgmt = pDevice->pMgmt;
1822         PSTxDesc        pHeadTD, pLastTD;
1823         unsigned int cbFrameBodySize;
1824         unsigned int uMACfragNum;
1825         unsigned char byPktType;
1826         bool bNeedEncryption = false;
1827         PSKeyItem       pTransmitKey = NULL;
1828         unsigned int cbHeaderSize;
1829         unsigned int ii;
1830         SKeyItem        STempKey;
1831
1832         if (pDevice->bStopTx0Pkt) {
1833                 dev_kfree_skb_irq(skb);
1834                 return false;
1835         }
1836
1837         if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1838                 dev_kfree_skb_irq(skb);
1839                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
1840                 return false;
1841         }
1842
1843         if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
1844                 if (pDevice->uAssocCount == 0) {
1845                         dev_kfree_skb_irq(skb);
1846                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
1847                         return false;
1848                 }
1849         }
1850
1851         pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
1852
1853         pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
1854
1855         memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
1856         cbFrameBodySize = skb->len - ETH_HLEN;
1857
1858         // 802.1H
1859         if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN)
1860                 cbFrameBodySize += 8;
1861
1862         uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
1863
1864         if (uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
1865                 dev_kfree_skb_irq(skb);
1866                 return false;
1867         }
1868         byPktType = (unsigned char)pDevice->byPacketType;
1869
1870         if (pDevice->bFixRate) {
1871                 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
1872                         if (pDevice->uConnectionRate >= RATE_11M)
1873                                 pDevice->wCurrentRate = RATE_11M;
1874                         else
1875                                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1876                 } else {
1877                         if (pDevice->uConnectionRate >= RATE_54M)
1878                                 pDevice->wCurrentRate = RATE_54M;
1879                         else
1880                                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1881                 }
1882         } else {
1883                 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
1884         }
1885
1886         //preamble type
1887         if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble)
1888                 pDevice->byPreambleType = pDevice->byShortPreamble;
1889         else
1890                 pDevice->byPreambleType = PREAMBLE_LONG;
1891
1892         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
1893
1894         if (pDevice->wCurrentRate <= RATE_11M) {
1895                 byPktType = PK_TYPE_11B;
1896         } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
1897                 byPktType = PK_TYPE_11A;
1898         } else {
1899                 if (pDevice->bProtectMode)
1900                         byPktType = PK_TYPE_11GB;
1901                 else
1902                         byPktType = PK_TYPE_11GA;
1903         }
1904
1905         if (pDevice->bEncryptionEnable)
1906                 bNeedEncryption = true;
1907
1908         if (pDevice->bEnableHostWEP) {
1909                 pTransmitKey = &STempKey;
1910                 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
1911                 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
1912                 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
1913                 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
1914                 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
1915                 memcpy(pTransmitKey->abyKey,
1916                        &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
1917                        pTransmitKey->uKeyLength
1918                         );
1919         }
1920         vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
1921                             cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
1922                             &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
1923                             &uMACfragNum,
1924                             &cbHeaderSize
1925                 );
1926
1927         if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
1928                 // Disable PS
1929                 MACbPSWakeup(pDevice->PortOffset);
1930         }
1931
1932         pDevice->bPWBitOn = false;
1933
1934         pLastTD = pHeadTD;
1935         for (ii = 0; ii < uMACfragNum; ii++) {
1936                 // Poll Transmit the adapter
1937                 wmb();
1938                 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
1939                 wmb();
1940                 if (ii == (uMACfragNum - 1))
1941                         pLastTD = pHeadTD;
1942                 pHeadTD = pHeadTD->next;
1943         }
1944
1945         // Save the information needed by the tx interrupt handler
1946         // to complete the Send request
1947         pLastTD->pTDInfo->skb = skb;
1948         pLastTD->pTDInfo->byFlags = 0;
1949         pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
1950
1951         pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
1952
1953         MACvTransmit0(pDevice->PortOffset);
1954
1955         return true;
1956 }
1957
1958 //TYPE_AC0DMA data tx
1959 static int  device_xmit(struct sk_buff *skb, struct net_device *dev) {
1960         PSDevice pDevice = netdev_priv(dev);
1961
1962         PSMgmtObject    pMgmt = pDevice->pMgmt;
1963         PSTxDesc        pHeadTD, pLastTD;
1964         unsigned int uNodeIndex = 0;
1965         unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1966         unsigned short wAID;
1967         unsigned int uMACfragNum = 1;
1968         unsigned int cbFrameBodySize;
1969         unsigned char byPktType;
1970         unsigned int cbHeaderSize;
1971         bool bNeedEncryption = false;
1972         PSKeyItem       pTransmitKey = NULL;
1973         SKeyItem        STempKey;
1974         unsigned int ii;
1975         bool bTKIP_UseGTK = false;
1976         bool bNeedDeAuth = false;
1977         unsigned char *pbyBSSID;
1978         bool bNodeExist = false;
1979
1980         spin_lock_irq(&pDevice->lock);
1981         if (!pDevice->bLinkPass) {
1982                 dev_kfree_skb_irq(skb);
1983                 spin_unlock_irq(&pDevice->lock);
1984                 return 0;
1985         }
1986
1987         if (pDevice->bStopDataPkt) {
1988                 dev_kfree_skb_irq(skb);
1989                 spin_unlock_irq(&pDevice->lock);
1990                 return 0;
1991         }
1992
1993         if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
1994                 if (pDevice->uAssocCount == 0) {
1995                         dev_kfree_skb_irq(skb);
1996                         spin_unlock_irq(&pDevice->lock);
1997                         return 0;
1998                 }
1999                 if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2000                         uNodeIndex = 0;
2001                         bNodeExist = true;
2002                         if (pMgmt->sNodeDBTable[0].bPSEnable) {
2003                                 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2004                                 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2005                                 // set tx map
2006                                 pMgmt->abyPSTxMap[0] |= byMask[0];
2007                                 spin_unlock_irq(&pDevice->lock);
2008                                 return 0;
2009                         }
2010                 } else {
2011                         if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
2012                                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2013                                         skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2014                                         pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2015                                         // set tx map
2016                                         wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2017                                         pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
2018                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2019                                                 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2020                                         spin_unlock_irq(&pDevice->lock);
2021                                         return 0;
2022                                 }
2023
2024                                 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble)
2025                                         pDevice->byPreambleType = pDevice->byShortPreamble;
2026                                 else
2027                                         pDevice->byPreambleType = PREAMBLE_LONG;
2028
2029                                 bNodeExist = true;
2030
2031                         }
2032                 }
2033
2034                 if (!bNodeExist) {
2035                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Unknown STA not found in node DB \n");
2036                         dev_kfree_skb_irq(skb);
2037                         spin_unlock_irq(&pDevice->lock);
2038                         return 0;
2039                 }
2040         }
2041
2042         pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2043
2044         pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2045
2046         memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2047         cbFrameBodySize = skb->len - ETH_HLEN;
2048         // 802.1H
2049         if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN)
2050                 cbFrameBodySize += 8;
2051
2052         if (pDevice->bEncryptionEnable) {
2053                 bNeedEncryption = true;
2054                 // get Transmit key
2055                 do {
2056                         if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2057                             (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2058                                 pbyBSSID = pDevice->abyBSSID;
2059                                 // get pairwise key
2060                                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2061                                         // get group key
2062                                         if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2063                                                 bTKIP_UseGTK = true;
2064                                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2065                                                 break;
2066                                         }
2067                                 } else {
2068                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get PTK.\n");
2069                                         break;
2070                                 }
2071                         } else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2072                                 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;  //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2073                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS Serach Key: \n");
2074                                 for (ii = 0; ii < 6; ii++)
2075                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "%x \n", *(pbyBSSID+ii));
2076                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "\n");
2077
2078                                 // get pairwise key
2079                                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2080                                         break;
2081                         }
2082                         // get group key
2083                         pbyBSSID = pDevice->abyBroadcastAddr;
2084                         if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2085                                 pTransmitKey = NULL;
2086                                 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA)
2087                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2088                                 else
2089                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2090                         } else {
2091                                 bTKIP_UseGTK = true;
2092                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2093                         }
2094                 } while (false);
2095         }
2096
2097         if (pDevice->bEnableHostWEP) {
2098                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "acdma0: STA index %d\n", uNodeIndex);
2099                 if (pDevice->bEncryptionEnable) {
2100                         pTransmitKey = &STempKey;
2101                         pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2102                         pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2103                         pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2104                         pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2105                         pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2106                         memcpy(pTransmitKey->abyKey,
2107                                &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2108                                pTransmitKey->uKeyLength
2109                                 );
2110                 }
2111         }
2112
2113         uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2114
2115         if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2116                 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2117                 dev_kfree_skb_irq(skb);
2118                 spin_unlock_irq(&pDevice->lock);
2119                 return 0;
2120         }
2121
2122         if (pTransmitKey != NULL) {
2123                 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2124                     (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2125                         uMACfragNum = 1; //WEP256 doesn't support fragment
2126                 }
2127         }
2128
2129         byPktType = (unsigned char)pDevice->byPacketType;
2130
2131         if (pDevice->bFixRate) {
2132 #ifdef  PLICE_DEBUG
2133                 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n", pDevice->eCurrentPHYType, pDevice->uConnectionRate);
2134 #endif
2135
2136                 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2137                         if (pDevice->uConnectionRate >= RATE_11M)
2138                                 pDevice->wCurrentRate = RATE_11M;
2139                         else
2140                                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2141                 } else {
2142                         if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2143                             (pDevice->uConnectionRate <= RATE_6M)) {
2144                                 pDevice->wCurrentRate = RATE_6M;
2145                         } else {
2146                                 if (pDevice->uConnectionRate >= RATE_54M)
2147                                         pDevice->wCurrentRate = RATE_54M;
2148                                 else
2149                                         pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2150
2151                         }
2152                 }
2153                 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2154                 pDevice->byTopCCKBasicRate = RATE_1M;
2155                 pDevice->byTopOFDMBasicRate = RATE_6M;
2156         } else {
2157                 //auto rate
2158                 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2159                         if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2160                                 pDevice->wCurrentRate = RATE_1M;
2161                                 pDevice->byACKRate = RATE_1M;
2162                                 pDevice->byTopCCKBasicRate = RATE_1M;
2163                                 pDevice->byTopOFDMBasicRate = RATE_6M;
2164                         } else {
2165                                 pDevice->wCurrentRate = RATE_6M;
2166                                 pDevice->byACKRate = RATE_6M;
2167                                 pDevice->byTopCCKBasicRate = RATE_1M;
2168                                 pDevice->byTopOFDMBasicRate = RATE_6M;
2169                         }
2170                 } else {
2171                         VNTWIFIvGetTxRate(pDevice->pMgmt,
2172                                           pDevice->sTxEthHeader.abyDstAddr,
2173                                           &(pDevice->wCurrentRate),
2174                                           &(pDevice->byACKRate),
2175                                           &(pDevice->byTopCCKBasicRate),
2176                                           &(pDevice->byTopOFDMBasicRate));
2177
2178                 }
2179         }
2180
2181
2182         if (pDevice->wCurrentRate <= RATE_11M) {
2183                 byPktType = PK_TYPE_11B;
2184         } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2185                 byPktType = PK_TYPE_11A;
2186         } else {
2187                 if (pDevice->bProtectMode)
2188                         byPktType = PK_TYPE_11GB;
2189                 else
2190                         byPktType = PK_TYPE_11GA;
2191         }
2192
2193         if (bNeedEncryption) {
2194                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2195                 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2196                         bNeedEncryption = false;
2197                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2198                         if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2199                                 if (pTransmitKey == NULL) {
2200                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Don't Find TX KEY\n");
2201                                 } else {
2202                                         if (bTKIP_UseGTK) {
2203                                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "error: KEY is GTK!!~~\n");
2204                                         } else {
2205                                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2206                                                 bNeedEncryption = true;
2207                                         }
2208                                 }
2209                         }
2210
2211                         if (pDevice->byCntMeasure == 2) {
2212                                 bNeedDeAuth = true;
2213                                 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2214                         }
2215
2216                         if (pDevice->bEnableHostWEP) {
2217                                 if ((uNodeIndex != 0) &&
2218                                     (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2219                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2220                                         bNeedEncryption = true;
2221                                 }
2222                         }
2223                 } else {
2224                         if (pTransmitKey == NULL) {
2225                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return no tx key\n");
2226                                 dev_kfree_skb_irq(skb);
2227                                 spin_unlock_irq(&pDevice->lock);
2228                                 return 0;
2229                         }
2230                 }
2231         }
2232
2233         vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2234                             cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2235                             &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2236                             &uMACfragNum,
2237                             &cbHeaderSize
2238                 );
2239
2240         if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2241                 // Disable PS
2242                 MACbPSWakeup(pDevice->PortOffset);
2243         }
2244         pDevice->bPWBitOn = false;
2245
2246         pLastTD = pHeadTD;
2247         for (ii = 0; ii < uMACfragNum; ii++) {
2248                 // Poll Transmit the adapter
2249                 wmb();
2250                 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2251                 wmb();
2252                 if (ii == uMACfragNum - 1)
2253                         pLastTD = pHeadTD;
2254                 pHeadTD = pHeadTD->next;
2255         }
2256
2257         // Save the information needed by the tx interrupt handler
2258         // to complete the Send request
2259         pLastTD->pTDInfo->skb = skb;
2260         pLastTD->pTDInfo->byFlags = 0;
2261         pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2262 #ifdef TxInSleep
2263         pDevice->nTxDataTimeCout = 0; //2008-8-21 chester <add> for send null packet
2264 #endif
2265         if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1)
2266                 netif_stop_queue(dev);
2267
2268         pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2269
2270         if (pDevice->bFixRate)
2271                 printk("FixRate:Rate is %d,TxPower is %d\n", pDevice->wCurrentRate, pDevice->byCurPwr);
2272
2273         {
2274                 unsigned char Protocol_Version;    //802.1x Authentication
2275                 unsigned char Packet_Type;           //802.1x Authentication
2276                 unsigned char Descriptor_type;
2277                 unsigned short Key_info;
2278                 bool bTxeapol_key = false;
2279                 Protocol_Version = skb->data[ETH_HLEN];
2280                 Packet_Type = skb->data[ETH_HLEN+1];
2281                 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2282                 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2283                 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2284                         if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2285                             (Packet_Type == 3)) {  //802.1x OR eapol-key challenge frame transfer
2286                                 bTxeapol_key = true;
2287                                 if ((Descriptor_type == 254) || (Descriptor_type == 2)) {       //WPA or RSN
2288                                         if (!(Key_info & BIT3) &&   //group-key challenge
2289                                             (Key_info & BIT8) && (Key_info & BIT9)) {    //send 2/2 key
2290                                                 pDevice->fWPA_Authened = true;
2291                                                 if (Descriptor_type == 254)
2292                                                         printk("WPA ");
2293                                                 else
2294                                                         printk("WPA2 ");
2295                                                 printk("Authentication completed!!\n");
2296                                         }
2297                                 }
2298                         }
2299                 }
2300         }
2301
2302         MACvTransmitAC0(pDevice->PortOffset);
2303
2304         dev->trans_start = jiffies;
2305
2306         spin_unlock_irq(&pDevice->lock);
2307         return 0;
2308 }
2309
2310 static  irqreturn_t  device_intr(int irq,  void *dev_instance) {
2311         struct net_device *dev = dev_instance;
2312         PSDevice     pDevice = (PSDevice)netdev_priv(dev);
2313
2314         int             max_count = 0;
2315         unsigned long dwMIBCounter = 0;
2316         PSMgmtObject    pMgmt = pDevice->pMgmt;
2317         unsigned char byOrgPageSel = 0;
2318         int             handled = 0;
2319         unsigned char byData = 0;
2320         int             ii = 0;
2321         unsigned long flags;
2322
2323         MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2324
2325         if (pDevice->dwIsr == 0)
2326                 return IRQ_RETVAL(handled);
2327
2328         if (pDevice->dwIsr == 0xffffffff) {
2329                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2330                 return IRQ_RETVAL(handled);
2331         }
2332
2333         handled = 1;
2334         MACvIntDisable(pDevice->PortOffset);
2335
2336         spin_lock_irqsave(&pDevice->lock, flags);
2337
2338         //Make sure current page is 0
2339         VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2340         if (byOrgPageSel == 1)
2341                 MACvSelectPage0(pDevice->PortOffset);
2342         else
2343                 byOrgPageSel = 0;
2344
2345         MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2346         // TBD....
2347         // Must do this after doing rx/tx, cause ISR bit is slow
2348         // than RD/TD write back
2349         // update ISR counter
2350         STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2351         while (pDevice->dwIsr != 0) {
2352                 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2353                 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2354
2355                 if (pDevice->dwIsr & ISR_FETALERR) {
2356                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2357                         VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2358                         VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2359                         device_error(pDevice, pDevice->dwIsr);
2360                 }
2361
2362                 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2363                         if (pDevice->dwIsr & ISR_MEASURESTART) {
2364                                 // 802.11h measure start
2365                                 pDevice->byOrgChannel = pDevice->byCurrentCh;
2366                                 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2367                                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2368                                 MACvSelectPage1(pDevice->PortOffset);
2369                                 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2370                                 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2371                                 MACvSelectPage0(pDevice->PortOffset);
2372                                 //xxxx
2373                                 if (set_channel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel)) {
2374                                         pDevice->bMeasureInProgress = true;
2375                                         MACvSelectPage1(pDevice->PortOffset);
2376                                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2377                                         MACvSelectPage0(pDevice->PortOffset);
2378                                         pDevice->byBasicMap = 0;
2379                                         pDevice->byCCAFraction = 0;
2380                                         for (ii = 0; ii < 8; ii++)
2381                                                 pDevice->dwRPIs[ii] = 0;
2382
2383                                 } else {
2384                                         // can not measure because set channel fail
2385                                         // clear measure control
2386                                         MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2387                                         s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2388                                         MACvSelectPage1(pDevice->PortOffset);
2389                                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2390                                         MACvSelectPage0(pDevice->PortOffset);
2391                                 }
2392                         }
2393                         if (pDevice->dwIsr & ISR_MEASUREEND) {
2394                                 // 802.11h measure end
2395                                 pDevice->bMeasureInProgress = false;
2396                                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2397                                 MACvSelectPage1(pDevice->PortOffset);
2398                                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2399                                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2400                                 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2401                                 pDevice->byBasicMap |= (byData >> 4);
2402                                 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
2403                                 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
2404                                 // clear measure control
2405                                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2406                                 MACvSelectPage0(pDevice->PortOffset);
2407                                 set_channel(pDevice, pDevice->byOrgChannel);
2408                                 MACvSelectPage1(pDevice->PortOffset);
2409                                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2410                                 MACvSelectPage0(pDevice->PortOffset);
2411                                 if (byData & MSRCTL_FINISH) {
2412                                         // measure success
2413                                         s_vCompleteCurrentMeasure(pDevice, 0);
2414                                 } else {
2415                                         // can not measure because not ready before end of measure time
2416                                         s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2417                                 }
2418                         }
2419                         if (pDevice->dwIsr & ISR_QUIETSTART) {
2420                                 do {
2421                                         ;
2422                                 } while (!CARDbStartQuiet(pDevice));
2423                         }
2424                 }
2425
2426                 if (pDevice->dwIsr & ISR_TBTT) {
2427                         if (pDevice->bEnableFirstQuiet) {
2428                                 pDevice->byQuietStartCount--;
2429                                 if (pDevice->byQuietStartCount == 0) {
2430                                         pDevice->bEnableFirstQuiet = false;
2431                                         MACvSelectPage1(pDevice->PortOffset);
2432                                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
2433                                         MACvSelectPage0(pDevice->PortOffset);
2434                                 }
2435                         }
2436                         if (pDevice->bChannelSwitch &&
2437                             (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
2438                                 pDevice->byChannelSwitchCount--;
2439                                 if (pDevice->byChannelSwitchCount == 0) {
2440                                         pDevice->bChannelSwitch = false;
2441                                         set_channel(pDevice, pDevice->byNewChannel);
2442                                         VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2443                                         MACvSelectPage1(pDevice->PortOffset);
2444                                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2445                                         MACvSelectPage0(pDevice->PortOffset);
2446                                         CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2447
2448                                 }
2449                         }
2450                         if (pDevice->eOPMode != OP_MODE_ADHOC) {
2451                                 if ((pDevice->bUpdateBBVGA) && pDevice->bLinkPass && (pDevice->uCurrRSSI != 0)) {
2452                                         long            ldBm;
2453
2454                                         RFvRSSITodBm(pDevice, (unsigned char) pDevice->uCurrRSSI, &ldBm);
2455                                         for (ii = 0; ii < BB_VGA_LEVEL; ii++) {
2456                                                 if (ldBm < pDevice->ldBmThreshold[ii]) {
2457                                                         pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
2458                                                         break;
2459                                                 }
2460                                         }
2461                                         if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2462                                                 pDevice->uBBVGADiffCount++;
2463                                                 if (pDevice->uBBVGADiffCount == 1) {
2464                                                         // first VGA diff gain
2465                                                         BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2466                                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2467                                                                 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2468                                                 }
2469                                                 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
2470                                                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2471                                                                 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2472                                                         BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2473                                                 }
2474                                         } else {
2475                                                 pDevice->uBBVGADiffCount = 1;
2476                                         }
2477                                 }
2478                         }
2479
2480                         pDevice->bBeaconSent = false;
2481                         if (pDevice->bEnablePSMode)
2482                                 PSbIsNextTBTTWakeUp((void *)pDevice);
2483
2484                         if ((pDevice->eOPMode == OP_MODE_AP) ||
2485                             (pDevice->eOPMode == OP_MODE_ADHOC)) {
2486                                 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2487                                                           (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2488                         }
2489
2490                         /* TODO: adhoc PS mode */
2491
2492                 }
2493
2494                 if (pDevice->dwIsr & ISR_BNTX) {
2495                         if (pDevice->eOPMode == OP_MODE_ADHOC) {
2496                                 pDevice->bIsBeaconBufReadySet = false;
2497                                 pDevice->cbBeaconBufReadySetCnt = 0;
2498                         }
2499
2500                         if (pDevice->eOPMode == OP_MODE_AP) {
2501                                 if (pMgmt->byDTIMCount > 0) {
2502                                         pMgmt->byDTIMCount--;
2503                                         pMgmt->sNodeDBTable[0].bRxPSPoll = false;
2504                                 } else {
2505                                         if (pMgmt->byDTIMCount == 0) {
2506                                                 // check if mutltcast tx bufferring
2507                                                 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2508                                                 pMgmt->sNodeDBTable[0].bRxPSPoll = true;
2509                                                 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2510                                         }
2511                                 }
2512                         }
2513                         pDevice->bBeaconSent = true;
2514
2515                         if (pDevice->bChannelSwitch) {
2516                                 pDevice->byChannelSwitchCount--;
2517                                 if (pDevice->byChannelSwitchCount == 0) {
2518                                         pDevice->bChannelSwitch = false;
2519                                         set_channel(pDevice, pDevice->byNewChannel);
2520                                         VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2521                                         MACvSelectPage1(pDevice->PortOffset);
2522                                         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2523                                         MACvSelectPage0(pDevice->PortOffset);
2524                                         CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2525                                 }
2526                         }
2527
2528                 }
2529
2530                 if (pDevice->dwIsr & ISR_RXDMA0)
2531                         max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2532
2533                 if (pDevice->dwIsr & ISR_RXDMA1)
2534                         max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2535
2536                 if (pDevice->dwIsr & ISR_TXDMA0)
2537                         max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2538
2539                 if (pDevice->dwIsr & ISR_AC0DMA)
2540                         max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2541
2542                 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
2543                         if (pDevice->eOPMode == OP_MODE_AP) {
2544                                 if (pDevice->bShortSlotTime)
2545                                         pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2546                                 else
2547                                         pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2548                         }
2549                         bMgrPrepareBeaconToSend(pDevice, pMgmt);
2550                         pDevice->byCntMeasure = 0;
2551                 }
2552
2553                 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2554
2555                 MACvReceive0(pDevice->PortOffset);
2556                 MACvReceive1(pDevice->PortOffset);
2557
2558                 if (max_count > pDevice->sOpts.int_works)
2559                         break;
2560         }
2561
2562         if (byOrgPageSel == 1)
2563                 MACvSelectPage1(pDevice->PortOffset);
2564
2565         spin_unlock_irqrestore(&pDevice->lock, flags);
2566
2567         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2568
2569         return IRQ_RETVAL(handled);
2570 }
2571
2572 static unsigned const ethernet_polynomial = 0x04c11db7U;
2573 static inline u32 ether_crc(int length, unsigned char *data)
2574 {
2575         int crc = -1;
2576
2577         while (--length >= 0) {
2578                 unsigned char current_octet = *data++;
2579                 int bit;
2580                 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2581                         crc = (crc << 1) ^
2582                                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2583                 }
2584         }
2585         return crc;
2586 }
2587
2588 //2008-8-4 <add> by chester
2589 static int Config_FileGetParameter(unsigned char *string,
2590                                    unsigned char *dest, unsigned char *source)
2591 {
2592         unsigned char buf1[100];
2593         int source_len = strlen(source);
2594
2595         memset(buf1, 0, 100);
2596         strcat(buf1, string);
2597         strcat(buf1, "=");
2598         source += strlen(buf1);
2599
2600         memcpy(dest, source, source_len - strlen(buf1));
2601         return true;
2602 }
2603
2604 int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter)
2605 {
2606         unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
2607         unsigned char tmpbuffer[20];
2608         struct file *file;
2609         int result=0;
2610
2611         if (!buffer) {
2612                 printk("allocate mem for file fail?\n");
2613                 return -1;
2614         }
2615         file = filp_open(CONFIG_PATH, O_RDONLY, 0);
2616         if (IS_ERR(file)) {
2617                 kfree(buffer);
2618                 printk("Config_FileOperation:open file fail?\n");
2619                 return -1;
2620         }
2621
2622         if (kernel_read(file, 0, buffer, 1024) < 0) {
2623                 printk("read file error?\n");
2624                 result = -1;
2625                 goto error1;
2626         }
2627
2628         if (Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
2629                 printk("get parameter error?\n");
2630                 result = -1;
2631                 goto error1;
2632         }
2633
2634         if (memcmp(tmpbuffer,"USA",3)==0) {
2635                 result = ZoneType_USA;
2636         } else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
2637                 result = ZoneType_Japan;
2638         } else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
2639                 result = ZoneType_Europe;
2640         } else {
2641                 result = -1;
2642                 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
2643         }
2644
2645 error1:
2646         kfree(buffer);
2647         fput(file);
2648         return result;
2649 }
2650
2651 static void device_set_multi(struct net_device *dev) {
2652         PSDevice         pDevice = (PSDevice)netdev_priv(dev);
2653
2654         PSMgmtObject     pMgmt = pDevice->pMgmt;
2655         u32              mc_filter[2];
2656         struct netdev_hw_addr *ha;
2657
2658         VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
2659
2660         if (dev->flags & IFF_PROMISC) {         /* Set promiscuous. */
2661                 DBG_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
2662                 /* Unconditionally log net taps. */
2663                 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
2664         } else if ((netdev_mc_count(dev) > pDevice->multicast_limit)
2665                  ||  (dev->flags & IFF_ALLMULTI)) {
2666                 MACvSelectPage1(pDevice->PortOffset);
2667                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
2668                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
2669                 MACvSelectPage0(pDevice->PortOffset);
2670                 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2671         } else {
2672                 memset(mc_filter, 0, sizeof(mc_filter));
2673                 netdev_for_each_mc_addr(ha, dev) {
2674                         int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
2675                         mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
2676                 }
2677                 MACvSelectPage1(pDevice->PortOffset);
2678                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
2679                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
2680                 MACvSelectPage0(pDevice->PortOffset);
2681                 pDevice->byRxMode &= ~(RCR_UNICAST);
2682                 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2683         }
2684
2685         if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2686                 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
2687                 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2688                 pDevice->byRxMode &= ~(RCR_UNICAST);
2689         }
2690
2691         VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
2692         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode);
2693 }
2694
2695 static struct net_device_stats *device_get_stats(struct net_device *dev) {
2696         PSDevice pDevice = (PSDevice)netdev_priv(dev);
2697
2698         return &pDevice->stats;
2699 }
2700
2701 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
2702         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
2703
2704         struct iwreq *wrq = (struct iwreq *)rq;
2705         int rc = 0;
2706         PSMgmtObject pMgmt = pDevice->pMgmt;
2707         PSCmdRequest pReq;
2708
2709         if (pMgmt == NULL) {
2710                 rc = -EFAULT;
2711                 return rc;
2712         }
2713
2714         switch (cmd) {
2715         case SIOCGIWNAME:
2716                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
2717                 break;
2718
2719         case SIOCGIWNWID:     //0x8b03  support
2720                 rc = -EOPNOTSUPP;
2721                 break;
2722
2723                 // Set frequency/channel
2724         case SIOCSIWFREQ:
2725                 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
2726                 break;
2727
2728                 // Get frequency/channel
2729         case SIOCGIWFREQ:
2730                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
2731                 break;
2732
2733                 // Set desired network name (ESSID)
2734         case SIOCSIWESSID:
2735
2736         {
2737                 char essid[IW_ESSID_MAX_SIZE+1];
2738                 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
2739                         rc = -E2BIG;
2740                         break;
2741                 }
2742                 if (copy_from_user(essid, wrq->u.essid.pointer,
2743                                    wrq->u.essid.length)) {
2744                         rc = -EFAULT;
2745                         break;
2746                 }
2747                 rc = iwctl_siwessid(dev, NULL,
2748                                     &(wrq->u.essid), essid);
2749         }
2750         break;
2751
2752         // Get current network name (ESSID)
2753         case SIOCGIWESSID:
2754
2755         {
2756                 char essid[IW_ESSID_MAX_SIZE+1];
2757                 if (wrq->u.essid.pointer)
2758                         rc = iwctl_giwessid(dev, NULL,
2759                                             &(wrq->u.essid), essid);
2760                 if (copy_to_user(wrq->u.essid.pointer,
2761                                  essid,
2762                                  wrq->u.essid.length))
2763                         rc = -EFAULT;
2764         }
2765         break;
2766
2767         case SIOCSIWAP:
2768
2769                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2770                 break;
2771
2772                 // Get current Access Point (BSSID)
2773         case SIOCGIWAP:
2774                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2775                 break;
2776
2777                 // Set desired station name
2778         case SIOCSIWNICKN:
2779                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
2780                 rc = -EOPNOTSUPP;
2781                 break;
2782
2783                 // Get current station name
2784         case SIOCGIWNICKN:
2785                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
2786                 rc = -EOPNOTSUPP;
2787                 break;
2788
2789                 // Set the desired bit-rate
2790         case SIOCSIWRATE:
2791                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2792                 break;
2793
2794                 // Get the current bit-rate
2795         case SIOCGIWRATE:
2796
2797                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2798                 break;
2799
2800                 // Set the desired RTS threshold
2801         case SIOCSIWRTS:
2802
2803                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
2804                 break;
2805
2806                 // Get the current RTS threshold
2807         case SIOCGIWRTS:
2808
2809                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
2810                 break;
2811
2812                 // Set the desired fragmentation threshold
2813         case SIOCSIWFRAG:
2814
2815                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
2816                 break;
2817
2818                 // Get the current fragmentation threshold
2819         case SIOCGIWFRAG:
2820
2821                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
2822                 break;
2823
2824                 // Set mode of operation
2825         case SIOCSIWMODE:
2826                 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
2827                 break;
2828
2829                 // Get mode of operation
2830         case SIOCGIWMODE:
2831                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
2832                 break;
2833
2834                 // Set WEP keys and mode
2835         case SIOCSIWENCODE: {
2836                 char abyKey[WLAN_WEP232_KEYLEN];
2837
2838                 if (wrq->u.encoding.pointer) {
2839                         if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2840                                 rc = -E2BIG;
2841                                 break;
2842                         }
2843                         memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2844                         if (copy_from_user(abyKey,
2845                                            wrq->u.encoding.pointer,
2846                                            wrq->u.encoding.length)) {
2847                                 rc = -EFAULT;
2848                                 break;
2849                         }
2850                 } else if (wrq->u.encoding.length != 0) {
2851                         rc = -EINVAL;
2852                         break;
2853                 }
2854                 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2855         }
2856         break;
2857
2858         // Get the WEP keys and mode
2859         case SIOCGIWENCODE:
2860
2861                 if (!capable(CAP_NET_ADMIN)) {
2862                         rc = -EPERM;
2863                         break;
2864                 }
2865                 {
2866                         char abyKey[WLAN_WEP232_KEYLEN];
2867
2868                         rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2869                         if (rc != 0) break;
2870                         if (wrq->u.encoding.pointer) {
2871                                 if (copy_to_user(wrq->u.encoding.pointer,
2872                                                  abyKey,
2873                                                  wrq->u.encoding.length))
2874                                         rc = -EFAULT;
2875                         }
2876                 }
2877                 break;
2878
2879                 // Get the current Tx-Power
2880         case SIOCGIWTXPOW:
2881                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
2882                 rc = -EOPNOTSUPP;
2883                 break;
2884
2885         case SIOCSIWTXPOW:
2886                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n");
2887                 rc = -EOPNOTSUPP;
2888                 break;
2889
2890         case SIOCSIWRETRY:
2891
2892                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
2893                 break;
2894
2895         case SIOCGIWRETRY:
2896
2897                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
2898                 break;
2899
2900                 // Get range of parameters
2901         case SIOCGIWRANGE:
2902
2903         {
2904                 struct iw_range range;
2905
2906                 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *)&range);
2907                 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
2908                         rc = -EFAULT;
2909         }
2910
2911         break;
2912
2913         case SIOCGIWPOWER:
2914
2915                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
2916                 break;
2917
2918         case SIOCSIWPOWER:
2919
2920                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
2921                 break;
2922
2923         case SIOCGIWSENS:
2924
2925                 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
2926                 break;
2927
2928         case SIOCSIWSENS:
2929                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
2930                 rc = -EOPNOTSUPP;
2931                 break;
2932
2933         case SIOCGIWAPLIST: {
2934                 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
2935
2936                 if (wrq->u.data.pointer) {
2937                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
2938                         if (rc == 0) {
2939                                 if (copy_to_user(wrq->u.data.pointer,
2940                                                  buffer,
2941                                                  (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
2942                                             ))
2943                                         rc = -EFAULT;
2944                         }
2945                 }
2946         }
2947         break;
2948
2949 #ifdef WIRELESS_SPY
2950         // Set the spy list
2951         case SIOCSIWSPY:
2952
2953                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
2954                 rc = -EOPNOTSUPP;
2955                 break;
2956
2957                 // Get the spy list
2958         case SIOCGIWSPY:
2959
2960                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
2961                 rc = -EOPNOTSUPP;
2962                 break;
2963
2964 #endif // WIRELESS_SPY
2965
2966         case SIOCGIWPRIV:
2967                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
2968                 rc = -EOPNOTSUPP;
2969                 break;
2970
2971 //2008-0409-07, <Add> by Einsn Liu
2972 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2973         case SIOCSIWAUTH:
2974                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
2975                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
2976                 break;
2977
2978         case SIOCGIWAUTH:
2979                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
2980                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
2981                 break;
2982
2983         case SIOCSIWGENIE:
2984                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
2985                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2986                 break;
2987
2988         case SIOCGIWGENIE:
2989                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
2990                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2991                 break;
2992
2993         case SIOCSIWENCODEEXT: {
2994                 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
2995                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
2996                 if (wrq->u.encoding.pointer) {
2997                         memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN + 1);
2998                         if (wrq->u.encoding.length > (sizeof(struct iw_encode_ext) + MAX_KEY_LEN)) {
2999                                 rc = -E2BIG;
3000                                 break;
3001                         }
3002                         if (copy_from_user(extra, wrq->u.encoding.pointer, wrq->u.encoding.length)) {
3003                                 rc = -EFAULT;
3004                                 break;
3005                         }
3006                 } else if (wrq->u.encoding.length != 0) {
3007                         rc = -EINVAL;
3008                         break;
3009                 }
3010                 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3011         }
3012         break;
3013
3014         case SIOCGIWENCODEEXT:
3015                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3016                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3017                 break;
3018
3019         case SIOCSIWMLME:
3020                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3021                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3022                 break;
3023
3024 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3025 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3026
3027         case IOCTL_CMD_TEST:
3028
3029                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3030                         rc = -EFAULT;
3031                         break;
3032                 } else {
3033                         rc = 0;
3034                 }
3035                 pReq = (PSCmdRequest)rq;
3036                 pReq->wResult = MAGIC_CODE;
3037                 break;
3038
3039         case IOCTL_CMD_SET:
3040
3041 #ifdef SndEvt_ToAPI
3042                 if ((((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_EVT) &&
3043                     !(pDevice->flags & DEVICE_FLAGS_OPENED))
3044 #else
3045                         if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3046                             (((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_WPA))
3047 #endif
3048                         {
3049                                 rc = -EFAULT;
3050                                 break;
3051                         } else {
3052                                 rc = 0;
3053                         }
3054
3055                 if (test_and_set_bit(0, (void *)&(pMgmt->uCmdBusy)))
3056                         return -EBUSY;
3057
3058                 rc = private_ioctl(pDevice, rq);
3059                 clear_bit(0, (void *)&(pMgmt->uCmdBusy));
3060                 break;
3061
3062         case IOCTL_CMD_HOSTAPD:
3063
3064                 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3065                 break;
3066
3067         case IOCTL_CMD_WPA:
3068
3069                 rc = wpa_ioctl(pDevice, &wrq->u.data);
3070                 break;
3071
3072         case SIOCETHTOOL:
3073                 return ethtool_ioctl(dev, (void *)rq->ifr_data);
3074                 // All other calls are currently unsupported
3075
3076         default:
3077                 rc = -EOPNOTSUPP;
3078                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3079
3080         }
3081
3082         if (pDevice->bCommit) {
3083                 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3084                         netif_stop_queue(pDevice->dev);
3085                         spin_lock_irq(&pDevice->lock);
3086                         bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
3087                         spin_unlock_irq(&pDevice->lock);
3088                 } else {
3089                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3090                         spin_lock_irq(&pDevice->lock);
3091                         pDevice->bLinkPass = false;
3092                         memset(pMgmt->abyCurrBSSID, 0, 6);
3093                         pMgmt->eCurrState = WMAC_STATE_IDLE;
3094                         netif_stop_queue(pDevice->dev);
3095 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3096                         pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3097                         if (!pDevice->bWPASuppWextEnabled)
3098 #endif
3099                                 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3100                         bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3101                         spin_unlock_irq(&pDevice->lock);
3102                 }
3103                 pDevice->bCommit = false;
3104         }
3105
3106         return rc;
3107 }
3108
3109 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3110 {
3111         u32 ethcmd;
3112
3113         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3114                 return -EFAULT;
3115
3116         switch (ethcmd) {
3117         case ETHTOOL_GDRVINFO: {
3118                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3119                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3120                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3121                 if (copy_to_user(useraddr, &info, sizeof(info)))
3122                         return -EFAULT;
3123                 return 0;
3124         }
3125
3126         }
3127
3128         return -EOPNOTSUPP;
3129 }
3130
3131 /*------------------------------------------------------------------*/
3132
3133 MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3134
3135 static struct pci_driver device_driver = {
3136         .name = DEVICE_NAME,
3137         .id_table = vt6655_pci_id_table,
3138         .probe = vt6655_probe,
3139         .remove = vt6655_remove,
3140 #ifdef CONFIG_PM
3141         .suspend = viawget_suspend,
3142         .resume = viawget_resume,
3143 #endif
3144 };
3145
3146 static int __init vt6655_init_module(void)
3147 {
3148         int ret;
3149
3150         ret = pci_register_driver(&device_driver);
3151 #ifdef CONFIG_PM
3152         if (ret >= 0)
3153                 register_reboot_notifier(&device_notifier);
3154 #endif
3155
3156         return ret;
3157 }
3158
3159 static void __exit vt6655_cleanup_module(void)
3160 {
3161 #ifdef CONFIG_PM
3162         unregister_reboot_notifier(&device_notifier);
3163 #endif
3164         pci_unregister_driver(&device_driver);
3165 }
3166
3167 module_init(vt6655_init_module);
3168 module_exit(vt6655_cleanup_module);
3169
3170 #ifdef CONFIG_PM
3171 static int
3172 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3173 {
3174         struct pci_dev *pdev = NULL;
3175         switch (event) {
3176         case SYS_DOWN:
3177         case SYS_HALT:
3178         case SYS_POWER_OFF:
3179                 for_each_pci_dev(pdev) {
3180                         if (pci_dev_driver(pdev) == &device_driver) {
3181                                 if (pci_get_drvdata(pdev))
3182                                         viawget_suspend(pdev, PMSG_HIBERNATE);
3183                         }
3184                 }
3185         }
3186         return NOTIFY_DONE;
3187 }
3188
3189 static int
3190 viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3191 {
3192         int power_status;   // to silence the compiler
3193
3194         PSDevice pDevice = pci_get_drvdata(pcid);
3195         PSMgmtObject  pMgmt = pDevice->pMgmt;
3196
3197         netif_stop_queue(pDevice->dev);
3198         spin_lock_irq(&pDevice->lock);
3199         pci_save_state(pcid);
3200         del_timer(&pDevice->sTimerCommand);
3201         del_timer(&pMgmt->sTimerSecondCallback);
3202         pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3203         pDevice->uCmdDequeueIdx = 0;
3204         pDevice->uCmdEnqueueIdx = 0;
3205         pDevice->bCmdRunning = false;
3206         MACbShutdown(pDevice->PortOffset);
3207         MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3208         pDevice->bLinkPass = false;
3209         memset(pMgmt->abyCurrBSSID, 0, 6);
3210         pMgmt->eCurrState = WMAC_STATE_IDLE;
3211         pci_disable_device(pcid);
3212         power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3213         spin_unlock_irq(&pDevice->lock);
3214         return 0;
3215 }
3216
3217 static int
3218 viawget_resume(struct pci_dev *pcid)
3219 {
3220         PSDevice  pDevice = pci_get_drvdata(pcid);
3221         PSMgmtObject  pMgmt = pDevice->pMgmt;
3222         int power_status;   // to silence the compiler
3223
3224         power_status = pci_set_power_state(pcid, PCI_D0);
3225         power_status = pci_enable_wake(pcid, PCI_D0, 0);
3226         pci_restore_state(pcid);
3227         if (netif_running(pDevice->dev)) {
3228                 spin_lock_irq(&pDevice->lock);
3229                 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3230                 device_init_registers(pDevice, DEVICE_INIT_DXPL);
3231                 if (pMgmt->sNodeDBTable[0].bActive) { // Assoc with BSS
3232                         pMgmt->sNodeDBTable[0].bActive = false;
3233                         pDevice->bLinkPass = false;
3234                         if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3235                                 // In Adhoc, BSS state set back to started.
3236                                 pMgmt->eCurrState = WMAC_STATE_STARTED;
3237                         } else {
3238                                 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3239                                 pMgmt->eCurrState = WMAC_STATE_IDLE;
3240                         }
3241                 }
3242                 init_timer(&pMgmt->sTimerSecondCallback);
3243                 init_timer(&pDevice->sTimerCommand);
3244                 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3245                 BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
3246                 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3247                 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3248                 spin_unlock_irq(&pDevice->lock);
3249         }
3250         return 0;
3251 }
3252
3253 #endif