Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/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
3399 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us