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 environment, 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 = %pM\n",
 819                 pDevice->abyCurrentNetAddr);
 820
 821     // reset Tx pointer
 822     CARDvSafeResetRx(pDevice);
 823     // reset Rx pointer
 824     CARDvSafeResetTx(pDevice);
 825
 826     if (pDevice->byLocalID <= REV_ID_VT3253_A1) {
 827         MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
 828     }
 829
 830     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 831
 832     // Turn On Rx DMA
 833     MACvReceive0(pDevice->PortOffset);
 834     MACvReceive1(pDevice->PortOffset);
 835
 836     // start the adapter
 837     MACvStart(pDevice->PortOffset);
 838
 839     netif_stop_queue(pDevice->dev);
 840
 841
 842 }
 843
 844
 845
 846 static void device_init_diversity_timer(PSDevice pDevice) {
 847
 848     init_timer(&pDevice->TimerSQ3Tmax1);
 849     pDevice->TimerSQ3Tmax1.data = (unsigned long) pDevice;
 850     pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 851     pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 852
 853     init_timer(&pDevice->TimerSQ3Tmax2);
 854     pDevice->TimerSQ3Tmax2.data = (unsigned long) pDevice;
 855     pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 856     pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 857
 858     init_timer(&pDevice->TimerSQ3Tmax3);
 859     pDevice->TimerSQ3Tmax3.data = (unsigned long) pDevice;
 860     pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack;
 861     pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 862
 863     return;
 864 }
 865
 866
 867 static bool device_release_WPADEV(PSDevice pDevice)
 868 {
 869   viawget_wpa_header *wpahdr;
 870   int ii=0;
 871  // wait_queue_head_t   Set_wait;
 872   //send device close to wpa_supplicnat layer
 873     if (pDevice->bWPADEVUp==true) {
 874                  wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 875                  wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 876                  wpahdr->resp_ie_len = 0;
 877                  wpahdr->req_ie_len = 0;
 878                  skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 879                  pDevice->skb->dev = pDevice->wpadev;
 880                  skb_reset_mac_header(pDevice->skb);
 881                  pDevice->skb->pkt_type = PACKET_HOST;
 882                  pDevice->skb->protocol = htons(ETH_P_802_2);
 883                  memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 884                  netif_rx(pDevice->skb);
 885                  pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 886
 887  //wait release WPADEV
 888               //    init_waitqueue_head(&Set_wait);
 889               //    wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ);    //1s wait
 890               while((pDevice->bWPADEVUp==true)) {
 891                 set_current_state(TASK_UNINTERRUPTIBLE);
 892                  schedule_timeout (HZ/20);          //wait 50ms
 893                  ii++;
 894                 if(ii>20)
 895                   break;
 896               }
 897            }
 898     return true;
 899 }
 900
 901
 902 static const struct net_device_ops device_netdev_ops = {
 903     .ndo_open               = device_open,
 904     .ndo_stop               = device_close,
 905     .ndo_do_ioctl           = device_ioctl,
 906     .ndo_get_stats          = device_get_stats,
 907     .ndo_start_xmit         = device_xmit,
 908     .ndo_set_rx_mode        = device_set_multi,
 909 };
 910
 911
 912
 913 static int __devinit
 914 vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent)
 915 {
 916     static bool bFirst = true;
 917     struct net_device*  dev = NULL;
 918     PCHIP_INFO  pChip_info = (PCHIP_INFO)ent->driver_data;
 919     PSDevice    pDevice;
 920     int         rc;
 921     if (device_nics ++>= MAX_UINTS) {
 922         printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
 923         return -ENODEV;
 924     }
 925
 926
 927     dev = alloc_etherdev(sizeof(DEVICE_INFO));
 928
 929     pDevice = (PSDevice) netdev_priv(dev);
 930
 931     if (dev == NULL) {
 932         printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
 933         return -ENODEV;
 934     }
 935
 936     // Chain it all together
 937    // SET_MODULE_OWNER(dev);
 938     SET_NETDEV_DEV(dev, &pcid->dev);
 939
 940     if (bFirst) {
 941         printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 942         printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
 943         bFirst=false;
 944     }
 945
 946     if (!vt6655_init_info(pcid, &pDevice, pChip_info)) {
 947         return -ENOMEM;
 948     }
 949     pDevice->dev = dev;
 950     pDevice->next_module = root_device_dev;
 951     root_device_dev = dev;
 952
 953     if (pci_enable_device(pcid)) {
 954         device_free_info(pDevice);
 955         return -ENODEV;
 956     }
 957     dev->irq = pcid->irq;
 958
 959 #ifdef  DEBUG
 960         printk("Before get pci_info memaddr is %x\n",pDevice->memaddr);
 961 #endif
 962     if (device_get_pci_info(pDevice,pcid) == false) {
 963         printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
 964         device_free_info(pDevice);
 965         return -ENODEV;
 966     }
 967
 968 #if 1
 969
 970 #ifdef  DEBUG
 971
 972         //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId);
 973         printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size);
 974         {
 975                 int i;
 976                 u32                     bar,len;
 977                 u32 address[] = {
 978                 PCI_BASE_ADDRESS_0,
 979                 PCI_BASE_ADDRESS_1,
 980                 PCI_BASE_ADDRESS_2,
 981                 PCI_BASE_ADDRESS_3,
 982                 PCI_BASE_ADDRESS_4,
 983                 PCI_BASE_ADDRESS_5,
 984                 0};
 985                 for (i=0;address[i];i++)
 986                 {
 987                         //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF);
 988                         pci_read_config_dword(pcid, address[i], &bar);
 989                         printk("bar %d is %x\n",i,bar);
 990                         if (!bar)
 991                         {
 992                                 printk("bar %d not implemented\n",i);
 993                                 continue;
 994                         }
 995                         if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
 996                         /* This is IO */
 997
 998                         len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
 999                         len = len & ~(len - 1);
1000
1001                         printk("IO space:  len in IO %x, BAR %d\n", len, i);
1002                         }
1003                         else
1004                         {
1005                                 len = bar & 0xFFFFFFF0;
1006                                 len = ~len + 1;
1007
1008                                 printk("len in MEM %x, BAR %d\n", len, i);
1009                         }
1010                 }
1011         }
1012 #endif
1013
1014
1015 #endif
1016
1017 #ifdef  DEBUG
1018         //return  0  ;
1019 #endif
1020     pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
1021         //pDevice->PortOffset = (unsigned long)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size);
1022
1023         if(pDevice->PortOffset == 0) {
1024        printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
1025        device_free_info(pDevice);
1026         return -ENODEV;
1027     }
1028
1029
1030
1031
1032     rc = pci_request_regions(pcid, DEVICE_NAME);
1033     if (rc) {
1034         printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
1035         device_free_info(pDevice);
1036         return -ENODEV;
1037     }
1038
1039     dev->base_addr = pDevice->ioaddr;
1040 #ifdef  PLICE_DEBUG
1041         unsigned char   value;
1042
1043         VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1044         printk("Before write: value is %x\n",value);
1045         //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00);
1046         VNSvOutPortB(pDevice->PortOffset,value);
1047         VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1048         printk("After write: value is %x\n",value);
1049 #endif
1050
1051
1052
1053 #ifdef IO_MAP
1054     pDevice->PortOffset = pDevice->ioaddr;
1055 #endif
1056     // do reset
1057     if (!MACbSoftwareReset(pDevice->PortOffset)) {
1058         printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
1059         device_free_info(pDevice);
1060         return -ENODEV;
1061     }
1062     // initial to reload eeprom
1063     MACvInitialize(pDevice->PortOffset);
1064     MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
1065
1066     device_get_options(pDevice, device_nics-1, dev->name);
1067     device_set_options(pDevice);
1068     //Mask out the options cannot be set to the chip
1069     pDevice->sOpts.flags &= pChip_info->flags;
1070
1071     //Enable the chip specified capbilities
1072     pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
1073     pDevice->tx_80211 = device_dma0_tx_80211;
1074     pDevice->sMgmtObj.pAdapter = (void *)pDevice;
1075     pDevice->pMgmt = &(pDevice->sMgmtObj);
1076
1077     dev->irq                = pcid->irq;
1078     dev->netdev_ops         = &device_netdev_ops;
1079
1080         dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1081
1082     rc = register_netdev(dev);
1083     if (rc)
1084     {
1085         printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1086         device_free_info(pDevice);
1087         return -ENODEV;
1088     }
1089 //2008-07-21-01<Add>by MikeLiu
1090 //register wpadev
1091 #if 0
1092    if(wpa_set_wpadev(pDevice, 1)!=0) {
1093      printk("Fail to Register WPADEV?\n");
1094         unregister_netdev(pDevice->dev);
1095         free_netdev(dev);
1096    }
1097 #endif
1098     device_print_info(pDevice);
1099     pci_set_drvdata(pcid, pDevice);
1100     return 0;
1101
1102 }
1103
1104 static void device_print_info(PSDevice pDevice)
1105 {
1106     struct net_device* dev=pDevice->dev;
1107
1108     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n",dev->name, get_chip_name(pDevice->chip_id));
1109     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%pM", dev->name, dev->dev_addr);
1110 #ifdef IO_MAP
1111     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx  ",(unsigned long) pDevice->ioaddr);
1112     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1113 #else
1114     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ",
1115                     (unsigned long) pDevice->ioaddr,(unsigned long) pDevice->PortOffset);
1116     DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1117 #endif
1118
1119 }
1120
1121 static bool __devinit vt6655_init_info(struct pci_dev* pcid, PSDevice* ppDevice,
1122     PCHIP_INFO pChip_info) {
1123
1124     PSDevice p;
1125
1126     memset(*ppDevice,0,sizeof(DEVICE_INFO));
1127
1128     if (pDevice_Infos == NULL) {
1129         pDevice_Infos =*ppDevice;
1130     }
1131     else {
1132         for (p=pDevice_Infos;p->next!=NULL;p=p->next)
1133             do {} while (0);
1134         p->next = *ppDevice;
1135         (*ppDevice)->prev = p;
1136     }
1137
1138     (*ppDevice)->pcid = pcid;
1139     (*ppDevice)->chip_id = pChip_info->chip_id;
1140     (*ppDevice)->io_size = pChip_info->io_size;
1141     (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1142     (*ppDevice)->multicast_limit =32;
1143
1144     spin_lock_init(&((*ppDevice)->lock));
1145
1146     return true;
1147 }
1148
1149 static bool device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) {
1150
1151     u16 pci_cmd;
1152     u8  b;
1153     unsigned int cis_addr;
1154 #ifdef  PLICE_DEBUG
1155         unsigned char pci_config[256];
1156         unsigned char   value =0x00;
1157         int             ii,j;
1158         u16     max_lat=0x0000;
1159         memset(pci_config,0x00,256);
1160 #endif
1161
1162     pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1163     pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID);
1164     pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1165     pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd));
1166
1167     pci_set_master(pcid);
1168
1169     pDevice->memaddr = pci_resource_start(pcid,0);
1170     pDevice->ioaddr = pci_resource_start(pcid,1);
1171
1172 #ifdef  DEBUG
1173 //      pDevice->ioaddr = pci_resource_start(pcid, 0);
1174 //      pDevice->memaddr = pci_resource_start(pcid,1);
1175 #endif
1176
1177     cis_addr = pci_resource_start(pcid,2);
1178
1179     pDevice->pcid = pcid;
1180
1181     pci_read_config_byte(pcid, PCI_COMMAND, &b);
1182     pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1183
1184 #ifdef  PLICE_DEBUG
1185         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1186         //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID);
1187         //for (ii=0;ii<0xFF;ii++)
1188         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1189         //max_lat  = 0x20;
1190         //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat);
1191         //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1192         //printk("max lat is %x\n",max_lat);
1193
1194         for (ii=0;ii<0xFF;ii++)
1195         {
1196                 pci_read_config_byte(pcid,ii,&value);
1197                 pci_config[ii] = value;
1198         }
1199         for (ii=0,j=1;ii<0x100;ii++,j++)
1200         {
1201                 if (j %16 == 0)
1202                 {
1203                         printk("%x:",pci_config[ii]);
1204                         printk("\n");
1205                 }
1206                 else
1207                 {
1208                         printk("%x:",pci_config[ii]);
1209                 }
1210         }
1211 #endif
1212     return true;
1213 }
1214
1215 static void device_free_info(PSDevice pDevice) {
1216     PSDevice         ptr;
1217     struct net_device*  dev=pDevice->dev;
1218
1219     ASSERT(pDevice);
1220 //2008-0714-01<Add>by chester
1221 device_release_WPADEV(pDevice);
1222
1223 //2008-07-21-01<Add>by MikeLiu
1224 //unregister wpadev
1225    if(wpa_set_wpadev(pDevice, 0)!=0)
1226      printk("unregister wpadev fail?\n");
1227
1228     if (pDevice_Infos==NULL)
1229         return;
1230
1231     for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next)
1232             do {} while (0);
1233
1234     if (ptr==pDevice) {
1235         if (ptr==pDevice_Infos)
1236             pDevice_Infos=ptr->next;
1237         else
1238             ptr->prev->next=ptr->next;
1239     }
1240     else {
1241         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1242         return;
1243     }
1244 #ifdef HOSTAP
1245     if (dev)
1246         vt6655_hostap_set_hostapd(pDevice, 0, 0);
1247 #endif
1248     if (dev)
1249         unregister_netdev(dev);
1250
1251     if (pDevice->PortOffset)
1252         iounmap((void *)pDevice->PortOffset);
1253
1254     if (pDevice->pcid)
1255         pci_release_regions(pDevice->pcid);
1256     if (dev)
1257         free_netdev(dev);
1258
1259     if (pDevice->pcid) {
1260         pci_set_drvdata(pDevice->pcid,NULL);
1261     }
1262 }
1263
1264 static bool device_init_rings(PSDevice pDevice) {
1265     void*   vir_pool;
1266
1267
1268     /*allocate all RD/TD rings a single pool*/
1269     vir_pool = pci_alloc_consistent(pDevice->pcid,
1270                     pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1271                     pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1272                     pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1273                     pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1274                     &pDevice->pool_dma);
1275
1276     if (vir_pool == NULL) {
1277         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1278         return false;
1279     }
1280
1281     memset(vir_pool, 0,
1282             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1283             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1284             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1285             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1286           );
1287
1288     pDevice->aRD0Ring = vir_pool;
1289     pDevice->aRD1Ring = vir_pool +
1290                         pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1291
1292
1293     pDevice->rd0_pool_dma = pDevice->pool_dma;
1294     pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1295                             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1296
1297     pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1298                     pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1299                     pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1300                     CB_BEACON_BUF_SIZE +
1301                     CB_MAX_BUF_SIZE,
1302                     &pDevice->tx_bufs_dma0);
1303
1304     if (pDevice->tx0_bufs == NULL) {
1305         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1306         pci_free_consistent(pDevice->pcid,
1307             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1308             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1309             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1310             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1311             vir_pool, pDevice->pool_dma
1312             );
1313         return false;
1314     }
1315
1316     memset(pDevice->tx0_bufs, 0,
1317            pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1318            pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1319            CB_BEACON_BUF_SIZE +
1320            CB_MAX_BUF_SIZE
1321           );
1322
1323     pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1324             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1325
1326     pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1327             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1328
1329
1330     // vir_pool: pvoid type
1331     pDevice->apTD0Rings = vir_pool
1332                           + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1333                           + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1334
1335     pDevice->apTD1Rings = vir_pool
1336             + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1337             + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1338             + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1339
1340
1341     pDevice->tx1_bufs = pDevice->tx0_bufs +
1342             pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1343
1344
1345     pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1346             pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1347
1348     pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1349             CB_BEACON_BUF_SIZE;
1350
1351     pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1352             pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1353
1354
1355     pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1356             pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1357
1358
1359     return true;
1360 }
1361
1362 static void device_free_rings(PSDevice pDevice) {
1363
1364     pci_free_consistent(pDevice->pcid,
1365             pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1366             pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1367             pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1368             pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1369             ,
1370             pDevice->aRD0Ring, pDevice->pool_dma
1371         );
1372
1373     if (pDevice->tx0_bufs)
1374         pci_free_consistent(pDevice->pcid,
1375            pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1376            pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1377            CB_BEACON_BUF_SIZE +
1378            CB_MAX_BUF_SIZE,
1379            pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1380         );
1381 }
1382
1383 static void device_init_rd0_ring(PSDevice pDevice) {
1384     int i;
1385     dma_addr_t      curr = pDevice->rd0_pool_dma;
1386     PSRxDesc        pDesc;
1387
1388     /* Init the RD0 ring entries */
1389     for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1390         pDesc = &(pDevice->aRD0Ring[i]);
1391         pDesc->pRDInfo = alloc_rd_info();
1392         ASSERT(pDesc->pRDInfo);
1393         if (!device_alloc_rx_buf(pDevice, pDesc)) {
1394             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1395             pDevice->dev->name);
1396         }
1397         pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1398         pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1399         pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1400     }
1401
1402     if (i > 0)
1403         pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1404     pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1405 }
1406
1407
1408 static void device_init_rd1_ring(PSDevice pDevice) {
1409     int i;
1410     dma_addr_t      curr = pDevice->rd1_pool_dma;
1411     PSRxDesc        pDesc;
1412
1413     /* Init the RD1 ring entries */
1414     for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1415         pDesc = &(pDevice->aRD1Ring[i]);
1416         pDesc->pRDInfo = alloc_rd_info();
1417         ASSERT(pDesc->pRDInfo);
1418         if (!device_alloc_rx_buf(pDevice, pDesc)) {
1419             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1420             pDevice->dev->name);
1421         }
1422         pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1423         pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1424         pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1425     }
1426
1427     if (i > 0)
1428         pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1429     pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1430 }
1431
1432
1433 static void device_init_defrag_cb(PSDevice pDevice) {
1434     int i;
1435     PSDeFragControlBlock pDeF;
1436
1437     /* Init the fragment ctl entries */
1438     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1439         pDeF = &(pDevice->sRxDFCB[i]);
1440         if (!device_alloc_frag_buf(pDevice, pDeF)) {
1441             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1442                 pDevice->dev->name);
1443         }
1444     }
1445     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1446     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1447 }
1448
1449
1450
1451
1452 static void device_free_rd0_ring(PSDevice pDevice) {
1453     int i;
1454
1455     for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1456         PSRxDesc        pDesc =&(pDevice->aRD0Ring[i]);
1457         PDEVICE_RD_INFO  pRDInfo =pDesc->pRDInfo;
1458
1459         pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1460            pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1461
1462         dev_kfree_skb(pRDInfo->skb);
1463
1464         kfree((void *)pDesc->pRDInfo);
1465     }
1466
1467 }
1468
1469 static void device_free_rd1_ring(PSDevice pDevice) {
1470     int i;
1471
1472
1473     for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1474         PSRxDesc        pDesc=&(pDevice->aRD1Ring[i]);
1475         PDEVICE_RD_INFO  pRDInfo=pDesc->pRDInfo;
1476
1477         pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1478            pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1479
1480         dev_kfree_skb(pRDInfo->skb);
1481
1482         kfree((void *)pDesc->pRDInfo);
1483     }
1484
1485 }
1486
1487 static void device_free_frag_buf(PSDevice pDevice) {
1488     PSDeFragControlBlock pDeF;
1489     int i;
1490
1491     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1492
1493         pDeF = &(pDevice->sRxDFCB[i]);
1494
1495         if (pDeF->skb)
1496             dev_kfree_skb(pDeF->skb);
1497
1498     }
1499
1500 }
1501
1502 static void device_init_td0_ring(PSDevice pDevice) {
1503     int i;
1504     dma_addr_t  curr;
1505     PSTxDesc        pDesc;
1506
1507     curr = pDevice->td0_pool_dma;
1508     for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1509         pDesc = &(pDevice->apTD0Rings[i]);
1510         pDesc->pTDInfo = alloc_td_info();
1511         ASSERT(pDesc->pTDInfo);
1512         if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1513             pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1514             pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1515         }
1516         pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1517         pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1518         pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1519     }
1520
1521     if (i > 0)
1522         pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1523     pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]);
1524
1525 }
1526
1527 static void device_init_td1_ring(PSDevice pDevice) {
1528     int i;
1529     dma_addr_t  curr;
1530     PSTxDesc    pDesc;
1531
1532     /* Init the TD ring entries */
1533     curr=pDevice->td1_pool_dma;
1534     for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) {
1535         pDesc=&(pDevice->apTD1Rings[i]);
1536         pDesc->pTDInfo = alloc_td_info();
1537         ASSERT(pDesc->pTDInfo);
1538         if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1539             pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ;
1540             pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ;
1541         }
1542         pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]);
1543         pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1544         pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1545     }
1546
1547     if (i > 0)
1548         pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1549     pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1550 }
1551
1552
1553
1554 static void device_free_td0_ring(PSDevice pDevice) {
1555     int i;
1556     for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1557         PSTxDesc        pDesc=&(pDevice->apTD0Rings[i]);
1558         PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1559
1560         if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1561             pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,
1562                pTDInfo->skb->len, PCI_DMA_TODEVICE);
1563
1564         if (pTDInfo->skb)
1565             dev_kfree_skb(pTDInfo->skb);
1566
1567         kfree((void *)pDesc->pTDInfo);
1568     }
1569 }
1570
1571 static void device_free_td1_ring(PSDevice pDevice) {
1572     int i;
1573
1574     for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1575         PSTxDesc        pDesc=&(pDevice->apTD1Rings[i]);
1576         PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1577
1578         if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1579             pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1580                pTDInfo->skb->len, PCI_DMA_TODEVICE);
1581
1582         if (pTDInfo->skb)
1583             dev_kfree_skb(pTDInfo->skb);
1584
1585         kfree((void *)pDesc->pTDInfo);
1586     }
1587
1588 }
1589
1590
1591
1592 /*-----------------------------------------------------------------*/
1593
1594 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1595     PSRxDesc    pRD;
1596     int works = 0;
1597
1598
1599     for (pRD = pDevice->pCurrRD[uIdx];
1600          pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1601          pRD = pRD->next) {
1602 //        DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1603         if (works++>15)
1604             break;
1605
1606         if (!pRD->pRDInfo->skb)
1607             break;
1608
1609         if (device_receive_frame(pDevice, pRD)) {
1610             if (!device_alloc_rx_buf(pDevice,pRD)) {
1611                     DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1612                     "%s: can not allocate rx buf\n", pDevice->dev->name);
1613                     break;
1614             }
1615         }
1616         pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1617         pDevice->dev->last_rx = jiffies;
1618     }
1619
1620     pDevice->pCurrRD[uIdx]=pRD;
1621
1622     return works;
1623 }
1624
1625
1626 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1627
1628     PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
1629
1630
1631     pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1632 #ifdef  PLICE_DEBUG
1633         //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb);
1634 #endif
1635     if (pRDInfo->skb==NULL)
1636         return false;
1637     ASSERT(pRDInfo->skb);
1638     pRDInfo->skb->dev = pDevice->dev;
1639     pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1640                                       pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1641     *((unsigned int *) &(pRD->m_rd0RD0)) = 0; /* FIX cast */
1642
1643     pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1644     pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1645     pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1646     pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1647
1648     return true;
1649 }
1650
1651
1652
1653 bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1654
1655     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1656     if (pDeF->skb == NULL)
1657         return false;
1658     ASSERT(pDeF->skb);
1659     pDeF->skb->dev = pDevice->dev;
1660
1661     return true;
1662 }
1663
1664
1665
1666 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1667     PSTxDesc                 pTD;
1668     bool bFull=false;
1669     int                      works = 0;
1670     unsigned char byTsr0;
1671     unsigned char byTsr1;
1672     unsigned int        uFrameSize, uFIFOHeaderSize;
1673     PSTxBufHead              pTxBufHead;
1674     struct net_device_stats* pStats = &pDevice->stats;
1675     struct sk_buff*          skb;
1676     unsigned int        uNodeIndex;
1677     PSMgmtObject             pMgmt = pDevice->pMgmt;
1678
1679
1680     for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
1681
1682         if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1683             break;
1684         if (works++>15)
1685             break;
1686
1687         byTsr0 = pTD->m_td0TD0.byTSR0;
1688         byTsr1 = pTD->m_td0TD0.byTSR1;
1689
1690         //Only the status of first TD in the chain is correct
1691         if (pTD->m_td1TD1.byTCR & TCR_STP) {
1692
1693             if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1694                 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1695                 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1696                 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1697                 // Update the statistics based on the Transmit status
1698                 // now, we DO'NT check TSR0_CDH
1699
1700                 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1701                         byTsr0, byTsr1,
1702                         (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1703                         uFrameSize, uIdx);
1704
1705
1706                 BSSvUpdateNodeTxCounter(pDevice,
1707                          byTsr0, byTsr1,
1708                          (unsigned char *)(pTD->pTDInfo->buf),
1709                          uFIFOHeaderSize
1710                          );
1711
1712                 if ( !(byTsr1 & TSR1_TERR)) {
1713                     if (byTsr0 != 0) {
1714                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1715                            (int)uIdx, byTsr1, byTsr0);
1716                     }
1717                     if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1718                         pDevice->s802_11Counter.TransmittedFragmentCount ++;
1719                     }
1720                     pStats->tx_packets++;
1721                     pStats->tx_bytes += pTD->pTDInfo->skb->len;
1722                 }
1723                 else {
1724                      DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1725                            (int)uIdx, byTsr1, byTsr0);
1726                     pStats->tx_errors++;
1727                     pStats->tx_dropped++;
1728                 }
1729             }
1730
1731             if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1732                 if (pDevice->bEnableHostapd) {
1733                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1734                     skb = pTD->pTDInfo->skb;
1735                         skb->dev = pDevice->apdev;
1736                         skb_reset_mac_header(skb);
1737                         skb->pkt_type = PACKET_OTHERHOST;
1738                     //skb->protocol = htons(ETH_P_802_2);
1739                         memset(skb->cb, 0, sizeof(skb->cb));
1740                         netif_rx(skb);
1741                     }
1742             }
1743
1744             if (byTsr1 & TSR1_TERR) {
1745             if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1746                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1747                           (int)uIdx, byTsr1, byTsr0);
1748             }
1749
1750 //                DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1751 //                          (int)uIdx, byTsr1, byTsr0);
1752
1753                 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1754                     (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1755                     unsigned short wAID;
1756                     unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1757
1758                     skb = pTD->pTDInfo->skb;
1759                     if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
1760                         if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1761                             skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1762                             pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1763                             // set tx map
1764                             wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1765                             pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
1766                             pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1767                             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1768                                     ,(int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1769                             pStats->tx_errors--;
1770                             pStats->tx_dropped--;
1771                         }
1772                     }
1773                 }
1774             }
1775             device_free_tx_buf(pDevice,pTD);
1776             pDevice->iTDUsed[uIdx]--;
1777         }
1778     }
1779
1780
1781     if (uIdx == TYPE_AC0DMA) {
1782         // RESERV_AC0DMA reserved for relay
1783
1784         if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1785             bFull = true;
1786             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1787         }
1788         if (netif_queue_stopped(pDevice->dev) && (bFull==false)){
1789             netif_wake_queue(pDevice->dev);
1790         }
1791     }
1792
1793
1794     pDevice->apTailTD[uIdx] = pTD;
1795
1796     return works;
1797 }
1798
1799
1800 static void device_error(PSDevice pDevice, unsigned short status) {
1801
1802     if (status & ISR_FETALERR) {
1803         DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1804             "%s: Hardware fatal error.\n",
1805             pDevice->dev->name);
1806         netif_stop_queue(pDevice->dev);
1807         del_timer(&pDevice->sTimerCommand);
1808         del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1809         pDevice->bCmdRunning = false;
1810         MACbShutdown(pDevice->PortOffset);
1811         return;
1812     }
1813
1814 }
1815
1816 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1817     PDEVICE_TD_INFO  pTDInfo=pDesc->pTDInfo;
1818     struct sk_buff* skb=pTDInfo->skb;
1819
1820     // pre-allocated buf_dma can't be unmapped.
1821     if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1822         pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
1823               PCI_DMA_TODEVICE);
1824     }
1825
1826     if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1827         dev_kfree_skb_irq(skb);
1828
1829     pTDInfo->skb_dma = 0;
1830     pTDInfo->skb = 0;
1831     pTDInfo->byFlags = 0;
1832 }
1833
1834
1835
1836 //PLICE_DEBUG ->
1837 void    InitRxManagementQueue(PSDevice  pDevice)
1838 {
1839         pDevice->rxManeQueue.packet_num = 0;
1840         pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1841 }
1842 //PLICE_DEBUG<-
1843
1844
1845
1846
1847
1848 //PLICE_DEBUG ->
1849 int MlmeThread(
1850      void * Context)
1851 {
1852         PSDevice        pDevice =  (PSDevice) Context;
1853         PSRxMgmtPacket                  pRxMgmtPacket;
1854         // int i ;
1855         //complete(&pDevice->notify);
1856 //printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num);
1857
1858         //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num);
1859         //i = 0;
1860 #if 1
1861         while (1)
1862         {
1863
1864         //printk("DDDD\n");
1865         //down(&pDevice->mlme_semaphore);
1866         // pRxMgmtPacket =  DeQueue(pDevice);
1867 #if 1
1868                 spin_lock_irq(&pDevice->lock);
1869                  while(pDevice->rxManeQueue.packet_num != 0)
1870                 {
1871                          pRxMgmtPacket =  DeQueue(pDevice);
1872                                 //pDevice;
1873                                 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1874                         vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1875                         //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num);
1876
1877                  }
1878                 spin_unlock_irq(&pDevice->lock);
1879                 if (mlme_kill == 0)
1880                 break;
1881                 //udelay(200);
1882 #endif
1883         //printk("Before schedule thread jiffies is %x\n",jiffies);
1884         schedule();
1885         //printk("after schedule thread jiffies is %x\n",jiffies);
1886         if (mlme_kill == 0)
1887                 break;
1888         //printk("i is %d\n",i);
1889         }
1890
1891 #endif
1892         return 0;
1893
1894 }
1895
1896
1897
1898 static int  device_open(struct net_device *dev) {
1899     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1900     int i;
1901 #ifdef WPA_SM_Transtatus
1902     extern SWPAResult wpa_Result;
1903 #endif
1904
1905     pDevice->rx_buf_sz = PKT_BUF_SZ;
1906     if (!device_init_rings(pDevice)) {
1907         return -ENOMEM;
1908     }
1909 //2008-5-13 <add> by chester
1910     i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1911     if (i)
1912         return i;
1913         //printk("DEBUG1\n");
1914 #ifdef WPA_SM_Transtatus
1915      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1916      wpa_Result.proto = 0;
1917      wpa_Result.key_mgmt = 0;
1918      wpa_Result.eap_type = 0;
1919      wpa_Result.authenticated = false;
1920      pDevice->fWPA_Authened = false;
1921 #endif
1922 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1923 device_init_rd0_ring(pDevice);
1924     device_init_rd1_ring(pDevice);
1925     device_init_defrag_cb(pDevice);
1926     device_init_td0_ring(pDevice);
1927     device_init_td1_ring(pDevice);
1928 //    VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
1929
1930
1931     if (pDevice->bDiversityRegCtlON) {
1932         device_init_diversity_timer(pDevice);
1933     }
1934     vMgrObjectInit(pDevice);
1935     vMgrTimerInit(pDevice);
1936
1937 //PLICE_DEBUG->
1938 #ifdef  TASK_LET
1939         tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice);
1940 #endif
1941 #ifdef  THREAD
1942         InitRxManagementQueue(pDevice);
1943         mlme_kill = 0;
1944         mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME");
1945         if (IS_ERR(mlme_task)) {
1946                 printk("thread create fail\n");
1947                 return -1;
1948         }
1949
1950         mlme_kill = 1;
1951 #endif
1952
1953
1954
1955 #if 0
1956         pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM);
1957         if (pDevice->MLMEThr_pid <0 )
1958         {
1959                 printk("unable start thread MlmeThread\n");
1960                 return -1;
1961         }
1962 #endif
1963
1964         //printk("thread id is %d\n",pDevice->MLMEThr_pid);
1965         //printk("Create thread time is %x\n",jiffies);
1966         //wait_for_completion(&pDevice->notify);
1967
1968
1969
1970
1971   // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
1972     //    return -ENOMEM;
1973 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1974         device_init_registers(pDevice, DEVICE_INIT_COLD);
1975     MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1976     memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1977     device_set_multi(pDevice->dev);
1978
1979     // Init for Key Management
1980     KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1981     add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1982
1983         #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1984         /*
1985      pDevice->bwextstep0 = false;
1986      pDevice->bwextstep1 = false;
1987      pDevice->bwextstep2 = false;
1988      pDevice->bwextstep3 = false;
1989      */
1990        pDevice->bwextcount=0;
1991      pDevice->bWPASuppWextEnabled = false;
1992 #endif
1993     pDevice->byReAssocCount = 0;
1994    pDevice->bWPADEVUp = false;
1995     // Patch: if WEP key already set by iwconfig but device not yet open
1996     if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1997         KeybSetDefaultKey(&(pDevice->sKey),
1998                             (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1999                             pDevice->uKeyLength,
2000                             NULL,
2001                             pDevice->abyKey,
2002                             KEY_CTL_WEP,
2003                             pDevice->PortOffset,
2004                             pDevice->byLocalID
2005                           );
2006          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
2007     }
2008
2009 //printk("DEBUG2\n");
2010
2011
2012 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
2013         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2014
2015     if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2016         bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
2017         }
2018         else {
2019         bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
2020         bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
2021     }
2022     pDevice->flags |=DEVICE_FLAGS_OPENED;
2023
2024     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
2025     return 0;
2026 }
2027
2028
2029 static int  device_close(struct net_device *dev) {
2030     PSDevice  pDevice=(PSDevice) netdev_priv(dev);
2031     PSMgmtObject     pMgmt = pDevice->pMgmt;
2032  //PLICE_DEBUG->
2033 #ifdef  THREAD
2034         mlme_kill = 0;
2035 #endif
2036 //PLICE_DEBUG<-
2037 //2007-1121-02<Add>by EinsnLiu
2038     if (pDevice->bLinkPass) {
2039         bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2040         mdelay(30);
2041     }
2042 #ifdef TxInSleep
2043     del_timer(&pDevice->sTimerTxData);
2044 #endif
2045     del_timer(&pDevice->sTimerCommand);
2046     del_timer(&pMgmt->sTimerSecondCallback);
2047     if (pDevice->bDiversityRegCtlON) {
2048         del_timer(&pDevice->TimerSQ3Tmax1);
2049         del_timer(&pDevice->TimerSQ3Tmax2);
2050         del_timer(&pDevice->TimerSQ3Tmax3);
2051     }
2052
2053 #ifdef  TASK_LET
2054         tasklet_kill(&pDevice->RxMngWorkItem);
2055 #endif
2056      netif_stop_queue(dev);
2057     pDevice->bCmdRunning = false;
2058     MACbShutdown(pDevice->PortOffset);
2059     MACbSoftwareReset(pDevice->PortOffset);
2060     CARDbRadioPowerOff(pDevice);
2061
2062     pDevice->bLinkPass = false;
2063     memset(pMgmt->abyCurrBSSID, 0, 6);
2064     pMgmt->eCurrState = WMAC_STATE_IDLE;
2065     device_free_td0_ring(pDevice);
2066     device_free_td1_ring(pDevice);
2067     device_free_rd0_ring(pDevice);
2068     device_free_rd1_ring(pDevice);
2069     device_free_frag_buf(pDevice);
2070     device_free_rings(pDevice);
2071     BSSvClearNodeDBTable(pDevice, 0);
2072     free_irq(dev->irq, dev);
2073     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
2074         //2008-0714-01<Add>by chester
2075 device_release_WPADEV(pDevice);
2076 //PLICE_DEBUG->
2077         //tasklet_kill(&pDevice->RxMngWorkItem);
2078 //PLICE_DEBUG<-
2079     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
2080     return 0;
2081 }
2082
2083
2084
2085 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
2086     PSDevice        pDevice=netdev_priv(dev);
2087     unsigned char *pbMPDU;
2088     unsigned int cbMPDULen = 0;
2089
2090
2091     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
2092     spin_lock_irq(&pDevice->lock);
2093
2094     if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2095         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
2096         dev_kfree_skb_irq(skb);
2097         spin_unlock_irq(&pDevice->lock);
2098         return 0;
2099     }
2100
2101     if (pDevice->bStopTx0Pkt == true) {
2102         dev_kfree_skb_irq(skb);
2103         spin_unlock_irq(&pDevice->lock);
2104         return 0;
2105     }
2106
2107     cbMPDULen = skb->len;
2108     pbMPDU = skb->data;
2109
2110     vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
2111
2112     spin_unlock_irq(&pDevice->lock);
2113
2114     return 0;
2115
2116 }
2117
2118
2119
2120 bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) {
2121     PSMgmtObject    pMgmt = pDevice->pMgmt;
2122     PSTxDesc        pHeadTD, pLastTD;
2123     unsigned int cbFrameBodySize;
2124     unsigned int uMACfragNum;
2125     unsigned char byPktType;
2126     bool bNeedEncryption = false;
2127     PSKeyItem       pTransmitKey = NULL;
2128     unsigned int cbHeaderSize;
2129     unsigned int ii;
2130     SKeyItem        STempKey;
2131 //    unsigned char byKeyIndex = 0;
2132
2133
2134     if (pDevice->bStopTx0Pkt == true) {
2135         dev_kfree_skb_irq(skb);
2136         return false;
2137     }
2138
2139     if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2140         dev_kfree_skb_irq(skb);
2141         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
2142         return false;
2143     }
2144
2145     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2146         if (pDevice->uAssocCount == 0) {
2147             dev_kfree_skb_irq(skb);
2148             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
2149             return false;
2150         }
2151     }
2152
2153     pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
2154
2155     pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2156
2157     memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2158     cbFrameBodySize = skb->len - ETH_HLEN;
2159
2160     // 802.1H
2161     if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2162         cbFrameBodySize += 8;
2163     }
2164     uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2165
2166     if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
2167         dev_kfree_skb_irq(skb);
2168         return false;
2169     }
2170     byPktType = (unsigned char)pDevice->byPacketType;
2171
2172
2173     if (pDevice->bFixRate) {
2174         if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2175             if (pDevice->uConnectionRate >= RATE_11M) {
2176                 pDevice->wCurrentRate = RATE_11M;
2177             } else {
2178                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2179             }
2180         } else {
2181             if (pDevice->uConnectionRate >= RATE_54M)
2182                 pDevice->wCurrentRate = RATE_54M;
2183             else
2184                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2185         }
2186     }
2187     else {
2188         pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2189     }
2190
2191     //preamble type
2192     if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2193         pDevice->byPreambleType = pDevice->byShortPreamble;
2194     }
2195     else {
2196         pDevice->byPreambleType = PREAMBLE_LONG;
2197     }
2198
2199     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2200
2201
2202     if (pDevice->wCurrentRate <= RATE_11M) {
2203         byPktType = PK_TYPE_11B;
2204     } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2205         byPktType = PK_TYPE_11A;
2206     } else {
2207         if (pDevice->bProtectMode == true) {
2208             byPktType = PK_TYPE_11GB;
2209         } else {
2210             byPktType = PK_TYPE_11GA;
2211         }
2212     }
2213
2214     if (pDevice->bEncryptionEnable == true)
2215         bNeedEncryption = true;
2216
2217     if (pDevice->bEnableHostWEP) {
2218         pTransmitKey = &STempKey;
2219         pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2220         pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2221         pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2222         pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2223         pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2224         memcpy(pTransmitKey->abyKey,
2225             &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2226             pTransmitKey->uKeyLength
2227             );
2228     }
2229     vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2230                         cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2231                         &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2232                         &uMACfragNum,
2233                         &cbHeaderSize
2234                         );
2235
2236     if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2237         // Disable PS
2238         MACbPSWakeup(pDevice->PortOffset);
2239     }
2240
2241     pDevice->bPWBitOn = false;
2242
2243     pLastTD = pHeadTD;
2244     for (ii = 0; ii < uMACfragNum; ii++) {
2245         // Poll Transmit the adapter
2246         wmb();
2247         pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2248         wmb();
2249         if (ii == (uMACfragNum - 1))
2250             pLastTD = pHeadTD;
2251         pHeadTD = pHeadTD->next;
2252     }
2253
2254     // Save the information needed by the tx interrupt handler
2255     // to complete the Send request
2256     pLastTD->pTDInfo->skb = skb;
2257     pLastTD->pTDInfo->byFlags = 0;
2258     pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2259
2260     pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2261
2262     MACvTransmit0(pDevice->PortOffset);
2263
2264
2265     return true;
2266 }
2267
2268 //TYPE_AC0DMA data tx
2269 static int  device_xmit(struct sk_buff *skb, struct net_device *dev) {
2270     PSDevice pDevice=netdev_priv(dev);
2271
2272     PSMgmtObject    pMgmt = pDevice->pMgmt;
2273     PSTxDesc        pHeadTD, pLastTD;
2274     unsigned int uNodeIndex = 0;
2275     unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2276     unsigned short wAID;
2277     unsigned int uMACfragNum = 1;
2278     unsigned int cbFrameBodySize;
2279     unsigned char byPktType;
2280     unsigned int cbHeaderSize;
2281     bool bNeedEncryption = false;
2282     PSKeyItem       pTransmitKey = NULL;
2283     SKeyItem        STempKey;
2284     unsigned int ii;
2285     bool bTKIP_UseGTK = false;
2286     bool bNeedDeAuth = false;
2287     unsigned char *pbyBSSID;
2288     bool bNodeExist = false;
2289
2290
2291
2292     spin_lock_irq(&pDevice->lock);
2293     if (pDevice->bLinkPass == false) {
2294         dev_kfree_skb_irq(skb);
2295         spin_unlock_irq(&pDevice->lock);
2296         return 0;
2297     }
2298
2299     if (pDevice->bStopDataPkt) {
2300         dev_kfree_skb_irq(skb);
2301         spin_unlock_irq(&pDevice->lock);
2302         return 0;
2303     }
2304
2305
2306     if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2307         if (pDevice->uAssocCount == 0) {
2308             dev_kfree_skb_irq(skb);
2309             spin_unlock_irq(&pDevice->lock);
2310             return 0;
2311         }
2312         if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2313             uNodeIndex = 0;
2314             bNodeExist = true;
2315             if (pMgmt->sNodeDBTable[0].bPSEnable) {
2316                 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2317                 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2318                 // set tx map
2319                 pMgmt->abyPSTxMap[0] |= byMask[0];
2320                 spin_unlock_irq(&pDevice->lock);
2321                 return 0;
2322             }
2323 }else {
2324             if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
2325                 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2326                     skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2327                     pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2328                     // set tx map
2329                     wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2330                     pMgmt->abyPSTxMap[wAID >> 3] |=  byMask[wAID & 7];
2331                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2332                              (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2333                     spin_unlock_irq(&pDevice->lock);
2334                     return 0;
2335                 }
2336
2337                 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2338                     pDevice->byPreambleType = pDevice->byShortPreamble;
2339
2340                 }else {
2341                     pDevice->byPreambleType = PREAMBLE_LONG;
2342                 }
2343                 bNodeExist = true;
2344
2345             }
2346         }
2347
2348         if (bNodeExist == false) {
2349             DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2350             dev_kfree_skb_irq(skb);
2351             spin_unlock_irq(&pDevice->lock);
2352             return 0;
2353         }
2354     }
2355
2356     pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2357
2358     pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2359
2360
2361     memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2362     cbFrameBodySize = skb->len - ETH_HLEN;
2363     // 802.1H
2364     if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2365         cbFrameBodySize += 8;
2366     }
2367
2368
2369     if (pDevice->bEncryptionEnable == true) {
2370         bNeedEncryption = true;
2371         // get Transmit key
2372         do {
2373             if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2374                 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2375                 pbyBSSID = pDevice->abyBSSID;
2376                 // get pairwise key
2377                 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2378                     // get group key
2379                     if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2380                         bTKIP_UseGTK = true;
2381                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2382                         break;
2383                     }
2384                 } else {
2385                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2386                     break;
2387                 }
2388             }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2389
2390                 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;  //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2391                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2392                 for (ii = 0; ii< 6; ii++)
2393                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2394                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2395
2396                 // get pairwise key
2397                 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2398                     break;
2399             }
2400             // get group key
2401             pbyBSSID = pDevice->abyBroadcastAddr;
2402             if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2403                 pTransmitKey = NULL;
2404                 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2405                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2406                 }
2407                 else
2408                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2409             } else {
2410                 bTKIP_UseGTK = true;
2411                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2412             }
2413         } while(false);
2414     }
2415
2416     if (pDevice->bEnableHostWEP) {
2417         DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2418         if (pDevice->bEncryptionEnable == true) {
2419             pTransmitKey = &STempKey;
2420             pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2421             pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2422             pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2423             pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2424             pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2425             memcpy(pTransmitKey->abyKey,
2426                 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2427                 pTransmitKey->uKeyLength
2428                 );
2429          }
2430     }
2431
2432     uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2433
2434     if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2435         DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2436         dev_kfree_skb_irq(skb);
2437         spin_unlock_irq(&pDevice->lock);
2438         return 0;
2439     }
2440
2441     if (pTransmitKey != NULL) {
2442         if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2443             (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2444             uMACfragNum = 1; //WEP256 doesn't support fragment
2445         }
2446     }
2447
2448     byPktType = (unsigned char)pDevice->byPacketType;
2449
2450     if (pDevice->bFixRate) {
2451 #ifdef  PLICE_DEBUG
2452         printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate);
2453 #endif
2454
2455         if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2456             if (pDevice->uConnectionRate >= RATE_11M) {
2457                 pDevice->wCurrentRate = RATE_11M;
2458             } else {
2459                 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2460             }
2461         } else {
2462             if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2463                 (pDevice->uConnectionRate <= RATE_6M)) {
2464                 pDevice->wCurrentRate = RATE_6M;
2465             } else {
2466                 if (pDevice->uConnectionRate >= RATE_54M)
2467                     pDevice->wCurrentRate = RATE_54M;
2468                 else
2469                     pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2470
2471             }
2472         }
2473         pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2474         pDevice->byTopCCKBasicRate = RATE_1M;
2475         pDevice->byTopOFDMBasicRate = RATE_6M;
2476     }
2477     else {
2478         //auto rate
2479     if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2480             if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2481                 pDevice->wCurrentRate = RATE_1M;
2482                 pDevice->byACKRate = RATE_1M;
2483                 pDevice->byTopCCKBasicRate = RATE_1M;
2484                 pDevice->byTopOFDMBasicRate = RATE_6M;
2485             } else {
2486                 pDevice->wCurrentRate = RATE_6M;
2487                 pDevice->byACKRate = RATE_6M;
2488                 pDevice->byTopCCKBasicRate = RATE_1M;
2489                 pDevice->byTopOFDMBasicRate = RATE_6M;
2490             }
2491         }
2492         else {
2493                 VNTWIFIvGetTxRate(  pDevice->pMgmt,
2494                                 pDevice->sTxEthHeader.abyDstAddr,
2495                                 &(pDevice->wCurrentRate),
2496                                 &(pDevice->byACKRate),
2497                                 &(pDevice->byTopCCKBasicRate),
2498                                 &(pDevice->byTopOFDMBasicRate));
2499
2500 #if 0
2501 printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n",
2502 pDevice->wCurrentRate,pDevice->byACKRate,
2503 pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate);
2504
2505 #endif
2506
2507 #if 0
2508
2509         pDevice->wCurrentRate = 11;
2510         pDevice->byACKRate = 8;
2511         pDevice->byTopCCKBasicRate = 3;
2512         pDevice->byTopOFDMBasicRate = 8;
2513 #endif
2514
2515
2516                 }
2517     }
2518
2519 //    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2520
2521     if (pDevice->wCurrentRate <= RATE_11M) {
2522         byPktType = PK_TYPE_11B;
2523     } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2524         byPktType = PK_TYPE_11A;
2525     } else {
2526         if (pDevice->bProtectMode == true) {
2527             byPktType = PK_TYPE_11GB;
2528         } else {
2529             byPktType = PK_TYPE_11GA;
2530         }
2531     }
2532
2533 //#ifdef        PLICE_DEBUG
2534 //      printk("FIX RATE:CurrentRate is %d");
2535 //#endif
2536
2537     if (bNeedEncryption == true) {
2538         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2539         if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2540             bNeedEncryption = false;
2541             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2542             if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2543                 if (pTransmitKey == NULL) {
2544                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2545                 }
2546                 else {
2547                     if (bTKIP_UseGTK == true) {
2548                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2549                     }
2550                     else {
2551                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2552                         bNeedEncryption = true;
2553                     }
2554                 }
2555             }
2556
2557             if (pDevice->byCntMeasure == 2) {
2558                 bNeedDeAuth = true;
2559                 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2560             }
2561
2562             if (pDevice->bEnableHostWEP) {
2563                 if ((uNodeIndex != 0) &&
2564                     (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2565                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2566                     bNeedEncryption = true;
2567                  }
2568              }
2569         }
2570         else {
2571             if (pTransmitKey == NULL) {
2572                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2573                 dev_kfree_skb_irq(skb);
2574                 spin_unlock_irq(&pDevice->lock);
2575                 return 0;
2576             }
2577         }
2578     }
2579
2580
2581 #ifdef  PLICE_DEBUG
2582         //if (skb->len == 98)
2583         //{
2584         //      printk("ping:len is %d\n");
2585         //}
2586 #endif
2587     vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2588                         cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2589                         &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2590                         &uMACfragNum,
2591                         &cbHeaderSize
2592                         );
2593
2594     if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2595         // Disable PS
2596         MACbPSWakeup(pDevice->PortOffset);
2597     }
2598     pDevice->bPWBitOn = false;
2599
2600     pLastTD = pHeadTD;
2601     for (ii = 0; ii < uMACfragNum; ii++) {
2602         // Poll Transmit the adapter
2603         wmb();
2604         pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2605         wmb();
2606         if (ii == uMACfragNum - 1)
2607             pLastTD = pHeadTD;
2608         pHeadTD = pHeadTD->next;
2609     }
2610
2611     // Save the information needed by the tx interrupt handler
2612     // to complete the Send request
2613     pLastTD->pTDInfo->skb = skb;
2614     pLastTD->pTDInfo->byFlags = 0;
2615     pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2616 #ifdef TxInSleep
2617   pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet
2618   #endif
2619     if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2620         netif_stop_queue(dev);
2621     }
2622
2623     pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2624 //#ifdef        PLICE_DEBUG
2625         if (pDevice->bFixRate)
2626         {
2627                 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2628         }
2629         else
2630         {
2631                 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2632         }
2633 //#endif
2634
2635 {
2636     unsigned char Protocol_Version;    //802.1x Authentication
2637     unsigned char Packet_Type;           //802.1x Authentication
2638     unsigned char Descriptor_type;
2639     unsigned short Key_info;
2640 bool bTxeapol_key = false;
2641     Protocol_Version = skb->data[ETH_HLEN];
2642     Packet_Type = skb->data[ETH_HLEN+1];
2643     Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2644     Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2645    if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2646            if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2647                 (Packet_Type==3)) {  //802.1x OR eapol-key challenge frame transfer
2648                         bTxeapol_key = true;
2649                 if((Descriptor_type==254)||(Descriptor_type==2)) {       //WPA or RSN
2650                        if(!(Key_info & BIT3) &&   //group-key challenge
2651                            (Key_info & BIT8) && (Key_info & BIT9)) {    //send 2/2 key
2652                           pDevice->fWPA_Authened = true;
2653                           if(Descriptor_type==254)
2654                               printk("WPA ");
2655                           else
2656                               printk("WPA2 ");
2657                           printk("Authentication completed!!\n");
2658                         }
2659                  }
2660              }
2661    }
2662 }
2663
2664     MACvTransmitAC0(pDevice->PortOffset);
2665 //    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2666
2667     dev->trans_start = jiffies;
2668
2669     spin_unlock_irq(&pDevice->lock);
2670     return 0;
2671
2672 }
2673
2674 static  irqreturn_t  device_intr(int irq,  void *dev_instance) {
2675     struct net_device* dev=dev_instance;
2676     PSDevice     pDevice=(PSDevice) netdev_priv(dev);
2677
2678     int             max_count=0;
2679     unsigned long dwMIBCounter=0;
2680     PSMgmtObject    pMgmt = pDevice->pMgmt;
2681     unsigned char byOrgPageSel=0;
2682     int             handled = 0;
2683     unsigned char byData = 0;
2684     int             ii= 0;
2685 //    unsigned char byRSSI;
2686     unsigned long flags;
2687
2688
2689     MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2690
2691     if (pDevice->dwIsr == 0)
2692         return IRQ_RETVAL(handled);
2693
2694     if (pDevice->dwIsr == 0xffffffff) {
2695         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2696         return IRQ_RETVAL(handled);
2697     }
2698     /*
2699       // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2700
2701         if ((pDevice->dwIsr & ISR_RXDMA0) &&
2702         (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2703         (pDevice->bBSSIDFilter == true)) {
2704         // update RSSI
2705         //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI);
2706         //pDevice->uCurrRSSI = byRSSI;
2707     }
2708     */
2709
2710     handled = 1;
2711     MACvIntDisable(pDevice->PortOffset);
2712
2713     spin_lock_irqsave(&pDevice->lock, flags);
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_irqrestore(&pDevice->lock, flags);
2962
2963     MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2964
2965     return IRQ_RETVAL(handled);
2966 }
2967
2968
2969 static unsigned const ethernet_polynomial = 0x04c11db7U;
2970 static inline u32 ether_crc(int length, unsigned char *data)
2971 {
2972     int crc = -1;
2973
2974     while(--length >= 0) {
2975         unsigned char current_octet = *data++;
2976         int bit;
2977         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2978             crc = (crc << 1) ^
2979                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2980         }
2981     }
2982     return crc;
2983 }
2984
2985 //2008-8-4 <add> by chester
2986 static int Config_FileGetParameter(unsigned char *string,
2987                 unsigned char *dest, unsigned char *source)
2988 {
2989   unsigned char buf1[100];
2990   int source_len = strlen(source);
2991
2992     memset(buf1,0,100);
2993     strcat(buf1, string);
2994     strcat(buf1, "=");
2995     source+=strlen(buf1);
2996
2997    memcpy(dest,source,source_len-strlen(buf1));
2998  return true;
2999 }
3000
3001 int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter) {
3002     unsigned char *config_path = CONFIG_PATH;
3003     unsigned char *buffer = NULL;
3004     unsigned char tmpbuffer[20];
3005     struct file   *filp=NULL;
3006     mm_segment_t old_fs = get_fs();
3007     //int oldfsuid=0,oldfsgid=0;
3008     int result=0;
3009
3010     set_fs (KERNEL_DS);
3011
3012     /* Can't do this anymore, so we rely on correct filesystem permissions:
3013     //Make sure a caller can read or write power as root
3014     oldfsuid=current->cred->fsuid;
3015     oldfsgid=current->cred->fsgid;
3016     current->cred->fsuid = 0;
3017     current->cred->fsgid = 0;
3018     */
3019
3020     //open file
3021       filp = filp_open(config_path, O_RDWR, 0);
3022         if (IS_ERR(filp)) {
3023              printk("Config_FileOperation:open file fail?\n");
3024              result=-1;
3025              goto error2;
3026           }
3027
3028      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
3029            printk("file %s cann't readable or writable?\n",config_path);
3030           result = -1;
3031           goto error1;
3032         }
3033
3034 buffer = kmalloc(1024, GFP_KERNEL);
3035 if(buffer==NULL) {
3036   printk("allocate mem for file fail?\n");
3037   result = -1;
3038   goto error1;
3039 }
3040
3041 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
3042  printk("read file error?\n");
3043  result = -1;
3044  goto error1;
3045 }
3046
3047 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
3048   printk("get parameter error?\n");
3049   result = -1;
3050   goto error1;
3051 }
3052
3053 if(memcmp(tmpbuffer,"USA",3)==0) {
3054   result=ZoneType_USA;
3055 }
3056 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
3057   result=ZoneType_Japan;
3058 }
3059 else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
3060  result=ZoneType_Europe;
3061 }
3062 else {
3063   result = -1;
3064   printk("Unknown Zonetype[%s]?\n",tmpbuffer);
3065 }
3066
3067 error1:
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 = kzalloc(IW_MAX_AP * (sizeof(struct sockaddr) +
3391                                        sizeof(struct iw_quality)), GFP_KERNEL);
3392
3393                 if (!buffer) {
3394                         rc = -ENOMEM;
3395                 } else if (wrq->u.data.pointer) {
3396                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3397                         if (rc == 0) {
3398                     if (copy_to_user(wrq->u.data.pointer,
3399                                                         buffer,
3400                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
3401                                         ))
3402                                     rc = -EFAULT;
3403                         }
3404             }
3405                 kfree(buffer);
3406         }
3407                 break;
3408
3409
3410 #ifdef WIRELESS_SPY
3411                 // Set the spy list
3412         case SIOCSIWSPY:
3413
3414         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3415                 rc = -EOPNOTSUPP;
3416                 break;
3417
3418                 // Get the spy list
3419         case SIOCGIWSPY:
3420
3421         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
3422                 rc = -EOPNOTSUPP;
3423                 break;
3424
3425 #endif // WIRELESS_SPY
3426
3427         case SIOCGIWPRIV:
3428         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3429                 rc = -EOPNOTSUPP;
3430 /*
3431                 if(wrq->u.data.pointer) {
3432                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
3433
3434                         if(copy_to_user(wrq->u.data.pointer,
3435                                         (u_char *) iwctl_private_args,
3436                                         sizeof(iwctl_private_args)))
3437                                 rc = -EFAULT;
3438                 }
3439 */
3440                 break;
3441
3442
3443 //2008-0409-07, <Add> by Einsn Liu
3444 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3445         case SIOCSIWAUTH:
3446                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3447                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3448                 break;
3449
3450         case SIOCGIWAUTH:
3451                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3452                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3453                 break;
3454
3455         case SIOCSIWGENIE:
3456                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3457                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3458                 break;
3459
3460         case SIOCGIWGENIE:
3461                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3462                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3463                 break;
3464
3465         case SIOCSIWENCODEEXT:
3466                 {
3467                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3468                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3469                         if(wrq->u.encoding.pointer){
3470                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
3471                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
3472                                         rc = -E2BIG;
3473                                         break;
3474                                 }
3475                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
3476                                         rc = -EFAULT;
3477                                         break;
3478                                 }
3479                         }else if(wrq->u.encoding.length != 0){
3480                                 rc = -EINVAL;
3481                                 break;
3482                         }
3483                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3484                 }
3485                 break;
3486
3487         case SIOCGIWENCODEEXT:
3488                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3489                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3490                 break;
3491
3492         case SIOCSIWMLME:
3493                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3494                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3495                 break;
3496
3497 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3498 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3499
3500     case IOCTL_CMD_TEST:
3501
3502                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3503                     rc = -EFAULT;
3504                     break;
3505                 } else {
3506                     rc = 0;
3507                 }
3508         pReq = (PSCmdRequest)rq;
3509         pReq->wResult = MAGIC_CODE;
3510         break;
3511
3512     case IOCTL_CMD_SET:
3513
3514                #ifdef SndEvt_ToAPI
3515                   if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) &&
3516                        !(pDevice->flags & DEVICE_FLAGS_OPENED))
3517               #else
3518                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3519                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
3520               #endif
3521                 {
3522                     rc = -EFAULT;
3523                     break;
3524                 } else {
3525                     rc = 0;
3526                 }
3527
3528             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
3529                     return -EBUSY;
3530             }
3531         rc = private_ioctl(pDevice, rq);
3532         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
3533         break;
3534
3535     case IOCTL_CMD_HOSTAPD:
3536
3537
3538         rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3539         break;
3540
3541     case IOCTL_CMD_WPA:
3542
3543         rc = wpa_ioctl(pDevice, &wrq->u.data);
3544         break;
3545
3546         case SIOCETHTOOL:
3547         return ethtool_ioctl(dev, (void *) rq->ifr_data);
3548         // All other calls are currently unsupported
3549
3550         default:
3551                 rc = -EOPNOTSUPP;
3552         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3553
3554
3555     }
3556
3557     if (pDevice->bCommit) {
3558        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3559            netif_stop_queue(pDevice->dev);
3560            spin_lock_irq(&pDevice->lock);
3561            bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
3562            spin_unlock_irq(&pDevice->lock);
3563        }
3564        else {
3565            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3566            spin_lock_irq(&pDevice->lock);
3567            pDevice->bLinkPass = false;
3568            memset(pMgmt->abyCurrBSSID, 0, 6);
3569            pMgmt->eCurrState = WMAC_STATE_IDLE;
3570            netif_stop_queue(pDevice->dev);
3571         #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3572               pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3573          if(pDevice->bWPASuppWextEnabled !=true)
3574          #endif
3575            bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3576            bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
3577            spin_unlock_irq(&pDevice->lock);
3578       }
3579       pDevice->bCommit = false;
3580     }
3581
3582     return rc;
3583 }
3584
3585
3586 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3587 {
3588         u32 ethcmd;
3589
3590         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3591                 return -EFAULT;
3592
3593         switch (ethcmd) {
3594         case ETHTOOL_GDRVINFO: {
3595                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3596                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3597                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3598                 if (copy_to_user(useraddr, &info, sizeof(info)))
3599                         return -EFAULT;
3600                 return 0;
3601         }
3602
3603         }
3604
3605         return -EOPNOTSUPP;
3606 }
3607
3608 /*------------------------------------------------------------------*/
3609
3610 MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3611
3612 static struct pci_driver device_driver = {
3613         .name = DEVICE_NAME,
3614         .id_table = vt6655_pci_id_table,
3615         .probe = vt6655_probe,
3616         .remove = vt6655_remove,
3617 #ifdef CONFIG_PM
3618         .suspend = viawget_suspend,
3619         .resume = viawget_resume,
3620 #endif
3621 };
3622
3623 static int __init vt6655_init_module(void)
3624 {
3625     int ret;
3626
3627
3628 //    ret=pci_module_init(&device_driver);
3629         //ret = pcie_port_service_register(&device_driver);
3630         ret = pci_register_driver(&device_driver);
3631 #ifdef CONFIG_PM
3632     if(ret >= 0)
3633         register_reboot_notifier(&device_notifier);
3634 #endif
3635
3636     return ret;
3637 }
3638
3639 static void __exit vt6655_cleanup_module(void)
3640 {
3641
3642
3643 #ifdef CONFIG_PM
3644     unregister_reboot_notifier(&device_notifier);
3645 #endif
3646     pci_unregister_driver(&device_driver);
3647
3648 }
3649
3650 module_init(vt6655_init_module);
3651 module_exit(vt6655_cleanup_module);
3652
3653
3654 #ifdef CONFIG_PM
3655 static int
3656 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3657 {
3658     struct pci_dev *pdev = NULL;
3659     switch(event) {
3660     case SYS_DOWN:
3661     case SYS_HALT:
3662     case SYS_POWER_OFF:
3663         for_each_pci_dev(pdev) {
3664             if(pci_dev_driver(pdev) == &device_driver) {
3665                 if (pci_get_drvdata(pdev))
3666                     viawget_suspend(pdev, PMSG_HIBERNATE);
3667             }
3668         }
3669     }
3670     return NOTIFY_DONE;
3671 }
3672
3673 static int
3674 viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3675 {
3676     int power_status;   // to silence the compiler
3677
3678     PSDevice pDevice=pci_get_drvdata(pcid);
3679     PSMgmtObject  pMgmt = pDevice->pMgmt;
3680
3681     netif_stop_queue(pDevice->dev);
3682     spin_lock_irq(&pDevice->lock);
3683     pci_save_state(pcid);
3684     del_timer(&pDevice->sTimerCommand);
3685     del_timer(&pMgmt->sTimerSecondCallback);
3686     pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3687     pDevice->uCmdDequeueIdx = 0;
3688     pDevice->uCmdEnqueueIdx = 0;
3689     pDevice->bCmdRunning = false;
3690     MACbShutdown(pDevice->PortOffset);
3691     MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3692     pDevice->bLinkPass = false;
3693     memset(pMgmt->abyCurrBSSID, 0, 6);
3694     pMgmt->eCurrState = WMAC_STATE_IDLE;
3695     pci_disable_device(pcid);
3696     power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3697     spin_unlock_irq(&pDevice->lock);
3698     return 0;
3699 }
3700
3701 static int
3702 viawget_resume(struct pci_dev *pcid)
3703 {
3704     PSDevice  pDevice=pci_get_drvdata(pcid);
3705     PSMgmtObject  pMgmt = pDevice->pMgmt;
3706     int power_status;   // to silence the compiler
3707
3708
3709     power_status = pci_set_power_state(pcid, 0);
3710     power_status = pci_enable_wake(pcid, 0, 0);
3711     pci_restore_state(pcid);
3712     if (netif_running(pDevice->dev)) {
3713         spin_lock_irq(&pDevice->lock);
3714         MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3715         device_init_registers(pDevice, DEVICE_INIT_DXPL);
3716         if (pMgmt->sNodeDBTable[0].bActive == true) { // Assoc with BSS
3717             pMgmt->sNodeDBTable[0].bActive = false;
3718             pDevice->bLinkPass = false;
3719             if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3720                 // In Adhoc, BSS state set back to started.
3721                 pMgmt->eCurrState = WMAC_STATE_STARTED;
3722            }
3723             else {
3724                 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3725                 pMgmt->eCurrState = WMAC_STATE_IDLE;
3726             }
3727         }
3728         init_timer(&pMgmt->sTimerSecondCallback);
3729         init_timer(&pDevice->sTimerCommand);
3730         MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3731         BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
3732         bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3733         bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
3734         spin_unlock_irq(&pDevice->lock);
3735     }
3736     return 0;
3737 }
3738
3739 #endif
3740
3741
3742
3743