BOOL PSbIsNextTBTTWakeUp(void *hDeviceContext) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = &(pDevice->sMgmtObj); BOOL bWakeUp = FALSE; if (pMgmt->wListenInterval >= 2) { if (pMgmt->wCountToWakeUp == 0) { pMgmt->wCountToWakeUp = pMgmt->wListenInterval; } pMgmt->wCountToWakeUp --; if (pMgmt->wCountToWakeUp == 1) { // Turn on wake up to listen next beacon MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); pDevice->bPSRxBeacon = FALSE; bWakeUp = TRUE; } else if ( !pDevice->bPSRxBeacon ) { //Listen until RxBeacon MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); } } return bWakeUp; }
static int vnt_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) { struct vnt_private *priv = hw->priv; priv->vif = vif; switch (vif->type) { case NL80211_IFTYPE_STATION: break; case NL80211_IFTYPE_ADHOC: MACvRegBitsOff(priv->PortOffset, MAC_REG_RCR, RCR_UNICAST); MACvRegBitsOn(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_ADHOC); break; case NL80211_IFTYPE_AP: MACvRegBitsOff(priv->PortOffset, MAC_REG_RCR, RCR_UNICAST); MACvRegBitsOn(priv->PortOffset, MAC_REG_HOSTCR, HOSTCR_AP); break; default: return -EOPNOTSUPP; } priv->op_mode = vif->type; return 0; }
void PSvEnablePowerSaving(void *hDeviceContext, WORD wListenInterval) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = &(pDevice->sMgmtObj); WORD wAID = pMgmt->wCurrAID | BIT14 | BIT15; // set period of power up before TBTT MACvWriteWord(pDevice, MAC_REG_PWBT, C_PWBT); if (pDevice->eOPMode != OP_MODE_ADHOC) { // set AID MACvWriteWord(pDevice, MAC_REG_AIDATIM, wAID); } else { // set ATIM Window //MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow); } //Warren:06-18-2004,the sequence must follow PSEN->AUTOSLEEP->GO2DOZE // enable power saving hw function MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_PSEN); // Set AutoSleep MACvRegBitsOn(pDevice, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); //Warren:MUST turn on this once before turn on AUTOSLEEP ,or the AUTOSLEEP doesn't work MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_GO2DOZE); if (wListenInterval >= 2) { // clear always listen beacon MACvRegBitsOff(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); // first time set listen next beacon MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); pMgmt->wCountToWakeUp = wListenInterval; } else { // always listen beacon MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); pMgmt->wCountToWakeUp = 0; } pDevice->bEnablePSMode = TRUE; if (pDevice->eOPMode == OP_MODE_ADHOC) { /* bMgrPrepareBeaconToSend((void *) pDevice, pMgmt); */ } // We don't send null pkt in ad hoc mode since beacon will handle this. else if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = TRUE; DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS:Power Saving Mode Enable... \n"); return; }
void PSvEnablePowerSaving(void *hDeviceContext, WORD wListenInterval) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = &(pDevice->sMgmtObj); WORD wAID = pMgmt->wCurrAID | BIT14 | BIT15; MACvWriteWord(pDevice, MAC_REG_PWBT, C_PWBT); if (pDevice->eOPMode != OP_MODE_ADHOC) { MACvWriteWord(pDevice, MAC_REG_AIDATIM, wAID); } else { } MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_PSEN); MACvRegBitsOn(pDevice, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_GO2DOZE); if (wListenInterval >= 2) { MACvRegBitsOff(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); pMgmt->wCountToWakeUp = wListenInterval; } else { MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); pMgmt->wCountToWakeUp = 0; } pDevice->bEnablePSMode = TRUE; if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) PSbSendNullPacket(pDevice); pDevice->bPWBitOn = TRUE; DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS:Power Saving Mode Enable...\n"); }
VOID PSvEnablePowerSaving( IN HANDLE hDeviceContext, IN WORD wListenInterval ) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = pDevice->pMgmt; WORD wAID = pMgmt->wCurrAID | BIT14 | BIT15; // set period of power up before TBTT VNSvOutPortW(pDevice->PortOffset + MAC_REG_PWBT, C_PWBT); if (pDevice->eOPMode != OP_MODE_ADHOC) { // set AID VNSvOutPortW(pDevice->PortOffset + MAC_REG_AIDATIM, wAID); } else { // set ATIM Window MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow); } // Set AutoSleep MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); // Set HWUTSF MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_HWUTSF); if (wListenInterval >= 2) { // clear always listen beacon MACvRegBitsOff(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); //pDevice->wCFG &= ~CFG_ALB; // first time set listen next beacon MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_LNBCN); pMgmt->wCountToWakeUp = wListenInterval; } else { // always listen beacon MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); //pDevice->wCFG |= CFG_ALB; pMgmt->wCountToWakeUp = 0; } // enable power saving hw function MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); pDevice->bEnablePSMode = TRUE; if (pDevice->eOPMode == OP_MODE_ADHOC) { // bMgrPrepareBeaconToSend((HANDLE)pDevice, pMgmt); } // We don't send null pkt in ad hoc mode since beacon will handle this. else if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = TRUE; DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS:Power Saving Mode Enable... \n"); return; }
VOID PSvEnablePowerSaving( IN HANDLE hDeviceContext, IN WORD wListenInterval ) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = pDevice->pMgmt; WORD wAID = pMgmt->wCurrAID | BIT14 | BIT15; VNSvOutPortW(pDevice->PortOffset + MAC_REG_PWBT, C_PWBT); if (pDevice->eOPMode != OP_MODE_ADHOC) { VNSvOutPortW(pDevice->PortOffset + MAC_REG_AIDATIM, wAID); } else { MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow); } MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); MACvRegBitsOn(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_HWUTSF); if (wListenInterval >= 2) { MACvRegBitsOff(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_LNBCN); pMgmt->wCountToWakeUp = wListenInterval; } else { MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); pMgmt->wCountToWakeUp = 0; } MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); pDevice->bEnablePSMode = TRUE; if (pDevice->eOPMode == OP_MODE_ADHOC) { } else if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = TRUE; DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS:Power Saving Mode Enable... \n"); return; }
BOOL PSbConsiderPowerDown( IN HANDLE hDeviceContext, IN BOOL bCheckRxDMA, IN BOOL bCheckCountToWakeUp ) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = pDevice->pMgmt; UINT uIdx; if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) return TRUE; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (pMgmt->bInTIMWake) return FALSE; } if (pDevice->bCmdRunning) return FALSE; MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); for (uIdx = 0; uIdx < TYPE_MAXTD; uIdx ++) { if (pDevice->iTDUsed[uIdx] != 0) return FALSE; } if (bCheckRxDMA && ((pDevice->dwIsr& ISR_RXDMA0) != 0) && ((pDevice->dwIsr & ISR_RXDMA1) != 0)){ return FALSE; }; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (bCheckCountToWakeUp && (pMgmt->wCountToWakeUp == 0 || pMgmt->wCountToWakeUp == 1)) { return FALSE; } } MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_GO2DOZE); DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Go to Doze ZZZZZZZZZZZZZZZ\n"); return TRUE; }
void PSvEnablePowerSaving(struct vnt_private *pDevice, u16 wListenInterval) { struct vnt_manager *pMgmt = &pDevice->vnt_mgmt; u16 wAID = pMgmt->wCurrAID | BIT14 | BIT15; /* set period of power up before TBTT */ MACvWriteWord(pDevice, MAC_REG_PWBT, C_PWBT); if (pDevice->eOPMode != OP_MODE_ADHOC) { /* set AID */ MACvWriteWord(pDevice, MAC_REG_AIDATIM, wAID); } else { /* set ATIM Window */ /* MACvWriteATIMW(pDevice->PortOffset, pMgmt->wCurrATIMWindow); */ } /* Warren:06-18-2004,the sequence must follow PSEN->AUTOSLEEP->GO2DOZE */ /* enable power saving hw function */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_PSEN); /* Set AutoSleep */ MACvRegBitsOn(pDevice, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); /* Warren:MUST turn on this once before turn on AUTOSLEEP ,or the AUTOSLEEP doesn't work */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_GO2DOZE); if (wListenInterval >= 2) { /* clear always listen beacon */ MACvRegBitsOff(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); /* first time set listen next beacon */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); pMgmt->wCountToWakeUp = wListenInterval; } else { /* always listen beacon */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); pMgmt->wCountToWakeUp = 0; } pDevice->bEnablePSMode = true; /* We don't send null pkt in ad hoc mode since beacon will handle this. */ if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) PSbSendNullPacket(pDevice); pDevice->bPWBitOn = true; DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "PS:Power Saving Mode Enable...\n"); }
int mac_send(volatile void *packet, int length) { int entry, dirty, tmp; /* use mac0 to send */ entry = sg_aAdapter->idxTxCurDesc; dirty = sg_aAdapter->idxTxdirtyDesc; #if MACDBG printf("enter mac_send\n"); #endif /* because of no interrupt, check TD status when sending begins */ /* 1.check TD's ownership */ if (sg_aAdapter->apTD[entry]->m_td0TD0.f1Owner == B_OWNED_BY_CHIP) { MACvRegBitsOn(sg_aAdapter->dwIoBase, (1 << 7), MAC_REG_TQWK); MACvTransmit(sg_aAdapter->dwIoBase); printf("TD overflow and let DMA send first\n"); #if MACDBG TD_RD_dump(); #endif return 1; } /* 2.clear current descriptor */ sg_aAdapter->apTD[entry]->m_td0TD0.byTSR0 = 0; sg_aAdapter->apTD[entry]->m_td0TD0.byTSR1 = 0; sg_aAdapter->apTD[entry]->m_td0TD0.f12VID = 0; sg_aAdapter->apTD[entry]->m_td0TD0.f4Prioity = 0; /* 3.prepare data:memcopy */ s_vSetupData_TD(sg_aAdapter, entry, length, packet); /* printf("init TD and data\n"); */ /* 4.jump to next TD */ tmp = (++sg_aAdapter->idxTxCurDesc); sg_aAdapter->idxTxCurDesc = tmp % sg_aAdapter->cbTD; #if MACDBG printf("jump to next TD=%d\n", sg_aAdapter->idxTxCurDesc); #endif /* 5.trigger TDMD1& enable queue */ MACvRegBitsOn(sg_aAdapter->dwIoBase, (1 << 7), MAC_REG_TQWK); MACvTransmit(sg_aAdapter->dwIoBase); #if MACDBG printf("data sent!\n", sg_aAdapter->idxTxCurDesc); #endif /* 6.error handling :checking TD if ABT, UND */ return 0; }
BOOL PSbConsiderPowerDown( IN HANDLE hDeviceContext, IN BOOL bCheckRxDMA, IN BOOL bCheckCountToWakeUp ) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = pDevice->pMgmt; UINT uIdx; // check if already in Doze mode if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) return TRUE; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { // check if in TIM wake period if (pMgmt->bInTIMWake) return FALSE; } // check scan state if (pDevice->bCmdRunning) return FALSE; // Froce PSEN on MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); // check if all TD are empty, for (uIdx = 0; uIdx < TYPE_MAXTD; uIdx ++) { if (pDevice->iTDUsed[uIdx] != 0) return FALSE; } // check if rx isr is clear if (bCheckRxDMA && ((pDevice->dwIsr& ISR_RXDMA0) != 0) && ((pDevice->dwIsr & ISR_RXDMA1) != 0)){ return FALSE; }; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (bCheckCountToWakeUp && (pMgmt->wCountToWakeUp == 0 || pMgmt->wCountToWakeUp == 1)) { return FALSE; } } // no Tx, no Rx isr, now go to Doze MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_GO2DOZE); DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Go to Doze ZZZZZZZZZZZZZZZ\n"); return TRUE; }
/** * set_channel() - Set NIC media channel * * @pDeviceHandler: The adapter to be set * @uConnectionChannel: Channel to be set * * Return Value: true if succeeded; false if failed. * */ bool set_channel(struct vnt_private *priv, struct ieee80211_channel *ch) { bool ret = true; if (priv->byCurrentCh == ch->hw_value) return ret; /* Set VGA to max sensitivity */ if (priv->bUpdateBBVGA && priv->byBBVGACurrent != priv->abyBBVGA[0]) { priv->byBBVGACurrent = priv->abyBBVGA[0]; BBvSetVGAGainOffset(priv, priv->byBBVGACurrent); } /* clear NAV */ MACvRegBitsOn(priv->PortOffset, MAC_REG_MACCR, MACCR_CLRNAV); /* TX_PE will reserve 3 us for MAX2829 A mode only, it is for better TX throughput */ if (priv->byRFType == RF_AIROHA7230) RFbAL7230SelectChannelPostProcess(priv, priv->byCurrentCh, ch->hw_value); priv->byCurrentCh = ch->hw_value; ret &= RFbSelectChannel(priv, priv->byRFType, ch->hw_value); /* Init Synthesizer Table */ if (priv->bEnablePSMode) RFvWriteWakeProgSyn(priv, priv->byRFType, ch->hw_value); BBvSoftwareReset(priv); if (priv->byLocalID > REV_ID_VT3253_B1) { unsigned long flags; spin_lock_irqsave(&priv->lock, flags); /* set HW default power register */ MACvSelectPage1(priv->PortOffset); RFbSetPower(priv, RATE_1M, priv->byCurrentCh); VNSvOutPortB(priv->PortOffset + MAC_REG_PWRCCK, priv->byCurPwr); RFbSetPower(priv, RATE_6M, priv->byCurrentCh); VNSvOutPortB(priv->PortOffset + MAC_REG_PWROFDM, priv->byCurPwr); MACvSelectPage0(priv->PortOffset); spin_unlock_irqrestore(&priv->lock, flags); } if (priv->byBBType == BB_TYPE_11B) RFbSetPower(priv, RATE_1M, priv->byCurrentCh); else RFbSetPower(priv, RATE_6M, priv->byCurrentCh); return ret; }
bool PSbIsNextTBTTWakeUp( struct vnt_private *priv ) { struct ieee80211_hw *hw = priv->hw; struct ieee80211_conf *conf = &hw->conf; bool wake_up = false; if (conf->listen_interval > 1) { if (!priv->wake_up_count) priv->wake_up_count = conf->listen_interval; --priv->wake_up_count; if (priv->wake_up_count == 1) { /* Turn on wake up to listen next beacon */ MACvRegBitsOn(priv->PortOffset, MAC_REG_PSCTL, PSCTL_LNBCN); wake_up = true; } } return wake_up; }
/* * Description: Write a Byte to BASEBAND, by embedded programming * * Parameters: * In: * dwIoBase - I/O base address * byBBAddr - address of register in Baseband * byData - data to write * Out: * none * * Return Value: true if succeeded; false if failed. * */ bool BBbWriteEmbedded(struct vnt_private *priv, unsigned char byBBAddr, unsigned char byData) { void __iomem *dwIoBase = priv->PortOffset; unsigned short ww; unsigned char byValue; /* BB reg offset */ VNSvOutPortB(dwIoBase + MAC_REG_BBREGADR, byBBAddr); /* set BB data */ VNSvOutPortB(dwIoBase + MAC_REG_BBREGDATA, byData); /* turn on BBREGCTL_REGW */ MACvRegBitsOn(dwIoBase, MAC_REG_BBREGCTL, BBREGCTL_REGW); /* W_MAX_TIMEOUT is the timeout period */ for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { VNSvInPortB(dwIoBase + MAC_REG_BBREGCTL, &byValue); if (byValue & BBREGCTL_DONE) break; } if (ww == W_MAX_TIMEOUT) { DBG_PORT80(0x31); pr_debug(" DBG_PORT80(0x31)\n"); return false; } return true; }
VOID GMACvGetVCAM(DWORD dwIoBase, BYTE byAddress, PWORD pwData) { BYTE byOrgCAMCR, byData; /* modify CAMCR to select CAM DATA regs */ VNSvInPortB(dwIoBase + MAC_REG_CAMCR, &byOrgCAMCR); byData = (BYTE)((byOrgCAMCR | CAMCR_PS1) & ~CAMCR_PS0); VNSvOutPortB(dwIoBase + MAC_REG_CAMCR, byData); /* enable/select VCAM */ VNSvOutPortB(dwIoBase + MAC_REG_CAMADDR, (BYTE)(CAMADDR_CAMEN | CAMADDR_VCAMSL | byAddress)); /* issue read command */ MACvRegBitsOn(dwIoBase, MAC_REG_CAMCR, CAMCR_CAMRD); /* Wait for CAMRD self clear */ while (TRUE) { if (GMACbIsRegBitsOff(dwIoBase, MAC_REG_CAMCR, CAMCR_CAMRD)) break; } /* read VID CAM data */ VNSvInPortW(dwIoBase + MAC_REG_CAM, pwData); /* disable CAMEN */ VNSvOutPortB(dwIoBase + MAC_REG_CAMADDR, 0); /* restore to original CAMCR */ VNSvOutPortB(dwIoBase + MAC_REG_CAMCR, byOrgCAMCR); }
VOID GMACvSetMCAM(DWORD dwIoBase, BYTE byAddress, PBYTE pbyData) { BYTE byOrgCAMCR, byData; /* DWORD dwData; */ /* modify CAMCR to select CAM DATA regs */ VNSvInPortB(dwIoBase + MAC_REG_CAMCR, &byOrgCAMCR); byData = (BYTE)((byOrgCAMCR | CAMCR_PS1) & ~CAMCR_PS0); VNSvOutPortB(dwIoBase + MAC_REG_CAMCR, byData); /* enable/select MCAM */ VNSvOutPortB(dwIoBase + MAC_REG_CAMADDR, (BYTE)(CAMADDR_CAMEN | byAddress)); /* set MCAM Data */ VNSvOutPortD(dwIoBase + MAC_REG_CAM, *(PDWORD)pbyData); /* VNSvInPortD(dwIoBase + MAC_REG_CAM, &dwData); */ VNSvOutPortW(dwIoBase + MAC_REG_CAM + 4, *(PWORD)(pbyData + 4)); /* VNSvInPortW(dwIoBase + MAC_REG_CAM + 4, (PWORD)(&dwData)); */ /* issue write command */ MACvRegBitsOn(dwIoBase, MAC_REG_CAMCR, CAMCR_CAMWR); /* Wait for CAMWR self clear */ while (TRUE) { if (GMACbIsRegBitsOff(dwIoBase, MAC_REG_CAMCR, CAMCR_CAMWR)) break; } /* disable CAMEN */ VNSvOutPortB(dwIoBase + MAC_REG_CAMADDR, 0); /* restore to original CAMCR */ VNSvOutPortB(dwIoBase + MAC_REG_CAMCR, byOrgCAMCR); }
VOID PSvDisablePowerSaving( IN HANDLE hDeviceContext ) { PSDevice pDevice = (PSDevice)hDeviceContext; // PSMgmtObject pMgmt = pDevice->pMgmt; // disable power saving hw function MACbPSWakeup(pDevice->PortOffset); //clear AutoSleep MACvRegBitsOff(pDevice->PortOffset, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); //clear HWUTSF MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_HWUTSF); // set always listen beacon MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); pDevice->bEnablePSMode = FALSE; if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = FALSE; return; }
void PSvDisablePowerSaving(void *hDeviceContext) { PSDevice pDevice = (PSDevice)hDeviceContext; // PSMgmtObject pMgmt = &(pDevice->sMgmtObj); // disable power saving hw function CONTROLnsRequestOut(pDevice, MESSAGE_TYPE_DISABLE_PS, 0, 0, 0, NULL ); //clear AutoSleep MACvRegBitsOff(pDevice, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); // set always listen beacon MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_ALBCN); pDevice->bEnablePSMode = FALSE; if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = FALSE; return; }
/* * Description: Auto Load EEPROM to MAC register * * Parameters: * In: * dwIoBase - I/O base address * Out: * none * * Return Value: TRUE if success; otherwise FALSE * */ BOOL SROMbAutoLoad (DWORD_PTR dwIoBase) { BYTE byWait; int ii; BYTE byOrg; VNSvInPortB(dwIoBase + MAC_REG_I2MCFG, &byOrg); // turn on hardware retry VNSvOutPortB(dwIoBase + MAC_REG_I2MCFG, (byOrg | I2MCFG_NORETRY)); MACvRegBitsOn(dwIoBase, MAC_REG_I2MCSR, I2MCSR_AUTOLD); // ii = Rom Address for (ii = 0; ii < EEP_MAX_CONTEXT_SIZE; ii++) { MACvTimer0MicroSDelay(dwIoBase, CB_EEPROM_READBYTE_WAIT); VNSvInPortB(dwIoBase + MAC_REG_I2MCSR, &byWait); if ( !(byWait & I2MCSR_AUTOLD)) break; } VNSvOutPortB(dwIoBase + MAC_REG_I2MCFG, byOrg); if (ii == EEP_MAX_CONTEXT_SIZE) return FALSE; return TRUE; }
VOID PSvDisablePowerSaving( IN HANDLE hDeviceContext ) { PSDevice pDevice = (PSDevice)hDeviceContext; MACbPSWakeup(pDevice->PortOffset); MACvRegBitsOff(pDevice->PortOffset, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); MACvRegBitsOff(pDevice->PortOffset, MAC_REG_TFTCTL, TFTCTL_HWUTSF); MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); pDevice->bEnablePSMode = FALSE; if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) { PSbSendNullPacket(pDevice); } pDevice->bPWBitOn = FALSE; return; }
/* * Description: Auto Load EEPROM to MAC register * * Parameters: * In: * dwIoBase - I/O base address * Out: * none * * Return Value: true if success; otherwise false * */ bool SROMbAutoLoad(unsigned long dwIoBase) { unsigned char byWait; int ii; unsigned char byOrg; VNSvInPortB(dwIoBase + MAC_REG_I2MCFG, &byOrg); /* turn on hardware retry */ VNSvOutPortB(dwIoBase + MAC_REG_I2MCFG, (byOrg | I2MCFG_NORETRY)); MACvRegBitsOn(dwIoBase, MAC_REG_I2MCSR, I2MCSR_AUTOLD); /* ii = Rom Address */ for (ii = 0; ii < EEP_MAX_CONTEXT_SIZE; ii++) { MACvTimer0MicroSDelay(dwIoBase, CB_EEPROM_READBYTE_WAIT); VNSvInPortB(dwIoBase + MAC_REG_I2MCSR, &byWait); if ( !(byWait & I2MCSR_AUTOLD)) break; } VNSvOutPortB(dwIoBase + MAC_REG_I2MCFG, byOrg); if (ii == EEP_MAX_CONTEXT_SIZE) return false; return true; }
BOOL PSbIsNextTBTTWakeUp( IN HANDLE hDeviceContext ) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = pDevice->pMgmt; BOOL bWakeUp = FALSE; if (pMgmt->wListenInterval >= 2) { if (pMgmt->wCountToWakeUp == 0) { pMgmt->wCountToWakeUp = pMgmt->wListenInterval; } pMgmt->wCountToWakeUp --; if (pMgmt->wCountToWakeUp == 1) { MACvRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_LNBCN); bWakeUp = TRUE; } } return bWakeUp; }
BOOL PSbConsiderPowerDown(void *hDeviceContext, BOOL bCheckRxDMA, BOOL bCheckCountToWakeUp) { PSDevice pDevice = (PSDevice)hDeviceContext; PSMgmtObject pMgmt = &(pDevice->sMgmtObj); BYTE byData; ControlvReadByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_PSCTL, &byData); if ((byData & PSCTL_PS) != 0) return TRUE; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (pMgmt->bInTIMWake) return FALSE; } if (pDevice->bCmdRunning) return FALSE; if (pDevice->bPSModeTxBurst) return FALSE; MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_PSEN); if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (bCheckCountToWakeUp && (pMgmt->wCountToWakeUp == 0 || pMgmt->wCountToWakeUp == 1)) { return FALSE; } } pDevice->bPSRxBeacon = TRUE; MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_GO2DOZE); DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Go to Doze ZZZZZZZZZZZZZZZ\n"); return TRUE; }
int PSbConsiderPowerDown(struct vnt_private *pDevice, int bCheckRxDMA, int bCheckCountToWakeUp) { struct vnt_manager *pMgmt = &pDevice->vnt_mgmt; u8 byData; /* check if already in Doze mode */ ControlvReadByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_PSCTL, &byData); if ((byData & PSCTL_PS) != 0) return true; if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { /* check if in TIM wake period */ if (pMgmt->bInTIMWake) return false; } /* check scan state */ if (pDevice->bCmdRunning) return false; /* Tx Burst */ if (pDevice->bPSModeTxBurst) return false; /* Froce PSEN on */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_PSEN); if (pMgmt->eCurrMode != WMAC_MODE_IBSS_STA) { if (bCheckCountToWakeUp && (pMgmt->wCountToWakeUp == 0 || pMgmt->wCountToWakeUp == 1)) { return false; } } pDevice->bPSRxBeacon = true; /* no Tx, no Rx isr, now go to Doze */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_GO2DOZE); DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Go to Doze ZZZZZZZZZZZZZZZ\n"); return true; }
BOOL GMACbSoftwareReset(DWORD dwIoBase, BYTE byRevId) { WORD ww; /* turn on CR1_SFRST */ MACvRegBitsOn(dwIoBase, MAC_REG_CR1_SET, CR1_SFRST); /* polling till software reset complete */ /* W_MAX_TIMEOUT is the timeout period */ for (ww = 0; ww < W_MAX_TIMEOUT; ww++) { if (GMACbIsRegBitsOff(dwIoBase, MAC_REG_CR1_SET, (BYTE)CR1_SFRST)) break; } if (ww == W_MAX_TIMEOUT) { /* turn on force reset */ MACvRegBitsOn(dwIoBase, MAC_REG_CR3_SET, CR3_FORSRST); /* delay 2ms */ GMACvTimer0MiniSDelay(dwIoBase, byRevId, 2); } return TRUE; }
void PSvEnablePowerSaving(struct vnt_private *priv, unsigned short wListenInterval) { u16 wAID = priv->current_aid | BIT(14) | BIT(15); /* set period of power up before TBTT */ VNSvOutPortW(priv->PortOffset + MAC_REG_PWBT, C_PWBT); if (priv->op_mode != NL80211_IFTYPE_ADHOC) { /* set AID */ VNSvOutPortW(priv->PortOffset + MAC_REG_AIDATIM, wAID); } else { /* set ATIM Window */ #if 0 /* TODO atim window */ MACvWriteATIMW(priv->PortOffset, pMgmt->wCurrATIMWindow); #endif } /* Set AutoSleep */ MACvRegBitsOn(priv->PortOffset, MAC_REG_PSCFG, PSCFG_AUTOSLEEP); /* Set HWUTSF */ MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL, TFTCTL_HWUTSF); if (wListenInterval >= 2) { /* clear always listen beacon */ MACvRegBitsOff(priv->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); /* first time set listen next beacon */ MACvRegBitsOn(priv->PortOffset, MAC_REG_PSCTL, PSCTL_LNBCN); } else { /* always listen beacon */ MACvRegBitsOn(priv->PortOffset, MAC_REG_PSCTL, PSCTL_ALBCN); } /* enable power saving hw function */ MACvRegBitsOn(priv->PortOffset, MAC_REG_PSCTL, PSCTL_PSEN); priv->bEnablePSMode = true; priv->bPWBitOn = true; pr_debug("PS:Power Saving Mode Enable...\n"); }
static void vAdHocBeaconRestart(PSDevice pDevice) { PSMgmtObject pMgmt = &(pDevice->sMgmtObj); if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && (pMgmt->eCurrState >= WMAC_STATE_STARTED)) { MACvRegBitsOn(pDevice, MAC_REG_TCR, TCR_AUTOBCNTX); } }
int PSbIsNextTBTTWakeUp(struct vnt_private *pDevice) { struct vnt_manager *pMgmt = &pDevice->vnt_mgmt; int bWakeUp = false; if (pMgmt->wListenInterval >= 2) { if (pMgmt->wCountToWakeUp == 0) pMgmt->wCountToWakeUp = pMgmt->wListenInterval; pMgmt->wCountToWakeUp--; if (pMgmt->wCountToWakeUp == 1) { /* Turn on wake up to listen next beacon */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); pDevice->bPSRxBeacon = false; bWakeUp = true; } else if (!pDevice->bPSRxBeacon) { /* Listen until RxBeacon */ MACvRegBitsOn(pDevice, MAC_REG_PSCTL, PSCTL_LNBCN); } } return bWakeUp; }
VOID GMACvTimer0MicroSDelay(DWORD dwIoBase, BYTE byRevId, UINT udelay) { BYTE byData; /* Notice!!! */ /* Disable Timer0 Interrupt */ MACvRegBitsOff(dwIoBase, MAC_REG_IMR + 2, (BYTE)(ISR_TMR0I >> 16)); /* Set resolution to micro second */ MACvRegBitsOn(dwIoBase, MAC_REG_CHIPGCR, CHIPGCR_TM0US); /* set delay time to udelay, unit is micro-second */ VNSvOutPortW(dwIoBase + MAC_REG_SOFT_TIMER0, (WORD)udelay); /* enable timer0 */ VNSvOutPortB(dwIoBase + MAC_REG_CR1_SET, CR1_TM0EN); /* wait for TM0EN self clear */ while (TRUE) { /* Method 1 -> OK, and safe */ if (GMACbIsRegBitsOff(dwIoBase, MAC_REG_CR1_SET, CR1_TM0EN)) { /* clear TMR0I */ VNSvInPortB(dwIoBase + MAC_REG_ISR + 2, &byData); VNSvOutPortB(dwIoBase + MAC_REG_ISR + 2, byData); break; } /* // Method 2 -> OK, but not safe VNSvInPortB(dwIoBase + MAC_REG_ISR + 2, &byData); if (BITbIsBitOn(byData, (BYTE)(ISR_TMR0I >> 16))) { VNSvOutPortB(dwIoBase + MAC_REG_ISR + 2, byData); break; } */ /* // Method 3 -> OK, but not safe if (MACbIsRegBitsOn(dwIoBase, MAC_REG_ISR + 2, (BYTE)(ISR_TMR0I >> 16))) { // clear TMR0I VNSvOutPortB(dwIoBase + MAC_REG_ISR + 2, (BYTE)(ISR_TMR0I >> 16)); break; } */ } /* Notice !!! */ /* Enable Timer0 Interrupt */ MACvRegBitsOn(dwIoBase, MAC_REG_IMR + 2, (BYTE)(ISR_TMR0I >> 16)); }
/* * Description: Sync. TSF counter to BSS * Get TSF offset and write to HW * * Parameters: * In: * priv - The adapter to be sync. * byRxRate - data rate of receive beacon * qwBSSTimestamp - Rx BCN's TSF * qwLocalTSF - Local TSF * Out: * none * * Return Value: none */ bool CARDbUpdateTSF(struct vnt_private *priv, unsigned char byRxRate, u64 qwBSSTimestamp) { u64 local_tsf; u64 qwTSFOffset = 0; CARDbGetCurrentTSF(priv, &local_tsf); if (qwBSSTimestamp != local_tsf) { qwTSFOffset = CARDqGetTSFOffset(byRxRate, qwBSSTimestamp, local_tsf); /* adjust TSF, HW's TSF add TSF Offset reg */ VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST, (u32)qwTSFOffset); VNSvOutPortD(priv->PortOffset + MAC_REG_TSFOFST + 4, (u32)(qwTSFOffset >> 32)); MACvRegBitsOn(priv->PortOffset, MAC_REG_TFTCTL, TFTCTL_TSFSYNCEN); }
/* * Description: * Restart AdHoc beacon after scan process complete * * Parameters: * In: * pDevice - Pointer to the adapter * Out: * none * * Return Value: none * */ static void vAdHocBeaconRestart(struct vnt_private *pDevice) { struct vnt_manager *pMgmt = &pDevice->vnt_mgmt; /* * Restart Beacon packet for AdHoc Server * if all of the following coditions are met: * (1) STA is in AdHoc mode * (2) VT3253 is programmed as automatic Beacon Transmitting */ if ((pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) && (pMgmt->eCurrState >= WMAC_STATE_STARTED)) { //PMESG(("RESTART_BEACON\n")); MACvRegBitsOn(pDevice, MAC_REG_TCR, TCR_AUTOBCNTX); } }