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

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

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