// Calc DC for complex numbers in 4 SignalBlocks, divided by 4 SORA_EXTERN_C HRESULT BB11BGetAccurateDCOffset( IN PSORA_RADIO_RX_STREAM pRxStream, OUT vcs & dcOffset, OUT ULONG * pDescCount, OUT FLAG * touched) { int dcReSum = 0, dcImSum = 0; HRESULT hr = S_OK; ULONG count; SignalBlock block; for (count = 0; count < 4; count++) { hr = SoraRadioReadRxStream(pRxStream, touched, block); FAILED_BREAK(hr); dcOffset = SoraCalcDC(block); dcReSum += dcOffset[0].re; dcImSum += dcOffset[0].im; } *pDescCount += count; dcOffset[0].re = (short)(dcReSum >> 2); dcOffset[0].im = (short)(dcImSum >> 2); set_all(dcOffset, dcOffset[0]); return hr; }
void Dot11ATxApp(const Config& config) { SampleBufferSize = _M(2); SampleBuffer = SoraUAllocBuffer(SampleBufferSize); printf("tx buffer: %08x\n", SampleBuffer); printf("tx buffer size: %08x\n", SampleBufferSize); if (SampleBuffer == NULL) return; PreparePacket(config, (PVOID)SampleBuffer, (ULONG)SampleBufferSize); HRESULT hr; do { //Generate Signal hr = BB11ATxFrameMod(&TxVector, &Packet); printf("GenSignal return %08x\n", hr); printf("Signal bytes = %d\n", Packet.Reserved3); /*{ PCOMPLEX8 pSampleBuffer = (PCOMPLEX8)SampleBuffer; for (i = 0; i < Packet.Reserved3; i++) printf("(%5d, %5d)\t", pSampleBuffer[i].re, pSampleBuffer[i].im); printf("\n"); }*/ hr = SoraURadioTransferEx(TARGET_RADIO, SampleBuffer, Packet.Reserved3, &TxID); printf("transfer, hr=%08x, id=%d\n", hr, TxID); FAILED_BREAK(hr); Monitor monitor; TxContext ctx(config, monitor); HANDLE hTxThread = AllocStartThread(DoDot11ATx, &ctx); if (SUCCEEDED(hr) && hTxThread) { printf("\n\nPress any key to exit the program\n"); time_t start = time(NULL); while(!_kbhit()) { if (config.Interval() != 0 && difftime(time(NULL), start) >= config.Interval()) break; } StopFreeThread(hTxThread); hr = SoraURadioTxFree(TARGET_RADIO, TxID); printf("tx free return %08x\n", hr); } } while (FALSE); SoraUReleaseBuffer((PVOID)SampleBuffer); printf("unmap tx buffer ret: %08x\n", hr); printf("Tx out.\n"); }
HRESULT RXInterruptTransfer(PMP_ADAPTER Adapter) { HRESULT hr; PSORA_RADIO pRadio = &Adapter->RadioManager.__radio_pool[0]; ULONG SampleSize; PRCB_MD pTxRCBMem; DbgPrint("[MIX] Get symbol from file, size = %08x \n", SampleSize); do { hr = SoraPacketGetTxResource(pRadio, &g_Packet); FAILED_BREAK(hr); SampleSize = __FillWithDefaultValue(g_Packet.pTxDesc->pSampleBuffer, MODULATE_BUFFER_SIZE); SoraPacketSetPhyFrameSize(&g_Packet, SampleSize); if (g_Packet.pTxDesc->FrameSize & RCB_BUFFER_ALIGN_MASK) { hr = E_INVALID_SIGNAL_SIZE; break; } pTxRCBMem = SoraAllocateRCBMem(pRadio->pTxResMgr, pPacket->pTxDesc->FrameSize); if (pTxRCBMem) { pPacket->pTxDesc->__RCBDestAddr = pTxRCBMem->Start; pPacket->pTxDesc->pRMD = pTxRCBMem; if (SUCCEEDED(hr)) { pPacket->pTxDesc->pSampleBuffer = NULL; pPacket->pTxDesc->SampleBufferSize = 0; InterlockedExchange(&pPacket->fStatus, PACKET_CAN_TX); } else { //release ULCB TX memory SoraFreeRCBMem(pRadio->pTxResMgr, pPacket->pTxDesc->pRMD); pPacket->pTxDesc->__RCBDestAddr = 0xcdcdcdcd; pPacket->pTxDesc->pRMD = NULL; InterlockedExchange(&pPacket->fStatus, PACKET_TF_FAIL); } } } }while(FALSE); return hr; }
HRESULT SORAAPI SoraHwHeavyRestart(PSORA_RADIO pRadio) { HRESULT hRes; KIRQL OldIrql; do { KeAcquireSpinLock(&pRadio->__HWOpLock, &OldIrql); WRITE_REGISTER_ULONG( (PULONG)(&((__PSORA_REGISTERS)pRadio->__ctrl_reg.pSoraSysRegs)->HWControl), 0x00); hRes = __SoraHwResetSysRegsUnsafe((__PSORA_REGISTERS)pRadio->__ctrl_reg.pSoraSysRegs); KeReleaseSpinLock(&pRadio->__HWOpLock, OldIrql); FAILED_BREAK(hRes); hRes = SoraRadioStart( pRadio, pRadio->__uRxGain, pRadio->__uTxGain, NULL); FAILED_BREAK(hRes); } while(FALSE); return hRes; }
/*++ __SoraHwResetRCBRegsUnsafe set Radio Control board's registers to default value. --*/ HRESULT __SoraHwResetRCBRegsUnsafe( IN SORA_REGS_HANDLE pRegisterManager) { HRESULT hRes = S_OK; do { hRes = __ConfigRegistersUnsafe( (__PHW_REGISTER_FILE)pRegisterManager, __gc_RadioRegDefaultValue, //TBD: move it to const static data section. sizeof(__gc_RadioRegDefaultValue) / sizeof(__REG_CONFIGURATION_ENTRY)); FAILED_BREAK(hRes); }while(FALSE); return hRes; }
void Dot11BTxApp(const Config& config) { HRESULT hr; if (Dot11BTxInit() < 0) return; Dot11BPreparePacket(config, (PVOID)SampleBuffer, (ULONG)SampleBufferSize); do { // Generate Signal hr = BB11BPMDPacketGenSignal(&Packet, &TxVector, (PUCHAR)TempBuffer, TempBufferSize); printf("[dot11b:tx] GenSignal return %08x\n", hr); printf("[dot11b:tx] Signal bytes=%d\n", Packet.Reserved3); hr = SoraURadioTransferEx(TARGET_RADIO, SampleBuffer, Packet.Reserved3, &TxID); printf("[dot11b:tx] transfer, hr=%08x, id=%d\n", hr, TxID); FAILED_BREAK(hr); Monitor monitor; TxContext ctx(config, monitor); HANDLE hTxThread = AllocStartThread(DoDot11BTx, &ctx); if (SUCCEEDED(hr)) { printf("\n\nPress any key to exit the program\n"); time_t start = time(NULL); while(!_kbhit()) { if (config.Interval() != 0 && difftime(time(NULL), start) >= config.Interval()) break; } StopFreeThread(hTxThread); hr = SoraURadioTxFree(TARGET_RADIO, TxID); printf("[dot11b:tx] tx free return %08x\n", hr); } } while(false); Dot11BTxClean(); printf("[dot11b:tx] Tx out.\n"); }
HRESULT DutStartRadio(PSORA_RADIO Radio) { HRESULT hr; do { hr = SoraRadioStart( Radio, SORA_RADIO_DEFAULT_RX_GAIN, SORA_RADIO_DEFAULT_TX_GAIN, NULL); FAILED_BREAK(hr); SoraHwSetTXVGA1(Radio, SORA_RADIO_DEFAULT_TX_GAIN); SoraHwSetRXVGA1(Radio, SORA_RADIO_DEFAULT_RX_GAIN); SoraHwSetCentralFreq(Radio, HWT_DEFAULT_CENTRAL_FREQ, 0); SORA_HW_ENABLE_RX(Radio); } while(FALSE); return hr; }
/*++ BB11BSpd is a simple implementation of software power detection. Return: E_FETCH_SIGNAL_HW_TIMEOUT, E_FETCH_SIGNAL_FORCE_STOPPED, BB11B_E_PD_LAG, BB11B_CHANNEL_CLEAN, BB11B_OK_POWER_DETECTED --*/ HRESULT BB11BSpd(PBB11B_SPD_CONTEXT pSpdContext, PSORA_RADIO_RX_STREAM pRxStream) { // Alias FLAG *b_workIndicator = pSpdContext->b_workIndicator; // pointer to flag, 0 for force stop, 1 for work vcs& DcOffset = (vcs&)pSpdContext->dcOffset; vui& BlockEnergySum = (vui&)pSpdContext->BlockEnergySum; FLAG touched; ULONG PeekBlockCount = 0; HRESULT hr = S_OK; int energyLevel; if (pSpdContext->b_resetFlag) { //DbgPrint("[TEMP1] reset\n"); BB11BSpdResetHistory(pSpdContext); } SignalBlock block; do { if (pSpdContext->b_reestimateOffset) { hr = BB11BGetAccurateDCOffset( pRxStream, DcOffset, &PeekBlockCount, &touched); FAILED_BREAK(hr); pSpdContext->b_reestimateOffset = 0; } while (TRUE) { hr = SoraRadioReadRxStream(pRxStream, &touched, block); FAILED_BREAK(hr); // Check whether force stopped if (*b_workIndicator == 0) { hr = BB11B_E_FORCE_STOP; break; } // Estimate and update DC offset SoraUpdateDC(block, DcOffset); RemoveDC(block, DcOffset); BlockEnergySum = SoraGetNorm(block); PeekBlockCount++; energyLevel = BB11BSpdUpdateEngeryHistoryAndCheckThreshold( pSpdContext, pSpdContext->b_threshold, pSpdContext->b_gainLevel ? pSpdContext->b_thresholdHL : pSpdContext->b_thresholdLH ); if (energyLevel != EL_NOISE) { if (pSpdContext->b_gainLevel == 0 && energyLevel == EL_HIGH) pSpdContext->b_gainLevelNext = 1; else if (pSpdContext->b_gainLevel == 1 && energyLevel == EL_LOW) pSpdContext->b_gainLevelNext = 0; pSpdContext->b_evalEnergy = BlockEnergySum[0]; hr = BB11B_OK_POWER_DETECTED; break; } if (touched && PeekBlockCount > pSpdContext->b_minDescCount) { hr = BB11B_CHANNEL_CLEAN; break; } if (PeekBlockCount >= pSpdContext->b_maxDescCount) { hr = BB11B_E_PD_LAG; break; } } } while(FALSE); pSpdContext->b_dcOffset = DcOffset[0]; return hr; }