drivers/staging/vt6655/device_main.c

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