2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
21 * Purpose: driver entry for initial, open, close, tx and rx.
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_intr - interrupt handle function
36 * device_rx_srv - rx service function
37 * device_alloc_rx_buf - rx buffer pre-allocated function
38 * device_free_tx_buf - free tx buffer function
39 * device_init_rd0_ring- initial rd dma0 ring
40 * device_init_rd1_ring- initial rd dma1 ring
41 * device_init_td0_ring- initial tx dma0 ring buffer
42 * device_init_td1_ring- initial tx dma1 ring buffer
43 * device_init_registers- initial MAC & BBP & RF internal registers.
44 * device_init_rings- initial tx/rx ring buffer
45 * device_free_rings- free all allocated ring buffer
46 * device_tx_srv- tx interrupt service function
52 #include <linux/file.h>
62 #include <linux/delay.h>
63 #include <linux/kthread.h>
64 #include <linux/slab.h>
66 /*--------------------- Static Definitions -------------------------*/
68 // Define module options
70 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
71 MODULE_LICENSE("GPL");
72 MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
74 #define DEVICE_PARAM(N, D)
76 #define RX_DESC_MIN0 16
77 #define RX_DESC_MAX0 128
78 #define RX_DESC_DEF0 32
79 DEVICE_PARAM(RxDescriptors0
, "Number of receive descriptors0");
81 #define RX_DESC_MIN1 16
82 #define RX_DESC_MAX1 128
83 #define RX_DESC_DEF1 32
84 DEVICE_PARAM(RxDescriptors1
, "Number of receive descriptors1");
86 #define TX_DESC_MIN0 16
87 #define TX_DESC_MAX0 128
88 #define TX_DESC_DEF0 32
89 DEVICE_PARAM(TxDescriptors0
, "Number of transmit descriptors0");
91 #define TX_DESC_MIN1 16
92 #define TX_DESC_MAX1 128
93 #define TX_DESC_DEF1 64
94 DEVICE_PARAM(TxDescriptors1
, "Number of transmit descriptors1");
96 #define INT_WORKS_DEF 20
97 #define INT_WORKS_MIN 10
98 #define INT_WORKS_MAX 64
100 DEVICE_PARAM(int_works
, "Number of packets per interrupt services");
102 #define RTS_THRESH_DEF 2347
104 #define FRAG_THRESH_DEF 2346
106 #define SHORT_RETRY_MIN 0
107 #define SHORT_RETRY_MAX 31
108 #define SHORT_RETRY_DEF 8
110 DEVICE_PARAM(ShortRetryLimit
, "Short frame retry limits");
112 #define LONG_RETRY_MIN 0
113 #define LONG_RETRY_MAX 15
114 #define LONG_RETRY_DEF 4
116 DEVICE_PARAM(LongRetryLimit
, "long frame retry limits");
118 /* BasebandType[] baseband type selected
119 0: indicate 802.11a type
120 1: indicate 802.11b type
121 2: indicate 802.11g type
123 #define BBP_TYPE_MIN 0
124 #define BBP_TYPE_MAX 2
125 #define BBP_TYPE_DEF 2
127 DEVICE_PARAM(BasebandType
, "baseband type");
129 #define DIVERSITY_ANT_DEF 0
131 DEVICE_PARAM(bDiversityANTEnable
, "ANT diversity mode");
134 // Static vars definitions
136 static CHIP_INFO chip_info_table
[] = {
137 { VT3253
, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
138 256, 1, DEVICE_FLAGS_IP_ALIGN
|DEVICE_FLAGS_TX_ALIGN
},
142 static const struct pci_device_id vt6655_pci_id_table
[] = {
143 { PCI_VDEVICE(VIA
, 0x3253), (kernel_ulong_t
)chip_info_table
},
147 /*--------------------- Static Functions --------------------------*/
149 static int vt6655_probe(struct pci_dev
*pcid
, const struct pci_device_id
*ent
);
150 static void vt6655_init_info(struct pci_dev
*pcid
,
151 struct vnt_private
**ppDevice
, PCHIP_INFO
);
152 static void device_free_info(struct vnt_private
*pDevice
);
153 static bool device_get_pci_info(struct vnt_private
*, struct pci_dev
*pcid
);
154 static void device_print_info(struct vnt_private
*pDevice
);
155 static void device_init_diversity_timer(struct vnt_private
*pDevice
);
156 static irqreturn_t
device_intr(int irq
, void *dev_instance
);
159 static int device_notify_reboot(struct notifier_block
*, unsigned long event
, void *ptr
);
160 static struct notifier_block device_notifier
= {
161 .notifier_call
= device_notify_reboot
,
167 static void device_init_rd0_ring(struct vnt_private
*pDevice
);
168 static void device_init_rd1_ring(struct vnt_private
*pDevice
);
169 static void device_init_td0_ring(struct vnt_private
*pDevice
);
170 static void device_init_td1_ring(struct vnt_private
*pDevice
);
172 static int device_rx_srv(struct vnt_private
*pDevice
, unsigned int uIdx
);
173 static int device_tx_srv(struct vnt_private
*pDevice
, unsigned int uIdx
);
174 static bool device_alloc_rx_buf(struct vnt_private
*pDevice
, PSRxDesc pDesc
);
175 static void device_init_registers(struct vnt_private
*pDevice
);
176 static void device_free_tx_buf(struct vnt_private
*pDevice
, PSTxDesc pDesc
);
177 static void device_free_td0_ring(struct vnt_private
*pDevice
);
178 static void device_free_td1_ring(struct vnt_private
*pDevice
);
179 static void device_free_rd0_ring(struct vnt_private
*pDevice
);
180 static void device_free_rd1_ring(struct vnt_private
*pDevice
);
181 static void device_free_rings(struct vnt_private
*pDevice
);
183 /*--------------------- Export Variables --------------------------*/
185 /*--------------------- Export Functions --------------------------*/
187 static char *get_chip_name(int chip_id
)
191 for (i
= 0; chip_info_table
[i
].name
!= NULL
; i
++)
192 if (chip_info_table
[i
].chip_id
== chip_id
)
194 return chip_info_table
[i
].name
;
197 static void vt6655_remove(struct pci_dev
*pcid
)
199 struct vnt_private
*pDevice
= pci_get_drvdata(pcid
);
203 device_free_info(pDevice
);
206 static void device_get_options(struct vnt_private
*pDevice
)
208 POPTIONS pOpts
= &(pDevice
->sOpts
);
210 pOpts
->nRxDescs0
= RX_DESC_DEF0
;
211 pOpts
->nRxDescs1
= RX_DESC_DEF1
;
212 pOpts
->nTxDescs
[0] = TX_DESC_DEF0
;
213 pOpts
->nTxDescs
[1] = TX_DESC_DEF1
;
214 pOpts
->int_works
= INT_WORKS_DEF
;
216 pOpts
->short_retry
= SHORT_RETRY_DEF
;
217 pOpts
->long_retry
= LONG_RETRY_DEF
;
218 pOpts
->bbp_type
= BBP_TYPE_DEF
;
219 pOpts
->flags
|= DEVICE_FLAGS_DiversityANT
;
223 device_set_options(struct vnt_private
*pDevice
)
225 pDevice
->byShortRetryLimit
= pDevice
->sOpts
.short_retry
;
226 pDevice
->byLongRetryLimit
= pDevice
->sOpts
.long_retry
;
227 pDevice
->bDiversityRegCtlON
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_DiversityANT
) ? 1 : 0;
228 pDevice
->byBBType
= pDevice
->sOpts
.bbp_type
;
229 pDevice
->byPacketType
= pDevice
->byBBType
;
230 pDevice
->byAutoFBCtrl
= AUTO_FB_0
;
231 pDevice
->bUpdateBBVGA
= true;
232 pDevice
->byPreambleType
= 0;
234 pr_debug(" byShortRetryLimit= %d\n", (int)pDevice
->byShortRetryLimit
);
235 pr_debug(" byLongRetryLimit= %d\n", (int)pDevice
->byLongRetryLimit
);
236 pr_debug(" byPreambleType= %d\n", (int)pDevice
->byPreambleType
);
237 pr_debug(" byShortPreamble= %d\n", (int)pDevice
->byShortPreamble
);
238 pr_debug(" byBBType= %d\n", (int)pDevice
->byBBType
);
239 pr_debug(" pDevice->bDiversityRegCtlON= %d\n",
240 (int)pDevice
->bDiversityRegCtlON
);
244 // Initialisation of MAC & BBP registers
247 static void device_init_registers(struct vnt_private
*pDevice
)
251 unsigned char byValue
;
252 unsigned char byValue1
;
253 unsigned char byCCKPwrdBm
= 0;
254 unsigned char byOFDMPwrdBm
= 0;
256 MACbShutdown(pDevice
->PortOffset
);
257 BBvSoftwareReset(pDevice
);
259 /* Do MACbSoftwareReset in MACvInitialize */
260 MACbSoftwareReset(pDevice
->PortOffset
);
262 pDevice
->bAES
= false;
264 /* Only used in 11g type, sync with ERP IE */
265 pDevice
->bProtectMode
= false;
267 pDevice
->bNonERPPresent
= false;
268 pDevice
->bBarkerPreambleMd
= false;
269 pDevice
->wCurrentRate
= RATE_1M
;
270 pDevice
->byTopOFDMBasicRate
= RATE_24M
;
271 pDevice
->byTopCCKBasicRate
= RATE_1M
;
273 /* Target to IF pin while programming to RF chip. */
274 pDevice
->byRevId
= 0;
277 MACvInitialize(pDevice
->PortOffset
);
280 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_LOCALID
, &pDevice
->byLocalID
);
282 spin_lock_irqsave(&pDevice
->lock
, flags
);
284 SROMvReadAllContents(pDevice
->PortOffset
, pDevice
->abyEEPROM
);
286 spin_unlock_irqrestore(&pDevice
->lock
, flags
);
288 /* Get Channel range */
289 pDevice
->byMinChannel
= 1;
290 pDevice
->byMaxChannel
= CB_MAX_CHANNEL
;
293 byValue
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_ANTENNA
);
294 if (byValue
& EEP_ANTINV
)
295 pDevice
->bTxRxAntInv
= true;
297 pDevice
->bTxRxAntInv
= false;
299 byValue
&= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
300 /* if not set default is All */
302 byValue
= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
304 pDevice
->ulDiversityNValue
= 100*260;
305 pDevice
->ulDiversityMValue
= 100*16;
307 pDevice
->byTMax2
= 4;
308 pDevice
->ulSQ3TH
= 0;
309 pDevice
->byTMax3
= 64;
311 if (byValue
== (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
)) {
312 pDevice
->byAntennaCount
= 2;
313 pDevice
->byTxAntennaMode
= ANT_B
;
314 pDevice
->dwTxAntennaSel
= 1;
315 pDevice
->dwRxAntennaSel
= 1;
317 if (pDevice
->bTxRxAntInv
)
318 pDevice
->byRxAntennaMode
= ANT_A
;
320 pDevice
->byRxAntennaMode
= ANT_B
;
322 byValue1
= SROMbyReadEmbedded(pDevice
->PortOffset
,
325 if ((byValue1
& 0x08) == 0)
326 pDevice
->bDiversityEnable
= false;
328 pDevice
->bDiversityEnable
= true;
330 pDevice
->bDiversityEnable
= false;
331 pDevice
->byAntennaCount
= 1;
332 pDevice
->dwTxAntennaSel
= 0;
333 pDevice
->dwRxAntennaSel
= 0;
335 if (byValue
& EEP_ANTENNA_AUX
) {
336 pDevice
->byTxAntennaMode
= ANT_A
;
338 if (pDevice
->bTxRxAntInv
)
339 pDevice
->byRxAntennaMode
= ANT_B
;
341 pDevice
->byRxAntennaMode
= ANT_A
;
343 pDevice
->byTxAntennaMode
= ANT_B
;
345 if (pDevice
->bTxRxAntInv
)
346 pDevice
->byRxAntennaMode
= ANT_A
;
348 pDevice
->byRxAntennaMode
= ANT_B
;
352 pr_debug("bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
353 pDevice
->bDiversityEnable
, (int)pDevice
->ulDiversityNValue
,
354 (int)pDevice
->ulDiversityMValue
, pDevice
->byTMax
,
357 /* zonetype initial */
358 pDevice
->byOriginalZonetype
= pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
];
361 pDevice
->byRFType
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_RFTYPE
);
363 /* force change RevID for VT3253 emu */
364 if ((pDevice
->byRFType
& RF_EMU
) != 0)
365 pDevice
->byRevId
= 0x80;
367 pDevice
->byRFType
&= RF_MASK
;
368 pr_debug("pDevice->byRFType = %x\n", pDevice
->byRFType
);
370 if (!pDevice
->bZoneRegExist
)
371 pDevice
->byZoneType
= pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
];
373 pr_debug("pDevice->byZoneType = %x\n", pDevice
->byZoneType
);
378 /* Get Desire Power Value */
379 pDevice
->byCurPwr
= 0xFF;
380 pDevice
->byCCKPwr
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_PWR_CCK
);
381 pDevice
->byOFDMPwrG
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_PWR_OFDMG
);
383 /* Load power Table */
384 for (ii
= 0; ii
< CB_MAX_CHANNEL_24G
; ii
++) {
385 pDevice
->abyCCKPwrTbl
[ii
+ 1] =
386 SROMbyReadEmbedded(pDevice
->PortOffset
,
387 (unsigned char)(ii
+ EEP_OFS_CCK_PWR_TBL
));
388 if (pDevice
->abyCCKPwrTbl
[ii
+ 1] == 0)
389 pDevice
->abyCCKPwrTbl
[ii
+1] = pDevice
->byCCKPwr
;
391 pDevice
->abyOFDMPwrTbl
[ii
+ 1] =
392 SROMbyReadEmbedded(pDevice
->PortOffset
,
393 (unsigned char)(ii
+ EEP_OFS_OFDM_PWR_TBL
));
394 if (pDevice
->abyOFDMPwrTbl
[ii
+ 1] == 0)
395 pDevice
->abyOFDMPwrTbl
[ii
+ 1] = pDevice
->byOFDMPwrG
;
397 pDevice
->abyCCKDefaultPwr
[ii
+ 1] = byCCKPwrdBm
;
398 pDevice
->abyOFDMDefaultPwr
[ii
+ 1] = byOFDMPwrdBm
;
401 /* recover 12,13 ,14channel for EUROPE by 11 channel */
402 for (ii
= 11; ii
< 14; ii
++) {
403 pDevice
->abyCCKPwrTbl
[ii
] = pDevice
->abyCCKPwrTbl
[10];
404 pDevice
->abyOFDMPwrTbl
[ii
] = pDevice
->abyOFDMPwrTbl
[10];
407 /* Load OFDM A Power Table */
408 for (ii
= 0; ii
< CB_MAX_CHANNEL_5G
; ii
++) {
409 pDevice
->abyOFDMPwrTbl
[ii
+ CB_MAX_CHANNEL_24G
+ 1] =
410 SROMbyReadEmbedded(pDevice
->PortOffset
,
411 (unsigned char)(ii
+ EEP_OFS_OFDMA_PWR_TBL
));
413 pDevice
->abyOFDMDefaultPwr
[ii
+ CB_MAX_CHANNEL_24G
+ 1] =
414 SROMbyReadEmbedded(pDevice
->PortOffset
,
415 (unsigned char)(ii
+ EEP_OFS_OFDMA_PWR_dBm
));
418 if (pDevice
->byLocalID
> REV_ID_VT3253_B1
) {
419 MACvSelectPage1(pDevice
->PortOffset
);
421 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_MSRCTL
+ 1,
422 (MSRCTL1_TXPWR
| MSRCTL1_CSAPAREN
));
424 MACvSelectPage0(pDevice
->PortOffset
);
427 /* use relative tx timeout and 802.11i D4 */
428 MACvWordRegBitsOn(pDevice
->PortOffset
,
429 MAC_REG_CFG
, (CFG_TKIPOPT
| CFG_NOTXTIMEOUT
));
431 /* set performance parameter by registry */
432 MACvSetShortRetryLimit(pDevice
->PortOffset
, pDevice
->byShortRetryLimit
);
433 MACvSetLongRetryLimit(pDevice
->PortOffset
, pDevice
->byLongRetryLimit
);
435 /* reset TSF counter */
436 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTRST
);
437 /* enable TSF counter */
438 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
440 /* initialize BBP registers */
441 BBbVT3253Init(pDevice
);
443 if (pDevice
->bUpdateBBVGA
) {
444 pDevice
->byBBVGACurrent
= pDevice
->abyBBVGA
[0];
445 pDevice
->byBBVGANew
= pDevice
->byBBVGACurrent
;
446 BBvSetVGAGainOffset(pDevice
, pDevice
->abyBBVGA
[0]);
449 BBvSetRxAntennaMode(pDevice
, pDevice
->byRxAntennaMode
);
450 BBvSetTxAntennaMode(pDevice
, pDevice
->byTxAntennaMode
);
452 /* Set BB and packet type at the same time. */
453 /* Set Short Slot Time, xIFS, and RSPINF. */
454 pDevice
->wCurrentRate
= RATE_54M
;
456 pDevice
->bRadioOff
= false;
458 pDevice
->byRadioCtl
= SROMbyReadEmbedded(pDevice
->PortOffset
,
460 pDevice
->bHWRadioOff
= false;
462 if (pDevice
->byRadioCtl
& EEP_RADIOCTL_ENABLE
) {
464 MACvGPIOIn(pDevice
->PortOffset
, &pDevice
->byGPIO
);
466 if (((pDevice
->byGPIO
& GPIO0_DATA
) &&
467 !(pDevice
->byRadioCtl
& EEP_RADIOCTL_INV
)) ||
468 (!(pDevice
->byGPIO
& GPIO0_DATA
) &&
469 (pDevice
->byRadioCtl
& EEP_RADIOCTL_INV
)))
470 pDevice
->bHWRadioOff
= true;
473 if (pDevice
->bHWRadioOff
|| pDevice
->bRadioControlOff
)
474 CARDbRadioPowerOff(pDevice
);
476 /* get Permanent network address */
477 SROMvReadEtherAddress(pDevice
->PortOffset
, pDevice
->abyCurrentNetAddr
);
478 pr_debug("Network address = %pM\n", pDevice
->abyCurrentNetAddr
);
480 /* reset Tx pointer */
481 CARDvSafeResetRx(pDevice
);
482 /* reset Rx pointer */
483 CARDvSafeResetTx(pDevice
);
485 if (pDevice
->byLocalID
<= REV_ID_VT3253_A1
)
486 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_RCR
, RCR_WPAERR
);
489 MACvReceive0(pDevice
->PortOffset
);
490 MACvReceive1(pDevice
->PortOffset
);
492 /* start the adapter */
493 MACvStart(pDevice
->PortOffset
);
496 static void device_init_diversity_timer(struct vnt_private
*pDevice
)
498 init_timer(&pDevice
->TimerSQ3Tmax1
);
499 pDevice
->TimerSQ3Tmax1
.data
= (unsigned long) pDevice
;
500 pDevice
->TimerSQ3Tmax1
.function
= TimerSQ3CallBack
;
501 pDevice
->TimerSQ3Tmax1
.expires
= RUN_AT(HZ
);
503 init_timer(&pDevice
->TimerSQ3Tmax2
);
504 pDevice
->TimerSQ3Tmax2
.data
= (unsigned long) pDevice
;
505 pDevice
->TimerSQ3Tmax2
.function
= TimerSQ3CallBack
;
506 pDevice
->TimerSQ3Tmax2
.expires
= RUN_AT(HZ
);
508 init_timer(&pDevice
->TimerSQ3Tmax3
);
509 pDevice
->TimerSQ3Tmax3
.data
= (unsigned long) pDevice
;
510 pDevice
->TimerSQ3Tmax3
.function
= TimerState1CallBack
;
511 pDevice
->TimerSQ3Tmax3
.expires
= RUN_AT(HZ
);
514 static void device_print_info(struct vnt_private
*pDevice
)
516 dev_info(&pDevice
->pcid
->dev
, "%s\n", get_chip_name(pDevice
->chip_id
));
518 dev_info(&pDevice
->pcid
->dev
, "MAC=%pM IO=0x%lx Mem=0x%lx IRQ=%d\n",
519 pDevice
->abyCurrentNetAddr
, (unsigned long)pDevice
->ioaddr
,
520 (unsigned long)pDevice
->PortOffset
, pDevice
->pcid
->irq
);
523 static void vt6655_init_info(struct pci_dev
*pcid
,
524 struct vnt_private
**ppDevice
,
525 PCHIP_INFO pChip_info
)
527 memset(*ppDevice
, 0, sizeof(**ppDevice
));
529 (*ppDevice
)->pcid
= pcid
;
530 (*ppDevice
)->chip_id
= pChip_info
->chip_id
;
531 (*ppDevice
)->io_size
= pChip_info
->io_size
;
532 (*ppDevice
)->nTxQueues
= pChip_info
->nTxQueue
;
533 (*ppDevice
)->multicast_limit
= 32;
535 spin_lock_init(&((*ppDevice
)->lock
));
538 static bool device_get_pci_info(struct vnt_private
*pDevice
,
539 struct pci_dev
*pcid
)
543 unsigned int cis_addr
;
545 pci_read_config_byte(pcid
, PCI_REVISION_ID
, &pDevice
->byRevId
);
546 pci_read_config_word(pcid
, PCI_SUBSYSTEM_ID
, &pDevice
->SubSystemID
);
547 pci_read_config_word(pcid
, PCI_SUBSYSTEM_VENDOR_ID
, &pDevice
->SubVendorID
);
548 pci_read_config_word(pcid
, PCI_COMMAND
, (u16
*)&(pci_cmd
));
550 pci_set_master(pcid
);
552 pDevice
->memaddr
= pci_resource_start(pcid
, 0);
553 pDevice
->ioaddr
= pci_resource_start(pcid
, 1);
555 cis_addr
= pci_resource_start(pcid
, 2);
557 pDevice
->pcid
= pcid
;
559 pci_read_config_byte(pcid
, PCI_COMMAND
, &b
);
560 pci_write_config_byte(pcid
, PCI_COMMAND
, (b
|PCI_COMMAND_MASTER
));
565 static void device_free_info(struct vnt_private
*pDevice
)
571 ieee80211_unregister_hw(pDevice
->hw
);
573 if (pDevice
->PortOffset
)
574 iounmap(pDevice
->PortOffset
);
577 pci_release_regions(pDevice
->pcid
);
580 ieee80211_free_hw(pDevice
->hw
);
583 static bool device_init_rings(struct vnt_private
*pDevice
)
587 /*allocate all RD/TD rings a single pool*/
588 vir_pool
= pci_zalloc_consistent(pDevice
->pcid
,
589 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
590 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
591 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
592 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
),
594 if (vir_pool
== NULL
) {
595 dev_err(&pDevice
->pcid
->dev
, "allocate desc dma memory failed\n");
599 pDevice
->aRD0Ring
= vir_pool
;
600 pDevice
->aRD1Ring
= vir_pool
+
601 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
);
603 pDevice
->rd0_pool_dma
= pDevice
->pool_dma
;
604 pDevice
->rd1_pool_dma
= pDevice
->rd0_pool_dma
+
605 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
);
607 pDevice
->tx0_bufs
= pci_zalloc_consistent(pDevice
->pcid
,
608 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
+
609 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
+
612 &pDevice
->tx_bufs_dma0
);
613 if (pDevice
->tx0_bufs
== NULL
) {
614 dev_err(&pDevice
->pcid
->dev
, "allocate buf dma memory failed\n");
616 pci_free_consistent(pDevice
->pcid
,
617 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
618 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
619 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
620 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
),
621 vir_pool
, pDevice
->pool_dma
626 pDevice
->td0_pool_dma
= pDevice
->rd1_pool_dma
+
627 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
);
629 pDevice
->td1_pool_dma
= pDevice
->td0_pool_dma
+
630 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
);
632 // vir_pool: pvoid type
633 pDevice
->apTD0Rings
= vir_pool
634 + pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
)
635 + pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
);
637 pDevice
->apTD1Rings
= vir_pool
638 + pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
)
639 + pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
)
640 + pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
);
642 pDevice
->tx1_bufs
= pDevice
->tx0_bufs
+
643 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
;
645 pDevice
->tx_beacon_bufs
= pDevice
->tx1_bufs
+
646 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
;
648 pDevice
->pbyTmpBuff
= pDevice
->tx_beacon_bufs
+
651 pDevice
->tx_bufs_dma1
= pDevice
->tx_bufs_dma0
+
652 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
;
654 pDevice
->tx_beacon_dma
= pDevice
->tx_bufs_dma1
+
655 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
;
660 static void device_free_rings(struct vnt_private
*pDevice
)
662 pci_free_consistent(pDevice
->pcid
,
663 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
664 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
665 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
666 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
)
668 pDevice
->aRD0Ring
, pDevice
->pool_dma
671 if (pDevice
->tx0_bufs
)
672 pci_free_consistent(pDevice
->pcid
,
673 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
+
674 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
+
677 pDevice
->tx0_bufs
, pDevice
->tx_bufs_dma0
681 static void device_init_rd0_ring(struct vnt_private
*pDevice
)
684 dma_addr_t curr
= pDevice
->rd0_pool_dma
;
687 /* Init the RD0 ring entries */
688 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs0
; i
++, curr
+= sizeof(SRxDesc
)) {
689 pDesc
= &(pDevice
->aRD0Ring
[i
]);
690 pDesc
->pRDInfo
= alloc_rd_info();
691 ASSERT(pDesc
->pRDInfo
);
692 if (!device_alloc_rx_buf(pDevice
, pDesc
))
693 dev_err(&pDevice
->pcid
->dev
, "can not alloc rx bufs\n");
695 pDesc
->next
= &(pDevice
->aRD0Ring
[(i
+1) % pDevice
->sOpts
.nRxDescs0
]);
696 pDesc
->pRDInfo
->curr_desc
= cpu_to_le32(curr
);
697 pDesc
->next_desc
= cpu_to_le32(curr
+ sizeof(SRxDesc
));
701 pDevice
->aRD0Ring
[i
-1].next_desc
= cpu_to_le32(pDevice
->rd0_pool_dma
);
702 pDevice
->pCurrRD
[0] = &(pDevice
->aRD0Ring
[0]);
705 static void device_init_rd1_ring(struct vnt_private
*pDevice
)
708 dma_addr_t curr
= pDevice
->rd1_pool_dma
;
711 /* Init the RD1 ring entries */
712 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs1
; i
++, curr
+= sizeof(SRxDesc
)) {
713 pDesc
= &(pDevice
->aRD1Ring
[i
]);
714 pDesc
->pRDInfo
= alloc_rd_info();
715 ASSERT(pDesc
->pRDInfo
);
716 if (!device_alloc_rx_buf(pDevice
, pDesc
))
717 dev_err(&pDevice
->pcid
->dev
, "can not alloc rx bufs\n");
719 pDesc
->next
= &(pDevice
->aRD1Ring
[(i
+1) % pDevice
->sOpts
.nRxDescs1
]);
720 pDesc
->pRDInfo
->curr_desc
= cpu_to_le32(curr
);
721 pDesc
->next_desc
= cpu_to_le32(curr
+ sizeof(SRxDesc
));
725 pDevice
->aRD1Ring
[i
-1].next_desc
= cpu_to_le32(pDevice
->rd1_pool_dma
);
726 pDevice
->pCurrRD
[1] = &(pDevice
->aRD1Ring
[0]);
729 static void device_free_rd0_ring(struct vnt_private
*pDevice
)
733 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs0
; i
++) {
734 PSRxDesc pDesc
= &(pDevice
->aRD0Ring
[i
]);
735 PDEVICE_RD_INFO pRDInfo
= pDesc
->pRDInfo
;
737 pci_unmap_single(pDevice
->pcid
, pRDInfo
->skb_dma
,
738 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
740 dev_kfree_skb(pRDInfo
->skb
);
742 kfree(pDesc
->pRDInfo
);
746 static void device_free_rd1_ring(struct vnt_private
*pDevice
)
750 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs1
; i
++) {
751 PSRxDesc pDesc
= &(pDevice
->aRD1Ring
[i
]);
752 PDEVICE_RD_INFO pRDInfo
= pDesc
->pRDInfo
;
754 pci_unmap_single(pDevice
->pcid
, pRDInfo
->skb_dma
,
755 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
757 dev_kfree_skb(pRDInfo
->skb
);
759 kfree(pDesc
->pRDInfo
);
763 static void device_init_td0_ring(struct vnt_private
*pDevice
)
769 curr
= pDevice
->td0_pool_dma
;
770 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[0]; i
++, curr
+= sizeof(STxDesc
)) {
771 pDesc
= &(pDevice
->apTD0Rings
[i
]);
772 pDesc
->pTDInfo
= alloc_td_info();
773 ASSERT(pDesc
->pTDInfo
);
774 if (pDevice
->flags
& DEVICE_FLAGS_TX_ALIGN
) {
775 pDesc
->pTDInfo
->buf
= pDevice
->tx0_bufs
+ (i
)*PKT_BUF_SZ
;
776 pDesc
->pTDInfo
->buf_dma
= pDevice
->tx_bufs_dma0
+ (i
)*PKT_BUF_SZ
;
778 pDesc
->next
= &(pDevice
->apTD0Rings
[(i
+1) % pDevice
->sOpts
.nTxDescs
[0]]);
779 pDesc
->pTDInfo
->curr_desc
= cpu_to_le32(curr
);
780 pDesc
->next_desc
= cpu_to_le32(curr
+sizeof(STxDesc
));
784 pDevice
->apTD0Rings
[i
-1].next_desc
= cpu_to_le32(pDevice
->td0_pool_dma
);
785 pDevice
->apTailTD
[0] = pDevice
->apCurrTD
[0] = &(pDevice
->apTD0Rings
[0]);
788 static void device_init_td1_ring(struct vnt_private
*pDevice
)
794 /* Init the TD ring entries */
795 curr
= pDevice
->td1_pool_dma
;
796 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[1]; i
++, curr
+= sizeof(STxDesc
)) {
797 pDesc
= &(pDevice
->apTD1Rings
[i
]);
798 pDesc
->pTDInfo
= alloc_td_info();
799 ASSERT(pDesc
->pTDInfo
);
800 if (pDevice
->flags
& DEVICE_FLAGS_TX_ALIGN
) {
801 pDesc
->pTDInfo
->buf
= pDevice
->tx1_bufs
+ (i
) * PKT_BUF_SZ
;
802 pDesc
->pTDInfo
->buf_dma
= pDevice
->tx_bufs_dma1
+ (i
) * PKT_BUF_SZ
;
804 pDesc
->next
= &(pDevice
->apTD1Rings
[(i
+ 1) % pDevice
->sOpts
.nTxDescs
[1]]);
805 pDesc
->pTDInfo
->curr_desc
= cpu_to_le32(curr
);
806 pDesc
->next_desc
= cpu_to_le32(curr
+sizeof(STxDesc
));
810 pDevice
->apTD1Rings
[i
-1].next_desc
= cpu_to_le32(pDevice
->td1_pool_dma
);
811 pDevice
->apTailTD
[1] = pDevice
->apCurrTD
[1] = &(pDevice
->apTD1Rings
[0]);
814 static void device_free_td0_ring(struct vnt_private
*pDevice
)
818 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[0]; i
++) {
819 PSTxDesc pDesc
= &(pDevice
->apTD0Rings
[i
]);
820 PDEVICE_TD_INFO pTDInfo
= pDesc
->pTDInfo
;
822 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
))
823 pci_unmap_single(pDevice
->pcid
, pTDInfo
->skb_dma
,
824 pTDInfo
->skb
->len
, PCI_DMA_TODEVICE
);
827 dev_kfree_skb(pTDInfo
->skb
);
829 kfree(pDesc
->pTDInfo
);
833 static void device_free_td1_ring(struct vnt_private
*pDevice
)
837 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[1]; i
++) {
838 PSTxDesc pDesc
= &(pDevice
->apTD1Rings
[i
]);
839 PDEVICE_TD_INFO pTDInfo
= pDesc
->pTDInfo
;
841 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
))
842 pci_unmap_single(pDevice
->pcid
, pTDInfo
->skb_dma
,
843 pTDInfo
->skb
->len
, PCI_DMA_TODEVICE
);
846 dev_kfree_skb(pTDInfo
->skb
);
848 kfree(pDesc
->pTDInfo
);
852 /*-----------------------------------------------------------------*/
854 static int device_rx_srv(struct vnt_private
*pDevice
, unsigned int uIdx
)
859 for (pRD
= pDevice
->pCurrRD
[uIdx
];
860 pRD
->m_rd0RD0
.f1Owner
== OWNED_BY_HOST
;
864 if (vnt_receive_frame(pDevice
, pRD
)) {
865 if (!device_alloc_rx_buf(pDevice
, pRD
)) {
866 dev_err(&pDevice
->pcid
->dev
,
867 "can not allocate rx buf\n");
871 pRD
->m_rd0RD0
.f1Owner
= OWNED_BY_NIC
;
874 pDevice
->pCurrRD
[uIdx
] = pRD
;
879 static bool device_alloc_rx_buf(struct vnt_private
*pDevice
, PSRxDesc pRD
)
881 PDEVICE_RD_INFO pRDInfo
= pRD
->pRDInfo
;
883 pRDInfo
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
884 if (pRDInfo
->skb
== NULL
)
886 ASSERT(pRDInfo
->skb
);
889 pci_map_single(pDevice
->pcid
,
890 skb_put(pRDInfo
->skb
, skb_tailroom(pRDInfo
->skb
)),
891 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
893 *((unsigned int *)&(pRD
->m_rd0RD0
)) = 0; /* FIX cast */
895 pRD
->m_rd0RD0
.wResCount
= cpu_to_le16(pDevice
->rx_buf_sz
);
896 pRD
->m_rd0RD0
.f1Owner
= OWNED_BY_NIC
;
897 pRD
->m_rd1RD1
.wReqCount
= cpu_to_le16(pDevice
->rx_buf_sz
);
898 pRD
->buff_addr
= cpu_to_le32(pRDInfo
->skb_dma
);
903 static const u8 fallback_rate0
[5][5] = {
904 {RATE_18M
, RATE_18M
, RATE_12M
, RATE_12M
, RATE_12M
},
905 {RATE_24M
, RATE_24M
, RATE_18M
, RATE_12M
, RATE_12M
},
906 {RATE_36M
, RATE_36M
, RATE_24M
, RATE_18M
, RATE_18M
},
907 {RATE_48M
, RATE_48M
, RATE_36M
, RATE_24M
, RATE_24M
},
908 {RATE_54M
, RATE_54M
, RATE_48M
, RATE_36M
, RATE_36M
}
911 static const u8 fallback_rate1
[5][5] = {
912 {RATE_18M
, RATE_18M
, RATE_12M
, RATE_6M
, RATE_6M
},
913 {RATE_24M
, RATE_24M
, RATE_18M
, RATE_6M
, RATE_6M
},
914 {RATE_36M
, RATE_36M
, RATE_24M
, RATE_12M
, RATE_12M
},
915 {RATE_48M
, RATE_48M
, RATE_24M
, RATE_12M
, RATE_12M
},
916 {RATE_54M
, RATE_54M
, RATE_36M
, RATE_18M
, RATE_18M
}
919 static int vnt_int_report_rate(struct vnt_private
*priv
,
920 PDEVICE_TD_INFO context
, u8 tsr0
, u8 tsr1
)
922 struct vnt_tx_fifo_head
*fifo_head
;
923 struct ieee80211_tx_info
*info
;
924 struct ieee80211_rate
*rate
;
926 u8 tx_retry
= (tsr0
& TSR0_NCR
);
935 fifo_head
= (struct vnt_tx_fifo_head
*)context
->buf
;
936 fb_option
= (le16_to_cpu(fifo_head
->fifo_ctl
) &
937 (FIFOCTL_AUTO_FB_0
| FIFOCTL_AUTO_FB_1
));
939 info
= IEEE80211_SKB_CB(context
->skb
);
940 idx
= info
->control
.rates
[0].idx
;
942 if (fb_option
&& !(tsr1
& TSR1_TERR
)) {
946 rate
= ieee80211_get_tx_rate(priv
->hw
, info
);
947 tx_rate
= rate
->hw_value
- RATE_18M
;
952 if (fb_option
& FIFOCTL_AUTO_FB_0
)
953 tx_rate
= fallback_rate0
[tx_rate
][retry
];
954 else if (fb_option
& FIFOCTL_AUTO_FB_1
)
955 tx_rate
= fallback_rate1
[tx_rate
][retry
];
957 if (info
->band
== IEEE80211_BAND_5GHZ
)
958 idx
= tx_rate
- RATE_6M
;
963 ieee80211_tx_info_clear_status(info
);
965 info
->status
.rates
[0].count
= tx_retry
;
967 if (!(tsr1
& TSR1_TERR
)) {
968 info
->status
.rates
[0].idx
= idx
;
969 info
->flags
|= IEEE80211_TX_STAT_ACK
;
975 static int device_tx_srv(struct vnt_private
*pDevice
, unsigned int uIdx
)
979 unsigned char byTsr0
;
980 unsigned char byTsr1
;
982 for (pTD
= pDevice
->apTailTD
[uIdx
]; pDevice
->iTDUsed
[uIdx
] > 0; pTD
= pTD
->next
) {
983 if (pTD
->m_td0TD0
.f1Owner
== OWNED_BY_NIC
)
988 byTsr0
= pTD
->m_td0TD0
.byTSR0
;
989 byTsr1
= pTD
->m_td0TD0
.byTSR1
;
991 //Only the status of first TD in the chain is correct
992 if (pTD
->m_td1TD1
.byTCR
& TCR_STP
) {
993 if ((pTD
->pTDInfo
->byFlags
& TD_FLAGS_NETIF_SKB
) != 0) {
995 vnt_int_report_rate(pDevice
, pTD
->pTDInfo
, byTsr0
, byTsr1
);
997 if (!(byTsr1
& TSR1_TERR
)) {
999 pr_debug(" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X]\n",
1004 pr_debug(" Tx[%d] dropped & tsr1[%02X] tsr0[%02X]\n",
1005 (int)uIdx
, byTsr1
, byTsr0
);
1009 if (byTsr1
& TSR1_TERR
) {
1010 if ((pTD
->pTDInfo
->byFlags
& TD_FLAGS_PRIV_SKB
) != 0) {
1011 pr_debug(" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X]\n",
1012 (int)uIdx
, byTsr1
, byTsr0
);
1015 device_free_tx_buf(pDevice
, pTD
);
1016 pDevice
->iTDUsed
[uIdx
]--;
1020 pDevice
->apTailTD
[uIdx
] = pTD
;
1025 static void device_error(struct vnt_private
*pDevice
, unsigned short status
)
1027 if (status
& ISR_FETALERR
) {
1028 dev_err(&pDevice
->pcid
->dev
, "Hardware fatal error\n");
1030 MACbShutdown(pDevice
->PortOffset
);
1035 static void device_free_tx_buf(struct vnt_private
*pDevice
, PSTxDesc pDesc
)
1037 PDEVICE_TD_INFO pTDInfo
= pDesc
->pTDInfo
;
1038 struct sk_buff
*skb
= pTDInfo
->skb
;
1040 // pre-allocated buf_dma can't be unmapped.
1041 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
)) {
1042 pci_unmap_single(pDevice
->pcid
, pTDInfo
->skb_dma
, skb
->len
,
1046 if (pTDInfo
->byFlags
& TD_FLAGS_NETIF_SKB
)
1047 ieee80211_tx_status_irqsafe(pDevice
->hw
, skb
);
1049 dev_kfree_skb_irq(skb
);
1051 pTDInfo
->skb_dma
= 0;
1052 pTDInfo
->skb
= NULL
;
1053 pTDInfo
->byFlags
= 0;
1056 static irqreturn_t
device_intr(int irq
, void *dev_instance
)
1058 struct vnt_private
*pDevice
= dev_instance
;
1060 unsigned long dwMIBCounter
= 0;
1061 unsigned char byOrgPageSel
= 0;
1064 unsigned long flags
;
1066 MACvReadISR(pDevice
->PortOffset
, &pDevice
->dwIsr
);
1068 if (pDevice
->dwIsr
== 0)
1069 return IRQ_RETVAL(handled
);
1071 if (pDevice
->dwIsr
== 0xffffffff) {
1072 pr_debug("dwIsr = 0xffff\n");
1073 return IRQ_RETVAL(handled
);
1077 MACvIntDisable(pDevice
->PortOffset
);
1079 spin_lock_irqsave(&pDevice
->lock
, flags
);
1081 //Make sure current page is 0
1082 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_PAGE1SEL
, &byOrgPageSel
);
1083 if (byOrgPageSel
== 1)
1084 MACvSelectPage0(pDevice
->PortOffset
);
1088 MACvReadMIBCounter(pDevice
->PortOffset
, &dwMIBCounter
);
1090 // Must do this after doing rx/tx, cause ISR bit is slow
1091 // than RD/TD write back
1092 // update ISR counter
1093 STAvUpdate802_11Counter(&pDevice
->s802_11Counter
, &pDevice
->scStatistic
, dwMIBCounter
);
1094 while (pDevice
->dwIsr
!= 0) {
1095 STAvUpdateIsrStatCounter(&pDevice
->scStatistic
, pDevice
->dwIsr
);
1096 MACvWriteISR(pDevice
->PortOffset
, pDevice
->dwIsr
);
1098 if (pDevice
->dwIsr
& ISR_FETALERR
) {
1099 pr_debug(" ISR_FETALERR\n");
1100 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_SOFTPWRCTL
, 0);
1101 VNSvOutPortW(pDevice
->PortOffset
+ MAC_REG_SOFTPWRCTL
, SOFTPWRCTL_SWPECTI
);
1102 device_error(pDevice
, pDevice
->dwIsr
);
1105 if (pDevice
->dwIsr
& ISR_TBTT
) {
1107 pDevice
->op_mode
!= NL80211_IFTYPE_ADHOC
) {
1108 if (pDevice
->bUpdateBBVGA
&&
1109 !(pDevice
->hw
->conf
.flags
& IEEE80211_CONF_OFFCHANNEL
) &&
1110 pDevice
->vif
->bss_conf
.assoc
&&
1111 pDevice
->uCurrRSSI
) {
1114 RFvRSSITodBm(pDevice
, (unsigned char) pDevice
->uCurrRSSI
, &ldBm
);
1115 for (ii
= 0; ii
< BB_VGA_LEVEL
; ii
++) {
1116 if (ldBm
< pDevice
->ldBmThreshold
[ii
]) {
1117 pDevice
->byBBVGANew
= pDevice
->abyBBVGA
[ii
];
1121 if (pDevice
->byBBVGANew
!= pDevice
->byBBVGACurrent
) {
1122 pDevice
->uBBVGADiffCount
++;
1123 if (pDevice
->uBBVGADiffCount
== 1) {
1124 // first VGA diff gain
1125 BBvSetVGAGainOffset(pDevice
, pDevice
->byBBVGANew
);
1126 pr_debug("First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
1128 pDevice
->byBBVGANew
,
1129 pDevice
->byBBVGACurrent
,
1130 (int)pDevice
->uBBVGADiffCount
);
1132 if (pDevice
->uBBVGADiffCount
>= BB_VGA_CHANGE_THRESHOLD
) {
1133 pr_debug("RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
1135 pDevice
->byBBVGANew
,
1136 pDevice
->byBBVGACurrent
,
1137 (int)pDevice
->uBBVGADiffCount
);
1138 BBvSetVGAGainOffset(pDevice
, pDevice
->byBBVGANew
);
1141 pDevice
->uBBVGADiffCount
= 1;
1146 pDevice
->bBeaconSent
= false;
1147 if (pDevice
->bEnablePSMode
)
1148 PSbIsNextTBTTWakeUp((void *)pDevice
);
1150 if ((pDevice
->op_mode
== NL80211_IFTYPE_AP
||
1151 pDevice
->op_mode
== NL80211_IFTYPE_ADHOC
) &&
1152 pDevice
->vif
->bss_conf
.enable_beacon
) {
1153 MACvOneShotTimer1MicroSec(pDevice
->PortOffset
,
1154 (pDevice
->vif
->bss_conf
.beacon_int
- MAKE_BEACON_RESERVED
) << 10);
1157 /* TODO: adhoc PS mode */
1161 if (pDevice
->dwIsr
& ISR_BNTX
) {
1162 if (pDevice
->op_mode
== NL80211_IFTYPE_ADHOC
) {
1163 pDevice
->bIsBeaconBufReadySet
= false;
1164 pDevice
->cbBeaconBufReadySetCnt
= 0;
1167 pDevice
->bBeaconSent
= true;
1170 if (pDevice
->dwIsr
& ISR_RXDMA0
)
1171 max_count
+= device_rx_srv(pDevice
, TYPE_RXDMA0
);
1173 if (pDevice
->dwIsr
& ISR_RXDMA1
)
1174 max_count
+= device_rx_srv(pDevice
, TYPE_RXDMA1
);
1176 if (pDevice
->dwIsr
& ISR_TXDMA0
)
1177 max_count
+= device_tx_srv(pDevice
, TYPE_TXDMA0
);
1179 if (pDevice
->dwIsr
& ISR_AC0DMA
)
1180 max_count
+= device_tx_srv(pDevice
, TYPE_AC0DMA
);
1182 if (pDevice
->dwIsr
& ISR_SOFTTIMER1
) {
1184 if (pDevice
->vif
->bss_conf
.enable_beacon
)
1185 vnt_beacon_make(pDevice
, pDevice
->vif
);
1189 /* If both buffers available wake the queue */
1191 if (AVAIL_TD(pDevice
, TYPE_TXDMA0
) &&
1192 AVAIL_TD(pDevice
, TYPE_AC0DMA
) &&
1193 ieee80211_queue_stopped(pDevice
->hw
, 0))
1194 ieee80211_wake_queues(pDevice
->hw
);
1197 MACvReadISR(pDevice
->PortOffset
, &pDevice
->dwIsr
);
1199 MACvReceive0(pDevice
->PortOffset
);
1200 MACvReceive1(pDevice
->PortOffset
);
1202 if (max_count
> pDevice
->sOpts
.int_works
)
1206 if (byOrgPageSel
== 1)
1207 MACvSelectPage1(pDevice
->PortOffset
);
1209 spin_unlock_irqrestore(&pDevice
->lock
, flags
);
1211 MACvIntEnable(pDevice
->PortOffset
, IMR_MASK_VALUE
);
1213 return IRQ_RETVAL(handled
);
1216 static int vnt_tx_packet(struct vnt_private
*priv
, struct sk_buff
*skb
)
1218 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
1220 u32 dma_idx
= TYPE_AC0DMA
;
1221 unsigned long flags
;
1223 spin_lock_irqsave(&priv
->lock
, flags
);
1225 if (!ieee80211_is_data(hdr
->frame_control
))
1226 dma_idx
= TYPE_TXDMA0
;
1228 if (AVAIL_TD(priv
, dma_idx
) < 1) {
1229 spin_unlock_irqrestore(&priv
->lock
, flags
);
1233 head_td
= priv
->apCurrTD
[dma_idx
];
1235 head_td
->m_td1TD1
.byTCR
= (TCR_EDP
|TCR_STP
);
1237 head_td
->pTDInfo
->skb
= skb
;
1239 priv
->iTDUsed
[dma_idx
]++;
1241 /* Take ownership */
1243 head_td
->m_td0TD0
.f1Owner
= OWNED_BY_NIC
;
1247 priv
->apCurrTD
[dma_idx
] = head_td
->next
;
1249 spin_unlock_irqrestore(&priv
->lock
, flags
);
1251 vnt_generate_fifo_header(priv
, dma_idx
, head_td
, skb
);
1253 if (MACbIsRegBitsOn(priv
->PortOffset
, MAC_REG_PSCTL
, PSCTL_PS
))
1254 MACbPSWakeup(priv
->PortOffset
);
1256 spin_lock_irqsave(&priv
->lock
, flags
);
1258 priv
->bPWBitOn
= false;
1260 head_td
->pTDInfo
->byFlags
= TD_FLAGS_NETIF_SKB
;
1262 if (dma_idx
== TYPE_AC0DMA
)
1263 MACvTransmitAC0(priv
->PortOffset
);
1265 MACvTransmit0(priv
->PortOffset
);
1267 spin_unlock_irqrestore(&priv
->lock
, flags
);
1272 static void vnt_tx_80211(struct ieee80211_hw
*hw
,
1273 struct ieee80211_tx_control
*control
,
1274 struct sk_buff
*skb
)
1276 struct vnt_private
*priv
= hw
->priv
;
1278 ieee80211_stop_queues(hw
);
1280 if (vnt_tx_packet(priv
, skb
)) {
1281 ieee80211_free_txskb(hw
, skb
);
1283 ieee80211_wake_queues(hw
);
1287 static int vnt_start(struct ieee80211_hw
*hw
)
1289 struct vnt_private
*priv
= hw
->priv
;
1292 priv
->rx_buf_sz
= PKT_BUF_SZ
;
1293 if (!device_init_rings(priv
))
1296 ret
= request_irq(priv
->pcid
->irq
, &device_intr
,
1297 IRQF_SHARED
, "vt6655", priv
);
1299 dev_dbg(&priv
->pcid
->dev
, "failed to start irq\n");
1303 dev_dbg(&priv
->pcid
->dev
, "call device init rd0 ring\n");
1304 device_init_rd0_ring(priv
);
1305 device_init_rd1_ring(priv
);
1306 device_init_td0_ring(priv
);
1307 device_init_td1_ring(priv
);
1309 device_init_registers(priv
);
1311 dev_dbg(&priv
->pcid
->dev
, "call MACvIntEnable\n");
1312 MACvIntEnable(priv
->PortOffset
, IMR_MASK_VALUE
);
1314 ieee80211_wake_queues(hw
);
1319 static void vnt_stop(struct ieee80211_hw
*hw
)
1321 struct vnt_private
*priv
= hw
->priv
;
1323 ieee80211_stop_queues(hw
);
1325 MACbShutdown(priv
->PortOffset
);
1326 MACbSoftwareReset(priv
->PortOffset
);
1327 CARDbRadioPowerOff(priv
);
1329 device_free_td0_ring(priv
);
1330 device_free_td1_ring(priv
);
1331 device_free_rd0_ring(priv
);
1332 device_free_rd1_ring(priv
);
1333 device_free_rings(priv
);
1335 free_irq(priv
->pcid
->irq
, priv
);
1338 static int vnt_add_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
1340 struct vnt_private
*priv
= hw
->priv
;
1344 switch (vif
->type
) {
1345 case NL80211_IFTYPE_STATION
:
1346 if (priv
->bDiversityRegCtlON
)
1347 device_init_diversity_timer(priv
);
1349 case NL80211_IFTYPE_ADHOC
:
1350 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_RCR
, RCR_UNICAST
);
1352 MACvRegBitsOn(priv
->PortOffset
, MAC_REG_HOSTCR
, HOSTCR_ADHOC
);
1355 case NL80211_IFTYPE_AP
:
1356 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_RCR
, RCR_UNICAST
);
1358 MACvRegBitsOn(priv
->PortOffset
, MAC_REG_HOSTCR
, HOSTCR_AP
);
1365 priv
->op_mode
= vif
->type
;
1370 static void vnt_remove_interface(struct ieee80211_hw
*hw
,
1371 struct ieee80211_vif
*vif
)
1373 struct vnt_private
*priv
= hw
->priv
;
1375 switch (vif
->type
) {
1376 case NL80211_IFTYPE_STATION
:
1377 if (priv
->bDiversityRegCtlON
) {
1378 del_timer(&priv
->TimerSQ3Tmax1
);
1379 del_timer(&priv
->TimerSQ3Tmax2
);
1380 del_timer(&priv
->TimerSQ3Tmax3
);
1383 case NL80211_IFTYPE_ADHOC
:
1384 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1385 MACvRegBitsOff(priv
->PortOffset
,
1386 MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
1387 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_HOSTCR
, HOSTCR_ADHOC
);
1389 case NL80211_IFTYPE_AP
:
1390 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1391 MACvRegBitsOff(priv
->PortOffset
,
1392 MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
1393 MACvRegBitsOff(priv
->PortOffset
, MAC_REG_HOSTCR
, HOSTCR_AP
);
1399 priv
->op_mode
= NL80211_IFTYPE_UNSPECIFIED
;
1403 static int vnt_config(struct ieee80211_hw
*hw
, u32 changed
)
1405 struct vnt_private
*priv
= hw
->priv
;
1406 struct ieee80211_conf
*conf
= &hw
->conf
;
1409 if (changed
& IEEE80211_CONF_CHANGE_PS
) {
1410 if (conf
->flags
& IEEE80211_CONF_PS
)
1411 PSvEnablePowerSaving(priv
, conf
->listen_interval
);
1413 PSvDisablePowerSaving(priv
);
1416 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
) ||
1417 (conf
->flags
& IEEE80211_CONF_OFFCHANNEL
)) {
1418 set_channel(priv
, conf
->chandef
.chan
->hw_value
);
1420 if (conf
->chandef
.chan
->band
== IEEE80211_BAND_5GHZ
)
1421 bb_type
= BB_TYPE_11A
;
1423 bb_type
= BB_TYPE_11G
;
1425 if (priv
->byBBType
!= bb_type
) {
1426 priv
->byBBType
= bb_type
;
1428 CARDbSetPhyParameter(priv
, priv
->byBBType
);
1432 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
1433 if (priv
->byBBType
== BB_TYPE_11B
)
1434 priv
->wCurrentRate
= RATE_1M
;
1436 priv
->wCurrentRate
= RATE_54M
;
1438 RFbSetPower(priv
, priv
->wCurrentRate
,
1439 conf
->chandef
.chan
->hw_value
);
1445 static void vnt_bss_info_changed(struct ieee80211_hw
*hw
,
1446 struct ieee80211_vif
*vif
, struct ieee80211_bss_conf
*conf
,
1449 struct vnt_private
*priv
= hw
->priv
;
1451 priv
->current_aid
= conf
->aid
;
1453 if (changed
& BSS_CHANGED_BSSID
)
1454 MACvWriteBSSIDAddress(priv
->PortOffset
, (u8
*)conf
->bssid
);
1456 if (changed
& BSS_CHANGED_BASIC_RATES
) {
1457 priv
->basic_rates
= conf
->basic_rates
;
1459 CARDvUpdateBasicTopRate(priv
);
1461 dev_dbg(&priv
->pcid
->dev
,
1462 "basic rates %x\n", conf
->basic_rates
);
1465 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
1466 if (conf
->use_short_preamble
) {
1467 MACvEnableBarkerPreambleMd(priv
->PortOffset
);
1468 priv
->byPreambleType
= true;
1470 MACvDisableBarkerPreambleMd(priv
->PortOffset
);
1471 priv
->byPreambleType
= false;
1475 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
1476 if (conf
->use_cts_prot
)
1477 MACvEnableProtectMD(priv
->PortOffset
);
1479 MACvDisableProtectMD(priv
->PortOffset
);
1482 if (changed
& BSS_CHANGED_ERP_SLOT
) {
1483 if (conf
->use_short_slot
)
1484 priv
->bShortSlotTime
= true;
1486 priv
->bShortSlotTime
= false;
1488 CARDbSetPhyParameter(priv
, priv
->byBBType
);
1489 BBvSetVGAGainOffset(priv
, priv
->abyBBVGA
[0]);
1492 if (changed
& BSS_CHANGED_TXPOWER
)
1493 RFbSetPower(priv
, priv
->wCurrentRate
,
1494 conf
->chandef
.chan
->hw_value
);
1496 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
1497 dev_dbg(&priv
->pcid
->dev
,
1498 "Beacon enable %d\n", conf
->enable_beacon
);
1500 if (conf
->enable_beacon
) {
1501 vnt_beacon_enable(priv
, vif
, conf
);
1503 MACvRegBitsOn(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1505 MACvRegBitsOff(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
1509 if (changed
& BSS_CHANGED_ASSOC
&& priv
->op_mode
!= NL80211_IFTYPE_AP
) {
1511 CARDbUpdateTSF(priv
, conf
->beacon_rate
->hw_value
,
1512 conf
->sync_device_ts
, conf
->sync_tsf
);
1514 CARDbSetBeaconPeriod(priv
, conf
->beacon_int
);
1516 CARDvSetFirstNextTBTT(priv
, conf
->beacon_int
);
1518 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
,
1520 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
,
1526 static u64
vnt_prepare_multicast(struct ieee80211_hw
*hw
,
1527 struct netdev_hw_addr_list
*mc_list
)
1529 struct vnt_private
*priv
= hw
->priv
;
1530 struct netdev_hw_addr
*ha
;
1534 netdev_hw_addr_list_for_each(ha
, mc_list
) {
1535 bit_nr
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
1537 mc_filter
|= 1ULL << (bit_nr
& 0x3f);
1540 priv
->mc_list_count
= mc_list
->count
;
1545 static void vnt_configure(struct ieee80211_hw
*hw
,
1546 unsigned int changed_flags
, unsigned int *total_flags
, u64 multicast
)
1548 struct vnt_private
*priv
= hw
->priv
;
1551 *total_flags
&= FIF_ALLMULTI
| FIF_OTHER_BSS
| FIF_PROMISC_IN_BSS
|
1552 FIF_BCN_PRBRESP_PROMISC
;
1554 VNSvInPortB(priv
->PortOffset
+ MAC_REG_RCR
, &rx_mode
);
1556 dev_dbg(&priv
->pcid
->dev
, "rx mode in = %x\n", rx_mode
);
1558 if (changed_flags
& FIF_PROMISC_IN_BSS
) {
1559 /* unconditionally log net taps */
1560 if (*total_flags
& FIF_PROMISC_IN_BSS
)
1561 rx_mode
|= RCR_UNICAST
;
1563 rx_mode
&= ~RCR_UNICAST
;
1566 if (changed_flags
& FIF_ALLMULTI
) {
1567 if (*total_flags
& FIF_ALLMULTI
) {
1568 if (priv
->mc_list_count
> 2) {
1569 MACvSelectPage1(priv
->PortOffset
);
1571 VNSvOutPortD(priv
->PortOffset
+
1572 MAC_REG_MAR0
, 0xffffffff);
1573 VNSvOutPortD(priv
->PortOffset
+
1574 MAC_REG_MAR0
+ 4, 0xffffffff);
1576 MACvSelectPage0(priv
->PortOffset
);
1578 MACvSelectPage1(priv
->PortOffset
);
1580 VNSvOutPortD(priv
->PortOffset
+
1581 MAC_REG_MAR0
, (u32
)multicast
);
1582 VNSvOutPortD(priv
->PortOffset
+
1584 (u32
)(multicast
>> 32));
1586 MACvSelectPage0(priv
->PortOffset
);
1589 rx_mode
|= RCR_MULTICAST
| RCR_BROADCAST
;
1591 rx_mode
&= ~(RCR_MULTICAST
| RCR_BROADCAST
);
1595 if (changed_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
)) {
1596 rx_mode
|= RCR_MULTICAST
| RCR_BROADCAST
;
1598 if (*total_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
))
1599 rx_mode
&= ~RCR_BSSID
;
1601 rx_mode
|= RCR_BSSID
;
1604 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_RCR
, rx_mode
);
1606 dev_dbg(&priv
->pcid
->dev
, "rx mode out= %x\n", rx_mode
);
1609 static int vnt_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
1610 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
1611 struct ieee80211_key_conf
*key
)
1613 struct vnt_private
*priv
= hw
->priv
;
1617 if (vnt_set_keys(hw
, sta
, vif
, key
))
1621 if (test_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
))
1622 clear_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
);
1630 static u64
vnt_get_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
1632 struct vnt_private
*priv
= hw
->priv
;
1635 CARDbGetCurrentTSF(priv
, &tsf
);
1640 static void vnt_set_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
1643 struct vnt_private
*priv
= hw
->priv
;
1645 CARDvUpdateNextTBTT(priv
, tsf
, vif
->bss_conf
.beacon_int
);
1648 static void vnt_reset_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
1650 struct vnt_private
*priv
= hw
->priv
;
1652 /* reset TSF counter */
1653 VNSvOutPortB(priv
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTRST
);
1656 static const struct ieee80211_ops vnt_mac_ops
= {
1660 .add_interface
= vnt_add_interface
,
1661 .remove_interface
= vnt_remove_interface
,
1662 .config
= vnt_config
,
1663 .bss_info_changed
= vnt_bss_info_changed
,
1664 .prepare_multicast
= vnt_prepare_multicast
,
1665 .configure_filter
= vnt_configure
,
1666 .set_key
= vnt_set_key
,
1667 .get_tsf
= vnt_get_tsf
,
1668 .set_tsf
= vnt_set_tsf
,
1669 .reset_tsf
= vnt_reset_tsf
,
1672 int vnt_init(struct vnt_private
*priv
)
1674 SET_IEEE80211_PERM_ADDR(priv
->hw
, priv
->abyCurrentNetAddr
);
1676 vnt_init_bands(priv
);
1678 if (ieee80211_register_hw(priv
->hw
))
1681 priv
->mac_hw
= true;
1683 CARDbRadioPowerOff(priv
);
1689 vt6655_probe(struct pci_dev
*pcid
, const struct pci_device_id
*ent
)
1691 PCHIP_INFO pChip_info
= (PCHIP_INFO
)ent
->driver_data
;
1692 struct vnt_private
*priv
;
1693 struct ieee80211_hw
*hw
;
1694 struct wiphy
*wiphy
;
1697 dev_notice(&pcid
->dev
,
1698 "%s Ver. %s\n", DEVICE_FULL_DRV_NAM
, DEVICE_VERSION
);
1700 dev_notice(&pcid
->dev
,
1701 "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
1703 hw
= ieee80211_alloc_hw(sizeof(*priv
), &vnt_mac_ops
);
1705 dev_err(&pcid
->dev
, "could not register ieee80211_hw\n");
1711 vt6655_init_info(pcid
, &priv
, pChip_info
);
1715 SET_IEEE80211_DEV(priv
->hw
, &pcid
->dev
);
1717 if (pci_enable_device(pcid
)) {
1718 device_free_info(priv
);
1723 "Before get pci_info memaddr is %x\n", priv
->memaddr
);
1725 if (!device_get_pci_info(priv
, pcid
)) {
1726 dev_err(&pcid
->dev
, ": Failed to find PCI device.\n");
1727 device_free_info(priv
);
1733 "after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",
1734 priv
->memaddr
, priv
->ioaddr
, priv
->io_size
);
1746 for (i
= 0; address
[i
]; i
++) {
1747 pci_read_config_dword(pcid
, address
[i
], &bar
);
1749 dev_dbg(&pcid
->dev
, "bar %d is %x\n", i
, bar
);
1753 "bar %d not implemented\n", i
);
1757 if (bar
& PCI_BASE_ADDRESS_SPACE_IO
) {
1760 len
= bar
& (PCI_BASE_ADDRESS_IO_MASK
& 0xffff);
1761 len
= len
& ~(len
- 1);
1764 "IO space: len in IO %x, BAR %d\n",
1767 len
= bar
& 0xfffffff0;
1771 "len in MEM %x, BAR %d\n", len
, i
);
1777 priv
->PortOffset
= ioremap(priv
->memaddr
& PCI_BASE_ADDRESS_MEM_MASK
,
1779 if (!priv
->PortOffset
) {
1780 dev_err(&pcid
->dev
, ": Failed to IO remapping ..\n");
1781 device_free_info(priv
);
1785 rc
= pci_request_regions(pcid
, DEVICE_NAME
);
1787 dev_err(&pcid
->dev
, ": Failed to find PCI device\n");
1788 device_free_info(priv
);
1793 if (!MACbSoftwareReset(priv
->PortOffset
)) {
1794 dev_err(&pcid
->dev
, ": Failed to access MAC hardware..\n");
1795 device_free_info(priv
);
1798 /* initial to reload eeprom */
1799 MACvInitialize(priv
->PortOffset
);
1800 MACvReadEtherAddress(priv
->PortOffset
, priv
->abyCurrentNetAddr
);
1802 device_get_options(priv
);
1803 device_set_options(priv
);
1804 /* Mask out the options cannot be set to the chip */
1805 priv
->sOpts
.flags
&= pChip_info
->flags
;
1807 /* Enable the chip specified capabilities */
1808 priv
->flags
= priv
->sOpts
.flags
| (pChip_info
->flags
& 0xff000000UL
);
1810 wiphy
= priv
->hw
->wiphy
;
1812 wiphy
->frag_threshold
= FRAG_THRESH_DEF
;
1813 wiphy
->rts_threshold
= RTS_THRESH_DEF
;
1814 wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
1815 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
1817 priv
->hw
->flags
= IEEE80211_HW_RX_INCLUDES_FCS
|
1818 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
1819 IEEE80211_HW_SIGNAL_DBM
|
1820 IEEE80211_HW_TIMING_BEACON_ONLY
;
1822 priv
->hw
->max_signal
= 100;
1827 device_print_info(priv
);
1828 pci_set_drvdata(pcid
, priv
);
1833 /*------------------------------------------------------------------*/
1836 static int vt6655_suspend(struct pci_dev
*pcid
, pm_message_t state
)
1838 struct vnt_private
*priv
= pci_get_drvdata(pcid
);
1839 unsigned long flags
;
1841 spin_lock_irqsave(&priv
->lock
, flags
);
1843 pci_save_state(pcid
);
1845 MACbShutdown(priv
->PortOffset
);
1847 pci_disable_device(pcid
);
1848 pci_set_power_state(pcid
, pci_choose_state(pcid
, state
));
1850 spin_unlock_irqrestore(&priv
->lock
, flags
);
1855 static int vt6655_resume(struct pci_dev
*pcid
)
1858 pci_set_power_state(pcid
, PCI_D0
);
1859 pci_enable_wake(pcid
, PCI_D0
, 0);
1860 pci_restore_state(pcid
);
1866 MODULE_DEVICE_TABLE(pci
, vt6655_pci_id_table
);
1868 static struct pci_driver device_driver
= {
1869 .name
= DEVICE_NAME
,
1870 .id_table
= vt6655_pci_id_table
,
1871 .probe
= vt6655_probe
,
1872 .remove
= vt6655_remove
,
1874 .suspend
= vt6655_suspend
,
1875 .resume
= vt6655_resume
,
1879 static int __init
vt6655_init_module(void)
1883 ret
= pci_register_driver(&device_driver
);
1886 register_reboot_notifier(&device_notifier
);
1892 static void __exit
vt6655_cleanup_module(void)
1895 unregister_reboot_notifier(&device_notifier
);
1897 pci_unregister_driver(&device_driver
);
1900 module_init(vt6655_init_module
);
1901 module_exit(vt6655_cleanup_module
);
1905 device_notify_reboot(struct notifier_block
*nb
, unsigned long event
, void *p
)
1907 struct pci_dev
*pdev
= NULL
;
1913 for_each_pci_dev(pdev
) {
1914 if (pci_dev_driver(pdev
) == &device_driver
) {
1915 if (pci_get_drvdata(pdev
))
1916 vt6655_suspend(pdev
, PMSG_HIBERNATE
);