#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <malloc.h>
#include <time.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>

#define PWIDTH 90

#ifndef I2C_M_NOREPSTART
#define I2C_M_NOREPSTART 0
#endif

typedef unsigned char u8;

static unsigned long
getTick ()
{
	static unsigned long init = 0;
	unsigned long t;
	struct timespec ts;

	clock_gettime(CLOCK_REALTIME, &ts);
	t = ts.tv_nsec / 1000000;
	t += ts.tv_sec * 1000;
	if (init == 0)
		init = t;
	return t - init;
}

struct regdmp {
	unsigned flags;
	unsigned shift;
	unsigned mask;
	const char *name;
};

struct reg {
	unsigned reg;
	unsigned flags;
	struct regdmp *dmp;
	const char *name;
};

static struct regdmp byte[] = {
	{ 0, 0,255, "VAL" },
	{ 0, 0, 0, NULL }
};

static struct regdmp conf[] = {
	{ 0, 7, 1, "OPD" },
	{ 0, 1,63, "CONFIG" },
	{ 0, 0, 1, "XOR" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f100[] = {
	{ 0, 4,15,"IDENT" },
	{ 0, 0,15,"RELEASE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f129[] = {
	{ 0, 3, 1, "I2C_FASTMODE" },
	{ 0, 0, 3, "I2CADDR_INC" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f12a[] = {
	{ 0, 7, 1, "I2CT_ON" },
	{ 0, 4, 7, "ENARPT_LEVEL" },
	{ 0, 3, 1, "SCLT_DELAY" },
	{ 0, 2, 1, "STOP_ENABLE" },
	{ 0, 1, 1, "STOP_SDAT2SDA" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f16a[] = {
	{ 0, 4,15, "SEL2" },
	{ 0, 0,15, "SEL1" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f16b[] = {
	{ 0, 4,15, "SEL4" },
	{ 0, 0,15, "SEL3" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f16c[] = {
	{ 0, 4,15, "SEL6" },
	{ 0, 0,15, "SEL5" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f190[] = {
	{ 0, 7, 1, "TIM_OFF" },
	{ 0, 6, 1, "DISEQC_RESET" },
	{ 0, 4, 3, "TIM_CMD" },
	{ 0, 3, 1, "DIS_PRECHARGE" },
	{ 0, 0, 7, "DISTX_MODE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f198[] = {
	{ 0, 7, 1, "TX_FAIL" },
	{ 0, 6, 1, "FIFO_FULL" },
	{ 0, 5, 1, "TX_IDLE" },
	{ 0, 4, 1, "GAP_BURST" },
	{ 0, 0,15, "TXFIFO_BYTES" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f1b6[] = {
	{ 0, 7, 1, "STANDBY" },
	{ 0, 6, 1, "BYPASSPLLCORE" },
	{ 0, 5, 1, "SELX1RATIO" },
	{ 0, 3, 1, "STOP_PLL" },
	{ 0, 2, 1, "BYPASSPLLFSK" },
	{ 0, 1, 1, "SELOSCI" },
	{ 0, 0, 1, "BYPASSPLLADC" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f1c2[] = {
	{ 0, 7, 1, "STOP_CLKPKDT2" },
	{ 0, 6, 1, "STOP_CLKPKDT1" },
	{ 0, 5, 1, "STOP_CLKFEC" },
	{ 0, 3, 1, "STOP_CLKADCI2" },
	{ 0, 2, 1, "INV_CLKADCI2" },
	{ 0, 1, 1, "STOP_CLKADCI1" },
	{ 0, 0, 1, "INV_CLKADCI1" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f1c3[] = {
	{ 0, 4, 1, "STOP_CLKSAMP2" },
	{ 0, 3, 1, "STOP_CLKSAMP1" },
	{ 0, 2, 1, "STOP_CLKVIT2" },
	{ 0, 1, 1, "STOP_CLKVIT1" },
	{ 0, 0, 1, "STOP_CLKTS" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f1e1[] = {
	{ 0, 5, 1, "DISEQC1_PON" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f201[] = {
	{ 0, 5, 1, "DUMMYPL_NOSDATA" },
	{ 0, 3, 3, "NOSPLH_BETA" },
	{ 0, 0, 7, "NOSDATA_BETA" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f206[] = {
	{ 0, 7, 1, "AGC1_LOCKED" },
	{ 0, 4, 1, "AGC1_MINPOWER" },
	{ 0, 3, 1, "AGCOUT_FAST" },
	{ 0, 0, 7, "AGCIQ_BETA" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f211[] = {
	{ 0, 7, 1, "MANUAL_MODCOD" },
	{ 0, 2,31, "DEMOD_MODCOD" },
	{ 0, 0, 3, "DEMOD_TYPE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f212[] = {
	{ 0, 7, 1, "CAR_LOCK" },
	{ 0, 5, 3, "TMGLOCK_QUALITY" },
	{ 0, 3, 1, "LOCK_DEFINITE" },
	{ 0, 0, 1, "OVADC_DETECT" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f213[] = {
	{ 0, 7, 1, "DEMOD_DELOCK" },
	{ 0, 3, 3, "AGC1_NOSIGNALACK" },
	{ 0, 2, 1, "AGC2_OVERFLOW" },
	{ 0, 1, 1, "CFR_OVERFLOW" },
	{ 0, 0, 1, "GAMMA_OVERUNDER" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f214[] = {
	{ 0, 7, 1, "DVBS2_ENABLE" },
	{ 0, 6, 1, "DVBS1_ENABLE" },
	{ 0, 4, 1, "SCAN_ENABLE" },
	{ 0, 3, 1, "CFR_AUTOSCAN" },
	{ 0, 0, 3, "TUN_RNG" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f215[] = {
	{ 0, 6, 1, "S1S2_SEQUENTIAL" },
	{ 0, 4, 1, "INFINITE_RELOCK" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f216[] = {
	{ 0, 0,31, "DEMOD_MODE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f21e[] = {
	{ 0, 3, 1, "NOSTOP_FIFOFULL" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f21f[] = {
	{ 0, 3, 1, "TUNER_NRELAUNCH" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f224[] = {
        { 0, 7, 1, "SPECINV_DEMOD" },
	{ 0, 2,31, "PLH_MODCOD" },
	{ 0, 0, 3, "PLH_TYPE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f238[] = {
        { 0, 7, 1, "CFRUPLOW_AUTO" },
	{ 0, 6, 1, "CFRUPLOW_TEST" },
	{ 0, 2, 1, "ROTAON" },
	{ 0, 0, 3, "PH_DET_ALGO" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f239[] = {
        { 0, 4, 3, "CAR_ALPHA_MANT" },
	{ 0, 0,15, "CAR_ALPHA_EXP" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f23a[] = {
        { 0, 4, 3, "CAR_BETA_MANT" },
	{ 0, 0,15, "CAR_BETA_EXP" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f23d[] = {
	{ 0, 4,15, "KC_COARSE_EXP" },
	{ 0, 0,15, "BETA_FREQ" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f250[] = {
	{ 0, 6, 3, "TMGLOCK_BETA" },
	{ 0, 4, 1, "DO_TIMING_CORR" },
	{ 0, 0, 3, "TMG_MINFREQ" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f251[] = {
	{ 0, 4,15, "TMGALPHAS_EXP" },
	{ 0, 0,15, "TMGBETAS_EXP" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f252[] = {
	{ 0, 4,15, "TMGALPHAS2_EXP" },
	{ 0, 0,15, "TMGBETAS2_EXP" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f259[] = {
	{ 0, 4,15, "SFR_SCANSTEP" },
	{ 0, 0,15, "SFR_CENTERSTEP" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f260[] = {
	{ 0, 7, 1, "AUTO_GUP" },
	{ 0, 0,127,"SYMB_FREQ_UP1" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f262[] = {
	{ 0, 7, 1, "AUTO_GLOW" },
	{ 0, 0,127,"SYMB_FREQ_LOW1" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f26d[] = {
	{ 0, 6, 3, "ROLLOFF_STATUS" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f290[] = {
	{ 0, 6, 1, "CARRIER3_DISABLE" },
	{ 0, 2, 1, "ROTA2ON" },
	{ 0, 0, 3, "PH_DET_ALGO2" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f291[] = {
	{ 0, 6, 3, "CFR2TOCFR1_DVBS1" },
	{ 0, 5, 1, "EN_S2CAR2CENTER" },
	{ 0, 4, 1, "DIS_BCHERRCFR2" },
	{ 0, 0, 7, "CFR2TOCFR1_BETA" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f297[] = {
	{ 0, 7, 1, "ENAB_SPSKSYMB" },
	{ 0, 4, 3, "CAR2S2_Q_ALPH_M" },
	{ 0, 0,15, "CAR2S2_Q_ALPH_E" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f298[] = {
	{ 0, 7, 1, "OLDI3Q_MODE" },
	{ 0, 4, 3, "CAR2S2_8_ALPH_M" },
	{ 0, 0,15, "CAR2S2_8_ALPH_M" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f29c[] = {
	{ 0, 4, 3, "CAR2S2_Q_BETA_M" },
	{ 0, 0,15, "CAR2S2_Q_BETA_M" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f29d[] = {
	{ 0, 4, 3, "CAR2S2_8_BETA_M" },
	{ 0, 0,15, "CAR2S2_8_BETA_M" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2b7[] = {
	{ 0, 4,15, "DIS_8P_9_10" },
	{ 0, 0,15, "DIS_8P_8_9" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2b8[] = {
	{ 0, 4,15, "DIS_8P_5_6" },
	{ 0, 0,15, "DIS_8P_3_4" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2b9[] = {
	{ 0, 4,15, "DIS_8P_2_3" },
	{ 0, 0,15, "DIS_8P_3_5" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2ba[] = {
	{ 0, 4,15, "DIS_QP_9_10" },
	{ 0, 0,15, "DIS_QP_8_9" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2bb[] = {
	{ 0, 4,15, "DIS_QP_5_6" },
	{ 0, 0,15, "DIS_QP_4_5" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2bc[] = {
	{ 0, 4,15, "DIS_QP_3_4" },
	{ 0, 0,15, "DIS_QP_2_3" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2bd[] = {
	{ 0, 4,15, "DIS_QP_3_5" },
	{ 0, 0,15, "DIS_QP_1_2" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2be[] = {
	{ 0, 4,15, "DIS_QP_2_5" },
	{ 0, 0,15, "DIS_QP_1_3" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2bf[] = {
	{ 0, 4,15, "DIS_QP_1_4" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2c0[] = {
	{ 0, 7, 1, "EN_CCIMODE" },
	{ 0, 0,127,"R0_GAUSSIEN" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2c1[] = {
	{ 0, 7, 1, "CCIDETECT_PLHONLY" },
	{ 0, 0,127,"R0_CCI" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2d8[] = {
	{ 0, 6, 1, "EQUALFFE_ON" },
	{ 0, 0, 7, "MU_EQUALFFE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f2e0[] = {
	{ 0, 7, 1, "TUN_ACKFAIL" },
	{ 0, 4, 7, "TUN_TYPE" },
	{ 0, 3, 1, "TUN_SECSTOP" },
	{ 0, 2, 1, "TUN_VCOSRCH" },
	{ 0, 0, 3, "TUN_MADDRESS" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f300[] = {
	{ 0, 7, 1, "DIS_QSCALE" },
	{ 0, 0,127,"SMAPCOEF_Q_LLR12" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f301[] = {
	{ 0, 2, 1, "ADJ_8PSKLLR1" },
	{ 0, 1, 1, "OLD_8PSKLLR1" },
	{ 0, 0, 1, "DIS_AB8PSK" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f302[] = {
	{ 0, 7, 1, "DIS_8SCALE" },
	{ 0, 0,127,"SMAPCOEF_8P_LLR23" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f333[] = {
	{ 0, 7, 1, "DSS_DVB" },
	{ 0, 4, 1, "DSS_SRCH" },
	{ 0, 1, 1, "SYNCVIT" },
	{ 0, 0, 1, "IQINV" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f33c[] = {
	{ 0, 6, 1, "DIS_VTHLOCK" },
	{ 0, 5, 1, "E7_8VIT" },
	{ 0, 4, 1, "E6_7VIT" },
	{ 0, 3, 1, "E5_6VIT" },
	{ 0, 2, 1, "E3_4VIT" },
	{ 0, 1, 1, "E2_3VIT" },
	{ 0, 0, 1, "E1_2VIT" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f33d[] = {
	{ 0, 7, 1, "AMVIT" },
	{ 0, 6, 1, "FROZENVIT" },
	{ 0, 4, 3, "SNVIT" },
	{ 0, 2, 3, "TOVVIT" },
	{ 0, 0, 3, "HYPVIT" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f33e[] = {
	{ 0, 4, 1, "PRFVIT" },
	{ 0, 3, 1, "LOCKEDVIT" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f369[] = {
	{ 0, 7, 1, "PKTDELIN_DELOCK" },
	{ 0, 6, 1, "SYNCDUPDFL_BADDFL" },
	{ 0, 5, 1, "CONTINUOUS_STREAM" },
	{ 0, 4, 1, "UNACCEPTED_STREAM" },
	{ 0, 3, 1, "BCH_ERROR_FLAG" },
	{ 0, 1, 1, "PKTDELIN_LOCK" },
	{ 0, 0, 1, "FIRST_LOCK" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f36a[] = {
	{ 0, 3,31, "FRAME_MODCOD" },
	{ 0, 0, 3, "FRAME_TYPE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f370[] = {
	{ 0, 7, 1, "TSDIL_ON" },
	{ 0, 6, 1, "TSRS_ON" },
	{ 0, 4, 1, "TSDESCRAMB_ON" },
	{ 0, 3, 1, "TSFRAME_MODE" },
	{ 0, 2, 1, "TS_DISABLE" },
	{ 0, 0, 1, "TSOUT_NOSYNC" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f372[] = {
	{ 0, 7, 1, "TSFIFO_DVBCI" },
	{ 0, 6, 7, "TSFIFO_SERIAL" },
	{ 0, 5, 1, "TSFIFO_TEIUPDATE" },
	{ 0, 4, 1, "TSFIFO_DUTY50" },
	{ 0, 3, 1, "TSFIFO_HSGNLOUT" },
	{ 0, 1, 3, "TSFIFO_ERRMODE" },
	{ 0, 0, 1, "RST_HWARE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f381[] = {
	{ 0, 7, 1, "TSFIFO_LINEOK" },
	{ 0, 6, 1, "TSFIFO_ERROR" },
	{ 0, 0, 1, "DIL_READY" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f382[] = {
	{ 0, 7, 1, "TSFIFO_DEMODSEL" },
	{ 0, 6, 1, "TSFIFOSPEED_STORE" },
	{ 0, 5, 1, "DILXX_RESET" },
	{ 0, 4, 1, "TSSERIAL_IMPOS" },
	{ 0, 1, 1, "SCRAMBDETECT" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f398[] = {
	{ 0, 7, 1, "ERR_SOURCE1" },
	{ 0, 0,127,"NUM_EVENT1" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f39d[] = {
	{ 0, 7, 1, "OLDVALUE" },
	{ 0, 0,127,"VAL" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f3a0[] = {
	{ 0, 7, 1, "SPY_ENABLE" },
	{ 0, 6, 1, "NO_SYNCBYTE" },
	{ 0, 5, 1, "SERIAL_MODE" },
	{ 0, 4, 1, "UNUSUAL_PACKET" },
	{ 0, 3, 1, "BERMETER_DATAMODE" },
	{ 0, 1, 1, "BERMETER_LMODE" },
	{ 0, 0, 1, "BERMETER_RESET" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f3a4[] = {
	{ 0, 7, 1, "SPY_ENDSIM" },
	{ 0, 6, 1, "VALID_SIM" },
	{ 0, 5, 1, "FOUND_SIGNAL" },
	{ 0, 4, 1, "DSS_SYNCBYTE" },
	{ 0, 0,15, "RESULT_STATE" },
	{ 0, 0, 0, NULL }
};

static struct regdmp f332[] = {
	{ 0, 7, 1, "NVTH_NOSRANGE" },
	{ 0, 6, 1, "VERROR_MAXMODE" },
	{ 0, 3, 1, "NSLOWSN_LOCKED" },
	{ 0, 1, 1, "DIS_RSFLOCK" },
	{ 0, 0, 0, NULL }
};

static struct regdmp fa86[] = {
	{ 0, 4, 1, "BROADCAST" },
	{ 0, 1, 1, "PRIORITY" },
	{ 0, 0, 1, "DDEMOD" },
	{ 0, 0, 0, NULL }
};

static struct regdmp ff11[] = {
	{ 0, 7, 1, "FRESFEC" },
	{ 0, 0, 0, NULL }
};

static struct reg demod_reg_tbl[] = {
	{ 0xf100, 0, f100, "MID" },
	{ 0xf129, 0, f129, "I2CCFG" },
	{ 0xf12a, 0, f12a, "P1_I2CRPT" },
	{ 0xf12b, 0, f12a, "P2_I2CRPT" },
	{ 0xf142, 0, conf, "GPIO2CFG" },
	{ 0xf143, 0, conf, "GPIO3CFG" },
	{ 0xf144, 0, conf, "GPIO4CFG" },
	{ 0xf145, 0, conf, "GPIO5CFG" },
	{ 0xf146, 0, conf, "GPIO6CFG" },
	{ 0xf147, 0, conf, "GPIO7CFG" },
	{ 0xf148, 0, conf, "GPIO8CFG" },
	{ 0xf149, 0, conf, "GPIO9CFG" },
	{ 0xf14a, 0, conf, "GPIO10CFG" },
	{ 0xf14b, 0, conf, "GPIO11CFG" },
	{ 0xf14c, 0, conf, "GPIO12CFG" },
	{ 0xf14d, 0, conf, "GPIO13CFG" },
	{ 0xf152, 0, conf, "AGCRF1CFG" },
	{ 0xf156, 0, conf, "AGCRF2CFG" },
	{ 0xf15b, 0, conf, "ERROR1CFG" },
	{ 0xf15c, 0, conf, "DPN1CFG" },
	{ 0xf15d, 0, conf, "STROUT1CFG" },
	{ 0xf15e, 0, conf, "CLKOUT1CFG" },
	{ 0xf15f, 0, conf, "DATA71CFG" },
	{ 0xf160, 0, conf, "ERROR2CFG" },
	{ 0xf161, 0, conf, "DPN2CFG" },
	{ 0xf162, 0, conf, "STROUT2CFG" },
	{ 0xf163, 0, conf, "CLKOUT2CFG" },
	{ 0xf164, 0, conf, "DATA72CFG" },
	{ 0xf165, 0, conf, "ERROR3CFG" },
	{ 0xf166, 0, conf, "DPN3CFG" },
	{ 0xf167, 0, conf, "STROUT3CFG" },
	{ 0xf168, 0, conf, "CLKOUT3CFG" },
	{ 0xf169, 0, conf, "DATA73CFG" },
	{ 0xf16a, 0, f16a, "STRSTATUS1" },
	{ 0xf16b, 0, f16b, "STRSTATUS2" },
	{ 0xf16c, 0, f16c, "STRSTATUS3" },
	{ 0xf190, 0, f190, "P2_DISTXCTL" },
	{ 0xf197, 0, byte, "P2_DISTXDATA" },
	{ 0xf198, 0, f198, "P2_DISTXSTATUS" },
	{ 0xf199, 0, byte, "P2_F22TX" },
	{ 0xf19a, 0, byte, "P2_F22RX" },
	{ 0xf19d, 0, byte, "P2_ACRDIV" },
	{ 0xf1a0, 0, f190, "P1_DISTXCTL" },
	{ 0xf1a7, 0, byte, "P1_DISTXDATA" },
	{ 0xf1a8, 0, f198, "P1_DISTXSTATUS" },
	{ 0xf1a9, 0, byte, "P1_F22TX" },
	{ 0xf1aa, 0, byte, "P1_F22RX" },
	{ 0xf1ad, 0, byte, "P1_ACRDIV" },
	{ 0xf1b3, 0, byte, "NCOARSE" },
	{ 0xf1b6, 0, f1b6, "SYNTCTRL" },
	{ 0xf1c2, 0, f1c2, "STOPCLK1" },
	{ 0xf1c3, 0, f1c3, "STOPCLK2" },
	{ 0xf1e1, 0, f1e1, "TSTTNR2" },
	{ 0xf201, 0, f201, "NOSCFG" },
	{ 0xf206, 0, f206, "AGC1CN" },
	{ 0xf20e, 0, byte, "AGCIQIN1" },
	{ 0xf20f, 0, byte, "AGCIQIN0" },
	{ 0xf211, 0, f211, "DMDMODCOD" },
	{ 0xf212, 0, f212, "DSTATUS" },
	{ 0xf213, 0, f213, "DSTATUS2" },
	{ 0xf214, 0, f214, "DMDCFGMD" },
	{ 0xf215, 0, f215, "DMDCFG2" },
	{ 0xf216, 0, f216, "DMDISTATE" },
	{ 0xf217, 0, byte, "DMDT0M" },
	{ 0xf21e, 0, f21e, "DMDCFG3" },
	{ 0xf21f, 0, f21f, "DMDCFG4" },
	{ 0xf220, 0, byte, "CORRELMANT" },
	{ 0xf221, 0, byte, "CORRELABS" },
	{ 0xf222, 0, byte, "CORRELEXP" },
	{ 0xf224, 0, f224, "PLHMODCOD" },
	{ 0xf22d, 0, byte, "AGC2_REF" },
	{ 0xf238, 0, f238, "CARCFG" },
	{ 0xf239, 0, f239, "ACLC" },
	{ 0xf23a, 0, f23a, "BCLC" },
	{ 0xf23d, 0, f23d, "CARFREQ" },
	{ 0xf23e, 0, byte, "CARHDR/K_FREQ_HDR" },
	{ 0xf23f, 0, byte, "LDT/CARLOCK_THRES" },
	{ 0xf240, 0, byte, "LDT2/CARLOCK_THRES2" },
	{ 0xf242, 0, byte, "CFRUP1" },
	{ 0xf243, 0, byte, "CFRUP0" },
	{ 0xf246, 0, byte, "CFRLOW1" },
	{ 0xf247, 0, byte, "CFRLOW0" },
        { 0xf248, 0, byte, "CFRINIT1" },
        { 0xf249, 0, byte, "CFRINIT0" },
        { 0xf24c, 0, byte, "CFR2/CAR_FREQ2" },
        { 0xf24d, 0, byte, "CFR1/CAR_FREQ1" },
        { 0xf24e, 0, byte, "CFR0/CAR_FREQ0" },
        { 0xf250, 0, f250, "TMGCFG" },
        { 0xf251, 0, f251, "RTC" },
        { 0xf252, 0, f252, "RTCS2" },
        { 0xf253, 0, byte, "TMGTHRISE" },
        { 0xf254, 0, byte, "TMGTHFALL" },
        { 0xf255, 0, byte, "SFRUPRATIO" },
        { 0xf256, 0, byte, "SFRLOWRATIO" },
        { 0xf258, 0, byte, "KREFTMG" },
        { 0xf259, 0, f259, "SFRSTEP" },
        { 0xf25e, 0, byte, "SFRINIT1" },
        { 0xf25f, 0, byte, "SFRINIT0" },
        { 0xf260, 0, f260, "SFRUP1" },
        { 0xf261, 0, byte, "SFRUP0" },
        { 0xf262, 0, f262, "SFRLOW1" },
        { 0xf263, 0, byte, "SFRLOW0" },
        { 0xf268, 0, byte, "TMGREG2" },
        { 0xf269, 0, byte, "TMGREG1" },
        { 0xf26a, 0, byte, "TMGREG0" },
        { 0xf26b, 0, byte, "TMGLOCK1" },
        { 0xf26c, 0, byte, "TMGLOCK0" },
        { 0xf26d, 0, f26d, "TMGOBS" },
	{ 0xf280, 0, byte, "NNOSDATAT1" },
	{ 0xf281, 0, byte, "NNOSDATAT0" },
	{ 0xf284, 0, byte, "NNOSPLHT1" },
	{ 0xf285, 0, byte, "NNOSPLHT0" },
	{ 0xf290, 0, f290, "CAR2CFG" },
	{ 0xf291, 0, f291, "CAR2CFG1" },
	{ 0xf297, 0, f297, "ACLC2S2Q" },
	{ 0xf298, 0, f298, "ACLC2S28" },
	{ 0xf29c, 0, f29c, "BCLC2S2Q" },
	{ 0xf29d, 0, f29d, "BCLC2S28" },
	{ 0xf2b7, 0, f2b7, "MODCODLST7" },
	{ 0xf2b8, 0, f2b8, "MODCODLST8" },
	{ 0xf2b9, 0, f2b9, "MODCODLST9" },
	{ 0xf2ba, 0, f2ba, "MODCODLSTA" },
	{ 0xf2bb, 0, f2bb, "MODCODLSTB" },
	{ 0xf2bc, 0, f2bc, "MODCODLSTC" },
	{ 0xf2bd, 0, f2bd, "MODCODLSTD" },
	{ 0xf2be, 0, f2be, "MODCODLSTE" },
	{ 0xf2bf, 0, f2bf, "MODCODLSTF" },
	{ 0xf2c0, 0, f2c0, "GAUSSR0" },
	{ 0xf2c1, 0, f2c1, "CCIR0" },
	{ 0xf2d8, 0, f2d8, "FFECFG" },
	{ 0xf2e0, 0, f2e0, "TNRCFG" },
	{ 0xf300, 0, f300, "SMAPCOEF7" },
	{ 0xf301, 0, f301, "SMAPCOEF6" },
	{ 0xf302, 0, f302, "SMAPCOEF5" },
	{ 0xf333, 0, f333, "FECM" },
	{ 0xf334, 0, byte, "VTH12" },
	{ 0xf335, 0, byte, "VTH23" },
	{ 0xf336, 0, byte, "VTH34" },
	{ 0xf337, 0, byte, "VTH56" },
	{ 0xf338, 0, byte, "VTH67" },
	{ 0xf339, 0, byte, "VTH78" },
	{ 0xf33c, 0, f33c, "PRVIT" },
	{ 0xf33d, 0, f33d, "VAVSRVIT" },
	{ 0xf33e, 0, f33e, "VSTATUSVIT" },
	{ 0xf370, 0, f370, "TSSTATEM" },
	{ 0xf372, 0, f372, "TSCFGH" },
	{ 0xf369, 0, f369, "PDELSTATUS1" },
	{ 0xf36a, 0, f36a, "PDELSTATUS2" },
	{ 0xf380, 0, byte, "TSFIFO_OUTSPEED" },
	{ 0xf381, 0, f381, "TSSTATUS" },
	{ 0xf382, 0, f382, "TSSTATUS2" },
	{ 0xf383, 0, byte, "BITRATE1" },
	{ 0xf384, 0, byte, "BITRATE0" },
	{ 0xf398, 0, f398, "ERRCTRL1" },
	{ 0xf399, 0, byte, "ERRCNT12" },
	{ 0xf39a, 0, byte, "ERRCNT11" },
	{ 0xf39b, 0, byte, "ERRCNT10" },
	{ 0xf39d, 0, f39d, "ERRCNT22" },
	{ 0xf39e, 0, byte, "ERRCNT21" },
	{ 0xf39f, 0, byte, "ERRCNT20" },
	{ 0xf3a0, 0, f3a0, "FECSPY" },
	{ 0xf3a4, 0, f3a4, "FSTATUS" },
	{ 0xf3ad, 0, byte, "FBERERR2" },
	{ 0xf3ae, 0, byte, "FBERERR1" },
	{ 0xf3af, 0, byte, "FBERERR0" },
	{ 0xf332, 0, f332, "VITSCALE" },
	{ 0xf600, 0, byte, "RCCFG2" },
	{ 0xfa43, 0, byte, "GAINLLR_NF4/QP_1_2" },
	{ 0xfa44, 0, byte, "GAINLLR_NF5/QP_3_5" },
	{ 0xfa45, 0, byte, "GAINLLR_NF6/QP_2_3" },
	{ 0xfa46, 0, byte, "GAINLLR_NF7/QP_3_4" },
	{ 0xfa47, 0, byte, "GAINLLR_NF8/QP_4_5" },
	{ 0xfa48, 0, byte, "GAINLLR_NF9/QP_5_6" },
	{ 0xfa49, 0, byte, "GAINLLR_NF10/QP_8_9" },
	{ 0xfa4a, 0, byte, "GAINLLR_NF11/QP_9_10" },
	{ 0xfa50, 0, byte, "GAINLLR_NF18/8P_9_10" },
	{ 0xfa86, 0, fa86, "GENCFG" },
	{ 0xff11, 0, ff11, "TSTRES0" },
	{ 0, 0, NULL, NULL }
};

static int
i2c_demod_valid(int reg)
{
	if (reg >= 0xf100 && reg < 0x10000)
		return 1;
	return 0;
}

static const char *
i2c_demod_prefix(int reg)
{
	if (reg >= 0xf200 && reg < 0xf400)
		return "P2_";
	if (reg >= 0xf400 && reg < 0xf600)
		return "P1_";
	return "";
}

static struct reg *i2c_demod_find(int reg)
{
	int reg2 = reg >= 0xf400 && reg < 0xf600 ? reg - 0x200 : reg;
	struct reg *rt;
	for (rt = demod_reg_tbl; rt->name; rt++)
		if (rt->reg == reg2)
			break;
	return rt->name ? rt : NULL;
}

static const char *i2c_print_old(const char *s)
{
	if (s[0])
		printf("%s\n", s);
	return "";
}

static int
i2c_line(int rd, int t1, int start, const char *s)
{
	static struct reg *old_rt[2] = { NULL, NULL };
	static int old_cmd[2] = { 0, 0 };
	int r, ptr, addr, cnt, d[16], val;
	struct reg *rt;
	struct regdmp *rtd;
	char buf[1024];

	r = sscanf(s + start, "%x, %d) %x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x",
	           &addr, &cnt,
	           &d[0], &d[1], &d[2], &d[3], &d[4], &d[5], &d[6], &d[7],
	           &d[8], &d[9], &d[10], &d[11], &d[12], &d[13], &d[14], &d[15]);
        if (r < 3 || cnt != r - 2)
        	return -1;
	if (addr < 0xd0 && addr > 0xd3)
		return -1;
	if (!rd)
		goto wr;

	if (old_rt[t1] == NULL)
		return -1;
	if (cnt < 1) {
		old_rt[t1] = NULL;
		return -1;
	}
	addr = old_cmd[t1];
	ptr = 0;
	do {
		val = d[ptr];
		rt = i2c_demod_find(addr++);
		if (rt == NULL) {
			s = i2c_print_old(s);
			continue;
		}
		snprintf(buf, sizeof(buf), "%-40s ; %s%s{%04x}", s,
			i2c_demod_prefix(addr - 1), rt->name, addr - 1);
		for (rtd = rt->dmp; rtd && rtd->name; rtd++) {
			if (strlen(buf) > PWIDTH) {
				printf("%s\n", buf);
				sprintf(buf, "%40s ;", "");
			}
			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s=0x%x",
				 rtd->name, (val >> rtd->shift) & rtd->mask);
			val &= ~(rtd->mask << rtd->shift);
		}
		if (val) {
			if (strlen(buf) > PWIDTH) {
				printf("%s\n", buf);
				sprintf(buf, "%40s ;", "");
			}
			snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " UNKNOWN=0x%x", val);
		}
		s = i2c_print_old(buf);
	} while (++ptr < cnt);
	old_rt[t1] = NULL;
	return 0;

wr:
	if (!i2c_demod_valid((d[0] << 8) | d[1]))
		return -1;
	if (cnt < 2)
		return -1;
	old_cmd[t1] = ((d[0] << 8) | d[1]) - 1;
	ptr = 2;
	do {
		addr = ++old_cmd[t1];
		rt = i2c_demod_find(addr);
		if (rt == NULL) {
			s = i2c_print_old(s);
			continue;
		}
		old_rt[t1] = rt;
		snprintf(buf, sizeof(buf), "%-40s ; %s%s{%04x}", s,
			i2c_demod_prefix(addr), rt->name, addr);
		if (ptr < cnt) {
			val = d[ptr];
			for (rtd = rt->dmp; rtd && rtd->name; rtd++) {
				if (strlen(buf) > PWIDTH) {
					printf("%s\n", buf);
					sprintf(buf, "%40s ;", "");
				}
				snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s=0x%x",
					 rtd->name, (val >> rtd->shift) & rtd->mask);
				val &= ~(rtd->mask << rtd->shift);
			}
			if (val) {
				if (strlen(buf) > PWIDTH) {
					printf("%s\n", buf);
					sprintf(buf, "%40s ;", "");
				}
				snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " UNKNOWN=0x%x", val);
			}
		}
		s = i2c_print_old(buf);
	} while (++ptr < cnt);
	return 0;
}

static void 
i2c_decoder(void)
{
	char buf[1024];
	int r;

	while (!feof(stdin)) {
		if (fgets(buf, sizeof(buf), stdin) == NULL)
			break;
		if (buf[0] == '\0')
			continue;
		buf[strlen(buf)-1] = '\0';
		r = -1;
		if (!strncmp(buf, "[i2c] wrte(", 11))
			r = i2c_line(0, 0, 11, buf);
		else if (!strncmp(buf, "[i2c] read(", 11))
			r = i2c_line(1, 0, 11, buf);
		else if (!strncmp(buf, "[i2c] t1_w(", 11))
			r = i2c_line(0, 1, 11, buf);
		else if (!strncmp(buf, "[i2c] t1_r(", 11))
			r = i2c_line(1, 1, 11, buf);
		if (r < 0)
			printf("%s\n", buf);
	}
}

static int i2c_fd = -1;

static int
i2c_open(int num, char *_path)
{
	char path[32];
	if (num < 8)
		sprintf(path, "/dev/i2c-%d", num);
	else
		strcpy(path, "/dev/axe/i2c_drv-0");
	i2c_fd = open(path, O_RDWR);
	if (i2c_fd < 0)
		return -1;
	if (_path)
		strcpy(_path, path);
	return 0;
}

static int
i2c_open_check(void)
{
	if (i2c_fd >= 0)
		return 0;
	if (i2c_open(0, NULL)) {
		printf("Unable to open i2c device\n");
		return -1;
	}
	return 0;
}

static u8 i2c_repeater[3] = { 0xf1, 0x2a, 0xbc };

static int
i2c_reg_read(int addr, int reg, u8 *buf, int cnt, int trans)
{
	u8 buf1[3];
	struct i2c_rdwr_ioctl_data d;
	struct i2c_msg m[4];
	int mi = 0, fmask = trans ? I2C_M_NOREPSTART : 0;

	if (i2c_open_check())
		return -1;

	memset(&d, 0, sizeof(d));
	memset(&m, 0, sizeof(m));
	memset(buf1, 0, sizeof(buf1));
	memset(buf, 0, cnt);

	/* STV0610 */
	if (addr == 0xc0 || addr == 0xc6) {
		fmask = I2C_M_NOREPSTART;
		m[mi].addr = (addr == 0xc0 ? 0xd0 : 0xd2) >> 1;
		m[mi].len = sizeof(i2c_repeater);
		m[mi].flags = fmask;
		m[mi].buf = i2c_repeater;
		mi++;
	}

	if (reg < 256) {
		buf1[0] = reg;
	} else {
		buf1[0] = reg >> 8;
		buf1[1] = reg;
	}

	m[mi].addr = addr >> 1;
	m[mi].len = reg < 256 ? 1 : 2;
	m[mi].flags = fmask;
	m[mi].buf = buf1;
	mi++;

	/* STV0610 */
	if (addr == 0xc0 || addr == 0xc6) {
		m[mi].addr = (addr == 0xc0 ? 0xd0 : 0xd2) >> 1;
		m[mi].len = sizeof(i2c_repeater);
		m[mi].flags = fmask;
		m[mi].buf = i2c_repeater;
		mi++;
	}

	m[mi].addr = addr >> 1;
	m[mi].len = cnt;
	m[mi].flags = fmask | I2C_M_RD;
	m[mi].buf = buf;
	mi++;

	d.nmsgs = mi;
	d.msgs = m;
	if (ioctl(i2c_fd, I2C_RDWR, &d) < 0) {
		printf("I2C RDWR failed for addr 0x%x\n", addr);
		return -1;
	}
	return cnt;
}

static int
i2c_reg_write(int addr, int reg, u8 *buf, int cnt, int trans)
{
	u8 buf1[32];
	struct i2c_rdwr_ioctl_data d;
	struct i2c_msg m[2];
	int mi = 0, fmask = trans ? I2C_M_NOREPSTART : 0;

	if (i2c_open_check())
		return -1;

	memset(&d, 0, sizeof(d));
	memset(&m, 0, sizeof(m));
	memset(buf1, 0, sizeof(buf1));

	/* STV0610 */
	if (addr == 0xc0 || addr == 0xc6) {
		fmask = I2C_M_NOREPSTART;
		m[mi].addr = (addr == 0xc0 ? 0xd0 : 0xd2) >> 1;
		m[mi].len = sizeof(i2c_repeater);
		m[mi].flags = fmask;
		m[mi].buf = i2c_repeater;
		mi++;
	}

	if (reg < 256) {
		buf1[0] = reg;
		memcpy(buf1 + 1, buf, cnt);
	} else {
		buf1[0] = reg >> 8;
		buf1[1] = reg;
		memcpy(buf1 + 2, buf, cnt);
	}

	m[mi].addr = addr >> 1;
	m[mi].len = (reg < 256 ? 1 : 2) + cnt;
	m[mi].flags = fmask;
	m[mi].buf = buf1;
	mi++;

	d.nmsgs = mi;
	d.msgs = m;
	if (ioctl(i2c_fd, I2C_RDWR, &d) < 0) {
		printf("I2C RDWR failed for addr 0x%x\n", addr);
		return -1;
	}
	return cnt;
}

static void
i2c_scan(void)
{
	int i, a, r;
	u8 v;
	char path[32];

	for (i = 0; i < 9; i++) {
		if (i2c_open(i, path))
			continue;
		a = 0xd0;
		r = i2c_reg_read(a, 0xf000, &v, 1, 1);
		if (r >= 0)
			printf("I2C read succeed for %s, addr 0x%02x: 0x%02x\n", path, a, v);
		close(i2c_fd);
		i2c_fd = -1;
	}
}

#define MAXARGV 32
#define MAXOPTS 32

static char *argv[MAXARGV];
static int argc;
static char *opts[MAXOPTS];
static int optc;

static int
find_opt(const char *name)
{
	int i;
	for (i = 0; i < optc; i++)
		if (strcmp(opts[i], name) == 0)
			return 1;
	return 0;
}

static void
parse_args(int _argc, char *_argv[])
{
	char *s;
	int i;

	argv[0] = _argv[0];
	argc = 1;
	for (i = 1; i < _argc; i++) {
		s = _argv[i];
		if (s[0] == '-') {
			s++;
			if (s[0] == '-')
				s++;
			if (optc < MAXOPTS)
				opts[optc++] = s;
		} else {
			if (argc < MAXARGV)
				argv[argc++] = s;
		}
	}
}

int
main(int _argc, char *_argv[])
{
	parse_args(_argc, _argv);
	if (argc > 1 && !strcmp(argv[1], "wait")) {
		long int ms = 1000;
		const char *f = NULL;
		if (argc > 2)
			ms = atol(argv[2]);
		if (argc > 3)
			nice(atoi(argv[3]));
		if (argc > 4)
			f = argv[4][0] ? argv[4] : NULL;
		ms += getTick();
		while (ms > getTick())
			if (f && !access(f, R_OK))
				break;
	}
	if (argc > 1 && !strcmp(argv[1], "i2c_decoder")) {
		i2c_decoder();
	}
	if (argc > 1 && !strcmp(argv[1], "i2c_scan")) {
		i2c_scan();
	}
	if (argc > 1 && !strcmp(argv[1], "i2c_reg_read")) {
		if (argc <= 3)
			exit(EXIT_FAILURE);
		int i, j;
		int a = strtol(argv[2], NULL, 0);
		int r = strtol(argv[3], NULL, 0);
		int c = argc > 4 ? strtol(argv[4], NULL, 0) : 1;
		u8 buf[16];
		char buf2[256];
		if (a < 0 || r < 0 || c < 0)
			exit(EXIT_FAILURE);
		i = i2c_reg_read(a, r, buf, c > sizeof(buf) ? sizeof(buf) : c, find_opt("trans"));
		if (i < 0) {
			printf("Unable to read register 0x%x from addr 0x%x\n", r, a);
			exit(EXIT_FAILURE);
		}
		if (find_opt("decode")) {
			if (r < 256)
				sprintf(buf2, "  > (%x, %d) %02x", a & ~1, 2, r & 0xff);
			else
				sprintf(buf2, "  > (%x, %d) %02x.%02x", a & ~1, 2, (r >> 8) & 0xff, r & 0xff);
			if (i2c_line(0, 0, 5, buf2) >= 0) {
				sprintf(buf2, "  < (%x, %d) ", a | 1, i);
				for (j = 0; j < i; j++)
					sprintf(buf2 + strlen(buf2), "%s%02x", j > 0 ? "." : "", buf[j]);
				if (i2c_line(1, 0, 5, buf2) >= 0)
					exit(EXIT_SUCCESS);
			}
		}
		if (!find_opt("decode") || find_opt("raw")) {
			for (j = 0; j < i; j++)
				printf("%s0x%02x", j > 0 ? ":" : "", buf[j]);
			printf("\n");
		}
		exit(EXIT_SUCCESS);
	}
	if (argc > 1 && !strcmp(argv[1], "i2c_reg_write")) {
		if (argc <= 4)
			exit(EXIT_FAILURE);
		int i, j;
		int a = strtol(argv[2], NULL, 0);
		int r = strtol(argv[3], NULL, 0);
		u8 buf[16];
		for (j = 4; j < argc && j < sizeof(buf) + 4; j++)
			buf[j-4] = strtol(argv[j], NULL, 0);
		if (a <= 0 && r < 0)
			exit(EXIT_FAILURE);
		i = i2c_reg_write(a, r, buf, j, find_opt("trans"));
		if (i < 0) {
			printf("Unable to write register 0x%x to addr 0x%x\n", r, a);
			exit(EXIT_FAILURE);
		}
		exit(EXIT_SUCCESS);
	}
	return 0;
}