SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 sucess,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=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
1109         dev->name,
1110         dev->dev_addr[0],dev->dev_addr[1],dev->dev_addr[2],
1111         dev->dev_addr[3],dev->dev_addr[4],dev->dev_addr[5]);
1112 #ifdef IO_MAP
1113     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx  ",(ULONG) pDevice->ioaddr);
1114     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1115 #else
1116     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ",(ULONG) pDevice->ioaddr,(ULONG) pDevice->PortOffset);
1117     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1118 #endif
1119
1120 }
1121
1122 static BOOL device_init_info(struct pci_dev* pcid, PSDevice* ppDevice,
1123     PCHIP_INFO pChip_info) {
1124
1125     PSDevice p;
1126
1127     memset(*ppDevice,0,sizeof(DEVICE_INFO));
1128
1129     if (pDevice_Infos == NULL) {
1130         pDevice_Infos =*ppDevice;
1131     }
1132     else {
1133         for (p=pDevice_Infos;p->next!=NULL;p=p->next)
1134             do {} while (0);
1135         p->next = *ppDevice;
1136         (*ppDevice)->prev = p;
1137     }
1138
1139     (*ppDevice)->pcid = pcid;
1140     (*ppDevice)->chip_id = pChip_info->chip_id;
1141     (*ppDevice)->io_size = pChip_info->io_size;
1142     (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1143     (*ppDevice)->multicast_limit =32;
1144
1145     spin_lock_init(&((*ppDevice)->lock));
1146
1147     return TRUE;
1148 }
1149
1150 static BOOL device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) {
1151
1152     U16 pci_cmd;
1153     U8  b;
1154     UINT cis_addr;
1155 #ifdef  PLICE_DEBUG
1156         BYTE       pci_config[256];
1157         BYTE    value =0x00;
1158         int             ii,j;
1159         U16     max_lat=0x0000;
1160         memset(pci_config,0x00,256);
1161 #endif
1162
1163     pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1164     pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID);
1165     pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1166     pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd));
1167
1168     pci_set_master(pcid);
1169
1170     pDevice->memaddr = pci_resource_start(pcid,0);
1171     pDevice->ioaddr = pci_resource_start(pcid,1);
1172
1173 #ifdef  DEBUG
1174 //      pDevice->ioaddr = pci_resource_start(pcid, 0);
1175 //      pDevice->memaddr = pci_resource_start(pcid,1);
1176 #endif
1177
1178     cis_addr = pci_resource_start(pcid,2);
1179
1180     pDevice->pcid = pcid;
1181
1182     pci_read_config_byte(pcid, PCI_COMMAND, &b);
1183     pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1184
1185 #ifdef  PLICE_DEBUG
1186         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1187         //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID);
1188         //for (ii=0;ii<0xFF;ii++)
1189         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1190         //max_lat  = 0x20;
1191         //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat);
1192         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1193         //printk("max lat is %x\n",max_lat);
1194
1195         for (ii=0;ii<0xFF;ii++)
1196         {
1197                 pci_read_config_byte(pcid,ii,&value);
1198                 pci_config[ii] = value;
1199         }
1200         for (ii=0,j=1;ii<0x100;ii++,j++)
1201         {
1202                 if (j %16 == 0)
1203                 {
1204                         printk("%x:",pci_config[ii]);
1205                         printk("\n");
1206                 }
1207                 else
1208                 {
1209                         printk("%x:",pci_config[ii]);
1210                 }
1211         }
1212 #endif
1213     return TRUE;
1214 }
1215
1216 static void device_free_info(PSDevice pDevice) {
1217     PSDevice         ptr;
1218     struct net_device*  dev=pDevice->dev;
1219
1220     ASSERT(pDevice);
1221 //2008-0714-01<Add>by chester
1222 device_release_WPADEV(pDevice);
1223
1224 //2008-07-21-01<Add>by MikeLiu
1225 //unregister wpadev
1226    if(wpa_set_wpadev(pDevice, 0)!=0)
1227      printk("unregister wpadev fail?\n");
1228
1229     if (pDevice_Infos==NULL)
1230         return;
1231
1232     for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next)
1233             do {} while (0);
1234
1235     if (ptr==pDevice) {
1236         if (ptr==pDevice_Infos)
1237             pDevice_Infos=ptr->next;
1238         else
1239             ptr->prev->next=ptr->next;
1240     }
1241     else {
1242         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1243         return;
1244     }
1245 #ifdef HOSTAP
1246     if (dev)
1247         hostap_set_hostapd(pDevice, 0, 0);
1248 #endif
1249     if (dev)
1250         unregister_netdev(dev);
1251
1252     if (pDevice->PortOffset)
1253         iounmap((PVOID)pDevice->PortOffset);
1254
1255     if (pDevice->pcid)
1256         pci_release_regions(pDevice->pcid);
1257     if (dev)
1258         free_netdev(dev);
1259
1260     if (pDevice->pcid) {
1261         pci_set_drvdata(pDevice->pcid,NULL);
1262     }
1263 }
1264
1265 static BOOL device_init_rings(PSDevice pDevice) {
1266     void*   vir_pool;
1267
1268
1269     /*allocate all RD/TD rings a single pool*/
1270     vir_pool = pci_alloc_consistent(pDevice->pcid,
1271                     pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1272                     pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1273                     pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1274                     pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1275                     &pDevice->pool_dma);
1276
1277     if (vir_pool == NULL) {
1278         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1279         return FALSE;
1280     }
1281
1282     memset(vir_pool, 0,
1283             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1284             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1285             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1286             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1287           );
1288
1289     pDevice->aRD0Ring = vir_pool;
1290     pDevice->aRD1Ring = vir_pool +
1291                         pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1292
1293
1294     pDevice->rd0_pool_dma = pDevice->pool_dma;
1295     pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1296                             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1297
1298     pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1299                     pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1300                     pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1301                     CB_BEACON_BUF_SIZE +
1302                     CB_MAX_BUF_SIZE,
1303                     &pDevice->tx_bufs_dma0);
1304
1305     if (pDevice->tx0_bufs == NULL) {
1306         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1307         pci_free_consistent(pDevice->pcid,
1308             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1309             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1310             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1311             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1312             vir_pool, pDevice->pool_dma
1313             );
1314         return FALSE;
1315     }
1316
1317     memset(pDevice->tx0_bufs, 0,
1318            pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1319            pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1320            CB_BEACON_BUF_SIZE +
1321            CB_MAX_BUF_SIZE
1322           );
1323
1324     pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1325             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1326
1327     pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1328             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1329
1330
1331     // vir_pool: pvoid type
1332     pDevice->apTD0Rings = vir_pool
1333                           + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1334                           + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1335
1336     pDevice->apTD1Rings = vir_pool
1337             + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1338             + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1339             + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1340
1341
1342     pDevice->tx1_bufs = pDevice->tx0_bufs +
1343             pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1344
1345
1346     pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1347             pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1348
1349     pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1350             CB_BEACON_BUF_SIZE;
1351
1352     pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1353             pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1354
1355
1356     pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1357             pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1358
1359
1360     return TRUE;
1361 }
1362
1363 static void device_free_rings(PSDevice pDevice) {
1364
1365     pci_free_consistent(pDevice->pcid,
1366             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1367             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1368             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1369             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1370             ,
1371             pDevice->aRD0Ring, pDevice->pool_dma
1372         );
1373
1374     if (pDevice->tx0_bufs)
1375         pci_free_consistent(pDevice->pcid,
1376            pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1377            pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1378            CB_BEACON_BUF_SIZE +
1379            CB_MAX_BUF_SIZE,
1380            pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1381         );
1382 }
1383
1384 static void device_init_rd0_ring(PSDevice pDevice) {
1385     int i;
1386     dma_addr_t      curr = pDevice->rd0_pool_dma;
1387     PSRxDesc        pDesc;
1388
1389     /* Init the RD0 ring entries */
1390     for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1391         pDesc = &(pDevice->aRD0Ring[i]);
1392         pDesc->pRDInfo = alloc_rd_info();
1393         ASSERT(pDesc->pRDInfo);
1394         if (!device_alloc_rx_buf(pDevice, pDesc)) {
1395             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1396             pDevice->dev->name);
1397         }
1398         pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1399         pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1400         pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1401     }
1402
1403     if (i > 0)
1404         pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1405     pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1406 }
1407
1408
1409 static void device_init_rd1_ring(PSDevice pDevice) {
1410     int i;
1411     dma_addr_t      curr = pDevice->rd1_pool_dma;
1412     PSRxDesc        pDesc;
1413
1414     /* Init the RD1 ring entries */
1415     for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1416         pDesc = &(pDevice->aRD1Ring[i]);
1417         pDesc->pRDInfo = alloc_rd_info();
1418         ASSERT(pDesc->pRDInfo);
1419         if (!device_alloc_rx_buf(pDevice, pDesc)) {
1420             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1421             pDevice->dev->name);
1422         }
1423         pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1424         pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1425         pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1426     }
1427
1428     if (i > 0)
1429         pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1430     pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1431 }
1432
1433
1434 static void device_init_defrag_cb(PSDevice pDevice) {
1435     int i;
1436     PSDeFragControlBlock pDeF;
1437
1438     /* Init the fragment ctl entries */
1439     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1440         pDeF = &(pDevice->sRxDFCB[i]);
1441         if (!device_alloc_frag_buf(pDevice, pDeF)) {
1442             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1443                 pDevice->dev->name);
1444         };
1445     }
1446     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1447     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1448 }
1449
1450
1451
1452
1453 static void device_free_rd0_ring(PSDevice pDevice) {
1454     int i;
1455
1456     for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1457         PSRxDesc        pDesc =&(pDevice->aRD0Ring[i]);
1458         PDEVICE_RD_INFO  pRDInfo =pDesc->pRDInfo;
1459
1460         pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1461            pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1462
1463         dev_kfree_skb(pRDInfo->skb);
1464
1465         kfree((PVOID)pDesc->pRDInfo);
1466     }
1467
1468 }
1469
1470 static void device_free_rd1_ring(PSDevice pDevice) {
1471     int i;
1472
1473
1474     for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1475         PSRxDesc        pDesc=&(pDevice->aRD1Ring[i]);
1476         PDEVICE_RD_INFO  pRDInfo=pDesc->pRDInfo;
1477
1478         pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1479            pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1480
1481         dev_kfree_skb(pRDInfo->skb);
1482
1483         kfree((PVOID)pDesc->pRDInfo);
1484     }
1485
1486 }
1487
1488 static void device_free_frag_buf(PSDevice pDevice) {
1489     PSDeFragControlBlock pDeF;
1490     int i;
1491
1492     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1493
1494         pDeF = &(pDevice->sRxDFCB[i]);
1495
1496         if (pDeF->skb)
1497             dev_kfree_skb(pDeF->skb);
1498
1499     }
1500
1501 }
1502
1503 static void device_init_td0_ring(PSDevice pDevice) {
1504     int i;
1505     dma_addr_t  curr;
1506     PSTxDesc        pDesc;
1507
1508     curr = pDevice->td0_pool_dma;
1509     for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1510         pDesc = &(pDevice->apTD0Rings[i]);
1511         pDesc->pTDInfo = alloc_td_info();
1512         ASSERT(pDesc->pTDInfo);
1513         if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1514             pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1515             pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1516         }
1517         pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1518         pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1519         pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1520     }
1521
1522     if (i > 0)
1523         pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1524     pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]);
1525
1526 }
1527
1528 static void device_init_td1_ring(PSDevice pDevice) {
1529     int i;
1530     dma_addr_t  curr;
1531     PSTxDesc    pDesc;
1532
1533     /* Init the TD ring entries */
1534     curr=pDevice->td1_pool_dma;
1535     for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) {
1536         pDesc=&(pDevice->apTD1Rings[i]);
1537         pDesc->pTDInfo = alloc_td_info();
1538         ASSERT(pDesc->pTDInfo);
1539         if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1540             pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ;
1541             pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ;
1542         }
1543         pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]);
1544         pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1545         pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1546     }
1547
1548     if (i > 0)
1549         pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1550     pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1551 }
1552
1553
1554
1555 static void device_free_td0_ring(PSDevice pDevice) {
1556     int i;
1557     for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1558         PSTxDesc        pDesc=&(pDevice->apTD0Rings[i]);
1559         PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1560
1561         if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1562             pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,
1563                pTDInfo->skb->len, PCI_DMA_TODEVICE);
1564
1565         if (pTDInfo->skb)
1566             dev_kfree_skb(pTDInfo->skb);
1567
1568         kfree((PVOID)pDesc->pTDInfo);
1569     }
1570 }
1571
1572 static void device_free_td1_ring(PSDevice pDevice) {
1573     int i;
1574
1575     for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1576         PSTxDesc        pDesc=&(pDevice->apTD1Rings[i]);
1577         PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1578
1579         if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1580             pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1581                pTDInfo->skb->len, PCI_DMA_TODEVICE);
1582
1583         if (pTDInfo->skb)
1584             dev_kfree_skb(pTDInfo->skb);
1585
1586         kfree((PVOID)pDesc->pTDInfo);
1587     }
1588
1589 }
1590
1591
1592
1593 /*-----------------------------------------------------------------*/
1594
1595 static int device_rx_srv(PSDevice pDevice, UINT uIdx) {
1596     PSRxDesc    pRD;
1597     int works = 0;
1598
1599
1600     for (pRD = pDevice->pCurrRD[uIdx];
1601          pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1602          pRD = pRD->next) {
1603 //        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1604         if (works++>15)
1605             break;
1606         if (device_receive_frame(pDevice, pRD)) {
1607             if (!device_alloc_rx_buf(pDevice,pRD)) {
1608                     DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1609                     "%s: can not allocate rx buf\n", pDevice->dev->name);
1610                     break;
1611             }
1612         }
1613         pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1614         pDevice->dev->last_rx = jiffies;
1615     }
1616
1617     pDevice->pCurrRD[uIdx]=pRD;
1618
1619     return works;
1620 }
1621
1622
1623 static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1624
1625     PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
1626
1627
1628     pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1629 #ifdef  PLICE_DEBUG
1630         //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb);
1631 #endif
1632     if (pRDInfo->skb==NULL)
1633         return FALSE;
1634     ASSERT(pRDInfo->skb);
1635     pRDInfo->skb->dev = pDevice->dev;
1636     pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1637                                       pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1638     *((unsigned int *) &(pRD->m_rd0RD0)) = 0; /* FIX cast */
1639
1640     pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1641     pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1642     pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1643     pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1644
1645     return TRUE;
1646 }
1647
1648
1649
1650 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1651
1652     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1653     if (pDeF->skb == NULL)
1654         return FALSE;
1655     ASSERT(pDeF->skb);
1656     pDeF->skb->dev = pDevice->dev;
1657
1658     return TRUE;
1659 }
1660
1661
1662
1663 static int device_tx_srv(PSDevice pDevice, UINT uIdx) {
1664     PSTxDesc                 pTD;
1665     BOOL                     bFull=FALSE;
1666     int                      works = 0;
1667     BYTE                     byTsr0;
1668     BYTE                     byTsr1;
1669     UINT                     uFrameSize, uFIFOHeaderSize;
1670     PSTxBufHead              pTxBufHead;
1671     struct net_device_stats* pStats = &pDevice->stats;
1672     struct sk_buff*          skb;
1673     UINT                     uNodeIndex;
1674     PSMgmtObject             pMgmt = pDevice->pMgmt;
1675
1676
1677     for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
1678
1679         if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1680             break;
1681         if (works++>15)
1682             break;
1683
1684         byTsr0 = pTD->m_td0TD0.byTSR0;
1685         byTsr1 = pTD->m_td0TD0.byTSR1;
1686
1687         //Only the status of first TD in the chain is correct
1688         if (pTD->m_td1TD1.byTCR & TCR_STP) {
1689
1690             if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1691                 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1692                 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1693                 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1694                 // Update the statistics based on the Transmit status
1695                 // now, we DO'NT check TSR0_CDH
1696
1697                 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1698                         byTsr0, byTsr1,
1699                         (PBYTE)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1700                         uFrameSize, uIdx);
1701
1702
1703                 BSSvUpdateNodeTxCounter(pDevice,
1704                          byTsr0, byTsr1,
1705                          (PBYTE)(pTD->pTDInfo->buf),
1706                          uFIFOHeaderSize
1707                          );
1708
1709                 if ( !(byTsr1 & TSR1_TERR)) {
1710                     if (byTsr0 != 0) {
1711                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1712                            (INT)uIdx, byTsr1, byTsr0);
1713                     }
1714                     if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1715                         pDevice->s802_11Counter.TransmittedFragmentCount ++;
1716                     }
1717                     pStats->tx_packets++;
1718                     pStats->tx_bytes += pTD->pTDInfo->skb->len;
1719                 }
1720                 else {
1721                      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1722                            (INT)uIdx, byTsr1, byTsr0);
1723                     pStats->tx_errors++;
1724                     pStats->tx_dropped++;
1725                 }
1726             }
1727
1728             if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1729                 if (pDevice->bEnableHostapd) {
1730                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1731                     skb = pTD->pTDInfo->skb;
1732                         skb->dev = pDevice->apdev;
1733                         skb_reset_mac_header(skb);
1734                         skb->pkt_type = PACKET_OTHERHOST;
1735                     //skb->protocol = htons(ETH_P_802_2);
1736                         memset(skb->cb, 0, sizeof(skb->cb));
1737                         netif_rx(skb);
1738                     }
1739             }
1740
1741             if (byTsr1 & TSR1_TERR) {
1742             if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1743                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1744                           (INT)uIdx, byTsr1, byTsr0);
1745             }
1746
1747 //                DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1748 //                          (INT)uIdx, byTsr1, byTsr0);
1749
1750                 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1751                     (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1752                     WORD    wAID;
1753                     BYTE    byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1754
1755                     skb = pTD->pTDInfo->skb;
1756                     if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
1757                         if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1758                             skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1759                             pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1760                             // set tx map
1761                             wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1762                             pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
1763                             pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1764                             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1765                                     ,(INT)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1766                             pStats->tx_errors--;
1767                             pStats->tx_dropped--;
1768                         }
1769                     }
1770                 }
1771             }
1772             device_free_tx_buf(pDevice,pTD);
1773             pDevice->iTDUsed[uIdx]--;
1774         }
1775     }
1776
1777
1778     if (uIdx == TYPE_AC0DMA) {
1779         // RESERV_AC0DMA reserved for relay
1780
1781         if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1782             bFull = TRUE;
1783             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1784         }
1785         if (netif_queue_stopped(pDevice->dev) && (bFull==FALSE)){
1786             netif_wake_queue(pDevice->dev);
1787         }
1788     }
1789
1790
1791     pDevice->apTailTD[uIdx] = pTD;
1792
1793     return works;
1794 }
1795
1796
1797 static void device_error(PSDevice pDevice, WORD status) {
1798
1799     if (status & ISR_FETALERR) {
1800         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1801             "%s: Hardware fatal error.\n",
1802             pDevice->dev->name);
1803         netif_stop_queue(pDevice->dev);
1804         del_timer(&pDevice->sTimerCommand);
1805         del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1806         pDevice->bCmdRunning = FALSE;
1807         MACbShutdown(pDevice->PortOffset);
1808         return;
1809     }
1810
1811 }
1812
1813 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1814     PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1815     struct sk_buff* skb=pTDInfo->skb;
1816
1817     // pre-allocated buf_dma can't be unmapped.
1818     if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1819         pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
1820               PCI_DMA_TODEVICE);
1821     }
1822
1823     if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1824         dev_kfree_skb_irq(skb);
1825
1826     pTDInfo->skb_dma = 0;
1827     pTDInfo->skb = 0;
1828     pTDInfo->byFlags = 0;
1829 }
1830
1831
1832
1833 //PLICE_DEBUG ->
1834 VOID    InitRxManagementQueue(PSDevice  pDevice)
1835 {
1836         pDevice->rxManeQueue.packet_num = 0;
1837         pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1838 }
1839 //PLICE_DEBUG<-
1840
1841
1842
1843
1844
1845 //PLICE_DEBUG ->
1846 INT MlmeThread(
1847      void * Context)
1848 {
1849         PSDevice        pDevice =  (PSDevice) Context;
1850         PSRxMgmtPacket                  pRxMgmtPacket;
1851         // int i ;
1852         //complete(&pDevice->notify);
1853 //printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num);
1854
1855         //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num);
1856         //i = 0;
1857 #if 1
1858         while (1)
1859         {
1860
1861         //printk("DDDD\n");
1862         //down(&pDevice->mlme_semaphore);
1863         // pRxMgmtPacket =  DeQueue(pDevice);
1864 #if 1
1865                 spin_lock_irq(&pDevice->lock);
1866                  while(pDevice->rxManeQueue.packet_num != 0)
1867                 {
1868                          pRxMgmtPacket =  DeQueue(pDevice);
1869                                 //pDevice;
1870                                 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1871                         vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1872                         //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num);
1873
1874                  }
1875                 spin_unlock_irq(&pDevice->lock);
1876                 if (mlme_kill == 0)
1877                 break;
1878                 //udelay(200);
1879 #endif
1880         //printk("Before schedule thread jiffies is %x\n",jiffies);
1881         schedule();
1882         //printk("after schedule thread jiffies is %x\n",jiffies);
1883         if (mlme_kill == 0)
1884                 break;
1885         //printk("i is %d\n",i);
1886         }
1887
1888 #endif
1889         return 0;
1890
1891 }
1892
1893
1894
1895 static int  device_open(struct net_device *dev) {
1896     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1897     int i;
1898 #ifdef WPA_SM_Transtatus
1899     extern SWPAResult wpa_Result;
1900 #endif
1901
1902     pDevice->rx_buf_sz = PKT_BUF_SZ;
1903     if (!device_init_rings(pDevice)) {
1904         return -ENOMEM;
1905     }
1906 //2008-5-13 <add> by chester
1907     i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1908     if (i)
1909         return i;
1910         //printk("DEBUG1\n");
1911 #ifdef WPA_SM_Transtatus
1912      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1913      wpa_Result.proto = 0;
1914      wpa_Result.key_mgmt = 0;
1915      wpa_Result.eap_type = 0;
1916      wpa_Result.authenticated = FALSE;
1917      pDevice->fWPA_Authened = FALSE;
1918 #endif
1919 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1920 device_init_rd0_ring(pDevice);
1921     device_init_rd1_ring(pDevice);
1922     device_init_defrag_cb(pDevice);
1923     device_init_td0_ring(pDevice);
1924     device_init_td1_ring(pDevice);
1925 //    VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
1926
1927
1928     if (pDevice->bDiversityRegCtlON) {
1929         device_init_diversity_timer(pDevice);
1930     }
1931     vMgrObjectInit(pDevice);
1932     vMgrTimerInit(pDevice);
1933
1934 //PLICE_DEBUG->
1935 #ifdef  TASK_LET
1936         tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice);
1937 #endif
1938 #ifdef  THREAD
1939         InitRxManagementQueue(pDevice);
1940         mlme_kill = 0;
1941         mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME");
1942         if (IS_ERR(mlme_task)) {
1943                 printk("thread create fail\n");
1944                 return -1;
1945         }
1946
1947         mlme_kill = 1;
1948 #endif
1949
1950
1951
1952 #if 0
1953         pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM);
1954         if (pDevice->MLMEThr_pid <0 )
1955         {
1956                 printk("unable start thread MlmeThread\n");
1957                 return -1;
1958         }
1959 #endif
1960
1961         //printk("thread id is %d\n",pDevice->MLMEThr_pid);
1962         //printk("Create thread time is %x\n",jiffies);
1963         //wait_for_completion(&pDevice->notify);
1964
1965
1966
1967
1968   // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
1969     //    return -ENOMEM;
1970 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1971         device_init_registers(pDevice, DEVICE_INIT_COLD);
1972     MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1973     memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1974     device_set_multi(pDevice->dev);
1975
1976     // Init for Key Management
1977     KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1978     add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1979
1980         #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1981         /*
1982      pDevice->bwextstep0 = FALSE;
1983      pDevice->bwextstep1 = FALSE;
1984      pDevice->bwextstep2 = FALSE;
1985      pDevice->bwextstep3 = FALSE;
1986      */
1987        pDevice->bwextcount=0;
1988      pDevice->bWPASuppWextEnabled = FALSE;
1989 #endif
1990     pDevice->byReAssocCount = 0;
1991    pDevice->bWPADEVUp = FALSE;
1992     // Patch: if WEP key already set by iwconfig but device not yet open
1993     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1994         KeybSetDefaultKey(&(pDevice->sKey),
1995                             (DWORD)(pDevice->byKeyIndex | (1 << 31)),
1996                             pDevice->uKeyLength,
1997                             NULL,
1998                             pDevice->abyKey,
1999                             KEY_CTL_WEP,
2000                             pDevice->PortOffset,
2001                             pDevice->byLocalID
2002                           );
2003          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
2004     }
2005
2006 //printk("DEBUG2\n");
2007
2008
2009 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
2010         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2011
2012     if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2013         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2014         }
2015         else {
2016         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
2017         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
2018     }
2019     pDevice->flags |=DEVICE_FLAGS_OPENED;
2020
2021     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
2022     return 0;
2023 }
2024
2025
2026 static int  device_close(struct net_device *dev) {
2027     PSDevice  pDevice=(PSDevice) netdev_priv(dev);
2028     PSMgmtObject     pMgmt = pDevice->pMgmt;
2029  //PLICE_DEBUG->
2030 #ifdef  THREAD
2031         mlme_kill = 0;
2032 #endif
2033 //PLICE_DEBUG<-
2034 //2007-1121-02<Add>by EinsnLiu
2035     if (pDevice->bLinkPass) {
2036         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2037         mdelay(30);
2038     }
2039 #ifdef TxInSleep
2040     del_timer(&pDevice->sTimerTxData);
2041 #endif
2042     del_timer(&pDevice->sTimerCommand);
2043     del_timer(&pMgmt->sTimerSecondCallback);
2044     if (pDevice->bDiversityRegCtlON) {
2045         del_timer(&pDevice->TimerSQ3Tmax1);
2046         del_timer(&pDevice->TimerSQ3Tmax2);
2047         del_timer(&pDevice->TimerSQ3Tmax3);
2048     }
2049
2050 #ifdef  TASK_LET
2051         tasklet_kill(&pDevice->RxMngWorkItem);
2052 #endif
2053      netif_stop_queue(dev);
2054     pDevice->bCmdRunning = FALSE;
2055     MACbShutdown(pDevice->PortOffset);
2056     MACbSoftwareReset(pDevice->PortOffset);
2057     CARDbRadioPowerOff(pDevice);
2058
2059     pDevice->bLinkPass = FALSE;
2060     memset(pMgmt->abyCurrBSSID, 0, 6);
2061     pMgmt->eCurrState = WMAC_STATE_IDLE;
2062     device_free_td0_ring(pDevice);
2063     device_free_td1_ring(pDevice);
2064     device_free_rd0_ring(pDevice);
2065     device_free_rd1_ring(pDevice);
2066     device_free_frag_buf(pDevice);
2067     device_free_rings(pDevice);
2068     BSSvClearNodeDBTable(pDevice, 0);
2069     free_irq(dev->irq, dev);
2070     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
2071         //2008-0714-01<Add>by chester
2072 device_release_WPADEV(pDevice);
2073 //PLICE_DEBUG->
2074         //tasklet_kill(&pDevice->RxMngWorkItem);
2075 //PLICE_DEBUG<-
2076     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
2077     return 0;
2078 }
2079
2080
2081
2082 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
2083     PSDevice        pDevice=netdev_priv(dev);
2084     PBYTE           pbMPDU;
2085     UINT            cbMPDULen = 0;
2086
2087
2088     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
2089     spin_lock_irq(&pDevice->lock);
2090
2091     if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2092         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
2093         dev_kfree_skb_irq(skb);
2094         spin_unlock_irq(&pDevice->lock);
2095         return 0;
2096     }
2097
2098     if (pDevice->bStopTx0Pkt == TRUE) {
2099         dev_kfree_skb_irq(skb);
2100         spin_unlock_irq(&pDevice->lock);
2101         return 0;
2102     };
2103
2104     cbMPDULen = skb->len;
2105     pbMPDU = skb->data;
2106
2107     vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
2108
2109     spin_unlock_irq(&pDevice->lock);
2110
2111     return 0;
2112
2113 }
2114
2115
2116
2117 BOOL device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, UINT uNodeIndex) {
2118     PSMgmtObject    pMgmt = pDevice->pMgmt;
2119     PSTxDesc        pHeadTD, pLastTD;
2120     UINT            cbFrameBodySize;
2121     UINT            uMACfragNum;
2122     BYTE            byPktType;
2123     BOOL            bNeedEncryption = FALSE;
2124     PSKeyItem       pTransmitKey = NULL;
2125     UINT            cbHeaderSize;
2126     UINT            ii;
2127     SKeyItem        STempKey;
2128 //    BYTE            byKeyIndex = 0;
2129
2130
2131     if (pDevice->bStopTx0Pkt == TRUE) {
2132         dev_kfree_skb_irq(skb);
2133         return FALSE;
2134     };
2135
2136     if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2137         dev_kfree_skb_irq(skb);
2138         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
2139         return FALSE;
2140     }
2141
2142     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2143         if (pDevice->uAssocCount == 0) {
2144             dev_kfree_skb_irq(skb);
2145             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
2146             return FALSE;
2147         }
2148     }
2149
2150     pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
2151
2152     pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2153
2154     memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2155     cbFrameBodySize = skb->len - U_HEADER_LEN;
2156
2157     // 802.1H
2158     if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2159         cbFrameBodySize += 8;
2160     }
2161     uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2162
2163     if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
2164         dev_kfree_skb_irq(skb);
2165         return FALSE;
2166     }
2167     byPktType = (BYTE)pDevice->byPacketType;
2168
2169
2170     if (pDevice->bFixRate) {
2171         if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2172             if (pDevice->uConnectionRate >= RATE_11M) {
2173                 pDevice->wCurrentRate = RATE_11M;
2174             } else {
2175                 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2176             }
2177         } else {
2178             if (pDevice->uConnectionRate >= RATE_54M)
2179                 pDevice->wCurrentRate = RATE_54M;
2180             else
2181                 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2182         }
2183     }
2184     else {
2185         pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2186     }
2187
2188     //preamble type
2189     if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2190         pDevice->byPreambleType = pDevice->byShortPreamble;
2191     }
2192     else {
2193         pDevice->byPreambleType = PREAMBLE_LONG;
2194     }
2195
2196     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2197
2198
2199     if (pDevice->wCurrentRate <= RATE_11M) {
2200         byPktType = PK_TYPE_11B;
2201     } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2202         byPktType = PK_TYPE_11A;
2203     } else {
2204         if (pDevice->bProtectMode == TRUE) {
2205             byPktType = PK_TYPE_11GB;
2206         } else {
2207             byPktType = PK_TYPE_11GA;
2208         }
2209     }
2210
2211     if (pDevice->bEncryptionEnable == TRUE)
2212         bNeedEncryption = TRUE;
2213
2214     if (pDevice->bEnableHostWEP) {
2215         pTransmitKey = &STempKey;
2216         pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2217         pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2218         pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2219         pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2220         pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2221         memcpy(pTransmitKey->abyKey,
2222             &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2223             pTransmitKey->uKeyLength
2224             );
2225     }
2226     vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2227                         cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2228                         &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2229                         &uMACfragNum,
2230                         &cbHeaderSize
2231                         );
2232
2233     if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2234         // Disable PS
2235         MACbPSWakeup(pDevice->PortOffset);
2236     }
2237
2238     pDevice->bPWBitOn = FALSE;
2239
2240     pLastTD = pHeadTD;
2241     for (ii = 0; ii < uMACfragNum; ii++) {
2242         // Poll Transmit the adapter
2243         wmb();
2244         pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2245         wmb();
2246         if (ii == (uMACfragNum - 1))
2247             pLastTD = pHeadTD;
2248         pHeadTD = pHeadTD->next;
2249     }
2250
2251     // Save the information needed by the tx interrupt handler
2252     // to complete the Send request
2253     pLastTD->pTDInfo->skb = skb;
2254     pLastTD->pTDInfo->byFlags = 0;
2255     pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2256
2257     pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2258
2259     MACvTransmit0(pDevice->PortOffset);
2260
2261
2262     return TRUE;
2263 }
2264
2265 //TYPE_AC0DMA data tx
2266 static int  device_xmit(struct sk_buff *skb, struct net_device *dev) {
2267     PSDevice pDevice=netdev_priv(dev);
2268
2269     PSMgmtObject    pMgmt = pDevice->pMgmt;
2270     PSTxDesc        pHeadTD, pLastTD;
2271     UINT            uNodeIndex = 0;
2272     BYTE            byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2273     WORD            wAID;
2274     UINT            uMACfragNum = 1;
2275     UINT            cbFrameBodySize;
2276     BYTE            byPktType;
2277     UINT            cbHeaderSize;
2278     BOOL            bNeedEncryption = FALSE;
2279     PSKeyItem       pTransmitKey = NULL;
2280     SKeyItem        STempKey;
2281     UINT            ii;
2282     BOOL            bTKIP_UseGTK = FALSE;
2283     BOOL            bNeedDeAuth = FALSE;
2284     PBYTE           pbyBSSID;
2285     BOOL            bNodeExist = FALSE;
2286
2287
2288
2289     spin_lock_irq(&pDevice->lock);
2290     if (pDevice->bLinkPass == FALSE) {
2291         dev_kfree_skb_irq(skb);
2292         spin_unlock_irq(&pDevice->lock);
2293         return 0;
2294     }
2295
2296     if (pDevice->bStopDataPkt) {
2297         dev_kfree_skb_irq(skb);
2298         spin_unlock_irq(&pDevice->lock);
2299         return 0;
2300     }
2301
2302
2303     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2304         if (pDevice->uAssocCount == 0) {
2305             dev_kfree_skb_irq(skb);
2306             spin_unlock_irq(&pDevice->lock);
2307             return 0;
2308         }
2309         if (IS_MULTICAST_ADDRESS((PBYTE)(skb->data))) {
2310             uNodeIndex = 0;
2311             bNodeExist = TRUE;
2312             if (pMgmt->sNodeDBTable[0].bPSEnable) {
2313                 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2314                 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2315                 // set tx map
2316                 pMgmt->abyPSTxMap[0] |= byMask[0];
2317                 spin_unlock_irq(&pDevice->lock);
2318                 return 0;
2319             }
2320 }else {
2321             if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
2322                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2323                     skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2324                     pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2325                     // set tx map
2326                     wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2327                     pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
2328                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2329                              (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2330                     spin_unlock_irq(&pDevice->lock);
2331                     return 0;
2332                 }
2333
2334                 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2335                     pDevice->byPreambleType = pDevice->byShortPreamble;
2336
2337                 }else {
2338                     pDevice->byPreambleType = PREAMBLE_LONG;
2339                 }
2340                 bNodeExist = TRUE;
2341
2342             }
2343         }
2344
2345         if (bNodeExist == FALSE) {
2346             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2347             dev_kfree_skb_irq(skb);
2348             spin_unlock_irq(&pDevice->lock);
2349             return 0;
2350         }
2351     }
2352
2353     pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2354
2355     pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2356
2357
2358     memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2359     cbFrameBodySize = skb->len - U_HEADER_LEN;
2360     // 802.1H
2361     if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2362         cbFrameBodySize += 8;
2363     }
2364
2365
2366     if (pDevice->bEncryptionEnable == TRUE) {
2367         bNeedEncryption = TRUE;
2368         // get Transmit key
2369         do {
2370             if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2371                 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2372                 pbyBSSID = pDevice->abyBSSID;
2373                 // get pairwise key
2374                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2375                     // get group key
2376                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2377                         bTKIP_UseGTK = TRUE;
2378                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2379                         break;
2380                     }
2381                 } else {
2382                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2383                     break;
2384                 }
2385             }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2386
2387                 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;  //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2388                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2389                 for (ii = 0; ii< 6; ii++)
2390                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2391                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2392
2393                 // get pairwise key
2394                 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE)
2395                     break;
2396             }
2397             // get group key
2398             pbyBSSID = pDevice->abyBroadcastAddr;
2399             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2400                 pTransmitKey = NULL;
2401                 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2402                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2403                 }
2404                 else
2405                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2406             } else {
2407                 bTKIP_UseGTK = TRUE;
2408                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2409             }
2410         } while(FALSE);
2411     }
2412
2413     if (pDevice->bEnableHostWEP) {
2414         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2415         if (pDevice->bEncryptionEnable == TRUE) {
2416             pTransmitKey = &STempKey;
2417             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2418             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2419             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2420             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2421             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2422             memcpy(pTransmitKey->abyKey,
2423                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2424                 pTransmitKey->uKeyLength
2425                 );
2426          }
2427     }
2428
2429     uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2430
2431     if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2432         DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2433         dev_kfree_skb_irq(skb);
2434         spin_unlock_irq(&pDevice->lock);
2435         return 0;
2436     }
2437
2438     if (pTransmitKey != NULL) {
2439         if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2440             (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2441             uMACfragNum = 1; //WEP256 doesn't support fragment
2442         }
2443     }
2444
2445     byPktType = (BYTE)pDevice->byPacketType;
2446
2447     if (pDevice->bFixRate) {
2448 #ifdef  PLICE_DEBUG
2449         printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate);
2450 #endif
2451
2452         if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2453             if (pDevice->uConnectionRate >= RATE_11M) {
2454                 pDevice->wCurrentRate = RATE_11M;
2455             } else {
2456                 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2457             }
2458         } else {
2459             if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2460                 (pDevice->uConnectionRate <= RATE_6M)) {
2461                 pDevice->wCurrentRate = RATE_6M;
2462             } else {
2463                 if (pDevice->uConnectionRate >= RATE_54M)
2464                     pDevice->wCurrentRate = RATE_54M;
2465                 else
2466                     pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2467
2468             }
2469         }
2470         pDevice->byACKRate = (BYTE) pDevice->wCurrentRate;
2471         pDevice->byTopCCKBasicRate = RATE_1M;
2472         pDevice->byTopOFDMBasicRate = RATE_6M;
2473     }
2474     else {
2475         //auto rate
2476     if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2477             if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2478                 pDevice->wCurrentRate = RATE_1M;
2479                 pDevice->byACKRate = RATE_1M;
2480                 pDevice->byTopCCKBasicRate = RATE_1M;
2481                 pDevice->byTopOFDMBasicRate = RATE_6M;
2482             } else {
2483                 pDevice->wCurrentRate = RATE_6M;
2484                 pDevice->byACKRate = RATE_6M;
2485                 pDevice->byTopCCKBasicRate = RATE_1M;
2486                 pDevice->byTopOFDMBasicRate = RATE_6M;
2487             }
2488         }
2489         else {
2490                 VNTWIFIvGetTxRate(  pDevice->pMgmt,
2491                                 pDevice->sTxEthHeader.abyDstAddr,
2492                                 &(pDevice->wCurrentRate),
2493                                 &(pDevice->byACKRate),
2494                                 &(pDevice->byTopCCKBasicRate),
2495                                 &(pDevice->byTopOFDMBasicRate));
2496
2497 #if 0
2498 printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n",
2499 pDevice->wCurrentRate,pDevice->byACKRate,
2500 pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate);
2501
2502 #endif
2503
2504 #if 0
2505
2506         pDevice->wCurrentRate = 11;
2507         pDevice->byACKRate = 8;
2508         pDevice->byTopCCKBasicRate = 3;
2509         pDevice->byTopOFDMBasicRate = 8;
2510 #endif
2511
2512
2513                 }
2514     }
2515
2516 //    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2517
2518     if (pDevice->wCurrentRate <= RATE_11M) {
2519         byPktType = PK_TYPE_11B;
2520     } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2521         byPktType = PK_TYPE_11A;
2522     } else {
2523         if (pDevice->bProtectMode == TRUE) {
2524             byPktType = PK_TYPE_11GB;
2525         } else {
2526             byPktType = PK_TYPE_11GA;
2527         }
2528     }
2529
2530 //#ifdef        PLICE_DEBUG
2531 //      printk("FIX RATE:CurrentRate is %d");
2532 //#endif
2533
2534     if (bNeedEncryption == TRUE) {
2535         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2536         if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2537             bNeedEncryption = FALSE;
2538             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2539             if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2540                 if (pTransmitKey == NULL) {
2541                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2542                 }
2543                 else {
2544                     if (bTKIP_UseGTK == TRUE) {
2545                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2546                     }
2547                     else {
2548                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2549                         bNeedEncryption = TRUE;
2550                     }
2551                 }
2552             }
2553
2554             if (pDevice->byCntMeasure == 2) {
2555                 bNeedDeAuth = TRUE;
2556                 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2557             }
2558
2559             if (pDevice->bEnableHostWEP) {
2560                 if ((uNodeIndex != 0) &&
2561                     (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2562                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2563                     bNeedEncryption = TRUE;
2564                  }
2565              }
2566         }
2567         else {
2568             if (pTransmitKey == NULL) {
2569                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2570                 dev_kfree_skb_irq(skb);
2571                 spin_unlock_irq(&pDevice->lock);
2572                 return 0;
2573             }
2574         }
2575     }
2576
2577
2578 #ifdef  PLICE_DEBUG
2579         //if (skb->len == 98)
2580         //{
2581         //      printk("ping:len is %d\n");
2582         //}
2583 #endif
2584     vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2585                         cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2586                         &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2587                         &uMACfragNum,
2588                         &cbHeaderSize
2589                         );
2590
2591     if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2592         // Disable PS
2593         MACbPSWakeup(pDevice->PortOffset);
2594     }
2595     pDevice->bPWBitOn = FALSE;
2596
2597     pLastTD = pHeadTD;
2598     for (ii = 0; ii < uMACfragNum; ii++) {
2599         // Poll Transmit the adapter
2600         wmb();
2601         pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2602         wmb();
2603         if (ii == uMACfragNum - 1)
2604             pLastTD = pHeadTD;
2605         pHeadTD = pHeadTD->next;
2606     }
2607
2608     // Save the information needed by the tx interrupt handler
2609     // to complete the Send request
2610     pLastTD->pTDInfo->skb = skb;
2611     pLastTD->pTDInfo->byFlags = 0;
2612     pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2613 #ifdef TxInSleep
2614   pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet
2615   #endif
2616     if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2617         netif_stop_queue(dev);
2618     }
2619
2620     pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2621 //#ifdef        PLICE_DEBUG
2622         if (pDevice->bFixRate)
2623         {
2624                 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2625         }
2626         else
2627         {
2628                 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2629         }
2630 //#endif
2631
2632 {
2633     BYTE  Protocol_Version;    //802.1x Authentication
2634     BYTE  Packet_Type;           //802.1x Authentication
2635     BYTE  Descriptor_type;
2636     WORD Key_info;
2637 BOOL            bTxeapol_key = FALSE;
2638     Protocol_Version = skb->data[U_HEADER_LEN];
2639     Packet_Type = skb->data[U_HEADER_LEN+1];
2640     Descriptor_type = skb->data[U_HEADER_LEN+1+1+2];
2641     Key_info = (skb->data[U_HEADER_LEN+1+1+2+1] << 8)|(skb->data[U_HEADER_LEN+1+1+2+2]);
2642    if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2643            if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2644                 (Packet_Type==3)) {  //802.1x OR eapol-key challenge frame transfer
2645                         bTxeapol_key = TRUE;
2646                 if((Descriptor_type==254)||(Descriptor_type==2)) {       //WPA or RSN
2647                        if(!(Key_info & BIT3) &&   //group-key challenge
2648                            (Key_info & BIT8) && (Key_info & BIT9)) {    //send 2/2 key
2649                           pDevice->fWPA_Authened = TRUE;
2650                           if(Descriptor_type==254)
2651                               printk("WPA ");
2652                           else
2653                               printk("WPA2 ");
2654                           printk("Authentication completed!!\n");
2655                         }
2656                  }
2657              }
2658    }
2659 }
2660
2661     MACvTransmitAC0(pDevice->PortOffset);
2662 //    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2663
2664     dev->trans_start = jiffies;
2665
2666     spin_unlock_irq(&pDevice->lock);
2667     return 0;
2668
2669 }
2670
2671 static  irqreturn_t  device_intr(int irq,  void *dev_instance) {
2672     struct net_device* dev=dev_instance;
2673     PSDevice     pDevice=(PSDevice) netdev_priv(dev);
2674
2675     int             max_count=0;
2676     DWORD           dwMIBCounter=0;
2677     PSMgmtObject    pMgmt = pDevice->pMgmt;
2678     BYTE            byOrgPageSel=0;
2679     int             handled = 0;
2680     BYTE            byData = 0;
2681     int             ii= 0;
2682 //    BYTE            byRSSI;
2683
2684
2685     MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2686
2687     if (pDevice->dwIsr == 0)
2688         return IRQ_RETVAL(handled);
2689
2690     if (pDevice->dwIsr == 0xffffffff) {
2691         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2692         return IRQ_RETVAL(handled);
2693     }
2694     /*
2695       // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2696
2697         if ((pDevice->dwIsr & ISR_RXDMA0) &&
2698         (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2699         (pDevice->bBSSIDFilter == TRUE)) {
2700         // update RSSI
2701         //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI);
2702         //pDevice->uCurrRSSI = byRSSI;
2703     }
2704     */
2705
2706     handled = 1;
2707     MACvIntDisable(pDevice->PortOffset);
2708     spin_lock_irq(&pDevice->lock);
2709
2710     //Make sure current page is 0
2711     VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2712     if (byOrgPageSel == 1) {
2713         MACvSelectPage0(pDevice->PortOffset);
2714     }
2715     else
2716         byOrgPageSel = 0;
2717
2718     MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2719     // TBD....
2720     // Must do this after doing rx/tx, cause ISR bit is slow
2721     // than RD/TD write back
2722     // update ISR counter
2723     STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2724     while (pDevice->dwIsr != 0) {
2725
2726         STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2727         MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2728
2729         if (pDevice->dwIsr & ISR_FETALERR){
2730             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2731             VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2732             VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2733             device_error(pDevice, pDevice->dwIsr);
2734         }
2735
2736         if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2737
2738             if (pDevice->dwIsr & ISR_MEASURESTART) {
2739                 // 802.11h measure start
2740                 pDevice->byOrgChannel = pDevice->byCurrentCh;
2741                 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2742                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2743                 MACvSelectPage1(pDevice->PortOffset);
2744                 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2745                 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2746                 MACvSelectPage0(pDevice->PortOffset);
2747                //xxxx
2748                // WCMDbFlushCommandQueue(pDevice->pMgmt, TRUE);
2749                 if (CARDbSetChannel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == TRUE) {
2750                     pDevice->bMeasureInProgress = TRUE;
2751                     MACvSelectPage1(pDevice->PortOffset);
2752                     MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2753                     MACvSelectPage0(pDevice->PortOffset);
2754                     pDevice->byBasicMap = 0;
2755                     pDevice->byCCAFraction = 0;
2756                     for(ii=0;ii<8;ii++) {
2757                         pDevice->dwRPIs[ii] = 0;
2758                     }
2759                 } else {
2760                     // can not measure because set channel fail
2761                    // WCMDbResetCommandQueue(pDevice->pMgmt);
2762                     // clear measure control
2763                     MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2764                     s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2765                     MACvSelectPage1(pDevice->PortOffset);
2766                     MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2767                     MACvSelectPage0(pDevice->PortOffset);
2768                 }
2769             }
2770             if (pDevice->dwIsr & ISR_MEASUREEND) {
2771                 // 802.11h measure end
2772                 pDevice->bMeasureInProgress = FALSE;
2773                 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2774                 MACvSelectPage1(pDevice->PortOffset);
2775                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2776                 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2777                 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2778                 pDevice->byBasicMap |= (byData >> 4);
2779                 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
2780                 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
2781                 // clear measure control
2782                 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2783                 MACvSelectPage0(pDevice->PortOffset);
2784                 CARDbSetChannel(pDevice, pDevice->byOrgChannel);
2785                 // WCMDbResetCommandQueue(pDevice->pMgmt);
2786                 MACvSelectPage1(pDevice->PortOffset);
2787                 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2788                 MACvSelectPage0(pDevice->PortOffset);
2789                 if (byData & MSRCTL_FINISH) {
2790                     // measure success
2791                     s_vCompleteCurrentMeasure(pDevice, 0);
2792                 } else {
2793                     // can not measure because not ready before end of measure time
2794                     s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2795                 }
2796             }
2797             if (pDevice->dwIsr & ISR_QUIETSTART) {
2798                 do {
2799                     ;
2800                 } while (CARDbStartQuiet(pDevice) == FALSE);
2801             }
2802         }
2803
2804         if (pDevice->dwIsr & ISR_TBTT) {
2805             if (pDevice->bEnableFirstQuiet == TRUE) {
2806                 pDevice->byQuietStartCount--;
2807                 if (pDevice->byQuietStartCount == 0) {
2808                     pDevice->bEnableFirstQuiet = FALSE;
2809                     MACvSelectPage1(pDevice->PortOffset);
2810                     MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
2811                     MACvSelectPage0(pDevice->PortOffset);
2812                 }
2813             }
2814             if ((pDevice->bChannelSwitch == TRUE) &&
2815                 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
2816                 pDevice->byChannelSwitchCount--;
2817                 if (pDevice->byChannelSwitchCount == 0) {
2818                     pDevice->bChannelSwitch = FALSE;
2819                     CARDbSetChannel(pDevice, pDevice->byNewChannel);
2820                     VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2821                     MACvSelectPage1(pDevice->PortOffset);
2822                     MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2823                     MACvSelectPage0(pDevice->PortOffset);
2824                     CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2825
2826                 }
2827             }
2828             if (pDevice->eOPMode == OP_MODE_ADHOC) {
2829                 //pDevice->bBeaconSent = FALSE;
2830             } else {
2831                 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == TRUE) && (pDevice->uCurrRSSI != 0)) {
2832                     LONG            ldBm;
2833
2834                     RFvRSSITodBm(pDevice, (BYTE) pDevice->uCurrRSSI, &ldBm);
2835                     for (ii=0;ii<BB_VGA_LEVEL;ii++) {
2836                         if (ldBm < pDevice->ldBmThreshold[ii]) {
2837                             pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
2838                             break;
2839                         }
2840                     }
2841                     if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2842                         pDevice->uBBVGADiffCount++;
2843                         if (pDevice->uBBVGADiffCount == 1) {
2844                             // first VGA diff gain
2845                             BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2846                             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2847                                             (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2848                         }
2849                         if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
2850                             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2851                                             (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2852                             BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2853                         }
2854                     } else {
2855                         pDevice->uBBVGADiffCount = 1;
2856                     }
2857                 }
2858             }
2859
2860             pDevice->bBeaconSent = FALSE;
2861             if (pDevice->bEnablePSMode) {
2862                 PSbIsNextTBTTWakeUp((HANDLE)pDevice);
2863             };
2864
2865             if ((pDevice->eOPMode == OP_MODE_AP) ||
2866                 (pDevice->eOPMode == OP_MODE_ADHOC)) {
2867
2868                 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2869                         (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2870             }
2871
2872             if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
2873                 // todo adhoc PS mode
2874             };
2875
2876         }
2877
2878         if (pDevice->dwIsr & ISR_BNTX) {
2879
2880             if (pDevice->eOPMode == OP_MODE_ADHOC) {
2881                 pDevice->bIsBeaconBufReadySet = FALSE;
2882                 pDevice->cbBeaconBufReadySetCnt = 0;
2883             };
2884
2885             if (pDevice->eOPMode == OP_MODE_AP) {
2886                 if(pMgmt->byDTIMCount > 0) {
2887                    pMgmt->byDTIMCount --;
2888                    pMgmt->sNodeDBTable[0].bRxPSPoll = FALSE;
2889                 }
2890                 else {
2891                     if(pMgmt->byDTIMCount == 0) {
2892                         // check if mutltcast tx bufferring
2893                         pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2894                         pMgmt->sNodeDBTable[0].bRxPSPoll = TRUE;
2895                         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2896                     }
2897                 }
2898             }
2899             pDevice->bBeaconSent = TRUE;
2900
2901             if (pDevice->bChannelSwitch == TRUE) {
2902                 pDevice->byChannelSwitchCount--;
2903                 if (pDevice->byChannelSwitchCount == 0) {
2904                     pDevice->bChannelSwitch = FALSE;
2905                     CARDbSetChannel(pDevice, pDevice->byNewChannel);
2906                     VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2907                     MACvSelectPage1(pDevice->PortOffset);
2908                     MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2909                     MACvSelectPage0(pDevice->PortOffset);
2910                     //VNTWIFIbSendBeacon(pDevice->pMgmt);
2911                     CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2912                 }
2913             }
2914
2915         }
2916
2917         if (pDevice->dwIsr & ISR_RXDMA0) {
2918             max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2919         }
2920         if (pDevice->dwIsr & ISR_RXDMA1) {
2921             max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2922         }
2923         if (pDevice->dwIsr & ISR_TXDMA0){
2924             max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2925         }
2926         if (pDevice->dwIsr & ISR_AC0DMA){
2927             max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2928         }
2929         if (pDevice->dwIsr & ISR_SOFTTIMER) {
2930
2931         }
2932         if (pDevice->dwIsr & ISR_SOFTTIMER1) {
2933             if (pDevice->eOPMode == OP_MODE_AP) {
2934                if (pDevice->bShortSlotTime)
2935                    pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2936                else
2937                    pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2938             }
2939             bMgrPrepareBeaconToSend(pDevice, pMgmt);
2940             pDevice->byCntMeasure = 0;
2941         }
2942
2943         MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2944
2945         MACvReceive0(pDevice->PortOffset);
2946         MACvReceive1(pDevice->PortOffset);
2947
2948         if (max_count>pDevice->sOpts.int_works)
2949             break;
2950     }
2951
2952     if (byOrgPageSel == 1) {
2953         MACvSelectPage1(pDevice->PortOffset);
2954     }
2955
2956     spin_unlock_irq(&pDevice->lock);
2957     MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2958
2959     return IRQ_RETVAL(handled);
2960 }
2961
2962
2963 static unsigned const ethernet_polynomial = 0x04c11db7U;
2964 static inline u32 ether_crc(int length, unsigned char *data)
2965 {
2966     int crc = -1;
2967
2968     while(--length >= 0) {
2969         unsigned char current_octet = *data++;
2970         int bit;
2971         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2972             crc = (crc << 1) ^
2973                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2974         }
2975     }
2976     return crc;
2977 }
2978
2979 //2008-8-4 <add> by chester
2980 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
2981 {
2982   UCHAR buf1[100];
2983   int source_len = strlen(source);
2984
2985     memset(buf1,0,100);
2986     strcat(buf1, string);
2987     strcat(buf1, "=");
2988     source+=strlen(buf1);
2989
2990    memcpy(dest,source,source_len-strlen(buf1));
2991  return TRUE;
2992 }
2993
2994 int Config_FileOperation(PSDevice pDevice,BOOL fwrite,unsigned char *Parameter) {
2995     UCHAR    *config_path=CONFIG_PATH;
2996     UCHAR    *buffer=NULL;
2997     UCHAR      tmpbuffer[20];
2998     struct file   *filp=NULL;
2999     mm_segment_t old_fs = get_fs();
3000     //int oldfsuid=0,oldfsgid=0;
3001     int result=0;
3002
3003     set_fs (KERNEL_DS);
3004
3005     /* Can't do this anymore, so we rely on correct filesystem permissions:
3006     //Make sure a caller can read or write power as root
3007     oldfsuid=current->cred->fsuid;
3008     oldfsgid=current->cred->fsgid;
3009     current->cred->fsuid = 0;
3010     current->cred->fsgid = 0;
3011     */
3012
3013     //open file
3014       filp = filp_open(config_path, O_RDWR, 0);
3015         if (IS_ERR(filp)) {
3016              printk("Config_FileOperation:open file fail?\n");
3017              result=-1;
3018              goto error2;
3019           }
3020
3021      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
3022            printk("file %s cann't readable or writable?\n",config_path);
3023           result = -1;
3024           goto error1;
3025         }
3026
3027 buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
3028 if(buffer==NULL) {
3029   printk("alllocate mem for file fail?\n");
3030   result = -1;
3031   goto error1;
3032 }
3033
3034 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
3035  printk("read file error?\n");
3036  result = -1;
3037  goto error1;
3038 }
3039
3040 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=TRUE) {
3041   printk("get parameter error?\n");
3042   result = -1;
3043   goto error1;
3044 }
3045
3046 if(memcmp(tmpbuffer,"USA",3)==0) {
3047   result=ZoneType_USA;
3048 }
3049 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
3050   result=ZoneType_Japan;
3051 }
3052 else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
3053  result=ZoneType_Europe;
3054 }
3055 else {
3056   result = -1;
3057   printk("Unknown Zonetype[%s]?\n",tmpbuffer);
3058 }
3059
3060 error1:
3061   if(buffer)
3062          kfree(buffer);
3063
3064   if(filp_close(filp,NULL))
3065        printk("Config_FileOperation:close file fail\n");
3066
3067 error2:
3068   set_fs (old_fs);
3069
3070   /*
3071   current->cred->fsuid=oldfsuid;
3072   current->cred->fsgid=oldfsgid;
3073   */
3074
3075   return result;
3076 }
3077
3078
3079
3080 static void device_set_multi(struct net_device *dev) {
3081     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
3082
3083     PSMgmtObject     pMgmt = pDevice->pMgmt;
3084     u32              mc_filter[2];
3085     int              i;
3086     struct dev_mc_list  *mclist;
3087
3088
3089     VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
3090
3091     if (dev->flags & IFF_PROMISC) {         /* Set promiscuous. */
3092         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
3093         /* Unconditionally log net taps. */
3094         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
3095     }
3096     else if ((dev->mc_count > pDevice->multicast_limit)
3097         ||  (dev->flags & IFF_ALLMULTI)) {
3098         MACvSelectPage1(pDevice->PortOffset);
3099         VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
3100         VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
3101         MACvSelectPage0(pDevice->PortOffset);
3102         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3103     }
3104     else {
3105         memset(mc_filter, 0, sizeof(mc_filter));
3106         for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3107              i++, mclist = mclist->next) {
3108             int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
3109             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
3110         }
3111         MACvSelectPage1(pDevice->PortOffset);
3112         VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
3113         VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
3114         MACvSelectPage0(pDevice->PortOffset);
3115         pDevice->byRxMode &= ~(RCR_UNICAST);
3116         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3117     }
3118
3119     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3120         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
3121         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3122         pDevice->byRxMode &= ~(RCR_UNICAST);
3123     }
3124
3125     VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
3126     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode );
3127 }
3128
3129
3130 static struct net_device_stats *device_get_stats(struct net_device *dev) {
3131     PSDevice pDevice=(PSDevice) netdev_priv(dev);
3132
3133     return &pDevice->stats;
3134 }
3135
3136
3137
3138 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
3139         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
3140
3141         struct iwreq *wrq = (struct iwreq *) rq;
3142         int                 rc =0;
3143     PSMgmtObject        pMgmt = pDevice->pMgmt;
3144     PSCmdRequest        pReq;
3145
3146
3147     if (pMgmt == NULL) {
3148         rc = -EFAULT;
3149         return rc;
3150     }
3151
3152     switch(cmd) {
3153
3154         case SIOCGIWNAME:
3155                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
3156                 break;
3157
3158         case SIOCGIWNWID:     //0x8b03  support
3159         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3160           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
3161         #else
3162         rc = -EOPNOTSUPP;
3163         #endif
3164                 break;
3165
3166                 // Set frequency/channel
3167         case SIOCSIWFREQ:
3168             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
3169                 break;
3170
3171                 // Get frequency/channel
3172         case SIOCGIWFREQ:
3173                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
3174                 break;
3175
3176                 // Set desired network name (ESSID)
3177         case SIOCSIWESSID:
3178
3179                 {
3180                         char essid[IW_ESSID_MAX_SIZE+1];
3181                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
3182                                 rc = -E2BIG;
3183                                 break;
3184                         }
3185                         if (copy_from_user(essid, wrq->u.essid.pointer,
3186                                            wrq->u.essid.length)) {
3187                                 rc = -EFAULT;
3188                                 break;
3189                         }
3190                         rc = iwctl_siwessid(dev, NULL,
3191                                             &(wrq->u.essid), essid);
3192                 }
3193                 break;
3194
3195
3196                 // Get current network name (ESSID)
3197         case SIOCGIWESSID:
3198
3199                 {
3200                         char essid[IW_ESSID_MAX_SIZE+1];
3201                         if (wrq->u.essid.pointer)
3202                                 rc = iwctl_giwessid(dev, NULL,
3203                                                     &(wrq->u.essid), essid);
3204                                 if (copy_to_user(wrq->u.essid.pointer,
3205                                                          essid,
3206                                                          wrq->u.essid.length) )
3207                                         rc = -EFAULT;
3208                 }
3209                 break;
3210
3211         case SIOCSIWAP:
3212
3213                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3214                 break;
3215
3216
3217                 // Get current Access Point (BSSID)
3218         case SIOCGIWAP:
3219                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3220                 break;
3221
3222
3223                 // Set desired station name
3224         case SIOCSIWNICKN:
3225         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
3226         rc = -EOPNOTSUPP;
3227                 break;
3228
3229                 // Get current station name
3230         case SIOCGIWNICKN:
3231         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
3232         rc = -EOPNOTSUPP;
3233                 break;
3234
3235                 // Set the desired bit-rate
3236         case SIOCSIWRATE:
3237                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3238                 break;
3239
3240         // Get the current bit-rate
3241         case SIOCGIWRATE:
3242
3243                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3244                 break;
3245
3246         // Set the desired RTS threshold
3247         case SIOCSIWRTS:
3248
3249                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
3250                 break;
3251
3252         // Get the current RTS threshold
3253         case SIOCGIWRTS:
3254
3255                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
3256                 break;
3257
3258                 // Set the desired fragmentation threshold
3259         case SIOCSIWFRAG:
3260
3261                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
3262             break;
3263
3264         // Get the current fragmentation threshold
3265         case SIOCGIWFRAG:
3266
3267                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
3268                 break;
3269
3270                 // Set mode of operation
3271         case SIOCSIWMODE:
3272         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
3273                 break;
3274
3275                 // Get mode of operation
3276         case SIOCGIWMODE:
3277                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
3278                 break;
3279
3280                 // Set WEP keys and mode
3281         case SIOCSIWENCODE:
3282                 {
3283             char abyKey[WLAN_WEP232_KEYLEN];
3284
3285                         if (wrq->u.encoding.pointer) {
3286
3287
3288                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
3289                                         rc = -E2BIG;
3290                                         break;
3291                                 }
3292                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
3293                                 if (copy_from_user(abyKey,
3294                                                   wrq->u.encoding.pointer,
3295                                                   wrq->u.encoding.length)) {
3296                                         rc = -EFAULT;
3297                                         break;
3298                                 }
3299                         } else if (wrq->u.encoding.length != 0) {
3300                                 rc = -EINVAL;
3301                                 break;
3302                         }
3303                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3304                 }
3305                 break;
3306
3307                 // Get the WEP keys and mode
3308         case SIOCGIWENCODE:
3309
3310                 if (!capable(CAP_NET_ADMIN)) {
3311                         rc = -EPERM;
3312                         break;
3313                 }
3314                 {
3315                     char abyKey[WLAN_WEP232_KEYLEN];
3316
3317                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3318                     if (rc != 0) break;
3319                         if (wrq->u.encoding.pointer) {
3320                                 if (copy_to_user(wrq->u.encoding.pointer,
3321                                                         abyKey,
3322                                                         wrq->u.encoding.length))
3323                                         rc = -EFAULT;
3324                         }
3325                 }
3326                 break;
3327
3328                 // Get the current Tx-Power
3329         case SIOCGIWTXPOW:
3330         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3331         rc = -EOPNOTSUPP;
3332                 break;
3333
3334         case SIOCSIWTXPOW:
3335         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3336         rc = -EOPNOTSUPP;
3337                 break;
3338
3339         case SIOCSIWRETRY:
3340
3341                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3342                 break;
3343
3344         case SIOCGIWRETRY:
3345
3346                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3347                 break;
3348
3349                 // Get range of parameters
3350         case SIOCGIWRANGE:
3351
3352                 {
3353                         struct iw_range range;
3354
3355                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
3356                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3357                                 rc = -EFAULT;
3358                 }
3359
3360                 break;
3361
3362         case SIOCGIWPOWER:
3363
3364                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3365                 break;
3366
3367
3368         case SIOCSIWPOWER:
3369
3370                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3371                 break;
3372
3373
3374         case SIOCGIWSENS:
3375
3376             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3377                 break;
3378
3379         case SIOCSIWSENS:
3380         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3381                 rc = -EOPNOTSUPP;
3382                 break;
3383
3384         case SIOCGIWAPLIST:
3385             {
3386             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3387
3388                     if (wrq->u.data.pointer) {
3389                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3390                         if (rc == 0) {
3391                     if (copy_to_user(wrq->u.data.pointer,
3392                                                         buffer,
3393                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
3394                                         ))
3395                                     rc = -EFAULT;
3396                         }
3397             }
3398         }
3399                 break;
3400
3401
3402 #ifdef WIRELESS_SPY
3403                 // Set the spy list
3404         case SIOCSIWSPY:
3405
3406         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3407                 rc = -EOPNOTSUPP;
3408                 break;
3409
3410                 // Get the spy list
3411         case SIOCGIWSPY:
3412
3413         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3414                 rc = -EOPNOTSUPP;
3415                 break;
3416
3417 #endif // WIRELESS_SPY
3418
3419         case SIOCGIWPRIV:
3420         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3421                 rc = -EOPNOTSUPP;
3422 /*
3423                 if(wrq->u.data.pointer) {
3424                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
3425
3426                         if(copy_to_user(wrq->u.data.pointer,
3427                                         (u_char *) iwctl_private_args,
3428                                         sizeof(iwctl_private_args)))
3429                                 rc = -EFAULT;
3430                 }
3431 */
3432                 break;
3433
3434
3435 //2008-0409-07, <Add> by Einsn Liu
3436 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3437         case SIOCSIWAUTH:
3438                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3439                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3440                 break;
3441
3442         case SIOCGIWAUTH:
3443                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3444                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3445                 break;
3446
3447         case SIOCSIWGENIE:
3448                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3449                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3450                 break;
3451
3452         case SIOCGIWGENIE:
3453                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3454                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3455                 break;
3456
3457         case SIOCSIWENCODEEXT:
3458                 {
3459                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3460                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3461                         if(wrq->u.encoding.pointer){
3462                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
3463                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
3464                                         rc = -E2BIG;
3465                                         break;
3466                                 }
3467                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
3468                                         rc = -EFAULT;
3469                                         break;
3470                                 }
3471                         }else if(wrq->u.encoding.length != 0){
3472                                 rc = -EINVAL;
3473                                 break;
3474                         }
3475                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3476                 }
3477                 break;
3478
3479         case SIOCGIWENCODEEXT:
3480                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3481                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3482                 break;
3483
3484         case SIOCSIWMLME:
3485                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3486                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3487                 break;
3488
3489 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3490 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3491
3492     case IOCTL_CMD_TEST:
3493
3494                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3495                     rc = -EFAULT;
3496                     break;
3497                 } else {
3498                     rc = 0;
3499                 }
3500         pReq = (PSCmdRequest)rq;
3501         pReq->wResult = MAGIC_CODE;
3502         break;
3503
3504     case IOCTL_CMD_SET:
3505
3506                #ifdef SndEvt_ToAPI
3507                   if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) &&
3508                        !(pDevice->flags & DEVICE_FLAGS_OPENED))
3509               #else
3510                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3511                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
3512               #endif
3513                 {
3514                     rc = -EFAULT;
3515                     break;
3516                 } else {
3517                     rc = 0;
3518                 }
3519
3520             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
3521                     return -EBUSY;
3522             }
3523         rc = private_ioctl(pDevice, rq);
3524         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
3525         break;
3526
3527     case IOCTL_CMD_HOSTAPD:
3528
3529
3530         rc = hostap_ioctl(pDevice, &wrq->u.data);
3531         break;
3532
3533     case IOCTL_CMD_WPA:
3534
3535         rc = wpa_ioctl(pDevice, &wrq->u.data);
3536         break;
3537
3538         case SIOCETHTOOL:
3539         return ethtool_ioctl(dev, (void *) rq->ifr_data);
3540         // All other calls are currently unsupported
3541
3542         default:
3543                 rc = -EOPNOTSUPP;
3544         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3545
3546
3547     }
3548
3549     if (pDevice->bCommit) {
3550        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3551            netif_stop_queue(pDevice->dev);
3552            spin_lock_irq(&pDevice->lock);
3553            bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
3554            spin_unlock_irq(&pDevice->lock);
3555        }
3556        else {
3557            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3558            spin_lock_irq(&pDevice->lock);
3559            pDevice->bLinkPass = FALSE;
3560            memset(pMgmt->abyCurrBSSID, 0, 6);
3561            pMgmt->eCurrState = WMAC_STATE_IDLE;
3562            netif_stop_queue(pDevice->dev);
3563         #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3564               pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3565          if(pDevice->bWPASuppWextEnabled !=TRUE)
3566          #endif
3567            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3568            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
3569            spin_unlock_irq(&pDevice->lock);
3570       }
3571       pDevice->bCommit = FALSE;
3572     }
3573
3574     return rc;
3575 }
3576
3577
3578 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3579 {
3580         u32 ethcmd;
3581
3582         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3583                 return -EFAULT;
3584
3585         switch (ethcmd) {
3586         case ETHTOOL_GDRVINFO: {
3587                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3588                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3589                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3590                 if (copy_to_user(useraddr, &info, sizeof(info)))
3591                         return -EFAULT;
3592                 return 0;
3593         }
3594
3595         }
3596
3597         return -EOPNOTSUPP;
3598 }
3599
3600 /*------------------------------------------------------------------*/
3601
3602 MODULE_DEVICE_TABLE(pci, device_id_table);
3603
3604 static struct pci_driver device_driver = {
3605         name:       DEVICE_NAME,
3606         id_table:   device_id_table,
3607         probe:      device_found1,
3608         remove:     device_remove1,
3609 #ifdef CONFIG_PM
3610         suspend:    viawget_suspend,
3611         resume:     viawget_resume,
3612 #endif
3613 };
3614
3615 static int __init device_init_module(void)
3616 {
3617     int ret;
3618
3619
3620 //    ret=pci_module_init(&device_driver);
3621         //ret = pcie_port_service_register(&device_driver);
3622         ret = pci_register_driver(&device_driver);
3623 #ifdef CONFIG_PM
3624     if(ret >= 0)
3625         register_reboot_notifier(&device_notifier);
3626 #endif
3627
3628     return ret;
3629 }
3630
3631 static void __exit device_cleanup_module(void)
3632 {
3633
3634
3635 #ifdef CONFIG_PM
3636     unregister_reboot_notifier(&device_notifier);
3637 #endif
3638     pci_unregister_driver(&device_driver);
3639
3640 }
3641
3642 module_init(device_init_module);
3643 module_exit(device_cleanup_module);
3644
3645
3646 #ifdef CONFIG_PM
3647 static int
3648 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3649 {
3650     struct pci_dev *pdev = NULL;
3651     switch(event) {
3652     case SYS_DOWN:
3653     case SYS_HALT:
3654     case SYS_POWER_OFF:
3655         while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
3656             if(pci_dev_driver(pdev) == &device_driver) {
3657                 if (pci_get_drvdata(pdev))
3658                     viawget_suspend(pdev, PMSG_HIBERNATE);
3659             }
3660         }
3661     }
3662     return NOTIFY_DONE;
3663 }
3664
3665 static int
3666 viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3667 {
3668     int power_status;   // to silence the compiler
3669
3670     PSDevice pDevice=pci_get_drvdata(pcid);
3671     PSMgmtObject  pMgmt = pDevice->pMgmt;
3672
3673     netif_stop_queue(pDevice->dev);
3674     spin_lock_irq(&pDevice->lock);
3675     pci_save_state(pcid);
3676     del_timer(&pDevice->sTimerCommand);
3677     del_timer(&pMgmt->sTimerSecondCallback);
3678     pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3679     pDevice->uCmdDequeueIdx = 0;
3680     pDevice->uCmdEnqueueIdx = 0;
3681     pDevice->bCmdRunning = FALSE;
3682     MACbShutdown(pDevice->PortOffset);
3683     MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3684     pDevice->bLinkPass = FALSE;
3685     memset(pMgmt->abyCurrBSSID, 0, 6);
3686     pMgmt->eCurrState = WMAC_STATE_IDLE;
3687     pci_disable_device(pcid);
3688     power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3689     spin_unlock_irq(&pDevice->lock);
3690     return 0;
3691 }
3692
3693 static int
3694 viawget_resume(struct pci_dev *pcid)
3695 {
3696     PSDevice  pDevice=pci_get_drvdata(pcid);
3697     PSMgmtObject  pMgmt = pDevice->pMgmt;
3698     int power_status;   // to silence the compiler
3699
3700
3701     power_status = pci_set_power_state(pcid, 0);
3702     power_status = pci_enable_wake(pcid, 0, 0);
3703     pci_restore_state(pcid);
3704     if (netif_running(pDevice->dev)) {
3705         spin_lock_irq(&pDevice->lock);
3706         MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3707         device_init_registers(pDevice, DEVICE_INIT_DXPL);
3708         if (pMgmt->sNodeDBTable[0].bActive == TRUE) { // Assoc with BSS
3709             pMgmt->sNodeDBTable[0].bActive = FALSE;
3710             pDevice->bLinkPass = FALSE;
3711             if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3712                 // In Adhoc, BSS state set back to started.
3713                 pMgmt->eCurrState = WMAC_STATE_STARTED;
3714            }
3715             else {
3716                 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3717                 pMgmt->eCurrState = WMAC_STATE_IDLE;
3718             }
3719         }
3720         init_timer(&pMgmt->sTimerSecondCallback);
3721         init_timer(&pDevice->sTimerCommand);
3722         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3723         BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
3724         bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3725         bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
3726         spin_unlock_irq(&pDevice->lock);
3727     }
3728     return 0;
3729 }
3730
3731 #endif
3732
3733
3734
3735