Version:  2.0.40 2.2.26 2.4.37 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 3.16

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

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