[media] mt2063: Use Unix standard error handling

Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 1139 insertions, 1220 deletions

diff --git a/drivers/media/common/tuners/mt2063.c b/drivers/media/common/tuners/mt2063.c
index 98bc2e2ee41..a1acfcc26bd 100644
--- a/drivers/media/common/tuners/mt2063.c
+++ b/drivers/media/common/tuners/mt2063.c
@@ -16,64 +16,18 @@ module_param(verbose, int, 0644);
 #define DVBFE_TUNER_SOFTWARE_SHUTDOWN		100
 #define DVBFE_TUNER_CLEAR_POWER_MASKBITS	101
 
-#define MT2063_ERROR (1 << 31)
-#define MT2063_USER_ERROR (1 << 30)
-
-/*  Macro to be used to check for errors  */
-#define MT2063_IS_ERROR(s) (((s) >> 30) != 0)
-#define MT2063_NO_ERROR(s) (((s) >> 30) == 0)
-
-#define MT2063_OK                           (0x00000000)
-
-/*  Unknown error  */
-#define MT2063_UNKNOWN                      (0x80000001)
-
+/* FIXME: Those error codes need conversion*/
 /*  Error:  Upconverter PLL is not locked  */
 #define MT2063_UPC_UNLOCK                   (0x80000002)
-
 /*  Error:  Downconverter PLL is not locked  */
 #define MT2063_DNC_UNLOCK                   (0x80000004)
-
-/*  Error:  Two-wire serial bus communications error  */
-#define MT2063_COMM_ERR                     (0x80000008)
-
-/*  Error:  Tuner handle passed to function was invalid  */
-#define MT2063_INV_HANDLE                   (0x80000010)
-
-/*  Error:  Function argument is invalid (out of range)  */
-#define MT2063_ARG_RANGE                    (0x80000020)
-
-/*  Error:  Function argument (ptr to return value) was NULL  */
-#define MT2063_ARG_NULL                     (0x80000040)
-
-/*  Error: Attempt to open more than MT_TUNER_CNT tuners  */
-#define MT2063_TUNER_CNT_ERR                (0x80000080)
-
-/*  Error: Tuner Part Code / Rev Code mismatches expected value  */
-#define MT2063_TUNER_ID_ERR                 (0x80000100)
-
-/*  Error: Tuner Initialization failure  */
-#define MT2063_TUNER_INIT_ERR               (0x80000200)
-
-#define MT2063_TUNER_OPEN_ERR               (0x80000400)
-
-/*  User-definable fields (see mt_userdef.h)  */
-#define MT2063_USER_DEFINED1                (0x00001000)
-#define MT2063_USER_DEFINED2                (0x00002000)
-#define MT2063_USER_DEFINED3                (0x00004000)
-#define MT2063_USER_DEFINED4                (0x00008000)
-#define MT2063_USER_MASK                    (0x4000f000)
-#define MT2063_USER_SHIFT                   (12)
+/*  Info: Unavoidable LO-related spur may be present in the output  */
+#define MT2063_SPUR_PRESENT_ERR                 (0x00800000)
 
 /*  Info: Mask of bits used for # of LO-related spurs that were avoided during tuning  */
 #define MT2063_SPUR_CNT_MASK                (0x001f0000)
 #define MT2063_SPUR_SHIFT                   (16)
 
-/*  Info: Tuner timeout waiting for condition  */
-#define MT2063_TUNER_TIMEOUT                (0x00400000)
-
-/*  Info: Unavoidable LO-related spur may be present in the output  */
-#define MT2063_SPUR_PRESENT_ERR                 (0x00800000)
 
 /*  Info: Tuner input frequency is out of range */
 #define MT2063_FIN_RANGE                    (0x01000000)
@@ -539,12 +493,12 @@ struct mt2063_state {
 /* Prototypes */
 static void MT2063_AddExclZone(struct MT2063_AvoidSpursData_t *pAS_Info,
                         u32 f_min, u32 f_max);
-static u32 MT2063_ReInit(void *h);
-static u32 MT2063_Close(void *hMT2063);
-static u32 MT2063_GetReg(void *h, u8 reg, u8 * val);
-static u32 MT2063_GetParam(void *h, enum MT2063_Param param, u32 * pValue);
-static u32 MT2063_SetReg(void *h, u8 reg, u8 val);
-static u32 MT2063_SetParam(void *h, enum MT2063_Param param, u32 nValue);
+static u32 MT2063_ReInit(struct MT2063_Info_t *pInfo);
+static u32 MT2063_Close(struct MT2063_Info_t *pInfo);
+static u32 MT2063_GetReg(struct MT2063_Info_t *pInfo, u8 reg, u8 * val);
+static u32 MT2063_GetParam(struct MT2063_Info_t *pInfo, enum MT2063_Param param, u32 * pValue);
+static u32 MT2063_SetReg(struct MT2063_Info_t *pInfo, u8 reg, u8 val);
+static u32 MT2063_SetParam(struct MT2063_Info_t *pInfo, enum MT2063_Param param, u32 nValue);
 
 /*****************/
 /* From drivers/media/common/tuners/mt2063_cfg.h */
@@ -769,7 +723,7 @@ static u32 MT2063_WriteSub(void *hUserData,
 			u32 addr,
 			u8 subAddress, u8 * pData, u32 cnt)
 {
-	u32 status = MT2063_OK;	/* Status to be returned        */
+	u32 status = 0;	/* Status to be returned        */
 	struct dvb_frontend *fe = hUserData;
 	struct mt2063_state *state = fe->tuner_priv;
 	/*
@@ -782,7 +736,7 @@ static u32 MT2063_WriteSub(void *hUserData,
 	fe->ops.i2c_gate_ctrl(fe, 1);	//I2C bypass drxk3926 close i2c bridge
 
 	if (mt2063_writeregs(state, subAddress, pData, cnt) < 0) {
-		status = MT2063_ERROR;
+		status = -EINVAL;
 	}
 	fe->ops.i2c_gate_ctrl(fe, 0);	//I2C bypass drxk3926 close i2c bridge
 
@@ -838,7 +792,7 @@ static u32 MT2063_ReadSub(void *hUserData,
 	 **         return MT_OK.
 	 */
 /*  return status;  */
-	u32 status = MT2063_OK;	/* Status to be returned        */
+	u32 status = 0;	/* Status to be returned        */
 	struct dvb_frontend *fe = hUserData;
 	struct mt2063_state *state = fe->tuner_priv;
 	u32 i = 0;
@@ -846,7 +800,7 @@ static u32 MT2063_ReadSub(void *hUserData,
 
 	for (i = 0; i < cnt; i++) {
 		if (mt2063_read_regs(state, subAddress + i, pData + i, 1) < 0) {
-			status = MT2063_ERROR;
+			status = -EINVAL;
 			break;
 		}
 	}
@@ -962,7 +916,7 @@ static u32 MT2063_RegisterTuner(struct MT2063_AvoidSpursData_t *pAS_Info)
 {
 #if MT2063_TUNER_CNT == 1
 	pAS_Info->nAS_Algorithm = 1;
-	return MT2063_OK;
+	return 0;
 #else
 	u32 index;
 
@@ -973,7 +927,7 @@ static u32 MT2063_RegisterTuner(struct MT2063_AvoidSpursData_t *pAS_Info)
 	 */
 	for (index = 0; index < TunerCount; index++) {
 		if (TunerList[index] == pAS_Info) {
-			return MT2063_OK;	/* Already here - no problem  */
+			return 0;	/* Already here - no problem  */
 		}
 	}
 
@@ -983,9 +937,9 @@ static u32 MT2063_RegisterTuner(struct MT2063_AvoidSpursData_t *pAS_Info)
 	if (TunerCount < MT2063_TUNER_CNT) {
 		TunerList[TunerCount] = pAS_Info;
 		TunerCount++;
-		return MT2063_OK;
+		return 0;
 	} else
-		return MT2063_TUNER_CNT_ERR;
+		return -ENODEV;
 #endif
 }
 
@@ -1810,13 +1764,13 @@ static u32 IsSpurInBand(struct MT2063_AvoidSpursData_t *pAS_Info,
 *****************************************************************************/
 static u32 MT2063_AvoidSpurs(void *h, struct MT2063_AvoidSpursData_t * pAS_Info)
 {
-	u32 status = MT2063_OK;
+	u32 status = 0;
 	u32 fm, fp;		/*  restricted range on LO's        */
 	pAS_Info->bSpurAvoided = 0;
 	pAS_Info->nSpursFound = 0;
 
 	if (pAS_Info->maxH1 == 0)
-		return MT2063_OK;
+		return 0;
 
 	/*
 	 **  Avoid LO Generated Spurs
@@ -2030,14 +1984,14 @@ static u32 MT2063_fLO_FractionalTerm(u32 f_ref, u32 num,
 ******************************************************************************/
 static u32 MT2063_Open(u32 MT2063_Addr, struct MT2063_Info_t **hMT2063, void *hUserData)
 {
-	u32 status = MT2063_OK;	/*  Status to be returned.  */
+	u32 status = 0;	/*  Status to be returned.  */
 	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;
+		return -ENODEV;
 	}
 
 	/*  Default tuner handle to NULL.  If successful, it will be reassigned  */
@@ -2045,7 +1999,7 @@ static u32 MT2063_Open(u32 MT2063_Addr, struct MT2063_Info_t **hMT2063, void *hU
 	if (state->MT2063_init == false) {
 		pInfo = kzalloc(sizeof(struct MT2063_Info_t), GFP_KERNEL);
 		if (pInfo == NULL) {
-			return MT2063_TUNER_OPEN_ERR;
+			return -ENOMEM;
 		}
 		pInfo->handle = NULL;
 		pInfo->address = MAX_UDATA;
@@ -2055,11 +2009,11 @@ static u32 MT2063_Open(u32 MT2063_Addr, struct MT2063_Info_t **hMT2063, void *hU
 		pInfo = *hMT2063;
 	}
 
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |= MT2063_RegisterTuner(&pInfo->AS_Data);
 	}
 
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		pInfo->handle = (void *) pInfo;
 
 		pInfo->hUserData = hUserData;
@@ -2068,7 +2022,7 @@ static u32 MT2063_Open(u32 MT2063_Addr, struct MT2063_Info_t **hMT2063, void *hU
 		status |= MT2063_ReInit((void *) pInfo);
 	}
 
-	if (MT2063_IS_ERROR(status))
+	if (status < 0)
 		/*  MT2063_Close handles the un-registration of the tuner  */
 		MT2063_Close((void *) pInfo);
 	else {
@@ -2106,12 +2060,10 @@ static u32 MT2063_IsValidHandle(struct MT2063_Info_t *handle)
 **   138   06-19-2007    DAD    Ver 1.00: Initial, derived from mt2067_b.
 **
 ******************************************************************************/
-static u32 MT2063_Close(void *hMT2063)
+static u32 MT2063_Close(struct MT2063_Info_t *pInfo)
 {
-	struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)hMT2063;
-
 	if (!MT2063_IsValidHandle(pInfo))
-		return MT2063_INV_HANDLE;
+		return -ENODEV;
 
 	/* Unregister tuner with SpurAvoidance routines (if needed) */
 	MT2063_UnRegisterTuner(&pInfo->AS_Data);
@@ -2122,7 +2074,7 @@ static u32 MT2063_Close(void *hMT2063)
 	//kfree(pInfo);
 	//pInfo = NULL;
 
-	return MT2063_OK;
+	return 0;
 }
 
 /****************************************************************************
@@ -2150,19 +2102,18 @@ static u32 MT2063_Close(void *hMT2063)
 **   138   06-19-2007    DAD    Ver 1.00: Initial, derived from mt2067_b.
 **
 ****************************************************************************/
-static u32 MT2063_GetLocked(void *h)
+static u32 MT2063_GetLocked(struct MT2063_Info_t *pInfo)
 {
 	const u32 nMaxWait = 100;	/*  wait a maximum of 100 msec   */
 	const u32 nPollRate = 2;	/*  poll status bits every 2 ms */
 	const u32 nMaxLoops = nMaxWait / nPollRate;
 	const u8 LO1LK = 0x80;
 	u8 LO2LK = 0x08;
-	u32 status = MT2063_OK;	/* Status to be returned        */
+	u32 status = 0;	/* Status to be returned        */
 	u32 nDelays = 0;
-	struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
 
 	if (MT2063_IsValidHandle(pInfo) == 0)
-		return MT2063_INV_HANDLE;
+		return -ENODEV;
 
 	/*  LO2 Lock bit was in a different place for B0 version  */
 	if (pInfo->tuner_id == MT2063_B0)
@@ -2174,7 +2125,7 @@ static u32 MT2063_GetLocked(void *h)
 				   MT2063_REG_LO_STATUS,
 				   &pInfo->reg[MT2063_REG_LO_STATUS], 1);
 
-		if (MT2063_IS_ERROR(status))
+		if (status < 0)
 			return (status);
 
 		if ((pInfo->reg[MT2063_REG_LO_STATUS] & (LO1LK | LO2LK)) ==
@@ -2285,378 +2236,375 @@ static u32 MT2063_GetLocked(void *h)
 **         06-24-2008    PINZ   Ver 1.18: Add Get/SetParam CTFILT_SW
 **
 ****************************************************************************/
-static u32 MT2063_GetParam(void *h, enum MT2063_Param param, u32 * pValue)
+static u32 MT2063_GetParam(struct MT2063_Info_t *pInfo, enum MT2063_Param param, u32 * pValue)
 {
-	u32 status = MT2063_OK;	/* Status to be returned        */
-	struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+	u32 status = 0;	/* Status to be returned        */
 	u32 Div;
 	u32 Num;
 
 	if (pValue == NULL)
-		status |= MT2063_ARG_NULL;
+		return -EINVAL;
 
 	/*  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:
-			{
-				u8 mask = (param == MT2063_PD1 ? 0x01 : 0x03);	/* PD1 vs PD2 */
-				u8 orig = (pInfo->reg[MT2063_REG_BYP_CTRL]);
-				u8 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,
-							    &reg, 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:
-			{
-				u8 val;
-				status |=
-				    MT2063_GetReg(pInfo, MT2063_REG_XO_STATUS,
-						  &val);
-				*pValue = val & 0x1f;
-			}
-			break;
-
-			/*  Get RF attenuator code                */
-		case MT2063_ACRF:
-			{
-				u8 val;
-				status |=
-				    MT2063_GetReg(pInfo, MT2063_REG_RF_STATUS,
-						  &val);
-				*pValue = val & 0x1f;
-			}
-			break;
-
-			/*  Get FIF attenuator code               */
-		case MT2063_ACFIF:
-			{
-				u8 val;
-				status |=
-				    MT2063_GetReg(pInfo, MT2063_REG_FIF_STATUS,
-						  &val);
-				*pValue = val & 0x1f;
-			}
-			break;
-
-			/*  Get LNA attenuator limit              */
-		case MT2063_ACLNA_MAX:
-			{
-				u8 val;
-				status |=
-				    MT2063_GetReg(pInfo, MT2063_REG_LNA_OV,
-						  &val);
-				*pValue = val & 0x1f;
-			}
-			break;
-
-			/*  Get RF attenuator limit               */
-		case MT2063_ACRF_MAX:
-			{
-				u8 val;
-				status |=
-				    MT2063_GetReg(pInfo, MT2063_REG_RF_OV,
-						  &val);
-				*pValue = val & 0x1f;
-			}
-			break;
-
-			/*  Get FIF attenuator limit               */
-		case MT2063_ACFIF_MAX:
-			{
-				u8 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 =
-						    (u32) MT2063_DNC_NONE;
-					else
-						*pValue =
-						    (u32) MT2063_DNC_2;
-				} else {	/* DNC1 is on */
-
-					if ((pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03)	/* if DNC2 is off */
-						*pValue =
-						    (u32) MT2063_DNC_1;
-					else
-						*pValue =
-						    (u32) 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 -ENODEV;
+
+	    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:
+		    {
+			    u8 mask = (param == MT2063_PD1 ? 0x01 : 0x03);	/* PD1 vs PD2 */
+			    u8 orig = (pInfo->reg[MT2063_REG_BYP_CTRL]);
+			    u8 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,
+							&reg, 1);
+
+			    if (status < 0)
+				    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 (status >= 0)
+					    *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:
+		    {
+			    u8 val;
+			    status |=
+				MT2063_GetReg(pInfo, MT2063_REG_XO_STATUS,
+					      &val);
+			    *pValue = val & 0x1f;
+		    }
+		    break;
+
+		    /*  Get RF attenuator code                */
+	    case MT2063_ACRF:
+		    {
+			    u8 val;
+			    status |=
+				MT2063_GetReg(pInfo, MT2063_REG_RF_STATUS,
+					      &val);
+			    *pValue = val & 0x1f;
+		    }
+		    break;
+
+		    /*  Get FIF attenuator code               */
+	    case MT2063_ACFIF:
+		    {
+			    u8 val;
+			    status |=
+				MT2063_GetReg(pInfo, MT2063_REG_FIF_STATUS,
+					      &val);
+			    *pValue = val & 0x1f;
+		    }
+		    break;
+
+		    /*  Get LNA attenuator limit              */
+	    case MT2063_ACLNA_MAX:
+		    {
+			    u8 val;
+			    status |=
+				MT2063_GetReg(pInfo, MT2063_REG_LNA_OV,
+					      &val);
+			    *pValue = val & 0x1f;
+		    }
+		    break;
+
+		    /*  Get RF attenuator limit               */
+	    case MT2063_ACRF_MAX:
+		    {
+			    u8 val;
+			    status |=
+				MT2063_GetReg(pInfo, MT2063_REG_RF_OV,
+					      &val);
+			    *pValue = val & 0x1f;
+		    }
+		    break;
+
+		    /*  Get FIF attenuator limit               */
+	    case MT2063_ACFIF_MAX:
+		    {
+			    u8 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 =
+						(u32) MT2063_DNC_NONE;
+				    else
+					    *pValue =
+						(u32) MT2063_DNC_2;
+			    } else {	/* DNC1 is on */
+
+				    if ((pInfo->reg[MT2063_REG_VGA_GAIN] & 0x03) == 0x03)	/* if DNC2 is off */
+					    *pValue =
+						(u32) MT2063_DNC_1;
+				    else
+					    *pValue =
+						(u32) 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 |= -ERANGE;
+	    }
 	return (status);
 }
 
@@ -2689,28 +2637,22 @@ static u32 MT2063_GetParam(void *h, enum MT2063_Param param, u32 * pValue)
 **   138   06-19-2007    DAD    Ver 1.00: Initial, derived from mt2067_b.
 **
 ****************************************************************************/
-static u32 MT2063_GetReg(void *h, u8 reg, u8 * val)
+static u32 MT2063_GetReg(struct MT2063_Info_t *pInfo, u8 reg, u8 * val)
 {
-	u32 status = MT2063_OK;	/* Status to be returned        */
-	struct MT2063_Info_t *pInfo = (struct MT2063_Info_t *)h;
+	u32 status = 0;	/* Status to be returned        */
 
 	/*  Verify that the handle passed points to a valid tuner         */
 	if (MT2063_IsValidHandle(pInfo) == 0)
-		status |= MT2063_INV_HANDLE;
+		return -ENODEV;
 
 	if (val == NULL)
-		status |= MT2063_ARG_NULL;
+		return -EINVAL;
 
 	if (reg >= MT2063_REG_END_REGS)
-		status |= MT2063_ARG_RANGE;
+		return -ERANGE;
 
-	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];
-	}
+	status = MT2063_ReadSub(pInfo->hUserData, pInfo->address, reg,
+			   &pInfo->reg[reg], 1);
 
 	return (status);
 }
@@ -2801,15 +2743,15 @@ static u32 MT2063_GetReg(void *h, u8 reg, u8 * val)
 static u32 MT2063_SetReceiverMode(struct MT2063_Info_t *pInfo,
 				      enum MT2063_RCVR_MODES Mode)
 {
-	u32 status = MT2063_OK;	/* Status to be returned        */
+	u32 status = 0;	/* Status to be returned        */
 	u8 val;
 	u32 longval;
 
 	if (Mode >= MT2063_NUM_RCVR_MODES)
-		status = MT2063_ARG_RANGE;
+		status = -ERANGE;
 
 	/* RFAGCen */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		val =
 		    (pInfo->
 		     reg[MT2063_REG_PD1_TGT] & (u8) ~ 0x40) | (RFAGCEN[Mode]
@@ -2821,12 +2763,12 @@ static u32 MT2063_SetReceiverMode(struct MT2063_Info_t *pInfo,
 	}
 
 	/* LNARin */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |= MT2063_SetParam(pInfo, MT2063_LNA_RIN, LNARIN[Mode]);
 	}
 
 	/* FIFFQEN and FIFFQ */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		val =
 		    (pInfo->
 		     reg[MT2063_REG_FIFF_CTRL2] & (u8) ~ 0xF0) |
@@ -2852,40 +2794,40 @@ static u32 MT2063_SetReceiverMode(struct MT2063_Info_t *pInfo,
 	status |= MT2063_SetParam(pInfo, MT2063_DNC_OUTPUT_ENABLE, longval);
 
 	/* acLNAmax */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |=
 		    MT2063_SetParam(pInfo, MT2063_ACLNA_MAX, ACLNAMAX[Mode]);
 	}
 
 	/* LNATGT */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |= MT2063_SetParam(pInfo, MT2063_LNA_TGT, LNATGT[Mode]);
 	}
 
 	/* ACRF */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |=
 		    MT2063_SetParam(pInfo, MT2063_ACRF_MAX, ACRFMAX[Mode]);
 	}
 
 	/* PD1TGT */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |= MT2063_SetParam(pInfo, MT2063_PD1_TGT, PD1TGT[Mode]);
 	}
 
 	/* FIFATN */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |=
 		    MT2063_SetParam(pInfo, MT2063_ACFIF_MAX, ACFIFMAX[Mode]);
 	}
 
 	/* PD2TGT */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		status |= MT2063_SetParam(pInfo, MT2063_PD2_TGT, PD2TGT[Mode]);
 	}
 
 	/* Ignore ATN Overload */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {
 		val =
 		    (pInfo->
 		     reg[MT2063_REG_LNA_TGT] & (u8) ~ 0x80) | (RFOVDIS[Mode]
@@ -2897,7 +2839,7 @@ static u32 MT2063_SetReceiverMode(struct MT2063_Info_t *pInfo,
 	}
 
 	/* Ignore FIF Overload */
-	if (MT2063_NO_ERROR(status)) {
+	if (status >= 0) {