Skip to content

K
kernel_linux

OpenHarmony / kernel_linux
上一次同步 4 年多

通知 15
Star 8
Fork 2
K
kernel_linux
提交 78e0e853 编写于 作者: M Malcolm Priestley 提交者： Greg Kroah-Hartman
浏览文件
操作

staging: vt6655: device_main replace pDevice with priv. 

Removing camel case.
Signed-off-by: NMalcolm Priestley <tvboxspy@gmail.com>
Signed-off-by: NGreg Kroah-Hartman <gregkh@linuxfoundation.org>
上级 464b577c
隐藏空白更改
内联 并排
Showing with 292 addition and 296 deletion
drivers/staging/vt6655/device_main.c
浏览文件 @ 78e0e853
...@@ -134,24 +134,24 @@ static const struct pci_device_id vt6655_pci_id_table[] = { ...@@ -134,24 +134,24 @@ static const struct pci_device_id vt6655_pci_id_table[] = {
/*--------------------- Static Functions --------------------------*/ /*--------------------- Static Functions --------------------------*/
static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent); static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent);
static void device_free_info(struct vnt_private *pDevice); static void device_free_info(struct vnt_private *priv);
static void device_print_info(struct vnt_private *pDevice); static void device_print_info(struct vnt_private *priv);
static void device_init_rd0_ring(struct vnt_private *pDevice); static void device_init_rd0_ring(struct vnt_private *priv);
static void device_init_rd1_ring(struct vnt_private *pDevice); static void device_init_rd1_ring(struct vnt_private *priv);
static void device_init_td0_ring(struct vnt_private *pDevice); static void device_init_td0_ring(struct vnt_private *priv);
static void device_init_td1_ring(struct vnt_private *pDevice); static void device_init_td1_ring(struct vnt_private *priv);
static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx); static int device_rx_srv(struct vnt_private *priv, unsigned int uIdx);
static int device_tx_srv(struct vnt_private *pDevice, unsigned int uIdx); static int device_tx_srv(struct vnt_private *priv, unsigned int uIdx);
static bool device_alloc_rx_buf(struct vnt_private *, struct vnt_rx_desc *); static bool device_alloc_rx_buf(struct vnt_private *, struct vnt_rx_desc *);
static void device_init_registers(struct vnt_private *pDevice); static void device_init_registers(struct vnt_private *priv);
static void device_free_tx_buf(struct vnt_private *, struct vnt_tx_desc *); static void device_free_tx_buf(struct vnt_private *, struct vnt_tx_desc *);
static void device_free_td0_ring(struct vnt_private *pDevice); static void device_free_td0_ring(struct vnt_private *priv);
static void device_free_td1_ring(struct vnt_private *pDevice); static void device_free_td1_ring(struct vnt_private *priv);
static void device_free_rd0_ring(struct vnt_private *pDevice); static void device_free_rd0_ring(struct vnt_private *priv);
static void device_free_rd1_ring(struct vnt_private *pDevice); static void device_free_rd1_ring(struct vnt_private *priv);
static void device_free_rings(struct vnt_private *pDevice); static void device_free_rings(struct vnt_private *priv);
/*--------------------- Export Variables --------------------------*/ /*--------------------- Export Variables --------------------------*/
...@@ -159,16 +159,16 @@ static void device_free_rings(struct vnt_private *pDevice); ...@@ -159,16 +159,16 @@ static void device_free_rings(struct vnt_private *pDevice);
static void vt6655_remove(struct pci_dev *pcid) static void vt6655_remove(struct pci_dev *pcid)
{ {
struct vnt_private *pDevice = pci_get_drvdata(pcid); struct vnt_private *priv = pci_get_drvdata(pcid);
if (pDevice == NULL) if (priv == NULL)
return; return;
device_free_info(pDevice); device_free_info(priv);
} }
static void device_get_options(struct vnt_private *pDevice) static void device_get_options(struct vnt_private *priv)
{ {
POPTIONS pOpts = &(pDevice->sOpts); POPTIONS pOpts = &priv->sOpts;
pOpts->nRxDescs0 = RX_DESC_DEF0; pOpts->nRxDescs0 = RX_DESC_DEF0;
pOpts->nRxDescs1 = RX_DESC_DEF1; pOpts->nRxDescs1 = RX_DESC_DEF1;
...@@ -182,28 +182,28 @@ static void device_get_options(struct vnt_private *pDevice) ...@@ -182,28 +182,28 @@ static void device_get_options(struct vnt_private *pDevice)
} }
static void static void
device_set_options(struct vnt_private *pDevice) device_set_options(struct vnt_private *priv)
{ {
pDevice->byShortRetryLimit = pDevice->sOpts.short_retry; priv->byShortRetryLimit = priv->sOpts.short_retry;
pDevice->byLongRetryLimit = pDevice->sOpts.long_retry; priv->byLongRetryLimit = priv->sOpts.long_retry;
pDevice->byBBType = pDevice->sOpts.bbp_type; priv->byBBType = priv->sOpts.bbp_type;
pDevice->byPacketType = pDevice->byBBType; priv->byPacketType = priv->byBBType;
pDevice->byAutoFBCtrl = AUTO_FB_0; priv->byAutoFBCtrl = AUTO_FB_0;
pDevice->bUpdateBBVGA = true; priv->bUpdateBBVGA = true;
pDevice->byPreambleType = 0; priv->byPreambleType = 0;
pr_debug(" byShortRetryLimit= %d\n", (int)pDevice->byShortRetryLimit); pr_debug(" byShortRetryLimit= %d\n", (int)priv->byShortRetryLimit);
pr_debug(" byLongRetryLimit= %d\n", (int)pDevice->byLongRetryLimit); pr_debug(" byLongRetryLimit= %d\n", (int)priv->byLongRetryLimit);
pr_debug(" byPreambleType= %d\n", (int)pDevice->byPreambleType); pr_debug(" byPreambleType= %d\n", (int)priv->byPreambleType);
pr_debug(" byShortPreamble= %d\n", (int)pDevice->byShortPreamble); pr_debug(" byShortPreamble= %d\n", (int)priv->byShortPreamble);
pr_debug(" byBBType= %d\n", (int)pDevice->byBBType); pr_debug(" byBBType= %d\n", (int)priv->byBBType);
} }
/* /*
* Initialisation of MAC & BBP registers * Initialisation of MAC & BBP registers
*/ */
static void device_init_registers(struct vnt_private *pDevice) static void device_init_registers(struct vnt_private *priv)
{ {
unsigned long flags; unsigned long flags;
unsigned int ii; unsigned int ii;
...@@ -211,45 +211,45 @@ static void device_init_registers(struct vnt_private *pDevice) ...@@ -211,45 +211,45 @@ static void device_init_registers(struct vnt_private *pDevice)
unsigned char byCCKPwrdBm = 0; unsigned char byCCKPwrdBm = 0;
unsigned char byOFDMPwrdBm = 0; unsigned char byOFDMPwrdBm = 0;
MACbShutdown(pDevice->PortOffset); MACbShutdown(priv->PortOffset);
BBvSoftwareReset(pDevice); BBvSoftwareReset(priv);
/* Do MACbSoftwareReset in MACvInitialize */ /* Do MACbSoftwareReset in MACvInitialize */
MACbSoftwareReset(pDevice->PortOffset); MACbSoftwareReset(priv->PortOffset);
pDevice->bAES = false; priv->bAES = false;
/* Only used in 11g type, sync with ERP IE */ /* Only used in 11g type, sync with ERP IE */
pDevice->bProtectMode = false; priv->bProtectMode = false;
pDevice->bNonERPPresent = false; priv->bNonERPPresent = false;
pDevice->bBarkerPreambleMd = false; priv->bBarkerPreambleMd = false;
pDevice->wCurrentRate = RATE_1M; priv->wCurrentRate = RATE_1M;
pDevice->byTopOFDMBasicRate = RATE_24M; priv->byTopOFDMBasicRate = RATE_24M;
pDevice->byTopCCKBasicRate = RATE_1M; priv->byTopCCKBasicRate = RATE_1M;
/* init MAC */ /* init MAC */
MACvInitialize(pDevice->PortOffset); MACvInitialize(priv->PortOffset);
/* Get Local ID */ /* Get Local ID */
VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &pDevice->byLocalID); VNSvInPortB(priv->PortOffset + MAC_REG_LOCALID, &priv->byLocalID);
spin_lock_irqsave(&pDevice->lock, flags); spin_lock_irqsave(&priv->lock, flags);
SROMvReadAllContents(pDevice->PortOffset, pDevice->abyEEPROM); SROMvReadAllContents(priv->PortOffset, priv->abyEEPROM);
spin_unlock_irqrestore(&pDevice->lock, flags); spin_unlock_irqrestore(&priv->lock, flags);
/* Get Channel range */ /* Get Channel range */
pDevice->byMinChannel = 1; priv->byMinChannel = 1;
pDevice->byMaxChannel = CB_MAX_CHANNEL; priv->byMaxChannel = CB_MAX_CHANNEL;
/* Get Antena */ /* Get Antena */
byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA); byValue = SROMbyReadEmbedded(priv->PortOffset, EEP_OFS_ANTENNA);
if (byValue & EEP_ANTINV) if (byValue & EEP_ANTINV)
pDevice->bTxRxAntInv = true; priv->bTxRxAntInv = true;
else else
pDevice->bTxRxAntInv = false; priv->bTxRxAntInv = false;
byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
/* if not set default is All */ /* if not set default is All */
...@@ -257,352 +257,348 @@ static void device_init_registers(struct vnt_private *pDevice) ...@@ -257,352 +257,348 @@ static void device_init_registers(struct vnt_private *pDevice)
byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) { if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
pDevice->byAntennaCount = 2; priv->byAntennaCount = 2;
pDevice->byTxAntennaMode = ANT_B; priv->byTxAntennaMode = ANT_B;
pDevice->dwTxAntennaSel = 1; priv->dwTxAntennaSel = 1;
pDevice->dwRxAntennaSel = 1; priv->dwRxAntennaSel = 1;
if (pDevice->bTxRxAntInv) if (priv->bTxRxAntInv)
pDevice->byRxAntennaMode = ANT_A; priv->byRxAntennaMode = ANT_A;
else else
pDevice->byRxAntennaMode = ANT_B; priv->byRxAntennaMode = ANT_B;
} else { } else {
pDevice->byAntennaCount = 1; priv->byAntennaCount = 1;
pDevice->dwTxAntennaSel = 0; priv->dwTxAntennaSel = 0;
pDevice->dwRxAntennaSel = 0; priv->dwRxAntennaSel = 0;
if (byValue & EEP_ANTENNA_AUX) { if (byValue & EEP_ANTENNA_AUX) {
pDevice->byTxAntennaMode = ANT_A; priv->byTxAntennaMode = ANT_A;
if (pDevice->bTxRxAntInv) if (priv->bTxRxAntInv)
pDevice->byRxAntennaMode = ANT_B; priv->byRxAntennaMode = ANT_B;
else else
pDevice->byRxAntennaMode = ANT_A; priv->byRxAntennaMode = ANT_A;
} else { } else {
pDevice->byTxAntennaMode = ANT_B; priv->byTxAntennaMode = ANT_B;
if (pDevice->bTxRxAntInv) if (priv->bTxRxAntInv)
pDevice->byRxAntennaMode = ANT_A; priv->byRxAntennaMode = ANT_A;
else else
pDevice->byRxAntennaMode = ANT_B; priv->byRxAntennaMode = ANT_B;
} }
} }
/* Set initial antenna mode */ /* Set initial antenna mode */
BBvSetTxAntennaMode(pDevice, pDevice->byTxAntennaMode); BBvSetTxAntennaMode(priv, priv->byTxAntennaMode);
BBvSetRxAntennaMode(pDevice, pDevice->byRxAntennaMode); BBvSetRxAntennaMode(priv, priv->byRxAntennaMode);
/* zonetype initial */ /* zonetype initial */
pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE]; priv->byOriginalZonetype = priv->abyEEPROM[EEP_OFS_ZONETYPE];
if (!pDevice->bZoneRegExist) if (!priv->bZoneRegExist)
pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE]; priv->byZoneType = priv->abyEEPROM[EEP_OFS_ZONETYPE];
pr_debug("pDevice->byZoneType = %x\n", pDevice->byZoneType); pr_debug("priv->byZoneType = %x\n", priv->byZoneType);
/* Init RF module */ /* Init RF module */
RFbInit(pDevice); RFbInit(priv);
/* Get Desire Power Value */ /* Get Desire Power Value */
pDevice->byCurPwr = 0xFF; priv->byCurPwr = 0xFF;
pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK); priv->byCCKPwr = SROMbyReadEmbedded(priv->PortOffset, EEP_OFS_PWR_CCK);
pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG); priv->byOFDMPwrG = SROMbyReadEmbedded(priv->PortOffset, EEP_OFS_PWR_OFDMG);
/* Load power Table */ /* Load power Table */
for (ii = 0; ii < CB_MAX_CHANNEL_24G; ii++) { for (ii = 0; ii < CB_MAX_CHANNEL_24G; ii++) {
pDevice->abyCCKPwrTbl[ii + 1] = priv->abyCCKPwrTbl[ii + 1] =
SROMbyReadEmbedded(pDevice->PortOffset, SROMbyReadEmbedded(priv->PortOffset,
(unsigned char)(ii + EEP_OFS_CCK_PWR_TBL)); (unsigned char)(ii + EEP_OFS_CCK_PWR_TBL));
if (pDevice->abyCCKPwrTbl[ii + 1] == 0) if (priv->abyCCKPwrTbl[ii + 1] == 0)
pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr; priv->abyCCKPwrTbl[ii+1] = priv->byCCKPwr;
pDevice->abyOFDMPwrTbl[ii + 1] = priv->abyOFDMPwrTbl[ii + 1] =
SROMbyReadEmbedded(pDevice->PortOffset, SROMbyReadEmbedded(priv->PortOffset,
(unsigned char)(ii + EEP_OFS_OFDM_PWR_TBL)); (unsigned char)(ii + EEP_OFS_OFDM_PWR_TBL));
if (pDevice->abyOFDMPwrTbl[ii + 1] == 0) if (priv->abyOFDMPwrTbl[ii + 1] == 0)
pDevice->abyOFDMPwrTbl[ii + 1] = pDevice->byOFDMPwrG; priv->abyOFDMPwrTbl[ii + 1] = priv->byOFDMPwrG;
pDevice->abyCCKDefaultPwr[ii + 1] = byCCKPwrdBm; priv->abyCCKDefaultPwr[ii + 1] = byCCKPwrdBm;
pDevice->abyOFDMDefaultPwr[ii + 1] = byOFDMPwrdBm; priv->abyOFDMDefaultPwr[ii + 1] = byOFDMPwrdBm;
} }
/* recover 12,13 ,14channel for EUROPE by 11 channel */ /* recover 12,13 ,14channel for EUROPE by 11 channel */
for (ii = 11; ii < 14; ii++) { for (ii = 11; ii < 14; ii++) {
pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10]; priv->abyCCKPwrTbl[ii] = priv->abyCCKPwrTbl[10];
pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10]; priv->abyOFDMPwrTbl[ii] = priv->abyOFDMPwrTbl[10];
} }
/* Load OFDM A Power Table */ /* Load OFDM A Power Table */
for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) { for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
pDevice->abyOFDMPwrTbl[ii + CB_MAX_CHANNEL_24G + 1] = priv->abyOFDMPwrTbl[ii + CB_MAX_CHANNEL_24G + 1] =
SROMbyReadEmbedded(pDevice->PortOffset, SROMbyReadEmbedded(priv->PortOffset,
(unsigned char)(ii + EEP_OFS_OFDMA_PWR_TBL)); (unsigned char)(ii + EEP_OFS_OFDMA_PWR_TBL));
pDevice->abyOFDMDefaultPwr[ii + CB_MAX_CHANNEL_24G + 1] = priv->abyOFDMDefaultPwr[ii + CB_MAX_CHANNEL_24G + 1] =
SROMbyReadEmbedded(pDevice->PortOffset, SROMbyReadEmbedded(priv->PortOffset,
(unsigned char)(ii + EEP_OFS_OFDMA_PWR_dBm)); (unsigned char)(ii + EEP_OFS_OFDMA_PWR_dBm));
} }
if (pDevice->byLocalID > REV_ID_VT3253_B1) { if (priv->byLocalID > REV_ID_VT3253_B1) {
MACvSelectPage1(pDevice->PortOffset); MACvSelectPage1(priv->PortOffset);
VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, VNSvOutPortB(priv->PortOffset + MAC_REG_MSRCTL + 1,
(MSRCTL1_TXPWR | MSRCTL1_CSAPAREN)); (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN));
MACvSelectPage0(pDevice->PortOffset); MACvSelectPage0(priv->PortOffset);
} }
/* use relative tx timeout and 802.11i D4 */ /* use relative tx timeout and 802.11i D4 */
MACvWordRegBitsOn(pDevice->PortOffset, MACvWordRegBitsOn(priv->PortOffset,
MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT)); MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
/* set performance parameter by registry */ /* set performance parameter by registry */
MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit); MACvSetShortRetryLimit(priv->PortOffset, priv->byShortRetryLimit);
MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit); MACvSetLongRetryLimit(priv->PortOffset, priv->byLongRetryLimit);
/* reset TSF counter */ /* reset TSF counter */
VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST); VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
/* enable TSF counter */ /* enable TSF counter */
VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
/* initialize BBP registers */ /* initialize BBP registers */
BBbVT3253Init(pDevice); BBbVT3253Init(priv);
if (pDevice->bUpdateBBVGA) { if (priv->bUpdateBBVGA) {
pDevice->byBBVGACurrent = pDevice->abyBBVGA[0]; priv->byBBVGACurrent = priv->abyBBVGA[0];
pDevice->byBBVGANew = pDevice->byBBVGACurrent; priv->byBBVGANew = priv->byBBVGACurrent;
BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]); BBvSetVGAGainOffset(priv, priv->abyBBVGA[0]);
} }
BBvSetRxAntennaMode(pDevice, pDevice->byRxAntennaMode); BBvSetRxAntennaMode(priv, priv->byRxAntennaMode);
BBvSetTxAntennaMode(pDevice, pDevice->byTxAntennaMode); BBvSetTxAntennaMode(priv, priv->byTxAntennaMode);
/* Set BB and packet type at the same time. */ /* Set BB and packet type at the same time. */
/* Set Short Slot Time, xIFS, and RSPINF. */ /* Set Short Slot Time, xIFS, and RSPINF. */
pDevice->wCurrentRate = RATE_54M; priv->wCurrentRate = RATE_54M;
pDevice->bRadioOff = false; priv->bRadioOff = false;
pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, priv->byRadioCtl = SROMbyReadEmbedded(priv->PortOffset,
EEP_OFS_RADIOCTL); EEP_OFS_RADIOCTL);
pDevice->bHWRadioOff = false; priv->bHWRadioOff = false;
if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) { if (priv->byRadioCtl & EEP_RADIOCTL_ENABLE) {
/* Get GPIO */ /* Get GPIO */
MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO); MACvGPIOIn(priv->PortOffset, &priv->byGPIO);
if (((pDevice->byGPIO & GPIO0_DATA) && if (((priv->byGPIO & GPIO0_DATA) &&
!(pDevice->byRadioCtl & EEP_RADIOCTL_INV)) || !(priv->byRadioCtl & EEP_RADIOCTL_INV)) ||
(!(pDevice->byGPIO & GPIO0_DATA) && (!(priv->byGPIO & GPIO0_DATA) &&
(pDevice->byRadioCtl & EEP_RADIOCTL_INV))) (priv->byRadioCtl & EEP_RADIOCTL_INV)))
pDevice->bHWRadioOff = true; priv->bHWRadioOff = true;
} }
if (pDevice->bHWRadioOff || pDevice->bRadioControlOff) if (priv->bHWRadioOff || priv->bRadioControlOff)
CARDbRadioPowerOff(pDevice); CARDbRadioPowerOff(priv);
/* get Permanent network address */ /* get Permanent network address */
SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr); SROMvReadEtherAddress(priv->PortOffset, priv->abyCurrentNetAddr);
pr_debug("Network address = %pM\n", pDevice->abyCurrentNetAddr); pr_debug("Network address = %pM\n", priv->abyCurrentNetAddr);
/* reset Tx pointer */ /* reset Tx pointer */
CARDvSafeResetRx(pDevice); CARDvSafeResetRx(priv);
/* reset Rx pointer */ /* reset Rx pointer */
CARDvSafeResetTx(pDevice); CARDvSafeResetTx(priv);
if (pDevice->byLocalID <= REV_ID_VT3253_A1) if (priv->byLocalID <= REV_ID_VT3253_A1)
MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR); MACvRegBitsOn(priv->PortOffset, MAC_REG_RCR, RCR_WPAERR);
/* Turn On Rx DMA */ /* Turn On Rx DMA */
MACvReceive0(pDevice->PortOffset); MACvReceive0(priv->PortOffset);
MACvReceive1(pDevice->PortOffset); MACvReceive1(priv->PortOffset);
/* start the adapter */ /* start the adapter */
MACvStart(pDevice->PortOffset); MACvStart(priv->PortOffset);
} }
static void device_print_info(struct vnt_private *pDevice) static void device_print_info(struct vnt_private *priv)
{ {
dev_info(&pDevice->pcid->dev, "MAC=%pM IO=0x%lx Mem=0x%lx IRQ=%d\n", dev_info(&priv->pcid->dev, "MAC=%pM IO=0x%lx Mem=0x%lx IRQ=%d\n",
pDevice->abyCurrentNetAddr, (unsigned long)pDevice->ioaddr, priv->abyCurrentNetAddr, (unsigned long)priv->ioaddr,
(unsigned long)pDevice->PortOffset, pDevice->pcid->irq); (unsigned long)priv->PortOffset, priv->pcid->irq);
} }
static void device_free_info(struct vnt_private *pDevice) static void device_free_info(struct vnt_private *priv)
{ {
if (!pDevice) if (!priv)
return; return;
if (pDevice->mac_hw) if (priv->mac_hw)
ieee80211_unregister_hw(pDevice->hw); ieee80211_unregister_hw(priv->hw);
if (pDevice->PortOffset) if (priv->PortOffset)
iounmap(pDevice->PortOffset); iounmap(priv->PortOffset);
if (pDevice->pcid) if (priv->pcid)
pci_release_regions(pDevice->pcid); pci_release_regions(priv->pcid);
if (pDevice->hw) if (priv->hw)
ieee80211_free_hw(pDevice->hw); ieee80211_free_hw(priv->hw);
} }
static bool device_init_rings(struct vnt_private *pDevice) static bool device_init_rings(struct vnt_private *priv)
{ {
void *vir_pool; void *vir_pool;
/*allocate all RD/TD rings a single pool*/ /*allocate all RD/TD rings a single pool*/
vir_pool = dma_zalloc_coherent(&pDevice->pcid->dev, vir_pool = dma_zalloc_coherent(&priv->pcid->dev,
pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) + priv->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) +
pDevice->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc), priv->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc),
&pDevice->pool_dma, GFP_ATOMIC); &priv->pool_dma, GFP_ATOMIC);
if (vir_pool == NULL) { if (vir_pool == NULL) {
dev_err(&pDevice->pcid->dev, "allocate desc dma memory failed\n"); dev_err(&priv->pcid->dev, "allocate desc dma memory failed\n");
return false; return false;
} }
pDevice->aRD0Ring = vir_pool; priv->aRD0Ring = vir_pool;
pDevice->aRD1Ring = vir_pool + priv->aRD1Ring = vir_pool +
pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc); priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc);
pDevice->rd0_pool_dma = pDevice->pool_dma; priv->rd0_pool_dma = priv->pool_dma;
pDevice->rd1_pool_dma = pDevice->rd0_pool_dma + priv->rd1_pool_dma = priv->rd0_pool_dma +
pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc); priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc);
pDevice->tx0_bufs = dma_zalloc_coherent(&pDevice->pcid->dev, priv->tx0_bufs = dma_zalloc_coherent(&priv->pcid->dev,
pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + priv->sOpts.nTxDescs[0] * PKT_BUF_SZ +
pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + priv->sOpts.nTxDescs[1] * PKT_BUF_SZ +
CB_BEACON_BUF_SIZE + CB_BEACON_BUF_SIZE +
CB_MAX_BUF_SIZE, CB_MAX_BUF_SIZE,
&pDevice->tx_bufs_dma0, &priv->tx_bufs_dma0,
GFP_ATOMIC); GFP_ATOMIC);
if (pDevice->tx0_bufs == NULL) { if (priv->tx0_bufs == NULL) {
dev_err(&pDevice->pcid->dev, "allocate buf dma memory failed\n"); dev_err(&priv->pcid->dev, "allocate buf dma memory failed\n");
dma_free_coherent(&pDevice->pcid->dev, dma_free_coherent(&priv->pcid->dev,
pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) + priv->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) +
pDevice->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc), priv->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc),
vir_pool, pDevice->pool_dma vir_pool, priv->pool_dma);
);
return false; return false;
} }
pDevice->td0_pool_dma = pDevice->rd1_pool_dma + priv->td0_pool_dma = priv->rd1_pool_dma +
pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc); priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc);
pDevice->td1_pool_dma = pDevice->td0_pool_dma + priv->td1_pool_dma = priv->td0_pool_dma +
pDevice->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc); priv->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc);
/* vir_pool: pvoid type */ /* vir_pool: pvoid type */
pDevice->apTD0Rings = vir_pool priv->apTD0Rings = vir_pool
+ pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc)
+ pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc); + priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc);
pDevice->apTD1Rings = vir_pool priv->apTD1Rings = vir_pool
+ pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc)
+ pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc)
+ pDevice->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc); + priv->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc);
pDevice->tx1_bufs = pDevice->tx0_bufs + priv->tx1_bufs = priv->tx0_bufs +
pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; priv->sOpts.nTxDescs[0] * PKT_BUF_SZ;
pDevice->tx_beacon_bufs = pDevice->tx1_bufs + priv->tx_beacon_bufs = priv->tx1_bufs +
pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; priv->sOpts.nTxDescs[1] * PKT_BUF_SZ;
pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs + priv->pbyTmpBuff = priv->tx_beacon_bufs +
CB_BEACON_BUF_SIZE; CB_BEACON_BUF_SIZE;
pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 + priv->tx_bufs_dma1 = priv->tx_bufs_dma0 +
pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; priv->sOpts.nTxDescs[0] * PKT_BUF_SZ;
pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 + priv->tx_beacon_dma = priv->tx_bufs_dma1 +
pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; priv->sOpts.nTxDescs[1] * PKT_BUF_SZ;
return true; return true;
} }
static void device_free_rings(struct vnt_private *pDevice) static void device_free_rings(struct vnt_private *priv)
{ {
dma_free_coherent(&pDevice->pcid->dev, dma_free_coherent(&priv->pcid->dev,
pDevice->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs0 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) + priv->sOpts.nRxDescs1 * sizeof(struct vnt_rx_desc) +
pDevice->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) + priv->sOpts.nTxDescs[0] * sizeof(struct vnt_tx_desc) +
pDevice->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc) priv->sOpts.nTxDescs[1] * sizeof(struct vnt_tx_desc),
, priv->aRD0Ring, priv->pool_dma);
pDevice->aRD0Ring, pDevice->pool_dma
); if (priv->tx0_bufs)
dma_free_coherent(&priv->pcid->dev,
if (pDevice->tx0_bufs) priv->sOpts.nTxDescs[0] * PKT_BUF_SZ +
dma_free_coherent(&pDevice->pcid->dev, priv->sOpts.nTxDescs[1] * PKT_BUF_SZ +
pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + CB_BEACON_BUF_SIZE +
pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + CB_MAX_BUF_SIZE,
CB_BEACON_BUF_SIZE + priv->tx0_bufs, priv->tx_bufs_dma0);
CB_MAX_BUF_SIZE,
pDevice->tx0_bufs, pDevice->tx_bufs_dma0
);
} }
static void device_init_rd0_ring(struct vnt_private *pDevice) static void device_init_rd0_ring(struct vnt_private *priv)
{ {
int i; int i;
dma_addr_t curr = pDevice->rd0_pool_dma; dma_addr_t curr = priv->rd0_pool_dma;
struct vnt_rx_desc *pDesc; struct vnt_rx_desc *pDesc;
/* Init the RD0 ring entries */ /* Init the RD0 ring entries */
for (i = 0; i < pDevice->sOpts.nRxDescs0; for (i = 0; i < priv->sOpts.nRxDescs0;
i ++, curr += sizeof(struct vnt_rx_desc)) { i ++, curr += sizeof(struct vnt_rx_desc)) {
pDesc = &(pDevice->aRD0Ring[i]); pDesc = &(priv->aRD0Ring[i]);
pDesc->rd_info = alloc_rd_info(); pDesc->rd_info = alloc_rd_info();
if (!device_alloc_rx_buf(pDevice, pDesc)) if (!device_alloc_rx_buf(priv, pDesc))
dev_err(&pDevice->pcid->dev, "can not alloc rx bufs\n"); dev_err(&priv->pcid->dev, "can not alloc rx bufs\n");
pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]); pDesc->next = &(priv->aRD0Ring[(i+1) % priv->sOpts.nRxDescs0]);
pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_rx_desc)); pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_rx_desc));
} }
if (i > 0) if (i > 0)
pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma); priv->aRD0Ring[i-1].next_desc = cpu_to_le32(priv->rd0_pool_dma);
pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]); priv->pCurrRD[0] = &priv->aRD0Ring[0];
} }
static void device_init_rd1_ring(struct vnt_private *pDevice) static void device_init_rd1_ring(struct vnt_private *priv)
{ {
int i; int i;
dma_addr_t curr = pDevice->rd1_pool_dma; dma_addr_t curr = priv->rd1_pool_dma;
struct vnt_rx_desc *pDesc; struct vnt_rx_desc *pDesc;
/* Init the RD1 ring entries */ /* Init the RD1 ring entries */
for (i = 0; i < pDevice->sOpts.nRxDescs1; for (i = 0; i < priv->sOpts.nRxDescs1;
i ++, curr += sizeof(struct vnt_rx_desc)) { i ++, curr += sizeof(struct vnt_rx_desc)) {
pDesc = &(pDevice->aRD1Ring[i]); pDesc = &(priv->aRD1Ring[i]);
pDesc->rd_info = alloc_rd_info(); pDesc->rd_info = alloc_rd_info();
if (!device_alloc_rx_buf(pDevice, pDesc)) if (!device_alloc_rx_buf(priv, pDesc))
dev_err(&pDevice->pcid->dev, "can not alloc rx bufs\n"); dev_err(&priv->pcid->dev, "can not alloc rx bufs\n");
pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]); pDesc->next = &(priv->aRD1Ring[(i+1) % priv->sOpts.nRxDescs1]);
pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_rx_desc)); pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_rx_desc));
} }
if (i > 0) if (i > 0)
pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma); priv->aRD1Ring[i-1].next_desc = cpu_to_le32(priv->rd1_pool_dma);
pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]); priv->pCurrRD[1] = &priv->aRD1Ring[0];
} }
static void device_free_rd0_ring(struct vnt_private *pDevice) static void device_free_rd0_ring(struct vnt_private *priv)
{ {
int i; int i;
for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) { for (i = 0; i < priv->sOpts.nRxDescs0; i++) {
struct vnt_rx_desc *pDesc = &(pDevice->aRD0Ring[i]); struct vnt_rx_desc *pDesc = &(priv->aRD0Ring[i]);
struct vnt_rd_info *rd_info = pDesc->rd_info; struct vnt_rd_info *rd_info = pDesc->rd_info;
dma_unmap_single(&pDevice->pcid->dev, rd_info->skb_dma, dma_unmap_single(&priv->pcid->dev, rd_info->skb_dma,
pDevice->rx_buf_sz, DMA_FROM_DEVICE); priv->rx_buf_sz, DMA_FROM_DEVICE);
dev_kfree_skb(rd_info->skb); dev_kfree_skb(rd_info->skb);
...@@ -610,16 +606,16 @@ static void device_free_rd0_ring(struct vnt_private *pDevice) ...@@ -610,16 +606,16 @@ static void device_free_rd0_ring(struct vnt_private *pDevice)
} }
} }
static void device_free_rd1_ring(struct vnt_private *pDevice) static void device_free_rd1_ring(struct vnt_private *priv)
{ {
int i; int i;
for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) { for (i = 0; i < priv->sOpts.nRxDescs1; i++) {
struct vnt_rx_desc *pDesc = &(pDevice->aRD1Ring[i]); struct vnt_rx_desc *pDesc = &(priv->aRD1Ring[i]);
struct vnt_rd_info *rd_info = pDesc->rd_info; struct vnt_rd_info *rd_info = pDesc->rd_info;
dma_unmap_single(&pDevice->pcid->dev, rd_info->skb_dma, dma_unmap_single(&priv->pcid->dev, rd_info->skb_dma,
pDevice->rx_buf_sz, DMA_FROM_DEVICE); priv->rx_buf_sz, DMA_FROM_DEVICE);
dev_kfree_skb(rd_info->skb); dev_kfree_skb(rd_info->skb);
...@@ -627,61 +623,61 @@ static void device_free_rd1_ring(struct vnt_private *pDevice) ...@@ -627,61 +623,61 @@ static void device_free_rd1_ring(struct vnt_private *pDevice)
} }
} }
static void device_init_td0_ring(struct vnt_private *pDevice) static void device_init_td0_ring(struct vnt_private *priv)
{ {
int i; int i;
dma_addr_t curr; dma_addr_t curr;
struct vnt_tx_desc *pDesc; struct vnt_tx_desc *pDesc;
curr = pDevice->td0_pool_dma; curr = priv->td0_pool_dma;
for (i = 0; i < pDevice->sOpts.nTxDescs[0]; for (i = 0; i < priv->sOpts.nTxDescs[0];
i++, curr += sizeof(struct vnt_tx_desc)) { i++, curr += sizeof(struct vnt_tx_desc)) {
pDesc = &(pDevice->apTD0Rings[i]); pDesc = &(priv->apTD0Rings[i]);
pDesc->td_info = alloc_td_info(); pDesc->td_info = alloc_td_info();
pDesc->td_info->buf = pDevice->tx0_bufs + i * PKT_BUF_SZ; pDesc->td_info->buf = priv->tx0_bufs + i * PKT_BUF_SZ;
pDesc->td_info->buf_dma = pDevice->tx_bufs_dma0 + i * PKT_BUF_SZ; pDesc->td_info->buf_dma = priv->tx_bufs_dma0 + i * PKT_BUF_SZ;
pDesc->next = &(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]); pDesc->next = &(priv->apTD0Rings[(i+1) % priv->sOpts.nTxDescs[0]]);
pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_tx_desc)); pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_tx_desc));
} }
if (i > 0) if (i > 0)
pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma); priv->apTD0Rings[i-1].next_desc = cpu_to_le32(priv->td0_pool_dma);
pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]); priv->apTailTD[0] = priv->apCurrTD[0] = &priv->apTD0Rings[0];
} }
static void device_init_td1_ring(struct vnt_private *pDevice) static void device_init_td1_ring(struct vnt_private *priv)
{ {
int i; int i;
dma_addr_t curr; dma_addr_t curr;
struct vnt_tx_desc *pDesc; struct vnt_tx_desc *pDesc;
/* Init the TD ring entries */ /* Init the TD ring entries */
curr = pDevice->td1_pool_dma; curr = priv->td1_pool_dma;
for (i = 0; i < pDevice->sOpts.nTxDescs[1]; for (i = 0; i < priv->sOpts.nTxDescs[1];
i++, curr += sizeof(struct vnt_tx_desc)) { i++, curr += sizeof(struct vnt_tx_desc)) {
pDesc = &(pDevice->apTD1Rings[i]); pDesc = &(priv->apTD1Rings[i]);
pDesc->td_info = alloc_td_info(); pDesc->td_info = alloc_td_info();
pDesc->td_info->buf = pDevice->tx1_bufs + i * PKT_BUF_SZ; pDesc->td_info->buf = priv->tx1_bufs + i * PKT_BUF_SZ;
pDesc->td_info->buf_dma = pDevice->tx_bufs_dma1 + i * PKT_BUF_SZ; pDesc->td_info->buf_dma = priv->tx_bufs_dma1 + i * PKT_BUF_SZ;
pDesc->next = &(pDevice->apTD1Rings[(i + 1) % pDevice->sOpts.nTxDescs[1]]); pDesc->next = &(priv->apTD1Rings[(i + 1) % priv->sOpts.nTxDescs[1]]);
pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_tx_desc)); pDesc->next_desc = cpu_to_le32(curr + sizeof(struct vnt_tx_desc));
} }
if (i > 0) if (i > 0)
pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma); priv->apTD1Rings[i-1].next_desc = cpu_to_le32(priv->td1_pool_dma);
pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]); priv->apTailTD[1] = priv->apCurrTD[1] = &priv->apTD1Rings[0];
} }
static void device_free_td0_ring(struct vnt_private *pDevice) static void device_free_td0_ring(struct vnt_private *priv)
{ {
int i; int i;
for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) { for (i = 0; i < priv->sOpts.nTxDescs[0]; i++) {
struct vnt_tx_desc *pDesc = &pDevice->apTD0Rings[i]; struct vnt_tx_desc *pDesc = &priv->apTD0Rings[i];
struct vnt_td_info *pTDInfo = pDesc->td_info; struct vnt_td_info *pTDInfo = pDesc->td_info;
dev_kfree_skb(pTDInfo->skb); dev_kfree_skb(pTDInfo->skb);
...@@ -689,12 +685,12 @@ static void device_free_td0_ring(struct vnt_private *pDevice) ...@@ -689,12 +685,12 @@ static void device_free_td0_ring(struct vnt_private *pDevice)
} }
} }
static void device_free_td1_ring(struct vnt_private *pDevice) static void device_free_td1_ring(struct vnt_private *priv)
{ {
int i; int i;
for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) { for (i = 0; i < priv->sOpts.nTxDescs[1]; i++) {
struct vnt_tx_desc *pDesc = &pDevice->apTD1Rings[i]; struct vnt_tx_desc *pDesc = &priv->apTD1Rings[i];
struct vnt_td_info *pTDInfo = pDesc->td_info; struct vnt_td_info *pTDInfo = pDesc->td_info;
dev_kfree_skb(pTDInfo->skb); dev_kfree_skb(pTDInfo->skb);
...@@ -704,12 +700,12 @@ static void device_free_td1_ring(struct vnt_private *pDevice) ...@@ -704,12 +700,12 @@ static void device_free_td1_ring(struct vnt_private *pDevice)
/*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/
static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx) static int device_rx_srv(struct vnt_private *priv, unsigned int uIdx)
{ {
struct vnt_rx_desc *pRD; struct vnt_rx_desc *pRD;
int works = 0; int works = 0;
for (pRD = pDevice->pCurrRD[uIdx]; for (pRD = priv->pCurrRD[uIdx];
pRD->rd0.owner == OWNED_BY_HOST; pRD->rd0.owner == OWNED_BY_HOST;
pRD = pRD->next) { pRD = pRD->next) {
if (works++ > 15) if (works++ > 15)
...@@ -718,9 +714,9 @@ static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx) ...@@ -718,9 +714,9 @@ static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx)
if (!pRD->rd_info->skb) if (!pRD->rd_info->skb)
break; break;
if (vnt_receive_frame(pDevice, pRD)) { if (vnt_receive_frame(priv, pRD)) {
if (!device_alloc_rx_buf(pDevice, pRD)) { if (!device_alloc_rx_buf(priv, pRD)) {
dev_err(&pDevice->pcid->dev, dev_err(&priv->pcid->dev,
"can not allocate rx buf\n"); "can not allocate rx buf\n");
break; break;
} }
...@@ -728,30 +724,30 @@ static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx) ...@@ -728,30 +724,30 @@ static int device_rx_srv(struct vnt_private *pDevice, unsigned int uIdx)
pRD->rd0.owner = OWNED_BY_NIC; pRD->rd0.owner = OWNED_BY_NIC;
} }
pDevice->pCurrRD[uIdx] = pRD; priv->pCurrRD[uIdx] = pRD;
return works; return works;
} }
static bool device_alloc_rx_buf(struct vnt_private *pDevice, static bool device_alloc_rx_buf(struct vnt_private *priv,
struct vnt_rx_desc *pRD) struct vnt_rx_desc *pRD)
{ {
struct vnt_rd_info *pRDInfo = pRD->rd_info; struct vnt_rd_info *pRDInfo = pRD->rd_info;
pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); pRDInfo->skb = dev_alloc_skb((int)priv->rx_buf_sz);
if (pRDInfo->skb == NULL) if (pRDInfo->skb == NULL)
return false; return false;
pRDInfo->skb_dma = pRDInfo->skb_dma =
dma_map_single(&pDevice->pcid->dev, dma_map_single(&priv->pcid->dev,
skb_put(pRDInfo->skb, skb_tailroom(pRDInfo->skb)), skb_put(pRDInfo->skb, skb_tailroom(pRDInfo->skb)),
pDevice->rx_buf_sz, DMA_FROM_DEVICE); priv->rx_buf_sz, DMA_FROM_DEVICE);
*((unsigned int *)&pRD->rd0) = 0; /* FIX cast */ *((unsigned int *)&pRD->rd0) = 0; /* FIX cast */
pRD->rd0.res_count = cpu_to_le16(pDevice->rx_buf_sz); pRD->rd0.res_count = cpu_to_le16(priv->rx_buf_sz);
pRD->rd0.owner = OWNED_BY_NIC; pRD->rd0.owner = OWNED_BY_NIC;
pRD->rd1.req_count = cpu_to_le16(pDevice->rx_buf_sz); pRD->rd1.req_count = cpu_to_le16(priv->rx_buf_sz);
pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma); pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
return true; return true;
...@@ -833,14 +829,14 @@ static int vnt_int_report_rate(struct vnt_private *priv, ...@@ -833,14 +829,14 @@ static int vnt_int_report_rate(struct vnt_private *priv,
return 0; return 0;
} }
static int device_tx_srv(struct vnt_private *pDevice, unsigned int uIdx) static int device_tx_srv(struct vnt_private *priv, unsigned int uIdx)
{ {
struct vnt_tx_desc *pTD; struct vnt_tx_desc *pTD;
int works = 0; int works = 0;
unsigned char byTsr0; unsigned char byTsr0;
unsigned char byTsr1; unsigned char byTsr1;
for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] > 0; pTD = pTD->next) { for (pTD = priv->apTailTD[uIdx]; priv->iTDUsed[uIdx] > 0; pTD = pTD->next) {
if (pTD->td0.owner == OWNED_BY_NIC) if (pTD->td0.owner == OWNED_BY_NIC)
break; break;
if (works++ > 15) if (works++ > 15)
...@@ -871,36 +867,36 @@ static int device_tx_srv(struct vnt_private *pDevice, unsigned int uIdx) ...@@ -871,36 +867,36 @@ static int device_tx_srv(struct vnt_private *pDevice, unsigned int uIdx)
} }
} }
vnt_int_report_rate(pDevice, pTD->td_info, byTsr0, byTsr1); vnt_int_report_rate(priv, pTD->td_info, byTsr0, byTsr1);
device_free_tx_buf(pDevice, pTD); device_free_tx_buf(priv, pTD);
pDevice->iTDUsed[uIdx]--; priv->iTDUsed[uIdx]--;
} }
} }
pDevice->apTailTD[uIdx] = pTD; priv->apTailTD[uIdx] = pTD;
return works; return works;
} }
static void device_error(struct vnt_private *pDevice, unsigned short status) static void device_error(struct vnt_private *priv, unsigned short status)
{ {
if (status & ISR_FETALERR) { if (status & ISR_FETALERR) {
dev_err(&pDevice->pcid->dev, "Hardware fatal error\n"); dev_err(&priv->pcid->dev, "Hardware fatal error\n");
MACbShutdown(pDevice->PortOffset); MACbShutdown(priv->PortOffset);
return; return;
} }
} }
static void device_free_tx_buf(struct vnt_private *pDevice, static void device_free_tx_buf(struct vnt_private *priv,
struct vnt_tx_desc *pDesc) struct vnt_tx_desc *pDesc)
{ {
struct vnt_td_info *pTDInfo = pDesc->td_info; struct vnt_td_info *pTDInfo = pDesc->td_info;
struct sk_buff *skb = pTDInfo->skb; struct sk_buff *skb = pTDInfo->skb;
if (skb) if (skb)
ieee80211_tx_status_irqsafe(pDevice->hw, skb); ieee80211_tx_status_irqsafe(priv->hw, skb);
pTDInfo->skb = NULL; pTDInfo->skb = NULL;
pTDInfo->flags = 0; pTDInfo->flags = 0;
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或