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