-\r
+
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
-\r
-#include "drxk_type.h"\r
-#include "mt2063.h"\r
-\r
-/* Version of this module */\r
-#define MT2063_VERSION 10018 /* Version 01.18 */\r
-\r
+
+#include "drxk_type.h"
+#include "mt2063.h"
+
+/* Version of this module */
+#define MT2063_VERSION 10018 /* Version 01.18 */
+
static unsigned int verbose;
-module_param(verbose, int, 0644);\r
-\r
-//i2c operation\r
-static int mt2063_writeregs(struct mt2063_state *state, u8 reg1,\r
- u8 *data, int len)
+module_param(verbose, int, 0644);
+
+//i2c operation
+static int mt2063_writeregs(struct mt2063_state *state, u8 reg1,
+ u8 * data, int len)
+{
+ int ret;
+ u8 buf[60]; /* = { reg1, data }; */
+
+ struct i2c_msg msg = {
+ .addr = state->config->tuner_address,
+ .flags = 0,
+ .buf = buf,
+ .len = len + 1
+ };
+
+ msg.buf[0] = reg1;
+ memcpy(msg.buf + 1, data, len);
+
+ //printk("mt2063_writeregs state->i2c=%p\n", state->i2c);
+ ret = i2c_transfer(state->i2c, &msg, 1);
+
+ if (ret < 0)
+ printk("mt2063_writeregs error ret=%d\n", ret);
+
+ return ret;
+}
+
+static int mt2063_read_regs(struct mt2063_state *state, u8 reg1, u8 * b, u8 len)
+{
+ int ret;
+ u8 b0[] = { reg1 };
+ struct i2c_msg msg[] = {
+ {
+ .addr = state->config->tuner_address,
+ .flags = I2C_M_RD,
+ .buf = b0,
+ .len = 1}, {
+ .addr = state->config->tuner_address,
+ .flags = I2C_M_RD,
+ .buf = b,
+ .len = len}
+ };
+
+ //printk("mt2063_read_regs state->i2c=%p\n", state->i2c);
+ ret = i2c_transfer(state->i2c, msg, 2);
+ if (ret < 0)
+ printk("mt2063_readregs error ret=%d\n", ret);
+
+ return ret;
+}
+
+//context of mt2063_userdef.c <Henry> ======================================
+//#################################################################
+//=================================================================
+/*****************************************************************************
+**
+** Name: MT_WriteSub
+**
+** Description: Write values to device using a two-wire serial bus.
+**
+** Parameters: hUserData - User-specific I/O parameter that was
+** passed to tuner's Open function.
+** addr - device serial bus address (value passed
+** as parameter to MTxxxx_Open)
+** subAddress - serial bus sub-address (Register Address)
+** pData - pointer to the Data to be written to the
+** device
+** cnt - number of bytes/registers to be written
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** user-defined
+**
+** Notes: This is a callback function that is called from the
+** the tuning algorithm. You MUST provide code for this
+** function to write data using the tuner's 2-wire serial
+** bus.
+**
+** The hUserData parameter is a user-specific argument.
+** If additional arguments are needed for the user's
+** serial bus read/write functions, this argument can be
+** used to supply the necessary information.
+** The hUserData parameter is initialized in the tuner's Open
+** function.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 03-25-2004 DAD Original
+**
+*****************************************************************************/
+UData_t MT2063_WriteSub(Handle_t hUserData,
+ UData_t addr,
+ U8Data subAddress, U8Data * pData, UData_t cnt)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct dvb_frontend *fe = hUserData;
+ struct mt2063_state *state = fe->tuner_priv;
+ /*
+ ** ToDo: Add code here to implement a serial-bus write
+ ** operation to the MTxxxx tuner. If successful,
+ ** return MT_OK.
+ */
+/* return status; */
+
+//#if !TUNER_CONTROL_BY_DRXK_DRIVER
+ fe->ops.i2c_gate_ctrl(fe, 1); //I2C bypass drxk3926 close i2c bridge
+//#endif
+
+ if (mt2063_writeregs(state, subAddress, pData, cnt) < 0) {
+ status = MT2063_ERROR;
+ }
+//#if !TUNER_CONTROL_BY_DRXK_DRIVER
+ fe->ops.i2c_gate_ctrl(fe, 0); //I2C bypass drxk3926 close i2c bridge
+//#endif
+
+ return (status);
+}
+
+/*****************************************************************************
+**
+** Name: MT_ReadSub
+**
+** Description: Read values from device using a two-wire serial bus.
+**
+** Parameters: hUserData - User-specific I/O parameter that was
+** passed to tuner's Open function.
+** addr - device serial bus address (value passed
+** as parameter to MTxxxx_Open)
+** subAddress - serial bus sub-address (Register Address)
+** pData - pointer to the Data to be written to the
+** device
+** cnt - number of bytes/registers to be written
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** user-defined
+**
+** Notes: This is a callback function that is called from the
+** the tuning algorithm. You MUST provide code for this
+** function to read data using the tuner's 2-wire serial
+** bus.
+**
+** The hUserData parameter is a user-specific argument.
+** If additional arguments are needed for the user's
+** serial bus read/write functions, this argument can be
+** used to supply the necessary information.
+** The hUserData parameter is initialized in the tuner's Open
+** function.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 03-25-2004 DAD Original
+**
+*****************************************************************************/
+UData_t MT2063_ReadSub(Handle_t hUserData,
+ UData_t addr,
+ U8Data subAddress, U8Data * pData, UData_t cnt)
+{
+ /*
+ ** ToDo: Add code here to implement a serial-bus read
+ ** operation to the MTxxxx tuner. If successful,
+ ** return MT_OK.
+ */
+/* return status; */
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct dvb_frontend *fe = hUserData;
+ struct mt2063_state *state = fe->tuner_priv;
+ UData_t i = 0;
+//#if !TUNER_CONTROL_BY_DRXK_DRIVER
+ fe->ops.i2c_gate_ctrl(fe, 1); //I2C bypass drxk3926 close i2c bridge
+//#endif
+
+ for (i = 0; i < cnt; i++) {
+ if (mt2063_read_regs(state, subAddress + i, pData + i, 1) < 0) {
+ status = MT2063_ERROR;
+ break;
+ }
+ }
+
+//#if !TUNER_CONTROL_BY_DRXK_DRIVER
+ fe->ops.i2c_gate_ctrl(fe, 0); //I2C bypass drxk3926 close i2c bridge
+//#endif
+
+ return (status);
+}
+
+/*****************************************************************************
+**
+** Name: MT_Sleep
+**
+** Description: Delay execution for "nMinDelayTime" milliseconds
+**
+** Parameters: hUserData - User-specific I/O parameter that was
+** passed to tuner's Open function.
+** nMinDelayTime - Delay time in milliseconds
+**
+** Returns: None.
+**
+** Notes: This is a callback function that is called from the
+** the tuning algorithm. You MUST provide code that
+** blocks execution for the specified period of time.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 03-25-2004 DAD Original
+**
+*****************************************************************************/
+void MT2063_Sleep(Handle_t hUserData, UData_t nMinDelayTime)
+{
+ /*
+ ** ToDo: Add code here to implement a OS blocking
+ ** for a period of "nMinDelayTime" milliseconds.
+ */
+ msleep(nMinDelayTime);
+}
+
+#if defined(MT2060_CNT)
+#if MT2060_CNT > 0
+/*****************************************************************************
+**
+** Name: MT_TunerGain (MT2060 only)
+**
+** Description: Measure the relative tuner gain using the demodulator
+**
+** Parameters: hUserData - User-specific I/O parameter that was
+** passed to tuner's Open function.
+** pMeas - Tuner gain (1/100 of dB scale).
+** ie. 1234 = 12.34 (dB)
+**
+** Returns: status:
+** MT_OK - No errors
+** user-defined errors could be set
+**
+** Notes: This is a callback function that is called from the
+** the 1st IF location routine. You MUST provide
+** code that measures the relative tuner gain in a dB
+** (not linear) scale. The return value is an integer
+** value scaled to 1/100 of a dB.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 06-16-2004 DAD Original
+** N/A 11-30-2004 DAD Renamed from MT_DemodInputPower. This name
+** better describes what this function does.
+**
+*****************************************************************************/
+UData_t MT2060_TunerGain(Handle_t hUserData, SData_t * pMeas)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+
+ /*
+ ** ToDo: Add code here to return the gain / power level measured
+ ** at the input to the demodulator.
+ */
+
+ return (status);
+}
+#endif
+#endif
+//end of mt2063_userdef.c
+//=================================================================
+//#################################################################
+//=================================================================
+
+//context of mt2063_spuravoid.c <Henry> ======================================
+//#################################################################
+//=================================================================
+
+/*****************************************************************************
+**
+** Name: mt_spuravoid.c
+**
+** Description: Microtune spur avoidance software module.
+** Supports Microtune tuner drivers.
+**
+** CVS ID: $Id: mt_spuravoid.c,v 1.3 2008/06/26 15:39:52 software Exp $
+** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2063/mt_spuravoid.c,v $
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 082 03-25-2005 JWS Original multi-tuner support - requires
+** MTxxxx_CNT declarations
+** 096 04-06-2005 DAD Ver 1.11: Fix divide by 0 error if maxH==0.
+** 094 04-06-2005 JWS Ver 1.11 Added uceil and ufloor to get rid
+** of compiler warnings
+** N/A 04-07-2005 DAD Ver 1.13: Merged single- and multi-tuner spur
+** avoidance into a single module.
+** 103 01-31-2005 DAD Ver 1.14: In MT_AddExclZone(), if the range
+** (f_min, f_max) < 0, ignore the entry.
+** 115 03-23-2007 DAD Fix declaration of spur due to truncation
+** errors.
+** 117 03-29-2007 RSK Ver 1.15: Re-wrote to match search order from
+** tuner DLL.
+** 137 06-18-2007 DAD Ver 1.16: Fix possible divide-by-0 error for
+** multi-tuners that have
+** (delta IF1) > (f_out-f_outbw/2).
+** 147 07-27-2007 RSK Ver 1.17: Corrected calculation (-) to (+)
+** Added logic to force f_Center within 1/2 f_Step.
+** 177 S 02-26-2008 RSK Ver 1.18: Corrected calculation using LO1 > MAX/2
+** Type casts added to preserve correct sign.
+** N/A I 06-17-2008 RSK Ver 1.19: Refactoring avoidance of DECT
+** frequencies into MT_ResetExclZones().
+** N/A I 06-20-2008 RSK Ver 1.21: New VERSION number for ver checking.
+**
+*****************************************************************************/
+
+#if !defined(MT2063_TUNER_CNT)
+#error MT2063_TUNER_CNT is not defined (see mt_userdef.h)
+#endif
+
+#if MT2063_TUNER_CNT == 0
+#error MT2063_TUNER_CNT must be updated in mt_userdef.h
+#endif
+
+/* Version of this module */
+#define MT2063_SPUR_VERSION 10201 /* Version 01.21 */
+
+/* Implement ceiling, floor functions. */
+#define ceil(n, d) (((n) < 0) ? (-((-(n))/(d))) : (n)/(d) + ((n)%(d) != 0))
+#define uceil(n, d) ((n)/(d) + ((n)%(d) != 0))
+#define floor(n, d) (((n) < 0) ? (-((-(n))/(d))) - ((n)%(d) != 0) : (n)/(d))
+#define ufloor(n, d) ((n)/(d))
+
+struct MT2063_FIFZone_t {
+ SData_t min_;
+ SData_t max_;
+};
+
+#if MT2063_TUNER_CNT > 1
+static struct MT2063_AvoidSpursData_t *TunerList[MT2063_TUNER_CNT];
+static UData_t TunerCount = 0;
+#endif
+
+UData_t MT2063_RegisterTuner(struct MT2063_AvoidSpursData_t *pAS_Info)
+{
+#if MT2063_TUNER_CNT == 1
+ pAS_Info->nAS_Algorithm = 1;
+ return MT2063_OK;
+#else
+ UData_t index;
+
+ pAS_Info->nAS_Algorithm = 2;
+
+ /*
+ ** Check to see if tuner is already registered
+ */
+ for (index = 0; index < TunerCount; index++) {
+ if (TunerList[index] == pAS_Info) {
+ return MT2063_OK; /* Already here - no problem */
+ }
+ }
+
+ /*
+ ** Add tuner to list - if there is room.
+ */
+ if (TunerCount < MT2063_TUNER_CNT) {
+ TunerList[TunerCount] = pAS_Info;
+ TunerCount++;
+ return MT2063_OK;
+ } else
+ return MT2063_TUNER_CNT_ERR;
+#endif
+}
+
+void MT2063_UnRegisterTuner(struct MT2063_AvoidSpursData_t *pAS_Info)
+{
+#if MT2063_TUNER_CNT == 1
+ pAS_Info;
+#else
+
+ UData_t index;
+
+ for (index = 0; index < TunerCount; index++) {
+ if (TunerList[index] == pAS_Info) {
+ TunerList[index] = TunerList[--TunerCount];
+ }
+ }
+#endif
+}
+
+/*
+** Reset all exclusion zones.
+** Add zones to protect the PLL FracN regions near zero
+**
+** N/A I 06-17-2008 RSK Ver 1.19: Refactoring avoidance of DECT
+** frequencies into MT_ResetExclZones().
+*/
+void MT2063_ResetExclZones(struct MT2063_AvoidSpursData_t *pAS_Info)
+{
+ UData_t center;
+#if MT2063_TUNER_CNT > 1
+ UData_t index;
+ struct MT2063_AvoidSpursData_t *adj;
+#endif
+
+ pAS_Info->nZones = 0; /* this clears the used list */
+ pAS_Info->usedZones = NULL; /* reset ptr */
+ pAS_Info->freeZones = NULL; /* reset ptr */
+
+ center =
+ pAS_Info->f_ref *
+ ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw / 2 +
+ pAS_Info->f_in) / pAS_Info->f_ref) - pAS_Info->f_in;
+ while (center <
+ pAS_Info->f_if1_Center + pAS_Info->f_if1_bw / 2 +
+ pAS_Info->f_LO1_FracN_Avoid) {
+ /* Exclude LO1 FracN */
+ MT2063_AddExclZone(pAS_Info,
+ center - pAS_Info->f_LO1_FracN_Avoid,
+ center - 1);
+ MT2063_AddExclZone(pAS_Info, center + 1,
+ center + pAS_Info->f_LO1_FracN_Avoid);
+ center += pAS_Info->f_ref;
+ }
+
+ center =
+ pAS_Info->f_ref *
+ ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw / 2 -
+ pAS_Info->f_out) / pAS_Info->f_ref) + pAS_Info->f_out;
+ while (center <
+ pAS_Info->f_if1_Center + pAS_Info->f_if1_bw / 2 +
+ pAS_Info->f_LO2_FracN_Avoid) {
+ /* Exclude LO2 FracN */
+ MT2063_AddExclZone(pAS_Info,
+ center - pAS_Info->f_LO2_FracN_Avoid,
+ center - 1);
+ MT2063_AddExclZone(pAS_Info, center + 1,
+ center + pAS_Info->f_LO2_FracN_Avoid);
+ center += pAS_Info->f_ref;
+ }
+
+ if (MT2063_EXCLUDE_US_DECT_FREQUENCIES(pAS_Info->avoidDECT)) {
+ /* Exclude LO1 values that conflict with DECT channels */
+ MT2063_AddExclZone(pAS_Info, 1920836000 - pAS_Info->f_in, 1922236000 - pAS_Info->f_in); /* Ctr = 1921.536 */
+ MT2063_AddExclZone(pAS_Info, 1922564000 - pAS_Info->f_in, 1923964000 - pAS_Info->f_in); /* Ctr = 1923.264 */
+ MT2063_AddExclZone(pAS_Info, 1924292000 - pAS_Info->f_in, 1925692000 - pAS_Info->f_in); /* Ctr = 1924.992 */
+ MT2063_AddExclZone(pAS_Info, 1926020000 - pAS_Info->f_in, 1927420000 - pAS_Info->f_in); /* Ctr = 1926.720 */
+ MT2063_AddExclZone(pAS_Info, 1927748000 - pAS_Info->f_in, 1929148000 - pAS_Info->f_in); /* Ctr = 1928.448 */
+ }
+
+ if (MT2063_EXCLUDE_EURO_DECT_FREQUENCIES(pAS_Info->avoidDECT)) {
+ MT2063_AddExclZone(pAS_Info, 1896644000 - pAS_Info->f_in, 1898044000 - pAS_Info->f_in); /* Ctr = 1897.344 */
+ MT2063_AddExclZone(pAS_Info, 1894916000 - pAS_Info->f_in, 1896316000 - pAS_Info->f_in); /* Ctr = 1895.616 */
+ MT2063_AddExclZone(pAS_Info, 1893188000 - pAS_Info->f_in, 1894588000 - pAS_Info->f_in); /* Ctr = 1893.888 */
+ MT2063_AddExclZone(pAS_Info, 1891460000 - pAS_Info->f_in, 1892860000 - pAS_Info->f_in); /* Ctr = 1892.16 */
+ MT2063_AddExclZone(pAS_Info, 1889732000 - pAS_Info->f_in, 1891132000 - pAS_Info->f_in); /* Ctr = 1890.432 */
+ MT2063_AddExclZone(pAS_Info, 1888004000 - pAS_Info->f_in, 1889404000 - pAS_Info->f_in); /* Ctr = 1888.704 */
+ MT2063_AddExclZone(pAS_Info, 1886276000 - pAS_Info->f_in, 1887676000 - pAS_Info->f_in); /* Ctr = 1886.976 */
+ MT2063_AddExclZone(pAS_Info, 1884548000 - pAS_Info->f_in, 1885948000 - pAS_Info->f_in); /* Ctr = 1885.248 */
+ MT2063_AddExclZone(pAS_Info, 1882820000 - pAS_Info->f_in, 1884220000 - pAS_Info->f_in); /* Ctr = 1883.52 */
+ MT2063_AddExclZone(pAS_Info, 1881092000 - pAS_Info->f_in, 1882492000 - pAS_Info->f_in); /* Ctr = 1881.792 */
+ }
+#if MT2063_TUNER_CNT > 1
+ /*
+ ** Iterate through all adjacent tuners and exclude frequencies related to them
+ */
+ for (index = 0; index < TunerCount; ++index) {
+ adj = TunerList[index];
+ if (pAS_Info == adj) /* skip over our own data, don't process it */
+ continue;
+
+ /*
+ ** Add 1st IF exclusion zone covering adjacent tuner's LO2
+ ** at "adjfLO2 + f_out" +/- m_MinLOSpacing
+ */
+ if (adj->f_LO2 != 0)
+ MT2063_AddExclZone(pAS_Info,
+ (adj->f_LO2 + pAS_Info->f_out) -
+ pAS_Info->f_min_LO_Separation,
+ (adj->f_LO2 + pAS_Info->f_out) +
+ pAS_Info->f_min_LO_Separation);
+
+ /*
+ ** Add 1st IF exclusion zone covering adjacent tuner's LO1
+ ** at "adjfLO1 - f_in" +/- m_MinLOSpacing
+ */
+ if (adj->f_LO1 != 0)
+ MT2063_AddExclZone(pAS_Info,
+ (adj->f_LO1 - pAS_Info->f_in) -
+ pAS_Info->f_min_LO_Separation,
+ (adj->f_LO1 - pAS_Info->f_in) +
+ pAS_Info->f_min_LO_Separation);
+ }
+#endif
+}
+
+static struct MT2063_ExclZone_t *InsertNode(struct MT2063_AvoidSpursData_t
+ *pAS_Info,
+ struct MT2063_ExclZone_t *pPrevNode)
+{
+ struct MT2063_ExclZone_t *pNode;
+ /* Check for a node in the free list */
+ if (pAS_Info->freeZones != NULL) {
+ /* Use one from the free list */
+ pNode = pAS_Info->freeZones;
+ pAS_Info->freeZones = pNode->next_;
+ } else {
+ /* Grab a node from the array */
+ pNode = &pAS_Info->MT2063_ExclZones[pAS_Info->nZones];
+ }
+
+ if (pPrevNode != NULL) {
+ pNode->next_ = pPrevNode->next_;
+ pPrevNode->next_ = pNode;
+ } else { /* insert at the beginning of the list */
+
+ pNode->next_ = pAS_Info->usedZones;
+ pAS_Info->usedZones = pNode;
+ }
+
+ pAS_Info->nZones++;
+ return pNode;
+}
+
+static struct MT2063_ExclZone_t *RemoveNode(struct MT2063_AvoidSpursData_t
+ *pAS_Info,
+ struct MT2063_ExclZone_t *pPrevNode,
+ struct MT2063_ExclZone_t
+ *pNodeToRemove)
+{
+ struct MT2063_ExclZone_t *pNext = pNodeToRemove->next_;
+
+ /* Make previous node point to the subsequent node */
+ if (pPrevNode != NULL)
+ pPrevNode->next_ = pNext;
+
+ /* Add pNodeToRemove to the beginning of the freeZones */
+ pNodeToRemove->next_ = pAS_Info->freeZones;
+ pAS_Info->freeZones = pNodeToRemove;
+
+ /* Decrement node count */
+ pAS_Info->nZones--;
+
+ return pNext;
+}
+
+/*****************************************************************************
+**
+** Name: MT_AddExclZone
+**
+** Description: Add (and merge) an exclusion zone into the list.
+** If the range (f_min, f_max) is totally outside the
+** 1st IF BW, ignore the entry.
+** If the range (f_min, f_max) is negative, ignore the entry.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 103 01-31-2005 DAD Ver 1.14: In MT_AddExclZone(), if the range
+** (f_min, f_max) < 0, ignore the entry.
+**
+*****************************************************************************/
+void MT2063_AddExclZone(struct MT2063_AvoidSpursData_t *pAS_Info,
+ UData_t f_min, UData_t f_max)
+{
+ struct MT2063_ExclZone_t *pNode = pAS_Info->usedZones;
+ struct MT2063_ExclZone_t *pPrev = NULL;
+ struct MT2063_ExclZone_t *pNext = NULL;
+
+ /* Check to see if this overlaps the 1st IF filter */
+ if ((f_max > (pAS_Info->f_if1_Center - (pAS_Info->f_if1_bw / 2)))
+ && (f_min < (pAS_Info->f_if1_Center + (pAS_Info->f_if1_bw / 2)))
+ && (f_min < f_max)) {
+ /*
+ ** 1 2 3 4 5 6
+ **
+ ** New entry: |---| |--| |--| |-| |---| |--|
+ ** or or or or or
+ ** Existing: |--| |--| |--| |---| |-| |--|
+ */
+
+ /* Check for our place in the list */
+ while ((pNode != NULL) && (pNode->max_ < f_min)) {
+ pPrev = pNode;
+ pNode = pNode->next_;
+ }
+
+ if ((pNode != NULL) && (pNode->min_ < f_max)) {
+ /* Combine me with pNode */
+ if (f_min < pNode->min_)
+ pNode->min_ = f_min;
+ if (f_max > pNode->max_)
+ pNode->max_ = f_max;
+ } else {
+ pNode = InsertNode(pAS_Info, pPrev);
+ pNode->min_ = f_min;
+ pNode->max_ = f_max;
+ }
+
+ /* Look for merging possibilities */
+ pNext = pNode->next_;
+ while ((pNext != NULL) && (pNext->min_ < pNode->max_)) {
+ if (pNext->max_ > pNode->max_)
+ pNode->max_ = pNext->max_;
+ pNext = RemoveNode(pAS_Info, pNode, pNext); /* Remove pNext, return ptr to pNext->next */
+ }
+ }
+}
+
+/*****************************************************************************
+**
+** Name: MT_ChooseFirstIF
+**
+** Description: Choose the best available 1st IF
+** If f_Desired is not excluded, choose that first.
+** Otherwise, return the value closest to f_Center that is
+** not excluded
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 117 03-29-2007 RSK Ver 1.15: Re-wrote to match search order from
+** tuner DLL.
+** 147 07-27-2007 RSK Ver 1.17: Corrected calculation (-) to (+)
+** Added logic to force f_Center within 1/2 f_Step.
+**
+*****************************************************************************/
+UData_t MT2063_ChooseFirstIF(struct MT2063_AvoidSpursData_t *pAS_Info)
+{
+ /*
+ ** Update "f_Desired" to be the nearest "combinational-multiple" of "f_LO1_Step".
+ ** The resulting number, F_LO1 must be a multiple of f_LO1_Step. And F_LO1 is the arithmetic sum
+ ** of f_in + f_Center. Neither f_in, nor f_Center must be a multiple of f_LO1_Step.
+ ** However, the sum must be.
+ */
+ const UData_t f_Desired =
+ pAS_Info->f_LO1_Step *
+ ((pAS_Info->f_if1_Request + pAS_Info->f_in +
+ pAS_Info->f_LO1_Step / 2) / pAS_Info->f_LO1_Step) -
+ pAS_Info->f_in;
+ const UData_t f_Step =
+ (pAS_Info->f_LO1_Step >
+ pAS_Info->f_LO2_Step) ? pAS_Info->f_LO1_Step : pAS_Info->
+ f_LO2_Step;
+ UData_t f_Center;
+
+ SData_t i;
+ SData_t j = 0;
+ UData_t bDesiredExcluded = 0;
+ UData_t bZeroExcluded = 0;
+ SData_t tmpMin, tmpMax;
+ SData_t bestDiff;
+ struct MT2063_ExclZone_t *pNode = pAS_Info->usedZones;
+ struct MT2063_FIFZone_t zones[MT2063_MAX_ZONES];
+
+ if (pAS_Info->nZones == 0)
+ return f_Desired;
+
+ /* f_Center needs to be an integer multiple of f_Step away from f_Desired */
+ if (pAS_Info->f_if1_Center > f_Desired)
+ f_Center =
+ f_Desired +
+ f_Step *
+ ((pAS_Info->f_if1_Center - f_Desired +
+ f_Step / 2) / f_Step);
+ else
+ f_Center =
+ f_Desired -
+ f_Step *
+ ((f_Desired - pAS_Info->f_if1_Center +
+ f_Step / 2) / f_Step);
+
+ //assert;
+ //if (!abs((SData_t) f_Center - (SData_t) pAS_Info->f_if1_Center) <= (SData_t) (f_Step/2))
+ // return 0;
+
+ /* Take MT_ExclZones, center around f_Center and change the resolution to f_Step */
+ while (pNode != NULL) {
+ /* floor function */
+ tmpMin =
+ floor((SData_t) (pNode->min_ - f_Center), (SData_t) f_Step);
+
+ /* ceil function */
+ tmpMax =
+ ceil((SData_t) (pNode->max_ - f_Center), (SData_t) f_Step);
+
+ if ((pNode->min_ < f_Desired) && (pNode->max_ > f_Desired))
+ bDesiredExcluded = 1;
+
+ if ((tmpMin < 0) && (tmpMax > 0))
+ bZeroExcluded = 1;
+
+ /* See if this zone overlaps the previous */
+ if ((j > 0) && (tmpMin < zones[j - 1].max_))
+ zones[j - 1].max_ = tmpMax;
+ else {
+ /* Add new zone */
+ //assert(j<MT2063_MAX_ZONES);
+ //if (j>=MT2063_MAX_ZONES)
+ //break;
+
+ zones[j].min_ = tmpMin;
+ zones[j].max_ = tmpMax;
+ j++;
+ }
+ pNode = pNode->next_;
+ }
+
+ /*
+ ** If the desired is okay, return with it
+ */
+ if (bDesiredExcluded == 0)
+ return f_Desired;
+
+ /*
+ ** If the desired is excluded and the center is okay, return with it
+ */
+ if (bZeroExcluded == 0)
+ return f_Center;
+
+ /* Find the value closest to 0 (f_Center) */
+ bestDiff = zones[0].min_;
+ for (i = 0; i < j; i++) {
+ if (abs(zones[i].min_) < abs(bestDiff))
+ bestDiff = zones[i].min_;
+ if (abs(zones[i].max_) < abs(bestDiff))
+ bestDiff = zones[i].max_;
+ }
+
+ if (bestDiff < 0)
+ return f_Center - ((UData_t) (-bestDiff) * f_Step);
+
+ return f_Center + (bestDiff * f_Step);
+}
+
+/****************************************************************************
+**
+** Name: gcd
+**
+** Description: Uses Euclid's algorithm
+**
+** Parameters: u, v - unsigned values whose GCD is desired.
+**
+** Global: None
+**
+** Returns: greatest common divisor of u and v, if either value
+** is 0, the other value is returned as the result.
+**
+** Dependencies: None.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 06-01-2004 JWS Original
+** N/A 08-03-2004 DAD Changed to Euclid's since it can handle
+** unsigned numbers.
+**
+****************************************************************************/
+static UData_t MT2063_gcd(UData_t u, UData_t v)
+{
+ UData_t r;
+
+ while (v != 0) {
+ r = u % v;
+ u = v;
+ v = r;
+ }
+
+ return u;
+}
+
+/****************************************************************************
+**
+** Name: umax
+**
+** Description: Implements a simple maximum function for unsigned numbers.
+** Implemented as a function rather than a macro to avoid
+** multiple evaluation of the calling parameters.
+**
+** Parameters: a, b - Values to be compared
+**
+** Global: None
+**
+** Returns: larger of the input values.
+**
+** Dependencies: None.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 06-02-2004 JWS Original
+**
+****************************************************************************/
+static UData_t MT2063_umax(UData_t a, UData_t b)
+{
+ return (a >= b) ? a : b;
+}
+
+#if MT2063_TUNER_CNT > 1
+static SData_t RoundAwayFromZero(SData_t n, SData_t d)
+{
+ return (n < 0) ? floor(n, d) : ceil(n, d);
+}
+
+/****************************************************************************
+**
+** Name: IsSpurInAdjTunerBand
+**
+** Description: Checks to see if a spur will be present within the IF's
+** bandwidth or near the zero IF.
+** (fIFOut +/- fIFBW/2, -fIFOut +/- fIFBW/2)
+** and
+** (0 +/- fZIFBW/2)
+**
+** ma mb me mf mc md
+** <--+-+-+-----------------+-+-+-----------------+-+-+-->
+** | ^ 0 ^ |
+** ^ b=-fIFOut+fIFBW/2 -b=+fIFOut-fIFBW/2 ^
+** a=-fIFOut-fIFBW/2 -a=+fIFOut+fIFBW/2
+**
+** Note that some equations are doubled to prevent round-off
+** problems when calculating fIFBW/2
+**
+** The spur frequencies are computed as:
+**
+** fSpur = n * f1 - m * f2 - fOffset
+**
+** Parameters: f1 - The 1st local oscillator (LO) frequency
+** of the tuner whose output we are examining
+** f2 - The 1st local oscillator (LO) frequency
+** of the adjacent tuner
+** fOffset - The 2nd local oscillator of the tuner whose
+** output we are examining
+** fIFOut - Output IF center frequency
+** fIFBW - Output IF Bandwidth
+** nMaxH - max # of LO harmonics to search
+** fp - If spur, positive distance to spur-free band edge (returned)
+** fm - If spur, negative distance to spur-free band edge (returned)
+**
+** Returns: 1 if an LO spur would be present, otherwise 0.
+**
+** Dependencies: None.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 01-21-2005 JWS Original, adapted from MT_DoubleConversion.
+** 115 03-23-2007 DAD Fix declaration of spur due to truncation
+** errors.
+** 137 06-18-2007 DAD Ver 1.16: Fix possible divide-by-0 error for
+** multi-tuners that have
+** (delta IF1) > (f_out-f_outbw/2).
+** 177 S 02-26-2008 RSK Ver 1.18: Corrected calculation using LO1 > MAX/2
+** Type casts added to preserve correct sign.
+**
+****************************************************************************/
+static UData_t IsSpurInAdjTunerBand(UData_t bIsMyOutput,
+ UData_t f1,
+ UData_t f2,
+ UData_t fOffset,
+ UData_t fIFOut,
+ UData_t fIFBW,
+ UData_t fZIFBW,
+ UData_t nMaxH, UData_t * fp, UData_t * fm)
+{
+ UData_t bSpurFound = 0;
+
+ const UData_t fHalf_IFBW = fIFBW / 2;
+ const UData_t fHalf_ZIFBW = fZIFBW / 2;
+
+ /* Calculate a scale factor for all frequencies, so that our
+ calculations all stay within 31 bits */
+ const UData_t f_Scale =
+ ((f1 +
+ (fOffset + fIFOut +
+ fHalf_IFBW) / nMaxH) / (MAX_UDATA / 2 / nMaxH)) + 1;
+
+ /*
+ ** After this scaling, _f1, _f2, and _f3 are guaranteed to fit into
+ ** signed data types (smaller than MAX_UDATA/2)
+ */
+ const SData_t _f1 = (SData_t) (f1 / f_Scale);
+ const SData_t _f2 = (SData_t) (f2 / f_Scale);
+ const SData_t _f3 = (SData_t) (fOffset / f_Scale);
+
+ const SData_t c = (SData_t) (fIFOut - fHalf_IFBW) / (SData_t) f_Scale;
+ const SData_t d = (SData_t) ((fIFOut + fHalf_IFBW) / f_Scale);
+ const SData_t f = (SData_t) (fHalf_ZIFBW / f_Scale);
+
+ SData_t ma, mb, mc, md, me, mf;
+
+ SData_t fp_ = 0;
+ SData_t fm_ = 0;
+ SData_t n;
+
+ /*
+ ** If the other tuner does not have an LO frequency defined,
+ ** assume that we cannot interfere with it
+ */
+ if (f2 == 0)
+ return 0;
+
+ /* Check out all multiples of f1 from -nMaxH to +nMaxH */
+ for (n = -(SData_t) nMaxH; n <= (SData_t) nMaxH; ++n) {
+ const SData_t nf1 = n * _f1;
+ md = (_f3 + d - nf1) / _f2;
+
+ /* If # f2 harmonics > nMaxH, then no spurs present */
+ if (md <= -(SData_t) nMaxH)
+ break;
+
+ ma = (_f3 - d - nf1) / _f2;
+ if ((ma == md) || (ma >= (SData_t) (nMaxH)))
+ continue;
+
+ mc = (_f3 + c - nf1) / _f2;
+ if (mc != md) {
+ const SData_t m = (n < 0) ? md : mc;
+ const SData_t fspur = (nf1 + m * _f2 - _f3);
+ const SData_t den = (bIsMyOutput ? n - 1 : n);
+ if (den == 0) {
+ fp_ = (d - fspur) * f_Scale;
+ fm_ = (fspur - c) * f_Scale;
+ } else {
+ fp_ =
+ (SData_t) RoundAwayFromZero((d - fspur) *
+ f_Scale, den);
+ fm_ =
+ (SData_t) RoundAwayFromZero((fspur - c) *
+ f_Scale, den);
+ }
+ if (((UData_t) abs(fm_) >= f_Scale)
+ && ((UData_t) abs(fp_) >= f_Scale)) {
+ bSpurFound = 1;
+ break;
+ }
+ }
+
+ /* Location of Zero-IF-spur to be checked */
+ mf = (_f3 + f - nf1) / _f2;
+ me = (_f3 - f - nf1) / _f2;
+ if (me != mf) {
+ const SData_t m = (n < 0) ? mf : me;
+ const SData_t fspur = (nf1 + m * _f2 - _f3);
+ const SData_t den = (bIsMyOutput ? n - 1 : n);
+ if (den == 0) {
+ fp_ = (d - fspur) * f_Scale;
+ fm_ = (fspur - c) * f_Scale;
+ } else {
+ fp_ =
+ (SData_t) RoundAwayFromZero((f - fspur) *
+ f_Scale, den);
+ fm_ =
+ (SData_t) RoundAwayFromZero((fspur + f) *
+ f_Scale, den);
+ }
+ if (((UData_t) abs(fm_) >= f_Scale)
+ && ((UData_t) abs(fp_) >= f_Scale)) {
+ bSpurFound = 1;
+ break;
+ }
+ }
+
+ mb = (_f3 - c - nf1) / _f2;
+ if (ma != mb) {
+ const SData_t m = (n < 0) ? mb : ma;
+ const SData_t fspur = (nf1 + m * _f2 - _f3);
+ const SData_t den = (bIsMyOutput ? n - 1 : n);
+ if (den == 0) {
+ fp_ = (d - fspur) * f_Scale;
+ fm_ = (fspur - c) * f_Scale;
+ } else {
+ fp_ =
+ (SData_t) RoundAwayFromZero((-c - fspur) *
+ f_Scale, den);
+ fm_ =
+ (SData_t) RoundAwayFromZero((fspur + d) *
+ f_Scale, den);
+ }
+ if (((UData_t) abs(fm_) >= f_Scale)
+ && ((UData_t) abs(fp_) >= f_Scale)) {
+ bSpurFound = 1;
+ break;
+ }
+ }
+ }
+
+ /*
+ ** Verify that fm & fp are both positive
+ ** Add one to ensure next 1st IF choice is not right on the edge
+ */
+ if (fp_ < 0) {
+ *fp = -fm_ + 1;
+ *fm = -fp_ + 1;
+ } else if (fp_ > 0) {
+ *fp = fp_ + 1;
+ *fm = fm_ + 1;
+ } else {
+ *fp = 1;
+ *fm = abs(fm_) + 1;
+ }
+
+ return bSpurFound;
+}
+#endif
+
+/****************************************************************************
+**
+** Name: IsSpurInBand
+**
+** Description: Checks to see if a spur will be present within the IF's
+** bandwidth. (fIFOut +/- fIFBW, -fIFOut +/- fIFBW)
+**
+** ma mb mc md
+** <--+-+-+-------------------+-------------------+-+-+-->
+** | ^ 0 ^ |
+** ^ b=-fIFOut+fIFBW/2 -b=+fIFOut-fIFBW/2 ^
+** a=-fIFOut-fIFBW/2 -a=+fIFOut+fIFBW/2
+**
+** Note that some equations are doubled to prevent round-off
+** problems when calculating fIFBW/2
+**
+** Parameters: pAS_Info - Avoid Spurs information block
+** fm - If spur, amount f_IF1 has to move negative
+** fp - If spur, amount f_IF1 has to move positive
+**
+** Global: None
+**
+** Returns: 1 if an LO spur would be present, otherwise 0.
+**
+** Dependencies: None.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** N/A 11-28-2002 DAD Implemented algorithm from applied patent
+**
+****************************************************************************/
+static UData_t IsSpurInBand(struct MT2063_AvoidSpursData_t *pAS_Info,
+ UData_t * fm, UData_t * fp)
+{
+ /*
+ ** Calculate LO frequency settings.
+ */
+ UData_t n, n0;
+ const UData_t f_LO1 = pAS_Info->f_LO1;
+ const UData_t f_LO2 = pAS_Info->f_LO2;
+ const UData_t d = pAS_Info->f_out + pAS_Info->f_out_bw / 2;
+ const UData_t c = d - pAS_Info->f_out_bw;
+ const UData_t f = pAS_Info->f_zif_bw / 2;
+ const UData_t f_Scale = (f_LO1 / (MAX_UDATA / 2 / pAS_Info->maxH1)) + 1;
+ SData_t f_nsLO1, f_nsLO2;
+ SData_t f_Spur;
+ UData_t ma, mb, mc, md, me, mf;
+ UData_t lo_gcd, gd_Scale, gc_Scale, gf_Scale, hgds, hgfs, hgcs;
+#if MT2063_TUNER_CNT > 1
+ UData_t index;
+
+ struct MT2063_AvoidSpursData_t *adj;
+#endif
+ *fm = 0;
+
+ /*
+ ** For each edge (d, c & f), calculate a scale, based on the gcd
+ ** of f_LO1, f_LO2 and the edge value. Use the larger of this
+ ** gcd-based scale factor or f_Scale.
+ */
+ lo_gcd = MT2063_gcd(f_LO1, f_LO2);
+ gd_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, d), f_Scale);
+ hgds = gd_Scale / 2;
+ gc_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, c), f_Scale);
+ hgcs = gc_Scale / 2;
+ gf_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, f), f_Scale);
+ hgfs = gf_Scale / 2;
+
+ n0 = uceil(f_LO2 - d, f_LO1 - f_LO2);
+
+ /* Check out all multiples of LO1 from n0 to m_maxLOSpurHarmonic */
+ for (n = n0; n <= pAS_Info->maxH1; ++n) {
+ md = (n * ((f_LO1 + hgds) / gd_Scale) -
+ ((d + hgds) / gd_Scale)) / ((f_LO2 + hgds) / gd_Scale);
+
+ /* If # fLO2 harmonics > m_maxLOSpurHarmonic, then no spurs present */
+ if (md >= pAS_Info->maxH1)
+ break;
+
+ ma = (n * ((f_LO1 + hgds) / gd_Scale) +
+ ((d + hgds) / gd_Scale)) / ((f_LO2 + hgds) / gd_Scale);
+
+ /* If no spurs between +/- (f_out + f_IFBW/2), then try next harmonic */
+ if (md == ma)
+ continue;
+
+ mc = (n * ((f_LO1 + hgcs) / gc_Scale) -
+ ((c + hgcs) / gc_Scale)) / ((f_LO2 + hgcs) / gc_Scale);
+ if (mc != md) {
+ f_nsLO1 = (SData_t) (n * (f_LO1 / gc_Scale));
+ f_nsLO2 = (SData_t) (mc * (f_LO2 / gc_Scale));
+ f_Spur =
+ (gc_Scale * (f_nsLO1 - f_nsLO2)) +
+ n * (f_LO1 % gc_Scale) - mc * (f_LO2 % gc_Scale);
+
+ *fp = ((f_Spur - (SData_t) c) / (mc - n)) + 1;
+ *fm = (((SData_t) d - f_Spur) / (mc - n)) + 1;
+ return 1;
+ }
+
+ /* Location of Zero-IF-spur to be checked */
+ me = (n * ((f_LO1 + hgfs) / gf_Scale) +
+ ((f + hgfs) / gf_Scale)) / ((f_LO2 + hgfs) / gf_Scale);
+ mf = (n * ((f_LO1 + hgfs) / gf_Scale) -
+ ((f + hgfs) / gf_Scale)) / ((f_LO2 + hgfs) / gf_Scale);
+ if (me != mf) {
+ f_nsLO1 = n * (f_LO1 / gf_Scale);
+ f_nsLO2 = me * (f_LO2 / gf_Scale);
+ f_Spur =
+ (gf_Scale * (f_nsLO1 - f_nsLO2)) +
+ n * (f_LO1 % gf_Scale) - me * (f_LO2 % gf_Scale);
+
+ *fp = ((f_Spur + (SData_t) f) / (me - n)) + 1;
+ *fm = (((SData_t) f - f_Spur) / (me - n)) + 1;
+ return 1;
+ }
+
+ mb = (n * ((f_LO1 + hgcs) / gc_Scale) +
+ ((c + hgcs) / gc_Scale)) / ((f_LO2 + hgcs) / gc_Scale);
+ if (ma != mb) {
+ f_nsLO1 = n * (f_LO1 / gc_Scale);
+ f_nsLO2 = ma * (f_LO2 / gc_Scale);
+ f_Spur =
+ (gc_Scale * (f_nsLO1 - f_nsLO2)) +
+ n * (f_LO1 % gc_Scale) - ma * (f_LO2 % gc_Scale);
+
+ *fp = (((SData_t) d + f_Spur) / (ma - n)) + 1;
+ *fm = (-(f_Spur + (SData_t) c) / (ma - n)) + 1;
+ return 1;
+ }
+ }
+
+#if MT2063_TUNER_CNT > 1
+ /* If no spur found, see if there are more tuners on the same board */
+ for (index = 0; index < TunerCount; ++index) {
+ adj = TunerList[index];
+ if (pAS_Info == adj) /* skip over our own data, don't process it */
+ continue;
+
+ /* Look for LO-related spurs from the adjacent tuner generated into my IF output */
+ if (IsSpurInAdjTunerBand(1, /* check my IF output */
+ pAS_Info->f_LO1, /* my fLO1 */
+ adj->f_LO1, /* the other tuner's fLO1 */
+ pAS_Info->f_LO2, /* my fLO2 */
+ pAS_Info->f_out, /* my fOut */
+ pAS_Info->f_out_bw, /* my output IF bandwidth */
+ pAS_Info->f_zif_bw, /* my Zero-IF bandwidth */
+ pAS_Info->maxH2, fp, /* minimum amount to move LO's positive */
+ fm)) /* miminum amount to move LO's negative */
+ return 1;
+ /* Look for LO-related spurs from my tuner generated into the adjacent tuner's IF output */
+ if (IsSpurInAdjTunerBand(0, /* check his IF output */
+ pAS_Info->f_LO1, /* my fLO1 */
+ adj->f_LO1, /* the other tuner's fLO1 */
+ adj->f_LO2, /* the other tuner's fLO2 */
+ adj->f_out, /* the other tuner's fOut */
+ adj->f_out_bw, /* the other tuner's output IF bandwidth */
+ pAS_Info->f_zif_bw, /* the other tuner's Zero-IF bandwidth */
+ adj->maxH2, fp, /* minimum amount to move LO's positive */
+ fm)) /* miminum amount to move LO's negative */
+ return 1;
+ }
+#endif
+ /* No spurs found */
+ return 0;
+}
+
+/*****************************************************************************
+**
+** Name: MT_AvoidSpurs
+**
+** Description: Main entry point to avoid spurs.
+** Checks for existing spurs in present LO1, LO2 freqs
+** and if present, chooses spur-free LO1, LO2 combination
+** that tunes the same input/output frequencies.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 096 04-06-2005 DAD Ver 1.11: Fix divide by 0 error if maxH==0.
+**
+*****************************************************************************/
+UData_t MT2063_AvoidSpurs(Handle_t h, struct MT2063_AvoidSpursData_t * pAS_Info)
+{
+ UData_t status = MT2063_OK;
+ UData_t fm, fp; /* restricted range on LO's */
+ pAS_Info->bSpurAvoided = 0;
+ pAS_Info->nSpursFound = 0;
+
+ if (pAS_Info->maxH1 == 0)
+ return MT2063_OK;
+
+ /*
+ ** Avoid LO Generated Spurs
+ **
+ ** Make sure that have no LO-related spurs within the IF output
+ ** bandwidth.
+ **
+ ** If there is an LO spur in this band, start at the current IF1 frequency
+ ** and work out until we find a spur-free frequency or run up against the
+ ** 1st IF SAW band edge. Use temporary copies of fLO1 and fLO2 so that they
+ ** will be unchanged if a spur-free setting is not found.
+ */
+ pAS_Info->bSpurPresent = IsSpurInBand(pAS_Info, &fm, &fp);
+ if (pAS_Info->bSpurPresent) {
+ UData_t zfIF1 = pAS_Info->f_LO1 - pAS_Info->f_in; /* current attempt at a 1st IF */
+ UData_t zfLO1 = pAS_Info->f_LO1; /* current attempt at an LO1 freq */
+ UData_t zfLO2 = pAS_Info->f_LO2; /* current attempt at an LO2 freq */
+ UData_t delta_IF1;
+ UData_t new_IF1;
+
+ /*
+ ** Spur was found, attempt to find a spur-free 1st IF
+ */
+ do {
+ pAS_Info->nSpursFound++;
+
+ /* Raise f_IF1_upper, if needed */
+ MT2063_AddExclZone(pAS_Info, zfIF1 - fm, zfIF1 + fp);
+
+ /* Choose next IF1 that is closest to f_IF1_CENTER */
+ new_IF1 = MT2063_ChooseFirstIF(pAS_Info);
+
+ if (new_IF1 > zfIF1) {
+ pAS_Info->f_LO1 += (new_IF1 - zfIF1);
+ pAS_Info->f_LO2 += (new_IF1 - zfIF1);
+ } else {
+ pAS_Info->f_LO1 -= (zfIF1 - new_IF1);
+ pAS_Info->f_LO2 -= (zfIF1 - new_IF1);
+ }
+ zfIF1 = new_IF1;
+
+ if (zfIF1 > pAS_Info->f_if1_Center)
+ delta_IF1 = zfIF1 - pAS_Info->f_if1_Center;
+ else
+ delta_IF1 = pAS_Info->f_if1_Center - zfIF1;
+ }
+ /*
+ ** Continue while the new 1st IF is still within the 1st IF bandwidth
+ ** and there is a spur in the band (again)
+ */
+ while ((2 * delta_IF1 + pAS_Info->f_out_bw <=
+ pAS_Info->f_if1_bw)
+ && (pAS_Info->bSpurPresent =
+ IsSpurInBand(pAS_Info, &fm, &fp)));
+
+ /*
+ ** Use the LO-spur free values found. If the search went all the way to
+ ** the 1st IF band edge and always found spurs, just leave the original
+ ** choice. It's as "good" as any other.
+ */
+ if (pAS_Info->bSpurPresent == 1) {
+ status |= MT2063_SPUR_PRESENT_ERR;
+ pAS_Info->f_LO1 = zfLO1;
+ pAS_Info->f_LO2 = zfLO2;
+ } else
+ pAS_Info->bSpurAvoided = 1;
+ }
+
+ status |=
+ ((pAS_Info->
+ nSpursFound << MT2063_SPUR_SHIFT) & MT2063_SPUR_CNT_MASK);
+
+ return (status);
+}
+
+UData_t MT2063_AvoidSpursVersion(void)
+{
+ return (MT2063_SPUR_VERSION);
+}
+
+//end of mt2063_spuravoid.c
+//=================================================================
+//#################################################################
+//=================================================================
+
+/*
+** The expected version of MT_AvoidSpursData_t
+** If the version is different, an updated file is needed from Microtune
+*/
+/* Expecting version 1.21 of the Spur Avoidance API */
+#define EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION 010201
+
+#if MT2063_AVOID_SPURS_INFO_VERSION < EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION
+#error Contact Microtune for a newer version of MT_SpurAvoid.c
+#elif MT2063_AVOID_SPURS_INFO_VERSION > EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION
+#error Contact Microtune for a newer version of mt2063.c
+#endif
+
+#ifndef MT2063_CNT
+#error You must define MT2063_CNT in the "mt_userdef.h" file
+#endif
+
+typedef enum {
+ MT2063_SET_ATTEN,
+ MT2063_INCR_ATTEN,
+ MT2063_DECR_ATTEN
+} MT2063_ATTEN_CNTL_MODE;
+
+//#define TUNER_MT2063_OPTIMIZATION
+/*
+** Constants used by the tuning algorithm
+*/
+#define MT2063_REF_FREQ (16000000UL) /* Reference oscillator Frequency (in Hz) */
+#define MT2063_IF1_BW (22000000UL) /* The IF1 filter bandwidth (in Hz) */
+#define MT2063_TUNE_STEP_SIZE (50000UL) /* Tune in steps of 50 kHz */
+#define MT2063_SPUR_STEP_HZ (250000UL) /* Step size (in Hz) to move IF1 when avoiding spurs */
+#define MT2063_ZIF_BW (2000000UL) /* Zero-IF spur-free bandwidth (in Hz) */
+#define MT2063_MAX_HARMONICS_1 (15UL) /* Highest intra-tuner LO Spur Harmonic to be avoided */
+#define MT2063_MAX_HARMONICS_2 (5UL) /* Highest inter-tuner LO Spur Harmonic to be avoided */
+#define MT2063_MIN_LO_SEP (1000000UL) /* Minimum inter-tuner LO frequency separation */
+#define MT2063_LO1_FRACN_AVOID (0UL) /* LO1 FracN numerator avoid region (in Hz) */
+#define MT2063_LO2_FRACN_AVOID (199999UL) /* LO2 FracN numerator avoid region (in Hz) */
+#define MT2063_MIN_FIN_FREQ (44000000UL) /* Minimum input frequency (in Hz) */
+#define MT2063_MAX_FIN_FREQ (1100000000UL) /* Maximum input frequency (in Hz) */
+#define MT2063_MIN_FOUT_FREQ (36000000UL) /* Minimum output frequency (in Hz) */
+#define MT2063_MAX_FOUT_FREQ (57000000UL) /* Maximum output frequency (in Hz) */
+#define MT2063_MIN_DNC_FREQ (1293000000UL) /* Minimum LO2 frequency (in Hz) */
+#define MT2063_MAX_DNC_FREQ (1614000000UL) /* Maximum LO2 frequency (in Hz) */
+#define MT2063_MIN_UPC_FREQ (1396000000UL) /* Minimum LO1 frequency (in Hz) */
+#define MT2063_MAX_UPC_FREQ (2750000000UL) /* Maximum LO1 frequency (in Hz) */
+
+/*
+** Define the supported Part/Rev codes for the MT2063
+*/
+#define MT2063_B0 (0x9B)
+#define MT2063_B1 (0x9C)
+#define MT2063_B2 (0x9D)
+#define MT2063_B3 (0x9E)
+
+/*
+** The number of Tuner Registers
+*/
+static const UData_t MT2063_Num_Registers = MT2063_REG_END_REGS;
+
+#define USE_GLOBAL_TUNER 0
+
+static UData_t nMT2063MaxTuners = MT2063_CNT;
+static struct MT2063_Info_t MT2063_Info[MT2063_CNT];
+static struct MT2063_Info_t *MT2063_Avail[MT2063_CNT];
+static UData_t nMT2063OpenTuners = 0;
+
+/*
+** Constants for setting receiver modes.
+** (6 modes defined at this time, enumerated by MT2063_RCVR_MODES)
+** (DNC1GC & DNC2GC are the values, which are used, when the specific
+** DNC Output is selected, the other is always off)
+**
+** If PAL-L or L' is received, set:
+** MT2063_SetParam(hMT2063,MT2063_TAGC,1);
+**
+** --------------+----------------------------------------------
+** Mode 0 : | MT2063_CABLE_QAM
+** Mode 1 : | MT2063_CABLE_ANALOG
+** Mode 2 : | MT2063_OFFAIR_COFDM
+** Mode 3 : | MT2063_OFFAIR_COFDM_SAWLESS
+** Mode 4 : | MT2063_OFFAIR_ANALOG
+** Mode 5 : | MT2063_OFFAIR_8VSB
+** --------------+----+----+----+----+-----+-----+--------------
+** Mode | 0 | 1 | 2 | 3 | 4 | 5 |
+** --------------+----+----+----+----+-----+-----+
+**
+**
+*/
+static const U8Data RFAGCEN[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data LNARIN[] = { 0, 0, 3, 3, 3, 3 };
+static const U8Data FIFFQEN[] = { 1, 1, 1, 1, 1, 1 };
+static const U8Data FIFFQ[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data DNC1GC[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data DNC2GC[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data ACLNAMAX[] = { 31, 31, 31, 31, 31, 31 };
+static const U8Data LNATGT[] = { 44, 43, 43, 43, 43, 43 };
+static const U8Data RFOVDIS[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data ACRFMAX[] = { 31, 31, 31, 31, 31, 31 };
+static const U8Data PD1TGT[] = { 36, 36, 38, 38, 36, 38 };
+static const U8Data FIFOVDIS[] = { 0, 0, 0, 0, 0, 0 };
+static const U8Data ACFIFMAX[] = { 29, 29, 29, 29, 29, 29 };
+static const U8Data PD2TGT[] = { 40, 33, 38, 42, 30, 38 };
+
+/*
+** Local Function Prototypes - not available for external access.
+*/
+
+/* Forward declaration(s): */
+static UData_t MT2063_CalcLO1Mult(UData_t * Div, UData_t * FracN, UData_t f_LO,
+ UData_t f_LO_Step, UData_t f_Ref);
+static UData_t MT2063_CalcLO2Mult(UData_t * Div, UData_t * FracN, UData_t f_LO,
+ UData_t f_LO_Step, UData_t f_Ref);
+static UData_t MT2063_fLO_FractionalTerm(UData_t f_ref, UData_t num,
+ UData_t denom);
+
+/******************************************************************************
+**
+** Name: MT2063_Open
+**
+** Description: Initialize the tuner's register values.
+**
+** Parameters: MT2063_Addr - Serial bus address of the tuner.
+** hMT2063 - Tuner handle passed back.
+** hUserData - User-defined data, if needed for the
+** MT_ReadSub() & MT_WriteSub functions.
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
+** MT_TUNER_INIT_ERR - Tuner initialization failed
+** MT_COMM_ERR - Serial bus communications error
+** MT_ARG_NULL - Null pointer argument passed
+** MT_TUNER_CNT_ERR - Too many tuners open
+**
+** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
+** MT_WriteSub - Write byte(s) of data to the two-wire bus
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+******************************************************************************/
+UData_t MT2063_Open(UData_t MT2063_Addr, Handle_t * hMT2063, Handle_t hUserData)
+{
+ UData_t status = MT2063_OK; /* Status to be returned. */
+ SData_t i;
+ struct MT2063_Info_t *pInfo = NULL;
+ struct dvb_frontend *fe = (struct dvb_frontend *)hUserData;
+ struct mt2063_state *state = fe->tuner_priv;
+
+ /* Check the argument before using */
+ if (hMT2063 == NULL) {
+ return MT2063_ARG_NULL;
+ }
+
+ /* Default tuner handle to NULL. If successful, it will be reassigned */
+
+#if USE_GLOBAL_TUNER
+ *hMT2063 = NULL;
+
+ /*
+ ** If this is our first tuner, initialize the address fields and
+ ** the list of available control blocks.
+ */
+ if (nMT2063OpenTuners == 0) {
+ for (i = MT2063_CNT - 1; i >= 0; i--) {
+ MT2063_Info[i].handle = NULL;
+ MT2063_Info[i].address = MAX_UDATA;
+ MT2063_Info[i].rcvr_mode = MT2063_CABLE_QAM;
+ MT2063_Info[i].hUserData = NULL;
+ MT2063_Avail[i] = &MT2063_Info[i];
+ }
+ }
+
+ /*
+ ** Look for an existing MT2063_State_t entry with this address.
+ */
+ for (i = MT2063_CNT - 1; i >= 0; i--) {
+ /*
+ ** If an open'ed handle provided, we'll re-initialize that structure.
+ **
+ ** We recognize an open tuner because the address and hUserData are
+ ** the same as one that has already been opened
+ */
+ if ((MT2063_Info[i].address == MT2063_Addr) &&
+ (MT2063_Info[i].hUserData == hUserData)) {
+ pInfo = &MT2063_Info[i];
+ break;
+ }
+ }
+
+ /* If not found, choose an empty spot. */
+ if (pInfo == NULL) {
+ /* Check to see that we're not over-allocating */
+ if (nMT2063OpenTuners == MT2063_CNT) {
+ return MT2063_TUNER_CNT_ERR;
+ }
+ /* Use the next available block from the list */
+ pInfo = MT2063_Avail[nMT2063OpenTuners];
+ nMT2063OpenTuners++;
+ }
+#else
+ if (state->MT2063_init == FALSE) {
+ pInfo = kzalloc(sizeof(struct MT2063_Info_t), GFP_KERNEL);
+ if (pInfo == NULL) {
+ return MT2063_TUNER_OPEN_ERR;
+ }
+ pInfo->handle = NULL;
+ pInfo->address = MAX_UDATA;
+ pInfo->rcvr_mode = MT2063_CABLE_QAM;
+ pInfo->hUserData = NULL;
+ } else {
+ pInfo = *hMT2063;
+ }
+#endif
+
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_RegisterTuner(&pInfo->AS_Data);
+ }
+
+ if (MT2063_NO_ERROR(status)) {
+ pInfo->handle = (Handle_t) pInfo;
+
+ pInfo->hUserData = hUserData;
+ pInfo->address = MT2063_Addr;
+ pInfo->rcvr_mode = MT2063_CABLE_QAM;
+ status |= MT2063_ReInit((Handle_t) pInfo);
+ }
+
+ if (MT2063_IS_ERROR(status))
+ /* MT2063_Close handles the un-registration of the tuner */
+ MT2063_Close((Handle_t) pInfo);
+ else {
+ state->MT2063_init = TRUE;
+ *hMT2063 = pInfo->handle;
+
+ }
+
+ return (status);
+}
+
+static UData_t MT2063_IsValidHandle(struct MT2063_Info_t *handle)
+{
+ return ((handle != NULL) && (handle->handle == handle)) ? 1 : 0;
+}
+
+/******************************************************************************
+**
+** Name: MT2063_Close
+**
+** Description: Release the handle to the tuner.
+**
+** Parameters: hMT2063 - Handle to the MT2063 tuner
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+**
+** Dependencies: mt_errordef.h - definition of error codes
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+******************************************************************************/
+UData_t MT2063_Close(Handle_t hMT2063)
+{
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)hMT2063;
+
+ if (!MT2063_IsValidHandle(pInfo))
+ return MT2063_INV_HANDLE;
+
+ /* Unregister tuner with SpurAvoidance routines (if needed) */
+ MT2063_UnRegisterTuner(&pInfo->AS_Data);
+ /* Now remove the tuner from our own list of tuners */
+ pInfo->handle = NULL;
+ pInfo->address = MAX_UDATA;
+ pInfo->hUserData = NULL;
+#if USE_GLOBAL_TUNER
+ nMT2063OpenTuners--;
+ MT2063_Avail[nMT2063OpenTuners] = pInfo; /* Return control block to available list */
+#else
+ //kfree(pInfo);
+ //pInfo = NULL;
+#endif
+ return MT2063_OK;
+}
+
+/******************************************************************************
+**
+** Name: MT2063_GetGPIO
+**
+** Description: Get the current MT2063 GPIO value.
+**
+** Parameters: h - Open handle to the tuner (from MT2063_Open).
+** gpio_id - Selects GPIO0, GPIO1 or GPIO2
+** attr - Selects input readback, I/O direction or
+** output value
+** *value - current setting of GPIO pin
+**
+** Usage: status = MT2063_GetGPIO(hMT2063, MT2063_GPIO_OUT, &value);
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+**
+** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+******************************************************************************/
+UData_t MT2063_GetGPIO(Handle_t h, enum MT2063_GPIO_ID gpio_id,
+ enum MT2063_GPIO_Attr attr, UData_t * value)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ U8Data regno;
+ SData_t shift;
+ static U8Data GPIOreg[3] =
+ { MT2063_REG_RF_STATUS, MT2063_REG_FIF_OV, MT2063_REG_RF_OV };
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ return MT2063_INV_HANDLE;
+
+ if (value == NULL)
+ return MT2063_ARG_NULL;
+
+ regno = GPIOreg[attr];
+
+ /* We'll read the register just in case the write didn't work last time */
+ status =
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address, regno,
+ &pInfo->reg[regno], 1);
+
+ shift = (gpio_id - MT2063_GPIO0 + 5);
+ *value = (pInfo->reg[regno] >> shift) & 1;
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_GetLocked
+**
+** Description: Checks to see if LO1 and LO2 are locked.
+**
+** Parameters: h - Open handle to the tuner (from MT2063_Open).
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_UPC_UNLOCK - Upconverter PLL unlocked
+** MT_DNC_UNLOCK - Downconverter PLL unlocked
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+**
+** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus
+** MT_Sleep - Delay execution for x milliseconds
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_GetLocked(Handle_t h)
+{
+ const UData_t nMaxWait = 100; /* wait a maximum of 100 msec */
+ const UData_t nPollRate = 2; /* poll status bits every 2 ms */
+ const UData_t nMaxLoops = nMaxWait / nPollRate;
+ const U8Data LO1LK = 0x80;
+ U8Data LO2LK = 0x08;
+ UData_t status = MT2063_OK; /* Status to be returned */
+ UData_t nDelays = 0;
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ return MT2063_INV_HANDLE;
+
+ /* LO2 Lock bit was in a different place for B0 version */
+ if (pInfo->tuner_id == MT2063_B0)
+ LO2LK = 0x40;
+
+ do {
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_LO_STATUS,
+ &pInfo->reg[MT2063_REG_LO_STATUS], 1);
+
+ if (MT2063_IS_ERROR(status))
+ return (status);
+
+ if ((pInfo->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) ==
+ (LO1LK | LO2LK)) {
+ return (status);
+ }
+ MT2063_Sleep(pInfo->hUserData, nPollRate); /* Wait between retries */
+ }
+ while (++nDelays < nMaxLoops);
+
+ if ((pInfo->reg[MT2063_REG_LO_STATUS] & LO1LK) == 0x00)
+ status |= MT2063_UPC_UNLOCK;
+ if ((pInfo->reg[MT2063_REG_LO_STATUS] & LO2LK) == 0x00)
+ status |= MT2063_DNC_UNLOCK;
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_GetParam
+**
+** Description: Gets a tuning algorithm parameter.
+**
+** This function provides access to the internals of the
+** tuning algorithm - mostly for testing purposes.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** param - Tuning algorithm parameter
+** (see enum MT2063_Param)
+** pValue - ptr to returned value
+**
+** param Description
+** ---------------------- --------------------------------
+** MT2063_IC_ADDR Serial Bus address of this tuner
+** MT2063_MAX_OPEN Max # of MT2063's allowed open
+** MT2063_NUM_OPEN # of MT2063's open
+** MT2063_SRO_FREQ crystal frequency
+** MT2063_STEPSIZE minimum tuning step size
+** MT2063_INPUT_FREQ input center frequency
+** MT2063_LO1_FREQ LO1 Frequency
+** MT2063_LO1_STEPSIZE LO1 minimum step size
+** MT2063_LO1_FRACN_AVOID LO1 FracN keep-out region
+** MT2063_IF1_ACTUAL Current 1st IF in use
+** MT2063_IF1_REQUEST Requested 1st IF
+** MT2063_IF1_CENTER Center of 1st IF SAW filter
+** MT2063_IF1_BW Bandwidth of 1st IF SAW filter
+** MT2063_ZIF_BW zero-IF bandwidth
+** MT2063_LO2_FREQ LO2 Frequency
+** MT2063_LO2_STEPSIZE LO2 minimum step size
+** MT2063_LO2_FRACN_AVOID LO2 FracN keep-out region
+** MT2063_OUTPUT_FREQ output center frequency
+** MT2063_OUTPUT_BW output bandwidth
+** MT2063_LO_SEPARATION min inter-tuner LO separation
+** MT2063_AS_ALG ID of avoid-spurs algorithm in use
+** MT2063_MAX_HARM1 max # of intra-tuner harmonics
+** MT2063_MAX_HARM2 max # of inter-tuner harmonics
+** MT2063_EXCL_ZONES # of 1st IF exclusion zones
+** MT2063_NUM_SPURS # of spurs found/avoided
+** MT2063_SPUR_AVOIDED >0 spurs avoided
+** MT2063_SPUR_PRESENT >0 spurs in output (mathematically)
+** MT2063_RCVR_MODE Predefined modes.
+** MT2063_ACLNA LNA attenuator gain code
+** MT2063_ACRF RF attenuator gain code
+** MT2063_ACFIF FIF attenuator gain code
+** MT2063_ACLNA_MAX LNA attenuator limit
+** MT2063_ACRF_MAX RF attenuator limit
+** MT2063_ACFIF_MAX FIF attenuator limit
+** MT2063_PD1 Actual value of PD1
+** MT2063_PD2 Actual value of PD2
+** MT2063_DNC_OUTPUT_ENABLE DNC output selection
+** MT2063_VGAGC VGA gain code
+** MT2063_VGAOI VGA output current
+** MT2063_TAGC TAGC setting
+** MT2063_AMPGC AMP gain code
+** MT2063_AVOID_DECT Avoid DECT Frequencies
+** MT2063_CTFILT_SW Cleartune filter selection
+**
+** Usage: status |= MT2063_GetParam(hMT2063,
+** MT2063_IF1_ACTUAL,
+** &f_IF1_Actual);
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+** MT_ARG_RANGE - Invalid parameter requested
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** See Also: MT2063_SetParam, MT2063_Open
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 154 09-13-2007 RSK Ver 1.05: Get/SetParam changes for LOx_FREQ
+** 10-31-2007 PINZ Ver 1.08: Get/SetParam add VGAGC, VGAOI, AMPGC, TAGC
+** 173 M 01-23-2008 RSK Ver 1.12: Read LO1C and LO2C registers from HW
+** in GetParam.
+** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT
+** Split SetParam up to ACLNA / ACLNA_MAX
+** removed ACLNA_INRC/DECR (+RF & FIF)
+** removed GCUAUTO / BYPATNDN/UP
+** 175 I 16-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.
+** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.
+** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW
+**
+****************************************************************************/
+UData_t MT2063_GetParam(Handle_t h, enum MT2063_Param param, UData_t * pValue)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+ UData_t Div;
+ UData_t Num;
+
+ if (pValue == NULL)
+ status |= MT2063_ARG_NULL;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status |= MT2063_INV_HANDLE;
+
+ if (MT2063_NO_ERROR(status)) {
+ switch (param) {
+ /* Serial Bus address of this tuner */
+ case MT2063_IC_ADDR:
+ *pValue = pInfo->address;
+ break;
+
+ /* Max # of MT2063's allowed to be open */
+ case MT2063_MAX_OPEN:
+ *pValue = nMT2063MaxTuners;
+ break;
+
+ /* # of MT2063's open */
+ case MT2063_NUM_OPEN:
+ *pValue = nMT2063OpenTuners;
+ break;
+
+ /* crystal frequency */
+ case MT2063_SRO_FREQ:
+ *pValue = pInfo->AS_Data.f_ref;
+ break;
+
+ /* minimum tuning step size */
+ case MT2063_STEPSIZE:
+ *pValue = pInfo->AS_Data.f_LO2_Step;
+ break;
+
+ /* input center frequency */
+ case MT2063_INPUT_FREQ:
+ *pValue = pInfo->AS_Data.f_in;
+ break;
+
+ /* LO1 Frequency */
+ case MT2063_LO1_FREQ:
+ {
+ /* read the actual tuner register values for LO1C_1 and LO1C_2 */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1C_1,
+ &pInfo->
+ reg[MT2063_REG_LO1C_1], 2);
+ Div = pInfo->reg[MT2063_REG_LO1C_1];
+ Num = pInfo->reg[MT2063_REG_LO1C_2] & 0x3F;
+ pInfo->AS_Data.f_LO1 =
+ (pInfo->AS_Data.f_ref * Div) +
+ MT2063_fLO_FractionalTerm(pInfo->AS_Data.
+ f_ref, Num, 64);
+ }
+ *pValue = pInfo->AS_Data.f_LO1;
+ break;
+
+ /* LO1 minimum step size */
+ case MT2063_LO1_STEPSIZE:
+ *pValue = pInfo->AS_Data.f_LO1_Step;
+ break;
+
+ /* LO1 FracN keep-out region */
+ case MT2063_LO1_FRACN_AVOID_PARAM:
+ *pValue = pInfo->AS_Data.f_LO1_FracN_Avoid;
+ break;
+
+ /* Current 1st IF in use */
+ case MT2063_IF1_ACTUAL:
+ *pValue = pInfo->f_IF1_actual;
+ break;
+
+ /* Requested 1st IF */
+ case MT2063_IF1_REQUEST:
+ *pValue = pInfo->AS_Data.f_if1_Request;
+ break;
+
+ /* Center of 1st IF SAW filter */
+ case MT2063_IF1_CENTER:
+ *pValue = pInfo->AS_Data.f_if1_Center;
+ break;
+
+ /* Bandwidth of 1st IF SAW filter */
+ case MT2063_IF1_BW:
+ *pValue = pInfo->AS_Data.f_if1_bw;
+ break;
+
+ /* zero-IF bandwidth */
+ case MT2063_ZIF_BW:
+ *pValue = pInfo->AS_Data.f_zif_bw;
+ break;
+
+ /* LO2 Frequency */
+ case MT2063_LO2_FREQ:
+ {
+ /* Read the actual tuner register values for LO2C_1, LO2C_2 and LO2C_3 */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2C_1,
+ &pInfo->
+ reg[MT2063_REG_LO2C_1], 3);
+ Div =
+ (pInfo->reg[MT2063_REG_LO2C_1] & 0xFE) >> 1;
+ Num =
+ ((pInfo->
+ reg[MT2063_REG_LO2C_1] & 0x01) << 12) |
+ (pInfo->
+ reg[MT2063_REG_LO2C_2] << 4) | (pInfo->
+ reg
+ [MT2063_REG_LO2C_3]
+ & 0x00F);
+ pInfo->AS_Data.f_LO2 =
+ (pInfo->AS_Data.f_ref * Div) +
+ MT2063_fLO_FractionalTerm(pInfo->AS_Data.
+ f_ref, Num, 8191);
+ }
+ *pValue = pInfo->AS_Data.f_LO2;
+ break;
+
+ /* LO2 minimum step size */
+ case MT2063_LO2_STEPSIZE:
+ *pValue = pInfo->AS_Data.f_LO2_Step;
+ break;
+
+ /* LO2 FracN keep-out region */
+ case MT2063_LO2_FRACN_AVOID:
+ *pValue = pInfo->AS_Data.f_LO2_FracN_Avoid;
+ break;
+
+ /* output center frequency */
+ case MT2063_OUTPUT_FREQ:
+ *pValue = pInfo->AS_Data.f_out;
+ break;
+
+ /* output bandwidth */
+ case MT2063_OUTPUT_BW:
+ *pValue = pInfo->AS_Data.f_out_bw - 750000;
+ break;
+
+ /* min inter-tuner LO separation */
+ case MT2063_LO_SEPARATION:
+ *pValue = pInfo->AS_Data.f_min_LO_Separation;
+ break;
+
+ /* ID of avoid-spurs algorithm in use */
+ case MT2063_AS_ALG:
+ *pValue = pInfo->AS_Data.nAS_Algorithm;
+ break;
+
+ /* max # of intra-tuner harmonics */
+ case MT2063_MAX_HARM1:
+ *pValue = pInfo->AS_Data.maxH1;
+ break;
+
+ /* max # of inter-tuner harmonics */
+ case MT2063_MAX_HARM2:
+ *pValue = pInfo->AS_Data.maxH2;
+ break;
+
+ /* # of 1st IF exclusion zones */
+ case MT2063_EXCL_ZONES:
+ *pValue = pInfo->AS_Data.nZones;
+ break;
+
+ /* # of spurs found/avoided */
+ case MT2063_NUM_SPURS:
+ *pValue = pInfo->AS_Data.nSpursFound;
+ break;
+
+ /* >0 spurs avoided */
+ case MT2063_SPUR_AVOIDED:
+ *pValue = pInfo->AS_Data.bSpurAvoided;
+ break;
+
+ /* >0 spurs in output (mathematically) */
+ case MT2063_SPUR_PRESENT:
+ *pValue = pInfo->AS_Data.bSpurPresent;
+ break;
+
+ /* Predefined receiver setup combination */
+ case MT2063_RCVR_MODE:
+ *pValue = pInfo->rcvr_mode;
+ break;
+
+ case MT2063_PD1:
+ case MT2063_PD2:
+ {
+ U8Data mask = (param == MT2063_PD1 ? 0x01 : 0x03); /* PD1 vs PD2 */
+ U8Data orig = (pInfo->reg[MT2063_REG_BYP_CTRL]);
+ U8Data reg = (orig & 0xF1) | mask; /* Only set 3 bits (not 5) */
+ int i;
+
+ *pValue = 0;
+
+ /* Initiate ADC output to reg 0x0A */
+ if (reg != orig)
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_BYP_CTRL,
+ ®, 1);
+
+ if (MT2063_IS_ERROR(status))
+ return (status);
+
+ for (i = 0; i < 8; i++) {
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_ADC_OUT,
+ &pInfo->
+ reg
+ [MT2063_REG_ADC_OUT],
+ 1);
+
+ if (MT2063_NO_ERROR(status))
+ *pValue +=
+ pInfo->
+ reg[MT2063_REG_ADC_OUT];
+ else {
+ if (i)
+ *pValue /= i;
+ return (status);
+ }
+ }
+ *pValue /= 8; /* divide by number of reads */
+ *pValue >>= 2; /* only want 6 MSB's out of 8 */
+
+ /* Restore value of Register BYP_CTRL */
+ if (reg != orig)
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_BYP_CTRL,
+ &orig, 1);
+ }
+ break;
+
+ /* Get LNA attenuator code */
+ case MT2063_ACLNA:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_XO_STATUS,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get RF attenuator code */
+ case MT2063_ACRF:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_RF_STATUS,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get FIF attenuator code */
+ case MT2063_ACFIF:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_FIF_STATUS,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get LNA attenuator limit */
+ case MT2063_ACLNA_MAX:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_LNA_OV,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get RF attenuator limit */
+ case MT2063_ACRF_MAX:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_RF_OV,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get FIF attenuator limit */
+ case MT2063_ACFIF_MAX:
+ {
+ U8Data val;
+ status |=
+ MT2063_GetReg(pInfo, MT2063_REG_FIF_OV,
+ &val);
+ *pValue = val & 0x1f;
+ }
+ break;
+
+ /* Get current used DNC output */
+ case MT2063_DNC_OUTPUT_ENABLE:
+ {
+ if ((pInfo->reg[MT2063_REG_DNC_GAIN] & 0x03) == 0x03) { /* if DNC1 is off */
+ if ((pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03) /* if DNC2 is off */
+ *pValue =
+ (UData_t) MT2063_DNC_NONE;
+ else
+ *pValue =
+ (UData_t) MT2063_DNC_2;
+ } else { /* DNC1 is on */
+
+ if ((pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03) /* if DNC2 is off */
+ *pValue =
+ (UData_t) MT2063_DNC_1;
+ else
+ *pValue =
+ (UData_t) MT2063_DNC_BOTH;
+ }
+ }
+ break;
+
+ /* Get VGA Gain Code */
+ case MT2063_VGAGC:
+ *pValue =
+ ((pInfo->reg[MT2063_REG_VGA_GAIN] & 0x0C) >> 2);
+ break;
+
+ /* Get VGA bias current */
+ case MT2063_VGAOI:
+ *pValue = (pInfo->reg[MT2063_REG_RSVD_31] & 0x07);
+ break;
+
+ /* Get TAGC setting */
+ case MT2063_TAGC:
+ *pValue = (pInfo->reg[MT2063_REG_RSVD_1E] & 0x03);
+ break;
+
+ /* Get AMP Gain Code */
+ case MT2063_AMPGC:
+ *pValue = (pInfo->reg[MT2063_REG_TEMP_SEL] & 0x03);
+ break;
+
+ /* Avoid DECT Frequencies */
+ case MT2063_AVOID_DECT:
+ *pValue = pInfo->AS_Data.avoidDECT;
+ break;
+
+ /* Cleartune filter selection: 0 - by IC (default), 1 - by software */
+ case MT2063_CTFILT_SW:
+ *pValue = pInfo->ctfilt_sw;
+ break;
+
+ case MT2063_EOP:
+ default:
+ status |= MT2063_ARG_RANGE;
+ }
+ }
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_GetReg
+**
+** Description: Gets an MT2063 register.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** reg - MT2063 register/subaddress location
+** *val - MT2063 register/subaddress value
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+** MT_ARG_RANGE - Argument out of range
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Use this function if you need to read a register from
+** the MT2063.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_GetReg(Handle_t h, U8Data reg, U8Data * val)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status |= MT2063_INV_HANDLE;
+
+ if (val == NULL)
+ status |= MT2063_ARG_NULL;
+
+ if (reg >= MT2063_REG_END_REGS)
+ status |= MT2063_ARG_RANGE;
+
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address, reg,
+ &pInfo->reg[reg], 1);
+ if (MT2063_NO_ERROR(status))
+ *val = pInfo->reg[reg];
+ }
+
+ return (status);
+}
+
+/******************************************************************************
+**
+** Name: MT2063_GetTemp
+**
+** Description: Get the MT2063 Temperature register.
+**
+** Parameters: h - Open handle to the tuner (from MT2063_Open).
+** *value - value read from the register
+**
+** Binary
+** Value Returned Value Approx Temp
+** ---------------------------------------------
+** MT2063_T_0C 0000 0C
+** MT2063_T_10C 0001 10C
+** MT2063_T_20C 0010 20C
+** MT2063_T_30C 0011 30C
+** MT2063_T_40C 0100 40C
+** MT2063_T_50C 0101 50C
+** MT2063_T_60C 0110 60C
+** MT2063_T_70C 0111 70C
+** MT2063_T_80C 1000 80C
+** MT2063_T_90C 1001 90C
+** MT2063_T_100C 1010 100C
+** MT2063_T_110C 1011 110C
+** MT2063_T_120C 1100 120C
+** MT2063_T_130C 1101 130C
+** MT2063_T_140C 1110 140C
+** MT2063_T_150C 1111 150C
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+** MT_ARG_RANGE - Argument out of range
+**
+** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
+** MT_WriteSub - Write byte(s) of data to the two-wire bus
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+******************************************************************************/
+UData_t MT2063_GetTemp(Handle_t h, enum MT2063_Temperature * value)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ return MT2063_INV_HANDLE;
+
+ if (value == NULL)
+ return MT2063_ARG_NULL;
+
+ if ((MT2063_NO_ERROR(status))
+ && ((pInfo->reg[MT2063_REG_TEMP_SEL] & 0xE0) != 0x00)) {
+ pInfo->reg[MT2063_REG_TEMP_SEL] &= (0x1F);
+ status |= MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_TEMP_SEL,
+ &pInfo->reg[MT2063_REG_TEMP_SEL], 1);
+ }
+
+ if (MT2063_NO_ERROR(status))
+ status |= MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_TEMP_STATUS,
+ &pInfo->reg[MT2063_REG_TEMP_STATUS],
+ 1);
+
+ if (MT2063_NO_ERROR(status))
+ *value =
+ (enum MT2063_Temperature)(pInfo->
+ reg[MT2063_REG_TEMP_STATUS] >> 4);
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_GetUserData
+**
+** Description: Gets the user-defined data item.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** The hUserData parameter is a user-specific argument
+** that is stored internally with the other tuner-
+** specific information.
+**
+** For example, if additional arguments are needed
+** for the user to identify the device communicating
+** with the tuner, this argument can be used to supply
+** the necessary information.
+**
+** The hUserData parameter is initialized in the tuner's
+** Open function to NULL.
+**
+** See Also: MT2063_Open
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_GetUserData(Handle_t h, Handle_t * hUserData)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+
+ if (hUserData == NULL)
+ status |= MT2063_ARG_NULL;
+
+ if (MT2063_NO_ERROR(status))
+ *hUserData = pInfo->hUserData;
+
+ return (status);
+}
+
+/******************************************************************************
+**
+** Name: MT2063_SetReceiverMode
+**
+** Description: Set the MT2063 receiver mode
+**
+** --------------+----------------------------------------------
+** Mode 0 : | MT2063_CABLE_QAM
+** Mode 1 : | MT2063_CABLE_ANALOG
+** Mode 2 : | MT2063_OFFAIR_COFDM
+** Mode 3 : | MT2063_OFFAIR_COFDM_SAWLESS
+** Mode 4 : | MT2063_OFFAIR_ANALOG
+** Mode 5 : | MT2063_OFFAIR_8VSB
+** --------------+----+----+----+----+-----+--------------------
+** (DNC1GC & DNC2GC are the values, which are used, when the specific
+** DNC Output is selected, the other is always off)
+**
+** |<---------- Mode -------------->|
+** Reg Field | 0 | 1 | 2 | 3 | 4 | 5 |
+** ------------+-----+-----+-----+-----+-----+-----+
+** RFAGCen | OFF | OFF | OFF | OFF | OFF | OFF
+** LNARin | 0 | 0 | 3 | 3 | 3 | 3
+** FIFFQen | 1 | 1 | 1 | 1 | 1 | 1
+** FIFFq | 0 | 0 | 0 | 0 | 0 | 0
+** DNC1gc | 0 | 0 | 0 | 0 | 0 | 0
+** DNC2gc | 0 | 0 | 0 | 0 | 0 | 0
+** GCU Auto | 1 | 1 | 1 | 1 | 1 | 1
+** LNA max Atn | 31 | 31 | 31 | 31 | 31 | 31
+** LNA Target | 44 | 43 | 43 | 43 | 43 | 43
+** ign RF Ovl | 0 | 0 | 0 | 0 | 0 | 0
+** RF max Atn | 31 | 31 | 31 | 31 | 31 | 31
+** PD1 Target | 36 | 36 | 38 | 38 | 36 | 38
+** ign FIF Ovl | 0 | 0 | 0 | 0 | 0 | 0
+** FIF max Atn | 5 | 5 | 5 | 5 | 5 | 5
+** PD2 Target | 40 | 33 | 42 | 42 | 33 | 42
+**
+**
+** Parameters: pInfo - ptr to MT2063_Info_t structure
+** Mode - desired reciever mode
+**
+** Usage: status = MT2063_SetReceiverMode(hMT2063, Mode);
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: MT2063_SetReg - Write a byte of data to a HW register.
+** Assumes that the tuner cache is valid.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** N/A 01-10-2007 PINZ Added additional GCU Settings, FIFF Calib will be triggered
+** 155 10-01-2007 DAD Ver 1.06: Add receiver mode for SECAM positive
+** modulation
+** (MT2063_ANALOG_TV_POS_NO_RFAGC_MODE)
+** N/A 10-22-2007 PINZ Ver 1.07: Changed some Registers at init to have
+** the same settings as with MT Launcher
+** N/A 10-30-2007 PINZ Add SetParam VGAGC & VGAOI
+** Add SetParam DNC_OUTPUT_ENABLE
+** Removed VGAGC from receiver mode,
+** default now 1
+** N/A 10-31-2007 PINZ Ver 1.08: Add SetParam TAGC, removed from rcvr-mode
+** Add SetParam AMPGC, removed from rcvr-mode
+** Corrected names of GCU values
+** reorganized receiver modes, removed,
+** (MT2063_ANALOG_TV_POS_NO_RFAGC_MODE)
+** Actualized Receiver-Mode values
+** N/A 11-12-2007 PINZ Ver 1.09: Actualized Receiver-Mode values
+** N/A 11-27-2007 PINZ Improved buffered writing
+** 01-03-2008 PINZ Ver 1.10: Added a trigger of BYPATNUP for
+** correct wakeup of the LNA after shutdown
+** Set AFCsd = 1 as default
+** Changed CAP1sel default
+** 01-14-2008 PINZ Ver 1.11: Updated gain settings
+** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT
+** Split SetParam up to ACLNA / ACLNA_MAX
+** removed ACLNA_INRC/DECR (+RF & FIF)
+** removed GCUAUTO / BYPATNDN/UP
+**
+******************************************************************************/
+static UData_t MT2063_SetReceiverMode(struct MT2063_Info_t *pInfo,
+ enum MT2063_RCVR_MODES Mode)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ U8Data val;
+ UData_t longval;
+
+ if (Mode >= MT2063_NUM_RCVR_MODES)
+ status = MT2063_ARG_RANGE;
+
+ /* RFAGCen */
+ if (MT2063_NO_ERROR(status)) {
+ val =
+ (pInfo->
+ reg[MT2063_REG_PD1_TGT] & (U8Data) ~ 0x40) | (RFAGCEN[Mode]
+ ? 0x40 :
+ 0x00);
+ if (pInfo->reg[MT2063_REG_PD1_TGT] != val) {
+ status |= MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT, val);
+ }
+ }
+
+ /* LNARin */
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_SetParam(pInfo, MT2063_LNA_RIN, LNARIN[Mode]);
+ }
+
+ /* FIFFQEN and FIFFQ */
+ if (MT2063_NO_ERROR(status)) {
+ val =
+ (pInfo->
+ reg[MT2063_REG_FIFF_CTRL2] & (U8Data) ~ 0xF0) |
+ (FIFFQEN[Mode] << 7) | (FIFFQ[Mode] << 4);
+ if (pInfo->reg[MT2063_REG_FIFF_CTRL2] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL2, val);
+ /* trigger FIFF calibration, needed after changing FIFFQ */
+ val =
+ (pInfo->reg[MT2063_REG_FIFF_CTRL] | (U8Data) 0x01);
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL, val);
+ val =
+ (pInfo->
+ reg[MT2063_REG_FIFF_CTRL] & (U8Data) ~ 0x01);
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL, val);
+ }
+ }
+
+ /* DNC1GC & DNC2GC */
+ status |= MT2063_GetParam(pInfo, MT2063_DNC_OUTPUT_ENABLE, &longval);
+ status |= MT2063_SetParam(pInfo, MT2063_DNC_OUTPUT_ENABLE, longval);
+
+ /* acLNAmax */
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_SetParam(pInfo, MT2063_ACLNA_MAX, ACLNAMAX[Mode]);
+ }
+
+ /* LNATGT */
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_SetParam(pInfo, MT2063_LNA_TGT, LNATGT[Mode]);
+ }
+
+ /* ACRF */
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_SetParam(pInfo, MT2063_ACRF_MAX, ACRFMAX[Mode]);
+ }
+
+ /* PD1TGT */
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_SetParam(pInfo, MT2063_PD1_TGT, PD1TGT[Mode]);
+ }
+
+ /* FIFATN */
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_SetParam(pInfo, MT2063_ACFIF_MAX, ACFIFMAX[Mode]);
+ }
+
+ /* PD2TGT */
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_SetParam(pInfo, MT2063_PD2_TGT, PD2TGT[Mode]);
+ }
+
+ /* Ignore ATN Overload */
+ if (MT2063_NO_ERROR(status)) {
+ val =
+ (pInfo->
+ reg[MT2063_REG_LNA_TGT] & (U8Data) ~ 0x80) | (RFOVDIS[Mode]
+ ? 0x80 :
+ 0x00);
+ if (pInfo->reg[MT2063_REG_LNA_TGT] != val) {
+ status |= MT2063_SetReg(pInfo, MT2063_REG_LNA_TGT, val);
+ }
+ }
+
+ /* Ignore FIF Overload */
+ if (MT2063_NO_ERROR(status)) {
+ val =
+ (pInfo->
+ reg[MT2063_REG_PD1_TGT] & (U8Data) ~ 0x80) |
+ (FIFOVDIS[Mode] ? 0x80 : 0x00);
+ if (pInfo->reg[MT2063_REG_PD1_TGT] != val) {
+ status |= MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT, val);
+ }
+ }
+
+ if (MT2063_NO_ERROR(status))
+ pInfo->rcvr_mode = Mode;
+
+ return (status);
+}
+
+/******************************************************************************
+**
+** Name: MT2063_ReInit
+**
+** Description: Initialize the tuner's register values.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus
+** MT_WriteSub - Write byte(s) of data to the two-wire bus
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 148 09-04-2007 RSK Ver 1.02: Corrected logic of Reg 3B Reference
+** 153 09-07-2007 RSK Ver 1.03: Lock Time improvements
+** N/A 10-31-2007 PINZ Ver 1.08: Changed values suitable to rcvr-mode 0
+** N/A 11-12-2007 PINZ Ver 1.09: Changed values suitable to rcvr-mode 0
+** N/A 01-03-2007 PINZ Ver 1.10: Added AFCsd = 1 into defaults
+** N/A 01-04-2007 PINZ Ver 1.10: Changed CAP1sel default
+** 01-14-2008 PINZ Ver 1.11: Updated gain settings
+** 03-18-2008 PINZ Ver 1.13: Added Support for B3
+** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.
+** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW
+**
+******************************************************************************/
+UData_t MT2063_ReInit(Handle_t h)
+{
+ U8Data all_resets = 0xF0; /* reset/load bits */
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+ U8Data *def;
+
+ U8Data MT2063B0_defaults[] = { /* Reg, Value */
+ 0x19, 0x05,
+ 0x1B, 0x1D,
+ 0x1C, 0x1F,
+ 0x1D, 0x0F,
+ 0x1E, 0x3F,
+ 0x1F, 0x0F,
+ 0x20, 0x3F,
+ 0x22, 0x21,
+ 0x23, 0x3F,
+ 0x24, 0x20,
+ 0x25, 0x3F,
+ 0x27, 0xEE,
+ 0x2C, 0x27, /* bit at 0x20 is cleared below */
+ 0x30, 0x03,
+ 0x2C, 0x07, /* bit at 0x20 is cleared here */
+ 0x2D, 0x87,
+ 0x2E, 0xAA,
+ 0x28, 0xE1, /* Set the FIFCrst bit here */
+ 0x28, 0xE0, /* Clear the FIFCrst bit here */
+ 0x00
+ };
+
+ /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */
+ U8Data MT2063B1_defaults[] = { /* Reg, Value */
+ 0x05, 0xF0,
+ 0x11, 0x10, /* New Enable AFCsd */
+ 0x19, 0x05,
+ 0x1A, 0x6C,
+ 0x1B, 0x24,
+ 0x1C, 0x28,
+ 0x1D, 0x8F,
+ 0x1E, 0x14,
+ 0x1F, 0x8F,
+ 0x20, 0x57,
+ 0x22, 0x21, /* New - ver 1.03 */
+ 0x23, 0x3C, /* New - ver 1.10 */
+ 0x24, 0x20, /* New - ver 1.03 */
+ 0x2C, 0x24, /* bit at 0x20 is cleared below */
+ 0x2D, 0x87, /* FIFFQ=0 */
+ 0x2F, 0xF3,
+ 0x30, 0x0C, /* New - ver 1.11 */
+ 0x31, 0x1B, /* New - ver 1.11 */
+ 0x2C, 0x04, /* bit at 0x20 is cleared here */
+ 0x28, 0xE1, /* Set the FIFCrst bit here */
+ 0x28, 0xE0, /* Clear the FIFCrst bit here */
+ 0x00
+ };
+
+ /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */
+ U8Data MT2063B3_defaults[] = { /* Reg, Value */
+ 0x05, 0xF0,
+ 0x19, 0x3D,
+ 0x2C, 0x24, /* bit at 0x20 is cleared below */
+ 0x2C, 0x04, /* bit at 0x20 is cleared here */
+ 0x28, 0xE1, /* Set the FIFCrst bit here */
+ 0x28, 0xE0, /* Clear the FIFCrst bit here */
+ 0x00
+ };
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status |= MT2063_INV_HANDLE;
+
+ /* Read the Part/Rev code from the tuner */
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PART_REV, pInfo->reg, 1);
+ }
+
+ if (MT2063_NO_ERROR(status) /* Check the part/rev code */
+ &&((pInfo->reg[MT2063_REG_PART_REV] != MT2063_B0) /* MT2063 B0 */
+ &&(pInfo->reg[MT2063_REG_PART_REV] != MT2063_B1) /* MT2063 B1 */
+ &&(pInfo->reg[MT2063_REG_PART_REV] != MT2063_B3))) /* MT2063 B3 */
+ status |= MT2063_TUNER_ID_ERR; /* Wrong tuner Part/Rev code */
+
+ /* Read the Part/Rev code (2nd byte) from the tuner */
+ if (MT2063_NO_ERROR(status))
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_RSVD_3B,
+ &pInfo->reg[MT2063_REG_RSVD_3B], 1);
+
+ if (MT2063_NO_ERROR(status) /* Check the 2nd part/rev code */
+ &&((pInfo->reg[MT2063_REG_RSVD_3B] & 0x80) != 0x00)) /* b7 != 0 ==> NOT MT2063 */
+ status |= MT2063_TUNER_ID_ERR; /* Wrong tuner Part/Rev code */
+
+ /* Reset the tuner */
+ if (MT2063_NO_ERROR(status))
+ status |= MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_3, &all_resets, 1);
+
+ /* change all of the default values that vary from the HW reset values */
+ /* def = (pInfo->reg[PART_REV] == MT2063_B0) ? MT2063B0_defaults : MT2063B1_defaults; */
+ switch (pInfo->reg[MT2063_REG_PART_REV]) {
+ case MT2063_B3:
+ def = MT2063B3_defaults;
+ break;
+
+ case MT2063_B1:
+ def = MT2063B1_defaults;
+ break;
+
+ case MT2063_B0:
+ def = MT2063B0_defaults;
+ break;
+
+ default:
+ status |= MT2063_TUNER_ID_ERR;
+ break;
+ }
+
+ while (MT2063_NO_ERROR(status) && *def) {
+ U8Data reg = *def++;
+ U8Data val = *def++;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address, reg, &val,
+ 1);
+ }
+
+ /* Wait for FIFF location to complete. */
+ if (MT2063_NO_ERROR(status)) {
+ UData_t FCRUN = 1;
+ SData_t maxReads = 10;
+ while (MT2063_NO_ERROR(status) && (FCRUN != 0)
+ && (maxReads-- > 0)) {
+ MT2063_Sleep(pInfo->hUserData, 2);
+ status |= MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_XO_STATUS,
+ &pInfo->
+ reg[MT2063_REG_XO_STATUS], 1);
+ FCRUN = (pInfo->reg[MT2063_REG_XO_STATUS] & 0x40) >> 6;
+ }
+
+ if (FCRUN != 0)
+ status |= MT2063_TUNER_INIT_ERR | MT2063_TUNER_TIMEOUT;
+
+ if (MT2063_NO_ERROR(status)) /* Re-read FIFFC value */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_FIFFC,
+ &pInfo->reg[MT2063_REG_FIFFC], 1);
+ }
+
+ /* Read back all the registers from the tuner */
+ if (MT2063_NO_ERROR(status))
+ status |= MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_PART_REV,
+ pInfo->reg, MT2063_REG_END_REGS);
+
+ if (MT2063_NO_ERROR(status)) {
+ /* Initialize the tuner state. */
+ pInfo->version = MT2063_VERSION;
+ pInfo->tuner_id = pInfo->reg[MT2063_REG_PART_REV];
+ pInfo->AS_Data.f_ref = MT2063_REF_FREQ;
+ pInfo->AS_Data.f_if1_Center =
+ (pInfo->AS_Data.f_ref / 8) *
+ ((UData_t) pInfo->reg[MT2063_REG_FIFFC] + 640);
+ pInfo->AS_Data.f_if1_bw = MT2063_IF1_BW;
+ pInfo->AS_Data.f_out = 43750000UL;
+ pInfo->AS_Data.f_out_bw = 6750000UL;
+ pInfo->AS_Data.f_zif_bw = MT2063_ZIF_BW;
+ pInfo->AS_Data.f_LO1_Step = pInfo->AS_Data.f_ref / 64;
+ pInfo->AS_Data.f_LO2_Step = MT2063_TUNE_STEP_SIZE;
+ pInfo->AS_Data.maxH1 = MT2063_MAX_HARMONICS_1;
+ pInfo->AS_Data.maxH2 = MT2063_MAX_HARMONICS_2;
+ pInfo->AS_Data.f_min_LO_Separation = MT2063_MIN_LO_SEP;
+ pInfo->AS_Data.f_if1_Request = pInfo->AS_Data.f_if1_Center;
+ pInfo->AS_Data.f_LO1 = 2181000000UL;
+ pInfo->AS_Data.f_LO2 = 1486249786UL;
+ pInfo->f_IF1_actual = pInfo->AS_Data.f_if1_Center;
+ pInfo->AS_Data.f_in =
+ pInfo->AS_Data.f_LO1 - pInfo->f_IF1_actual;
+ pInfo->AS_Data.f_LO1_FracN_Avoid = MT2063_LO1_FRACN_AVOID;
+ pInfo->AS_Data.f_LO2_FracN_Avoid = MT2063_LO2_FRACN_AVOID;
+ pInfo->num_regs = MT2063_REG_END_REGS;
+ pInfo->AS_Data.avoidDECT = MT2063_AVOID_BOTH;
+ pInfo->ctfilt_sw = 0;
+ }
+
+ if (MT2063_NO_ERROR(status)) {
+ pInfo->CTFiltMax[0] = 69230000;
+ pInfo->CTFiltMax[1] = 105770000;
+ pInfo->CTFiltMax[2] = 140350000;
+ pInfo->CTFiltMax[3] = 177110000;
+ pInfo->CTFiltMax[4] = 212860000;
+ pInfo->CTFiltMax[5] = 241130000;
+ pInfo->CTFiltMax[6] = 274370000;
+ pInfo->CTFiltMax[7] = 309820000;
+ pInfo->CTFiltMax[8] = 342450000;
+ pInfo->CTFiltMax[9] = 378870000;
+ pInfo->CTFiltMax[10] = 416210000;
+ pInfo->CTFiltMax[11] = 456500000;
+ pInfo->CTFiltMax[12] = 495790000;
+ pInfo->CTFiltMax[13] = 534530000;
+ pInfo->CTFiltMax[14] = 572610000;
+ pInfo->CTFiltMax[15] = 598970000;
+ pInfo->CTFiltMax[16] = 635910000;
+ pInfo->CTFiltMax[17] = 672130000;
+ pInfo->CTFiltMax[18] = 714840000;
+ pInfo->CTFiltMax[19] = 739660000;
+ pInfo->CTFiltMax[20] = 770410000;
+ pInfo->CTFiltMax[21] = 814660000;
+ pInfo->CTFiltMax[22] = 846950000;
+ pInfo->CTFiltMax[23] = 867820000;
+ pInfo->CTFiltMax[24] = 915980000;
+ pInfo->CTFiltMax[25] = 947450000;
+ pInfo->CTFiltMax[26] = 983110000;
+ pInfo->CTFiltMax[27] = 1021630000;
+ pInfo->CTFiltMax[28] = 1061870000;
+ pInfo->CTFiltMax[29] = 1098330000;
+ pInfo->CTFiltMax[30] = 1138990000;
+ }
+
+ /*
+ ** Fetch the FCU osc value and use it and the fRef value to
+ ** scale all of the Band Max values
+ */
+ if (MT2063_NO_ERROR(status)) {
+ UData_t fcu_osc;
+ UData_t i;
+
+ pInfo->reg[MT2063_REG_CTUNE_CTRL] = 0x0A;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_CTUNE_CTRL,
+ &pInfo->reg[MT2063_REG_CTUNE_CTRL], 1);
+ /* Read the ClearTune filter calibration value */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_FIFFC,
+ &pInfo->reg[MT2063_REG_FIFFC], 1);
+ fcu_osc = pInfo->reg[MT2063_REG_FIFFC];
+
+ pInfo->reg[MT2063_REG_CTUNE_CTRL] = 0x00;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_CTUNE_CTRL,
+ &pInfo->reg[MT2063_REG_CTUNE_CTRL], 1);
+
+ /* Adjust each of the values in the ClearTune filter cross-over table */
+ for (i = 0; i < 31; i++) {
+ pInfo->CTFiltMax[i] =
+ (pInfo->CTFiltMax[i] / 768) * (fcu_osc + 640);
+ }
+ }
+
+ return (status);
+}
+
+/******************************************************************************
+**
+** Name: MT2063_SetGPIO
+**
+** Description: Modify the MT2063 GPIO value.
+**
+** Parameters: h - Open handle to the tuner (from MT2063_Open).
+** gpio_id - Selects GPIO0, GPIO1 or GPIO2
+** attr - Selects input readback, I/O direction or
+** output value
+** value - value to set GPIO pin 15, 14 or 19
+**
+** Usage: status = MT2063_SetGPIO(hMT2063, MT2063_GPIO1, MT2063_GPIO_OUT, 1);
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+**
+** Dependencies: MT_WriteSub - Write byte(s) of data to the two-wire-bus
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+******************************************************************************/
+UData_t MT2063_SetGPIO(Handle_t h, enum MT2063_GPIO_ID gpio_id,
+ enum MT2063_GPIO_Attr attr, UData_t value)
{
- int ret;
- u8 buf[60];/* = { reg1, data };*/\r
- \r
- struct i2c_msg msg = {
- .addr = state->config->tuner_address,\r
- .flags = 0,
- .buf = buf,
- .len = len + 1
- };
+ UData_t status = MT2063_OK; /* Status to be returned */
+ U8Data regno;
+ SData_t shift;
+ static U8Data GPIOreg[3] = { 0x15, 0x19, 0x18 };
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
- msg.buf[0] = reg1;
- memcpy(msg.buf + 1, data, len);
-\r
- //printk("mt2063_writeregs state->i2c=%p\n", state->i2c);\r
- ret = i2c_transfer(state->i2c, &msg, 1);
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ return MT2063_INV_HANDLE;
- if (ret < 0)\r
- printk("mt2063_writeregs error ret=%d\n", ret);\r
+ regno = GPIOreg[attr];
- return ret;\r
-}\r
-\r
-static int mt2063_read_regs(struct mt2063_state *state, u8 reg1, u8 *b, u8 len)\r
+ shift = (gpio_id - MT2063_GPIO0 + 5);
+
+ if (value & 0x01)
+ pInfo->reg[regno] |= (0x01 << shift);
+ else
+ pInfo->reg[regno] &= ~(0x01 << shift);
+ status =
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address, regno,
+ &pInfo->reg[regno], 1);
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_SetParam
+**
+** Description: Sets a tuning algorithm parameter.
+**
+** This function provides access to the internals of the
+** tuning algorithm. You can override many of the tuning
+** algorithm defaults using this function.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** param - Tuning algorithm parameter
+** (see enum MT2063_Param)
+** nValue - value to be set
+**
+** param Description
+** ---------------------- --------------------------------
+** MT2063_SRO_FREQ crystal frequency
+** MT2063_STEPSIZE minimum tuning step size
+** MT2063_LO1_FREQ LO1 frequency
+** MT2063_LO1_STEPSIZE LO1 minimum step size
+** MT2063_LO1_FRACN_AVOID LO1 FracN keep-out region
+** MT2063_IF1_REQUEST Requested 1st IF
+** MT2063_ZIF_BW zero-IF bandwidth
+** MT2063_LO2_FREQ LO2 frequency
+** MT2063_LO2_STEPSIZE LO2 minimum step size
+** MT2063_LO2_FRACN_AVOID LO2 FracN keep-out region
+** MT2063_OUTPUT_FREQ output center frequency
+** MT2063_OUTPUT_BW output bandwidth
+** MT2063_LO_SEPARATION min inter-tuner LO separation
+** MT2063_MAX_HARM1 max # of intra-tuner harmonics
+** MT2063_MAX_HARM2 max # of inter-tuner harmonics
+** MT2063_RCVR_MODE Predefined modes
+** MT2063_LNA_RIN Set LNA Rin (*)
+** MT2063_LNA_TGT Set target power level at LNA (*)
+** MT2063_PD1_TGT Set target power level at PD1 (*)
+** MT2063_PD2_TGT Set target power level at PD2 (*)
+** MT2063_ACLNA_MAX LNA attenuator limit (*)
+** MT2063_ACRF_MAX RF attenuator limit (*)
+** MT2063_ACFIF_MAX FIF attenuator limit (*)
+** MT2063_DNC_OUTPUT_ENABLE DNC output selection
+** MT2063_VGAGC VGA gain code
+** MT2063_VGAOI VGA output current
+** MT2063_TAGC TAGC setting
+** MT2063_AMPGC AMP gain code
+** MT2063_AVOID_DECT Avoid DECT Frequencies
+** MT2063_CTFILT_SW Cleartune filter selection
+**
+** (*) This parameter is set by MT2063_RCVR_MODE, do not call
+** additionally.
+**
+** Usage: status |= MT2063_SetParam(hMT2063,
+** MT2063_STEPSIZE,
+** 50000);
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Null pointer argument passed
+** MT_ARG_RANGE - Invalid parameter requested
+** or set value out of range
+** or non-writable parameter
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** See Also: MT2063_GetParam, MT2063_Open
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 154 09-13-2007 RSK Ver 1.05: Get/SetParam changes for LOx_FREQ
+** 10-31-2007 PINZ Ver 1.08: Get/SetParam add VGAGC, VGAOI, AMPGC, TAGC
+** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT
+** Split SetParam up to ACLNA / ACLNA_MAX
+** removed ACLNA_INRC/DECR (+RF & FIF)
+** removed GCUAUTO / BYPATNDN/UP
+** 175 I 06-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.
+** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.
+** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW
+**
+****************************************************************************/
+UData_t MT2063_SetParam(Handle_t h, enum MT2063_Param param, UData_t nValue)
{
- int ret; \r
- u8 b0[] = { reg1 };\r
- struct i2c_msg msg[] = {
- {
- .addr = state->config->tuner_address,\r
- .flags = I2C_M_RD,\r
- .buf = b0,\r
- .len = 1
- }, {
- .addr = state->config->tuner_address,\r
- .flags = I2C_M_RD,
- .buf = b,\r
- .len = len\r
+ UData_t status = MT2063_OK; /* Status to be returned */
+ U8Data val = 0;
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status |= MT2063_INV_HANDLE;
+
+ if (MT2063_NO_ERROR(status)) {
+ switch (param) {
+ /* crystal frequency */
+ case MT2063_SRO_FREQ:
+ pInfo->AS_Data.f_ref = nValue;
+ pInfo->AS_Data.f_LO1_FracN_Avoid = 0;
+ pInfo->AS_Data.f_LO2_FracN_Avoid = nValue / 80 - 1;
+ pInfo->AS_Data.f_LO1_Step = nValue / 64;
+ pInfo->AS_Data.f_if1_Center =
+ (pInfo->AS_Data.f_ref / 8) *
+ (pInfo->reg[MT2063_REG_FIFFC] + 640);
+ break;
+
+ /* minimum tuning step size */
+ case MT2063_STEPSIZE:
+ pInfo->AS_Data.f_LO2_Step = nValue;
+ break;
+
+ /* LO1 frequency */
+ case MT2063_LO1_FREQ:
+ {
+ /* Note: LO1 and LO2 are BOTH written at toggle of LDLOos */
+ /* Capture the Divider and Numerator portions of other LO */
+ U8Data tempLO2CQ[3];
+ U8Data tempLO2C[3];
+ U8Data tmpOneShot;
+ UData_t Div, FracN;
+ U8Data restore = 0;
+
+ /* Buffer the queue for restoration later and get actual LO2 values. */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_1,
+ &(tempLO2CQ[0]), 3);
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2C_1,
+ &(tempLO2C[0]), 3);
+
+ /* clear the one-shot bits */
+ tempLO2CQ[2] = tempLO2CQ[2] & 0x0F;
+ tempLO2C[2] = tempLO2C[2] & 0x0F;
+
+ /* only write the queue values if they are different from the actual. */
+ if ((tempLO2CQ[0] != tempLO2C[0]) ||
+ (tempLO2CQ[1] != tempLO2C[1]) ||
+ (tempLO2CQ[2] != tempLO2C[2])) {
+ /* put actual LO2 value into queue (with 0 in one-shot bits) */
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_1,
+ &(tempLO2C[0]), 3);
+
+ if (status == MT2063_OK) {
+ /* cache the bytes just written. */
+ pInfo->reg[MT2063_REG_LO2CQ_1] =
+ tempLO2C[0];
+ pInfo->reg[MT2063_REG_LO2CQ_2] =
+ tempLO2C[1];
+ pInfo->reg[MT2063_REG_LO2CQ_3] =
+ tempLO2C[2];
+ }
+ restore = 1;
+ }
+
+ /* Calculate the Divider and Numberator components of LO1 */
+ status =
+ MT2063_CalcLO1Mult(&Div, &FracN, nValue,
+ pInfo->AS_Data.f_ref /
+ 64,
+ pInfo->AS_Data.f_ref);
+ pInfo->reg[MT2063_REG_LO1CQ_1] =
+ (U8Data) (Div & 0x00FF);
+ pInfo->reg[MT2063_REG_LO1CQ_2] =
+ (U8Data) (FracN);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1CQ_1,
+ &pInfo->
+ reg[MT2063_REG_LO1CQ_1], 2);
+
+ /* set the one-shot bit to load the pair of LO values */
+ tmpOneShot = tempLO2CQ[2] | 0xE0;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_3,
+ &tmpOneShot, 1);
+
+ /* only restore the queue values if they were different from the actual. */
+ if (restore) {
+ /* put actual LO2 value into queue (0 in one-shot bits) */
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_1,
+ &(tempLO2CQ[0]), 3);
+
+ /* cache the bytes just written. */
+ pInfo->reg[MT2063_REG_LO2CQ_1] =
+ tempLO2CQ[0];
+ pInfo->reg[MT2063_REG_LO2CQ_2] =
+ tempLO2CQ[1];
+ pInfo->reg[MT2063_REG_LO2CQ_3] =
+ tempLO2CQ[2];
+ }
+
+ MT2063_GetParam(pInfo->hUserData,
+ MT2063_LO1_FREQ,
+ &pInfo->AS_Data.f_LO1);
+ }
+ break;
+
+ /* LO1 minimum step size */
+ case MT2063_LO1_STEPSIZE:
+ pInfo->AS_Data.f_LO1_Step = nValue;
+ break;
+
+ /* LO1 FracN keep-out region */
+ case MT2063_LO1_FRACN_AVOID_PARAM:
+ pInfo->AS_Data.f_LO1_FracN_Avoid = nValue;
+ break;
+
+ /* Requested 1st IF */
+ case MT2063_IF1_REQUEST:
+ pInfo->AS_Data.f_if1_Request = nValue;
+ break;
+
+ /* zero-IF bandwidth */
+ case MT2063_ZIF_BW:
+ pInfo->AS_Data.f_zif_bw = nValue;
+ break;
+
+ /* LO2 frequency */
+ case MT2063_LO2_FREQ:
+ {
+ /* Note: LO1 and LO2 are BOTH written at toggle of LDLOos */
+ /* Capture the Divider and Numerator portions of other LO */
+ U8Data tempLO1CQ[2];
+ U8Data tempLO1C[2];
+ UData_t Div2;
+ UData_t FracN2;
+ U8Data tmpOneShot;
+ U8Data restore = 0;
+
+ /* Buffer the queue for restoration later and get actual LO2 values. */
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1CQ_1,
+ &(tempLO1CQ[0]), 2);
+ status |=
+ MT2063_ReadSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1C_1,
+ &(tempLO1C[0]), 2);
+
+ /* only write the queue values if they are different from the actual. */
+ if ((tempLO1CQ[0] != tempLO1C[0])
+ || (tempLO1CQ[1] != tempLO1C[1])) {
+ /* put actual LO1 value into queue */
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1CQ_1,
+ &(tempLO1C[0]), 2);
+
+ /* cache the bytes just written. */
+ pInfo->reg[MT2063_REG_LO1CQ_1] =
+ tempLO1C[0];
+ pInfo->reg[MT2063_REG_LO1CQ_2] =
+ tempLO1C[1];
+ restore = 1;
+ }
+
+ /* Calculate the Divider and Numberator components of LO2 */
+ status =
+ MT2063_CalcLO2Mult(&Div2, &FracN2, nValue,
+ pInfo->AS_Data.f_ref /
+ 8191,
+ pInfo->AS_Data.f_ref);
+ pInfo->reg[MT2063_REG_LO2CQ_1] =
+ (U8Data) ((Div2 << 1) |
+ ((FracN2 >> 12) & 0x01)) & 0xFF;
+ pInfo->reg[MT2063_REG_LO2CQ_2] =
+ (U8Data) ((FracN2 >> 4) & 0xFF);
+ pInfo->reg[MT2063_REG_LO2CQ_3] =
+ (U8Data) ((FracN2 & 0x0F));
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1CQ_1,
+ &pInfo->
+ reg[MT2063_REG_LO1CQ_1], 3);
+
+ /* set the one-shot bit to load the LO values */
+ tmpOneShot =
+ pInfo->reg[MT2063_REG_LO2CQ_3] | 0xE0;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO2CQ_3,
+ &tmpOneShot, 1);
+
+ /* only restore LO1 queue value if they were different from the actual. */
+ if (restore) {
+ /* put previous LO1 queue value back into queue */
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_LO1CQ_1,
+ &(tempLO1CQ[0]), 2);
+
+ /* cache the bytes just written. */
+ pInfo->reg[MT2063_REG_LO1CQ_1] =
+ tempLO1CQ[0];
+ pInfo->reg[MT2063_REG_LO1CQ_2] =
+ tempLO1CQ[1];
+ }
+
+ MT2063_GetParam(pInfo->hUserData,
+ MT2063_LO2_FREQ,
+ &pInfo->AS_Data.f_LO2);
+ }
+ break;
+
+ /* LO2 minimum step size */
+ case MT2063_LO2_STEPSIZE:
+ pInfo->AS_Data.f_LO2_Step = nValue;
+ break;
+
+ /* LO2 FracN keep-out region */
+ case MT2063_LO2_FRACN_AVOID:
+ pInfo->AS_Data.f_LO2_FracN_Avoid = nValue;
+ break;
+
+ /* output center frequency */
+ case MT2063_OUTPUT_FREQ:
+ pInfo->AS_Data.f_out = nValue;
+ break;
+
+ /* output bandwidth */
+ case MT2063_OUTPUT_BW:
+ pInfo->AS_Data.f_out_bw = nValue + 750000;
+ break;
+
+ /* min inter-tuner LO separation */
+ case MT2063_LO_SEPARATION:
+ pInfo->AS_Data.f_min_LO_Separation = nValue;
+ break;
+
+ /* max # of intra-tuner harmonics */
+ case MT2063_MAX_HARM1:
+ pInfo->AS_Data.maxH1 = nValue;
+ break;
+
+ /* max # of inter-tuner harmonics */
+ case MT2063_MAX_HARM2:
+ pInfo->AS_Data.maxH2 = nValue;
+ break;
+
+ case MT2063_RCVR_MODE:
+ status |=
+ MT2063_SetReceiverMode(pInfo,
+ (enum MT2063_RCVR_MODES)
+ nValue);
+ break;
+
+ /* Set LNA Rin -- nValue is desired value */
+ case MT2063_LNA_RIN:
+ val =
+ (pInfo->
+ reg[MT2063_REG_CTRL_2C] & (U8Data) ~ 0x03) |
+ (nValue & 0x03);
+ if (pInfo->reg[MT2063_REG_CTRL_2C] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_CTRL_2C,
+ val);
+ }
+ break;
+
+ /* Set target power level at LNA -- nValue is desired value */
+ case MT2063_LNA_TGT:
+ val =
+ (pInfo->
+ reg[MT2063_REG_LNA_TGT] & (U8Data) ~ 0x3F) |
+ (nValue & 0x3F);
+ if (pInfo->reg[MT2063_REG_LNA_TGT] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_LNA_TGT,
+ val);
+ }
+ break;
+
+ /* Set target power level at PD1 -- nValue is desired value */
+ case MT2063_PD1_TGT:
+ val =
+ (pInfo->
+ reg[MT2063_REG_PD1_TGT] & (U8Data) ~ 0x3F) |
+ (nValue & 0x3F);
+ if (pInfo->reg[MT2063_REG_PD1_TGT] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT,
+ val);
+ }
+ break;
+
+ /* Set target power level at PD2 -- nValue is desired value */
+ case MT2063_PD2_TGT:
+ val =
+ (pInfo->
+ reg[MT2063_REG_PD2_TGT] & (U8Data) ~ 0x3F) |
+ (nValue & 0x3F);
+ if (pInfo->reg[MT2063_REG_PD2_TGT] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_PD2_TGT,
+ val);
+ }
+ break;
+
+ /* Set LNA atten limit -- nValue is desired value */
+ case MT2063_ACLNA_MAX:
+ val =
+ (pInfo->
+ reg[MT2063_REG_LNA_OV] & (U8Data) ~ 0x1F) | (nValue
+ &
+ 0x1F);
+ if (pInfo->reg[MT2063_REG_LNA_OV] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_LNA_OV,
+ val);
+ }
+ break;
+
+ /* Set RF atten limit -- nValue is desired value */
+ case MT2063_ACRF_MAX:
+ val =
+ (pInfo->
+ reg[MT2063_REG_RF_OV] & (U8Data) ~ 0x1F) | (nValue
+ &
+ 0x1F);
+ if (pInfo->reg[MT2063_REG_RF_OV] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_RF_OV, val);
+ }
+ break;
+
+ /* Set FIF atten limit -- nValue is desired value, max. 5 if no B3 */
+ case MT2063_ACFIF_MAX:
+ if (pInfo->reg[MT2063_REG_PART_REV] != MT2063_B3
+ && nValue > 5)
+ nValue = 5;
+ val =
+ (pInfo->
+ reg[MT2063_REG_FIF_OV] & (U8Data) ~ 0x1F) | (nValue
+ &
+ 0x1F);
+ if (pInfo->reg[MT2063_REG_FIF_OV] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_FIF_OV,
+ val);
+ }
+ break;
+
+ case MT2063_DNC_OUTPUT_ENABLE:
+ /* selects, which DNC output is used */
+ switch ((enum MT2063_DNC_Output_Enable)nValue) {
+ case MT2063_DNC_NONE:
+ {
+ val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC) | 0x03; /* Set DNC1GC=3 */
+ if (pInfo->reg[MT2063_REG_DNC_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_DNC_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC) | 0x03; /* Set DNC2GC=3 */
+ if (pInfo->reg[MT2063_REG_VGA_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_VGA_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */
+ if (pInfo->reg[MT2063_REG_RSVD_20] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_RSVD_20,
+ val);
+
+ break;
+ }
+ case MT2063_DNC_1:
+ {
+ val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC) | (DNC1GC[pInfo->rcvr_mode] & 0x03); /* Set DNC1GC=x */
+ if (pInfo->reg[MT2063_REG_DNC_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_DNC_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC) | 0x03; /* Set DNC2GC=3 */
+ if (pInfo->reg[MT2063_REG_VGA_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_VGA_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */
+ if (pInfo->reg[MT2063_REG_RSVD_20] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_RSVD_20,
+ val);
+
+ break;
+ }
+ case MT2063_DNC_2:
+ {
+ val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC) | 0x03; /* Set DNC1GC=3 */
+ if (pInfo->reg[MT2063_REG_DNC_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_DNC_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC) | (DNC2GC[pInfo->rcvr_mode] & 0x03); /* Set DNC2GC=x */
+ if (pInfo->reg[MT2063_REG_VGA_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_VGA_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_RSVD_20] | 0x40); /* Set PD2MUX=1 */
+ if (pInfo->reg[MT2063_REG_RSVD_20] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_RSVD_20,
+ val);
+
+ break;
+ }
+ case MT2063_DNC_BOTH:
+ {
+ val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC) | (DNC1GC[pInfo->rcvr_mode] & 0x03); /* Set DNC1GC=x */
+ if (pInfo->reg[MT2063_REG_DNC_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_DNC_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC) | (DNC2GC[pInfo->rcvr_mode] & 0x03); /* Set DNC2GC=x */
+ if (pInfo->reg[MT2063_REG_VGA_GAIN] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_VGA_GAIN,
+ val);
+
+ val = (pInfo->reg[MT2063_REG_RSVD_20] | 0x40); /* Set PD2MUX=1 */
+ if (pInfo->reg[MT2063_REG_RSVD_20] !=
+ val)
+ status |=
+ MT2063_SetReg(h,
+ MT2063_REG_RSVD_20,
+ val);
+
+ break;
+ }
+ default:
+ break;
+ }
+ break;
+
+ case MT2063_VGAGC:
+ /* Set VGA gain code */
+ val =
+ (pInfo->
+ reg[MT2063_REG_VGA_GAIN] & (U8Data) ~ 0x0C) |
+ ((nValue & 0x03) << 2);
+ if (pInfo->reg[MT2063_REG_VGA_GAIN] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_VGA_GAIN,
+ val);
+ }
+ break;
+
+ case MT2063_VGAOI:
+ /* Set VGA bias current */
+ val =
+ (pInfo->
+ reg[MT2063_REG_RSVD_31] & (U8Data) ~ 0x07) |
+ (nValue & 0x07);
+ if (pInfo->reg[MT2063_REG_RSVD_31] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_RSVD_31,
+ val);
+ }
+ break;
+
+ case MT2063_TAGC:
+ /* Set TAGC */
+ val =
+ (pInfo->
+ reg[MT2063_REG_RSVD_1E] & (U8Data) ~ 0x03) |
+ (nValue & 0x03);
+ if (pInfo->reg[MT2063_REG_RSVD_1E] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_RSVD_1E,
+ val);
+ }
+ break;
+
+ case MT2063_AMPGC:
+ /* Set Amp gain code */
+ val =
+ (pInfo->
+ reg[MT2063_REG_TEMP_SEL] & (U8Data) ~ 0x03) |
+ (nValue & 0x03);
+ if (pInfo->reg[MT2063_REG_TEMP_SEL] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_TEMP_SEL,
+ val);
+ }
+ break;
+
+ /* Avoid DECT Frequencies */
+ case MT2063_AVOID_DECT:
+ {
+ enum MT2063_DECT_Avoid_Type newAvoidSetting =
+ (enum MT2063_DECT_Avoid_Type)nValue;
+ if ((newAvoidSetting >=
+ MT2063_NO_DECT_AVOIDANCE)
+ && (newAvoidSetting <= MT2063_AVOID_BOTH)) {
+ pInfo->AS_Data.avoidDECT =
+ newAvoidSetting;
+ }
+ }
+ break;
+
+ /* Cleartune filter selection: 0 - by IC (default), 1 - by software */
+ case MT2063_CTFILT_SW:
+ pInfo->ctfilt_sw = (nValue & 0x01);
+ break;
+
+ /* These parameters are read-only */
+ case MT2063_IC_ADDR:
+ case MT2063_MAX_OPEN:
+ case MT2063_NUM_OPEN:
+ case MT2063_INPUT_FREQ:
+ case MT2063_IF1_ACTUAL:
+ case MT2063_IF1_CENTER:
+ case MT2063_IF1_BW:
+ case MT2063_AS_ALG:
+ case MT2063_EXCL_ZONES:
+ case MT2063_SPUR_AVOIDED:
+ case MT2063_NUM_SPURS:
+ case MT2063_SPUR_PRESENT:
+ case MT2063_ACLNA:
+ case MT2063_ACRF:
+ case MT2063_ACFIF:
+ case MT2063_EOP:
+ default:
+ status |= MT2063_ARG_RANGE;
}
- };
-\r
- //printk("mt2063_read_regs state->i2c=%p\n", state->i2c);\r
- ret = i2c_transfer(state->i2c, msg, 2);\r
- if (ret < 0)\r
- printk("mt2063_readregs error ret=%d\n", ret);\r
-
- return ret;\r
-}\r
-\r
-\r
-\r
-\r
-//context of mt2063_userdef.c <Henry> ======================================\r
-//#################################################################\r
-//=================================================================\r
-/*****************************************************************************\r
-**\r
-** Name: MT_WriteSub\r
-**\r
-** Description: Write values to device using a two-wire serial bus.\r
-**\r
-** Parameters: hUserData - User-specific I/O parameter that was\r
-** passed to tuner's Open function.\r
-** addr - device serial bus address (value passed\r
-** as parameter to MTxxxx_Open)\r
-** subAddress - serial bus sub-address (Register Address)\r
-** pData - pointer to the Data to be written to the \r
-** device \r
-** cnt - number of bytes/registers to be written\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** user-defined\r
-**\r
-** Notes: This is a callback function that is called from the\r
-** the tuning algorithm. You MUST provide code for this\r
-** function to write data using the tuner's 2-wire serial \r
-** bus.\r
-**\r
-** The hUserData parameter is a user-specific argument.\r
-** If additional arguments are needed for the user's\r
-** serial bus read/write functions, this argument can be\r
-** used to supply the necessary information.\r
-** The hUserData parameter is initialized in the tuner's Open\r
-** function.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 03-25-2004 DAD Original\r
-**\r
-*****************************************************************************/\r
-UData_t MT2063_WriteSub(Handle_t hUserData, \r
- UData_t addr, \r
- U8Data subAddress, \r
- U8Data *pData, \r
- UData_t cnt)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct dvb_frontend *fe = hUserData;\r
- struct mt2063_state *state = fe->tuner_priv; \r
- /*\r
- ** ToDo: Add code here to implement a serial-bus write\r
- ** operation to the MTxxxx tuner. If successful,\r
- ** return MT_OK.\r
- */\r
-/* return status; */\r
-\r
-//#if !TUNER_CONTROL_BY_DRXK_DRIVER \r
- fe->ops.i2c_gate_ctrl(fe, 1); //I2C bypass drxk3926 close i2c bridge \r
-//#endif\r
-\r
- if (mt2063_writeregs(state, subAddress,pData, cnt)<0)\r
- {\r
- status = MT2063_ERROR;\r
- }\r
- \r
-//#if !TUNER_CONTROL_BY_DRXK_DRIVER \r
- fe->ops.i2c_gate_ctrl(fe, 0); //I2C bypass drxk3926 close i2c bridge \r
-//#endif\r
-\r
- return (status);\r
-}\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: MT_ReadSub\r
-**\r
-** Description: Read values from device using a two-wire serial bus.\r
-**\r
-** Parameters: hUserData - User-specific I/O parameter that was\r
-** passed to tuner's Open function.\r
-** addr - device serial bus address (value passed\r
-** as parameter to MTxxxx_Open)\r
-** subAddress - serial bus sub-address (Register Address)\r
-** pData - pointer to the Data to be written to the \r
-** device \r
-** cnt - number of bytes/registers to be written\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** user-defined\r
-**\r
-** Notes: This is a callback function that is called from the\r
-** the tuning algorithm. You MUST provide code for this\r
-** function to read data using the tuner's 2-wire serial \r
-** bus.\r
-**\r
-** The hUserData parameter is a user-specific argument.\r
-** If additional arguments are needed for the user's\r
-** serial bus read/write functions, this argument can be\r
-** used to supply the necessary information.\r
-** The hUserData parameter is initialized in the tuner's Open\r
-** function.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 03-25-2004 DAD Original\r
-**\r
-*****************************************************************************/\r
-UData_t MT2063_ReadSub(Handle_t hUserData, \r
- UData_t addr, \r
- U8Data subAddress, \r
- U8Data *pData, \r
- UData_t cnt)\r
-{\r
- /*\r
- ** ToDo: Add code here to implement a serial-bus read\r
- ** operation to the MTxxxx tuner. If successful,\r
- ** return MT_OK.\r
- */\r
-/* return status; */\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct dvb_frontend *fe = hUserData;\r
- struct mt2063_state *state = fe->tuner_priv; \r
- UData_t i = 0;\r
-//#if !TUNER_CONTROL_BY_DRXK_DRIVER \r
- fe->ops.i2c_gate_ctrl(fe, 1); //I2C bypass drxk3926 close i2c bridge \r
-//#endif\r
- \r
- for (i = 0; i < cnt; i++)\r
- { \r
- if (mt2063_read_regs(state, subAddress+i, pData+i, 1)<0)\r
- {\r
- status = MT2063_ERROR;\r
- break;\r
- }\r
- }\r
-\r
-//#if !TUNER_CONTROL_BY_DRXK_DRIVER\r
- fe->ops.i2c_gate_ctrl(fe, 0); //I2C bypass drxk3926 close i2c bridge\r
-//#endif\r
-\r
- return(status);\r
-}\r
-\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: MT_Sleep\r
-**\r
-** Description: Delay execution for "nMinDelayTime" milliseconds\r
-**\r
-** Parameters: hUserData - User-specific I/O parameter that was\r
-** passed to tuner's Open function.\r
-** nMinDelayTime - Delay time in milliseconds\r
-**\r
-** Returns: None.\r
-**\r
-** Notes: This is a callback function that is called from the\r
-** the tuning algorithm. You MUST provide code that\r
-** blocks execution for the specified period of time. \r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 03-25-2004 DAD Original\r
-**\r
-*****************************************************************************/\r
-void MT2063_Sleep(Handle_t hUserData, \r
- UData_t nMinDelayTime)\r
-{\r
- /*\r
- ** ToDo: Add code here to implement a OS blocking\r
- ** for a period of "nMinDelayTime" milliseconds.\r
- */\r
- msleep(nMinDelayTime);\r
-}\r
-\r
-\r
-#if defined(MT2060_CNT)\r
-#if MT2060_CNT > 0\r
-/*****************************************************************************\r
-**\r
-** Name: MT_TunerGain (MT2060 only)\r
-**\r
-** Description: Measure the relative tuner gain using the demodulator\r
-**\r
-** Parameters: hUserData - User-specific I/O parameter that was\r
-** passed to tuner's Open function.\r
-** pMeas - Tuner gain (1/100 of dB scale).\r
-** ie. 1234 = 12.34 (dB)\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** user-defined errors could be set\r
-**\r
-** Notes: This is a callback function that is called from the\r
-** the 1st IF location routine. You MUST provide\r
-** code that measures the relative tuner gain in a dB\r
-** (not linear) scale. The return value is an integer\r
-** value scaled to 1/100 of a dB.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 06-16-2004 DAD Original\r
-** N/A 11-30-2004 DAD Renamed from MT_DemodInputPower. This name\r
-** better describes what this function does.\r
-**\r
-*****************************************************************************/\r
-UData_t MT2060_TunerGain(Handle_t hUserData,\r
- SData_t* pMeas)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
-\r
- /*\r
- ** ToDo: Add code here to return the gain / power level measured\r
- ** at the input to the demodulator.\r
- */\r
-\r
-\r
-\r
- return (status);\r
-}\r
-#endif\r
-#endif\r
-//end of mt2063_userdef.c\r
-//=================================================================\r
-//#################################################################\r
-//=================================================================\r
-\r
-\r
-//context of mt2063_spuravoid.c <Henry> ======================================\r
-//#################################################################\r
-//=================================================================\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: mt_spuravoid.c\r
-**\r
-** Description: Microtune spur avoidance software module.\r
-** Supports Microtune tuner drivers.\r
-**\r
-** CVS ID: $Id: mt_spuravoid.c,v 1.3 2008/06/26 15:39:52 software Exp $\r
-** CVS Source: $Source: /export/home/cvsroot/software/tuners/MT2063/mt_spuravoid.c,v $\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 082 03-25-2005 JWS Original multi-tuner support - requires\r
-** MTxxxx_CNT declarations\r
-** 096 04-06-2005 DAD Ver 1.11: Fix divide by 0 error if maxH==0.\r
-** 094 04-06-2005 JWS Ver 1.11 Added uceil and ufloor to get rid\r
-** of compiler warnings\r
-** N/A 04-07-2005 DAD Ver 1.13: Merged single- and multi-tuner spur\r
-** avoidance into a single module.\r
-** 103 01-31-2005 DAD Ver 1.14: In MT_AddExclZone(), if the range\r
-** (f_min, f_max) < 0, ignore the entry.\r
-** 115 03-23-2007 DAD Fix declaration of spur due to truncation\r
-** errors.\r
-** 117 03-29-2007 RSK Ver 1.15: Re-wrote to match search order from\r
-** tuner DLL.\r
-** 137 06-18-2007 DAD Ver 1.16: Fix possible divide-by-0 error for\r
-** multi-tuners that have\r
-** (delta IF1) > (f_out-f_outbw/2).\r
-** 147 07-27-2007 RSK Ver 1.17: Corrected calculation (-) to (+)\r
-** Added logic to force f_Center within 1/2 f_Step.\r
-** 177 S 02-26-2008 RSK Ver 1.18: Corrected calculation using LO1 > MAX/2\r
-** Type casts added to preserve correct sign.\r
-** N/A I 06-17-2008 RSK Ver 1.19: Refactoring avoidance of DECT\r
-** frequencies into MT_ResetExclZones().\r
-** N/A I 06-20-2008 RSK Ver 1.21: New VERSION number for ver checking.\r
-**\r
-*****************************************************************************/\r
-\r
-#if !defined(MT2063_TUNER_CNT)\r
-#error MT2063_TUNER_CNT is not defined (see mt_userdef.h)\r
-#endif\r
-\r
-#if MT2063_TUNER_CNT == 0\r
-#error MT2063_TUNER_CNT must be updated in mt_userdef.h\r
-#endif\r
-\r
-/* Version of this module */\r
-#define MT2063_SPUR_VERSION 10201 /* Version 01.21 */\r
-\r
-\r
-/* Implement ceiling, floor functions. */\r
-#define ceil(n, d) (((n) < 0) ? (-((-(n))/(d))) : (n)/(d) + ((n)%(d) != 0))\r
-#define uceil(n, d) ((n)/(d) + ((n)%(d) != 0))\r
-#define floor(n, d) (((n) < 0) ? (-((-(n))/(d))) - ((n)%(d) != 0) : (n)/(d))\r
-#define ufloor(n, d) ((n)/(d))\r
-\r
-\r
-struct MT2063_FIFZone_t\r
-{\r
- SData_t min_;\r
- SData_t max_;\r
-};\r
-\r
-#if MT2063_TUNER_CNT > 1\r
-static struct MT2063_AvoidSpursData_t* TunerList[MT2063_TUNER_CNT];\r
-static UData_t TunerCount = 0;\r
-#endif\r
-\r
-UData_t MT2063_RegisterTuner(struct MT2063_AvoidSpursData_t* pAS_Info)\r
-{\r
-#if MT2063_TUNER_CNT == 1\r
- pAS_Info->nAS_Algorithm = 1;\r
- return MT2063_OK;\r
-#else\r
- UData_t index;\r
-\r
- pAS_Info->nAS_Algorithm = 2;\r
-\r
- /*\r
- ** Check to see if tuner is already registered\r
- */\r
- for (index = 0; index < TunerCount; index++)\r
- {\r
- if (TunerList[index] == pAS_Info)\r
- {\r
- return MT2063_OK; /* Already here - no problem */\r
- }\r
- }\r
-\r
- /*\r
- ** Add tuner to list - if there is room.\r
- */\r
- if (TunerCount < MT2063_TUNER_CNT)\r
- {\r
- TunerList[TunerCount] = pAS_Info;\r
- TunerCount++;\r
- return MT2063_OK;\r
- }\r
- else\r
- return MT2063_TUNER_CNT_ERR;\r
-#endif\r
-}\r
-\r
-\r
-void MT2063_UnRegisterTuner(struct MT2063_AvoidSpursData_t* pAS_Info)\r
-{\r
-#if MT2063_TUNER_CNT == 1\r
- pAS_Info;\r
-#else\r
-\r
- UData_t index;\r
-\r
- for (index = 0; index < TunerCount; index++)\r
- {\r
- if (TunerList[index] == pAS_Info)\r
- {\r
- TunerList[index] = TunerList[--TunerCount];\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-\r
-/*\r
-** Reset all exclusion zones.\r
-** Add zones to protect the PLL FracN regions near zero\r
-**\r
-** N/A I 06-17-2008 RSK Ver 1.19: Refactoring avoidance of DECT\r
-** frequencies into MT_ResetExclZones().\r
-*/\r
-void MT2063_ResetExclZones(struct MT2063_AvoidSpursData_t* pAS_Info)\r
-{\r
- UData_t center;\r
-#if MT2063_TUNER_CNT > 1\r
- UData_t index;\r
- struct MT2063_AvoidSpursData_t* adj;\r
-#endif\r
-\r
- pAS_Info->nZones = 0; /* this clears the used list */\r
- pAS_Info->usedZones = NULL; /* reset ptr */\r
- pAS_Info->freeZones = NULL; /* reset ptr */\r
-\r
- center = pAS_Info->f_ref * ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw/2 + pAS_Info->f_in) / pAS_Info->f_ref) - pAS_Info->f_in;\r
- while (center < pAS_Info->f_if1_Center + pAS_Info->f_if1_bw/2 + pAS_Info->f_LO1_FracN_Avoid)\r
- {\r
- /* Exclude LO1 FracN */\r
- MT2063_AddExclZone(pAS_Info, center-pAS_Info->f_LO1_FracN_Avoid, center-1);\r
- MT2063_AddExclZone(pAS_Info, center+1, center+pAS_Info->f_LO1_FracN_Avoid);\r
- center += pAS_Info->f_ref;\r
- }\r
-\r
- center = pAS_Info->f_ref * ((pAS_Info->f_if1_Center - pAS_Info->f_if1_bw/2 - pAS_Info->f_out) / pAS_Info->f_ref) + pAS_Info->f_out;\r
- while (center < pAS_Info->f_if1_Center + pAS_Info->f_if1_bw/2 + pAS_Info->f_LO2_FracN_Avoid)\r
- {\r
- /* Exclude LO2 FracN */\r
- MT2063_AddExclZone(pAS_Info, center-pAS_Info->f_LO2_FracN_Avoid, center-1);\r
- MT2063_AddExclZone(pAS_Info, center+1, center+pAS_Info->f_LO2_FracN_Avoid);\r
- center += pAS_Info->f_ref;\r
- }\r
-\r
- if( MT2063_EXCLUDE_US_DECT_FREQUENCIES(pAS_Info->avoidDECT) )\r
- {\r
- /* Exclude LO1 values that conflict with DECT channels */\r
- MT2063_AddExclZone(pAS_Info, 1920836000 - pAS_Info->f_in, 1922236000 - pAS_Info->f_in); /* Ctr = 1921.536 */\r
- MT2063_AddExclZone(pAS_Info, 1922564000 - pAS_Info->f_in, 1923964000 - pAS_Info->f_in); /* Ctr = 1923.264 */\r
- MT2063_AddExclZone(pAS_Info, 1924292000 - pAS_Info->f_in, 1925692000 - pAS_Info->f_in); /* Ctr = 1924.992 */\r
- MT2063_AddExclZone(pAS_Info, 1926020000 - pAS_Info->f_in, 1927420000 - pAS_Info->f_in); /* Ctr = 1926.720 */\r
- MT2063_AddExclZone(pAS_Info, 1927748000 - pAS_Info->f_in, 1929148000 - pAS_Info->f_in); /* Ctr = 1928.448 */\r
- }\r
-\r
- if( MT2063_EXCLUDE_EURO_DECT_FREQUENCIES(pAS_Info->avoidDECT) )\r
- {\r
- MT2063_AddExclZone(pAS_Info, 1896644000 - pAS_Info->f_in, 1898044000 - pAS_Info->f_in); /* Ctr = 1897.344 */\r
- MT2063_AddExclZone(pAS_Info, 1894916000 - pAS_Info->f_in, 1896316000 - pAS_Info->f_in); /* Ctr = 1895.616 */\r
- MT2063_AddExclZone(pAS_Info, 1893188000 - pAS_Info->f_in, 1894588000 - pAS_Info->f_in); /* Ctr = 1893.888 */\r
- MT2063_AddExclZone(pAS_Info, 1891460000 - pAS_Info->f_in, 1892860000 - pAS_Info->f_in); /* Ctr = 1892.16 */\r
- MT2063_AddExclZone(pAS_Info, 1889732000 - pAS_Info->f_in, 1891132000 - pAS_Info->f_in); /* Ctr = 1890.432 */\r
- MT2063_AddExclZone(pAS_Info, 1888004000 - pAS_Info->f_in, 1889404000 - pAS_Info->f_in); /* Ctr = 1888.704 */\r
- MT2063_AddExclZone(pAS_Info, 1886276000 - pAS_Info->f_in, 1887676000 - pAS_Info->f_in); /* Ctr = 1886.976 */\r
- MT2063_AddExclZone(pAS_Info, 1884548000 - pAS_Info->f_in, 1885948000 - pAS_Info->f_in); /* Ctr = 1885.248 */\r
- MT2063_AddExclZone(pAS_Info, 1882820000 - pAS_Info->f_in, 1884220000 - pAS_Info->f_in); /* Ctr = 1883.52 */\r
- MT2063_AddExclZone(pAS_Info, 1881092000 - pAS_Info->f_in, 1882492000 - pAS_Info->f_in); /* Ctr = 1881.792 */\r
- }\r
-\r
-#if MT2063_TUNER_CNT > 1\r
- /*\r
- ** Iterate through all adjacent tuners and exclude frequencies related to them\r
- */\r
- for (index = 0; index < TunerCount; ++index)\r
- {\r
- adj = TunerList[index];\r
- if (pAS_Info == adj) /* skip over our own data, don't process it */\r
- continue;\r
-\r
- /*\r
- ** Add 1st IF exclusion zone covering adjacent tuner's LO2\r
- ** at "adjfLO2 + f_out" +/- m_MinLOSpacing\r
- */\r
- if (adj->f_LO2 != 0)\r
- MT2063_AddExclZone(pAS_Info,\r
- (adj->f_LO2 + pAS_Info->f_out) - pAS_Info->f_min_LO_Separation,\r
- (adj->f_LO2 + pAS_Info->f_out) + pAS_Info->f_min_LO_Separation );\r
-\r
- /*\r
- ** Add 1st IF exclusion zone covering adjacent tuner's LO1\r
- ** at "adjfLO1 - f_in" +/- m_MinLOSpacing\r
- */\r
- if (adj->f_LO1 != 0)\r
- MT2063_AddExclZone(pAS_Info,\r
- (adj->f_LO1 - pAS_Info->f_in) - pAS_Info->f_min_LO_Separation,\r
- (adj->f_LO1 - pAS_Info->f_in) + pAS_Info->f_min_LO_Separation );\r
- }\r
-#endif\r
-}\r
-\r
-\r
-static struct MT2063_ExclZone_t* InsertNode(struct MT2063_AvoidSpursData_t* pAS_Info,\r
- struct MT2063_ExclZone_t* pPrevNode)\r
-{\r
- struct MT2063_ExclZone_t* pNode;\r
- /* Check for a node in the free list */\r
- if (pAS_Info->freeZones != NULL)\r
- {\r
- /* Use one from the free list */\r
- pNode = pAS_Info->freeZones;\r
- pAS_Info->freeZones = pNode->next_;\r
- }\r
- else\r
- {\r
- /* Grab a node from the array */\r
- pNode = &pAS_Info->MT2063_ExclZones[pAS_Info->nZones];\r
- }\r
-\r
- if (pPrevNode != NULL)\r
- {\r
- pNode->next_ = pPrevNode->next_;\r
- pPrevNode->next_ = pNode;\r
- }\r
- else /* insert at the beginning of the list */\r
- {\r
- pNode->next_ = pAS_Info->usedZones;\r
- pAS_Info->usedZones = pNode;\r
- }\r
-\r
- pAS_Info->nZones++;\r
- return pNode;\r
-}\r
-\r
-\r
-static struct MT2063_ExclZone_t* RemoveNode(struct MT2063_AvoidSpursData_t* pAS_Info,\r
- struct MT2063_ExclZone_t* pPrevNode,\r
- struct MT2063_ExclZone_t* pNodeToRemove)\r
-{\r
- struct MT2063_ExclZone_t* pNext = pNodeToRemove->next_;\r
-\r
- /* Make previous node point to the subsequent node */\r
- if (pPrevNode != NULL)\r
- pPrevNode->next_ = pNext;\r
-\r
- /* Add pNodeToRemove to the beginning of the freeZones */\r
- pNodeToRemove->next_ = pAS_Info->freeZones;\r
- pAS_Info->freeZones = pNodeToRemove;\r
-\r
- /* Decrement node count */\r
- pAS_Info->nZones--;\r
-\r
- return pNext;\r
-}\r
-\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: MT_AddExclZone\r
-**\r
-** Description: Add (and merge) an exclusion zone into the list.\r
-** If the range (f_min, f_max) is totally outside the\r
-** 1st IF BW, ignore the entry.\r
-** If the range (f_min, f_max) is negative, ignore the entry.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 103 01-31-2005 DAD Ver 1.14: In MT_AddExclZone(), if the range\r
-** (f_min, f_max) < 0, ignore the entry.\r
-**\r
-*****************************************************************************/\r
-void MT2063_AddExclZone(struct MT2063_AvoidSpursData_t* pAS_Info,\r
- UData_t f_min,\r
- UData_t f_max)\r
-{\r
- struct MT2063_ExclZone_t* pNode = pAS_Info->usedZones;\r
- struct MT2063_ExclZone_t* pPrev = NULL;\r
- struct MT2063_ExclZone_t* pNext = NULL;\r
- \r
- /* Check to see if this overlaps the 1st IF filter */\r
- if ((f_max > (pAS_Info->f_if1_Center - (pAS_Info->f_if1_bw / 2)))\r
- && (f_min < (pAS_Info->f_if1_Center + (pAS_Info->f_if1_bw / 2)))\r
- && (f_min < f_max))\r
- {\r
- /*\r
- ** 1 2 3 4 5 6\r
- **\r
- ** New entry: |---| |--| |--| |-| |---| |--|\r
- ** or or or or or\r
- ** Existing: |--| |--| |--| |---| |-| |--|\r
- */\r
- \r
- /* Check for our place in the list */\r
- while ((pNode != NULL) && (pNode->max_ < f_min))\r
- {\r
- pPrev = pNode;\r
- pNode = pNode->next_;\r
- }\r
-\r
- if ((pNode != NULL) && (pNode->min_ < f_max))\r
- {\r
- /* Combine me with pNode */\r
- if (f_min < pNode->min_)\r
- pNode->min_ = f_min;\r
- if (f_max > pNode->max_)\r
- pNode->max_ = f_max;\r
- }\r
- else\r
- {\r
- pNode = InsertNode(pAS_Info, pPrev);\r
- pNode->min_ = f_min;\r
- pNode->max_ = f_max;\r
- }\r
-\r
- /* Look for merging possibilities */\r
- pNext = pNode->next_;\r
- while ((pNext != NULL) && (pNext->min_ < pNode->max_))\r
- {\r
- if (pNext->max_ > pNode->max_)\r
- pNode->max_ = pNext->max_;\r
- pNext = RemoveNode(pAS_Info, pNode, pNext); /* Remove pNext, return ptr to pNext->next */\r
- }\r
- }\r
-}\r
-\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: MT_ChooseFirstIF\r
-**\r
-** Description: Choose the best available 1st IF\r
-** If f_Desired is not excluded, choose that first.\r
-** Otherwise, return the value closest to f_Center that is\r
-** not excluded\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 117 03-29-2007 RSK Ver 1.15: Re-wrote to match search order from\r
-** tuner DLL.\r
-** 147 07-27-2007 RSK Ver 1.17: Corrected calculation (-) to (+)\r
-** Added logic to force f_Center within 1/2 f_Step.\r
-**\r
-*****************************************************************************/\r
-UData_t MT2063_ChooseFirstIF(struct MT2063_AvoidSpursData_t* pAS_Info)\r
-{\r
- /*\r
- ** Update "f_Desired" to be the nearest "combinational-multiple" of "f_LO1_Step".\r
- ** The resulting number, F_LO1 must be a multiple of f_LO1_Step. And F_LO1 is the arithmetic sum\r
- ** of f_in + f_Center. Neither f_in, nor f_Center must be a multiple of f_LO1_Step.\r
- ** However, the sum must be.\r
- */\r
- const UData_t f_Desired = pAS_Info->f_LO1_Step * ((pAS_Info->f_if1_Request + pAS_Info->f_in + pAS_Info->f_LO1_Step/2) / pAS_Info->f_LO1_Step) - pAS_Info->f_in;\r
- const UData_t f_Step = (pAS_Info->f_LO1_Step > pAS_Info->f_LO2_Step) ? pAS_Info->f_LO1_Step : pAS_Info->f_LO2_Step;\r
- UData_t f_Center;\r
-\r
- SData_t i;\r
- SData_t j = 0;\r
- UData_t bDesiredExcluded = 0;\r
- UData_t bZeroExcluded = 0;\r
- SData_t tmpMin, tmpMax;\r
- SData_t bestDiff;\r
- struct MT2063_ExclZone_t* pNode = pAS_Info->usedZones;\r
- struct MT2063_FIFZone_t zones[MT2063_MAX_ZONES];\r
-\r
- if (pAS_Info->nZones == 0)\r
- return f_Desired;\r
-\r
- /* f_Center needs to be an integer multiple of f_Step away from f_Desired */\r
- if (pAS_Info->f_if1_Center > f_Desired)\r
- f_Center = f_Desired + f_Step * ((pAS_Info->f_if1_Center - f_Desired + f_Step/2) / f_Step);\r
- else\r
- f_Center = f_Desired - f_Step * ((f_Desired - pAS_Info->f_if1_Center + f_Step/2) / f_Step);\r
-\r
- //assert;\r
- //if (!abs((SData_t) f_Center - (SData_t) pAS_Info->f_if1_Center) <= (SData_t) (f_Step/2))\r
- // return 0;\r
-\r
- /* Take MT_ExclZones, center around f_Center and change the resolution to f_Step */\r
- while (pNode != NULL)\r
- {\r
- /* floor function */\r
- tmpMin = floor((SData_t) (pNode->min_ - f_Center), (SData_t) f_Step);\r
-\r
- /* ceil function */\r
- tmpMax = ceil((SData_t) (pNode->max_ - f_Center), (SData_t) f_Step);\r
-\r
- if ((pNode->min_ < f_Desired) && (pNode->max_ > f_Desired))\r
- bDesiredExcluded = 1;\r
-\r
- if ((tmpMin < 0) && (tmpMax > 0))\r
- bZeroExcluded = 1;\r
-\r
- /* See if this zone overlaps the previous */\r
- if ((j>0) && (tmpMin < zones[j-1].max_))\r
- zones[j-1].max_ = tmpMax;\r
- else\r
- {\r
- /* Add new zone */\r
- //assert(j<MT2063_MAX_ZONES);\r
- //if (j>=MT2063_MAX_ZONES)\r
- //break;\r
- \r
- zones[j].min_ = tmpMin;\r
- zones[j].max_ = tmpMax;\r
- j++;\r
- }\r
- pNode = pNode->next_;\r
- }\r
-\r
- /*\r
- ** If the desired is okay, return with it\r
- */\r
- if (bDesiredExcluded == 0)\r
- return f_Desired;\r
-\r
- /*\r
- ** If the desired is excluded and the center is okay, return with it\r
- */\r
- if (bZeroExcluded == 0)\r
- return f_Center;\r
-\r
- /* Find the value closest to 0 (f_Center) */\r
- bestDiff = zones[0].min_;\r
- for (i=0; i<j; i++)\r
- {\r
- if (abs(zones[i].min_) < abs(bestDiff)) bestDiff = zones[i].min_;\r
- if (abs(zones[i].max_) < abs(bestDiff)) bestDiff = zones[i].max_;\r
- }\r
-\r
-\r
- if (bestDiff < 0)\r
- return f_Center - ((UData_t) (-bestDiff) * f_Step);\r
-\r
- return f_Center + (bestDiff * f_Step);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: gcd\r
-**\r
-** Description: Uses Euclid's algorithm\r
-**\r
-** Parameters: u, v - unsigned values whose GCD is desired.\r
-**\r
-** Global: None\r
-**\r
-** Returns: greatest common divisor of u and v, if either value\r
-** is 0, the other value is returned as the result.\r
-**\r
-** Dependencies: None.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 06-01-2004 JWS Original\r
-** N/A 08-03-2004 DAD Changed to Euclid's since it can handle\r
-** unsigned numbers.\r
-**\r
-****************************************************************************/\r
-static UData_t MT2063_gcd(UData_t u, UData_t v)\r
-{\r
- UData_t r;\r
-\r
- while (v != 0)\r
- {\r
- r = u % v;\r
- u = v;\r
- v = r;\r
- }\r
-\r
- return u;\r
-}\r
-\r
-/****************************************************************************\r
-**\r
-** Name: umax\r
-**\r
-** Description: Implements a simple maximum function for unsigned numbers.\r
-** Implemented as a function rather than a macro to avoid\r
-** multiple evaluation of the calling parameters.\r
-**\r
-** Parameters: a, b - Values to be compared\r
-**\r
-** Global: None\r
-**\r
-** Returns: larger of the input values.\r
-**\r
-** Dependencies: None.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 06-02-2004 JWS Original\r
-**\r
-****************************************************************************/\r
-static UData_t MT2063_umax(UData_t a, UData_t b)\r
-{\r
- return (a >= b) ? a : b;\r
-}\r
-\r
-#if MT2063_TUNER_CNT > 1\r
-static SData_t RoundAwayFromZero(SData_t n, SData_t d)\r
-{\r
- return (n<0) ? floor(n, d) : ceil(n, d);\r
-}\r
-\r
-/****************************************************************************\r
-**\r
-** Name: IsSpurInAdjTunerBand\r
-**\r
-** Description: Checks to see if a spur will be present within the IF's\r
-** bandwidth or near the zero IF.\r
-** (fIFOut +/- fIFBW/2, -fIFOut +/- fIFBW/2)\r
-** and\r
-** (0 +/- fZIFBW/2)\r
-**\r
-** ma mb me mf mc md\r
-** <--+-+-+-----------------+-+-+-----------------+-+-+-->\r
-** | ^ 0 ^ |\r
-** ^ b=-fIFOut+fIFBW/2 -b=+fIFOut-fIFBW/2 ^\r
-** a=-fIFOut-fIFBW/2 -a=+fIFOut+fIFBW/2\r
-**\r
-** Note that some equations are doubled to prevent round-off\r
-** problems when calculating fIFBW/2\r
-**\r
-** The spur frequencies are computed as:\r
-**\r
-** fSpur = n * f1 - m * f2 - fOffset\r
-**\r
-** Parameters: f1 - The 1st local oscillator (LO) frequency\r
-** of the tuner whose output we are examining\r
-** f2 - The 1st local oscillator (LO) frequency\r
-** of the adjacent tuner\r
-** fOffset - The 2nd local oscillator of the tuner whose\r
-** output we are examining\r
-** fIFOut - Output IF center frequency\r
-** fIFBW - Output IF Bandwidth\r
-** nMaxH - max # of LO harmonics to search\r
-** fp - If spur, positive distance to spur-free band edge (returned)\r
-** fm - If spur, negative distance to spur-free band edge (returned)\r
-**\r
-** Returns: 1 if an LO spur would be present, otherwise 0.\r
-**\r
-** Dependencies: None.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 01-21-2005 JWS Original, adapted from MT_DoubleConversion.\r
-** 115 03-23-2007 DAD Fix declaration of spur due to truncation\r
-** errors.\r
-** 137 06-18-2007 DAD Ver 1.16: Fix possible divide-by-0 error for\r
-** multi-tuners that have\r
-** (delta IF1) > (f_out-f_outbw/2).\r
-** 177 S 02-26-2008 RSK Ver 1.18: Corrected calculation using LO1 > MAX/2\r
-** Type casts added to preserve correct sign.\r
-**\r
-****************************************************************************/\r
-static UData_t IsSpurInAdjTunerBand(UData_t bIsMyOutput,\r
- UData_t f1,\r
- UData_t f2,\r
- UData_t fOffset,\r
- UData_t fIFOut,\r
- UData_t fIFBW,\r
- UData_t fZIFBW,\r
- UData_t nMaxH,\r
- UData_t *fp,\r
- UData_t *fm)\r
-{\r
- UData_t bSpurFound = 0;\r
-\r
- const UData_t fHalf_IFBW = fIFBW / 2;\r
- const UData_t fHalf_ZIFBW = fZIFBW / 2;\r
-\r
- /* Calculate a scale factor for all frequencies, so that our\r
- calculations all stay within 31 bits */\r
- const UData_t f_Scale = ((f1 + (fOffset + fIFOut + fHalf_IFBW) / nMaxH) / (MAX_UDATA/2 / nMaxH)) + 1;\r
-\r
- /*\r
- ** After this scaling, _f1, _f2, and _f3 are guaranteed to fit into\r
- ** signed data types (smaller than MAX_UDATA/2)\r
- */\r
- const SData_t _f1 = (SData_t) ( f1 / f_Scale);\r
- const SData_t _f2 = (SData_t) ( f2 / f_Scale);\r
- const SData_t _f3 = (SData_t) (fOffset / f_Scale);\r
-\r
- const SData_t c = (SData_t) (fIFOut - fHalf_IFBW) / (SData_t) f_Scale;\r
- const SData_t d = (SData_t) ((fIFOut + fHalf_IFBW) / f_Scale);\r
- const SData_t f = (SData_t) (fHalf_ZIFBW / f_Scale);\r
-\r
- SData_t ma, mb, mc, md, me, mf;\r
-\r
- SData_t fp_ = 0;\r
- SData_t fm_ = 0;\r
- SData_t n;\r
-\r
-\r
- /*\r
- ** If the other tuner does not have an LO frequency defined,\r
- ** assume that we cannot interfere with it\r
- */\r
- if (f2 == 0)\r
- return 0;\r
-\r
-\r
- /* Check out all multiples of f1 from -nMaxH to +nMaxH */\r
- for (n = -(SData_t)nMaxH; n <= (SData_t)nMaxH; ++n)\r
- {\r
- const SData_t nf1 = n*_f1;\r
- md = (_f3 + d - nf1) / _f2;\r
-\r
- /* If # f2 harmonics > nMaxH, then no spurs present */\r
- if (md <= -(SData_t) nMaxH )\r
- break;\r
-\r
- ma = (_f3 - d - nf1) / _f2;\r
- if ((ma == md) || (ma >= (SData_t) (nMaxH)))\r
- continue;\r
-\r
- mc = (_f3 + c - nf1) / _f2;\r
- if (mc != md)\r
- {\r
- const SData_t m = (n<0) ? md : mc;\r
- const SData_t fspur = (nf1 + m*_f2 - _f3);\r
- const SData_t den = (bIsMyOutput ? n - 1 : n);\r
- if (den == 0)\r
- {\r
- fp_ = (d - fspur)* f_Scale;\r
- fm_ = (fspur - c)* f_Scale;\r
- }\r
- else\r
- {\r
- fp_ = (SData_t) RoundAwayFromZero((d - fspur)* f_Scale, den);\r
- fm_ = (SData_t) RoundAwayFromZero((fspur - c)* f_Scale, den);\r
- }\r
- if (((UData_t)abs(fm_) >= f_Scale) && ((UData_t)abs(fp_) >= f_Scale))\r
- {\r
- bSpurFound = 1;\r
- break;\r
- }\r
- }\r
-\r
- /* Location of Zero-IF-spur to be checked */\r
- mf = (_f3 + f - nf1) / _f2;\r
- me = (_f3 - f - nf1) / _f2;\r
- if (me != mf)\r
- {\r
- const SData_t m = (n<0) ? mf : me;\r
- const SData_t fspur = (nf1 + m*_f2 - _f3);\r
- const SData_t den = (bIsMyOutput ? n - 1 : n);\r
- if (den == 0)\r
- {\r
- fp_ = (d - fspur)* f_Scale;\r
- fm_ = (fspur - c)* f_Scale;\r
- }\r
- else\r
- {\r
- fp_ = (SData_t) RoundAwayFromZero((f - fspur)* f_Scale, den);\r
- fm_ = (SData_t) RoundAwayFromZero((fspur + f)* f_Scale, den);\r
- }\r
- if (((UData_t)abs(fm_) >= f_Scale) && ((UData_t)abs(fp_) >= f_Scale))\r
- {\r
- bSpurFound = 1;\r
- break;\r
- }\r
- }\r
-\r
- mb = (_f3 - c - nf1) / _f2;\r
- if (ma != mb)\r
- {\r
- const SData_t m = (n<0) ? mb : ma;\r
- const SData_t fspur = (nf1 + m*_f2 - _f3);\r
- const SData_t den = (bIsMyOutput ? n - 1 : n);\r
- if (den == 0)\r
- {\r
- fp_ = (d - fspur)* f_Scale;\r
- fm_ = (fspur - c)* f_Scale;\r
- }\r
- else\r
- {\r
- fp_ = (SData_t) RoundAwayFromZero((-c - fspur)* f_Scale, den);\r
- fm_ = (SData_t) RoundAwayFromZero((fspur +d)* f_Scale, den);\r
- }\r
- if (((UData_t)abs(fm_) >= f_Scale) && ((UData_t)abs(fp_) >= f_Scale))\r
- {\r
- bSpurFound = 1;\r
- break;\r
- }\r
- }\r
- }\r
-\r
- /*\r
- ** Verify that fm & fp are both positive\r
- ** Add one to ensure next 1st IF choice is not right on the edge\r
- */\r
- if (fp_ < 0)\r
- {\r
- *fp = -fm_ + 1;\r
- *fm = -fp_ + 1;\r
- }\r
- else if (fp_ > 0)\r
- {\r
- *fp = fp_ + 1;\r
- *fm = fm_ + 1;\r
- }\r
- else\r
- {\r
- *fp = 1;\r
- *fm = abs(fm_) + 1;\r
- }\r
-\r
- return bSpurFound;\r
-}\r
-#endif\r
-\r
-/****************************************************************************\r
-**\r
-** Name: IsSpurInBand\r
-**\r
-** Description: Checks to see if a spur will be present within the IF's\r
-** bandwidth. (fIFOut +/- fIFBW, -fIFOut +/- fIFBW)\r
-**\r
-** ma mb mc md\r
-** <--+-+-+-------------------+-------------------+-+-+-->\r
-** | ^ 0 ^ |\r
-** ^ b=-fIFOut+fIFBW/2 -b=+fIFOut-fIFBW/2 ^\r
-** a=-fIFOut-fIFBW/2 -a=+fIFOut+fIFBW/2\r
-**\r
-** Note that some equations are doubled to prevent round-off\r
-** problems when calculating fIFBW/2\r
-**\r
-** Parameters: pAS_Info - Avoid Spurs information block\r
-** fm - If spur, amount f_IF1 has to move negative\r
-** fp - If spur, amount f_IF1 has to move positive\r
-**\r
-** Global: None\r
-**\r
-** Returns: 1 if an LO spur would be present, otherwise 0.\r
-**\r
-** Dependencies: None.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** N/A 11-28-2002 DAD Implemented algorithm from applied patent\r
-**\r
-****************************************************************************/\r
-static UData_t IsSpurInBand(struct MT2063_AvoidSpursData_t* pAS_Info,\r
- UData_t* fm,\r
- UData_t* fp)\r
-{\r
- /*\r
- ** Calculate LO frequency settings.\r
- */\r
- UData_t n, n0;\r
- const UData_t f_LO1 = pAS_Info->f_LO1;\r
- const UData_t f_LO2 = pAS_Info->f_LO2;\r
- const UData_t d = pAS_Info->f_out + pAS_Info->f_out_bw/2;\r
- const UData_t c = d - pAS_Info->f_out_bw;\r
- const UData_t f = pAS_Info->f_zif_bw/2;\r
- const UData_t f_Scale = (f_LO1 / (MAX_UDATA/2 / pAS_Info->maxH1)) + 1;\r
- SData_t f_nsLO1, f_nsLO2;\r
- SData_t f_Spur;\r
- UData_t ma, mb, mc, md, me, mf;\r
- UData_t lo_gcd, gd_Scale, gc_Scale, gf_Scale, hgds, hgfs, hgcs;\r
-#if MT2063_TUNER_CNT > 1\r
- UData_t index;\r
-\r
- struct MT2063_AvoidSpursData_t *adj;\r
-#endif\r
- *fm = 0;\r
-\r
- /*\r
- ** For each edge (d, c & f), calculate a scale, based on the gcd\r
- ** of f_LO1, f_LO2 and the edge value. Use the larger of this\r
- ** gcd-based scale factor or f_Scale.\r
- */\r
- lo_gcd = MT2063_gcd(f_LO1, f_LO2);\r
- gd_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, d), f_Scale);\r
- hgds = gd_Scale/2;\r
- gc_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, c), f_Scale);\r
- hgcs = gc_Scale/2;\r
- gf_Scale = MT2063_umax((UData_t) MT2063_gcd(lo_gcd, f), f_Scale);\r
- hgfs = gf_Scale/2;\r
-\r
- n0 = uceil(f_LO2 - d, f_LO1 - f_LO2);\r
-\r
- /* Check out all multiples of LO1 from n0 to m_maxLOSpurHarmonic */\r
- for (n=n0; n<=pAS_Info->maxH1; ++n)\r
- {\r
- md = (n*((f_LO1+hgds)/gd_Scale) - ((d+hgds)/gd_Scale)) / ((f_LO2+hgds)/gd_Scale);\r
-\r
- /* If # fLO2 harmonics > m_maxLOSpurHarmonic, then no spurs present */\r
- if (md >= pAS_Info->maxH1)\r
- break;\r
-\r
- ma = (n*((f_LO1+hgds)/gd_Scale) + ((d+hgds)/gd_Scale)) / ((f_LO2+hgds)/gd_Scale);\r
-\r
- /* If no spurs between +/- (f_out + f_IFBW/2), then try next harmonic */\r
- if (md == ma)\r
- continue;\r
-\r
- mc = (n*((f_LO1+hgcs)/gc_Scale) - ((c+hgcs)/gc_Scale)) / ((f_LO2+hgcs)/gc_Scale);\r
- if (mc != md)\r
- {\r
- f_nsLO1 = (SData_t) (n*(f_LO1/gc_Scale));\r
- f_nsLO2 = (SData_t) (mc*(f_LO2/gc_Scale));\r
- f_Spur = (gc_Scale * (f_nsLO1 - f_nsLO2)) + n*(f_LO1 % gc_Scale) - mc*(f_LO2 % gc_Scale);\r
-\r
- *fp = ((f_Spur - (SData_t) c) / (mc - n)) + 1;\r
- *fm = (((SData_t) d - f_Spur) / (mc - n)) + 1;\r
- return 1;\r
- }\r
-\r
- /* Location of Zero-IF-spur to be checked */\r
- me = (n*((f_LO1+hgfs)/gf_Scale) + ((f+hgfs)/gf_Scale)) / ((f_LO2+hgfs)/gf_Scale);\r
- mf = (n*((f_LO1+hgfs)/gf_Scale) - ((f+hgfs)/gf_Scale)) / ((f_LO2+hgfs)/gf_Scale);\r
- if (me != mf)\r
- {\r
- f_nsLO1 = n*(f_LO1/gf_Scale);\r
- f_nsLO2 = me*(f_LO2/gf_Scale);\r
- f_Spur = (gf_Scale * (f_nsLO1 - f_nsLO2)) + n*(f_LO1 % gf_Scale) - me*(f_LO2 % gf_Scale);\r
-\r
- *fp = ((f_Spur + (SData_t) f) / (me - n)) + 1;\r
- *fm = (((SData_t) f - f_Spur) / (me - n)) + 1;\r
- return 1;\r
- }\r
-\r
- mb = (n*((f_LO1+hgcs)/gc_Scale) + ((c+hgcs)/gc_Scale)) / ((f_LO2+hgcs)/gc_Scale);\r
- if (ma != mb)\r
- {\r
- f_nsLO1 = n*(f_LO1/gc_Scale);\r
- f_nsLO2 = ma*(f_LO2/gc_Scale);\r
- f_Spur = (gc_Scale * (f_nsLO1 - f_nsLO2)) + n*(f_LO1 % gc_Scale) - ma*(f_LO2 % gc_Scale);\r
-\r
- *fp = (((SData_t) d + f_Spur) / (ma - n)) + 1;\r
- *fm = (-(f_Spur + (SData_t) c) / (ma - n)) + 1;\r
- return 1;\r
- }\r
- }\r
-\r
-#if MT2063_TUNER_CNT > 1\r
- /* If no spur found, see if there are more tuners on the same board */\r
- for (index = 0; index < TunerCount; ++index)\r
- {\r
- adj = TunerList[index];\r
- if (pAS_Info == adj) /* skip over our own data, don't process it */\r
- continue;\r
-\r
- /* Look for LO-related spurs from the adjacent tuner generated into my IF output */\r
- if (IsSpurInAdjTunerBand(1, /* check my IF output */\r
- pAS_Info->f_LO1, /* my fLO1 */\r
- adj->f_LO1, /* the other tuner's fLO1 */\r
- pAS_Info->f_LO2, /* my fLO2 */\r
- pAS_Info->f_out, /* my fOut */\r
- pAS_Info->f_out_bw, /* my output IF bandwidth */\r
- pAS_Info->f_zif_bw, /* my Zero-IF bandwidth */\r
- pAS_Info->maxH2,\r
- fp, /* minimum amount to move LO's positive */\r
- fm)) /* miminum amount to move LO's negative */\r
- return 1;\r
- /* Look for LO-related spurs from my tuner generated into the adjacent tuner's IF output */\r
- if (IsSpurInAdjTunerBand(0, /* check his IF output */\r
- pAS_Info->f_LO1, /* my fLO1 */\r
- adj->f_LO1, /* the other tuner's fLO1 */\r
- adj->f_LO2, /* the other tuner's fLO2 */\r
- adj->f_out, /* the other tuner's fOut */\r
- adj->f_out_bw, /* the other tuner's output IF bandwidth */\r
- pAS_Info->f_zif_bw, /* the other tuner's Zero-IF bandwidth */\r
- adj->maxH2,\r
- fp, /* minimum amount to move LO's positive */\r
- fm)) /* miminum amount to move LO's negative */\r
- return 1;\r
- }\r
-#endif\r
- /* No spurs found */\r
- return 0;\r
-}\r
-\r
-\r
-/*****************************************************************************\r
-**\r
-** Name: MT_AvoidSpurs\r
-**\r
-** Description: Main entry point to avoid spurs.\r
-** Checks for existing spurs in present LO1, LO2 freqs\r
-** and if present, chooses spur-free LO1, LO2 combination\r
-** that tunes the same input/output frequencies.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 096 04-06-2005 DAD Ver 1.11: Fix divide by 0 error if maxH==0.\r
-**\r
-*****************************************************************************/\r
-UData_t MT2063_AvoidSpurs(Handle_t h,\r
- struct MT2063_AvoidSpursData_t* pAS_Info)\r
-{\r
- UData_t status = MT2063_OK;\r
- UData_t fm, fp; /* restricted range on LO's */\r
- pAS_Info->bSpurAvoided = 0;\r
- pAS_Info->nSpursFound = 0;\r
-\r
- if (pAS_Info->maxH1 == 0)\r
- return MT2063_OK;\r
-\r
- /*\r
- ** Avoid LO Generated Spurs\r
- **\r
- ** Make sure that have no LO-related spurs within the IF output\r
- ** bandwidth.\r
- **\r
- ** If there is an LO spur in this band, start at the current IF1 frequency\r
- ** and work out until we find a spur-free frequency or run up against the\r
- ** 1st IF SAW band edge. Use temporary copies of fLO1 and fLO2 so that they\r
- ** will be unchanged if a spur-free setting is not found.\r
- */\r
- pAS_Info->bSpurPresent = IsSpurInBand(pAS_Info, &fm, &fp);\r
- if (pAS_Info->bSpurPresent)\r
- {\r
- UData_t zfIF1 = pAS_Info->f_LO1 - pAS_Info->f_in; /* current attempt at a 1st IF */\r
- UData_t zfLO1 = pAS_Info->f_LO1; /* current attempt at an LO1 freq */\r
- UData_t zfLO2 = pAS_Info->f_LO2; /* current attempt at an LO2 freq */\r
- UData_t delta_IF1;\r
- UData_t new_IF1;\r
-\r
- /*\r
- ** Spur was found, attempt to find a spur-free 1st IF\r
- */\r
- do\r
- {\r
- pAS_Info->nSpursFound++;\r
-\r
- /* Raise f_IF1_upper, if needed */\r
- MT2063_AddExclZone(pAS_Info, zfIF1 - fm, zfIF1 + fp);\r
-\r
- /* Choose next IF1 that is closest to f_IF1_CENTER */\r
- new_IF1 = MT2063_ChooseFirstIF(pAS_Info);\r
-\r
- if (new_IF1 > zfIF1)\r
- {\r
- pAS_Info->f_LO1 += (new_IF1 - zfIF1);\r
- pAS_Info->f_LO2 += (new_IF1 - zfIF1);\r
- }\r
- else\r
- {\r
- pAS_Info->f_LO1 -= (zfIF1 - new_IF1);\r
- pAS_Info->f_LO2 -= (zfIF1 - new_IF1);\r
- }\r
- zfIF1 = new_IF1;\r
-\r
- if (zfIF1 > pAS_Info->f_if1_Center)\r
- delta_IF1 = zfIF1 - pAS_Info->f_if1_Center;\r
- else\r
- delta_IF1 = pAS_Info->f_if1_Center - zfIF1;\r
- }\r
- /*\r
- ** Continue while the new 1st IF is still within the 1st IF bandwidth\r
- ** and there is a spur in the band (again)\r
- */\r
- while ((2*delta_IF1 + pAS_Info->f_out_bw <= pAS_Info->f_if1_bw) &&\r
- (pAS_Info->bSpurPresent = IsSpurInBand(pAS_Info, &fm, &fp)));\r
-\r
- /*\r
- ** Use the LO-spur free values found. If the search went all the way to\r
- ** the 1st IF band edge and always found spurs, just leave the original\r
- ** choice. It's as "good" as any other.\r
- */\r
- if (pAS_Info->bSpurPresent == 1)\r
- {\r
- status |= MT2063_SPUR_PRESENT_ERR;\r
- pAS_Info->f_LO1 = zfLO1;\r
- pAS_Info->f_LO2 = zfLO2;\r
- }\r
- else\r
- pAS_Info->bSpurAvoided = 1;\r
- }\r
-\r
- status |= ((pAS_Info->nSpursFound << MT2063_SPUR_SHIFT) & MT2063_SPUR_CNT_MASK);\r
-\r
- return (status);\r
-}\r
-\r
-\r
-UData_t MT2063_AvoidSpursVersion(void)\r
-{\r
- return (MT2063_SPUR_VERSION);\r
-}\r
-//end of mt2063_spuravoid.c\r
-//=================================================================\r
-//#################################################################\r
-//=================================================================\r
-\r
-\r
-/*\r
-** The expected version of MT_AvoidSpursData_t\r
-** If the version is different, an updated file is needed from Microtune\r
-*/\r
-/* Expecting version 1.21 of the Spur Avoidance API */\r
-#define EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION 010201\r
-\r
-#if MT2063_AVOID_SPURS_INFO_VERSION < EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION\r
-#error Contact Microtune for a newer version of MT_SpurAvoid.c\r
-#elif MT2063_AVOID_SPURS_INFO_VERSION > EXPECTED_MT2063_AVOID_SPURS_INFO_VERSION\r
-#error Contact Microtune for a newer version of mt2063.c\r
-#endif\r
-\r
-#ifndef MT2063_CNT\r
-#error You must define MT2063_CNT in the "mt_userdef.h" file\r
-#endif\r
-\r
-\r
-typedef enum\r
-{\r
- MT2063_SET_ATTEN,\r
- MT2063_INCR_ATTEN,\r
- MT2063_DECR_ATTEN\r
-} MT2063_ATTEN_CNTL_MODE;\r
-\r
-\r
-//#define TUNER_MT2063_OPTIMIZATION\r
-/*\r
-** Constants used by the tuning algorithm\r
-*/\r
-#define MT2063_REF_FREQ (16000000UL) /* Reference oscillator Frequency (in Hz) */\r
-#define MT2063_IF1_BW (22000000UL) /* The IF1 filter bandwidth (in Hz) */\r
-#define MT2063_TUNE_STEP_SIZE (50000UL) /* Tune in steps of 50 kHz */\r
-#define MT2063_SPUR_STEP_HZ (250000UL) /* Step size (in Hz) to move IF1 when avoiding spurs */\r
-#define MT2063_ZIF_BW (2000000UL) /* Zero-IF spur-free bandwidth (in Hz) */\r
-#define MT2063_MAX_HARMONICS_1 (15UL) /* Highest intra-tuner LO Spur Harmonic to be avoided */\r
-#define MT2063_MAX_HARMONICS_2 (5UL) /* Highest inter-tuner LO Spur Harmonic to be avoided */\r
-#define MT2063_MIN_LO_SEP (1000000UL) /* Minimum inter-tuner LO frequency separation */\r
-#define MT2063_LO1_FRACN_AVOID (0UL) /* LO1 FracN numerator avoid region (in Hz) */\r
-#define MT2063_LO2_FRACN_AVOID (199999UL) /* LO2 FracN numerator avoid region (in Hz) */\r
-#define MT2063_MIN_FIN_FREQ (44000000UL) /* Minimum input frequency (in Hz) */\r
-#define MT2063_MAX_FIN_FREQ (1100000000UL) /* Maximum input frequency (in Hz) */\r
-#define MT2063_MIN_FOUT_FREQ (36000000UL) /* Minimum output frequency (in Hz) */\r
-#define MT2063_MAX_FOUT_FREQ (57000000UL) /* Maximum output frequency (in Hz) */\r
-#define MT2063_MIN_DNC_FREQ (1293000000UL) /* Minimum LO2 frequency (in Hz) */\r
-#define MT2063_MAX_DNC_FREQ (1614000000UL) /* Maximum LO2 frequency (in Hz) */\r
-#define MT2063_MIN_UPC_FREQ (1396000000UL) /* Minimum LO1 frequency (in Hz) */\r
-#define MT2063_MAX_UPC_FREQ (2750000000UL) /* Maximum LO1 frequency (in Hz) */\r
-\r
-\r
-/*\r
-** Define the supported Part/Rev codes for the MT2063\r
-*/\r
-#define MT2063_B0 (0x9B)\r
-#define MT2063_B1 (0x9C)\r
-#define MT2063_B2 (0x9D)\r
-#define MT2063_B3 (0x9E)\r
-\r
-/*\r
-** The number of Tuner Registers\r
-*/\r
-static const UData_t MT2063_Num_Registers = MT2063_REG_END_REGS;\r
-\r
-\r
-#define USE_GLOBAL_TUNER 0\r
-\r
-static UData_t nMT2063MaxTuners = MT2063_CNT;\r
-static struct MT2063_Info_t MT2063_Info[MT2063_CNT];\r
-static struct MT2063_Info_t *MT2063_Avail[MT2063_CNT];\r
-static UData_t nMT2063OpenTuners = 0;\r
-\r
-\r
-/*\r
-** Constants for setting receiver modes.\r
-** (6 modes defined at this time, enumerated by MT2063_RCVR_MODES)\r
-** (DNC1GC & DNC2GC are the values, which are used, when the specific\r
-** DNC Output is selected, the other is always off)\r
-**\r
-** If PAL-L or L' is received, set:\r
-** MT2063_SetParam(hMT2063,MT2063_TAGC,1);\r
-**\r
-** --------------+----------------------------------------------\r
-** Mode 0 : | MT2063_CABLE_QAM\r
-** Mode 1 : | MT2063_CABLE_ANALOG\r
-** Mode 2 : | MT2063_OFFAIR_COFDM\r
-** Mode 3 : | MT2063_OFFAIR_COFDM_SAWLESS\r
-** Mode 4 : | MT2063_OFFAIR_ANALOG\r
-** Mode 5 : | MT2063_OFFAIR_8VSB\r
-** --------------+----+----+----+----+-----+-----+--------------\r
-** Mode | 0 | 1 | 2 | 3 | 4 | 5 |\r
-** --------------+----+----+----+----+-----+-----+\r
-**\r
-**\r
-*/\r
-static const U8Data RFAGCEN[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data LNARIN[] = { 0, 0, 3, 3, 3, 3 };\r
-static const U8Data FIFFQEN[] = { 1, 1, 1, 1, 1, 1 };\r
-static const U8Data FIFFQ[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data DNC1GC[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data DNC2GC[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data ACLNAMAX[] = { 31, 31, 31, 31, 31, 31 };\r
-static const U8Data LNATGT[] = { 44, 43, 43, 43, 43, 43 };\r
-static const U8Data RFOVDIS[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data ACRFMAX[] = { 31, 31, 31, 31, 31, 31 };\r
-static const U8Data PD1TGT[] = { 36, 36, 38, 38, 36, 38 };\r
-static const U8Data FIFOVDIS[] = { 0, 0, 0, 0, 0, 0 };\r
-static const U8Data ACFIFMAX[] = { 29, 29, 29, 29, 29, 29 };\r
-static const U8Data PD2TGT[] = { 40, 33, 38, 42, 30, 38 };\r
-\r
-/*\r
-** Local Function Prototypes - not available for external access.\r
-*/\r
-\r
-/* Forward declaration(s): */\r
-static UData_t MT2063_CalcLO1Mult(UData_t *Div, UData_t *FracN, UData_t f_LO, UData_t f_LO_Step, UData_t f_Ref);\r
-static UData_t MT2063_CalcLO2Mult(UData_t *Div, UData_t *FracN, UData_t f_LO, UData_t f_LO_Step, UData_t f_Ref);\r
-static UData_t MT2063_fLO_FractionalTerm(UData_t f_ref, UData_t num, UData_t denom);\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_Open\r
-**\r
-** Description: Initialize the tuner's register values.\r
-**\r
-** Parameters: MT2063_Addr - Serial bus address of the tuner.\r
-** hMT2063 - Tuner handle passed back.\r
-** hUserData - User-defined data, if needed for the\r
-** MT_ReadSub() & MT_WriteSub functions.\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch\r
-** MT_TUNER_INIT_ERR - Tuner initialization failed\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_ARG_NULL - Null pointer argument passed\r
-** MT_TUNER_CNT_ERR - Too many tuners open\r
-**\r
-** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus\r
-** MT_WriteSub - Write byte(s) of data to the two-wire bus\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_Open(UData_t MT2063_Addr,\r
- Handle_t* hMT2063,\r
- Handle_t hUserData)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned. */\r
- SData_t i;\r
- struct MT2063_Info_t* pInfo = NULL;\r
- struct dvb_frontend *fe= (struct dvb_frontend *)hUserData;\r
- struct mt2063_state *state = fe->tuner_priv;\r
-\r
- /* Check the argument before using */\r
- if (hMT2063 == NULL)\r
- { \r
- return MT2063_ARG_NULL;\r
- }\r
- \r
- /* Default tuner handle to NULL. If successful, it will be reassigned */\r
- \r
-#if USE_GLOBAL_TUNER\r
- *hMT2063 = NULL;\r
-\r
- /*\r
- ** If this is our first tuner, initialize the address fields and\r
- ** the list of available control blocks.\r
- */\r
- if (nMT2063OpenTuners == 0)\r
- {\r
- for (i=MT2063_CNT-1; i>=0; i--)\r
- {\r
- MT2063_Info[i].handle = NULL;\r
- MT2063_Info[i].address = MAX_UDATA;\r
- MT2063_Info[i].rcvr_mode = MT2063_CABLE_QAM;\r
- MT2063_Info[i].hUserData = NULL;\r
- MT2063_Avail[i] = &MT2063_Info[i];\r
- }\r
- }\r
-\r
- /*\r
- ** Look for an existing MT2063_State_t entry with this address.\r
- */\r
- for (i=MT2063_CNT-1; i>=0; i--)\r
- {\r
- /*\r
- ** If an open'ed handle provided, we'll re-initialize that structure.\r
- **\r
- ** We recognize an open tuner because the address and hUserData are\r
- ** the same as one that has already been opened\r
- */\r
- if ((MT2063_Info[i].address == MT2063_Addr) &&\r
- (MT2063_Info[i].hUserData == hUserData))\r
- {\r
- pInfo = &MT2063_Info[i];\r
- break;\r
- }\r
- }\r
-\r
- /* If not found, choose an empty spot. */\r
- if (pInfo == NULL)\r
- {\r
- /* Check to see that we're not over-allocating */\r
- if (nMT2063OpenTuners == MT2063_CNT)\r
- { \r
- return MT2063_TUNER_CNT_ERR;\r
- }\r
- /* Use the next available block from the list */\r
- pInfo = MT2063_Avail[nMT2063OpenTuners];\r
- nMT2063OpenTuners++;\r
- }\r
-#else\r
- if (state->MT2063_init==FALSE)\r
- { \r
- pInfo = kzalloc(sizeof (struct MT2063_Info_t), GFP_KERNEL);\r
- if (pInfo == NULL)\r
- { \r
- return MT2063_TUNER_OPEN_ERR;\r
- }\r
- pInfo->handle = NULL;\r
- pInfo->address = MAX_UDATA;\r
- pInfo->rcvr_mode = MT2063_CABLE_QAM;\r
- pInfo->hUserData = NULL;\r
- }\r
- else\r
- { \r
- pInfo = *hMT2063; \r
- }\r
-#endif\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_RegisterTuner(&pInfo->AS_Data);\r
- }\r
- \r
- if (MT2063_NO_ERROR(status))\r
- {\r
- pInfo->handle = (Handle_t) pInfo;\r
-\r
- pInfo->hUserData = hUserData;\r
- pInfo->address = MT2063_Addr;\r
- pInfo->rcvr_mode = MT2063_CABLE_QAM;\r
- status |= MT2063_ReInit((Handle_t) pInfo);\r
- }\r
-\r
- if (MT2063_IS_ERROR(status))\r
- /* MT2063_Close handles the un-registration of the tuner */\r
- MT2063_Close((Handle_t) pInfo);\r
- else\r
- {\r
- state->MT2063_init = TRUE;\r
- *hMT2063 = pInfo->handle;\r
-\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-static UData_t MT2063_IsValidHandle(struct MT2063_Info_t* handle)\r
-{ \r
- return ((handle != NULL) && (handle->handle == handle)) ? 1 : 0;\r
-}\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_Close\r
-**\r
-** Description: Release the handle to the tuner.\r
-**\r
-** Parameters: hMT2063 - Handle to the MT2063 tuner\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-**\r
-** Dependencies: mt_errordef.h - definition of error codes\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_Close(Handle_t hMT2063)\r
-{\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) hMT2063;\r
-\r
- if (!MT2063_IsValidHandle(pInfo))\r
- return MT2063_INV_HANDLE;\r
-\r
- /* Unregister tuner with SpurAvoidance routines (if needed) */\r
- MT2063_UnRegisterTuner(&pInfo->AS_Data);\r
- /* Now remove the tuner from our own list of tuners */\r
- pInfo->handle = NULL;\r
- pInfo->address = MAX_UDATA;\r
- pInfo->hUserData = NULL;\r
- #if USE_GLOBAL_TUNER\r
- nMT2063OpenTuners--;\r
- MT2063_Avail[nMT2063OpenTuners] = pInfo; /* Return control block to available list */\r
- #else\r
- //kfree(pInfo);\r
- //pInfo = NULL;\r
- #endif\r
- return MT2063_OK;\r
-}\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_GetGPIO\r
-**\r
-** Description: Get the current MT2063 GPIO value.\r
-**\r
-** Parameters: h - Open handle to the tuner (from MT2063_Open).\r
-** gpio_id - Selects GPIO0, GPIO1 or GPIO2\r
-** attr - Selects input readback, I/O direction or\r
-** output value\r
-** *value - current setting of GPIO pin\r
-**\r
-** Usage: status = MT2063_GetGPIO(hMT2063, MT2063_GPIO_OUT, &value);\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-**\r
-** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_GetGPIO(Handle_t h, enum MT2063_GPIO_ID gpio_id,\r
- enum MT2063_GPIO_Attr attr,\r
- UData_t* value)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- U8Data regno;\r
- SData_t shift;\r
- static U8Data GPIOreg[3] = {MT2063_REG_RF_STATUS, MT2063_REG_FIF_OV, MT2063_REG_RF_OV};\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- return MT2063_INV_HANDLE;\r
-\r
- if (value == NULL)\r
- return MT2063_ARG_NULL;\r
-\r
- regno = GPIOreg[attr];\r
-\r
- /* We'll read the register just in case the write didn't work last time */\r
- status = MT2063_ReadSub(pInfo->hUserData, pInfo->address, regno, &pInfo->reg[regno], 1);\r
-\r
- shift = (gpio_id - MT2063_GPIO0 + 5);\r
- *value = (pInfo->reg[regno] >> shift) & 1;\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_GetLocked\r
-**\r
-** Description: Checks to see if LO1 and LO2 are locked.\r
-**\r
-** Parameters: h - Open handle to the tuner (from MT2063_Open).\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_UPC_UNLOCK - Upconverter PLL unlocked\r
-** MT_DNC_UNLOCK - Downconverter PLL unlocked\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-**\r
-** Dependencies: MT_ReadSub - Read byte(s) of data from the serial bus\r
-** MT_Sleep - Delay execution for x milliseconds\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_GetLocked(Handle_t h)\r
-{\r
- const UData_t nMaxWait = 100; /* wait a maximum of 100 msec */\r
- const UData_t nPollRate = 2; /* poll status bits every 2 ms */\r
- const UData_t nMaxLoops = nMaxWait / nPollRate;\r
- const U8Data LO1LK = 0x80;\r
- U8Data LO2LK = 0x08;\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- UData_t nDelays = 0;\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- return MT2063_INV_HANDLE;\r
-\r
- /* LO2 Lock bit was in a different place for B0 version */\r
- if (pInfo->tuner_id == MT2063_B0)\r
- LO2LK = 0x40;\r
-\r
- do\r
- {\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO_STATUS, &pInfo->reg[MT2063_REG_LO_STATUS], 1);\r
-\r
- if (MT2063_IS_ERROR(status))\r
- return (status);\r
-\r
- if ((pInfo->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) == (LO1LK | LO2LK))\r
- {\r
- return (status);\r
- }\r
- MT2063_Sleep(pInfo->hUserData, nPollRate); /* Wait between retries */\r
- }\r
- while (++nDelays < nMaxLoops);\r
-\r
- if ((pInfo->reg[MT2063_REG_LO_STATUS] & LO1LK) == 0x00)\r
- status |= MT2063_UPC_UNLOCK;\r
- if ((pInfo->reg[MT2063_REG_LO_STATUS] & LO2LK) == 0x00)\r
- status |= MT2063_DNC_UNLOCK;\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_GetParam\r
-**\r
-** Description: Gets a tuning algorithm parameter.\r
-**\r
-** This function provides access to the internals of the\r
-** tuning algorithm - mostly for testing purposes.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** param - Tuning algorithm parameter\r
-** (see enum MT2063_Param)\r
-** pValue - ptr to returned value\r
-**\r
-** param Description\r
-** ---------------------- --------------------------------\r
-** MT2063_IC_ADDR Serial Bus address of this tuner\r
-** MT2063_MAX_OPEN Max # of MT2063's allowed open\r
-** MT2063_NUM_OPEN # of MT2063's open\r
-** MT2063_SRO_FREQ crystal frequency\r
-** MT2063_STEPSIZE minimum tuning step size\r
-** MT2063_INPUT_FREQ input center frequency\r
-** MT2063_LO1_FREQ LO1 Frequency\r
-** MT2063_LO1_STEPSIZE LO1 minimum step size\r
-** MT2063_LO1_FRACN_AVOID LO1 FracN keep-out region\r
-** MT2063_IF1_ACTUAL Current 1st IF in use\r
-** MT2063_IF1_REQUEST Requested 1st IF\r
-** MT2063_IF1_CENTER Center of 1st IF SAW filter\r
-** MT2063_IF1_BW Bandwidth of 1st IF SAW filter\r
-** MT2063_ZIF_BW zero-IF bandwidth\r
-** MT2063_LO2_FREQ LO2 Frequency\r
-** MT2063_LO2_STEPSIZE LO2 minimum step size\r
-** MT2063_LO2_FRACN_AVOID LO2 FracN keep-out region\r
-** MT2063_OUTPUT_FREQ output center frequency\r
-** MT2063_OUTPUT_BW output bandwidth\r
-** MT2063_LO_SEPARATION min inter-tuner LO separation\r
-** MT2063_AS_ALG ID of avoid-spurs algorithm in use\r
-** MT2063_MAX_HARM1 max # of intra-tuner harmonics\r
-** MT2063_MAX_HARM2 max # of inter-tuner harmonics\r
-** MT2063_EXCL_ZONES # of 1st IF exclusion zones\r
-** MT2063_NUM_SPURS # of spurs found/avoided\r
-** MT2063_SPUR_AVOIDED >0 spurs avoided\r
-** MT2063_SPUR_PRESENT >0 spurs in output (mathematically)\r
-** MT2063_RCVR_MODE Predefined modes.\r
-** MT2063_ACLNA LNA attenuator gain code\r
-** MT2063_ACRF RF attenuator gain code\r
-** MT2063_ACFIF FIF attenuator gain code\r
-** MT2063_ACLNA_MAX LNA attenuator limit\r
-** MT2063_ACRF_MAX RF attenuator limit\r
-** MT2063_ACFIF_MAX FIF attenuator limit\r
-** MT2063_PD1 Actual value of PD1\r
-** MT2063_PD2 Actual value of PD2\r
-** MT2063_DNC_OUTPUT_ENABLE DNC output selection\r
-** MT2063_VGAGC VGA gain code\r
-** MT2063_VGAOI VGA output current\r
-** MT2063_TAGC TAGC setting\r
-** MT2063_AMPGC AMP gain code\r
-** MT2063_AVOID_DECT Avoid DECT Frequencies\r
-** MT2063_CTFILT_SW Cleartune filter selection\r
-**\r
-** Usage: status |= MT2063_GetParam(hMT2063,\r
-** MT2063_IF1_ACTUAL,\r
-** &f_IF1_Actual);\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-** MT_ARG_RANGE - Invalid parameter requested\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** See Also: MT2063_SetParam, MT2063_Open\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 154 09-13-2007 RSK Ver 1.05: Get/SetParam changes for LOx_FREQ\r
-** 10-31-2007 PINZ Ver 1.08: Get/SetParam add VGAGC, VGAOI, AMPGC, TAGC\r
-** 173 M 01-23-2008 RSK Ver 1.12: Read LO1C and LO2C registers from HW\r
-** in GetParam.\r
-** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT\r
-** Split SetParam up to ACLNA / ACLNA_MAX\r
-** removed ACLNA_INRC/DECR (+RF & FIF)\r
-** removed GCUAUTO / BYPATNDN/UP\r
-** 175 I 16-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.\r
-** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.\r
-** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_GetParam(Handle_t h,\r
- enum MT2063_Param param,\r
- UData_t* pValue)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
- UData_t Div;\r
- UData_t Num;\r
-\r
- if (pValue == NULL)\r
- status |= MT2063_ARG_NULL;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status |= MT2063_INV_HANDLE;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- switch (param)\r
- {\r
- /* Serial Bus address of this tuner */\r
- case MT2063_IC_ADDR:\r
- *pValue = pInfo->address;\r
- break;\r
-\r
- /* Max # of MT2063's allowed to be open */\r
- case MT2063_MAX_OPEN:\r
- *pValue = nMT2063MaxTuners;\r
- break;\r
-\r
- /* # of MT2063's open */\r
- case MT2063_NUM_OPEN:\r
- *pValue = nMT2063OpenTuners;\r
- break;\r
-\r
- /* crystal frequency */\r
- case MT2063_SRO_FREQ:\r
- *pValue = pInfo->AS_Data.f_ref;\r
- break;\r
-\r
- /* minimum tuning step size */\r
- case MT2063_STEPSIZE:\r
- *pValue = pInfo->AS_Data.f_LO2_Step;\r
- break;\r
-\r
- /* input center frequency */\r
- case MT2063_INPUT_FREQ:\r
- *pValue = pInfo->AS_Data.f_in;\r
- break;\r
-\r
- /* LO1 Frequency */\r
- case MT2063_LO1_FREQ:\r
- {\r
- /* read the actual tuner register values for LO1C_1 and LO1C_2 */\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1C_1, &pInfo->reg[MT2063_REG_LO1C_1], 2);\r
- Div = pInfo->reg[MT2063_REG_LO1C_1];\r
- Num = pInfo->reg[MT2063_REG_LO1C_2] & 0x3F;\r
- pInfo->AS_Data.f_LO1 = (pInfo->AS_Data.f_ref * Div) + MT2063_fLO_FractionalTerm(pInfo->AS_Data.f_ref, Num, 64);\r
- }\r
- *pValue = pInfo->AS_Data.f_LO1;\r
- break;\r
-\r
- /* LO1 minimum step size */\r
- case MT2063_LO1_STEPSIZE:\r
- *pValue = pInfo->AS_Data.f_LO1_Step;\r
- break;\r
-\r
- /* LO1 FracN keep-out region */\r
- case MT2063_LO1_FRACN_AVOID_PARAM:\r
- *pValue = pInfo->AS_Data.f_LO1_FracN_Avoid;\r
- break;\r
-\r
- /* Current 1st IF in use */\r
- case MT2063_IF1_ACTUAL:\r
- *pValue = pInfo->f_IF1_actual;\r
- break;\r
-\r
- /* Requested 1st IF */\r
- case MT2063_IF1_REQUEST:\r
- *pValue = pInfo->AS_Data.f_if1_Request;\r
- break;\r
-\r
- /* Center of 1st IF SAW filter */\r
- case MT2063_IF1_CENTER:\r
- *pValue = pInfo->AS_Data.f_if1_Center;\r
- break;\r
-\r
- /* Bandwidth of 1st IF SAW filter */\r
- case MT2063_IF1_BW:\r
- *pValue = pInfo->AS_Data.f_if1_bw;\r
- break;\r
-\r
- /* zero-IF bandwidth */\r
- case MT2063_ZIF_BW:\r
- *pValue = pInfo->AS_Data.f_zif_bw;\r
- break;\r
-\r
- /* LO2 Frequency */\r
- case MT2063_LO2_FREQ:\r
- {\r
- /* Read the actual tuner register values for LO2C_1, LO2C_2 and LO2C_3 */\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2C_1, &pInfo->reg[MT2063_REG_LO2C_1], 3);\r
- Div = (pInfo->reg[MT2063_REG_LO2C_1] & 0xFE ) >> 1;\r
- Num = ((pInfo->reg[MT2063_REG_LO2C_1] & 0x01 ) << 12) | (pInfo->reg[MT2063_REG_LO2C_2] << 4) | (pInfo->reg[MT2063_REG_LO2C_3] & 0x00F);\r
- pInfo->AS_Data.f_LO2 = (pInfo->AS_Data.f_ref * Div) + MT2063_fLO_FractionalTerm(pInfo->AS_Data.f_ref, Num, 8191);\r
- }\r
- *pValue = pInfo->AS_Data.f_LO2;\r
- break;\r
-\r
- /* LO2 minimum step size */\r
- case MT2063_LO2_STEPSIZE:\r
- *pValue = pInfo->AS_Data.f_LO2_Step;\r
- break;\r
-\r
- /* LO2 FracN keep-out region */\r
- case MT2063_LO2_FRACN_AVOID:\r
- *pValue = pInfo->AS_Data.f_LO2_FracN_Avoid;\r
- break;\r
-\r
- /* output center frequency */\r
- case MT2063_OUTPUT_FREQ:\r
- *pValue = pInfo->AS_Data.f_out;\r
- break;\r
-\r
- /* output bandwidth */\r
- case MT2063_OUTPUT_BW:\r
- *pValue = pInfo->AS_Data.f_out_bw - 750000;\r
- break;\r
-\r
- /* min inter-tuner LO separation */\r
- case MT2063_LO_SEPARATION:\r
- *pValue = pInfo->AS_Data.f_min_LO_Separation;\r
- break;\r
-\r
- /* ID of avoid-spurs algorithm in use */\r
- case MT2063_AS_ALG:\r
- *pValue = pInfo->AS_Data.nAS_Algorithm;\r
- break;\r
-\r
- /* max # of intra-tuner harmonics */\r
- case MT2063_MAX_HARM1:\r
- *pValue = pInfo->AS_Data.maxH1;\r
- break;\r
-\r
- /* max # of inter-tuner harmonics */\r
- case MT2063_MAX_HARM2:\r
- *pValue = pInfo->AS_Data.maxH2;\r
- break;\r
-\r
- /* # of 1st IF exclusion zones */\r
- case MT2063_EXCL_ZONES:\r
- *pValue = pInfo->AS_Data.nZones;\r
- break;\r
-\r
- /* # of spurs found/avoided */\r
- case MT2063_NUM_SPURS:\r
- *pValue = pInfo->AS_Data.nSpursFound;\r
- break;\r
-\r
- /* >0 spurs avoided */\r
- case MT2063_SPUR_AVOIDED:\r
- *pValue = pInfo->AS_Data.bSpurAvoided;\r
- break;\r
-\r
- /* >0 spurs in output (mathematically) */\r
- case MT2063_SPUR_PRESENT:\r
- *pValue = pInfo->AS_Data.bSpurPresent;\r
- break;\r
-\r
- /* Predefined receiver setup combination */\r
- case MT2063_RCVR_MODE:\r
- *pValue = pInfo->rcvr_mode;\r
- break;\r
-\r
- case MT2063_PD1:\r
- case MT2063_PD2:\r
- {\r
- U8Data mask = (param == MT2063_PD1 ? 0x01 : 0x03); /* PD1 vs PD2 */\r
- U8Data orig = (pInfo->reg[MT2063_REG_BYP_CTRL]);\r
- U8Data reg = (orig & 0xF1) | mask; /* Only set 3 bits (not 5) */\r
- int i;\r
-\r
- *pValue = 0;\r
-\r
- /* Initiate ADC output to reg 0x0A */\r
- if (reg != orig)\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_BYP_CTRL, ®, 1);\r
-\r
- if (MT2063_IS_ERROR(status))\r
- return (status);\r
-\r
- for (i=0; i<8; i++) {\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_ADC_OUT, &pInfo->reg[MT2063_REG_ADC_OUT], 1);\r
-\r
- if (MT2063_NO_ERROR(status))\r
- *pValue += pInfo->reg[MT2063_REG_ADC_OUT];\r
- else\r
- {\r
- if( i ) *pValue /= i;\r
- return (status);\r
- }\r
- }\r
- *pValue /= 8; /* divide by number of reads */\r
- *pValue >>=2; /* only want 6 MSB's out of 8 */\r
-\r
- /* Restore value of Register BYP_CTRL */\r
- if (reg != orig)\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_BYP_CTRL, &orig, 1);\r
- }\r
- break;\r
-\r
- /* Get LNA attenuator code */\r
- case MT2063_ACLNA:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_XO_STATUS, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get RF attenuator code */\r
- case MT2063_ACRF:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_RF_STATUS, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get FIF attenuator code */\r
- case MT2063_ACFIF:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_FIF_STATUS, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get LNA attenuator limit */\r
- case MT2063_ACLNA_MAX:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_LNA_OV, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get RF attenuator limit */\r
- case MT2063_ACRF_MAX:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_RF_OV, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get FIF attenuator limit */\r
- case MT2063_ACFIF_MAX:\r
- {\r
- U8Data val;\r
- status |= MT2063_GetReg(pInfo, MT2063_REG_FIF_OV, &val);\r
- *pValue = val & 0x1f;\r
- }\r
- break;\r
-\r
- /* Get current used DNC output */\r
- case MT2063_DNC_OUTPUT_ENABLE:\r
- {\r
- if ( (pInfo->reg[MT2063_REG_DNC_GAIN] & 0x03) == 0x03) /* if DNC1 is off */\r
- {\r
- if ( (pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03) /* if DNC2 is off */\r
- *pValue = (UData_t)MT2063_DNC_NONE;\r
- else\r
- *pValue = (UData_t)MT2063_DNC_2;\r
- }\r
- else /* DNC1 is on */\r
- {\r
- if ( (pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03) /* if DNC2 is off */\r
- *pValue = (UData_t)MT2063_DNC_1;\r
- else\r
- *pValue = (UData_t)MT2063_DNC_BOTH;\r
- }\r
- }\r
- break;\r
-\r
- /* Get VGA Gain Code */\r
- case MT2063_VGAGC:\r
- *pValue = ( (pInfo->reg[MT2063_REG_VGA_GAIN] & 0x0C) >> 2 );\r
- break;\r
-\r
- /* Get VGA bias current */\r
- case MT2063_VGAOI:\r
- *pValue = (pInfo->reg[MT2063_REG_RSVD_31] & 0x07);\r
- break;\r
-\r
- /* Get TAGC setting */\r
- case MT2063_TAGC:\r
- *pValue = (pInfo->reg[MT2063_REG_RSVD_1E] & 0x03);\r
- break;\r
-\r
- /* Get AMP Gain Code */\r
- case MT2063_AMPGC:\r
- *pValue = (pInfo->reg[MT2063_REG_TEMP_SEL] & 0x03);\r
- break;\r
-\r
- /* Avoid DECT Frequencies */\r
- case MT2063_AVOID_DECT:\r
- *pValue = pInfo->AS_Data.avoidDECT;\r
- break;\r
-\r
- /* Cleartune filter selection: 0 - by IC (default), 1 - by software */\r
- case MT2063_CTFILT_SW:\r
- *pValue = pInfo->ctfilt_sw;\r
- break;\r
-\r
- case MT2063_EOP:\r
- default:\r
- status |= MT2063_ARG_RANGE;\r
- }\r
- }\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_GetReg\r
-**\r
-** Description: Gets an MT2063 register.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** reg - MT2063 register/subaddress location\r
-** *val - MT2063 register/subaddress value\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-** MT_ARG_RANGE - Argument out of range\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Use this function if you need to read a register from\r
-** the MT2063.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_GetReg(Handle_t h,\r
- U8Data reg,\r
- U8Data* val)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status |= MT2063_INV_HANDLE;\r
-\r
- if (val == NULL)\r
- status |= MT2063_ARG_NULL;\r
-\r
- if (reg >= MT2063_REG_END_REGS)\r
- status |= MT2063_ARG_RANGE;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, reg, &pInfo->reg[reg], 1);\r
- if (MT2063_NO_ERROR(status))\r
- *val = pInfo->reg[reg];\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_GetTemp\r
-**\r
-** Description: Get the MT2063 Temperature register.\r
-**\r
-** Parameters: h - Open handle to the tuner (from MT2063_Open).\r
-** *value - value read from the register\r
-**\r
-** Binary\r
-** Value Returned Value Approx Temp\r
-** ---------------------------------------------\r
-** MT2063_T_0C 0000 0C\r
-** MT2063_T_10C 0001 10C\r
-** MT2063_T_20C 0010 20C\r
-** MT2063_T_30C 0011 30C\r
-** MT2063_T_40C 0100 40C\r
-** MT2063_T_50C 0101 50C\r
-** MT2063_T_60C 0110 60C\r
-** MT2063_T_70C 0111 70C\r
-** MT2063_T_80C 1000 80C\r
-** MT2063_T_90C 1001 90C\r
-** MT2063_T_100C 1010 100C\r
-** MT2063_T_110C 1011 110C\r
-** MT2063_T_120C 1100 120C\r
-** MT2063_T_130C 1101 130C\r
-** MT2063_T_140C 1110 140C\r
-** MT2063_T_150C 1111 150C\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-** MT_ARG_RANGE - Argument out of range\r
-**\r
-** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus\r
-** MT_WriteSub - Write byte(s) of data to the two-wire bus\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_GetTemp(Handle_t h, enum MT2063_Temperature* value)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- return MT2063_INV_HANDLE;\r
-\r
- if (value == NULL)\r
- return MT2063_ARG_NULL;\r
-\r
- if ((MT2063_NO_ERROR(status)) && ((pInfo->reg[MT2063_REG_TEMP_SEL] & 0xE0) != 0x00))\r
- {\r
- pInfo->reg[MT2063_REG_TEMP_SEL] &= (0x1F);\r
- status |= MT2063_WriteSub(pInfo->hUserData,\r
- pInfo->address,\r
- MT2063_REG_TEMP_SEL,\r
- &pInfo->reg[MT2063_REG_TEMP_SEL],\r
- 1);\r
- }\r
-\r
- if (MT2063_NO_ERROR(status))\r
- status |= MT2063_ReadSub(pInfo->hUserData,\r
- pInfo->address,\r
- MT2063_REG_TEMP_STATUS,\r
- &pInfo->reg[MT2063_REG_TEMP_STATUS],\r
- 1);\r
-\r
- if (MT2063_NO_ERROR(status))\r
- *value = (enum MT2063_Temperature) (pInfo->reg[MT2063_REG_TEMP_STATUS] >> 4);\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_GetUserData\r
-**\r
-** Description: Gets the user-defined data item.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** The hUserData parameter is a user-specific argument\r
-** that is stored internally with the other tuner-\r
-** specific information.\r
-**\r
-** For example, if additional arguments are needed\r
-** for the user to identify the device communicating\r
-** with the tuner, this argument can be used to supply\r
-** the necessary information.\r
-**\r
-** The hUserData parameter is initialized in the tuner's\r
-** Open function to NULL.\r
-**\r
-** See Also: MT2063_Open\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_GetUserData(Handle_t h,\r
- Handle_t* hUserData)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
-\r
- if (hUserData == NULL)\r
- status |= MT2063_ARG_NULL;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- *hUserData = pInfo->hUserData;\r
-\r
- return (status);\r
-}\r
-\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_SetReceiverMode\r
-**\r
-** Description: Set the MT2063 receiver mode\r
-**\r
-** --------------+----------------------------------------------\r
-** Mode 0 : | MT2063_CABLE_QAM\r
-** Mode 1 : | MT2063_CABLE_ANALOG\r
-** Mode 2 : | MT2063_OFFAIR_COFDM\r
-** Mode 3 : | MT2063_OFFAIR_COFDM_SAWLESS\r
-** Mode 4 : | MT2063_OFFAIR_ANALOG\r
-** Mode 5 : | MT2063_OFFAIR_8VSB\r
-** --------------+----+----+----+----+-----+--------------------\r
-** (DNC1GC & DNC2GC are the values, which are used, when the specific\r
-** DNC Output is selected, the other is always off)\r
-**\r
-** |<---------- Mode -------------->|\r
-** Reg Field | 0 | 1 | 2 | 3 | 4 | 5 |\r
-** ------------+-----+-----+-----+-----+-----+-----+\r
-** RFAGCen | OFF | OFF | OFF | OFF | OFF | OFF\r
-** LNARin | 0 | 0 | 3 | 3 | 3 | 3\r
-** FIFFQen | 1 | 1 | 1 | 1 | 1 | 1\r
-** FIFFq | 0 | 0 | 0 | 0 | 0 | 0\r
-** DNC1gc | 0 | 0 | 0 | 0 | 0 | 0\r
-** DNC2gc | 0 | 0 | 0 | 0 | 0 | 0\r
-** GCU Auto | 1 | 1 | 1 | 1 | 1 | 1\r
-** LNA max Atn | 31 | 31 | 31 | 31 | 31 | 31\r
-** LNA Target | 44 | 43 | 43 | 43 | 43 | 43\r
-** ign RF Ovl | 0 | 0 | 0 | 0 | 0 | 0\r
-** RF max Atn | 31 | 31 | 31 | 31 | 31 | 31\r
-** PD1 Target | 36 | 36 | 38 | 38 | 36 | 38\r
-** ign FIF Ovl | 0 | 0 | 0 | 0 | 0 | 0\r
-** FIF max Atn | 5 | 5 | 5 | 5 | 5 | 5\r
-** PD2 Target | 40 | 33 | 42 | 42 | 33 | 42\r
-**\r
-**\r
-** Parameters: pInfo - ptr to MT2063_Info_t structure\r
-** Mode - desired reciever mode\r
-**\r
-** Usage: status = MT2063_SetReceiverMode(hMT2063, Mode);\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: MT2063_SetReg - Write a byte of data to a HW register.\r
-** Assumes that the tuner cache is valid.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** N/A 01-10-2007 PINZ Added additional GCU Settings, FIFF Calib will be triggered\r
-** 155 10-01-2007 DAD Ver 1.06: Add receiver mode for SECAM positive\r
-** modulation\r
-** (MT2063_ANALOG_TV_POS_NO_RFAGC_MODE)\r
-** N/A 10-22-2007 PINZ Ver 1.07: Changed some Registers at init to have\r
-** the same settings as with MT Launcher\r
-** N/A 10-30-2007 PINZ Add SetParam VGAGC & VGAOI\r
-** Add SetParam DNC_OUTPUT_ENABLE\r
-** Removed VGAGC from receiver mode,\r
-** default now 1\r
-** N/A 10-31-2007 PINZ Ver 1.08: Add SetParam TAGC, removed from rcvr-mode\r
-** Add SetParam AMPGC, removed from rcvr-mode\r
-** Corrected names of GCU values\r
-** reorganized receiver modes, removed,\r
-** (MT2063_ANALOG_TV_POS_NO_RFAGC_MODE)\r
-** Actualized Receiver-Mode values\r
-** N/A 11-12-2007 PINZ Ver 1.09: Actualized Receiver-Mode values\r
-** N/A 11-27-2007 PINZ Improved buffered writing\r
-** 01-03-2008 PINZ Ver 1.10: Added a trigger of BYPATNUP for\r
-** correct wakeup of the LNA after shutdown\r
-** Set AFCsd = 1 as default\r
-** Changed CAP1sel default\r
-** 01-14-2008 PINZ Ver 1.11: Updated gain settings\r
-** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT\r
-** Split SetParam up to ACLNA / ACLNA_MAX\r
-** removed ACLNA_INRC/DECR (+RF & FIF)\r
-** removed GCUAUTO / BYPATNDN/UP\r
-**\r
-******************************************************************************/\r
-static UData_t MT2063_SetReceiverMode(struct MT2063_Info_t* pInfo, enum MT2063_RCVR_MODES Mode)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- U8Data val;\r
- UData_t longval;\r
-\r
-\r
- if (Mode >= MT2063_NUM_RCVR_MODES)\r
- status = MT2063_ARG_RANGE;\r
-\r
- /* RFAGCen */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- val = (pInfo->reg[MT2063_REG_PD1_TGT] & (U8Data)~0x40) | (RFAGCEN[Mode] ? 0x40 : 0x00);\r
- if( pInfo->reg[MT2063_REG_PD1_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT, val);\r
- }\r
- }\r
-\r
- /* LNARin */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_LNA_RIN, LNARIN[Mode]);\r
- }\r
-\r
- /* FIFFQEN and FIFFQ */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- val = (pInfo->reg[MT2063_REG_FIFF_CTRL2] & (U8Data)~0xF0) | (FIFFQEN[Mode] << 7) | (FIFFQ[Mode] << 4);\r
- if( pInfo->reg[MT2063_REG_FIFF_CTRL2] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL2, val);\r
- /* trigger FIFF calibration, needed after changing FIFFQ */\r
- val = (pInfo->reg[MT2063_REG_FIFF_CTRL] | (U8Data)0x01);\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL, val);\r
- val = (pInfo->reg[MT2063_REG_FIFF_CTRL] & (U8Data)~0x01);\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_FIFF_CTRL, val);\r
- }\r
- }\r
-\r
- /* DNC1GC & DNC2GC */\r
- status |= MT2063_GetParam(pInfo, MT2063_DNC_OUTPUT_ENABLE, &longval);\r
- status |= MT2063_SetParam(pInfo, MT2063_DNC_OUTPUT_ENABLE, longval);\r
-\r
- /* acLNAmax */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_ACLNA_MAX, ACLNAMAX[Mode]);\r
- }\r
-\r
- /* LNATGT */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_LNA_TGT, LNATGT[Mode]);\r
- }\r
-\r
- /* ACRF */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_ACRF_MAX, ACRFMAX[Mode]);\r
- }\r
-\r
- /* PD1TGT */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_PD1_TGT, PD1TGT[Mode]);\r
- }\r
-\r
- /* FIFATN */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_ACFIF_MAX, ACFIFMAX[Mode]);\r
- }\r
-\r
- /* PD2TGT */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_SetParam(pInfo, MT2063_PD2_TGT, PD2TGT[Mode]);\r
- }\r
-\r
- /* Ignore ATN Overload */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- val = (pInfo->reg[MT2063_REG_LNA_TGT] & (U8Data)~0x80) | (RFOVDIS[Mode] ? 0x80 : 0x00);\r
- if( pInfo->reg[MT2063_REG_LNA_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_LNA_TGT, val);\r
- }\r
- }\r
-\r
- /* Ignore FIF Overload */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- val = (pInfo->reg[MT2063_REG_PD1_TGT] & (U8Data)~0x80) | (FIFOVDIS[Mode] ? 0x80 : 0x00);\r
- if( pInfo->reg[MT2063_REG_PD1_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT, val);\r
- }\r
- }\r
-\r
- if (MT2063_NO_ERROR(status))\r
- pInfo->rcvr_mode = Mode;\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_ReInit\r
-**\r
-** Description: Initialize the tuner's register values.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_TUNER_ID_ERR - Tuner Part/Rev code mismatch\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: MT_ReadSub - Read byte(s) of data from the two-wire bus\r
-** MT_WriteSub - Write byte(s) of data to the two-wire bus\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 148 09-04-2007 RSK Ver 1.02: Corrected logic of Reg 3B Reference\r
-** 153 09-07-2007 RSK Ver 1.03: Lock Time improvements\r
-** N/A 10-31-2007 PINZ Ver 1.08: Changed values suitable to rcvr-mode 0\r
-** N/A 11-12-2007 PINZ Ver 1.09: Changed values suitable to rcvr-mode 0\r
-** N/A 01-03-2007 PINZ Ver 1.10: Added AFCsd = 1 into defaults\r
-** N/A 01-04-2007 PINZ Ver 1.10: Changed CAP1sel default\r
-** 01-14-2008 PINZ Ver 1.11: Updated gain settings\r
-** 03-18-2008 PINZ Ver 1.13: Added Support for B3\r
-** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.\r
-** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_ReInit(Handle_t h)\r
-{\r
- U8Data all_resets = 0xF0; /* reset/load bits */\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
- U8Data *def;\r
-\r
- U8Data MT2063B0_defaults[] = { /* Reg, Value */\r
- 0x19, 0x05,\r
- 0x1B, 0x1D,\r
- 0x1C, 0x1F,\r
- 0x1D, 0x0F,\r
- 0x1E, 0x3F,\r
- 0x1F, 0x0F,\r
- 0x20, 0x3F,\r
- 0x22, 0x21,\r
- 0x23, 0x3F,\r
- 0x24, 0x20,\r
- 0x25, 0x3F,\r
- 0x27, 0xEE,\r
- 0x2C, 0x27, /* bit at 0x20 is cleared below */\r
- 0x30, 0x03,\r
- 0x2C, 0x07, /* bit at 0x20 is cleared here */\r
- 0x2D, 0x87,\r
- 0x2E, 0xAA,\r
- 0x28, 0xE1, /* Set the FIFCrst bit here */\r
- 0x28, 0xE0, /* Clear the FIFCrst bit here */\r
- 0x00 };\r
-\r
- /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */\r
- U8Data MT2063B1_defaults[] = { /* Reg, Value */\r
- 0x05, 0xF0,\r
- 0x11, 0x10, /* New Enable AFCsd */\r
- 0x19, 0x05,\r
- 0x1A, 0x6C,\r
- 0x1B, 0x24,\r
- 0x1C, 0x28,\r
- 0x1D, 0x8F,\r
- 0x1E, 0x14,\r
- 0x1F, 0x8F,\r
- 0x20, 0x57,\r
- 0x22, 0x21, /* New - ver 1.03 */\r
- 0x23, 0x3C, /* New - ver 1.10 */\r
- 0x24, 0x20, /* New - ver 1.03 */\r
- 0x2C, 0x24, /* bit at 0x20 is cleared below */\r
- 0x2D, 0x87, /* FIFFQ=0 */\r
- 0x2F, 0xF3,\r
- 0x30, 0x0C, /* New - ver 1.11 */\r
- 0x31, 0x1B, /* New - ver 1.11 */\r
- 0x2C, 0x04, /* bit at 0x20 is cleared here */\r
- 0x28, 0xE1, /* Set the FIFCrst bit here */\r
- 0x28, 0xE0, /* Clear the FIFCrst bit here */\r
- 0x00 };\r
-\r
- /* writing 0x05 0xf0 sw-resets all registers, so we write only needed changes */\r
- U8Data MT2063B3_defaults[] = { /* Reg, Value */\r
- 0x05, 0xF0,\r
- 0x19, 0x3D,\r
- 0x2C, 0x24, /* bit at 0x20 is cleared below */\r
- 0x2C, 0x04, /* bit at 0x20 is cleared here */\r
- 0x28, 0xE1, /* Set the FIFCrst bit here */\r
- 0x28, 0xE0, /* Clear the FIFCrst bit here */\r
- 0x00 };\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status |= MT2063_INV_HANDLE;\r
-\r
- /* Read the Part/Rev code from the tuner */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_PART_REV, pInfo->reg, 1);\r
- }\r
- \r
- if (MT2063_NO_ERROR(status) /* Check the part/rev code */\r
- && ( (pInfo->reg[MT2063_REG_PART_REV] != MT2063_B0) /* MT2063 B0 */\r
- && (pInfo->reg[MT2063_REG_PART_REV] != MT2063_B1) /* MT2063 B1 */\r
- && (pInfo->reg[MT2063_REG_PART_REV] != MT2063_B3))) /* MT2063 B3 */\r
- status |= MT2063_TUNER_ID_ERR; /* Wrong tuner Part/Rev code */\r
-\r
- /* Read the Part/Rev code (2nd byte) from the tuner */\r
- if (MT2063_NO_ERROR(status))\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_RSVD_3B, &pInfo->reg[MT2063_REG_RSVD_3B], 1);\r
-\r
- if (MT2063_NO_ERROR(status) /* Check the 2nd part/rev code */\r
- && ((pInfo->reg[MT2063_REG_RSVD_3B] & 0x80) != 0x00)) /* b7 != 0 ==> NOT MT2063 */\r
- status |= MT2063_TUNER_ID_ERR; /* Wrong tuner Part/Rev code */\r
- \r
- /* Reset the tuner */\r
- if (MT2063_NO_ERROR(status))\r
- status |= MT2063_WriteSub(pInfo->hUserData,\r
- pInfo->address,\r
- MT2063_REG_LO2CQ_3,\r
- &all_resets,\r
- 1);\r
-\r
- /* change all of the default values that vary from the HW reset values */\r
- /* def = (pInfo->reg[PART_REV] == MT2063_B0) ? MT2063B0_defaults : MT2063B1_defaults; */\r
- switch (pInfo->reg[MT2063_REG_PART_REV])\r
- {\r
- case MT2063_B3 :\r
- def = MT2063B3_defaults;\r
- break;\r
-\r
- case MT2063_B1 :\r
- def = MT2063B1_defaults;\r
- break;\r
-\r
- case MT2063_B0 :\r
- def = MT2063B0_defaults;\r
- break;\r
-\r
- default :\r
- status |= MT2063_TUNER_ID_ERR;\r
- break;\r
- }\r
-\r
- while (MT2063_NO_ERROR(status) && *def)\r
- {\r
- U8Data reg = *def++;\r
- U8Data val = *def++;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, reg, &val, 1);\r
- }\r
-\r
- /* Wait for FIFF location to complete. */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- UData_t FCRUN = 1;\r
- SData_t maxReads = 10;\r
- while (MT2063_NO_ERROR(status) && (FCRUN != 0) && (maxReads-- > 0))\r
- {\r
- MT2063_Sleep(pInfo->hUserData, 2);\r
- status |= MT2063_ReadSub(pInfo->hUserData,\r
- pInfo->address,\r
- MT2063_REG_XO_STATUS,\r
- &pInfo->reg[MT2063_REG_XO_STATUS],\r
- 1);\r
- FCRUN = (pInfo->reg[MT2063_REG_XO_STATUS] & 0x40) >> 6;\r
- }\r
-\r
- if (FCRUN != 0)\r
- status |= MT2063_TUNER_INIT_ERR | MT2063_TUNER_TIMEOUT;\r
-\r
- if (MT2063_NO_ERROR(status)) /* Re-read FIFFC value */\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_FIFFC, &pInfo->reg[MT2063_REG_FIFFC], 1);\r
- }\r
-\r
- /* Read back all the registers from the tuner */\r
- if (MT2063_NO_ERROR(status))\r
- status |= MT2063_ReadSub(pInfo->hUserData,\r
- pInfo->address,\r
- MT2063_REG_PART_REV,\r
- pInfo->reg,\r
- MT2063_REG_END_REGS);\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- /* Initialize the tuner state. */\r
- pInfo->version = MT2063_VERSION;\r
- pInfo->tuner_id = pInfo->reg[MT2063_REG_PART_REV];\r
- pInfo->AS_Data.f_ref = MT2063_REF_FREQ;\r
- pInfo->AS_Data.f_if1_Center = (pInfo->AS_Data.f_ref / 8) * ((UData_t) pInfo->reg[MT2063_REG_FIFFC] + 640);\r
- pInfo->AS_Data.f_if1_bw = MT2063_IF1_BW;\r
- pInfo->AS_Data.f_out = 43750000UL;\r
- pInfo->AS_Data.f_out_bw = 6750000UL;\r
- pInfo->AS_Data.f_zif_bw = MT2063_ZIF_BW;\r
- pInfo->AS_Data.f_LO1_Step = pInfo->AS_Data.f_ref / 64;\r
- pInfo->AS_Data.f_LO2_Step = MT2063_TUNE_STEP_SIZE;\r
- pInfo->AS_Data.maxH1 = MT2063_MAX_HARMONICS_1;\r
- pInfo->AS_Data.maxH2 = MT2063_MAX_HARMONICS_2;\r
- pInfo->AS_Data.f_min_LO_Separation = MT2063_MIN_LO_SEP;\r
- pInfo->AS_Data.f_if1_Request = pInfo->AS_Data.f_if1_Center;\r
- pInfo->AS_Data.f_LO1 = 2181000000UL;\r
- pInfo->AS_Data.f_LO2 = 1486249786UL;\r
- pInfo->f_IF1_actual = pInfo->AS_Data.f_if1_Center;\r
- pInfo->AS_Data.f_in = pInfo->AS_Data.f_LO1 - pInfo->f_IF1_actual;\r
- pInfo->AS_Data.f_LO1_FracN_Avoid = MT2063_LO1_FRACN_AVOID;\r
- pInfo->AS_Data.f_LO2_FracN_Avoid = MT2063_LO2_FRACN_AVOID;\r
- pInfo->num_regs = MT2063_REG_END_REGS;\r
- pInfo->AS_Data.avoidDECT = MT2063_AVOID_BOTH;\r
- pInfo->ctfilt_sw = 0;\r
- }\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- pInfo->CTFiltMax[ 0] = 69230000;\r
- pInfo->CTFiltMax[ 1] = 105770000;\r
- pInfo->CTFiltMax[ 2] = 140350000;\r
- pInfo->CTFiltMax[ 3] = 177110000;\r
- pInfo->CTFiltMax[ 4] = 212860000;\r
- pInfo->CTFiltMax[ 5] = 241130000;\r
- pInfo->CTFiltMax[ 6] = 274370000;\r
- pInfo->CTFiltMax[ 7] = 309820000;\r
- pInfo->CTFiltMax[ 8] = 342450000;\r
- pInfo->CTFiltMax[ 9] = 378870000;\r
- pInfo->CTFiltMax[10] = 416210000;\r
- pInfo->CTFiltMax[11] = 456500000;\r
- pInfo->CTFiltMax[12] = 495790000;\r
- pInfo->CTFiltMax[13] = 534530000;\r
- pInfo->CTFiltMax[14] = 572610000;\r
- pInfo->CTFiltMax[15] = 598970000;\r
- pInfo->CTFiltMax[16] = 635910000;\r
- pInfo->CTFiltMax[17] = 672130000;\r
- pInfo->CTFiltMax[18] = 714840000;\r
- pInfo->CTFiltMax[19] = 739660000;\r
- pInfo->CTFiltMax[20] = 770410000;\r
- pInfo->CTFiltMax[21] = 814660000;\r
- pInfo->CTFiltMax[22] = 846950000;\r
- pInfo->CTFiltMax[23] = 867820000;\r
- pInfo->CTFiltMax[24] = 915980000;\r
- pInfo->CTFiltMax[25] = 947450000;\r
- pInfo->CTFiltMax[26] = 983110000;\r
- pInfo->CTFiltMax[27] = 1021630000;\r
- pInfo->CTFiltMax[28] = 1061870000;\r
- pInfo->CTFiltMax[29] = 1098330000;\r
- pInfo->CTFiltMax[30] = 1138990000;\r
- }\r
-\r
- /*\r
- ** Fetch the FCU osc value and use it and the fRef value to\r
- ** scale all of the Band Max values\r
- */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- UData_t fcu_osc;\r
- UData_t i;\r
-\r
- pInfo->reg[MT2063_REG_CTUNE_CTRL] = 0x0A;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_CTUNE_CTRL, &pInfo->reg[MT2063_REG_CTUNE_CTRL], 1);\r
- /* Read the ClearTune filter calibration value */\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_FIFFC, &pInfo->reg[MT2063_REG_FIFFC], 1);\r
- fcu_osc = pInfo->reg[MT2063_REG_FIFFC];\r
-\r
- pInfo->reg[MT2063_REG_CTUNE_CTRL] = 0x00;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_CTUNE_CTRL, &pInfo->reg[MT2063_REG_CTUNE_CTRL], 1);\r
- \r
- /* Adjust each of the values in the ClearTune filter cross-over table */\r
- for (i = 0; i < 31; i++)\r
- {\r
- pInfo->CTFiltMax[i] = (pInfo->CTFiltMax[i]/768) * (fcu_osc + 640);\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/******************************************************************************\r
-**\r
-** Name: MT2063_SetGPIO\r
-**\r
-** Description: Modify the MT2063 GPIO value.\r
-**\r
-** Parameters: h - Open handle to the tuner (from MT2063_Open).\r
-** gpio_id - Selects GPIO0, GPIO1 or GPIO2\r
-** attr - Selects input readback, I/O direction or\r
-** output value\r
-** value - value to set GPIO pin 15, 14 or 19\r
-**\r
-** Usage: status = MT2063_SetGPIO(hMT2063, MT2063_GPIO1, MT2063_GPIO_OUT, 1);\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-**\r
-** Dependencies: MT_WriteSub - Write byte(s) of data to the two-wire-bus\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-******************************************************************************/\r
-UData_t MT2063_SetGPIO(Handle_t h, enum MT2063_GPIO_ID gpio_id,\r
- enum MT2063_GPIO_Attr attr,\r
- UData_t value)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- U8Data regno;\r
- SData_t shift;\r
- static U8Data GPIOreg[3] = {0x15, 0x19, 0x18};\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- return MT2063_INV_HANDLE;\r
-\r
- regno = GPIOreg[attr];\r
-\r
- shift = (gpio_id - MT2063_GPIO0 + 5);\r
-\r
- if (value & 0x01)\r
- pInfo->reg[regno] |= (0x01 << shift);\r
- else\r
- pInfo->reg[regno] &= ~(0x01 << shift);\r
- status = MT2063_WriteSub(pInfo->hUserData, pInfo->address, regno, &pInfo->reg[regno], 1);\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_SetParam\r
-**\r
-** Description: Sets a tuning algorithm parameter.\r
-**\r
-** This function provides access to the internals of the\r
-** tuning algorithm. You can override many of the tuning\r
-** algorithm defaults using this function.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** param - Tuning algorithm parameter\r
-** (see enum MT2063_Param)\r
-** nValue - value to be set\r
-**\r
-** param Description\r
-** ---------------------- --------------------------------\r
-** MT2063_SRO_FREQ crystal frequency\r
-** MT2063_STEPSIZE minimum tuning step size\r
-** MT2063_LO1_FREQ LO1 frequency\r
-** MT2063_LO1_STEPSIZE LO1 minimum step size\r
-** MT2063_LO1_FRACN_AVOID LO1 FracN keep-out region\r
-** MT2063_IF1_REQUEST Requested 1st IF\r
-** MT2063_ZIF_BW zero-IF bandwidth\r
-** MT2063_LO2_FREQ LO2 frequency\r
-** MT2063_LO2_STEPSIZE LO2 minimum step size\r
-** MT2063_LO2_FRACN_AVOID LO2 FracN keep-out region\r
-** MT2063_OUTPUT_FREQ output center frequency\r
-** MT2063_OUTPUT_BW output bandwidth\r
-** MT2063_LO_SEPARATION min inter-tuner LO separation\r
-** MT2063_MAX_HARM1 max # of intra-tuner harmonics\r
-** MT2063_MAX_HARM2 max # of inter-tuner harmonics\r
-** MT2063_RCVR_MODE Predefined modes\r
-** MT2063_LNA_RIN Set LNA Rin (*)\r
-** MT2063_LNA_TGT Set target power level at LNA (*)\r
-** MT2063_PD1_TGT Set target power level at PD1 (*)\r
-** MT2063_PD2_TGT Set target power level at PD2 (*)\r
-** MT2063_ACLNA_MAX LNA attenuator limit (*)\r
-** MT2063_ACRF_MAX RF attenuator limit (*)\r
-** MT2063_ACFIF_MAX FIF attenuator limit (*)\r
-** MT2063_DNC_OUTPUT_ENABLE DNC output selection\r
-** MT2063_VGAGC VGA gain code\r
-** MT2063_VGAOI VGA output current\r
-** MT2063_TAGC TAGC setting\r
-** MT2063_AMPGC AMP gain code\r
-** MT2063_AVOID_DECT Avoid DECT Frequencies\r
-** MT2063_CTFILT_SW Cleartune filter selection\r
-**\r
-** (*) This parameter is set by MT2063_RCVR_MODE, do not call\r
-** additionally.\r
-**\r
-** Usage: status |= MT2063_SetParam(hMT2063,\r
-** MT2063_STEPSIZE,\r
-** 50000);\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Null pointer argument passed\r
-** MT_ARG_RANGE - Invalid parameter requested\r
-** or set value out of range\r
-** or non-writable parameter\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** See Also: MT2063_GetParam, MT2063_Open\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 154 09-13-2007 RSK Ver 1.05: Get/SetParam changes for LOx_FREQ\r
-** 10-31-2007 PINZ Ver 1.08: Get/SetParam add VGAGC, VGAOI, AMPGC, TAGC\r
-** 04-18-2008 PINZ Ver 1.15: Add SetParam LNARIN & PDxTGT\r
-** Split SetParam up to ACLNA / ACLNA_MAX\r
-** removed ACLNA_INRC/DECR (+RF & FIF)\r
-** removed GCUAUTO / BYPATNDN/UP\r
-** 175 I 06-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.\r
-** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.\r
-** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_SetParam(Handle_t h,\r
- enum MT2063_Param param,\r
- UData_t nValue)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- U8Data val=0;\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status |= MT2063_INV_HANDLE;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- switch (param)\r
- {\r
- /* crystal frequency */\r
- case MT2063_SRO_FREQ:\r
- pInfo->AS_Data.f_ref = nValue;\r
- pInfo->AS_Data.f_LO1_FracN_Avoid = 0;\r
- pInfo->AS_Data.f_LO2_FracN_Avoid = nValue / 80 - 1;\r
- pInfo->AS_Data.f_LO1_Step = nValue / 64;\r
- pInfo->AS_Data.f_if1_Center = (pInfo->AS_Data.f_ref / 8) * (pInfo->reg[MT2063_REG_FIFFC] + 640);\r
- break;\r
-\r
- /* minimum tuning step size */\r
- case MT2063_STEPSIZE:\r
- pInfo->AS_Data.f_LO2_Step = nValue;\r
- break;\r
-\r
-\r
- /* LO1 frequency */\r
- case MT2063_LO1_FREQ:\r
- {\r
- /* Note: LO1 and LO2 are BOTH written at toggle of LDLOos */\r
- /* Capture the Divider and Numerator portions of other LO */\r
- U8Data tempLO2CQ[3];\r
- U8Data tempLO2C[3];\r
- U8Data tmpOneShot;\r
- UData_t Div, FracN;\r
- U8Data restore = 0;\r
-\r
- /* Buffer the queue for restoration later and get actual LO2 values. */\r
- status |= MT2063_ReadSub (pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_1, &(tempLO2CQ[0]), 3);\r
- status |= MT2063_ReadSub (pInfo->hUserData, pInfo->address, MT2063_REG_LO2C_1, &(tempLO2C[0]), 3);\r
-\r
- /* clear the one-shot bits */\r
- tempLO2CQ[2] = tempLO2CQ[2] & 0x0F;\r
- tempLO2C[2] = tempLO2C[2] & 0x0F;\r
-\r
- /* only write the queue values if they are different from the actual. */\r
- if( ( tempLO2CQ[0] != tempLO2C[0] ) ||\r
- ( tempLO2CQ[1] != tempLO2C[1] ) ||\r
- ( tempLO2CQ[2] != tempLO2C[2] ) )\r
- {\r
- /* put actual LO2 value into queue (with 0 in one-shot bits) */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_1, &(tempLO2C[0]), 3);\r
-\r
- if( status == MT2063_OK )\r
- {\r
- /* cache the bytes just written. */\r
- pInfo->reg[MT2063_REG_LO2CQ_1] = tempLO2C[0];\r
- pInfo->reg[MT2063_REG_LO2CQ_2] = tempLO2C[1];\r
- pInfo->reg[MT2063_REG_LO2CQ_3] = tempLO2C[2];\r
- }\r
- restore = 1;\r
- }\r
-\r
- /* Calculate the Divider and Numberator components of LO1 */\r
- status = MT2063_CalcLO1Mult(&Div, &FracN, nValue, pInfo->AS_Data.f_ref/64, pInfo->AS_Data.f_ref);\r
- pInfo->reg[MT2063_REG_LO1CQ_1] = (U8Data)(Div & 0x00FF);\r
- pInfo->reg[MT2063_REG_LO1CQ_2] = (U8Data)(FracN);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &pInfo->reg[MT2063_REG_LO1CQ_1], 2);\r
-\r
- /* set the one-shot bit to load the pair of LO values */\r
- tmpOneShot = tempLO2CQ[2] | 0xE0;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_3, &tmpOneShot, 1);\r
-\r
- /* only restore the queue values if they were different from the actual. */\r
- if( restore )\r
- {\r
- /* put actual LO2 value into queue (0 in one-shot bits) */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_1, &(tempLO2CQ[0]), 3);\r
-\r
- /* cache the bytes just written. */\r
- pInfo->reg[MT2063_REG_LO2CQ_1] = tempLO2CQ[0];\r
- pInfo->reg[MT2063_REG_LO2CQ_2] = tempLO2CQ[1];\r
- pInfo->reg[MT2063_REG_LO2CQ_3] = tempLO2CQ[2];\r
- }\r
-\r
- MT2063_GetParam( pInfo->hUserData, MT2063_LO1_FREQ, &pInfo->AS_Data.f_LO1 );\r
- }\r
- break;\r
-\r
- /* LO1 minimum step size */\r
- case MT2063_LO1_STEPSIZE:\r
- pInfo->AS_Data.f_LO1_Step = nValue;\r
- break;\r
-\r
- /* LO1 FracN keep-out region */\r
- case MT2063_LO1_FRACN_AVOID_PARAM:\r
- pInfo->AS_Data.f_LO1_FracN_Avoid = nValue;\r
- break;\r
-\r
- /* Requested 1st IF */\r
- case MT2063_IF1_REQUEST:\r
- pInfo->AS_Data.f_if1_Request = nValue;\r
- break;\r
-\r
- /* zero-IF bandwidth */\r
- case MT2063_ZIF_BW:\r
- pInfo->AS_Data.f_zif_bw = nValue;\r
- break;\r
-\r
- /* LO2 frequency */\r
- case MT2063_LO2_FREQ:\r
- {\r
- /* Note: LO1 and LO2 are BOTH written at toggle of LDLOos */\r
- /* Capture the Divider and Numerator portions of other LO */\r
- U8Data tempLO1CQ[2];\r
- U8Data tempLO1C[2];\r
- UData_t Div2;\r
- UData_t FracN2;\r
- U8Data tmpOneShot;\r
- U8Data restore = 0;\r
-\r
- /* Buffer the queue for restoration later and get actual LO2 values. */\r
- status |= MT2063_ReadSub (pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &(tempLO1CQ[0]), 2);\r
- status |= MT2063_ReadSub (pInfo->hUserData, pInfo->address, MT2063_REG_LO1C_1, &(tempLO1C[0]), 2);\r
-\r
- /* only write the queue values if they are different from the actual. */\r
- if( (tempLO1CQ[0] != tempLO1C[0]) || (tempLO1CQ[1] != tempLO1C[1]) )\r
- {\r
- /* put actual LO1 value into queue */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &(tempLO1C[0]), 2);\r
-\r
- /* cache the bytes just written. */\r
- pInfo->reg[MT2063_REG_LO1CQ_1] = tempLO1C[0];\r
- pInfo->reg[MT2063_REG_LO1CQ_2] = tempLO1C[1];\r
- restore = 1;\r
- }\r
-\r
- /* Calculate the Divider and Numberator components of LO2 */\r
- status = MT2063_CalcLO2Mult(&Div2, &FracN2, nValue, pInfo->AS_Data.f_ref/8191, pInfo->AS_Data.f_ref);\r
- pInfo->reg[MT2063_REG_LO2CQ_1] = (U8Data)((Div2 << 1) | ((FracN2 >> 12) & 0x01) ) & 0xFF;\r
- pInfo->reg[MT2063_REG_LO2CQ_2] = (U8Data)((FracN2 >> 4) & 0xFF);\r
- pInfo->reg[MT2063_REG_LO2CQ_3] = (U8Data)((FracN2 & 0x0F) );\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &pInfo->reg[MT2063_REG_LO1CQ_1], 3);\r
-\r
- /* set the one-shot bit to load the LO values */\r
- tmpOneShot = pInfo->reg[MT2063_REG_LO2CQ_3] | 0xE0;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_3, &tmpOneShot, 1);\r
-\r
- /* only restore LO1 queue value if they were different from the actual. */\r
- if( restore )\r
- {\r
- /* put previous LO1 queue value back into queue */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &(tempLO1CQ[0]), 2);\r
-\r
- /* cache the bytes just written. */\r
- pInfo->reg[MT2063_REG_LO1CQ_1] = tempLO1CQ[0];\r
- pInfo->reg[MT2063_REG_LO1CQ_2] = tempLO1CQ[1];\r
- }\r
-\r
- MT2063_GetParam( pInfo->hUserData, MT2063_LO2_FREQ, &pInfo->AS_Data.f_LO2 );\r
- }\r
- break;\r
-\r
- /* LO2 minimum step size */\r
- case MT2063_LO2_STEPSIZE:\r
- pInfo->AS_Data.f_LO2_Step = nValue;\r
- break;\r
-\r
- /* LO2 FracN keep-out region */\r
- case MT2063_LO2_FRACN_AVOID:\r
- pInfo->AS_Data.f_LO2_FracN_Avoid = nValue;\r
- break;\r
-\r
- /* output center frequency */\r
- case MT2063_OUTPUT_FREQ:\r
- pInfo->AS_Data.f_out = nValue;\r
- break;\r
-\r
- /* output bandwidth */\r
- case MT2063_OUTPUT_BW:\r
- pInfo->AS_Data.f_out_bw = nValue + 750000;\r
- break;\r
-\r
- /* min inter-tuner LO separation */\r
- case MT2063_LO_SEPARATION:\r
- pInfo->AS_Data.f_min_LO_Separation = nValue;\r
- break;\r
-\r
- /* max # of intra-tuner harmonics */\r
- case MT2063_MAX_HARM1:\r
- pInfo->AS_Data.maxH1 = nValue;\r
- break;\r
-\r
- /* max # of inter-tuner harmonics */\r
- case MT2063_MAX_HARM2:\r
- pInfo->AS_Data.maxH2 = nValue;\r
- break;\r
-\r
- case MT2063_RCVR_MODE:\r
- status |= MT2063_SetReceiverMode(pInfo, (enum MT2063_RCVR_MODES)nValue);\r
- break;\r
-\r
- /* Set LNA Rin -- nValue is desired value */\r
- case MT2063_LNA_RIN:\r
- val = ( pInfo->reg[MT2063_REG_CTRL_2C] & (U8Data)~0x03) | (nValue & 0x03);\r
- if( pInfo->reg[MT2063_REG_CTRL_2C] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_CTRL_2C, val);\r
- }\r
- break;\r
-\r
- /* Set target power level at LNA -- nValue is desired value */\r
- case MT2063_LNA_TGT:\r
- val = ( pInfo->reg[MT2063_REG_LNA_TGT] & (U8Data)~0x3F) | (nValue & 0x3F);\r
- if( pInfo->reg[MT2063_REG_LNA_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_LNA_TGT, val);\r
- }\r
- break;\r
-\r
- /* Set target power level at PD1 -- nValue is desired value */\r
- case MT2063_PD1_TGT:\r
- val = ( pInfo->reg[MT2063_REG_PD1_TGT] & (U8Data)~0x3F) | (nValue & 0x3F);\r
- if( pInfo->reg[MT2063_REG_PD1_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_PD1_TGT, val);\r
- }\r
- break;\r
-\r
- /* Set target power level at PD2 -- nValue is desired value */\r
- case MT2063_PD2_TGT:\r
- val = ( pInfo->reg[MT2063_REG_PD2_TGT] & (U8Data)~0x3F) | (nValue & 0x3F);\r
- if( pInfo->reg[MT2063_REG_PD2_TGT] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_PD2_TGT, val);\r
- }\r
- break;\r
-\r
- /* Set LNA atten limit -- nValue is desired value */\r
- case MT2063_ACLNA_MAX:\r
- val = ( pInfo->reg[MT2063_REG_LNA_OV] & (U8Data)~0x1F) | (nValue & 0x1F);\r
- if( pInfo->reg[MT2063_REG_LNA_OV] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_LNA_OV, val);\r
- }\r
- break;\r
-\r
- /* Set RF atten limit -- nValue is desired value */\r
- case MT2063_ACRF_MAX:\r
- val = ( pInfo->reg[MT2063_REG_RF_OV] & (U8Data)~0x1F) | (nValue & 0x1F);\r
- if( pInfo->reg[MT2063_REG_RF_OV] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_RF_OV, val);\r
- }\r
- break;\r
-\r
- /* Set FIF atten limit -- nValue is desired value, max. 5 if no B3 */\r
- case MT2063_ACFIF_MAX:\r
- if ( pInfo->reg[MT2063_REG_PART_REV] != MT2063_B3 && nValue > 5)\r
- nValue = 5;\r
- val = ( pInfo->reg[MT2063_REG_FIF_OV] & (U8Data)~0x1F) | (nValue & 0x1F);\r
- if( pInfo->reg[MT2063_REG_FIF_OV] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_FIF_OV, val);\r
- }\r
- break;\r
-\r
- case MT2063_DNC_OUTPUT_ENABLE:\r
- /* selects, which DNC output is used */\r
- switch ((enum MT2063_DNC_Output_Enable)nValue)\r
- {\r
- case MT2063_DNC_NONE :\r
- {\r
- val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC ) | 0x03; /* Set DNC1GC=3 */\r
- if (pInfo->reg[MT2063_REG_DNC_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_DNC_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC ) | 0x03; /* Set DNC2GC=3 */\r
- if (pInfo->reg[MT2063_REG_VGA_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_VGA_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */\r
- if (pInfo->reg[MT2063_REG_RSVD_20] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_RSVD_20, val);\r
-\r
- break;\r
- }\r
- case MT2063_DNC_1 :\r
- {\r
- val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC ) | (DNC1GC[pInfo->rcvr_mode] & 0x03); /* Set DNC1GC=x */\r
- if (pInfo->reg[MT2063_REG_DNC_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_DNC_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC ) | 0x03; /* Set DNC2GC=3 */\r
- if (pInfo->reg[MT2063_REG_VGA_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_VGA_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_RSVD_20] & ~0x40); /* Set PD2MUX=0 */\r
- if (pInfo->reg[MT2063_REG_RSVD_20] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_RSVD_20, val);\r
-\r
- break;\r
- }\r
- case MT2063_DNC_2 :\r
- {\r
- val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC ) | 0x03; /* Set DNC1GC=3 */\r
- if (pInfo->reg[MT2063_REG_DNC_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_DNC_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC ) | (DNC2GC[pInfo->rcvr_mode] & 0x03); /* Set DNC2GC=x */\r
- if (pInfo->reg[MT2063_REG_VGA_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_VGA_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_RSVD_20] | 0x40); /* Set PD2MUX=1 */\r
- if (pInfo->reg[MT2063_REG_RSVD_20] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_RSVD_20, val);\r
-\r
- break;\r
- }\r
- case MT2063_DNC_BOTH :\r
- {\r
- val = (pInfo->reg[MT2063_REG_DNC_GAIN] & 0xFC ) | (DNC1GC[pInfo->rcvr_mode] & 0x03); /* Set DNC1GC=x */\r
- if (pInfo->reg[MT2063_REG_DNC_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_DNC_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_VGA_GAIN] & 0xFC ) | (DNC2GC[pInfo->rcvr_mode] & 0x03); /* Set DNC2GC=x */\r
- if (pInfo->reg[MT2063_REG_VGA_GAIN] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_VGA_GAIN, val);\r
-\r
- val = (pInfo->reg[MT2063_REG_RSVD_20] | 0x40); /* Set PD2MUX=1 */\r
- if (pInfo->reg[MT2063_REG_RSVD_20] != val)\r
- status |= MT2063_SetReg(h, MT2063_REG_RSVD_20, val);\r
-\r
- break;\r
- }\r
- default : break;\r
- }\r
- break;\r
-\r
- case MT2063_VGAGC:\r
- /* Set VGA gain code */\r
- val = (pInfo->reg[MT2063_REG_VGA_GAIN] & (U8Data)~0x0C) | ( (nValue & 0x03) << 2);\r
- if( pInfo->reg[MT2063_REG_VGA_GAIN] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_VGA_GAIN, val);\r
- }\r
- break;\r
-\r
- case MT2063_VGAOI:\r
- /* Set VGA bias current */\r
- val = (pInfo->reg[MT2063_REG_RSVD_31] & (U8Data)~0x07) | (nValue & 0x07);\r
- if( pInfo->reg[MT2063_REG_RSVD_31] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_RSVD_31, val);\r
- }\r
- break;\r
-\r
- case MT2063_TAGC:\r
- /* Set TAGC */\r
- val = (pInfo->reg[MT2063_REG_RSVD_1E] & (U8Data)~0x03) | (nValue & 0x03);\r
- if( pInfo->reg[MT2063_REG_RSVD_1E] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_RSVD_1E, val);\r
- }\r
- break;\r
-\r
- case MT2063_AMPGC:\r
- /* Set Amp gain code */\r
- val = (pInfo->reg[MT2063_REG_TEMP_SEL] & (U8Data)~0x03) | (nValue & 0x03);\r
- if( pInfo->reg[MT2063_REG_TEMP_SEL] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_TEMP_SEL, val);\r
- }\r
- break;\r
-\r
- /* Avoid DECT Frequencies */\r
- case MT2063_AVOID_DECT:\r
- {\r
- enum MT2063_DECT_Avoid_Type newAvoidSetting = (enum MT2063_DECT_Avoid_Type) nValue;\r
- if( (newAvoidSetting >= MT2063_NO_DECT_AVOIDANCE) && (newAvoidSetting <= MT2063_AVOID_BOTH) )\r
- {\r
- pInfo->AS_Data.avoidDECT = newAvoidSetting;\r
- }\r
- }\r
- break;\r
-\r
- /* Cleartune filter selection: 0 - by IC (default), 1 - by software */\r
- case MT2063_CTFILT_SW:\r
- pInfo->ctfilt_sw = (nValue & 0x01);\r
- break;\r
-\r
- /* These parameters are read-only */\r
- case MT2063_IC_ADDR:\r
- case MT2063_MAX_OPEN:\r
- case MT2063_NUM_OPEN:\r
- case MT2063_INPUT_FREQ:\r
- case MT2063_IF1_ACTUAL:\r
- case MT2063_IF1_CENTER:\r
- case MT2063_IF1_BW:\r
- case MT2063_AS_ALG:\r
- case MT2063_EXCL_ZONES:\r
- case MT2063_SPUR_AVOIDED:\r
- case MT2063_NUM_SPURS:\r
- case MT2063_SPUR_PRESENT:\r
- case MT2063_ACLNA:\r
- case MT2063_ACRF:\r
- case MT2063_ACFIF:\r
- case MT2063_EOP:\r
- default:\r
- status |= MT2063_ARG_RANGE;\r
- }\r
- }\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_SetPowerMaskBits\r
-**\r
-** Description: Sets the power-down mask bits for various sections of\r
-** the MT2063\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Bits - Mask bits to be set.\r
-**\r
-** See definition of MT2063_Mask_Bits type for description\r
-** of each of the power bits.\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_SetPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits Bits)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
- else\r
- {\r
- Bits = (enum MT2063_Mask_Bits)(Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */\r
- if ((Bits & 0xFF00) != 0)\r
- {\r
- pInfo->reg[MT2063_REG_PWR_2] |= (U8Data)((Bits & 0xFF00) >> 8);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_2, &pInfo->reg[MT2063_REG_PWR_2], 1);\r
- }\r
- if ((Bits & 0xFF) != 0)\r
- {\r
- pInfo->reg[MT2063_REG_PWR_1] |= ((U8Data)Bits & 0xFF);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_1, &pInfo->reg[MT2063_REG_PWR_1], 1);\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_ClearPowerMaskBits\r
-**\r
-** Description: Clears the power-down mask bits for various sections of\r
-** the MT2063\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Bits - Mask bits to be cleared.\r
-**\r
-** See definition of MT2063_Mask_Bits type for description\r
-** of each of the power bits.\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_ClearPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits Bits)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
- else\r
- {\r
- Bits = (enum MT2063_Mask_Bits)(Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */\r
- if ((Bits & 0xFF00) != 0)\r
- {\r
- pInfo->reg[MT2063_REG_PWR_2] &= ~(U8Data)(Bits >> 8);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_2, &pInfo->reg[MT2063_REG_PWR_2], 1);\r
- }\r
- if ((Bits & 0xFF) != 0)\r
- {\r
- pInfo->reg[MT2063_REG_PWR_1] &= ~(U8Data)(Bits & 0xFF);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_1, &pInfo->reg[MT2063_REG_PWR_1], 1);\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_GetPowerMaskBits\r
-**\r
-** Description: Returns a mask of the enabled power shutdown bits\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Bits - Mask bits to currently set.\r
-**\r
-** See definition of MT2063_Mask_Bits type for description\r
-** of each of the power bits.\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_NULL - Output argument is NULL\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_GetPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits *Bits)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
- else\r
- {\r
- if (Bits == NULL)\r
- status |= MT2063_ARG_NULL;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_1, &pInfo->reg[MT2063_REG_PWR_1], 2);\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- *Bits = (enum MT2063_Mask_Bits)(((SData_t)pInfo->reg[MT2063_REG_PWR_2] << 8) + pInfo->reg[MT2063_REG_PWR_1]);\r
- *Bits = (enum MT2063_Mask_Bits)(*Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_EnableExternalShutdown\r
-**\r
-** Description: Enables or disables the operation of the external\r
-** shutdown pin\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Enabled - 0 = disable the pin, otherwise enable it\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_EnableExternalShutdown(Handle_t h, U8Data Enabled)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
- else\r
- {\r
- if (Enabled == 0)\r
- pInfo->reg[MT2063_REG_PWR_1] &= ~0x08; /* Turn off the bit */\r
- else\r
- pInfo->reg[MT2063_REG_PWR_1] |= 0x08; /* Turn the bit on */\r
-\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_1, &pInfo->reg[MT2063_REG_PWR_1], 1);\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_SoftwareShutdown\r
-**\r
-** Description: Enables or disables software shutdown function. When\r
-** Shutdown==1, any section whose power mask is set will be\r
-** shutdown.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Shutdown - 1 = shutdown the masked sections, otherwise\r
-** power all sections on\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_COMM_ERR - Serial bus communications error\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 01-03-2008 PINZ Ver 1.xx: Added a trigger of BYPATNUP for\r
-** correct wakeup of the LNA\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_SoftwareShutdown(Handle_t h, U8Data Shutdown)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- {\r
- status = MT2063_INV_HANDLE;\r
- }\r
- else\r
- {\r
- if (Shutdown == 1)\r
- pInfo->reg[MT2063_REG_PWR_1] |= 0x04; /* Turn the bit on */\r
- else\r
- pInfo->reg[MT2063_REG_PWR_1] &= ~0x04; /* Turn off the bit */\r
-\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_PWR_1, &pInfo->reg[MT2063_REG_PWR_1], 1);\r
- \r
- if (Shutdown != 1)\r
- {\r
- pInfo->reg[MT2063_REG_BYP_CTRL] = (pInfo->reg[MT2063_REG_BYP_CTRL] & 0x9F) | 0x40;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_BYP_CTRL, &pInfo->reg[MT2063_REG_BYP_CTRL], 1);\r
- pInfo->reg[MT2063_REG_BYP_CTRL] = (pInfo->reg[MT2063_REG_BYP_CTRL] & 0x9F);\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_BYP_CTRL, &pInfo->reg[MT2063_REG_BYP_CTRL], 1);\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_SetExtSRO\r
-**\r
-** Description: Sets the external SRO driver.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** Ext_SRO_Setting - external SRO drive setting\r
-**\r
-** (default) MT2063_EXT_SRO_OFF - ext driver off\r
-** MT2063_EXT_SRO_BY_1 - ext driver = SRO frequency\r
-** MT2063_EXT_SRO_BY_2 - ext driver = SRO/2 frequency\r
-** MT2063_EXT_SRO_BY_4 - ext driver = SRO/4 frequency\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** The Ext_SRO_Setting settings default to OFF\r
-** Use this function if you need to override the default\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 189 S 05-13-2008 RSK Ver 1.16: Correct location for ExtSRO control.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_SetExtSRO(Handle_t h,\r
- enum MT2063_Ext_SRO Ext_SRO_Setting)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status = MT2063_INV_HANDLE;\r
- else\r
- {\r
- pInfo->reg[MT2063_REG_CTRL_2C] = (pInfo->reg[MT2063_REG_CTRL_2C] & 0x3F) | ((U8Data)Ext_SRO_Setting << 6);\r
- status = MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_CTRL_2C, &pInfo->reg[MT2063_REG_CTRL_2C], 1);\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_SetReg\r
-**\r
-** Description: Sets an MT2063 register.\r
-**\r
-** Parameters: h - Tuner handle (returned by MT2063_Open)\r
-** reg - MT2063 register/subaddress location\r
-** val - MT2063 register/subaddress value\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_ARG_RANGE - Argument out of range\r
-**\r
-** Dependencies: USERS MUST CALL MT2063_Open() FIRST!\r
-**\r
-** Use this function if you need to override a default\r
-** register value\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_SetReg(Handle_t h,\r
- U8Data reg,\r
- U8Data val)\r
-{\r
- UData_t status = MT2063_OK; /* Status to be returned */\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- status |= MT2063_INV_HANDLE;\r
-\r
- if (reg >= MT2063_REG_END_REGS)\r
- status |= MT2063_ARG_RANGE;\r
-\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, reg, &val, 1);\r
- if (MT2063_NO_ERROR(status))\r
- pInfo->reg[reg] = val;\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-\r
-static UData_t MT2063_Round_fLO(UData_t f_LO, UData_t f_LO_Step, UData_t f_ref)\r
-{\r
- return f_ref * (f_LO / f_ref)\r
- + f_LO_Step * (((f_LO % f_ref) + (f_LO_Step / 2)) / f_LO_Step);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: fLO_FractionalTerm\r
-**\r
-** Description: Calculates the portion contributed by FracN / denom.\r
-**\r
-** This function preserves maximum precision without\r
-** risk of overflow. It accurately calculates\r
-** f_ref * num / denom to within 1 HZ with fixed math.\r
-**\r
-** Parameters: num - Fractional portion of the multiplier\r
-** denom - denominator portion of the ratio\r
-** This routine successfully handles denom values\r
-** up to and including 2^18.\r
-** f_Ref - SRO frequency. This calculation handles\r
-** f_ref as two separate 14-bit fields.\r
-** Therefore, a maximum value of 2^28-1\r
-** may safely be used for f_ref. This is\r
-** the genesis of the magic number "14" and the\r
-** magic mask value of 0x03FFF.\r
-**\r
-** Returns: f_ref * num / denom\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-static UData_t MT2063_fLO_FractionalTerm( UData_t f_ref,\r
- UData_t num,\r
- UData_t denom )\r
-{\r
- UData_t t1 = (f_ref >> 14) * num;\r
- UData_t term1 = t1 / denom;\r
- UData_t loss = t1 % denom;\r
- UData_t term2 = ( ((f_ref & 0x00003FFF) * num + (loss<<14)) + (denom/2) ) / denom;\r
- return ((term1 << 14) + term2);\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: CalcLO1Mult\r
-**\r
-** Description: Calculates Integer divider value and the numerator\r
-** value for a FracN PLL.\r
-**\r
-** This function assumes that the f_LO and f_Ref are\r
-** evenly divisible by f_LO_Step.\r
-**\r
-** Parameters: Div - OUTPUT: Whole number portion of the multiplier\r
-** FracN - OUTPUT: Fractional portion of the multiplier\r
-** f_LO - desired LO frequency.\r
-** f_LO_Step - Minimum step size for the LO (in Hz).\r
-** f_Ref - SRO frequency.\r
-** f_Avoid - Range of PLL frequencies to avoid near\r
-** integer multiples of f_Ref (in Hz).\r
-**\r
-** Returns: Recalculated LO frequency.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-static UData_t MT2063_CalcLO1Mult(UData_t *Div,\r
- UData_t *FracN,\r
- UData_t f_LO,\r
- UData_t f_LO_Step,\r
- UData_t f_Ref)\r
-{\r
- /* Calculate the whole number portion of the divider */\r
- *Div = f_LO / f_Ref;\r
-\r
- /* Calculate the numerator value (round to nearest f_LO_Step) */\r
- *FracN = (64 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) + (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);\r
-\r
- return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm( f_Ref, *FracN, 64 );\r
-}\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: CalcLO2Mult\r
-**\r
-** Description: Calculates Integer divider value and the numerator\r
-** value for a FracN PLL.\r
-**\r
-** This function assumes that the f_LO and f_Ref are\r
-** evenly divisible by f_LO_Step.\r
-**\r
-** Parameters: Div - OUTPUT: Whole number portion of the multiplier\r
-** FracN - OUTPUT: Fractional portion of the multiplier\r
-** f_LO - desired LO frequency.\r
-** f_LO_Step - Minimum step size for the LO (in Hz).\r
-** f_Ref - SRO frequency.\r
-** f_Avoid - Range of PLL frequencies to avoid near\r
-** integer multiples of f_Ref (in Hz).\r
-**\r
-** Returns: Recalculated LO frequency.\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-**\r
-****************************************************************************/\r
-static UData_t MT2063_CalcLO2Mult(UData_t *Div,\r
- UData_t *FracN,\r
- UData_t f_LO,\r
- UData_t f_LO_Step,\r
- UData_t f_Ref)\r
-{\r
- /* Calculate the whole number portion of the divider */\r
- *Div = f_LO / f_Ref;\r
-\r
- /* Calculate the numerator value (round to nearest f_LO_Step) */\r
- *FracN = (8191 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) + (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);\r
-\r
- return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm( f_Ref, *FracN, 8191 );\r
-}\r
-\r
-/****************************************************************************\r
-**\r
-** Name: FindClearTuneFilter\r
-**\r
-** Description: Calculate the corrrect ClearTune filter to be used for\r
-** a given input frequency.\r
-**\r
-** Parameters: pInfo - ptr to tuner data structure\r
-** f_in - RF input center frequency (in Hz).\r
-**\r
-** Returns: ClearTune filter number (0-31)\r
-**\r
-** Dependencies: MUST CALL MT2064_Open BEFORE FindClearTuneFilter!\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 04-10-2008 PINZ Ver 1.14: Use software-controlled ClearTune\r
-** cross-over frequency values.\r
-**\r
-****************************************************************************/\r
-static UData_t FindClearTuneFilter(struct MT2063_Info_t* pInfo, UData_t f_in)\r
-{\r
- UData_t RFBand;\r
- UData_t idx; /* index loop */\r
-\r
- /*\r
- ** Find RF Band setting\r
- */\r
- RFBand = 31; /* def when f_in > all */\r
- for (idx=0; idx<31; ++idx)\r
- {\r
- if (pInfo->CTFiltMax[idx] >= f_in)\r
- {\r
- RFBand = idx;\r
- break;\r
- }\r
- }\r
- return (RFBand);\r
-}\r
-\r
-\r
-\r
-/****************************************************************************\r
-**\r
-** Name: MT2063_Tune\r
-**\r
-** Description: Change the tuner's tuned frequency to RFin.\r
-**\r
-** Parameters: h - Open handle to the tuner (from MT2063_Open).\r
-** f_in - RF input center frequency (in Hz).\r
-**\r
-** Returns: status:\r
-** MT_OK - No errors\r
-** MT_INV_HANDLE - Invalid tuner handle\r
-** MT_UPC_UNLOCK - Upconverter PLL unlocked\r
-** MT_DNC_UNLOCK - Downconverter PLL unlocked\r
-** MT_COMM_ERR - Serial bus communications error\r
-** MT_SPUR_CNT_MASK - Count of avoided LO spurs\r
-** MT_SPUR_PRESENT - LO spur possible in output\r
-** MT_FIN_RANGE - Input freq out of range\r
-** MT_FOUT_RANGE - Output freq out of range\r
-** MT_UPC_RANGE - Upconverter freq out of range\r
-** MT_DNC_RANGE - Downconverter freq out of range\r
-**\r
-** Dependencies: MUST CALL MT2063_Open BEFORE MT2063_Tune!\r
-**\r
-** MT_ReadSub - Read data from the two-wire serial bus\r
-** MT_WriteSub - Write data to the two-wire serial bus\r
-** MT_Sleep - Delay execution for x milliseconds\r
-** MT2063_GetLocked - Checks to see if LO1 and LO2 are locked\r
-**\r
-** Revision History:\r
-**\r
-** SCR Date Author Description\r
-** -------------------------------------------------------------------------\r
-** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.\r
-** 04-10-2008 PINZ Ver 1.05: Use software-controlled ClearTune\r
-** cross-over frequency values.\r
-** 175 I 16-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.\r
-** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.\r
-** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW\r
-**\r
-****************************************************************************/\r
-UData_t MT2063_Tune(Handle_t h,\r
- UData_t f_in) /* RF input center frequency */\r
-{\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
-\r
- UData_t status = MT2063_OK; /* status of operation */\r
- UData_t LO1; /* 1st LO register value */\r
- UData_t Num1; /* Numerator for LO1 reg. value */\r
- UData_t f_IF1; /* 1st IF requested */\r
- UData_t LO2; /* 2nd LO register value */\r
- UData_t Num2; /* Numerator for LO2 reg. value */\r
- UData_t ofLO1, ofLO2; /* last time's LO frequencies */\r
- UData_t ofin, ofout; /* last time's I/O frequencies */\r
- U8Data fiffc = 0x80; /* FIFF center freq from tuner */\r
- UData_t fiffof; /* Offset from FIFF center freq */\r
- const U8Data LO1LK = 0x80; /* Mask for LO1 Lock bit */\r
- U8Data LO2LK = 0x08; /* Mask for LO2 Lock bit */\r
- U8Data val;\r
- UData_t RFBand;\r
-\r
- /* Verify that the handle passed points to a valid tuner */\r
- if (MT2063_IsValidHandle(pInfo) == 0)\r
- return MT2063_INV_HANDLE;\r
-\r
- /* Check the input and output frequency ranges */\r
- if ((f_in < MT2063_MIN_FIN_FREQ) || (f_in > MT2063_MAX_FIN_FREQ))\r
- status |= MT2063_FIN_RANGE;\r
-\r
- if ((pInfo->AS_Data.f_out < MT2063_MIN_FOUT_FREQ) || (pInfo->AS_Data.f_out > MT2063_MAX_FOUT_FREQ))\r
- status |= MT2063_FOUT_RANGE;\r
- \r
- /*\r
- ** Save original LO1 and LO2 register values\r
- */\r
- ofLO1 = pInfo->AS_Data.f_LO1;\r
- ofLO2 = pInfo->AS_Data.f_LO2;\r
- ofin = pInfo->AS_Data.f_in;\r
- ofout = pInfo->AS_Data.f_out;\r
-\r
- /*\r
- ** Find and set RF Band setting\r
- */\r
- if (pInfo->ctfilt_sw == 1)\r
- {\r
- val = ( pInfo->reg[MT2063_REG_CTUNE_CTRL] | 0x08 );\r
- if( pInfo->reg[MT2063_REG_CTUNE_CTRL] != val )\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_CTUNE_CTRL, val);\r
- }\r
- val = pInfo->reg[MT2063_REG_CTUNE_OV];\r
- RFBand = FindClearTuneFilter(pInfo, f_in);\r
- pInfo->reg[MT2063_REG_CTUNE_OV] = (U8Data)((pInfo->reg[MT2063_REG_CTUNE_OV] & ~0x1F)\r
- | RFBand);\r
- if (pInfo->reg[MT2063_REG_CTUNE_OV] != val)\r
- {\r
- status |= MT2063_SetReg(pInfo, MT2063_REG_CTUNE_OV, val);\r
- }\r
- }\r
-\r
- /*\r
- ** Read the FIFF Center Frequency from the tuner\r
- */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_ReadSub(pInfo->hUserData, pInfo->address, MT2063_REG_FIFFC, &pInfo->reg[MT2063_REG_FIFFC], 1);\r
- fiffc = pInfo->reg[MT2063_REG_FIFFC];\r
- }\r
- /*\r
- ** Assign in the requested values\r
- */\r
- pInfo->AS_Data.f_in = f_in;\r
- /* Request a 1st IF such that LO1 is on a step size */\r
- pInfo->AS_Data.f_if1_Request = MT2063_Round_fLO(pInfo->AS_Data.f_if1_Request + f_in, pInfo->AS_Data.f_LO1_Step, pInfo->AS_Data.f_ref) - f_in;\r
-\r
- /*\r
- ** Calculate frequency settings. f_IF1_FREQ + f_in is the\r
- ** desired LO1 frequency\r
- */\r
- MT2063_ResetExclZones(&pInfo->AS_Data);\r
- \r
- f_IF1 = MT2063_ChooseFirstIF(&pInfo->AS_Data);\r
- \r
- pInfo->AS_Data.f_LO1 = MT2063_Round_fLO(f_IF1 + f_in, pInfo->AS_Data.f_LO1_Step, pInfo->AS_Data.f_ref);\r
- \r
- pInfo->AS_Data.f_LO2 = MT2063_Round_fLO(pInfo->AS_Data.f_LO1 - pInfo->AS_Data.f_out - f_in, pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);\r
- \r
- /*\r
- ** Check for any LO spurs in the output bandwidth and adjust\r
- ** the LO settings to avoid them if needed\r
- */\r
- status |= MT2063_AvoidSpurs(h, &pInfo->AS_Data);\r
- /*\r
- ** MT_AvoidSpurs spurs may have changed the LO1 & LO2 values.\r
- ** Recalculate the LO frequencies and the values to be placed\r
- ** in the tuning registers.\r
- */\r
- pInfo->AS_Data.f_LO1 = MT2063_CalcLO1Mult(&LO1, &Num1, pInfo->AS_Data.f_LO1, pInfo->AS_Data.f_LO1_Step, pInfo->AS_Data.f_ref);\r
- pInfo->AS_Data.f_LO2 = MT2063_Round_fLO(pInfo->AS_Data.f_LO1 - pInfo->AS_Data.f_out - f_in, pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);\r
- pInfo->AS_Data.f_LO2 = MT2063_CalcLO2Mult(&LO2, &Num2, pInfo->AS_Data.f_LO2, pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);\r
-\r
- \r
- /*\r
- ** Check the upconverter and downconverter frequency ranges\r
- */\r
- if ((pInfo->AS_Data.f_LO1 < MT2063_MIN_UPC_FREQ) || (pInfo->AS_Data.f_LO1 > MT2063_MAX_UPC_FREQ))\r
- status |= MT2063_UPC_RANGE;\r
- if ((pInfo->AS_Data.f_LO2 < MT2063_MIN_DNC_FREQ) || (pInfo->AS_Data.f_LO2 > MT2063_MAX_DNC_FREQ))\r
- status |= MT2063_DNC_RANGE;\r
- /* LO2 Lock bit was in a different place for B0 version */\r
- if (pInfo->tuner_id == MT2063_B0)\r
- LO2LK = 0x40;\r
-\r
- /*\r
- ** If we have the same LO frequencies and we're already locked,\r
- ** then skip re-programming the LO registers.\r
- */\r
- if ((ofLO1 != pInfo->AS_Data.f_LO1)\r
- || (ofLO2 != pInfo->AS_Data.f_LO2)\r
- || ((pInfo->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) != (LO1LK | LO2LK)))\r
- {\r
- /*\r
- ** Calculate the FIFFOF register value\r
- **\r
- ** IF1_Actual\r
- ** FIFFOF = ------------ - 8 * FIFFC - 4992\r
- ** f_ref/64\r
- */\r
- fiffof = (pInfo->AS_Data.f_LO1 - f_in) / (pInfo->AS_Data.f_ref / 64) - 8 * (UData_t)fiffc - 4992;\r
- if (fiffof > 0xFF)\r
- fiffof = 0xFF;\r
-\r
- /*\r
- ** Place all of the calculated values into the local tuner\r
- ** register fields.\r
- */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- pInfo->reg[MT2063_REG_LO1CQ_1] = (U8Data)(LO1 & 0xFF); /* DIV1q */\r
- pInfo->reg[MT2063_REG_LO1CQ_2] = (U8Data)(Num1 & 0x3F); /* NUM1q */\r
- pInfo->reg[MT2063_REG_LO2CQ_1] = (U8Data)(((LO2 & 0x7F) << 1) /* DIV2q */\r
- | (Num2 >> 12)); /* NUM2q (hi) */\r
- pInfo->reg[MT2063_REG_LO2CQ_2] = (U8Data)((Num2 & 0x0FF0) >> 4); /* NUM2q (mid) */\r
- pInfo->reg[MT2063_REG_LO2CQ_3] = (U8Data)(0xE0 | (Num2 & 0x000F)); /* NUM2q (lo) */\r
-\r
- /*\r
- ** Now write out the computed register values\r
- ** IMPORTANT: There is a required order for writing\r
- ** (0x05 must follow all the others).\r
- */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &pInfo->reg[MT2063_REG_LO1CQ_1], 5); /* 0x01 - 0x05 */\r
- if (pInfo->tuner_id == MT2063_B0)\r
- {\r
- /* Re-write the one-shot bits to trigger the tune operation */\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_3, &pInfo->reg[MT2063_REG_LO2CQ_3], 1); /* 0x05 */\r
- }\r
- /* Write out the FIFF offset only if it's changing */\r
- if (pInfo->reg[MT2063_REG_FIFF_OFFSET] != (U8Data)fiffof)\r
- {\r
- pInfo->reg[MT2063_REG_FIFF_OFFSET] = (U8Data)fiffof;\r
- status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_FIFF_OFFSET, &pInfo->reg[MT2063_REG_FIFF_OFFSET], 1);\r
- }\r
- }\r
-\r
- /*\r
- ** Check for LO's locking\r
- */\r
-\r
- \r
- if (MT2063_NO_ERROR(status))\r
- {\r
- status |= MT2063_GetLocked(h);\r
- }\r
- /*\r
- ** If we locked OK, assign calculated data to MT2063_Info_t structure\r
- */\r
- if (MT2063_NO_ERROR(status))\r
- {\r
- pInfo->f_IF1_actual = pInfo->AS_Data.f_LO1 - f_in;\r
- }\r
- }\r
-\r
- return (status);\r
-}\r
-\r
-UData_t MT_Tune_atv(Handle_t h, UData_t f_in, UData_t bw_in, enum MTTune_atv_standard tv_type) \r
-{\r
-\r
- UData_t status = MT2063_OK;\r
- struct MT2063_Info_t* pInfo = (struct MT2063_Info_t*) h;\r
- struct dvb_frontend *fe = (struct dvb_frontend *)pInfo->hUserData;\r
- struct mt2063_state *state = fe->tuner_priv;\r
-\r
- SData_t pict_car = 0;\r
- SData_t pict2chanb_vsb = 0;\r
- SData_t pict2chanb_snd = 0;\r
- SData_t pict2snd1 = 0;\r
- SData_t pict2snd2 = 0;\r
- SData_t ch_bw = 0;\r
-\r
- SData_t if_mid = 0;\r
- SData_t rcvr_mode =0;\r
- UData_t mode_get =0;\r
-\r
- \r
- switch (tv_type) {\r
- case MTTUNEA_PAL_B : {\r
- pict_car = 38900000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 5500000;\r
- pict2snd2 = 5742000;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_PAL_G : {\r
- pict_car = 38900000;\r
- ch_bw = 7000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 5500000;\r
- pict2snd2 = 0;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_PAL_I : {\r
- pict_car = 38900000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 6000000;\r
- pict2snd2 = 0;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_PAL_L : {\r
- pict_car = 38900000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 6500000;\r
- pict2snd2 = 0;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_PAL_MN : {\r
- pict_car = 38900000;\r
- ch_bw = 6000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 4500000;\r
- pict2snd2 = 0;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_PAL_DK : {\r
- pict_car = 38900000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -1250000; \r
- pict2snd1 = 6500000;\r
- pict2snd2 = 0;\r
- rcvr_mode =1;\r
- break;\r
- }\r
- case MTTUNEA_DIGITAL : {\r
- pict_car = 36125000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -(ch_bw/2); \r
- pict2snd1 = 0;\r
- pict2snd2 = 0;\r
- rcvr_mode = 2;\r
- break;\r
- }\r
- case MTTUNEA_FMRADIO : {\r
- pict_car = 38900000;\r
- ch_bw = 8000000; \r
- pict2chanb_vsb = -(ch_bw/2); \r
- pict2snd1 = 0;\r
- pict2snd2 = 0;\r
- rcvr_mode =4;\r
- //f_in -= 2900000;\r
- break;\r
- }\r
- case MTTUNEA_DVBC : {\r
- pict_car = 36125000;\r
- ch_bw = 8000000;\r
- pict2chanb_vsb = -(ch_bw/2); \r
- pict2snd1 = 0;\r
- pict2snd2 = 0;\r
- rcvr_mode = MT2063_CABLE_QAM;\r
- break;\r
- } \r
- case MTTUNEA_DVBT : {\r
- pict_car = 36125000;\r
- ch_bw = bw_in;//8000000\r
- pict2chanb_vsb = -(ch_bw/2); \r
- pict2snd1 = 0;\r
- pict2snd2 = 0;\r
- rcvr_mode = MT2063_OFFAIR_COFDM;\r
- break;\r
- }\r
- case MTTUNEA_UNKNOWN : break;\r
- default : break;\r
- }\r
-\r
- pict2chanb_snd = pict2chanb_vsb - ch_bw;\r
- if_mid = pict_car - (pict2chanb_vsb + (ch_bw/2) );\r
-\r
- status |= MT2063_SetParam(h,MT2063_STEPSIZE,125000);\r
- status |= MT2063_SetParam(h,MT2063_OUTPUT_FREQ,if_mid);\r
- status |= MT2063_SetParam(h,MT2063_OUTPUT_BW,ch_bw);\r
- status |=MT2063_GetParam(h,MT2063_RCVR_MODE,&mode_get);\r
- \r
- status |= MT2063_SetParam(h,MT2063_RCVR_MODE,rcvr_mode);\r
- status |= MT2063_Tune(h,( f_in + (pict2chanb_vsb + (ch_bw/2) ) ) );\r
- status |=MT2063_GetParam(h,MT2063_RCVR_MODE,&mode_get);\r
- \r
- return (UData_t)status;\r
-} \r
-\r
-\r
-static int mt2063_init(struct dvb_frontend *fe)\r
-{\r
- UData_t status = MT2063_ERROR;\r
- struct mt2063_state *state = fe->tuner_priv;\r
-\r
- status = MT2063_Open(0xC0, &(state->MT2063_ht), fe);\r
- status |= MT2063_SoftwareShutdown(state->MT2063_ht, 1);\r
- status |= MT2063_ClearPowerMaskBits(state->MT2063_ht, MT2063_ALL_SD); \r
-\r
- if(MT2063_OK != status)\r
- {\r
- printk("%s %d error status = 0x%x!!\n", __func__, __LINE__, status);\r
- return -1;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-static int mt2063_sleep(struct dvb_frontend *fe)\r
+ }
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_SetPowerMaskBits
+**
+** Description: Sets the power-down mask bits for various sections of
+** the MT2063
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Bits - Mask bits to be set.
+**
+** See definition of MT2063_Mask_Bits type for description
+** of each of the power bits.
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_SetPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits Bits)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+ else {
+ Bits = (enum MT2063_Mask_Bits)(Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */
+ if ((Bits & 0xFF00) != 0) {
+ pInfo->reg[MT2063_REG_PWR_2] |=
+ (U8Data) ((Bits & 0xFF00) >> 8);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_2,
+ &pInfo->reg[MT2063_REG_PWR_2], 1);
+ }
+ if ((Bits & 0xFF) != 0) {
+ pInfo->reg[MT2063_REG_PWR_1] |= ((U8Data) Bits & 0xFF);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_1,
+ &pInfo->reg[MT2063_REG_PWR_1], 1);
+ }
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_ClearPowerMaskBits
+**
+** Description: Clears the power-down mask bits for various sections of
+** the MT2063
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Bits - Mask bits to be cleared.
+**
+** See definition of MT2063_Mask_Bits type for description
+** of each of the power bits.
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_ClearPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits Bits)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+ else {
+ Bits = (enum MT2063_Mask_Bits)(Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */
+ if ((Bits & 0xFF00) != 0) {
+ pInfo->reg[MT2063_REG_PWR_2] &= ~(U8Data) (Bits >> 8);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_2,
+ &pInfo->reg[MT2063_REG_PWR_2], 1);
+ }
+ if ((Bits & 0xFF) != 0) {
+ pInfo->reg[MT2063_REG_PWR_1] &= ~(U8Data) (Bits & 0xFF);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_1,
+ &pInfo->reg[MT2063_REG_PWR_1], 1);
+ }
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_GetPowerMaskBits
+**
+** Description: Returns a mask of the enabled power shutdown bits
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Bits - Mask bits to currently set.
+**
+** See definition of MT2063_Mask_Bits type for description
+** of each of the power bits.
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_NULL - Output argument is NULL
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_GetPowerMaskBits(Handle_t h, enum MT2063_Mask_Bits * Bits)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+ else {
+ if (Bits == NULL)
+ status |= MT2063_ARG_NULL;
+
+ if (MT2063_NO_ERROR(status))
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_1,
+ &pInfo->reg[MT2063_REG_PWR_1], 2);
+
+ if (MT2063_NO_ERROR(status)) {
+ *Bits =
+ (enum
+ MT2063_Mask_Bits)(((SData_t) pInfo->
+ reg[MT2063_REG_PWR_2] << 8) +
+ pInfo->reg[MT2063_REG_PWR_1]);
+ *Bits = (enum MT2063_Mask_Bits)(*Bits & MT2063_ALL_SD); /* Only valid bits for this tuner */
+ }
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_EnableExternalShutdown
+**
+** Description: Enables or disables the operation of the external
+** shutdown pin
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Enabled - 0 = disable the pin, otherwise enable it
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_EnableExternalShutdown(Handle_t h, U8Data Enabled)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+ else {
+ if (Enabled == 0)
+ pInfo->reg[MT2063_REG_PWR_1] &= ~0x08; /* Turn off the bit */
+ else
+ pInfo->reg[MT2063_REG_PWR_1] |= 0x08; /* Turn the bit on */
+
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_1,
+ &pInfo->reg[MT2063_REG_PWR_1], 1);
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_SoftwareShutdown
+**
+** Description: Enables or disables software shutdown function. When
+** Shutdown==1, any section whose power mask is set will be
+** shutdown.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Shutdown - 1 = shutdown the masked sections, otherwise
+** power all sections on
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_COMM_ERR - Serial bus communications error
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 01-03-2008 PINZ Ver 1.xx: Added a trigger of BYPATNUP for
+** correct wakeup of the LNA
+**
+****************************************************************************/
+UData_t MT2063_SoftwareShutdown(Handle_t h, U8Data Shutdown)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0) {
+ status = MT2063_INV_HANDLE;
+ } else {
+ if (Shutdown == 1)
+ pInfo->reg[MT2063_REG_PWR_1] |= 0x04; /* Turn the bit on */
+ else
+ pInfo->reg[MT2063_REG_PWR_1] &= ~0x04; /* Turn off the bit */
+
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_PWR_1,
+ &pInfo->reg[MT2063_REG_PWR_1], 1);
+
+ if (Shutdown != 1) {
+ pInfo->reg[MT2063_REG_BYP_CTRL] =
+ (pInfo->reg[MT2063_REG_BYP_CTRL] & 0x9F) | 0x40;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_BYP_CTRL,
+ &pInfo->reg[MT2063_REG_BYP_CTRL],
+ 1);
+ pInfo->reg[MT2063_REG_BYP_CTRL] =
+ (pInfo->reg[MT2063_REG_BYP_CTRL] & 0x9F);
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_BYP_CTRL,
+ &pInfo->reg[MT2063_REG_BYP_CTRL],
+ 1);
+ }
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_SetExtSRO
+**
+** Description: Sets the external SRO driver.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** Ext_SRO_Setting - external SRO drive setting
+**
+** (default) MT2063_EXT_SRO_OFF - ext driver off
+** MT2063_EXT_SRO_BY_1 - ext driver = SRO frequency
+** MT2063_EXT_SRO_BY_2 - ext driver = SRO/2 frequency
+** MT2063_EXT_SRO_BY_4 - ext driver = SRO/4 frequency
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** The Ext_SRO_Setting settings default to OFF
+** Use this function if you need to override the default
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 189 S 05-13-2008 RSK Ver 1.16: Correct location for ExtSRO control.
+**
+****************************************************************************/
+UData_t MT2063_SetExtSRO(Handle_t h, enum MT2063_Ext_SRO Ext_SRO_Setting)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status = MT2063_INV_HANDLE;
+ else {
+ pInfo->reg[MT2063_REG_CTRL_2C] =
+ (pInfo->
+ reg[MT2063_REG_CTRL_2C] & 0x3F) | ((U8Data) Ext_SRO_Setting
+ << 6);
+ status =
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_CTRL_2C,
+ &pInfo->reg[MT2063_REG_CTRL_2C], 1);
+ }
+
+ return (status);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_SetReg
+**
+** Description: Sets an MT2063 register.
+**
+** Parameters: h - Tuner handle (returned by MT2063_Open)
+** reg - MT2063 register/subaddress location
+** val - MT2063 register/subaddress value
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_COMM_ERR - Serial bus communications error
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_ARG_RANGE - Argument out of range
+**
+** Dependencies: USERS MUST CALL MT2063_Open() FIRST!
+**
+** Use this function if you need to override a default
+** register value
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+UData_t MT2063_SetReg(Handle_t h, U8Data reg, U8Data val)
+{
+ UData_t status = MT2063_OK; /* Status to be returned */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ status |= MT2063_INV_HANDLE;
+
+ if (reg >= MT2063_REG_END_REGS)
+ status |= MT2063_ARG_RANGE;
+
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_WriteSub(pInfo->hUserData, pInfo->address, reg, &val,
+ 1);
+ if (MT2063_NO_ERROR(status))
+ pInfo->reg[reg] = val;
+ }
+
+ return (status);
+}
+
+static UData_t MT2063_Round_fLO(UData_t f_LO, UData_t f_LO_Step, UData_t f_ref)
+{
+ return f_ref * (f_LO / f_ref)
+ + f_LO_Step * (((f_LO % f_ref) + (f_LO_Step / 2)) / f_LO_Step);
+}
+
+/****************************************************************************
+**
+** Name: fLO_FractionalTerm
+**
+** Description: Calculates the portion contributed by FracN / denom.
+**
+** This function preserves maximum precision without
+** risk of overflow. It accurately calculates
+** f_ref * num / denom to within 1 HZ with fixed math.
+**
+** Parameters: num - Fractional portion of the multiplier
+** denom - denominator portion of the ratio
+** This routine successfully handles denom values
+** up to and including 2^18.
+** f_Ref - SRO frequency. This calculation handles
+** f_ref as two separate 14-bit fields.
+** Therefore, a maximum value of 2^28-1
+** may safely be used for f_ref. This is
+** the genesis of the magic number "14" and the
+** magic mask value of 0x03FFF.
+**
+** Returns: f_ref * num / denom
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+static UData_t MT2063_fLO_FractionalTerm(UData_t f_ref,
+ UData_t num, UData_t denom)
+{
+ UData_t t1 = (f_ref >> 14) * num;
+ UData_t term1 = t1 / denom;
+ UData_t loss = t1 % denom;
+ UData_t term2 =
+ (((f_ref & 0x00003FFF) * num + (loss << 14)) + (denom / 2)) / denom;
+ return ((term1 << 14) + term2);
+}
+
+/****************************************************************************
+**
+** Name: CalcLO1Mult
+**
+** Description: Calculates Integer divider value and the numerator
+** value for a FracN PLL.
+**
+** This function assumes that the f_LO and f_Ref are
+** evenly divisible by f_LO_Step.
+**
+** Parameters: Div - OUTPUT: Whole number portion of the multiplier
+** FracN - OUTPUT: Fractional portion of the multiplier
+** f_LO - desired LO frequency.
+** f_LO_Step - Minimum step size for the LO (in Hz).
+** f_Ref - SRO frequency.
+** f_Avoid - Range of PLL frequencies to avoid near
+** integer multiples of f_Ref (in Hz).
+**
+** Returns: Recalculated LO frequency.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+static UData_t MT2063_CalcLO1Mult(UData_t * Div,
+ UData_t * FracN,
+ UData_t f_LO,
+ UData_t f_LO_Step, UData_t f_Ref)
+{
+ /* Calculate the whole number portion of the divider */
+ *Div = f_LO / f_Ref;
+
+ /* Calculate the numerator value (round to nearest f_LO_Step) */
+ *FracN =
+ (64 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) +
+ (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);
+
+ return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm(f_Ref, *FracN, 64);
+}
+
+/****************************************************************************
+**
+** Name: CalcLO2Mult
+**
+** Description: Calculates Integer divider value and the numerator
+** value for a FracN PLL.
+**
+** This function assumes that the f_LO and f_Ref are
+** evenly divisible by f_LO_Step.
+**
+** Parameters: Div - OUTPUT: Whole number portion of the multiplier
+** FracN - OUTPUT: Fractional portion of the multiplier
+** f_LO - desired LO frequency.
+** f_LO_Step - Minimum step size for the LO (in Hz).
+** f_Ref - SRO frequency.
+** f_Avoid - Range of PLL frequencies to avoid near
+** integer multiples of f_Ref (in Hz).
+**
+** Returns: Recalculated LO frequency.
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+**
+****************************************************************************/
+static UData_t MT2063_CalcLO2Mult(UData_t * Div,
+ UData_t * FracN,
+ UData_t f_LO,
+ UData_t f_LO_Step, UData_t f_Ref)
+{
+ /* Calculate the whole number portion of the divider */
+ *Div = f_LO / f_Ref;
+
+ /* Calculate the numerator value (round to nearest f_LO_Step) */
+ *FracN =
+ (8191 * (((f_LO % f_Ref) + (f_LO_Step / 2)) / f_LO_Step) +
+ (f_Ref / f_LO_Step / 2)) / (f_Ref / f_LO_Step);
+
+ return (f_Ref * (*Div)) + MT2063_fLO_FractionalTerm(f_Ref, *FracN,
+ 8191);
+}
+
+/****************************************************************************
+**
+** Name: FindClearTuneFilter
+**
+** Description: Calculate the corrrect ClearTune filter to be used for
+** a given input frequency.
+**
+** Parameters: pInfo - ptr to tuner data structure
+** f_in - RF input center frequency (in Hz).
+**
+** Returns: ClearTune filter number (0-31)
+**
+** Dependencies: MUST CALL MT2064_Open BEFORE FindClearTuneFilter!
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 04-10-2008 PINZ Ver 1.14: Use software-controlled ClearTune
+** cross-over frequency values.
+**
+****************************************************************************/
+static UData_t FindClearTuneFilter(struct MT2063_Info_t *pInfo, UData_t f_in)
+{
+ UData_t RFBand;
+ UData_t idx; /* index loop */
+
+ /*
+ ** Find RF Band setting
+ */
+ RFBand = 31; /* def when f_in > all */
+ for (idx = 0; idx < 31; ++idx) {
+ if (pInfo->CTFiltMax[idx] >= f_in) {
+ RFBand = idx;
+ break;
+ }
+ }
+ return (RFBand);
+}
+
+/****************************************************************************
+**
+** Name: MT2063_Tune
+**
+** Description: Change the tuner's tuned frequency to RFin.
+**
+** Parameters: h - Open handle to the tuner (from MT2063_Open).
+** f_in - RF input center frequency (in Hz).
+**
+** Returns: status:
+** MT_OK - No errors
+** MT_INV_HANDLE - Invalid tuner handle
+** MT_UPC_UNLOCK - Upconverter PLL unlocked
+** MT_DNC_UNLOCK - Downconverter PLL unlocked
+** MT_COMM_ERR - Serial bus communications error
+** MT_SPUR_CNT_MASK - Count of avoided LO spurs
+** MT_SPUR_PRESENT - LO spur possible in output
+** MT_FIN_RANGE - Input freq out of range
+** MT_FOUT_RANGE - Output freq out of range
+** MT_UPC_RANGE - Upconverter freq out of range
+** MT_DNC_RANGE - Downconverter freq out of range
+**
+** Dependencies: MUST CALL MT2063_Open BEFORE MT2063_Tune!
+**
+** MT_ReadSub - Read data from the two-wire serial bus
+** MT_WriteSub - Write data to the two-wire serial bus
+** MT_Sleep - Delay execution for x milliseconds
+** MT2063_GetLocked - Checks to see if LO1 and LO2 are locked
+**
+** Revision History:
+**
+** SCR Date Author Description
+** -------------------------------------------------------------------------
+** 138 06-19-2007 DAD Ver 1.00: Initial, derived from mt2067_b.
+** 04-10-2008 PINZ Ver 1.05: Use software-controlled ClearTune
+** cross-over frequency values.
+** 175 I 16-06-2008 PINZ Ver 1.16: Add control to avoid US DECT freqs.
+** 175 I 06-19-2008 RSK Ver 1.17: Refactor DECT control to SpurAvoid.
+** 06-24-2008 PINZ Ver 1.18: Add Get/SetParam CTFILT_SW
+**
+****************************************************************************/
+UData_t MT2063_Tune(Handle_t h, UData_t f_in)
+{ /* RF input center frequency */
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+
+ UData_t status = MT2063_OK; /* status of operation */
+ UData_t LO1; /* 1st LO register value */
+ UData_t Num1; /* Numerator for LO1 reg. value */
+ UData_t f_IF1; /* 1st IF requested */
+ UData_t LO2; /* 2nd LO register value */
+ UData_t Num2; /* Numerator for LO2 reg. value */
+ UData_t ofLO1, ofLO2; /* last time's LO frequencies */
+ UData_t ofin, ofout; /* last time's I/O frequencies */
+ U8Data fiffc = 0x80; /* FIFF center freq from tuner */
+ UData_t fiffof; /* Offset from FIFF center freq */
+ const U8Data LO1LK = 0x80; /* Mask for LO1 Lock bit */
+ U8Data LO2LK = 0x08; /* Mask for LO2 Lock bit */
+ U8Data val;
+ UData_t RFBand;
+
+ /* Verify that the handle passed points to a valid tuner */
+ if (MT2063_IsValidHandle(pInfo) == 0)
+ return MT2063_INV_HANDLE;
+
+ /* Check the input and output frequency ranges */
+ if ((f_in < MT2063_MIN_FIN_FREQ) || (f_in > MT2063_MAX_FIN_FREQ))
+ status |= MT2063_FIN_RANGE;
+
+ if ((pInfo->AS_Data.f_out < MT2063_MIN_FOUT_FREQ)
+ || (pInfo->AS_Data.f_out > MT2063_MAX_FOUT_FREQ))
+ status |= MT2063_FOUT_RANGE;
+
+ /*
+ ** Save original LO1 and LO2 register values
+ */
+ ofLO1 = pInfo->AS_Data.f_LO1;
+ ofLO2 = pInfo->AS_Data.f_LO2;
+ ofin = pInfo->AS_Data.f_in;
+ ofout = pInfo->AS_Data.f_out;
+
+ /*
+ ** Find and set RF Band setting
+ */
+ if (pInfo->ctfilt_sw == 1) {
+ val = (pInfo->reg[MT2063_REG_CTUNE_CTRL] | 0x08);
+ if (pInfo->reg[MT2063_REG_CTUNE_CTRL] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_CTUNE_CTRL, val);
+ }
+ val = pInfo->reg[MT2063_REG_CTUNE_OV];
+ RFBand = FindClearTuneFilter(pInfo, f_in);
+ pInfo->reg[MT2063_REG_CTUNE_OV] =
+ (U8Data) ((pInfo->reg[MT2063_REG_CTUNE_OV] & ~0x1F)
+ | RFBand);
+ if (pInfo->reg[MT2063_REG_CTUNE_OV] != val) {
+ status |=
+ MT2063_SetReg(pInfo, MT2063_REG_CTUNE_OV, val);
+ }
+ }
+
+ /*
+ ** Read the FIFF Center Frequency from the tuner
+ */
+ if (MT2063_NO_ERROR(status)) {
+ status |=
+ MT2063_ReadSub(pInfo->hUserData, pInfo->address,
+ MT2063_REG_FIFFC,
+ &pInfo->reg[MT2063_REG_FIFFC], 1);
+ fiffc = pInfo->reg[MT2063_REG_FIFFC];
+ }
+ /*
+ ** Assign in the requested values
+ */
+ pInfo->AS_Data.f_in = f_in;
+ /* Request a 1st IF such that LO1 is on a step size */
+ pInfo->AS_Data.f_if1_Request =
+ MT2063_Round_fLO(pInfo->AS_Data.f_if1_Request + f_in,
+ pInfo->AS_Data.f_LO1_Step,
+ pInfo->AS_Data.f_ref) - f_in;
+
+ /*
+ ** Calculate frequency settings. f_IF1_FREQ + f_in is the
+ ** desired LO1 frequency
+ */
+ MT2063_ResetExclZones(&pInfo->AS_Data);
+
+ f_IF1 = MT2063_ChooseFirstIF(&pInfo->AS_Data);
+
+ pInfo->AS_Data.f_LO1 =
+ MT2063_Round_fLO(f_IF1 + f_in, pInfo->AS_Data.f_LO1_Step,
+ pInfo->AS_Data.f_ref);
+
+ pInfo->AS_Data.f_LO2 =
+ MT2063_Round_fLO(pInfo->AS_Data.f_LO1 - pInfo->AS_Data.f_out - f_in,
+ pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);
+
+ /*
+ ** Check for any LO spurs in the output bandwidth and adjust
+ ** the LO settings to avoid them if needed
+ */
+ status |= MT2063_AvoidSpurs(h, &pInfo->AS_Data);
+ /*
+ ** MT_AvoidSpurs spurs may have changed the LO1 & LO2 values.
+ ** Recalculate the LO frequencies and the values to be placed
+ ** in the tuning registers.
+ */
+ pInfo->AS_Data.f_LO1 =
+ MT2063_CalcLO1Mult(&LO1, &Num1, pInfo->AS_Data.f_LO1,
+ pInfo->AS_Data.f_LO1_Step, pInfo->AS_Data.f_ref);
+ pInfo->AS_Data.f_LO2 =
+ MT2063_Round_fLO(pInfo->AS_Data.f_LO1 - pInfo->AS_Data.f_out - f_in,
+ pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);
+ pInfo->AS_Data.f_LO2 =
+ MT2063_CalcLO2Mult(&LO2, &Num2, pInfo->AS_Data.f_LO2,
+ pInfo->AS_Data.f_LO2_Step, pInfo->AS_Data.f_ref);
+
+ /*
+ ** Check the upconverter and downconverter frequency ranges
+ */
+ if ((pInfo->AS_Data.f_LO1 < MT2063_MIN_UPC_FREQ)
+ || (pInfo->AS_Data.f_LO1 > MT2063_MAX_UPC_FREQ))
+ status |= MT2063_UPC_RANGE;
+ if ((pInfo->AS_Data.f_LO2 < MT2063_MIN_DNC_FREQ)
+ || (pInfo->AS_Data.f_LO2 > MT2063_MAX_DNC_FREQ))
+ status |= MT2063_DNC_RANGE;
+ /* LO2 Lock bit was in a different place for B0 version */
+ if (pInfo->tuner_id == MT2063_B0)
+ LO2LK = 0x40;
+
+ /*
+ ** If we have the same LO frequencies and we're already locked,
+ ** then skip re-programming the LO registers.
+ */
+ if ((ofLO1 != pInfo->AS_Data.f_LO1)
+ || (ofLO2 != pInfo->AS_Data.f_LO2)
+ || ((pInfo->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) !=
+ (LO1LK | LO2LK))) {
+ /*
+ ** Calculate the FIFFOF register value
+ **
+ ** IF1_Actual
+ ** FIFFOF = ------------ - 8 * FIFFC - 4992
+ ** f_ref/64
+ */
+ fiffof =
+ (pInfo->AS_Data.f_LO1 -
+ f_in) / (pInfo->AS_Data.f_ref / 64) - 8 * (UData_t) fiffc -
+ 4992;
+ if (fiffof > 0xFF)
+ fiffof = 0xFF;
+
+ /*
+ ** Place all of the calculated values into the local tuner
+ ** register fields.
+ */
+ if (MT2063_NO_ERROR(status)) {
+ pInfo->reg[MT2063_REG_LO1CQ_1] = (U8Data) (LO1 & 0xFF); /* DIV1q */
+ pInfo->reg[MT2063_REG_LO1CQ_2] = (U8Data) (Num1 & 0x3F); /* NUM1q */
+ pInfo->reg[MT2063_REG_LO2CQ_1] = (U8Data) (((LO2 & 0x7F) << 1) /* DIV2q */
+ |(Num2 >> 12)); /* NUM2q (hi) */
+ pInfo->reg[MT2063_REG_LO2CQ_2] = (U8Data) ((Num2 & 0x0FF0) >> 4); /* NUM2q (mid) */
+ pInfo->reg[MT2063_REG_LO2CQ_3] = (U8Data) (0xE0 | (Num2 & 0x000F)); /* NUM2q (lo) */
+
+ /*
+ ** Now write out the computed register values
+ ** IMPORTANT: There is a required order for writing
+ ** (0x05 must follow all the others).
+ */
+ status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO1CQ_1, &pInfo->reg[MT2063_REG_LO1CQ_1], 5); /* 0x01 - 0x05 */
+ if (pInfo->tuner_id == MT2063_B0) {
+ /* Re-write the one-shot bits to trigger the tune operation */
+ status |= MT2063_WriteSub(pInfo->hUserData, pInfo->address, MT2063_REG_LO2CQ_3, &pInfo->reg[MT2063_REG_LO2CQ_3], 1); /* 0x05 */
+ }
+ /* Write out the FIFF offset only if it's changing */
+ if (pInfo->reg[MT2063_REG_FIFF_OFFSET] !=
+ (U8Data) fiffof) {
+ pInfo->reg[MT2063_REG_FIFF_OFFSET] =
+ (U8Data) fiffof;
+ status |=
+ MT2063_WriteSub(pInfo->hUserData,
+ pInfo->address,
+ MT2063_REG_FIFF_OFFSET,
+ &pInfo->
+ reg[MT2063_REG_FIFF_OFFSET],
+ 1);
+ }
+ }
+
+ /*
+ ** Check for LO's locking
+ */
+
+ if (MT2063_NO_ERROR(status)) {
+ status |= MT2063_GetLocked(h);
+ }
+ /*
+ ** If we locked OK, assign calculated data to MT2063_Info_t structure
+ */
+ if (MT2063_NO_ERROR(status)) {
+ pInfo->f_IF1_actual = pInfo->AS_Data.f_LO1 - f_in;
+ }
+ }
+
+ return (status);
+}
+
+UData_t MT_Tune_atv(Handle_t h, UData_t f_in, UData_t bw_in,
+ enum MTTune_atv_standard tv_type)
+{
+
+ UData_t status = MT2063_OK;
+ struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+ struct dvb_frontend *fe = (struct dvb_frontend *)pInfo->hUserData;
+ struct mt2063_state *state = fe->tuner_priv;
+
+ SData_t pict_car = 0;
+ SData_t pict2chanb_vsb = 0;
+ SData_t pict2chanb_snd = 0;
+ SData_t pict2snd1 = 0;
+ SData_t pict2snd2 = 0;
+ SData_t ch_bw = 0;
+
+ SData_t if_mid = 0;
+ SData_t rcvr_mode = 0;
+ UData_t mode_get = 0;
+
+ switch (tv_type) {
+ case MTTUNEA_PAL_B:{
+ pict_car = 38900000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 5500000;
+ pict2snd2 = 5742000;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_PAL_G:{
+ pict_car = 38900000;
+ ch_bw = 7000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 5500000;
+ pict2snd2 = 0;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_PAL_I:{
+ pict_car = 38900000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 6000000;
+ pict2snd2 = 0;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_PAL_L:{
+ pict_car = 38900000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 6500000;
+ pict2snd2 = 0;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_PAL_MN:{
+ pict_car = 38900000;
+ ch_bw = 6000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 4500000;
+ pict2snd2 = 0;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_PAL_DK:{
+ pict_car = 38900000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -1250000;
+ pict2snd1 = 6500000;
+ pict2snd2 = 0;
+ rcvr_mode = 1;
+ break;
+ }
+ case MTTUNEA_DIGITAL:{
+ pict_car = 36125000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -(ch_bw / 2);
+ pict2snd1 = 0;
+ pict2snd2 = 0;
+ rcvr_mode = 2;
+ break;
+ }
+ case MTTUNEA_FMRADIO:{
+ pict_car = 38900000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -(ch_bw / 2);
+ pict2snd1 = 0;
+ pict2snd2 = 0;
+ rcvr_mode = 4;
+ //f_in -= 2900000;
+ break;
+ }
+ case MTTUNEA_DVBC:{
+ pict_car = 36125000;
+ ch_bw = 8000000;
+ pict2chanb_vsb = -(ch_bw / 2);
+ pict2snd1 = 0;
+ pict2snd2 = 0;
+ rcvr_mode = MT2063_CABLE_QAM;
+ break;
+ }
+ case MTTUNEA_DVBT:{
+ pict_car = 36125000;
+ ch_bw = bw_in; //8000000
+ pict2chanb_vsb = -(ch_bw / 2);
+ pict2snd1 = 0;
+ pict2snd2 = 0;
+ rcvr_mode = MT2063_OFFAIR_COFDM;
+ break;
+ }
+ case MTTUNEA_UNKNOWN:
+ break;
+ default:
+ break;
+ }
+
+ pict2chanb_snd = pict2chanb_vsb - ch_bw;
+ if_mid = pict_car - (pict2chanb_vsb + (ch_bw / 2));
+
+ status |= MT2063_SetParam(h, MT2063_STEPSIZE, 125000);
+ status |= MT2063_SetParam(h, MT2063_OUTPUT_FREQ, if_mid);
+ status |= MT2063_SetParam(h, MT2063_OUTPUT_BW, ch_bw);
+ status |= MT2063_GetParam(h, MT2063_RCVR_MODE, &mode_get);
+
+ status |= MT2063_SetParam(h, MT2063_RCVR_MODE, rcvr_mode);
+ status |= MT2063_Tune(h, (f_in + (pict2chanb_vsb + (ch_bw / 2))));
+ status |= MT2063_GetParam(h, MT2063_RCVR_MODE, &mode_get);
+
+ return (UData_t) status;
+}
+
+static int mt2063_init(struct dvb_frontend *fe)
+{
+ UData_t status = MT2063_ERROR;
+ struct mt2063_state *state = fe->tuner_priv;
+
+ status = MT2063_Open(0xC0, &(state->MT2063_ht), fe);
+ status |= MT2063_SoftwareShutdown(state->MT2063_ht, 1);
+ status |= MT2063_ClearPowerMaskBits(state->MT2063_ht, MT2063_ALL_SD);
+
+ if (MT2063_OK != status) {
+ printk("%s %d error status = 0x%x!!\n", __func__, __LINE__,
+ status);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int mt2063_sleep(struct dvb_frontend *fe)
{
- /* TODO: power down */
+ /* TODO: power down */
return 0;
}
-\r
-static int mt2063_get_status(struct dvb_frontend *fe, u32 *status)\r
+
+static int mt2063_get_status(struct dvb_frontend *fe, u32 * status)
{
- int rc = 0;\r
- \r
- //get tuner lock status\r
- \r
- return rc;\r
+ int rc = 0;
+
+ //get tuner lock status
+
+ return rc;
}
-\r
-\r
-static int mt2063_get_state(struct dvb_frontend *fe,\r
- enum tuner_param param,
- struct tuner_state *state)
-{\r
- struct mt2063_state *mt2063State = fe->tuner_priv;\r
- \r
+
+static int mt2063_get_state(struct dvb_frontend *fe,
+ enum tuner_param param, struct tuner_state *state)
+{
+ struct mt2063_state *mt2063State = fe->tuner_priv;
+
switch (param) {
case DVBFE_TUNER_FREQUENCY:
- //get frequency\r
+ //get frequency
break;
case DVBFE_TUNER_TUNERSTEP:
break;
case DVBFE_TUNER_IFFREQ:
break;
case DVBFE_TUNER_BANDWIDTH:
- //get bandwidth\r
+ //get bandwidth
break;
- case DVBFE_TUNER_REFCLOCK: \r
- state->refclock = (u32_t)MT2063_GetLocked((Handle_t)(mt2063State->MT2063_ht));\r
+ case DVBFE_TUNER_REFCLOCK:
+ state->refclock =
+ (u32_t)
+ MT2063_GetLocked((Handle_t) (mt2063State->MT2063_ht));
break;
default:
break;
}
- return (int)state->refclock;\r
-}\r
-\r
-static int mt2063_set_state(struct dvb_frontend *fe,\r
- enum tuner_param param,
- struct tuner_state *state)
+ return (int)state->refclock;
+}
+
+static int mt2063_set_state(struct dvb_frontend *fe,
+ enum tuner_param param, struct tuner_state *state)
{
- struct mt2063_state *mt2063State = fe->tuner_priv;\r
- UData_t status = MT2063_OK;\r
- \r
+ struct mt2063_state *mt2063State = fe->tuner_priv;
+ UData_t status = MT2063_OK;
+
switch (param) {
case DVBFE_TUNER_FREQUENCY:
- //set frequency\r
-\r
- status = MT_Tune_atv((Handle_t)(mt2063State->MT2063_ht), state->frequency, state->bandwidth, mt2063State->tv_type);\r
- \r
- mt2063State->frequency = state->frequency;\r
+ //set frequency
+
+ status =
+ MT_Tune_atv((Handle_t) (mt2063State->MT2063_ht),
+ state->frequency, state->bandwidth,
+ mt2063State->tv_type);
+
+ mt2063State->frequency = state->frequency;
break;
case DVBFE_TUNER_TUNERSTEP:
break;
case DVBFE_TUNER_IFFREQ:
break;
case DVBFE_TUNER_BANDWIDTH:
- //set bandwidth\r
- mt2063State->bandwidth = state->bandwidth;\r
+ //set bandwidth
+ mt2063State->bandwidth = state->bandwidth;
+ break;
+ case DVBFE_TUNER_REFCLOCK:
+
+ break;
+ case DVBFE_TUNER_OPEN:
+ status = MT2063_Open(MT2063_I2C, &(mt2063State->MT2063_ht), fe);
+ break;
+ case DVBFE_TUNER_SOFTWARE_SHUTDOWN:
+ status = MT2063_SoftwareShutdown(mt2063State->MT2063_ht, 1);
+ break;
+ case DVBFE_TUNER_CLEAR_POWER_MASKBITS:
+ status =
+ MT2063_ClearPowerMaskBits(mt2063State->MT2063_ht,
+ MT2063_ALL_SD);
break;
- case DVBFE_TUNER_REFCLOCK:\r
- \r
- break;\r
- case DVBFE_TUNER_OPEN:\r
- status = MT2063_Open(MT2063_I2C, &(mt2063State->MT2063_ht), fe);\r
- break;\r
- case DVBFE_TUNER_SOFTWARE_SHUTDOWN:\r
- status = MT2063_SoftwareShutdown(mt2063State->MT2063_ht, 1);\r
- break;\r
- case DVBFE_TUNER_CLEAR_POWER_MASKBITS:\r
- status = MT2063_ClearPowerMaskBits(mt2063State->MT2063_ht, MT2063_ALL_SD);\r
- break;\r
default:
break;
}
- return (int)status;\r
-}\r
-\r
-static int mt2063_release(struct dvb_frontend *fe)\r
+ return (int)status;
+}
+
+static int mt2063_release(struct dvb_frontend *fe)
{
- struct mt2063_state *state = fe->tuner_priv;\r
+ struct mt2063_state *state = fe->tuner_priv;
fe->tuner_priv = NULL;
kfree(state);
return 0;
-}\r
-\r
-static struct dvb_tuner_ops mt2063_ops = {\r
+}
+
+static struct dvb_tuner_ops mt2063_ops = {
.info = {
- .name = "MT2063 Silicon Tuner",\r
- .frequency_min = 45000000,\r
- .frequency_max = 850000000,\r
- .frequency_step = 0,
- },
-
- .init = mt2063_init,\r
- .sleep = mt2063_sleep,\r
- .get_status = mt2063_get_status,\r
- .get_state = mt2063_get_state,\r
- .set_state = mt2063_set_state,\r
- .release = mt2063_release\r
+ .name = "MT2063 Silicon Tuner",
+ .frequency_min = 45000000,
+ .frequency_max = 850000000,
+ .frequency_step = 0,
+ },
+
+ .init = mt2063_init,
+ .sleep = mt2063_sleep,
+ .get_status = mt2063_get_status,
+ .get_state = mt2063_get_state,
+ .set_state = mt2063_set_state,
+ .release = mt2063_release
};
-struct dvb_frontend *mt2063_attach(struct dvb_frontend *fe,\r
- struct mt2063_config *config,\r
- struct i2c_adapter *i2c)
+struct dvb_frontend *mt2063_attach(struct dvb_frontend *fe,
+ struct mt2063_config *config,
+ struct i2c_adapter *i2c)
{
- struct mt2063_state *state = NULL;\r
+ struct mt2063_state *state = NULL;
- state = kzalloc(sizeof (struct mt2063_state), GFP_KERNEL);\r
+ state = kzalloc(sizeof(struct mt2063_state), GFP_KERNEL);
if (state == NULL)
goto error;
- state->config = config;
- state->i2c = i2c;
- state->frontend = fe;
- state->reference = config->refclock / 1000; /* kHz */\r
- state->MT2063_init = FALSE;\r
- fe->tuner_priv = state;
- fe->ops.tuner_ops = mt2063_ops;\r
+ state->config = config;
+ state->i2c = i2c;
+ state->frontend = fe;
+ state->reference = config->refclock / 1000; /* kHz */
+ state->MT2063_init = FALSE;
+ fe->tuner_priv = state;
+ fe->ops.tuner_ops = mt2063_ops;
- printk("%s: Attaching MT2063 \n", __func__);\r
+ printk("%s: Attaching MT2063 \n", __func__);
return fe;
error:
return NULL;
}
-\r
-
-EXPORT_SYMBOL(mt2063_attach);\r
+EXPORT_SYMBOL(mt2063_attach);
MODULE_PARM_DESC(verbose, "Set Verbosity level");
-MODULE_AUTHOR("Henry");\r
-MODULE_DESCRIPTION("MT2063 Silicon tuner");\r
-MODULE_LICENSE("GPL");\r
-\r
-\r
-\r
+MODULE_AUTHOR("Henry");
+MODULE_DESCRIPTION("MT2063 Silicon tuner");
+MODULE_LICENSE("GPL");
projects / deliverable / linux.git / commitdiff
