?? hamaro_pwrscan.c
字號:
/* hamaro_pwrscan.c */
/*+++ *******************************************************************\
*
* Abstract:
*
* Hamaro Power Scan FSM implementation.
*
* Created: 12/15/2005
*
*
* Copyright and Disclaimer:
*
* ---------------------------------------------------------------
* This software is provided "AS IS" without warranty of any kind,
* either expressed or implied, including but not limited to the
* implied warranties of noninfringement, merchantability and/or
* fitness for a particular purpose.
* ---------------------------------------------------------------
*
* Author: Amar Puttur
*
* Module Revision Id:
*
* $Header:hamaro_pwrscan.c, 1, 12/15/2005 1:43:00 PM, Amar Puttur$
*
* Copyright (c) 2005, 2006 Conexant Systems, Inc.
* All rights reserved.
*
\******************************************************************* ---*/
#include <stdlib.h> /* ANSI Standard */
#include <time.h>
#include "hamaro_sts.h"
#if HAMARO_SCAN_THE_SKY
#include "hamaro_pwrscan.h"
#include "hamaro_fsm.h"
#include "kal.h"
#define PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE 0
#define STS_ENABLE_VERBOSE_LOG 0
#if PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE
#include <stdio.h>
#endif /* PWRSCAN_USE_EXTERNAL_POWER_SPECTRUM_FILE */
#if HAMARO_WIN_DEBUG
#define STSDBG_WR_INT_LN(str, val) (WINDBG_WriteIntegerLn((char*)(str), val))
#define STSDBG_WR_INT(str, val) (WINDBG_WriteInteger((char*)(str), val))
#define STSDBG_WR_HEX(str, val) (WINDBG_WriteHex((char*)(str), val))
#define STSDBG_WR_UNSIGNED_LN(str, val) (WINDBG_WriteUnsignedLn((char*)(str), val))
#define STSDBG_WR_UNSIGNED(str, val) (WINDBG_WriteUnsigned((char*)(str), val))
#define STSDBG_WR_STR(str, nl) (WINDBG_WriteString((char*)(str), nl))
#define STSDBG_WR_ELAPSED_TIME() (WINDBG_FileWriteDuration())
#define STSDBG_START_TIMER() (WINDBG_SetTimer()) /* used for time measurements */
#else // HAMARO_WIN_DEBUG
#define STSDBG_WR_INT_LN(str, val) /* Expands to nothing */
#define STSDBG_WR_INT(str, val) /* Expands to nothing */
#define STSDBG_WR_UNSIGNED_LN(str, val) /* Expands to nothing */
#define STSDBG_WR_UNSIGNED(str, val) /* Expands to nothing */
#define STSDBG_WR_STR(str, nl) /* Expands to nothing */
#define STSDBG_WR_ELAPSED_TIME() /* Expands to nothing */
#define STSDBG_START_TIMER() /* Expands to nothing */
#endif /* HAMARO_WIN_DEBUG */
extern unsigned long sts_fsm_coding;
FSM pwr_scan_fsm = {&sts_fsm_coding, 0xF0000000, 0, 0, 0, 0};
extern void STS_ParsePowerDataInMainBuffer();
extern void STS_CheckCandidateWithStitcheddata();
static HAMARO_PWRSCAN_DATA s_power_scan_data;
static unsigned short* p_power_reading = 0;
static unsigned long* p_freq_reading = 0;
static signed char* p_agcacc = 0;
static unsigned short* p_filled_buffer_length = 0;
static unsigned short* p_max_pwr_reading = 0;
//extern HAMARO_STS_POWER_SPECTRUM_DATA s_power_spectrum_data;
//extern HAMARO_STS_POWER_SPECTRUM_DATA *s_power_spectrum_data_base;
#define s_power_spectrum_data_base HWBUF_DEC_BUF0_ADDR
#define s_power_spectrum_data (*(HAMARO_STS_POWER_SPECTRUM_DATA *)s_power_spectrum_data_base)
/* static */ HAMARO_PWRSCAN_BUFFER_INFO s_pwrscan_buffer_info[STS_MAX_NUM_OF_SCAN_SEGMENTS];
static unsigned short s_buffer_info_index;
static unsigned short s_scaled_max_power_reading = 0;
static BOOL s_aagc_filter = True;
static BOOL s_continue_scan = False;
static BOOL s_stop = False;
static long fsample = PWRSCAN_SAMPLE_RATE;
/*****************************************************************************/
/* POWER SCAN FSM */
/*****************************************************************************/
/* Function prototypes */
/* Power scan: Reset state */
static void PWRSCAN_ResetEnter();
static BOOL PWRSCAN_Reset2TuneCriterion();
static STATE* PWRSCAN_Reset2Tune();
static BOOL PWRSCAN_Reset2AbortCriterion();
static STATE* PWRSCAN_Reset2Abort();
/* Power scan: Tune state */
static void PWRSCAN_TuneEnter();
static BOOL PWRSCAN_Tune2StartCriterion();
static STATE* PWRSCAN_Tune2Start();
static BOOL PWRSCAN_Tune2AbortCriterion();
static STATE* PWRSCAN_Tune2Abort();
/* Power scan: Start state */
static void PWRSCAN_StartEnter();
static BOOL PWRSCAN_Start2StepCriterion();
static STATE* PWRSCAN_Start2Step();
static BOOL PWRSCAN_Start2AbortCriterion();
static STATE* PWRSCAN_Start2Abort();
/* Power scan: Step state */
static void PWRSCAN_StepEnter();
static void PWRSCAN_Step();
static BOOL PWRSCAN_Step2StopCriterion();
static STATE* PWRSCAN_Step2Stop();
static BOOL PWRSCAN_Step2AbortCriterion();
static STATE* PWRSCAN_Step2Abort();
/* Power scan: Stop state */
static void PWRSCAN_StopEnter();
static BOOL PWRSCAN_Stop2ReadyCriterion();
static STATE* PWRSCAN_Stop2Ready();
static BOOL PWRSCAN_Stop2TuneCriterion();
static STATE* PWRSCAN_Stop2Tune();
/* Power scan: Abort state */
static void PWRSCAN_AbortEnter();
/* Power scan: Ready state */
static void PWRSCAN_ReadyEnter();
/* State tables */
STATE pwrscan_reset_state = /* PWRSCAN FSM, RESET state */
{
PWRSCAN_ResetEnter, /* Entry task */
{
{PWRSCAN_Reset2TuneCriterion, PWRSCAN_Reset2Tune},
{PWRSCAN_Reset2AbortCriterion, PWRSCAN_Reset2Abort},
{0,0} /* End of Criterion/Exit task */
},
0, /* Regular/Routine task */
0, /* No counter */
PWRSCAN_RESET_STATE /* state code */
};
STATE pwrscan_tune_state = /* PWRSCAN FSM, TUNE state */
{
PWRSCAN_TuneEnter, /* Entry task */
{
{PWRSCAN_Tune2AbortCriterion, PWRSCAN_Tune2Abort}, /* higher priority */
{PWRSCAN_Tune2StartCriterion, PWRSCAN_Tune2Start},
{0,0} /* End of Criterion/Exit task */
},
0, /* Regular/Routine task */
0, /* No counter */
PWRSCAN_TUNE_STATE /* state code */
};
STATE pwrscan_start_state = /* PWRSCAN FSM, START state */
{
PWRSCAN_StartEnter, /* Entry task */
{
{PWRSCAN_Start2AbortCriterion, PWRSCAN_Start2Abort}, /* higher priority */
{PWRSCAN_Start2StepCriterion, PWRSCAN_Start2Step},
{0,0}
},
0, /* Regular task */
0,
PWRSCAN_START_STATE
};
STATE pwrscan_step_state = /* PWRSCAN FSM, STEP state */
{
PWRSCAN_StepEnter, /* Entry task */
{
{PWRSCAN_Step2AbortCriterion, PWRSCAN_Step2Abort}, /* higher priority */
{PWRSCAN_Step2StopCriterion, PWRSCAN_Step2Stop},
{0,0}
},
PWRSCAN_Step, /* Regular task */
0,
PWRSCAN_STEP_STATE
};
STATE pwrscan_stop_state = /* PWRSCAN FSM, STOP state */
{
PWRSCAN_StopEnter, /* Entry task */
{
{PWRSCAN_Stop2ReadyCriterion, PWRSCAN_Stop2Ready},
{PWRSCAN_Stop2TuneCriterion, PWRSCAN_Stop2Tune},
{0,0} /* End of Criterion/Exit task */
},
0, /* Regular/Routine task */
0, /* No counter */
PWRSCAN_STOP_STATE
};
STATE pwrscan_ready_state = /* PWRSCAN FSM, READY state */
{
PWRSCAN_ReadyEnter, /* Entry task */
{
{0,0} /* End of Criterion/Exit task */
},
0, /* Regular/Routine task */
0, /* No counter */
PWRSCAN_READY_STATE /* state code (uses bits [11:8] position) */
};
STATE pwrscan_abort_state = /* PWRSCAN FSM, ABORT state */
{
PWRSCAN_AbortEnter, /* Entry task */
{
{0,0} /* End of Criterion/Exit task */
},
0, /* Regular/Routine task */
0, /* No counter */
PWRSCAN_ABORT_STATE /* state code (uses bits [11:8] position) */
};
/*****************************************************************************/
/*****************************************************************************/
/* PWRSCAN_Start() */
/* Main FSM function */
/*****************************************************************************/
void
PWRSCAN_Start(FSM *fsm, HAMARO_PWRSCAN_INPUT* p_power_scan_input)
{
if (p_power_scan_input == 0)
{
return;
}
memcpy(&s_power_scan_data.power_scan_input, p_power_scan_input, sizeof(HAMARO_PWRSCAN_INPUT));
fsm->p_curr = &pwrscan_reset_state;
}
/*****************************************************************************/
/* PWRSCAN_ResetBuffers() */
/*****************************************************************************/
static BOOL
PWRSCAN_ResetBuffers()
{
if (STS_GetUseMainBuffer() == True)
{
memset(&s_power_spectrum_data.power[0], 0, sizeof(unsigned short)*(STS_MAX_INDEX-1));
memset(&s_power_spectrum_data.abs_freq[0],0, sizeof(unsigned long)*(STS_MAX_INDEX-1));
memset(&s_pwrscan_buffer_info, 0, sizeof(HAMARO_PWRSCAN_BUFFER_INFO) * STS_MAX_NUM_OF_SCAN_SEGMENTS);
s_power_spectrum_data.filled_buffer_len = 0;
s_power_spectrum_data.agcacc = 0;
s_buffer_info_index = 0;
}
else
{
memset(&s_power_spectrum_data.sub_power[0], 0, sizeof(unsigned short)*(STS_MAX_SUB_INDEX-1));
memset(&s_power_spectrum_data.sub_abs_freq[0],0, sizeof(unsigned long)*(STS_MAX_SUB_INDEX-1));
s_power_spectrum_data.filled_sub_buffer_len = 0;
s_power_spectrum_data.sub_agcacc = 0;
}
return (True);
}
void
PWRSCAN_SetAAGCFilter(BOOL value) /* True = apply filter; False = do not apply filter */
{
if (value == True)
{
STSDBG_WR_STR("PWRSCAN_SetAAGCFilter::AAGC FILTER IS ON", True);
}
else
{
STSDBG_WR_STR("PWRSCAN_SetAAGCFilter::AAGC FILTER IS OFF", True);
}
s_aagc_filter = value;
}
static BOOL
PWRSCAN_IsAAGCFilter() /* True = apply filter; False = do not apply filter */
{
return (s_aagc_filter);
}
/* MUST BE USED ONLY IN THE SCAN_THE_SKY MODULE */
BOOL
PWRSCAN_AAGCControl(BOOL freeze)
{
if (freeze == True)
{
(hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0x01, &hamaro_nim_list.nim[0]->iostatus);
if (hamaro_nim_list.nim[0]->iostatus != 0UL) return(False);
}
else
{
(hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0xFF, &hamaro_nim_list.nim[0]->iostatus);
if (hamaro_nim_list.nim[0]->iostatus != 0UL) return(False);
(hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x72, 0x00, &hamaro_nim_list.nim[0]->iostatus);
if (hamaro_nim_list.nim[0]->iostatus != 0UL) return(False);
}
return True;
}
BOOL
PWRSCAN_BTLAccClear()
{ /* Main Accum = 0x02, Sub Accum = 0x00 */
(hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x3A, 0x08, &hamaro_nim_list.nim[0]->iostatus);
if (hamaro_nim_list.nim[0]->iostatus != 0UL) return(False);
(hamaro_nim_list.nim[0]->SBWrite)(hamaro_nim_list.nim[0]->demod_handle, 0x3B, 0x00, &hamaro_nim_list.nim[0]->iostatus);
if (hamaro_nim_list.nim[0]->iostatus != 0UL) return(False);
return True;
}
/* END OF - MUST BE USED ONLY IN THE SCAN_THE_SKY MODULE - */
BOOL
PWRSCAN_IsBufferEmpty()
{
if (STS_GetUseMainBuffer() == True)
{
if (s_power_spectrum_data.filled_buffer_len == 0)
{
return (True);
}
}
else
{
if (s_power_spectrum_data.filled_sub_buffer_len == 0)
{
return (True);
}
}
return (False);
}
/*****************************************************************************/
/* PWRSCAN_GetMaxNumberSets() */
/*****************************************************************************/
static unsigned short
PWRSCAN_GetMaxNumberSets(unsigned char search_span_mhz, unsigned short number_freq_cnt, unsigned long step_size_hz)
{
return ( (unsigned short) ( (((unsigned long)search_span_mhz * 1000000UL) + 500000UL) / ((unsigned long)number_freq_cnt * step_size_hz) ) );
}
static unsigned short
PWRSCAN_GetNumFreqCount(unsigned char match_filter_clk_mhz, unsigned short desired_step_size_khz)
{
unsigned long constraint1, constraint2;
STSDBG_WR_INT_LN("match_filter_clk_hz = ", match_filter_clk_mhz);
STSDBG_WR_INT_LN("desired_step_size_khz = ", desired_step_size_khz);
constraint1 = STS_MATCH_FILTER_CONSTANT/match_filter_clk_mhz;
STSDBG_WR_INT_LN("constraint1 = ", constraint1);
/* (((0.25 * mfclk_mhz) * 2)/step_size) + 1 */
constraint2 = ((((250 * (match_filter_clk_mhz*1000)) * 2) / desired_step_size_khz)/1000) + 1;
STSDBG_WR_INT_LN("constraint2 = ", constraint2);
#if HAMARO_WIN_DEBUG
WINDBG_FileWriteNewLine();
#endif /* HAMARO_WIN_DEBUG */
if (constraint1 < constraint2)
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -