// 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;
}
