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