Pileus Git - ~andy/linux/blob - drivers/staging/vt6655/device_main.c

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