phantom_enums.h

来自「QPSK Tuner details, for conexant chipset」· C头文件 代码 · 共 482 行 · 第 1/2 页

}   PHANTOM_SPEC_INV;


/*******************************************************************************************************/
/* PHANTOM_ROLLOFF */
/*******************************************************************************************************/
typedef enum _PHANTOMRollOff  {   /* matched filter roll-off factors */
    PHANTOM_ROLLOFF_02=0,             /*   roll-off factor is 0.2  */
    PHANTOM_ROLLOFF_025=1,            /*   roll-off factor is 0.25 */
    PHANTOM_ROLLOFF_035=2,            /*   roll-off factor is 0.35 */
    PHANTOM_ROLLOFF_UNDEF=0xFF        /*   roll-off factor is undefined */
}   PHANTOM_ROLLOFF;


/*******************************************************************************************************/
/* PHANTOM_DEMOD family */
/*******************************************************************************************************/
typedef enum _PHANTOMDemod  {    /* demod types supported by this driver */
    PHANTOM=1,                   /* Phantom */
    DEMOD_UNDEF=0                /* Demod undefined */
}   PHANTOM_DEMOD;

typedef enum _PHANTOMTunerRefClkoutDiv { /*Ref Clockout divider types supported */
    PHANTOM_TUNER_REF_CLKOUT_DIV1=0, 
	PHANTOM_TUNER_REF_CLKOUT_DIV2=1
}	PHANTOM_TUNER_REF_CLOCKOUT_DIV;

/*******************************************************************************************************/
/* MPEG related */
/*******************************************************************************************************/
/*******************************************************************************************************/
/* PHANTOM_OUTPUT_MODE */
/*******************************************************************************************************/
typedef enum _PHANTOMOutputMode  {          /* data output mode */
    PHANTOM_PARALLEL_OUT=1,                      /*   Data is clocked out on DATA[7:0] a byte at a time */
    PHANTOM_SERIAL_OUT_DATA0,                    /*   Data is clocked out on DATA0 one bit at a time */
    PHANTOM_SERIAL_OUT_DATA7,                    /*   Data is clocked out on DATA7 one bit at a time */
    PHANTOM_OUTMODE_UNDEF=0                      /*   output mode is undefined */
}   PHANTOM_OUTPUT_MODE;


/*******************************************************************************************************/
/* PHANTOM_CLKOUT */
/*******************************************************************************************************/
typedef enum _PHANTOMClkOutEdge  {          /* clock edge -- see PHANTOM_MPEG_OUT->ClkOutEdge */
    PHANTOM_CLKOUT_EDGE=1,                       /*  data levels change on edge - default */
    PHANTOM_CLKOUT_HOLD=2,                       /*  advance output clock by 1/8 clk period.data change with extended hold time */
    PHANTOM_CLKOUT_ENDEF=0                       /*  (undefined) */
}   PHANTOM_CLKOUT;


/*******************************************************************************************************/
/* INVERT CLOCK */
/*******************************************************************************************************/
typedef enum _PHANTOMInvertClk  {           /* Clock Smoothing Select */
    PHANTOM_INVERT_CLK_UNDEF=0,                  /* undefined */
    PHANTOM_CHANGING_ON_RISING,                  /* Data is changing on rising edge of clock. */
    PHANTOM_CHANGING_ON_FALLING                  /* Data is changing on falling edge of clock. */
}   PHANTOM_INVERT_CLK;


/*******************************************************************************************************/
/* PHANTOM_TEI_BIT */
/*******************************************************************************************************/
typedef enum _PHANTOMTEIBit {               /* hold time after clocking edge:*/
    PHANTOM_TEI_BIT_UNDEF=0,                     /*   hold-time is undefined */
    PHANTOM_TEI_BIT_SET,
    PHANTOM_TEI_BIT_NOT_SET
}   PHANTOM_TEI_BIT;


/*******************************************************************************************************/
/* PHANTOM_CLK_PARITY_MODE */
/*******************************************************************************************************/
/* clock parity:  specifies continuous or punctured during the parity portion of the MPEG payload */
typedef enum _PHANTOMClkParityMode  {       
    PHANTOM_CLK_CONTINUOUS=1,                    /*   Clock is continuous throughout MPEG frame */
    PHANTOM_CLK_GAPPED,                          /*   Clock is gapped during parity portion of MPEG frame */
    PHANTOM_CLK_PARITY_UNDEF=0                   /*   clock parity is undefined */
}   PHANTOM_CLK_PARITY_MODE;


/*******************************************************************************************************/
/* PHANTOM_CNTL_SIGNAL_POL */
/*******************************************************************************************************/
typedef enum _PHANTOMCntlSignalPol  {      /* Polarity for MPEG Cntl Signal - Start, Valid, Fail */
    PHANTOM_CNTL_SIGNAL_POL_UNDEF = 0,          /* undefined */
    PHANTOM_ACTIVE_LOW,                         /* Active Low  */
    PHANTOM_ACTIVE_HIGH                         /* Active High */
}   PHANTOM_CNTL_SIGNAL_POL;


/*******************************************************************************************************/
/* PHANTOM_START_SIGNAL_WIDTH */
/*******************************************************************************************************/
/* Start Signal Width in Serial mode. Start Signal Width is always byte wide in Parallel mode. */
typedef enum _PHANTOMStartSignalWidth  {   
    PHANTOM_START_SIGNAL_WIDTH_UNDEF = 0,       /* undefined  */
    PHANTOM_BIT_WIDE,                           /* Bit Wide */
    PHANTOM_BYTE_WIDE                           /* Byte Wide */
}   PHANTOM_START_SIGNAL_WIDTH;


/*******************************************************************************************************/
/* PHANTOM_CNTL_SIGNAL_MODE */
/*******************************************************************************************************/
typedef enum _PHANTOMCntlSignalMode  {     /* MPEG Cntl signal active mode */
    PHANTOM_CNTL_SIGNAL_MODE_UNDEF = 0,         /* undefined */
    PHANTOM_ENTIRE_PACKET,                      /* Cntl signal active during entire data packet */
    PHANTOM_FIRST_BYTE                          /* Cntl signal active during first byte only */
}   PHANTOM_CNTL_SIGNAL_MODE;


/*******************************************************************************************************/
/* PHANTOM_SYNC_BYTE_INSERT_MODE */
/*******************************************************************************************************/
typedef enum PHANTOMSyncByteInsertMode  {  /* MPEG Sync byte insert Control */
    PHANTOM_SYNC_BYTE_INSERT_UNDEF = 0,         /* undefined */
    PHANTOM_SYNC_BYTE_INSERT,                   /* Sync byte 47Hex needs to be inserted*/
    PHANTOM_SYNC_BYTE_NOT_INSERT                /* Sync byte will not be inserted */
}   PHANTOM_SYNC_BYTE_INSERT_MODE;


/*******************************************************************************************************/
/* PHANTOM_TSTATE */
/*******************************************************************************************************/
typedef enum _PHANTOMTState  {              /* tstate mpeg setting */
    PHANTOM_TSTATE_MPEG_OFF=1,                   /*   set MPEG pins to NON-Tstate */
    PHANTOM_TSTATE_MPEG_ON,                      /*   set MPEG pins to Tstate */
    PHANTOM_TSTATE_UNDEF=0                       /*   tri-state is in an unknown condition */
}   PHANTOM_TSTATE;             


/*******************************************************************************************************/
/* Ranges */
/*******************************************************************************************************/
/*******************************************************************************************************/
/* PHANTOM_FREQ_XTAL_RANGE */
/*******************************************************************************************************/
typedef enum _PHANTOMFreqXtalRange  {       /* xtal frequency (in mhz), valid range */
    PHANTOM_FREQ_XTAL_LOW=5,                /*   low range 5 megahertz */
    PHANTOM_FREQ_XTAL_HIGH=41                    
}   PHANTOM_FREQ_XTAL_RANGE;


/*******************************************************************************************************/
/* misc enums */
/*******************************************************************************************************/
/*******************************************************************************************************/
/* PHANTOM_LNBMODE_SET */
/*******************************************************************************************************/
typedef enum _PHANTOMLnbmodeset {
    PHANTOM_LNBMODE_SIGMA_DELTA_TONE=0x00,       /* Tone PWM Mode */
    PHANTOM_LNBMODE_DIGITAL_TONE=0x01,           /* Tone Clock Mode (default) */
    PHANTOM_LNBMODE_ENVELOPE=0x02,               /* Envelope Mode */
    PHANTOM_LNBMODE_MANUAL_ZERO=0x03             /* Static '0' (zero) */
}   PHANTOM_LNBMODE_SET;


typedef enum _PHANTOMLnbRxExpWindow  {
    PHANTOM_REPLY_EXPIRATION_WINDOW_150=0x00,   /* 150 mSec */
    PHANTOM_REPLY_EXPIRATION_WINDOW_166=0x01,   /* 166 mSec */
    PHANTOM_REPLY_EXPIRATION_WINDOW_182=0x02,   /* 182 mSec */
    PHANTOM_REPLY_EXPIRATION_WINDOW_200=0x03    /* 200 mSec */
}   PHANTOM_LNB_RX_EXP_WINDOW;


#if PHANTOM_INCLUDE_DISEQC2
/*******************************************************************************************************/
/* PHANTOM_LNB_BURST */
/*******************************************************************************************************/
typedef enum _PHANTOMLnbburst  {
    PHANTOM_LNB_BURST_MODULATED=1,                /* Modulated: Tone B               */
    PHANTOM_LNB_BURST_UNMODULATED,                /* Not modulated: Tone A           */
    PHANTOM_LNB_BURST_UNDEF=0                     /* undefined (results in an error) */
}   PHANTOM_LNB_BURST;

/*******************************************************************************************************/
/* PHANTOM_LNB_TONEBURST_EN_SET */
/*******************************************************************************************************/
typedef enum _PHANTOMLnbToneBurstEn  {
    PHANTOM_LNB_TONEBURST_ENABLE=1,                /* Enable tone burst               */
    PHANTOM_LNB_TONEBURST_DISABLE                  /* Disable tone burst           */    
}   PHANTOM_LNB_TONEBURST_EN_SET;

/*******************************************************************************************************/
/* PHANTOM_RXMODE */
/*******************************************************************************************************/
typedef enum _PHANTOMRxMode  {
    PHANTOM_RXMODE_INTERROGATION=0,              /* Demod expects multiple devices attached */
    PHANTOM_RXMODE_QUICKREPLY=1,                 /* demod expects 1 rx (rx is suspended after 1st rx received) */
    PHANTOM_RXMODE_NOREPLY=2                     /* demod expects to receive no Rx message(s) */
}   PHANTOM_RXMODE;
#endif /* PHANTOM_INCLUDE_DISEQC2 */


/*******************************************************************************************************/
/* Demod specific Enums */
/*******************************************************************************************************/
/*******************************************************************************************************/
/* PHANTOM_NULL_DATA_MODE */
/*******************************************************************************************************/
typedef enum _PHANTOMNullDataMode  {        /* MPEG Null Data Mode Control */
    PHANTOM_NULL_DATA_MODE_UNDEF = 0,            /* undefined */
    PHANTOM_FIXED_NULL_DATA_ENABLED,             /* Null data will be modified */
    PHANTOM_FIXED_NULL_DATA_DISABLED             /* Null data is not modified */
}   PHANTOM_NULL_DATA_MODE;


/*******************************************************************************************************/
/* PHANTOM_NULL_DATA_VALUE */
/*******************************************************************************************************/
typedef enum _PHANTOMNullDataValue  {       /* MPEG Null Data Value */
    PHANTOM_NULL_DATA_VALUE_UNDEF = 0,           /* undefined */
    PHANTOM_FIXED_NULL_DATA_HIGH,                /* Null data will be replaced with 1 */
    PHANTOM_FIXED_NULL_DATA_LOW                  /* Null data will be replaced with 0 */
}   PHANTOM_NULL_DATA_VALUE;

#endif  /* #ifndef PHANTOM_ENUMS_H_DEFINED */