]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/commitdiff
V4L/DVB(7767): Move tuners to common/tuners
authorMauro Carvalho Chehab <mchehab@infradead.org>
Wed, 30 Apr 2008 00:38:44 +0000 (21:38 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Tue, 29 Apr 2008 21:41:37 +0000 (18:41 -0300)
There were several issues in the past, caused by the hybrid tuner design, since
now, the same tuner can be used by drivers/media/dvb and drivers/media/video.

Kconfig items were rearranged, to split V4L/DVB core from their drivers.

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
76 files changed:
drivers/media/Kconfig
drivers/media/Makefile
drivers/media/common/tuners/Kconfig [new file with mode: 0644]
drivers/media/common/tuners/Makefile [new file with mode: 0644]
drivers/media/common/tuners/mt20xx.c [new file with mode: 0644]
drivers/media/common/tuners/mt20xx.h [new file with mode: 0644]
drivers/media/common/tuners/tda18271-common.c [new file with mode: 0644]
drivers/media/common/tuners/tda18271-fe.c [new file with mode: 0644]
drivers/media/common/tuners/tda18271-maps.c [new file with mode: 0644]
drivers/media/common/tuners/tda18271-priv.h [new file with mode: 0644]
drivers/media/common/tuners/tda18271.h [new file with mode: 0644]
drivers/media/common/tuners/tda827x.c [new file with mode: 0644]
drivers/media/common/tuners/tda827x.h [new file with mode: 0644]
drivers/media/common/tuners/tda8290.c [new file with mode: 0644]
drivers/media/common/tuners/tda8290.h [new file with mode: 0644]
drivers/media/common/tuners/tda9887.c [new file with mode: 0644]
drivers/media/common/tuners/tda9887.h [new file with mode: 0644]
drivers/media/common/tuners/tea5761.c [new file with mode: 0644]
drivers/media/common/tuners/tea5761.h [new file with mode: 0644]
drivers/media/common/tuners/tea5767.c [new file with mode: 0644]
drivers/media/common/tuners/tea5767.h [new file with mode: 0644]
drivers/media/common/tuners/tuner-i2c.h [new file with mode: 0644]
drivers/media/common/tuners/tuner-simple.c [new file with mode: 0644]
drivers/media/common/tuners/tuner-simple.h [new file with mode: 0644]
drivers/media/common/tuners/tuner-types.c [new file with mode: 0644]
drivers/media/common/tuners/tuner-xc2028-types.h [new file with mode: 0644]
drivers/media/common/tuners/tuner-xc2028.c [new file with mode: 0644]
drivers/media/common/tuners/tuner-xc2028.h [new file with mode: 0644]
drivers/media/common/tuners/xc5000.c [new file with mode: 0644]
drivers/media/common/tuners/xc5000.h [new file with mode: 0644]
drivers/media/common/tuners/xc5000_priv.h [new file with mode: 0644]
drivers/media/dvb/Kconfig
drivers/media/dvb/b2c2/Makefile
drivers/media/dvb/bt8xx/Makefile
drivers/media/dvb/dvb-core/Kconfig [deleted file]
drivers/media/dvb/dvb-usb/Makefile
drivers/media/dvb/frontends/Kconfig
drivers/media/dvb/frontends/Makefile
drivers/media/dvb/frontends/tda18271-common.c [deleted file]
drivers/media/dvb/frontends/tda18271-fe.c [deleted file]
drivers/media/dvb/frontends/tda18271-priv.h [deleted file]
drivers/media/dvb/frontends/tda18271-tables.c [deleted file]
drivers/media/dvb/frontends/tda18271.h [deleted file]
drivers/media/dvb/frontends/tda827x.c [deleted file]
drivers/media/dvb/frontends/tda827x.h [deleted file]
drivers/media/dvb/frontends/xc5000.c [deleted file]
drivers/media/dvb/frontends/xc5000.h [deleted file]
drivers/media/dvb/frontends/xc5000_priv.h [deleted file]
drivers/media/video/Kconfig
drivers/media/video/Makefile
drivers/media/video/au0828/Makefile
drivers/media/video/bt8xx/Makefile
drivers/media/video/cx23885/Makefile
drivers/media/video/cx88/Makefile
drivers/media/video/em28xx/Makefile
drivers/media/video/ivtv/Makefile
drivers/media/video/mt20xx.c [deleted file]
drivers/media/video/mt20xx.h [deleted file]
drivers/media/video/pvrusb2/Makefile
drivers/media/video/saa7134/Makefile
drivers/media/video/tda8290.c [deleted file]
drivers/media/video/tda8290.h [deleted file]
drivers/media/video/tda9887.c [deleted file]
drivers/media/video/tda9887.h [deleted file]
drivers/media/video/tea5761.c [deleted file]
drivers/media/video/tea5761.h [deleted file]
drivers/media/video/tea5767.c [deleted file]
drivers/media/video/tea5767.h [deleted file]
drivers/media/video/tuner-i2c.h [deleted file]
drivers/media/video/tuner-simple.c [deleted file]
drivers/media/video/tuner-simple.h [deleted file]
drivers/media/video/tuner-types.c [deleted file]
drivers/media/video/tuner-xc2028-types.h [deleted file]
drivers/media/video/tuner-xc2028.c [deleted file]
drivers/media/video/tuner-xc2028.h [deleted file]
drivers/media/video/usbvision/Makefile

index 128bb9cd5755f57f7a8cab9895149edcb39680aa..b5664927df912bd75d96a10c8b02403bed2affd9 100644 (file)
@@ -5,6 +5,12 @@
 menu "Multimedia devices"
        depends on HAS_IOMEM
 
+comment "Multimedia core support"
+
+#
+# V4L core and enabled API's
+#
+
 config VIDEO_DEV
        tristate "Video For Linux"
        ---help---
@@ -58,135 +64,59 @@ config VIDEO_V4L1_COMPAT
 
          If you are unsure as to whether this is required, answer Y.
 
-config VIDEO_V4L2
-       tristate
-       depends on VIDEO_DEV && VIDEO_V4L2_COMMON
-       default VIDEO_DEV && VIDEO_V4L2_COMMON
-
-config VIDEO_V4L1
-       tristate
-       depends on VIDEO_DEV && VIDEO_V4L2_COMMON && VIDEO_ALLOW_V4L1
-       default VIDEO_DEV && VIDEO_V4L2_COMMON && VIDEO_ALLOW_V4L1
-
-source "drivers/media/video/Kconfig"
-
-source "drivers/media/radio/Kconfig"
-
-source "drivers/media/dvb/Kconfig"
-
-source "drivers/media/common/Kconfig"
+#
+# DVB Core
+#
 
-config VIDEO_TUNER
-       tristate
-       depends on I2C
-       select TUNER_XC2028 if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_MT20XX if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_TDA8290 if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_TEA5761 if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_TEA5767 if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_SIMPLE if !VIDEO_TUNER_CUSTOMIZE
-       select TUNER_TDA9887 if !VIDEO_TUNER_CUSTOMIZE
-
-menuconfig VIDEO_TUNER_CUSTOMIZE
-       bool "Customize analog tuner modules to build"
-       depends on VIDEO_TUNER
+config DVB_CORE
+       tristate "DVB for Linux"
+       depends on NET && INET
+       select CRC32
        help
-         This allows the user to deselect tuner drivers unnecessary
-         for their hardware from the build. Use this option with care
-         as deselecting tuner drivers which are in fact necessary will
-         result in V4L devices which cannot be tuned due to lack of
-         driver support
+         Support Digital Video Broadcasting hardware.  Enable this if you
+         own a DVB adapter and want to use it or if you compile Linux for
+         a digital SetTopBox.
 
-         If unsure say N.
-
-if VIDEO_TUNER_CUSTOMIZE
+         DVB core utility functions for device handling, software fallbacks etc.
+         Say Y when you have a DVB card and want to use it. Say Y if your want
+         to build your drivers outside the kernel, but need the DVB core. All
+         in-kernel drivers will select this automatically if needed.
 
-config TUNER_XC2028
-       tristate "XCeive xc2028/xc3028 tuners"
-       depends on I2C && FW_LOADER
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for the xc2028/xc3028 tuners.
+         API specs and user tools are available from <http://www.linuxtv.org/>.
 
-config TUNER_MT20XX
-       tristate "Microtune 2032 / 2050 tuners"
-       depends on I2C
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for the MT2032 / MT2050 tuner.
-
-config TUNER_TDA8290
-       tristate "TDA 8290/8295 + 8275(a)/18271 tuner combo"
-       depends on I2C
-       select DVB_TDA827X
-       select DVB_TDA18271
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for Philips TDA8290+8275(a) tuner.
+         Please report problems regarding this driver to the LinuxDVB
+         mailing list.
 
-config TUNER_TEA5761
-       tristate "TEA 5761 radio tuner (EXPERIMENTAL)"
-       depends on I2C && EXPERIMENTAL
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for the Philips TEA5761 radio tuner.
-
-config TUNER_TEA5767
-       tristate "TEA 5767 radio tuner"
-       depends on I2C
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for the Philips TEA5767 radio tuner.
-
-config TUNER_SIMPLE
-       tristate "Simple tuner support"
-       depends on I2C
-       select TUNER_TDA9887
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for various simple tuners.
+         If unsure say N.
 
-config TUNER_TDA9887
-       tristate "TDA 9885/6/7 analog IF demodulator"
-       depends on I2C
-       default m if VIDEO_TUNER_CUSTOMIZE
-       help
-         Say Y here to include support for Philips TDA9885/6/7
-         analog IF demodulator.
+config VIDEO_MEDIA
+       tristate
+       default DVB_CORE || VIDEO_DEV
+       depends on DVB_CORE || VIDEO_DEV
 
-endif # VIDEO_TUNER_CUSTOMIZE
+comment "Multimedia drivers"
 
-config VIDEOBUF_GEN
-       tristate
+source "drivers/media/common/Kconfig"
 
-config VIDEOBUF_DMA_SG
-       depends on HAS_DMA
-       select VIDEOBUF_GEN
-       tristate
+#
+# Tuner drivers for DVB and V4L
+#
 
-config VIDEOBUF_VMALLOC
-       select VIDEOBUF_GEN
-       tristate
+source "drivers/media/common/tuners/Kconfig"
 
-config VIDEOBUF_DVB
-       tristate
-       select VIDEOBUF_GEN
-       select VIDEOBUF_DMA_SG
+#
+# Video/Radio/Hybrid adapters
+#
 
-config VIDEO_BTCX
-       tristate
+source "drivers/media/video/Kconfig"
 
-config VIDEO_IR_I2C
-       tristate
+source "drivers/media/radio/Kconfig"
 
-config VIDEO_IR
-       tristate
-       depends on INPUT
-       select VIDEO_IR_I2C if I2C
+#
+# DVB adapters
+#
 
-config VIDEO_TVEEPROM
-       tristate
-       depends on I2C
+source "drivers/media/dvb/Kconfig"
 
 config DAB
        boolean "DAB adapters"
index 7b8bb6949f5e877262312666a4991bf46c957c81..73f742c7e818428f1965d880a3c442e71154a957 100644 (file)
@@ -2,10 +2,10 @@
 # Makefile for the kernel multimedia device drivers.
 #
 
-obj-y := common/
-obj-y += video/
+obj-$(CONFIG_VIDEO_MEDIA) += common/
+
+# Since hybrid devices are here, should be compiled if DVB and/or V4L
+obj-$(CONFIG_VIDEO_MEDIA) += video/
+
 obj-$(CONFIG_VIDEO_DEV) += radio/
 obj-$(CONFIG_DVB_CORE)  += dvb/
-ifeq ($(CONFIG_DVB_CORE),)
-  obj-$(CONFIG_VIDEO_TUNER)  += dvb/frontends/
-endif
diff --git a/drivers/media/common/tuners/Kconfig b/drivers/media/common/tuners/Kconfig
new file mode 100644 (file)
index 0000000..9a6a902
--- /dev/null
@@ -0,0 +1,118 @@
+config DVB_CORE_ATTACH
+       bool "Load and attach frontend driver modules as needed"
+       depends on DVB_CORE
+       depends on MODULES
+       help
+         Remove the static dependency of DVB card drivers on all
+         frontend modules for all possible card variants. Instead,
+         allow the card drivers to only load the frontend modules
+         they require. This saves several KBytes of memory.
+
+         Note: You will need module-init-tools v3.2 or later for this feature.
+
+         If unsure say Y.
+
+config VIDEO_TUNER
+       tristate
+       default DVB_CORE || VIDEO_DEV
+       depends on DVB_CORE || VIDEO_DEV
+       select TUNER_XC2028 if !VIDEO_TUNER_CUSTOMIZE
+       select DVB_TUNER_XC5000 if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_MT20XX if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_TDA8290 if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_TEA5761 if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_TEA5767 if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_SIMPLE if !VIDEO_TUNER_CUSTOMIZE
+       select TUNER_TDA9887 if !VIDEO_TUNER_CUSTOMIZE
+
+menuconfig VIDEO_TUNER_CUSTOMIZE
+       bool "Customize analog and hybrid tuner modules to build"
+       depends on VIDEO_TUNER
+       help
+         This allows the user to deselect tuner drivers unnecessary
+         for their hardware from the build. Use this option with care
+         as deselecting tuner drivers which are in fact necessary will
+         result in V4L/DVB devices which cannot be tuned due to lack of
+         driver support
+
+         If unsure say N.
+
+if VIDEO_TUNER_CUSTOMIZE
+
+config TUNER_SIMPLE
+       tristate "Simple tuner support"
+       depends on I2C
+       select TUNER_TDA9887
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for various simple tuners.
+
+config TUNER_TDA8290
+       tristate "TDA 8290/8295 + 8275(a)/18271 tuner combo"
+       depends on I2C
+       select DVB_TDA827X
+       select DVB_TDA18271
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for Philips TDA8290+8275(a) tuner.
+
+config DVB_TDA827X
+       tristate "Philips TDA827X silicon tuner"
+       depends on DVB_CORE && I2C
+       default m if DVB_FE_CUSTOMISE
+       help
+         A DVB-T silicon tuner module. Say Y when you want to support this tuner.
+
+config DVB_TDA18271
+       tristate "NXP TDA18271 silicon tuner"
+       depends on I2C
+       default m if DVB_FE_CUSTOMISE
+       help
+         A silicon tuner module. Say Y when you want to support this tuner.
+
+config TUNER_TDA9887
+       tristate "TDA 9885/6/7 analog IF demodulator"
+       depends on I2C
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for Philips TDA9885/6/7
+         analog IF demodulator.
+
+config TUNER_TEA5761
+       tristate "TEA 5761 radio tuner (EXPERIMENTAL)"
+       depends on I2C && EXPERIMENTAL
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for the Philips TEA5761 radio tuner.
+
+config TUNER_TEA5767
+       tristate "TEA 5767 radio tuner"
+       depends on I2C
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for the Philips TEA5767 radio tuner.
+
+config TUNER_MT20XX
+       tristate "Microtune 2032 / 2050 tuners"
+       depends on I2C
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for the MT2032 / MT2050 tuner.
+
+config TUNER_XC2028
+       tristate "XCeive xc2028/xc3028 tuners"
+       depends on I2C && FW_LOADER
+       default m if VIDEO_TUNER_CUSTOMIZE
+       help
+         Say Y here to include support for the xc2028/xc3028 tuners.
+
+config DVB_TUNER_XC5000
+       tristate "Xceive XC5000 silicon tuner"
+       depends on I2C
+       default m if DVB_FE_CUSTOMISE
+       help
+         A driver for the silicon tuner XC5000 from Xceive.
+         This device is only used inside a SiP called togther with a
+         demodulator for now.
+
+endif # VIDEO_TUNER_CUSTOMIZE
diff --git a/drivers/media/common/tuners/Makefile b/drivers/media/common/tuners/Makefile
new file mode 100644 (file)
index 0000000..685ae64
--- /dev/null
@@ -0,0 +1,21 @@
+#
+# Makefile for common V4L/DVB tuners
+#
+
+tda18271-objs := tda18271-maps.o tda18271-common.o tda18271-fe.o
+
+obj-$(CONFIG_TUNER_XC2028) += tuner-xc2028.o
+obj-$(CONFIG_TUNER_SIMPLE) += tuner-simple.o
+# tuner-types will be merged into tuner-simple, in the future
+obj-$(CONFIG_TUNER_SIMPLE) += tuner-types.o
+obj-$(CONFIG_TUNER_MT20XX) += mt20xx.o
+obj-$(CONFIG_TUNER_TDA8290) += tda8290.o
+obj-$(CONFIG_TUNER_TEA5767) += tea5767.o
+obj-$(CONFIG_TUNER_TEA5761) += tea5761.o
+obj-$(CONFIG_TUNER_TDA9887) += tda9887.o
+obj-$(CONFIG_DVB_TDA827X) += tda827x.o
+obj-$(CONFIG_DVB_TDA18271) += tda18271.o
+obj-$(CONFIG_DVB_TUNER_XC5000) += xc5000.o
+
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
diff --git a/drivers/media/common/tuners/mt20xx.c b/drivers/media/common/tuners/mt20xx.c
new file mode 100644 (file)
index 0000000..fbcb282
--- /dev/null
@@ -0,0 +1,670 @@
+/*
+ * i2c tv tuner chip device driver
+ * controls microtune tuners, mt2032 + mt2050 at the moment.
+ *
+ * This "mt20xx" module was split apart from the original "tuner" module.
+ */
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/videodev.h>
+#include "tuner-i2c.h"
+#include "mt20xx.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+/* ---------------------------------------------------------------------- */
+
+static unsigned int optimize_vco  = 1;
+module_param(optimize_vco,      int, 0644);
+
+static unsigned int tv_antenna    = 1;
+module_param(tv_antenna,        int, 0644);
+
+static unsigned int radio_antenna;
+module_param(radio_antenna,     int, 0644);
+
+/* ---------------------------------------------------------------------- */
+
+#define MT2032 0x04
+#define MT2030 0x06
+#define MT2040 0x07
+#define MT2050 0x42
+
+static char *microtune_part[] = {
+       [ MT2030 ] = "MT2030",
+       [ MT2032 ] = "MT2032",
+       [ MT2040 ] = "MT2040",
+       [ MT2050 ] = "MT2050",
+};
+
+struct microtune_priv {
+       struct tuner_i2c_props i2c_props;
+
+       unsigned int xogc;
+       //unsigned int radio_if2;
+
+       u32 frequency;
+};
+
+static int microtune_release(struct dvb_frontend *fe)
+{
+       kfree(fe->tuner_priv);
+       fe->tuner_priv = NULL;
+
+       return 0;
+}
+
+static int microtune_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+       return 0;
+}
+
+// IsSpurInBand()?
+static int mt2032_spurcheck(struct dvb_frontend *fe,
+                           int f1, int f2, int spectrum_from,int spectrum_to)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int n1=1,n2,f;
+
+       f1=f1/1000; //scale to kHz to avoid 32bit overflows
+       f2=f2/1000;
+       spectrum_from/=1000;
+       spectrum_to/=1000;
+
+       tuner_dbg("spurcheck f1=%d f2=%d  from=%d to=%d\n",
+                 f1,f2,spectrum_from,spectrum_to);
+
+       do {
+           n2=-n1;
+           f=n1*(f1-f2);
+           do {
+               n2--;
+               f=f-f2;
+               tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
+
+               if( (f>spectrum_from) && (f<spectrum_to))
+                       tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
+           } while ( (f>(f2-spectrum_to)) || (n2>-5));
+           n1++;
+       } while (n1<5);
+
+       return 1;
+}
+
+static int mt2032_compute_freq(struct dvb_frontend *fe,
+                              unsigned int rfin,
+                              unsigned int if1, unsigned int if2,
+                              unsigned int spectrum_from,
+                              unsigned int spectrum_to,
+                              unsigned char *buf,
+                              int *ret_sel,
+                              unsigned int xogc) //all in Hz
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
+               desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
+
+       fref= 5250 *1000; //5.25MHz
+       desired_lo1=rfin+if1;
+
+       lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
+       lo1n=lo1/8;
+       lo1a=lo1-(lo1n*8);
+
+       s=rfin/1000/1000+1090;
+
+       if(optimize_vco) {
+               if(s>1890) sel=0;
+               else if(s>1720) sel=1;
+               else if(s>1530) sel=2;
+               else if(s>1370) sel=3;
+               else sel=4; // >1090
+       }
+       else {
+               if(s>1790) sel=0; // <1958
+               else if(s>1617) sel=1;
+               else if(s>1449) sel=2;
+               else if(s>1291) sel=3;
+               else sel=4; // >1090
+       }
+       *ret_sel=sel;
+
+       lo1freq=(lo1a+8*lo1n)*fref;
+
+       tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
+                 rfin,lo1,lo1n,lo1a,sel,lo1freq);
+
+       desired_lo2=lo1freq-rfin-if2;
+       lo2=(desired_lo2)/fref;
+       lo2n=lo2/8;
+       lo2a=lo2-(lo2n*8);
+       lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
+       lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;
+
+       tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
+                 rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
+
+       if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
+               tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
+                          lo1a, lo1n, lo2a,lo2n);
+               return(-1);
+       }
+
+       mt2032_spurcheck(fe, lo1freq, desired_lo2,  spectrum_from, spectrum_to);
+       // should recalculate lo1 (one step up/down)
+
+       // set up MT2032 register map for transfer over i2c
+       buf[0]=lo1n-1;
+       buf[1]=lo1a | (sel<<4);
+       buf[2]=0x86; // LOGC
+       buf[3]=0x0f; //reserved
+       buf[4]=0x1f;
+       buf[5]=(lo2n-1) | (lo2a<<5);
+       if(rfin >400*1000*1000)
+               buf[6]=0xe4;
+       else
+               buf[6]=0xf4; // set PKEN per rev 1.2
+       buf[7]=8+xogc;
+       buf[8]=0xc3; //reserved
+       buf[9]=0x4e; //reserved
+       buf[10]=0xec; //reserved
+       buf[11]=(lo2num&0xff);
+       buf[12]=(lo2num>>8) |0x80; // Lo2RST
+
+       return 0;
+}
+
+static int mt2032_check_lo_lock(struct dvb_frontend *fe)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int try,lock=0;
+       unsigned char buf[2];
+
+       for(try=0;try<10;try++) {
+               buf[0]=0x0e;
+               tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+               tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
+               tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
+               lock=buf[0] &0x06;
+
+               if (lock==6)
+                       break;
+
+               tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
+               udelay(1000);
+       }
+       return lock;
+}
+
+static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned char buf[2];
+       int tad1;
+
+       buf[0]=0x0f;
+       tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+       tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
+       tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
+       tad1=buf[0]&0x07;
+
+       if(tad1 ==0) return lock;
+       if(tad1 ==1) return lock;
+
+       if(tad1==2) {
+               if(sel==0)
+                       return lock;
+               else sel--;
+       }
+       else {
+               if(sel<4)
+                       sel++;
+               else
+                       return lock;
+       }
+
+       tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);
+
+       buf[0]=0x0f;
+       buf[1]=sel;
+       tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+       lock=mt2032_check_lo_lock(fe);
+       return lock;
+}
+
+
+static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,
+                              unsigned int if1, unsigned int if2,
+                              unsigned int from, unsigned int to)
+{
+       unsigned char buf[21];
+       int lint_try,ret,sel,lock=0;
+       struct microtune_priv *priv = fe->tuner_priv;
+
+       tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
+                 rfin,if1,if2,from,to);
+
+       buf[0]=0;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+       tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
+
+       buf[0]=0;
+       ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);
+       if (ret<0)
+               return;
+
+       // send only the relevant registers per Rev. 1.2
+       buf[0]=0;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);
+       buf[5]=5;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);
+       buf[11]=11;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);
+       if(ret!=3)
+               tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);
+
+       // wait for PLLs to lock (per manual), retry LINT if not.
+       for(lint_try=0; lint_try<2; lint_try++) {
+               lock=mt2032_check_lo_lock(fe);
+
+               if(optimize_vco)
+                       lock=mt2032_optimize_vco(fe,sel,lock);
+               if(lock==6) break;
+
+               tuner_dbg("mt2032: re-init PLLs by LINT\n");
+               buf[0]=7;
+               buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs
+               tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+               mdelay(10);
+               buf[1]=8+priv->xogc;
+               tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+       }
+
+       if (lock!=6)
+               tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");
+
+       buf[0]=2;
+       buf[1]=0x20; // LOGC for optimal phase noise
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+       if (ret!=2)
+               tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
+}
+
+
+static int mt2032_set_tv_freq(struct dvb_frontend *fe,
+                             struct analog_parameters *params)
+{
+       int if2,from,to;
+
+       // signal bandwidth and picture carrier
+       if (params->std & V4L2_STD_525_60) {
+               // NTSC
+               from = 40750*1000;
+               to   = 46750*1000;
+               if2  = 45750*1000;
+       } else {
+               // PAL
+               from = 32900*1000;
+               to   = 39900*1000;
+               if2  = 38900*1000;
+       }
+
+       mt2032_set_if_freq(fe, params->frequency*62500,
+                          1090*1000*1000, if2, from, to);
+
+       return 0;
+}
+
+static int mt2032_set_radio_freq(struct dvb_frontend *fe,
+                                struct analog_parameters *params)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int if2;
+
+       if (params->std & V4L2_STD_525_60) {
+               tuner_dbg("pinnacle ntsc\n");
+               if2 = 41300 * 1000;
+       } else {
+               tuner_dbg("pinnacle pal\n");
+               if2 = 33300 * 1000;
+       }
+
+       // per Manual for FM tuning: first if center freq. 1085 MHz
+       mt2032_set_if_freq(fe, params->frequency * 125 / 2,
+                          1085*1000*1000,if2,if2,if2);
+
+       return 0;
+}
+
+static int mt2032_set_params(struct dvb_frontend *fe,
+                            struct analog_parameters *params)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int ret = -EINVAL;
+
+       switch (params->mode) {
+       case V4L2_TUNER_RADIO:
+               ret = mt2032_set_radio_freq(fe, params);
+               priv->frequency = params->frequency * 125 / 2;
+               break;
+       case V4L2_TUNER_ANALOG_TV:
+       case V4L2_TUNER_DIGITAL_TV:
+               ret = mt2032_set_tv_freq(fe, params);
+               priv->frequency = params->frequency * 62500;
+               break;
+       }
+
+       return ret;
+}
+
+static struct dvb_tuner_ops mt2032_tuner_ops = {
+       .set_analog_params = mt2032_set_params,
+       .release           = microtune_release,
+       .get_frequency     = microtune_get_frequency,
+};
+
+// Initialization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
+static int mt2032_init(struct dvb_frontend *fe)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned char buf[21];
+       int ret,xogc,xok=0;
+
+       // Initialize Registers per spec.
+       buf[1]=2; // Index to register 2
+       buf[2]=0xff;
+       buf[3]=0x0f;
+       buf[4]=0x1f;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);
+
+       buf[5]=6; // Index register 6
+       buf[6]=0xe4;
+       buf[7]=0x8f;
+       buf[8]=0xc3;
+       buf[9]=0x4e;
+       buf[10]=0xec;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);
+
+       buf[12]=13;  // Index register 13
+       buf[13]=0x32;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);
+
+       // Adjust XOGC (register 7), wait for XOK
+       xogc=7;
+       do {
+               tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
+               mdelay(10);
+               buf[0]=0x0e;
+               tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+               tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
+               xok=buf[0]&0x01;
+               tuner_dbg("mt2032: xok = 0x%02x\n",xok);
+               if (xok == 1) break;
+
+               xogc--;
+               tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
+               if (xogc == 3) {
+                       xogc=4; // min. 4 per spec
+                       break;
+               }
+               buf[0]=0x07;
+               buf[1]=0x88 + xogc;
+               ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+               if (ret!=2)
+                       tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
+       } while (xok != 1 );
+       priv->xogc=xogc;
+
+       memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));
+
+       return(1);
+}
+
+static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned char buf[2];
+       int ret;
+
+       buf[0] = 6;
+       buf[1] = antenna ? 0x11 : 0x10;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
+       tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
+}
+
+static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned int if1=1218*1000*1000;
+       unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
+       int ret;
+       unsigned char buf[6];
+
+       tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
+                 freq,if1,if2);
+
+       f_lo1=freq+if1;
+       f_lo1=(f_lo1/1000000)*1000000;
+
+       f_lo2=f_lo1-freq-if2;
+       f_lo2=(f_lo2/50000)*50000;
+
+       lo1=f_lo1/4000000;
+       lo2=f_lo2/4000000;
+
+       f_lo1_modulo= f_lo1-(lo1*4000000);
+       f_lo2_modulo= f_lo2-(lo2*4000000);
+
+       num1=4*f_lo1_modulo/4000000;
+       num2=4096*(f_lo2_modulo/1000)/4000;
+
+       // todo spurchecks
+
+       div1a=(lo1/12)-1;
+       div1b=lo1-(div1a+1)*12;
+
+       div2a=(lo2/8)-1;
+       div2b=lo2-(div2a+1)*8;
+
+       if (debug > 1) {
+               tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
+               tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
+                         num1,num2,div1a,div1b,div2a,div2b);
+       }
+
+       buf[0]=1;
+       buf[1]= 4*div1b + num1;
+       if(freq<275*1000*1000) buf[1] = buf[1]|0x80;
+
+       buf[2]=div1a;
+       buf[3]=32*div2b + num2/256;
+       buf[4]=num2-(num2/256)*256;
+       buf[5]=div2a;
+       if(num2!=0) buf[5]=buf[5]|0x40;
+
+       if (debug > 1) {
+               int i;
+               tuner_dbg("bufs is: ");
+               for(i=0;i<6;i++)
+                       printk("%x ",buf[i]);
+               printk("\n");
+       }
+
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);
+       if (ret!=6)
+               tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
+}
+
+static int mt2050_set_tv_freq(struct dvb_frontend *fe,
+                             struct analog_parameters *params)
+{
+       unsigned int if2;
+
+       if (params->std & V4L2_STD_525_60) {
+               // NTSC
+               if2 = 45750*1000;
+       } else {
+               // PAL
+               if2 = 38900*1000;
+       }
+       if (V4L2_TUNER_DIGITAL_TV == params->mode) {
+               // DVB (pinnacle 300i)
+               if2 = 36150*1000;
+       }
+       mt2050_set_if_freq(fe, params->frequency*62500, if2);
+       mt2050_set_antenna(fe, tv_antenna);
+
+       return 0;
+}
+
+static int mt2050_set_radio_freq(struct dvb_frontend *fe,
+                                struct analog_parameters *params)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int if2;
+
+       if (params->std & V4L2_STD_525_60) {
+               tuner_dbg("pinnacle ntsc\n");
+               if2 = 41300 * 1000;
+       } else {
+               tuner_dbg("pinnacle pal\n");
+               if2 = 33300 * 1000;
+       }
+
+       mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);
+       mt2050_set_antenna(fe, radio_antenna);
+
+       return 0;
+}
+
+static int mt2050_set_params(struct dvb_frontend *fe,
+                            struct analog_parameters *params)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       int ret = -EINVAL;
+
+       switch (params->mode) {
+       case V4L2_TUNER_RADIO:
+               ret = mt2050_set_radio_freq(fe, params);
+               priv->frequency = params->frequency * 125 / 2;
+               break;
+       case V4L2_TUNER_ANALOG_TV:
+       case V4L2_TUNER_DIGITAL_TV:
+               ret = mt2050_set_tv_freq(fe, params);
+               priv->frequency = params->frequency * 62500;
+               break;
+       }
+
+       return ret;
+}
+
+static struct dvb_tuner_ops mt2050_tuner_ops = {
+       .set_analog_params = mt2050_set_params,
+       .release           = microtune_release,
+       .get_frequency     = microtune_get_frequency,
+};
+
+static int mt2050_init(struct dvb_frontend *fe)
+{
+       struct microtune_priv *priv = fe->tuner_priv;
+       unsigned char buf[2];
+       int ret;
+
+       buf[0]=6;
+       buf[1]=0x10;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); //  power
+
+       buf[0]=0x0f;
+       buf[1]=0x0f;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo
+
+       buf[0]=0x0d;
+       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+       tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
+
+       tuner_dbg("mt2050: sro is %x\n",buf[0]);
+
+       memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));
+
+       return 0;
+}
+
+struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
+                                     struct i2c_adapter* i2c_adap,
+                                     u8 i2c_addr)
+{
+       struct microtune_priv *priv = NULL;
+       char *name;
+       unsigned char buf[21];
+       int company_code;
+
+       priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+       fe->tuner_priv = priv;
+
+       priv->i2c_props.addr = i2c_addr;
+       priv->i2c_props.adap = i2c_adap;
+       priv->i2c_props.name = "mt20xx";
+
+       //priv->radio_if2 = 10700 * 1000;       /* 10.7MHz - FM radio */
+
+       memset(buf,0,sizeof(buf));
+
+       name = "unknown";
+
+       tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
+       tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
+       if (debug) {
+               int i;
+               tuner_dbg("MT20xx hexdump:");
+               for(i=0;i<21;i++) {
+                       printk(" %02x",buf[i]);
+                       if(((i+1)%8)==0) printk(" ");
+               }
+               printk("\n");
+       }
+       company_code = buf[0x11] << 8 | buf[0x12];
+       tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
+                  company_code,buf[0x13],buf[0x14]);
+
+
+       if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
+           NULL != microtune_part[buf[0x13]])
+               name = microtune_part[buf[0x13]];
+       switch (buf[0x13]) {
+       case MT2032:
+               mt2032_init(fe);
+               break;
+       case MT2050:
+               mt2050_init(fe);
+               break;
+       default:
+               tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
+                          name);
+               return NULL;
+       }
+
+       strlcpy(fe->ops.tuner_ops.info.name, name,
+               sizeof(fe->ops.tuner_ops.info.name));
+       tuner_info("microtune %s found, OK\n",name);
+       return fe;
+}
+
+EXPORT_SYMBOL_GPL(microtune_attach);
+
+MODULE_DESCRIPTION("Microtune tuner driver");
+MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
+MODULE_LICENSE("GPL");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/mt20xx.h b/drivers/media/common/tuners/mt20xx.h
new file mode 100644 (file)
index 0000000..aa848e1
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __MT20XX_H__
+#define __MT20XX_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+#if defined(CONFIG_TUNER_MT20XX) || (defined(CONFIG_TUNER_MT20XX_MODULE) && defined(MODULE))
+extern struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
+                                            struct i2c_adapter* i2c_adap,
+                                            u8 i2c_addr);
+#else
+static inline struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
+                                            struct i2c_adapter* i2c_adap,
+                                            u8 i2c_addr)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __MT20XX_H__ */
diff --git a/drivers/media/common/tuners/tda18271-common.c b/drivers/media/common/tuners/tda18271-common.c
new file mode 100644 (file)
index 0000000..e27a762
--- /dev/null
@@ -0,0 +1,666 @@
+/*
+    tda18271-common.c - driver for the Philips / NXP TDA18271 silicon tuner
+
+    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "tda18271-priv.h"
+
+static int tda18271_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       enum tda18271_i2c_gate gate;
+       int ret = 0;
+
+       switch (priv->gate) {
+       case TDA18271_GATE_DIGITAL:
+       case TDA18271_GATE_ANALOG:
+               gate = priv->gate;
+               break;
+       case TDA18271_GATE_AUTO:
+       default:
+               switch (priv->mode) {
+               case TDA18271_DIGITAL:
+                       gate = TDA18271_GATE_DIGITAL;
+                       break;
+               case TDA18271_ANALOG:
+               default:
+                       gate = TDA18271_GATE_ANALOG;
+                       break;
+               }
+       }
+
+       switch (gate) {
+       case TDA18271_GATE_ANALOG:
+               if (fe->ops.analog_ops.i2c_gate_ctrl)
+                       ret = fe->ops.analog_ops.i2c_gate_ctrl(fe, enable);
+               break;
+       case TDA18271_GATE_DIGITAL:
+               if (fe->ops.i2c_gate_ctrl)
+                       ret = fe->ops.i2c_gate_ctrl(fe, enable);
+               break;
+       default:
+               ret = -EINVAL;
+               break;
+       }
+
+       return ret;
+};
+
+/*---------------------------------------------------------------------*/
+
+static void tda18271_dump_regs(struct dvb_frontend *fe, int extended)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       tda_reg("=== TDA18271 REG DUMP ===\n");
+       tda_reg("ID_BYTE            = 0x%02x\n", 0xff & regs[R_ID]);
+       tda_reg("THERMO_BYTE        = 0x%02x\n", 0xff & regs[R_TM]);
+       tda_reg("POWER_LEVEL_BYTE   = 0x%02x\n", 0xff & regs[R_PL]);
+       tda_reg("EASY_PROG_BYTE_1   = 0x%02x\n", 0xff & regs[R_EP1]);
+       tda_reg("EASY_PROG_BYTE_2   = 0x%02x\n", 0xff & regs[R_EP2]);
+       tda_reg("EASY_PROG_BYTE_3   = 0x%02x\n", 0xff & regs[R_EP3]);
+       tda_reg("EASY_PROG_BYTE_4   = 0x%02x\n", 0xff & regs[R_EP4]);
+       tda_reg("EASY_PROG_BYTE_5   = 0x%02x\n", 0xff & regs[R_EP5]);
+       tda_reg("CAL_POST_DIV_BYTE  = 0x%02x\n", 0xff & regs[R_CPD]);
+       tda_reg("CAL_DIV_BYTE_1     = 0x%02x\n", 0xff & regs[R_CD1]);
+       tda_reg("CAL_DIV_BYTE_2     = 0x%02x\n", 0xff & regs[R_CD2]);
+       tda_reg("CAL_DIV_BYTE_3     = 0x%02x\n", 0xff & regs[R_CD3]);
+       tda_reg("MAIN_POST_DIV_BYTE = 0x%02x\n", 0xff & regs[R_MPD]);
+       tda_reg("MAIN_DIV_BYTE_1    = 0x%02x\n", 0xff & regs[R_MD1]);
+       tda_reg("MAIN_DIV_BYTE_2    = 0x%02x\n", 0xff & regs[R_MD2]);
+       tda_reg("MAIN_DIV_BYTE_3    = 0x%02x\n", 0xff & regs[R_MD3]);
+
+       /* only dump extended regs if DBG_ADV is set */
+       if (!(tda18271_debug & DBG_ADV))
+               return;
+
+       /* W indicates write-only registers.
+        * Register dump for write-only registers shows last value written. */
+
+       tda_reg("EXTENDED_BYTE_1    = 0x%02x\n", 0xff & regs[R_EB1]);
+       tda_reg("EXTENDED_BYTE_2    = 0x%02x\n", 0xff & regs[R_EB2]);
+       tda_reg("EXTENDED_BYTE_3    = 0x%02x\n", 0xff & regs[R_EB3]);
+       tda_reg("EXTENDED_BYTE_4    = 0x%02x\n", 0xff & regs[R_EB4]);
+       tda_reg("EXTENDED_BYTE_5    = 0x%02x\n", 0xff & regs[R_EB5]);
+       tda_reg("EXTENDED_BYTE_6    = 0x%02x\n", 0xff & regs[R_EB6]);
+       tda_reg("EXTENDED_BYTE_7    = 0x%02x\n", 0xff & regs[R_EB7]);
+       tda_reg("EXTENDED_BYTE_8    = 0x%02x\n", 0xff & regs[R_EB8]);
+       tda_reg("EXTENDED_BYTE_9  W = 0x%02x\n", 0xff & regs[R_EB9]);
+       tda_reg("EXTENDED_BYTE_10   = 0x%02x\n", 0xff & regs[R_EB10]);
+       tda_reg("EXTENDED_BYTE_11   = 0x%02x\n", 0xff & regs[R_EB11]);
+       tda_reg("EXTENDED_BYTE_12   = 0x%02x\n", 0xff & regs[R_EB12]);
+       tda_reg("EXTENDED_BYTE_13   = 0x%02x\n", 0xff & regs[R_EB13]);
+       tda_reg("EXTENDED_BYTE_14   = 0x%02x\n", 0xff & regs[R_EB14]);
+       tda_reg("EXTENDED_BYTE_15   = 0x%02x\n", 0xff & regs[R_EB15]);
+       tda_reg("EXTENDED_BYTE_16 W = 0x%02x\n", 0xff & regs[R_EB16]);
+       tda_reg("EXTENDED_BYTE_17 W = 0x%02x\n", 0xff & regs[R_EB17]);
+       tda_reg("EXTENDED_BYTE_18   = 0x%02x\n", 0xff & regs[R_EB18]);
+       tda_reg("EXTENDED_BYTE_19 W = 0x%02x\n", 0xff & regs[R_EB19]);
+       tda_reg("EXTENDED_BYTE_20 W = 0x%02x\n", 0xff & regs[R_EB20]);
+       tda_reg("EXTENDED_BYTE_21   = 0x%02x\n", 0xff & regs[R_EB21]);
+       tda_reg("EXTENDED_BYTE_22   = 0x%02x\n", 0xff & regs[R_EB22]);
+       tda_reg("EXTENDED_BYTE_23   = 0x%02x\n", 0xff & regs[R_EB23]);
+}
+
+int tda18271_read_regs(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       unsigned char buf = 0x00;
+       int ret;
+       struct i2c_msg msg[] = {
+               { .addr = priv->i2c_props.addr, .flags = 0,
+                 .buf = &buf, .len = 1 },
+               { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
+                 .buf = regs, .len = 16 }
+       };
+
+       tda18271_i2c_gate_ctrl(fe, 1);
+
+       /* read all registers */
+       ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
+
+       tda18271_i2c_gate_ctrl(fe, 0);
+
+       if (ret != 2)
+               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
+
+       if (tda18271_debug & DBG_REG)
+               tda18271_dump_regs(fe, 0);
+
+       return (ret == 2 ? 0 : ret);
+}
+
+int tda18271_read_extended(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       unsigned char regdump[TDA18271_NUM_REGS];
+       unsigned char buf = 0x00;
+       int ret, i;
+       struct i2c_msg msg[] = {
+               { .addr = priv->i2c_props.addr, .flags = 0,
+                 .buf = &buf, .len = 1 },
+               { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
+                 .buf = regdump, .len = TDA18271_NUM_REGS }
+       };
+
+       tda18271_i2c_gate_ctrl(fe, 1);
+
+       /* read all registers */
+       ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
+
+       tda18271_i2c_gate_ctrl(fe, 0);
+
+       if (ret != 2)
+               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
+
+       for (i = 0; i < TDA18271_NUM_REGS; i++) {
+               /* don't update write-only registers */
+               if ((i != R_EB9)  &&
+                   (i != R_EB16) &&
+                   (i != R_EB17) &&
+                   (i != R_EB19) &&
+                   (i != R_EB20))
+               regs[i] = regdump[i];
+       }
+
+       if (tda18271_debug & DBG_REG)
+               tda18271_dump_regs(fe, 1);
+
+       return (ret == 2 ? 0 : ret);
+}
+
+int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       unsigned char buf[TDA18271_NUM_REGS + 1];
+       struct i2c_msg msg = { .addr = priv->i2c_props.addr, .flags = 0,
+                              .buf = buf, .len = len + 1 };
+       int i, ret;
+
+       BUG_ON((len == 0) || (idx + len > sizeof(buf)));
+
+       buf[0] = idx;
+       for (i = 1; i <= len; i++)
+               buf[i] = regs[idx - 1 + i];
+
+       tda18271_i2c_gate_ctrl(fe, 1);
+
+       /* write registers */
+       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
+
+       tda18271_i2c_gate_ctrl(fe, 0);
+
+       if (ret != 1)
+               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
+
+       return (ret == 1 ? 0 : ret);
+}
+
+/*---------------------------------------------------------------------*/
+
+int tda18271_charge_pump_source(struct dvb_frontend *fe,
+                               enum tda18271_pll pll, int force)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       int r_cp = (pll == TDA18271_CAL_PLL) ? R_EB7 : R_EB4;
+
+       regs[r_cp] &= ~0x20;
+       regs[r_cp] |= ((force & 1) << 5);
+       tda18271_write_regs(fe, r_cp, 1);
+
+       return 0;
+}
+
+int tda18271_init_regs(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       tda_dbg("initializing registers for device @ %d-%04x\n",
+               i2c_adapter_id(priv->i2c_props.adap),
+               priv->i2c_props.addr);
+
+       /* initialize registers */
+       switch (priv->id) {
+       case TDA18271HDC1:
+               regs[R_ID]   = 0x83;
+               break;
+       case TDA18271HDC2:
+               regs[R_ID]   = 0x84;
+               break;
+       };
+
+       regs[R_TM]   = 0x08;
+       regs[R_PL]   = 0x80;
+       regs[R_EP1]  = 0xc6;
+       regs[R_EP2]  = 0xdf;
+       regs[R_EP3]  = 0x16;
+       regs[R_EP4]  = 0x60;
+       regs[R_EP5]  = 0x80;
+       regs[R_CPD]  = 0x80;
+       regs[R_CD1]  = 0x00;
+       regs[R_CD2]  = 0x00;
+       regs[R_CD3]  = 0x00;
+       regs[R_MPD]  = 0x00;
+       regs[R_MD1]  = 0x00;
+       regs[R_MD2]  = 0x00;
+       regs[R_MD3]  = 0x00;
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               regs[R_EB1]  = 0xff;
+               break;
+       case TDA18271HDC2:
+               regs[R_EB1]  = 0xfc;
+               break;
+       };
+
+       regs[R_EB2]  = 0x01;
+       regs[R_EB3]  = 0x84;
+       regs[R_EB4]  = 0x41;
+       regs[R_EB5]  = 0x01;
+       regs[R_EB6]  = 0x84;
+       regs[R_EB7]  = 0x40;
+       regs[R_EB8]  = 0x07;
+       regs[R_EB9]  = 0x00;
+       regs[R_EB10] = 0x00;
+       regs[R_EB11] = 0x96;
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               regs[R_EB12] = 0x0f;
+               break;
+       case TDA18271HDC2:
+               regs[R_EB12] = 0x33;
+               break;
+       };
+
+       regs[R_EB13] = 0xc1;
+       regs[R_EB14] = 0x00;
+       regs[R_EB15] = 0x8f;
+       regs[R_EB16] = 0x00;
+       regs[R_EB17] = 0x00;
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               regs[R_EB18] = 0x00;
+               break;
+       case TDA18271HDC2:
+               regs[R_EB18] = 0x8c;
+               break;
+       };
+
+       regs[R_EB19] = 0x00;
+       regs[R_EB20] = 0x20;
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               regs[R_EB21] = 0x33;
+               break;
+       case TDA18271HDC2:
+               regs[R_EB21] = 0xb3;
+               break;
+       };
+
+       regs[R_EB22] = 0x48;
+       regs[R_EB23] = 0xb0;
+
+       if (priv->small_i2c) {
+               tda18271_write_regs(fe, 0x00, 0x10);
+               tda18271_write_regs(fe, 0x10, 0x10);
+               tda18271_write_regs(fe, 0x20, 0x07);
+       } else
+               tda18271_write_regs(fe, 0x00, TDA18271_NUM_REGS);
+
+       /* setup agc1 gain */
+       regs[R_EB17] = 0x00;
+       tda18271_write_regs(fe, R_EB17, 1);
+       regs[R_EB17] = 0x03;
+       tda18271_write_regs(fe, R_EB17, 1);
+       regs[R_EB17] = 0x43;
+       tda18271_write_regs(fe, R_EB17, 1);
+       regs[R_EB17] = 0x4c;
+       tda18271_write_regs(fe, R_EB17, 1);
+
+       /* setup agc2 gain */
+       if ((priv->id) == TDA18271HDC1) {
+               regs[R_EB20] = 0xa0;
+               tda18271_write_regs(fe, R_EB20, 1);
+               regs[R_EB20] = 0xa7;
+               tda18271_write_regs(fe, R_EB20, 1);
+               regs[R_EB20] = 0xe7;
+               tda18271_write_regs(fe, R_EB20, 1);
+               regs[R_EB20] = 0xec;
+               tda18271_write_regs(fe, R_EB20, 1);
+       }
+
+       /* image rejection calibration */
+
+       /* low-band */
+       regs[R_EP3] = 0x1f;
+       regs[R_EP4] = 0x66;
+       regs[R_EP5] = 0x81;
+       regs[R_CPD] = 0xcc;
+       regs[R_CD1] = 0x6c;
+       regs[R_CD2] = 0x00;
+       regs[R_CD3] = 0x00;
+       regs[R_MPD] = 0xcd;
+       regs[R_MD1] = 0x77;
+       regs[R_MD2] = 0x08;
+       regs[R_MD3] = 0x00;
+
+       tda18271_write_regs(fe, R_EP3, 11);
+
+       if ((priv->id) == TDA18271HDC2) {
+               /* main pll cp source on */
+               tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
+               msleep(1);
+
+               /* main pll cp source off */
+               tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
+       }
+
+       msleep(5); /* pll locking */
+
+       /* launch detector */
+       tda18271_write_regs(fe, R_EP1, 1);
+       msleep(5); /* wanted low measurement */
+
+       regs[R_EP5] = 0x85;
+       regs[R_CPD] = 0xcb;
+       regs[R_CD1] = 0x66;
+       regs[R_CD2] = 0x70;
+
+       tda18271_write_regs(fe, R_EP3, 7);
+       msleep(5); /* pll locking */
+
+       /* launch optimization algorithm */
+       tda18271_write_regs(fe, R_EP2, 1);
+       msleep(30); /* image low optimization completion */
+
+       /* mid-band */
+       regs[R_EP5] = 0x82;
+       regs[R_CPD] = 0xa8;
+       regs[R_CD2] = 0x00;
+       regs[R_MPD] = 0xa9;
+       regs[R_MD1] = 0x73;
+       regs[R_MD2] = 0x1a;
+
+       tda18271_write_regs(fe, R_EP3, 11);
+       msleep(5); /* pll locking */
+
+       /* launch detector */
+       tda18271_write_regs(fe, R_EP1, 1);
+       msleep(5); /* wanted mid measurement */
+
+       regs[R_EP5] = 0x86;
+       regs[R_CPD] = 0xa8;
+       regs[R_CD1] = 0x66;
+       regs[R_CD2] = 0xa0;
+
+       tda18271_write_regs(fe, R_EP3, 7);
+       msleep(5); /* pll locking */
+
+       /* launch optimization algorithm */
+       tda18271_write_regs(fe, R_EP2, 1);
+       msleep(30); /* image mid optimization completion */
+
+       /* high-band */
+       regs[R_EP5] = 0x83;
+       regs[R_CPD] = 0x98;
+       regs[R_CD1] = 0x65;
+       regs[R_CD2] = 0x00;
+       regs[R_MPD] = 0x99;
+       regs[R_MD1] = 0x71;
+       regs[R_MD2] = 0xcd;
+
+       tda18271_write_regs(fe, R_EP3, 11);
+       msleep(5); /* pll locking */
+
+       /* launch detector */
+       tda18271_write_regs(fe, R_EP1, 1);
+       msleep(5); /* wanted high measurement */
+
+       regs[R_EP5] = 0x87;
+       regs[R_CD1] = 0x65;
+       regs[R_CD2] = 0x50;
+
+       tda18271_write_regs(fe, R_EP3, 7);
+       msleep(5); /* pll locking */
+
+       /* launch optimization algorithm */
+       tda18271_write_regs(fe, R_EP2, 1);
+       msleep(30); /* image high optimization completion */
+
+       /* return to normal mode */
+       regs[R_EP4] = 0x64;
+       tda18271_write_regs(fe, R_EP4, 1);
+
+       /* synchronize */
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       return 0;
+}
+
+/*---------------------------------------------------------------------*/
+
+/*
+ *  Standby modes, EP3 [7:5]
+ *
+ *  | SM  || SM_LT || SM_XT || mode description
+ *  |=====\\=======\\=======\\===================================
+ *  |  0  ||   0   ||   0   || normal mode
+ *  |-----||-------||-------||-----------------------------------
+ *  |     ||       ||       || standby mode w/ slave tuner output
+ *  |  1  ||   0   ||   0   || & loop thru & xtal oscillator on
+ *  |-----||-------||-------||-----------------------------------
+ *  |  1  ||   1   ||   0   || standby mode w/ xtal oscillator on
+ *  |-----||-------||-------||-----------------------------------
+ *  |  1  ||   1   ||   1   || power off
+ *
+ */
+
+int tda18271_set_standby_mode(struct dvb_frontend *fe,
+                             int sm, int sm_lt, int sm_xt)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       tda_dbg("sm = %d, sm_lt = %d, sm_xt = %d\n", sm, sm_lt, sm_xt);
+
+       regs[R_EP3]  &= ~0xe0; /* clear sm, sm_lt, sm_xt */
+       regs[R_EP3]  |= sm    ? (1 << 7) : 0 |
+                       sm_lt ? (1 << 6) : 0 |
+                       sm_xt ? (1 << 5) : 0;
+
+       tda18271_write_regs(fe, R_EP3, 1);
+
+       return 0;
+}
+
+/*---------------------------------------------------------------------*/
+
+int tda18271_calc_main_pll(struct dvb_frontend *fe, u32 freq)
+{
+       /* sets main post divider & divider bytes, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 d, pd;
+       u32 div;
+
+       int ret = tda18271_lookup_pll_map(fe, MAIN_PLL, &freq, &pd, &d);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_MPD]   = (0x77 & pd);
+
+       switch (priv->mode) {
+       case TDA18271_ANALOG:
+               regs[R_MPD]  &= ~0x08;
+               break;
+       case TDA18271_DIGITAL:
+               regs[R_MPD]  |=  0x08;
+               break;
+       }
+
+       div =  ((d * (freq / 1000)) << 7) / 125;
+
+       regs[R_MD1]   = 0x7f & (div >> 16);
+       regs[R_MD2]   = 0xff & (div >> 8);
+       regs[R_MD3]   = 0xff & div;
+fail:
+       return ret;
+}
+
+int tda18271_calc_cal_pll(struct dvb_frontend *fe, u32 freq)
+{
+       /* sets cal post divider & divider bytes, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 d, pd;
+       u32 div;
+
+       int ret = tda18271_lookup_pll_map(fe, CAL_PLL, &freq, &pd, &d);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_CPD]   = pd;
+
+       div =  ((d * (freq / 1000)) << 7) / 125;
+
+       regs[R_CD1]   = 0x7f & (div >> 16);
+       regs[R_CD2]   = 0xff & (div >> 8);
+       regs[R_CD3]   = 0xff & div;
+fail:
+       return ret;
+}
+
+/*---------------------------------------------------------------------*/
+
+int tda18271_calc_bp_filter(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets bp filter bits, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       int ret = tda18271_lookup_map(fe, BP_FILTER, freq, &val);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_EP1]  &= ~0x07; /* clear bp filter bits */
+       regs[R_EP1]  |= (0x07 & val);
+fail:
+       return ret;
+}
+
+int tda18271_calc_km(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets K & M bits, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       int ret = tda18271_lookup_map(fe, RF_CAL_KMCO, freq, &val);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_EB13] &= ~0x7c; /* clear k & m bits */
+       regs[R_EB13] |= (0x7c & val);
+fail:
+       return ret;
+}
+
+int tda18271_calc_rf_band(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets rf band bits, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       int ret = tda18271_lookup_map(fe, RF_BAND, freq, &val);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_EP2]  &= ~0xe0; /* clear rf band bits */
+       regs[R_EP2]  |= (0xe0 & (val << 5));
+fail:
+       return ret;
+}
+
+int tda18271_calc_gain_taper(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets gain taper bits, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       int ret = tda18271_lookup_map(fe, GAIN_TAPER, freq, &val);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_EP2]  &= ~0x1f; /* clear gain taper bits */
+       regs[R_EP2]  |= (0x1f & val);
+fail:
+       return ret;
+}
+
+int tda18271_calc_ir_measure(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets IR Meas bits, but does not write them */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       int ret = tda18271_lookup_map(fe, IR_MEASURE, freq, &val);
+       if (ret < 0)
+               goto fail;
+
+       regs[R_EP5] &= ~0x07;
+       regs[R_EP5] |= (0x07 & val);
+fail:
+       return ret;
+}
+
+int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq)
+{
+       /* sets rf cal byte (RFC_Cprog), but does not write it */
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u8 val;
+
+       tda18271_lookup_map(fe, RF_CAL, freq, &val);
+
+       regs[R_EB14] = val;
+
+       return 0;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda18271-fe.c b/drivers/media/common/tuners/tda18271-fe.c
new file mode 100644 (file)
index 0000000..b262100
--- /dev/null
@@ -0,0 +1,1153 @@
+/*
+    tda18271-fe.c - driver for the Philips / NXP TDA18271 silicon tuner
+
+    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <linux/delay.h>
+#include <linux/videodev2.h>
+#include "tda18271-priv.h"
+
+int tda18271_debug;
+module_param_named(debug, tda18271_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debug level "
+                "(info=1, map=2, reg=4, adv=8, cal=16 (or-able))");
+
+static int tda18271_cal_on_startup;
+module_param_named(cal, tda18271_cal_on_startup, int, 0644);
+MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup");
+
+static DEFINE_MUTEX(tda18271_list_mutex);
+static LIST_HEAD(hybrid_tuner_instance_list);
+
+/*---------------------------------------------------------------------*/
+
+static inline int charge_pump_source(struct dvb_frontend *fe, int force)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       return tda18271_charge_pump_source(fe,
+                                          (priv->role == TDA18271_SLAVE) ?
+                                          TDA18271_CAL_PLL :
+                                          TDA18271_MAIN_PLL, force);
+}
+
+static int tda18271_channel_configuration(struct dvb_frontend *fe,
+                                         struct tda18271_std_map_item *map,
+                                         u32 freq, u32 bw)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u32 N;
+
+       /* update TV broadcast parameters */
+
+       /* set standard */
+       regs[R_EP3]  &= ~0x1f; /* clear std bits */
+       regs[R_EP3]  |= (map->agc_mode << 3) | map->std;
+
+       /* set rfagc to high speed mode */
+       regs[R_EP3] &= ~0x04;
+
+       /* set cal mode to normal */
+       regs[R_EP4]  &= ~0x03;
+
+       /* update IF output level & IF notch frequency */
+       regs[R_EP4]  &= ~0x1c; /* clear if level bits */
+       regs[R_EP4]  |= (map->if_lvl << 2);
+
+       switch (priv->mode) {
+       case TDA18271_ANALOG:
+               regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
+               break;
+       case TDA18271_DIGITAL:
+               regs[R_MPD]  |= 0x80; /* IF notch = 1 */
+               break;
+       }
+
+       /* update FM_RFn */
+       regs[R_EP4]  &= ~0x80;
+       regs[R_EP4]  |= map->fm_rfn << 7;
+
+       /* update rf top / if top */
+       regs[R_EB22]  = 0x00;
+       regs[R_EB22] |= map->rfagc_top;
+       tda18271_write_regs(fe, R_EB22, 1);
+
+       /* --------------------------------------------------------------- */
+
+       /* disable Power Level Indicator */
+       regs[R_EP1]  |= 0x40;
+
+       /* frequency dependent parameters */
+
+       tda18271_calc_ir_measure(fe, &freq);
+
+       tda18271_calc_bp_filter(fe, &freq);
+
+       tda18271_calc_rf_band(fe, &freq);
+
+       tda18271_calc_gain_taper(fe, &freq);
+
+       /* --------------------------------------------------------------- */
+
+       /* dual tuner and agc1 extra configuration */
+
+       switch (priv->role) {
+       case TDA18271_MASTER:
+               regs[R_EB1]  |= 0x04; /* main vco */
+               break;
+       case TDA18271_SLAVE:
+               regs[R_EB1]  &= ~0x04; /* cal vco */
+               break;
+       }
+
+       /* agc1 always active */
+       regs[R_EB1]  &= ~0x02;
+
+       /* agc1 has priority on agc2 */
+       regs[R_EB1]  &= ~0x01;
+
+       tda18271_write_regs(fe, R_EB1, 1);
+
+       /* --------------------------------------------------------------- */
+
+       N = map->if_freq * 1000 + freq;
+
+       switch (priv->role) {
+       case TDA18271_MASTER:
+               tda18271_calc_main_pll(fe, N);
+               tda18271_write_regs(fe, R_MPD, 4);
+               break;
+       case TDA18271_SLAVE:
+               tda18271_calc_cal_pll(fe, N);
+               tda18271_write_regs(fe, R_CPD, 4);
+
+               regs[R_MPD] = regs[R_CPD] & 0x7f;
+               tda18271_write_regs(fe, R_MPD, 1);
+               break;
+       }
+
+       tda18271_write_regs(fe, R_TM, 7);
+
+       /* force charge pump source */
+       charge_pump_source(fe, 1);
+
+       msleep(1);
+
+       /* return pll to normal operation */
+       charge_pump_source(fe, 0);
+
+       msleep(20);
+
+       /* set rfagc to normal speed mode */
+       if (map->fm_rfn)
+               regs[R_EP3] &= ~0x04;
+       else
+               regs[R_EP3] |= 0x04;
+       tda18271_write_regs(fe, R_EP3, 1);
+
+       return 0;
+}
+
+static int tda18271_read_thermometer(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       int tm;
+
+       /* switch thermometer on */
+       regs[R_TM]   |= 0x10;
+       tda18271_write_regs(fe, R_TM, 1);
+
+       /* read thermometer info */
+       tda18271_read_regs(fe);
+
+       if ((((regs[R_TM] & 0x0f) == 0x00) && ((regs[R_TM] & 0x20) == 0x20)) ||
+           (((regs[R_TM] & 0x0f) == 0x08) && ((regs[R_TM] & 0x20) == 0x00))) {
+
+               if ((regs[R_TM] & 0x20) == 0x20)
+                       regs[R_TM] &= ~0x20;
+               else
+                       regs[R_TM] |= 0x20;
+
+               tda18271_write_regs(fe, R_TM, 1);
+
+               msleep(10); /* temperature sensing */
+
+               /* read thermometer info */
+               tda18271_read_regs(fe);
+       }
+
+       tm = tda18271_lookup_thermometer(fe);
+
+       /* switch thermometer off */
+       regs[R_TM]   &= ~0x10;
+       tda18271_write_regs(fe, R_TM, 1);
+
+       /* set CAL mode to normal */
+       regs[R_EP4]  &= ~0x03;
+       tda18271_write_regs(fe, R_EP4, 1);
+
+       return tm;
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
+                                                    u32 freq)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
+       unsigned char *regs = priv->tda18271_regs;
+       int tm_current, rfcal_comp, approx, i;
+       u8 dc_over_dt, rf_tab;
+
+       /* power up */
+       tda18271_set_standby_mode(fe, 0, 0, 0);
+
+       /* read die current temperature */
+       tm_current = tda18271_read_thermometer(fe);
+
+       /* frequency dependent parameters */
+
+       tda18271_calc_rf_cal(fe, &freq);
+       rf_tab = regs[R_EB14];
+
+       i = tda18271_lookup_rf_band(fe, &freq, NULL);
+       if (i < 0)
+               return -EINVAL;
+
+       if ((0 == map[i].rf3) || (freq / 1000 < map[i].rf2)) {
+               approx = map[i].rf_a1 *
+                       (freq / 1000 - map[i].rf1) + map[i].rf_b1 + rf_tab;
+       } else {
+               approx = map[i].rf_a2 *
+                       (freq / 1000 - map[i].rf2) + map[i].rf_b2 + rf_tab;
+       }
+
+       if (approx < 0)
+               approx = 0;
+       if (approx > 255)
+               approx = 255;
+
+       tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt);
+
+       /* calculate temperature compensation */
+       rfcal_comp = dc_over_dt * (tm_current - priv->tm_rfcal);
+
+       regs[R_EB14] = approx + rfcal_comp;
+       tda18271_write_regs(fe, R_EB14, 1);
+
+       return 0;
+}
+
+static int tda18271_por(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       /* power up detector 1 */
+       regs[R_EB12] &= ~0x20;
+       tda18271_write_regs(fe, R_EB12, 1);
+
+       regs[R_EB18] &= ~0x80; /* turn agc1 loop on */
+       regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
+       tda18271_write_regs(fe, R_EB18, 1);
+
+       regs[R_EB21] |= 0x03; /* set agc2_gain to -6 dB */
+
+       /* POR mode */
+       tda18271_set_standby_mode(fe, 1, 0, 0);
+
+       /* disable 1.5 MHz low pass filter */
+       regs[R_EB23] &= ~0x04; /* forcelp_fc2_en = 0 */
+       regs[R_EB23] &= ~0x02; /* XXX: lp_fc[2] = 0 */
+       tda18271_write_regs(fe, R_EB21, 3);
+
+       return 0;
+}
+
+static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u32 N;
+
+       /* set CAL mode to normal */
+       regs[R_EP4]  &= ~0x03;
+       tda18271_write_regs(fe, R_EP4, 1);
+
+       /* switch off agc1 */
+       regs[R_EP3]  |= 0x40; /* sm_lt = 1 */
+
+       regs[R_EB18] |= 0x03; /* set agc1_gain to 15 dB */
+       tda18271_write_regs(fe, R_EB18, 1);
+
+       /* frequency dependent parameters */
+
+       tda18271_calc_bp_filter(fe, &freq);
+       tda18271_calc_gain_taper(fe, &freq);
+       tda18271_calc_rf_band(fe, &freq);
+       tda18271_calc_km(fe, &freq);
+
+       tda18271_write_regs(fe, R_EP1, 3);
+       tda18271_write_regs(fe, R_EB13, 1);
+
+       /* main pll charge pump source */
+       tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
+
+       /* cal pll charge pump source */
+       tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1);
+
+       /* force dcdc converter to 0 V */
+       regs[R_EB14] = 0x00;
+       tda18271_write_regs(fe, R_EB14, 1);
+
+       /* disable plls lock */
+       regs[R_EB20] &= ~0x20;
+       tda18271_write_regs(fe, R_EB20, 1);
+
+       /* set CAL mode to RF tracking filter calibration */
+       regs[R_EP4]  |= 0x03;
+       tda18271_write_regs(fe, R_EP4, 2);
+
+       /* --------------------------------------------------------------- */
+
+       /* set the internal calibration signal */
+       N = freq;
+
+       tda18271_calc_cal_pll(fe, N);
+       tda18271_write_regs(fe, R_CPD, 4);
+
+       /* downconvert internal calibration */
+       N += 1000000;
+
+       tda18271_calc_main_pll(fe, N);
+       tda18271_write_regs(fe, R_MPD, 4);
+
+       msleep(5);
+
+       tda18271_write_regs(fe, R_EP2, 1);
+       tda18271_write_regs(fe, R_EP1, 1);
+       tda18271_write_regs(fe, R_EP2, 1);
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       /* --------------------------------------------------------------- */
+
+       /* normal operation for the main pll */
+       tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
+
+       /* normal operation for the cal pll  */
+       tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0);
+
+       msleep(10); /* plls locking */
+
+       /* launch the rf tracking filters calibration */
+       regs[R_EB20]  |= 0x20;
+       tda18271_write_regs(fe, R_EB20, 1);
+
+       msleep(60); /* calibration */
+
+       /* --------------------------------------------------------------- */
+
+       /* set CAL mode to normal */
+       regs[R_EP4]  &= ~0x03;
+
+       /* switch on agc1 */
+       regs[R_EP3]  &= ~0x40; /* sm_lt = 0 */
+
+       regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
+       tda18271_write_regs(fe, R_EB18, 1);
+
+       tda18271_write_regs(fe, R_EP3, 2);
+
+       /* synchronization */
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       /* get calibration result */
+       tda18271_read_extended(fe);
+
+       return regs[R_EB14];
+}
+
+static int tda18271_powerscan(struct dvb_frontend *fe,
+                             u32 *freq_in, u32 *freq_out)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       int sgn, bcal, count, wait;
+       u8 cid_target;
+       u16 count_limit;
+       u32 freq;
+
+       freq = *freq_in;
+
+       tda18271_calc_rf_band(fe, &freq);
+       tda18271_calc_rf_cal(fe, &freq);
+       tda18271_calc_gain_taper(fe, &freq);
+       tda18271_lookup_cid_target(fe, &freq, &cid_target, &count_limit);
+
+       tda18271_write_regs(fe, R_EP2, 1);
+       tda18271_write_regs(fe, R_EB14, 1);
+
+       /* downconvert frequency */
+       freq += 1000000;
+
+       tda18271_calc_main_pll(fe, freq);
+       tda18271_write_regs(fe, R_MPD, 4);
+
+       msleep(5); /* pll locking */
+
+       /* detection mode */
+       regs[R_EP4]  &= ~0x03;
+       regs[R_EP4]  |= 0x01;
+       tda18271_write_regs(fe, R_EP4, 1);
+
+       /* launch power detection measurement */
+       tda18271_write_regs(fe, R_EP2, 1);
+
+       /* read power detection info, stored in EB10 */
+       tda18271_read_extended(fe);
+
+       /* algorithm initialization */
+       sgn = 1;
+       *freq_out = *freq_in;
+       bcal = 0;
+       count = 0;
+       wait = false;
+
+       while ((regs[R_EB10] & 0x3f) < cid_target) {
+               /* downconvert updated freq to 1 MHz */
+               freq = *freq_in + (sgn * count) + 1000000;
+
+               tda18271_calc_main_pll(fe, freq);
+               tda18271_write_regs(fe, R_MPD, 4);
+
+               if (wait) {
+                       msleep(5); /* pll locking */
+                       wait = false;
+               } else
+                       udelay(100); /* pll locking */
+
+               /* launch power detection measurement */
+               tda18271_write_regs(fe, R_EP2, 1);
+
+               /* read power detection info, stored in EB10 */
+               tda18271_read_extended(fe);
+
+               count += 200;
+
+               if (count <= count_limit)
+                       continue;
+
+               if (sgn <= 0)
+                       break;
+
+               sgn = -1 * sgn;
+               count = 200;
+               wait = true;
+       }
+
+       if ((regs[R_EB10] & 0x3f) >= cid_target) {
+               bcal = 1;
+               *freq_out = freq - 1000000;
+       } else
+               bcal = 0;
+
+       tda_cal("bcal = %d, freq_in = %d, freq_out = %d (freq = %d)\n",
+               bcal, *freq_in, *freq_out, freq);
+
+       return bcal;
+}
+
+static int tda18271_powerscan_init(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       /* set standard to digital */
+       regs[R_EP3]  &= ~0x1f; /* clear std bits */
+       regs[R_EP3]  |= 0x12;
+
+       /* set cal mode to normal */
+       regs[R_EP4]  &= ~0x03;
+
+       /* update IF output level & IF notch frequency */
+       regs[R_EP4]  &= ~0x1c; /* clear if level bits */
+
+       tda18271_write_regs(fe, R_EP3, 2);
+
+       regs[R_EB18] &= ~0x03; /* set agc1_gain to   6 dB */
+       tda18271_write_regs(fe, R_EB18, 1);
+
+       regs[R_EB21] &= ~0x03; /* set agc2_gain to -15 dB */
+
+       /* 1.5 MHz low pass filter */
+       regs[R_EB23] |= 0x04; /* forcelp_fc2_en = 1 */
+       regs[R_EB23] |= 0x02; /* lp_fc[2] = 1 */
+
+       tda18271_write_regs(fe, R_EB21, 3);
+
+       return 0;
+}
+
+static int tda18271_rf_tracking_filters_init(struct dvb_frontend *fe, u32 freq)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
+       unsigned char *regs = priv->tda18271_regs;
+       int bcal, rf, i;
+#define RF1 0
+#define RF2 1
+#define RF3 2
+       u32 rf_default[3];
+       u32 rf_freq[3];
+       u8 prog_cal[3];
+       u8 prog_tab[3];
+
+       i = tda18271_lookup_rf_band(fe, &freq, NULL);
+
+       if (i < 0)
+               return i;
+
+       rf_default[RF1] = 1000 * map[i].rf1_def;
+       rf_default[RF2] = 1000 * map[i].rf2_def;
+       rf_default[RF3] = 1000 * map[i].rf3_def;
+
+       for (rf = RF1; rf <= RF3; rf++) {
+               if (0 == rf_default[rf])
+                       return 0;
+               tda_cal("freq = %d, rf = %d\n", freq, rf);
+
+               /* look for optimized calibration frequency */
+               bcal = tda18271_powerscan(fe, &rf_default[rf], &rf_freq[rf]);
+
+               tda18271_calc_rf_cal(fe, &rf_freq[rf]);
+               prog_tab[rf] = regs[R_EB14];
+
+               if (1 == bcal)
+                       prog_cal[rf] = tda18271_calibrate_rf(fe, rf_freq[rf]);
+               else
+                       prog_cal[rf] = prog_tab[rf];
+
+               switch (rf) {
+               case RF1:
+                       map[i].rf_a1 = 0;
+                       map[i].rf_b1 = prog_cal[RF1] - prog_tab[RF1];
+                       map[i].rf1   = rf_freq[RF1] / 1000;
+                       break;
+               case RF2:
+                       map[i].rf_a1 = (prog_cal[RF2] - prog_tab[RF2] -
+                                       prog_cal[RF1] + prog_tab[RF1]) /
+                               ((rf_freq[RF2] - rf_freq[RF1]) / 1000);
+                       map[i].rf2   = rf_freq[RF2] / 1000;
+                       break;
+               case RF3:
+                       map[i].rf_a2 = (prog_cal[RF3] - prog_tab[RF3] -
+                                       prog_cal[RF2] + prog_tab[RF2]) /
+                               ((rf_freq[RF3] - rf_freq[RF2]) / 1000);
+                       map[i].rf_b2 = prog_cal[RF2] - prog_tab[RF2];
+                       map[i].rf3   = rf_freq[RF3] / 1000;
+                       break;
+               default:
+                       BUG();
+               }
+       }
+
+       return 0;
+}
+
+static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned int i;
+
+       tda_info("tda18271: performing RF tracking filter calibration\n");
+
+       /* wait for die temperature stabilization */
+       msleep(200);
+
+       tda18271_powerscan_init(fe);
+
+       /* rf band calibration */
+       for (i = 0; priv->rf_cal_state[i].rfmax != 0; i++)
+               tda18271_rf_tracking_filters_init(fe, 1000 *
+                                                 priv->rf_cal_state[i].rfmax);
+
+       priv->tm_rfcal = tda18271_read_thermometer(fe);
+
+       return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda18271c2_rf_cal_init(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       /* test RF_CAL_OK to see if we need init */
+       if ((regs[R_EP1] & 0x10) == 0)
+               priv->cal_initialized = false;
+
+       if (priv->cal_initialized)
+               return 0;
+
+       tda18271_calc_rf_filter_curve(fe);
+
+       tda18271_por(fe);
+
+       tda_info("tda18271: RF tracking filter calibration complete\n");
+
+       priv->cal_initialized = true;
+
+       return 0;
+}
+
+static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe,
+                                                    u32 freq, u32 bw)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       u32 N = 0;
+
+       /* calculate bp filter */
+       tda18271_calc_bp_filter(fe, &freq);
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       regs[R_EB4]  &= 0x07;
+       regs[R_EB4]  |= 0x60;
+       tda18271_write_regs(fe, R_EB4, 1);
+
+       regs[R_EB7]   = 0x60;
+       tda18271_write_regs(fe, R_EB7, 1);
+
+       regs[R_EB14]  = 0x00;
+       tda18271_write_regs(fe, R_EB14, 1);
+
+       regs[R_EB20]  = 0xcc;
+       tda18271_write_regs(fe, R_EB20, 1);
+
+       /* set cal mode to RF tracking filter calibration */
+       regs[R_EP4]  |= 0x03;
+
+       /* calculate cal pll */
+
+       switch (priv->mode) {
+       case TDA18271_ANALOG:
+               N = freq - 1250000;
+               break;
+       case TDA18271_DIGITAL:
+               N = freq + bw / 2;
+               break;
+       }
+
+       tda18271_calc_cal_pll(fe, N);
+
+       /* calculate main pll */
+
+       switch (priv->mode) {
+       case TDA18271_ANALOG:
+               N = freq - 250000;
+               break;
+       case TDA18271_DIGITAL:
+               N = freq + bw / 2 + 1000000;
+               break;
+       }
+
+       tda18271_calc_main_pll(fe, N);
+
+       tda18271_write_regs(fe, R_EP3, 11);
+       msleep(5); /* RF tracking filter calibration initialization */
+
+       /* search for K,M,CO for RF calibration */
+       tda18271_calc_km(fe, &freq);
+       tda18271_write_regs(fe, R_EB13, 1);
+
+       /* search for rf band */
+       tda18271_calc_rf_band(fe, &freq);
+
+       /* search for gain taper */
+       tda18271_calc_gain_taper(fe, &freq);
+
+       tda18271_write_regs(fe, R_EP2, 1);
+       tda18271_write_regs(fe, R_EP1, 1);
+       tda18271_write_regs(fe, R_EP2, 1);
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       regs[R_EB4]  &= 0x07;
+       regs[R_EB4]  |= 0x40;
+       tda18271_write_regs(fe, R_EB4, 1);
+
+       regs[R_EB7]   = 0x40;
+       tda18271_write_regs(fe, R_EB7, 1);
+       msleep(10); /* pll locking */
+
+       regs[R_EB20]  = 0xec;
+       tda18271_write_regs(fe, R_EB20, 1);
+       msleep(60); /* RF tracking filter calibration completion */
+
+       regs[R_EP4]  &= ~0x03; /* set cal mode to normal */
+       tda18271_write_regs(fe, R_EP4, 1);
+
+       tda18271_write_regs(fe, R_EP1, 1);
+
+       /* RF tracking filter correction for VHF_Low band */
+       if (0 == tda18271_calc_rf_cal(fe, &freq))
+               tda18271_write_regs(fe, R_EB14, 1);
+
+       return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda18271_ir_cal_init(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+
+       tda18271_read_regs(fe);
+
+       /* test IR_CAL_OK to see if we need init */
+       if ((regs[R_EP1] & 0x08) == 0)
+               tda18271_init_regs(fe);
+
+       return 0;
+}
+
+static int tda18271_init(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+
+       mutex_lock(&priv->lock);
+
+       /* power up */
+       tda18271_set_standby_mode(fe, 0, 0, 0);
+
+       /* initialization */
+       tda18271_ir_cal_init(fe);
+
+       if (priv->id == TDA18271HDC2)
+               tda18271c2_rf_cal_init(fe);
+
+       mutex_unlock(&priv->lock);
+
+       return 0;
+}
+
+static int tda18271_tune(struct dvb_frontend *fe,
+                        struct tda18271_std_map_item *map, u32 freq, u32 bw)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+
+       tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n",
+               freq, map->if_freq, bw, map->agc_mode, map->std);
+
+       tda18271_init(fe);
+
+       mutex_lock(&priv->lock);
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               tda18271c1_rf_tracking_filter_calibration(fe, freq, bw);
+               break;
+       case TDA18271HDC2:
+               tda18271c2_rf_tracking_filters_correction(fe, freq);
+               break;
+       }
+       tda18271_channel_configuration(fe, map, freq, bw);
+
+       mutex_unlock(&priv->lock);
+
+       return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda18271_set_params(struct dvb_frontend *fe,
+                              struct dvb_frontend_parameters *params)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_std_map *std_map = &priv->std;
+       struct tda18271_std_map_item *map;
+       int ret;
+       u32 bw, freq = params->frequency;
+
+       priv->mode = TDA18271_DIGITAL;
+
+       if (fe->ops.info.type == FE_ATSC) {
+               switch (params->u.vsb.modulation) {
+               case VSB_8:
+               case VSB_16:
+                       map = &std_map->atsc_6;
+                       break;
+               case QAM_64:
+               case QAM_256:
+                       map = &std_map->qam_6;
+                       break;
+               default:
+                       tda_warn("modulation not set!\n");
+                       return -EINVAL;
+               }
+#if 0
+               /* userspace request is already center adjusted */
+               freq += 1750000; /* Adjust to center (+1.75MHZ) */
+#endif
+               bw = 6000000;
+       } else if (fe->ops.info.type == FE_OFDM) {
+               switch (params->u.ofdm.bandwidth) {
+               case BANDWIDTH_6_MHZ:
+                       bw = 6000000;
+                       map = &std_map->dvbt_6;
+                       break;
+               case BANDWIDTH_7_MHZ:
+                       bw = 7000000;
+                       map = &std_map->dvbt_7;
+                       break;
+               case BANDWIDTH_8_MHZ:
+                       bw = 8000000;
+                       map = &std_map->dvbt_8;
+                       break;
+               default:
+                       tda_warn("bandwidth not set!\n");
+                       return -EINVAL;
+               }
+       } else {
+               tda_warn("modulation type not supported!\n");
+               return -EINVAL;
+       }
+
+       /* When tuning digital, the analog demod must be tri-stated */
+       if (fe->ops.analog_ops.standby)
+               fe->ops.analog_ops.standby(fe);
+
+       ret = tda18271_tune(fe, map, freq, bw);
+
+       if (ret < 0)
+               goto fail;
+
+       priv->frequency = freq;
+       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
+               params->u.ofdm.bandwidth : 0;
+fail:
+       return ret;
+}
+
+static int tda18271_set_analog_params(struct dvb_frontend *fe,
+                                     struct analog_parameters *params)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_std_map *std_map = &priv->std;
+       struct tda18271_std_map_item *map;
+       char *mode;
+       int ret;
+       u32 freq = params->frequency * 62500;
+
+       priv->mode = TDA18271_ANALOG;
+
+       if (params->mode == V4L2_TUNER_RADIO) {
+               freq = freq / 1000;
+               map = &std_map->fm_radio;
+               mode = "fm";
+       } else if (params->std & V4L2_STD_MN) {
+               map = &std_map->atv_mn;
+               mode = "MN";
+       } else if (params->std & V4L2_STD_B) {
+               map = &std_map->atv_b;
+               mode = "B";
+       } else if (params->std & V4L2_STD_GH) {
+               map = &std_map->atv_gh;
+               mode = "GH";
+       } else if (params->std & V4L2_STD_PAL_I) {
+               map = &std_map->atv_i;
+               mode = "I";
+       } else if (params->std & V4L2_STD_DK) {
+               map = &std_map->atv_dk;
+               mode = "DK";
+       } else if (params->std & V4L2_STD_SECAM_L) {
+               map = &std_map->atv_l;
+               mode = "L";
+       } else if (params->std & V4L2_STD_SECAM_LC) {
+               map = &std_map->atv_lc;
+               mode = "L'";
+       } else {
+               map = &std_map->atv_i;
+               mode = "xx";
+       }
+
+       tda_dbg("setting tda18271 to system %s\n", mode);
+
+       ret = tda18271_tune(fe, map, freq, 0);
+
+       if (ret < 0)
+               goto fail;
+
+       priv->frequency = freq;
+       priv->bandwidth = 0;
+fail:
+       return ret;
+}
+
+static int tda18271_sleep(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+
+       mutex_lock(&priv->lock);
+
+       /* standby mode w/ slave tuner output
+        * & loop thru & xtal oscillator on */
+       tda18271_set_standby_mode(fe, 1, 0, 0);
+
+       mutex_unlock(&priv->lock);
+
+       return 0;
+}
+
+static int tda18271_release(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+
+       mutex_lock(&tda18271_list_mutex);
+
+       if (priv)
+               hybrid_tuner_release_state(priv);
+
+       mutex_unlock(&tda18271_list_mutex);
+
+       fe->tuner_priv = NULL;
+
+       return 0;
+}
+
+static int tda18271_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+       return 0;
+}
+
+static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       *bandwidth = priv->bandwidth;
+       return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+#define tda18271_update_std(std_cfg, name) do {                                \
+       if (map->std_cfg.if_freq +                                      \
+               map->std_cfg.agc_mode + map->std_cfg.std +              \
+               map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) {     \
+               tda_dbg("Using custom std config for %s\n", name);      \
+               memcpy(&std->std_cfg, &map->std_cfg,                    \
+                       sizeof(struct tda18271_std_map_item));          \
+       } } while (0)
+
+#define tda18271_dump_std_item(std_cfg, name) do {                     \
+       tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, "          \
+               "if_lvl = %d, rfagc_top = 0x%02x\n",                    \
+               name, std->std_cfg.if_freq,                             \
+               std->std_cfg.agc_mode, std->std_cfg.std,                \
+               std->std_cfg.if_lvl, std->std_cfg.rfagc_top);           \
+       } while (0)
+
+static int tda18271_dump_std_map(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_std_map *std = &priv->std;
+
+       tda_dbg("========== STANDARD MAP SETTINGS ==========\n");
+       tda18271_dump_std_item(fm_radio, "  fm  ");
+       tda18271_dump_std_item(atv_b,  "atv b ");
+       tda18271_dump_std_item(atv_dk, "atv dk");
+       tda18271_dump_std_item(atv_gh, "atv gh");
+       tda18271_dump_std_item(atv_i,  "atv i ");
+       tda18271_dump_std_item(atv_l,  "atv l ");
+       tda18271_dump_std_item(atv_lc, "atv l'");
+       tda18271_dump_std_item(atv_mn, "atv mn");
+       tda18271_dump_std_item(atsc_6, "atsc 6");
+       tda18271_dump_std_item(dvbt_6, "dvbt 6");
+       tda18271_dump_std_item(dvbt_7, "dvbt 7");
+       tda18271_dump_std_item(dvbt_8, "dvbt 8");
+       tda18271_dump_std_item(qam_6,  "qam 6 ");
+       tda18271_dump_std_item(qam_8,  "qam 8 ");
+
+       return 0;
+}
+
+static int tda18271_update_std_map(struct dvb_frontend *fe,
+                                  struct tda18271_std_map *map)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_std_map *std = &priv->std;
+
+       if (!map)
+               return -EINVAL;
+
+       tda18271_update_std(fm_radio, "fm");
+       tda18271_update_std(atv_b,  "atv b");
+       tda18271_update_std(atv_dk, "atv dk");
+       tda18271_update_std(atv_gh, "atv gh");
+       tda18271_update_std(atv_i,  "atv i");
+       tda18271_update_std(atv_l,  "atv l");
+       tda18271_update_std(atv_lc, "atv l'");
+       tda18271_update_std(atv_mn, "atv mn");
+       tda18271_update_std(atsc_6, "atsc 6");
+       tda18271_update_std(dvbt_6, "dvbt 6");
+       tda18271_update_std(dvbt_7, "dvbt 7");
+       tda18271_update_std(dvbt_8, "dvbt 8");
+       tda18271_update_std(qam_6,  "qam 6");
+       tda18271_update_std(qam_8,  "qam 8");
+
+       return 0;
+}
+
+static int tda18271_get_id(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       char *name;
+       int ret = 0;
+
+       mutex_lock(&priv->lock);
+       tda18271_read_regs(fe);
+       mutex_unlock(&priv->lock);
+
+       switch (regs[R_ID] & 0x7f) {
+       case 3:
+               name = "TDA18271HD/C1";
+               priv->id = TDA18271HDC1;
+               break;
+       case 4:
+               name = "TDA18271HD/C2";
+               priv->id = TDA18271HDC2;
+               break;
+       default:
+               name = "Unknown device";
+               ret = -EINVAL;
+               break;
+       }
+
+       tda_info("%s detected @ %d-%04x%s\n", name,
+                i2c_adapter_id(priv->i2c_props.adap),
+                priv->i2c_props.addr,
+                (0 == ret) ? "" : ", device not supported.");
+
+       return ret;
+}
+
+static struct dvb_tuner_ops tda18271_tuner_ops = {
+       .info = {
+               .name = "NXP TDA18271HD",
+               .frequency_min  =  45000000,
+               .frequency_max  = 864000000,
+               .frequency_step =     62500
+       },
+       .init              = tda18271_init,
+       .sleep             = tda18271_sleep,
+       .set_params        = tda18271_set_params,
+       .set_analog_params = tda18271_set_analog_params,
+       .release           = tda18271_release,
+       .get_frequency     = tda18271_get_frequency,
+       .get_bandwidth     = tda18271_get_bandwidth,
+};
+
+struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
+                                    struct i2c_adapter *i2c,
+                                    struct tda18271_config *cfg)
+{
+       struct tda18271_priv *priv = NULL;
+       int instance;
+
+       mutex_lock(&tda18271_list_mutex);
+
+       instance = hybrid_tuner_request_state(struct tda18271_priv, priv,
+                                             hybrid_tuner_instance_list,
+                                             i2c, addr, "tda18271");
+       switch (instance) {
+       case 0:
+               goto fail;
+               break;
+       case 1:
+               /* new tuner instance */
+               priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
+               priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
+               priv->cal_initialized = false;
+               mutex_init(&priv->lock);
+
+               fe->tuner_priv = priv;
+
+               if (cfg)
+                       priv->small_i2c = cfg->small_i2c;
+
+               if (tda18271_get_id(fe) < 0)
+                       goto fail;
+
+               if (tda18271_assign_map_layout(fe) < 0)
+                       goto fail;
+
+               mutex_lock(&priv->lock);
+               tda18271_init_regs(fe);
+
+               if ((tda18271_cal_on_startup) && (priv->id == TDA18271HDC2))
+                       tda18271c2_rf_cal_init(fe);
+
+               mutex_unlock(&priv->lock);
+               break;
+       default:
+               /* existing tuner instance */
+               fe->tuner_priv = priv;
+
+               /* allow dvb driver to override i2c gate setting */
+               if ((cfg) && (cfg->gate != TDA18271_GATE_ANALOG))
+                       priv->gate = cfg->gate;
+               break;
+       }
+
+       /* override default std map with values in config struct */
+       if ((cfg) && (cfg->std_map))
+               tda18271_update_std_map(fe, cfg->std_map);
+
+       mutex_unlock(&tda18271_list_mutex);
+
+       memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops,
+              sizeof(struct dvb_tuner_ops));
+
+       if (tda18271_debug & (DBG_MAP | DBG_ADV))
+               tda18271_dump_std_map(fe);
+
+       return fe;
+fail:
+       mutex_unlock(&tda18271_list_mutex);
+
+       tda18271_release(fe);
+       return NULL;
+}
+EXPORT_SYMBOL_GPL(tda18271_attach);
+MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver");
+MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("0.3");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda18271-maps.c b/drivers/media/common/tuners/tda18271-maps.c
new file mode 100644 (file)
index 0000000..83e7561
--- /dev/null
@@ -0,0 +1,1313 @@
+/*
+    tda18271-tables.c - driver for the Philips / NXP TDA18271 silicon tuner
+
+    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "tda18271-priv.h"
+
+struct tda18271_pll_map {
+       u32 lomax;
+       u8 pd; /* post div */
+       u8 d;  /*      div */
+};
+
+struct tda18271_map {
+       u32 rfmax;
+       u8  val;
+};
+
+/*---------------------------------------------------------------------*/
+
+static struct tda18271_pll_map tda18271c1_main_pll[] = {
+       { .lomax =  32000, .pd = 0x5f, .d = 0xf0 },
+       { .lomax =  35000, .pd = 0x5e, .d = 0xe0 },
+       { .lomax =  37000, .pd = 0x5d, .d = 0xd0 },
+       { .lomax =  41000, .pd = 0x5c, .d = 0xc0 },
+       { .lomax =  44000, .pd = 0x5b, .d = 0xb0 },
+       { .lomax =  49000, .pd = 0x5a, .d = 0xa0 },
+       { .lomax =  54000, .pd = 0x59, .d = 0x90 },
+       { .lomax =  61000, .pd = 0x58, .d = 0x80 },
+       { .lomax =  65000, .pd = 0x4f, .d = 0x78 },
+       { .lomax =  70000, .pd = 0x4e, .d = 0x70 },
+       { .lomax =  75000, .pd = 0x4d, .d = 0x68 },
+       { .lomax =  82000, .pd = 0x4c, .d = 0x60 },
+       { .lomax =  89000, .pd = 0x4b, .d = 0x58 },
+       { .lomax =  98000, .pd = 0x4a, .d = 0x50 },
+       { .lomax = 109000, .pd = 0x49, .d = 0x48 },
+       { .lomax = 123000, .pd = 0x48, .d = 0x40 },
+       { .lomax = 131000, .pd = 0x3f, .d = 0x3c },
+       { .lomax = 141000, .pd = 0x3e, .d = 0x38 },
+       { .lomax = 151000, .pd = 0x3d, .d = 0x34 },
+       { .lomax = 164000, .pd = 0x3c, .d = 0x30 },
+       { .lomax = 179000, .pd = 0x3b, .d = 0x2c },
+       { .lomax = 197000, .pd = 0x3a, .d = 0x28 },
+       { .lomax = 219000, .pd = 0x39, .d = 0x24 },
+       { .lomax = 246000, .pd = 0x38, .d = 0x20 },
+       { .lomax = 263000, .pd = 0x2f, .d = 0x1e },
+       { .lomax = 282000, .pd = 0x2e, .d = 0x1c },
+       { .lomax = 303000, .pd = 0x2d, .d = 0x1a },
+       { .lomax = 329000, .pd = 0x2c, .d = 0x18 },
+       { .lomax = 359000, .pd = 0x2b, .d = 0x16 },
+       { .lomax = 395000, .pd = 0x2a, .d = 0x14 },
+       { .lomax = 438000, .pd = 0x29, .d = 0x12 },
+       { .lomax = 493000, .pd = 0x28, .d = 0x10 },
+       { .lomax = 526000, .pd = 0x1f, .d = 0x0f },
+       { .lomax = 564000, .pd = 0x1e, .d = 0x0e },
+       { .lomax = 607000, .pd = 0x1d, .d = 0x0d },
+       { .lomax = 658000, .pd = 0x1c, .d = 0x0c },
+       { .lomax = 718000, .pd = 0x1b, .d = 0x0b },
+       { .lomax = 790000, .pd = 0x1a, .d = 0x0a },
+       { .lomax = 877000, .pd = 0x19, .d = 0x09 },
+       { .lomax = 987000, .pd = 0x18, .d = 0x08 },
+       { .lomax =      0, .pd = 0x00, .d = 0x00 }, /* end */
+};
+
+static struct tda18271_pll_map tda18271c2_main_pll[] = {
+       { .lomax =  33125, .pd = 0x57, .d = 0xf0 },
+       { .lomax =  35500, .pd = 0x56, .d = 0xe0 },
+       { .lomax =  38188, .pd = 0x55, .d = 0xd0 },
+       { .lomax =  41375, .pd = 0x54, .d = 0xc0 },
+       { .lomax =  45125, .pd = 0x53, .d = 0xb0 },
+       { .lomax =  49688, .pd = 0x52, .d = 0xa0 },
+       { .lomax =  55188, .pd = 0x51, .d = 0x90 },
+       { .lomax =  62125, .pd = 0x50, .d = 0x80 },
+       { .lomax =  66250, .pd = 0x47, .d = 0x78 },
+       { .lomax =  71000, .pd = 0x46, .d = 0x70 },
+       { .lomax =  76375, .pd = 0x45, .d = 0x68 },
+       { .lomax =  82750, .pd = 0x44, .d = 0x60 },
+       { .lomax =  90250, .pd = 0x43, .d = 0x58 },
+       { .lomax =  99375, .pd = 0x42, .d = 0x50 },
+       { .lomax = 110375, .pd = 0x41, .d = 0x48 },
+       { .lomax = 124250, .pd = 0x40, .d = 0x40 },
+       { .lomax = 132500, .pd = 0x37, .d = 0x3c },
+       { .lomax = 142000, .pd = 0x36, .d = 0x38 },
+       { .lomax = 152750, .pd = 0x35, .d = 0x34 },
+       { .lomax = 165500, .pd = 0x34, .d = 0x30 },
+       { .lomax = 180500, .pd = 0x33, .d = 0x2c },
+       { .lomax = 198750, .pd = 0x32, .d = 0x28 },
+       { .lomax = 220750, .pd = 0x31, .d = 0x24 },
+       { .lomax = 248500, .pd = 0x30, .d = 0x20 },
+       { .lomax = 265000, .pd = 0x27, .d = 0x1e },
+       { .lomax = 284000, .pd = 0x26, .d = 0x1c },
+       { .lomax = 305500, .pd = 0x25, .d = 0x1a },
+       { .lomax = 331000, .pd = 0x24, .d = 0x18 },
+       { .lomax = 361000, .pd = 0x23, .d = 0x16 },
+       { .lomax = 397500, .pd = 0x22, .d = 0x14 },
+       { .lomax = 441500, .pd = 0x21, .d = 0x12 },
+       { .lomax = 497000, .pd = 0x20, .d = 0x10 },
+       { .lomax = 530000, .pd = 0x17, .d = 0x0f },
+       { .lomax = 568000, .pd = 0x16, .d = 0x0e },
+       { .lomax = 611000, .pd = 0x15, .d = 0x0d },
+       { .lomax = 662000, .pd = 0x14, .d = 0x0c },
+       { .lomax = 722000, .pd = 0x13, .d = 0x0b },
+       { .lomax = 795000, .pd = 0x12, .d = 0x0a },
+       { .lomax = 883000, .pd = 0x11, .d = 0x09 },
+       { .lomax = 994000, .pd = 0x10, .d = 0x08 },
+       { .lomax =      0, .pd = 0x00, .d = 0x00 }, /* end */
+};
+
+static struct tda18271_pll_map tda18271c1_cal_pll[] = {
+       { .lomax =   33000, .pd = 0xdd, .d = 0xd0 },
+       { .lomax =   36000, .pd = 0xdc, .d = 0xc0 },
+       { .lomax =   40000, .pd = 0xdb, .d = 0xb0 },
+       { .lomax =   44000, .pd = 0xda, .d = 0xa0 },
+       { .lomax =   49000, .pd = 0xd9, .d = 0x90 },
+       { .lomax =   55000, .pd = 0xd8, .d = 0x80 },
+       { .lomax =   63000, .pd = 0xd3, .d = 0x70 },
+       { .lomax =   67000, .pd = 0xcd, .d = 0x68 },
+       { .lomax =   73000, .pd = 0xcc, .d = 0x60 },
+       { .lomax =   80000, .pd = 0xcb, .d = 0x58 },
+       { .lomax =   88000, .pd = 0xca, .d = 0x50 },
+       { .lomax =   98000, .pd = 0xc9, .d = 0x48 },
+       { .lomax =  110000, .pd = 0xc8, .d = 0x40 },
+       { .lomax =  126000, .pd = 0xc3, .d = 0x38 },
+       { .lomax =  135000, .pd = 0xbd, .d = 0x34 },
+       { .lomax =  147000, .pd = 0xbc, .d = 0x30 },
+       { .lomax =  160000, .pd = 0xbb, .d = 0x2c },
+       { .lomax =  176000, .pd = 0xba, .d = 0x28 },
+       { .lomax =  196000, .pd = 0xb9, .d = 0x24 },
+       { .lomax =  220000, .pd = 0xb8, .d = 0x20 },
+       { .lomax =  252000, .pd = 0xb3, .d = 0x1c },
+       { .lomax =  271000, .pd = 0xad, .d = 0x1a },
+       { .lomax =  294000, .pd = 0xac, .d = 0x18 },
+       { .lomax =  321000, .pd = 0xab, .d = 0x16 },
+       { .lomax =  353000, .pd = 0xaa, .d = 0x14 },
+       { .lomax =  392000, .pd = 0xa9, .d = 0x12 },
+       { .lomax =  441000, .pd = 0xa8, .d = 0x10 },
+       { .lomax =  505000, .pd = 0xa3, .d = 0x0e },
+       { .lomax =  543000, .pd = 0x9d, .d = 0x0d },
+       { .lomax =  589000, .pd = 0x9c, .d = 0x0c },
+       { .lomax =  642000, .pd = 0x9b, .d = 0x0b },
+       { .lomax =  707000, .pd = 0x9a, .d = 0x0a },
+       { .lomax =  785000, .pd = 0x99, .d = 0x09 },
+       { .lomax =  883000, .pd = 0x98, .d = 0x08 },
+       { .lomax = 1010000, .pd = 0x93, .d = 0x07 },
+       { .lomax =       0, .pd = 0x00, .d = 0x00 }, /* end */
+};
+
+static struct tda18271_pll_map tda18271c2_cal_pll[] = {
+       { .lomax =   33813, .pd = 0xdd, .d = 0xd0 },
+       { .lomax =   36625, .pd = 0xdc, .d = 0xc0 },
+       { .lomax =   39938, .pd = 0xdb, .d = 0xb0 },
+       { .lomax =   43938, .pd = 0xda, .d = 0xa0 },
+       { .lomax =   48813, .pd = 0xd9, .d = 0x90 },
+       { .lomax =   54938, .pd = 0xd8, .d = 0x80 },
+       { .lomax =   62813, .pd = 0xd3, .d = 0x70 },
+       { .lomax =   67625, .pd = 0xcd, .d = 0x68 },
+       { .lomax =   73250, .pd = 0xcc, .d = 0x60 },
+       { .lomax =   79875, .pd = 0xcb, .d = 0x58 },
+       { .lomax =   87875, .pd = 0xca, .d = 0x50 },
+       { .lomax =   97625, .pd = 0xc9, .d = 0x48 },
+       { .lomax =  109875, .pd = 0xc8, .d = 0x40 },
+       { .lomax =  125625, .pd = 0xc3, .d = 0x38 },
+       { .lomax =  135250, .pd = 0xbd, .d = 0x34 },
+       { .lomax =  146500, .pd = 0xbc, .d = 0x30 },
+       { .lomax =  159750, .pd = 0xbb, .d = 0x2c },
+       { .lomax =  175750, .pd = 0xba, .d = 0x28 },
+       { .lomax =  195250, .pd = 0xb9, .d = 0x24 },
+       { .lomax =  219750, .pd = 0xb8, .d = 0x20 },
+       { .lomax =  251250, .pd = 0xb3, .d = 0x1c },
+       { .lomax =  270500, .pd = 0xad, .d = 0x1a },
+       { .lomax =  293000, .pd = 0xac, .d = 0x18 },
+       { .lomax =  319500, .pd = 0xab, .d = 0x16 },
+       { .lomax =  351500, .pd = 0xaa, .d = 0x14 },
+       { .lomax =  390500, .pd = 0xa9, .d = 0x12 },
+       { .lomax =  439500, .pd = 0xa8, .d = 0x10 },
+       { .lomax =  502500, .pd = 0xa3, .d = 0x0e },
+       { .lomax =  541000, .pd = 0x9d, .d = 0x0d },
+       { .lomax =  586000, .pd = 0x9c, .d = 0x0c },
+       { .lomax =  639000, .pd = 0x9b, .d = 0x0b },
+       { .lomax =  703000, .pd = 0x9a, .d = 0x0a },
+       { .lomax =  781000, .pd = 0x99, .d = 0x09 },
+       { .lomax =  879000, .pd = 0x98, .d = 0x08 },
+       { .lomax =       0, .pd = 0x00, .d = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271_bp_filter[] = {
+       { .rfmax =  62000, .val = 0x00 },
+       { .rfmax =  84000, .val = 0x01 },
+       { .rfmax = 100000, .val = 0x02 },
+       { .rfmax = 140000, .val = 0x03 },
+       { .rfmax = 170000, .val = 0x04 },
+       { .rfmax = 180000, .val = 0x05 },
+       { .rfmax = 865000, .val = 0x06 },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271c1_km[] = {
+       { .rfmax =  61100, .val = 0x74 },
+       { .rfmax = 350000, .val = 0x40 },
+       { .rfmax = 720000, .val = 0x30 },
+       { .rfmax = 865000, .val = 0x40 },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271c2_km[] = {
+       { .rfmax =  47900, .val = 0x38 },
+       { .rfmax =  61100, .val = 0x44 },
+       { .rfmax = 350000, .val = 0x30 },
+       { .rfmax = 720000, .val = 0x24 },
+       { .rfmax = 865000, .val = 0x3c },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271_rf_band[] = {
+       { .rfmax =  47900, .val = 0x00 },
+       { .rfmax =  61100, .val = 0x01 },
+/*     { .rfmax = 152600, .val = 0x02 }, */
+       { .rfmax = 121200, .val = 0x02 },
+       { .rfmax = 164700, .val = 0x03 },
+       { .rfmax = 203500, .val = 0x04 },
+       { .rfmax = 457800, .val = 0x05 },
+       { .rfmax = 865000, .val = 0x06 },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271_gain_taper[] = {
+       { .rfmax =  45400, .val = 0x1f },
+       { .rfmax =  45800, .val = 0x1e },
+       { .rfmax =  46200, .val = 0x1d },
+       { .rfmax =  46700, .val = 0x1c },
+       { .rfmax =  47100, .val = 0x1b },
+       { .rfmax =  47500, .val = 0x1a },
+       { .rfmax =  47900, .val = 0x19 },
+       { .rfmax =  49600, .val = 0x17 },
+       { .rfmax =  51200, .val = 0x16 },
+       { .rfmax =  52900, .val = 0x15 },
+       { .rfmax =  54500, .val = 0x14 },
+       { .rfmax =  56200, .val = 0x13 },
+       { .rfmax =  57800, .val = 0x12 },
+       { .rfmax =  59500, .val = 0x11 },
+       { .rfmax =  61100, .val = 0x10 },
+       { .rfmax =  67600, .val = 0x0d },
+       { .rfmax =  74200, .val = 0x0c },
+       { .rfmax =  80700, .val = 0x0b },
+       { .rfmax =  87200, .val = 0x0a },
+       { .rfmax =  93800, .val = 0x09 },
+       { .rfmax = 100300, .val = 0x08 },
+       { .rfmax = 106900, .val = 0x07 },
+       { .rfmax = 113400, .val = 0x06 },
+       { .rfmax = 119900, .val = 0x05 },
+       { .rfmax = 126500, .val = 0x04 },
+       { .rfmax = 133000, .val = 0x03 },
+       { .rfmax = 139500, .val = 0x02 },
+       { .rfmax = 146100, .val = 0x01 },
+       { .rfmax = 152600, .val = 0x00 },
+       { .rfmax = 154300, .val = 0x1f },
+       { .rfmax = 156100, .val = 0x1e },
+       { .rfmax = 157800, .val = 0x1d },
+       { .rfmax = 159500, .val = 0x1c },
+       { .rfmax = 161200, .val = 0x1b },
+       { .rfmax = 163000, .val = 0x1a },
+       { .rfmax = 164700, .val = 0x19 },
+       { .rfmax = 170200, .val = 0x17 },
+       { .rfmax = 175800, .val = 0x16 },
+       { .rfmax = 181300, .val = 0x15 },
+       { .rfmax = 186900, .val = 0x14 },
+       { .rfmax = 192400, .val = 0x13 },
+       { .rfmax = 198000, .val = 0x12 },
+       { .rfmax = 203500, .val = 0x11 },
+       { .rfmax = 216200, .val = 0x14 },
+       { .rfmax = 228900, .val = 0x13 },
+       { .rfmax = 241600, .val = 0x12 },
+       { .rfmax = 254400, .val = 0x11 },
+       { .rfmax = 267100, .val = 0x10 },
+       { .rfmax = 279800, .val = 0x0f },
+       { .rfmax = 292500, .val = 0x0e },
+       { .rfmax = 305200, .val = 0x0d },
+       { .rfmax = 317900, .val = 0x0c },
+       { .rfmax = 330700, .val = 0x0b },
+       { .rfmax = 343400, .val = 0x0a },
+       { .rfmax = 356100, .val = 0x09 },
+       { .rfmax = 368800, .val = 0x08 },
+       { .rfmax = 381500, .val = 0x07 },
+       { .rfmax = 394200, .val = 0x06 },
+       { .rfmax = 406900, .val = 0x05 },
+       { .rfmax = 419700, .val = 0x04 },
+       { .rfmax = 432400, .val = 0x03 },
+       { .rfmax = 445100, .val = 0x02 },
+       { .rfmax = 457800, .val = 0x01 },
+       { .rfmax = 476300, .val = 0x19 },
+       { .rfmax = 494800, .val = 0x18 },
+       { .rfmax = 513300, .val = 0x17 },
+       { .rfmax = 531800, .val = 0x16 },
+       { .rfmax = 550300, .val = 0x15 },
+       { .rfmax = 568900, .val = 0x14 },
+       { .rfmax = 587400, .val = 0x13 },
+       { .rfmax = 605900, .val = 0x12 },
+       { .rfmax = 624400, .val = 0x11 },
+       { .rfmax = 642900, .val = 0x10 },
+       { .rfmax = 661400, .val = 0x0f },
+       { .rfmax = 679900, .val = 0x0e },
+       { .rfmax = 698400, .val = 0x0d },
+       { .rfmax = 716900, .val = 0x0c },
+       { .rfmax = 735400, .val = 0x0b },
+       { .rfmax = 753900, .val = 0x0a },
+       { .rfmax = 772500, .val = 0x09 },
+       { .rfmax = 791000, .val = 0x08 },
+       { .rfmax = 809500, .val = 0x07 },
+       { .rfmax = 828000, .val = 0x06 },
+       { .rfmax = 846500, .val = 0x05 },
+       { .rfmax = 865000, .val = 0x04 },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271c1_rf_cal[] = {
+       { .rfmax = 41000, .val = 0x1e },
+       { .rfmax = 43000, .val = 0x30 },
+       { .rfmax = 45000, .val = 0x43 },
+       { .rfmax = 46000, .val = 0x4d },
+       { .rfmax = 47000, .val = 0x54 },
+       { .rfmax = 47900, .val = 0x64 },
+       { .rfmax = 49100, .val = 0x20 },
+       { .rfmax = 50000, .val = 0x22 },
+       { .rfmax = 51000, .val = 0x2a },
+       { .rfmax = 53000, .val = 0x32 },
+       { .rfmax = 55000, .val = 0x35 },
+       { .rfmax = 56000, .val = 0x3c },
+       { .rfmax = 57000, .val = 0x3f },
+       { .rfmax = 58000, .val = 0x48 },
+       { .rfmax = 59000, .val = 0x4d },
+       { .rfmax = 60000, .val = 0x58 },
+       { .rfmax = 61100, .val = 0x5f },
+       { .rfmax =     0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271c2_rf_cal[] = {
+       { .rfmax =  41000, .val = 0x0f },
+       { .rfmax =  43000, .val = 0x1c },
+       { .rfmax =  45000, .val = 0x2f },
+       { .rfmax =  46000, .val = 0x39 },
+       { .rfmax =  47000, .val = 0x40 },
+       { .rfmax =  47900, .val = 0x50 },
+       { .rfmax =  49100, .val = 0x16 },
+       { .rfmax =  50000, .val = 0x18 },
+       { .rfmax =  51000, .val = 0x20 },
+       { .rfmax =  53000, .val = 0x28 },
+       { .rfmax =  55000, .val = 0x2b },
+       { .rfmax =  56000, .val = 0x32 },
+       { .rfmax =  57000, .val = 0x35 },
+       { .rfmax =  58000, .val = 0x3e },
+       { .rfmax =  59000, .val = 0x43 },
+       { .rfmax =  60000, .val = 0x4e },
+       { .rfmax =  61100, .val = 0x55 },
+       { .rfmax =  63000, .val = 0x0f },
+       { .rfmax =  64000, .val = 0x11 },
+       { .rfmax =  65000, .val = 0x12 },
+       { .rfmax =  66000, .val = 0x15 },
+       { .rfmax =  67000, .val = 0x16 },
+       { .rfmax =  68000, .val = 0x17 },
+       { .rfmax =  70000, .val = 0x19 },
+       { .rfmax =  71000, .val = 0x1c },
+       { .rfmax =  72000, .val = 0x1d },
+       { .rfmax =  73000, .val = 0x1f },
+       { .rfmax =  74000, .val = 0x20 },
+       { .rfmax =  75000, .val = 0x21 },
+       { .rfmax =  76000, .val = 0x24 },
+       { .rfmax =  77000, .val = 0x25 },
+       { .rfmax =  78000, .val = 0x27 },
+       { .rfmax =  80000, .val = 0x28 },
+       { .rfmax =  81000, .val = 0x29 },
+       { .rfmax =  82000, .val = 0x2d },
+       { .rfmax =  83000, .val = 0x2e },
+       { .rfmax =  84000, .val = 0x2f },
+       { .rfmax =  85000, .val = 0x31 },
+       { .rfmax =  86000, .val = 0x33 },
+       { .rfmax =  87000, .val = 0x34 },
+       { .rfmax =  88000, .val = 0x35 },
+       { .rfmax =  89000, .val = 0x37 },
+       { .rfmax =  90000, .val = 0x38 },
+       { .rfmax =  91000, .val = 0x39 },
+       { .rfmax =  93000, .val = 0x3c },
+       { .rfmax =  94000, .val = 0x3e },
+       { .rfmax =  95000, .val = 0x3f },
+       { .rfmax =  96000, .val = 0x40 },
+       { .rfmax =  97000, .val = 0x42 },
+       { .rfmax =  99000, .val = 0x45 },
+       { .rfmax = 100000, .val = 0x46 },
+       { .rfmax = 102000, .val = 0x48 },
+       { .rfmax = 103000, .val = 0x4a },
+       { .rfmax = 105000, .val = 0x4d },
+       { .rfmax = 106000, .val = 0x4e },
+       { .rfmax = 107000, .val = 0x50 },
+       { .rfmax = 108000, .val = 0x51 },
+       { .rfmax = 110000, .val = 0x54 },
+       { .rfmax = 111000, .val = 0x56 },
+       { .rfmax = 112000, .val = 0x57 },
+       { .rfmax = 113000, .val = 0x58 },
+       { .rfmax = 114000, .val = 0x59 },
+       { .rfmax = 115000, .val = 0x5c },
+       { .rfmax = 116000, .val = 0x5d },
+       { .rfmax = 117000, .val = 0x5f },
+       { .rfmax = 119000, .val = 0x60 },
+       { .rfmax = 120000, .val = 0x64 },
+       { .rfmax = 121000, .val = 0x65 },
+       { .rfmax = 122000, .val = 0x66 },
+       { .rfmax = 123000, .val = 0x68 },
+       { .rfmax = 124000, .val = 0x69 },
+       { .rfmax = 125000, .val = 0x6c },
+       { .rfmax = 126000, .val = 0x6d },
+       { .rfmax = 127000, .val = 0x6e },
+       { .rfmax = 128000, .val = 0x70 },
+       { .rfmax = 129000, .val = 0x71 },
+       { .rfmax = 130000, .val = 0x75 },
+       { .rfmax = 131000, .val = 0x77 },
+       { .rfmax = 132000, .val = 0x78 },
+       { .rfmax = 133000, .val = 0x7b },
+       { .rfmax = 134000, .val = 0x7e },
+       { .rfmax = 135000, .val = 0x81 },
+       { .rfmax = 136000, .val = 0x82 },
+       { .rfmax = 137000, .val = 0x87 },
+       { .rfmax = 138000, .val = 0x88 },
+       { .rfmax = 139000, .val = 0x8d },
+       { .rfmax = 140000, .val = 0x8e },
+       { .rfmax = 141000, .val = 0x91 },
+       { .rfmax = 142000, .val = 0x95 },
+       { .rfmax = 143000, .val = 0x9a },
+       { .rfmax = 144000, .val = 0x9d },
+       { .rfmax = 145000, .val = 0xa1 },
+       { .rfmax = 146000, .val = 0xa2 },
+       { .rfmax = 147000, .val = 0xa4 },
+       { .rfmax = 148000, .val = 0xa9 },
+       { .rfmax = 149000, .val = 0xae },
+       { .rfmax = 150000, .val = 0xb0 },
+       { .rfmax = 151000, .val = 0xb1 },
+       { .rfmax = 152000, .val = 0xb7 },
+       { .rfmax = 153000, .val = 0xbd },
+       { .rfmax = 154000, .val = 0x20 },
+       { .rfmax = 155000, .val = 0x22 },
+       { .rfmax = 156000, .val = 0x24 },
+       { .rfmax = 157000, .val = 0x25 },
+       { .rfmax = 158000, .val = 0x27 },
+       { .rfmax = 159000, .val = 0x29 },
+       { .rfmax = 160000, .val = 0x2c },
+       { .rfmax = 161000, .val = 0x2d },
+       { .rfmax = 163000, .val = 0x2e },
+       { .rfmax = 164000, .val = 0x2f },
+       { .rfmax = 165000, .val = 0x30 },
+       { .rfmax = 166000, .val = 0x11 },
+       { .rfmax = 167000, .val = 0x12 },
+       { .rfmax = 168000, .val = 0x13 },
+       { .rfmax = 169000, .val = 0x14 },
+       { .rfmax = 170000, .val = 0x15 },
+       { .rfmax = 172000, .val = 0x16 },
+       { .rfmax = 173000, .val = 0x17 },
+       { .rfmax = 174000, .val = 0x18 },
+       { .rfmax = 175000, .val = 0x1a },
+       { .rfmax = 176000, .val = 0x1b },
+       { .rfmax = 178000, .val = 0x1d },
+       { .rfmax = 179000, .val = 0x1e },
+       { .rfmax = 180000, .val = 0x1f },
+       { .rfmax = 181000, .val = 0x20 },
+       { .rfmax = 182000, .val = 0x21 },
+       { .rfmax = 183000, .val = 0x22 },
+       { .rfmax = 184000, .val = 0x24 },
+       { .rfmax = 185000, .val = 0x25 },
+       { .rfmax = 186000, .val = 0x26 },
+       { .rfmax = 187000, .val = 0x27 },
+       { .rfmax = 188000, .val = 0x29 },
+       { .rfmax = 189000, .val = 0x2a },
+       { .rfmax = 190000, .val = 0x2c },
+       { .rfmax = 191000, .val = 0x2d },
+       { .rfmax = 192000, .val = 0x2e },
+       { .rfmax = 193000, .val = 0x2f },
+       { .rfmax = 194000, .val = 0x30 },
+       { .rfmax = 195000, .val = 0x33 },
+       { .rfmax = 196000, .val = 0x35 },
+       { .rfmax = 198000, .val = 0x36 },
+       { .rfmax = 200000, .val = 0x38 },
+       { .rfmax = 201000, .val = 0x3c },
+       { .rfmax = 202000, .val = 0x3d },
+       { .rfmax = 203500, .val = 0x3e },
+       { .rfmax = 206000, .val = 0x0e },
+       { .rfmax = 208000, .val = 0x0f },
+       { .rfmax = 212000, .val = 0x10 },
+       { .rfmax = 216000, .val = 0x11 },
+       { .rfmax = 217000, .val = 0x12 },
+       { .rfmax = 218000, .val = 0x13 },
+       { .rfmax = 220000, .val = 0x14 },
+       { .rfmax = 222000, .val = 0x15 },
+       { .rfmax = 225000, .val = 0x16 },
+       { .rfmax = 228000, .val = 0x17 },
+       { .rfmax = 231000, .val = 0x18 },
+       { .rfmax = 234000, .val = 0x19 },
+       { .rfmax = 235000, .val = 0x1a },
+       { .rfmax = 236000, .val = 0x1b },
+       { .rfmax = 237000, .val = 0x1c },
+       { .rfmax = 240000, .val = 0x1d },
+       { .rfmax = 242000, .val = 0x1f },
+       { .rfmax = 247000, .val = 0x20 },
+       { .rfmax = 249000, .val = 0x21 },
+       { .rfmax = 252000, .val = 0x22 },
+       { .rfmax = 253000, .val = 0x23 },
+       { .rfmax = 254000, .val = 0x24 },
+       { .rfmax = 256000, .val = 0x25 },
+       { .rfmax = 259000, .val = 0x26 },
+       { .rfmax = 262000, .val = 0x27 },
+       { .rfmax = 264000, .val = 0x28 },
+       { .rfmax = 267000, .val = 0x29 },
+       { .rfmax = 269000, .val = 0x2a },
+       { .rfmax = 271000, .val = 0x2b },
+       { .rfmax = 273000, .val = 0x2c },
+       { .rfmax = 275000, .val = 0x2d },
+       { .rfmax = 277000, .val = 0x2e },
+       { .rfmax = 279000, .val = 0x2f },
+       { .rfmax = 282000, .val = 0x30 },
+       { .rfmax = 284000, .val = 0x31 },
+       { .rfmax = 286000, .val = 0x32 },
+       { .rfmax = 287000, .val = 0x33 },
+       { .rfmax = 290000, .val = 0x34 },
+       { .rfmax = 293000, .val = 0x35 },
+       { .rfmax = 295000, .val = 0x36 },
+       { .rfmax = 297000, .val = 0x37 },
+       { .rfmax = 300000, .val = 0x38 },
+       { .rfmax = 303000, .val = 0x39 },
+       { .rfmax = 305000, .val = 0x3a },
+       { .rfmax = 306000, .val = 0x3b },
+       { .rfmax = 307000, .val = 0x3c },
+       { .rfmax = 310000, .val = 0x3d },
+       { .rfmax = 312000, .val = 0x3e },
+       { .rfmax = 315000, .val = 0x3f },
+       { .rfmax = 318000, .val = 0x40 },
+       { .rfmax = 320000, .val = 0x41 },
+       { .rfmax = 323000, .val = 0x42 },
+       { .rfmax = 324000, .val = 0x43 },
+       { .rfmax = 325000, .val = 0x44 },
+       { .rfmax = 327000, .val = 0x45 },
+       { .rfmax = 331000, .val = 0x46 },
+       { .rfmax = 334000, .val = 0x47 },
+       { .rfmax = 337000, .val = 0x48 },
+       { .rfmax = 339000, .val = 0x49 },
+       { .rfmax = 340000, .val = 0x4a },
+       { .rfmax = 341000, .val = 0x4b },
+       { .rfmax = 343000, .val = 0x4c },
+       { .rfmax = 345000, .val = 0x4d },
+       { .rfmax = 349000, .val = 0x4e },
+       { .rfmax = 352000, .val = 0x4f },
+       { .rfmax = 353000, .val = 0x50 },
+       { .rfmax = 355000, .val = 0x51 },
+       { .rfmax = 357000, .val = 0x52 },
+       { .rfmax = 359000, .val = 0x53 },
+       { .rfmax = 361000, .val = 0x54 },
+       { .rfmax = 362000, .val = 0x55 },
+       { .rfmax = 364000, .val = 0x56 },
+       { .rfmax = 368000, .val = 0x57 },
+       { .rfmax = 370000, .val = 0x58 },
+       { .rfmax = 372000, .val = 0x59 },
+       { .rfmax = 375000, .val = 0x5a },
+       { .rfmax = 376000, .val = 0x5b },
+       { .rfmax = 377000, .val = 0x5c },
+       { .rfmax = 379000, .val = 0x5d },
+       { .rfmax = 382000, .val = 0x5e },
+       { .rfmax = 384000, .val = 0x5f },
+       { .rfmax = 385000, .val = 0x60 },
+       { .rfmax = 386000, .val = 0x61 },
+       { .rfmax = 388000, .val = 0x62 },
+       { .rfmax = 390000, .val = 0x63 },
+       { .rfmax = 393000, .val = 0x64 },
+       { .rfmax = 394000, .val = 0x65 },
+       { .rfmax = 396000, .val = 0x66 },
+       { .rfmax = 397000, .val = 0x67 },
+       { .rfmax = 398000, .val = 0x68 },
+       { .rfmax = 400000, .val = 0x69 },
+       { .rfmax = 402000, .val = 0x6a },
+       { .rfmax = 403000, .val = 0x6b },
+       { .rfmax = 407000, .val = 0x6c },
+       { .rfmax = 408000, .val = 0x6d },
+       { .rfmax = 409000, .val = 0x6e },
+       { .rfmax = 410000, .val = 0x6f },
+       { .rfmax = 411000, .val = 0x70 },
+       { .rfmax = 412000, .val = 0x71 },
+       { .rfmax = 413000, .val = 0x72 },
+       { .rfmax = 414000, .val = 0x73 },
+       { .rfmax = 417000, .val = 0x74 },
+       { .rfmax = 418000, .val = 0x75 },
+       { .rfmax = 420000, .val = 0x76 },
+       { .rfmax = 422000, .val = 0x77 },
+       { .rfmax = 423000, .val = 0x78 },
+       { .rfmax = 424000, .val = 0x79 },
+       { .rfmax = 427000, .val = 0x7a },
+       { .rfmax = 428000, .val = 0x7b },
+       { .rfmax = 429000, .val = 0x7d },
+       { .rfmax = 432000, .val = 0x7f },
+       { .rfmax = 434000, .val = 0x80 },
+       { .rfmax = 435000, .val = 0x81 },
+       { .rfmax = 436000, .val = 0x83 },
+       { .rfmax = 437000, .val = 0x84 },
+       { .rfmax = 438000, .val = 0x85 },
+       { .rfmax = 439000, .val = 0x86 },
+       { .rfmax = 440000, .val = 0x87 },
+       { .rfmax = 441000, .val = 0x88 },
+       { .rfmax = 442000, .val = 0x89 },
+       { .rfmax = 445000, .val = 0x8a },
+       { .rfmax = 446000, .val = 0x8b },
+       { .rfmax = 447000, .val = 0x8c },
+       { .rfmax = 448000, .val = 0x8e },
+       { .rfmax = 449000, .val = 0x8f },
+       { .rfmax = 450000, .val = 0x90 },
+       { .rfmax = 452000, .val = 0x91 },
+       { .rfmax = 453000, .val = 0x93 },
+       { .rfmax = 454000, .val = 0x94 },
+       { .rfmax = 456000, .val = 0x96 },
+       { .rfmax = 457000, .val = 0x98 },
+       { .rfmax = 461000, .val = 0x11 },
+       { .rfmax = 468000, .val = 0x12 },
+       { .rfmax = 472000, .val = 0x13 },
+       { .rfmax = 473000, .val = 0x14 },
+       { .rfmax = 474000, .val = 0x15 },
+       { .rfmax = 481000, .val = 0x16 },
+       { .rfmax = 486000, .val = 0x17 },
+       { .rfmax = 491000, .val = 0x18 },
+       { .rfmax = 498000, .val = 0x19 },
+       { .rfmax = 499000, .val = 0x1a },
+       { .rfmax = 501000, .val = 0x1b },
+       { .rfmax = 506000, .val = 0x1c },
+       { .rfmax = 511000, .val = 0x1d },
+       { .rfmax = 516000, .val = 0x1e },
+       { .rfmax = 520000, .val = 0x1f },
+       { .rfmax = 521000, .val = 0x20 },
+       { .rfmax = 525000, .val = 0x21 },
+       { .rfmax = 529000, .val = 0x22 },
+       { .rfmax = 533000, .val = 0x23 },
+       { .rfmax = 539000, .val = 0x24 },
+       { .rfmax = 541000, .val = 0x25 },
+       { .rfmax = 547000, .val = 0x26 },
+       { .rfmax = 549000, .val = 0x27 },
+       { .rfmax = 551000, .val = 0x28 },
+       { .rfmax = 556000, .val = 0x29 },
+       { .rfmax = 561000, .val = 0x2a },
+       { .rfmax = 563000, .val = 0x2b },
+       { .rfmax = 565000, .val = 0x2c },
+       { .rfmax = 569000, .val = 0x2d },
+       { .rfmax = 571000, .val = 0x2e },
+       { .rfmax = 577000, .val = 0x2f },
+       { .rfmax = 580000, .val = 0x30 },
+       { .rfmax = 582000, .val = 0x31 },
+       { .rfmax = 584000, .val = 0x32 },
+       { .rfmax = 588000, .val = 0x33 },
+       { .rfmax = 591000, .val = 0x34 },
+       { .rfmax = 596000, .val = 0x35 },
+       { .rfmax = 598000, .val = 0x36 },
+       { .rfmax = 603000, .val = 0x37 },
+       { .rfmax = 604000, .val = 0x38 },
+       { .rfmax = 606000, .val = 0x39 },
+       { .rfmax = 612000, .val = 0x3a },
+       { .rfmax = 615000, .val = 0x3b },
+       { .rfmax = 617000, .val = 0x3c },
+       { .rfmax = 621000, .val = 0x3d },
+       { .rfmax = 622000, .val = 0x3e },
+       { .rfmax = 625000, .val = 0x3f },
+       { .rfmax = 632000, .val = 0x40 },
+       { .rfmax = 633000, .val = 0x41 },
+       { .rfmax = 634000, .val = 0x42 },
+       { .rfmax = 642000, .val = 0x43 },
+       { .rfmax = 643000, .val = 0x44 },
+       { .rfmax = 647000, .val = 0x45 },
+       { .rfmax = 650000, .val = 0x46 },
+       { .rfmax = 652000, .val = 0x47 },
+       { .rfmax = 657000, .val = 0x48 },
+       { .rfmax = 661000, .val = 0x49 },
+       { .rfmax = 662000, .val = 0x4a },
+       { .rfmax = 665000, .val = 0x4b },
+       { .rfmax = 667000, .val = 0x4c },
+       { .rfmax = 670000, .val = 0x4d },
+       { .rfmax = 673000, .val = 0x4e },
+       { .rfmax = 676000, .val = 0x4f },
+       { .rfmax = 677000, .val = 0x50 },
+       { .rfmax = 681000, .val = 0x51 },
+       { .rfmax = 683000, .val = 0x52 },
+       { .rfmax = 686000, .val = 0x53 },
+       { .rfmax = 688000, .val = 0x54 },
+       { .rfmax = 689000, .val = 0x55 },
+       { .rfmax = 691000, .val = 0x56 },
+       { .rfmax = 695000, .val = 0x57 },
+       { .rfmax = 698000, .val = 0x58 },
+       { .rfmax = 703000, .val = 0x59 },
+       { .rfmax = 704000, .val = 0x5a },
+       { .rfmax = 705000, .val = 0x5b },
+       { .rfmax = 707000, .val = 0x5c },
+       { .rfmax = 710000, .val = 0x5d },
+       { .rfmax = 712000, .val = 0x5e },
+       { .rfmax = 717000, .val = 0x5f },
+       { .rfmax = 718000, .val = 0x60 },
+       { .rfmax = 721000, .val = 0x61 },
+       { .rfmax = 722000, .val = 0x62 },
+       { .rfmax = 723000, .val = 0x63 },
+       { .rfmax = 725000, .val = 0x64 },
+       { .rfmax = 727000, .val = 0x65 },
+       { .rfmax = 730000, .val = 0x66 },
+       { .rfmax = 732000, .val = 0x67 },
+       { .rfmax = 735000, .val = 0x68 },
+       { .rfmax = 740000, .val = 0x69 },
+       { .rfmax = 741000, .val = 0x6a },
+       { .rfmax = 742000, .val = 0x6b },
+       { .rfmax = 743000, .val = 0x6c },
+       { .rfmax = 745000, .val = 0x6d },
+       { .rfmax = 747000, .val = 0x6e },
+       { .rfmax = 748000, .val = 0x6f },
+       { .rfmax = 750000, .val = 0x70 },
+       { .rfmax = 752000, .val = 0x71 },
+       { .rfmax = 754000, .val = 0x72 },
+       { .rfmax = 757000, .val = 0x73 },
+       { .rfmax = 758000, .val = 0x74 },
+       { .rfmax = 760000, .val = 0x75 },
+       { .rfmax = 763000, .val = 0x76 },
+       { .rfmax = 764000, .val = 0x77 },
+       { .rfmax = 766000, .val = 0x78 },
+       { .rfmax = 767000, .val = 0x79 },
+       { .rfmax = 768000, .val = 0x7a },
+       { .rfmax = 773000, .val = 0x7b },
+       { .rfmax = 774000, .val = 0x7c },
+       { .rfmax = 776000, .val = 0x7d },
+       { .rfmax = 777000, .val = 0x7e },
+       { .rfmax = 778000, .val = 0x7f },
+       { .rfmax = 779000, .val = 0x80 },
+       { .rfmax = 781000, .val = 0x81 },
+       { .rfmax = 783000, .val = 0x82 },
+       { .rfmax = 784000, .val = 0x83 },
+       { .rfmax = 785000, .val = 0x84 },
+       { .rfmax = 786000, .val = 0x85 },
+       { .rfmax = 793000, .val = 0x86 },
+       { .rfmax = 794000, .val = 0x87 },
+       { .rfmax = 795000, .val = 0x88 },
+       { .rfmax = 797000, .val = 0x89 },
+       { .rfmax = 799000, .val = 0x8a },
+       { .rfmax = 801000, .val = 0x8b },
+       { .rfmax = 802000, .val = 0x8c },
+       { .rfmax = 803000, .val = 0x8d },
+       { .rfmax = 804000, .val = 0x8e },
+       { .rfmax = 810000, .val = 0x90 },
+       { .rfmax = 811000, .val = 0x91 },
+       { .rfmax = 812000, .val = 0x92 },
+       { .rfmax = 814000, .val = 0x93 },
+       { .rfmax = 816000, .val = 0x94 },
+       { .rfmax = 817000, .val = 0x96 },
+       { .rfmax = 818000, .val = 0x97 },
+       { .rfmax = 820000, .val = 0x98 },
+       { .rfmax = 821000, .val = 0x99 },
+       { .rfmax = 822000, .val = 0x9a },
+       { .rfmax = 828000, .val = 0x9b },
+       { .rfmax = 829000, .val = 0x9d },
+       { .rfmax = 830000, .val = 0x9f },
+       { .rfmax = 831000, .val = 0xa0 },
+       { .rfmax = 833000, .val = 0xa1 },
+       { .rfmax = 835000, .val = 0xa2 },
+       { .rfmax = 836000, .val = 0xa3 },
+       { .rfmax = 837000, .val = 0xa4 },
+       { .rfmax = 838000, .val = 0xa6 },
+       { .rfmax = 840000, .val = 0xa8 },
+       { .rfmax = 842000, .val = 0xa9 },
+       { .rfmax = 845000, .val = 0xaa },
+       { .rfmax = 846000, .val = 0xab },
+       { .rfmax = 847000, .val = 0xad },
+       { .rfmax = 848000, .val = 0xae },
+       { .rfmax = 852000, .val = 0xaf },
+       { .rfmax = 853000, .val = 0xb0 },
+       { .rfmax = 858000, .val = 0xb1 },
+       { .rfmax = 860000, .val = 0xb2 },
+       { .rfmax = 861000, .val = 0xb3 },
+       { .rfmax = 862000, .val = 0xb4 },
+       { .rfmax = 863000, .val = 0xb6 },
+       { .rfmax = 864000, .val = 0xb8 },
+       { .rfmax = 865000, .val = 0xb9 },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+static struct tda18271_map tda18271_ir_measure[] = {
+       { .rfmax =  30000, .val = 4 },
+       { .rfmax = 200000, .val = 5 },
+       { .rfmax = 600000, .val = 6 },
+       { .rfmax = 865000, .val = 7 },
+       { .rfmax =      0, .val = 0 }, /* end */
+};
+
+static struct tda18271_map tda18271_rf_cal_dc_over_dt[] = {
+       { .rfmax =  47900, .val = 0x00 },
+       { .rfmax =  55000, .val = 0x00 },
+       { .rfmax =  61100, .val = 0x0a },
+       { .rfmax =  64000, .val = 0x0a },
+       { .rfmax =  82000, .val = 0x14 },
+       { .rfmax =  84000, .val = 0x19 },
+       { .rfmax = 119000, .val = 0x1c },
+       { .rfmax = 124000, .val = 0x20 },
+       { .rfmax = 129000, .val = 0x2a },
+       { .rfmax = 134000, .val = 0x32 },
+       { .rfmax = 139000, .val = 0x39 },
+       { .rfmax = 144000, .val = 0x3e },
+       { .rfmax = 149000, .val = 0x3f },
+       { .rfmax = 152600, .val = 0x40 },
+       { .rfmax = 154000, .val = 0x40 },
+       { .rfmax = 164700, .val = 0x41 },
+       { .rfmax = 203500, .val = 0x32 },
+       { .rfmax = 353000, .val = 0x19 },
+       { .rfmax = 356000, .val = 0x1a },
+       { .rfmax = 359000, .val = 0x1b },
+       { .rfmax = 363000, .val = 0x1c },
+       { .rfmax = 366000, .val = 0x1d },
+       { .rfmax = 369000, .val = 0x1e },
+       { .rfmax = 373000, .val = 0x1f },
+       { .rfmax = 376000, .val = 0x20 },
+       { .rfmax = 379000, .val = 0x21 },
+       { .rfmax = 383000, .val = 0x22 },
+       { .rfmax = 386000, .val = 0x23 },
+       { .rfmax = 389000, .val = 0x24 },
+       { .rfmax = 393000, .val = 0x25 },
+       { .rfmax = 396000, .val = 0x26 },
+       { .rfmax = 399000, .val = 0x27 },
+       { .rfmax = 402000, .val = 0x28 },
+       { .rfmax = 404000, .val = 0x29 },
+       { .rfmax = 407000, .val = 0x2a },
+       { .rfmax = 409000, .val = 0x2b },
+       { .rfmax = 412000, .val = 0x2c },
+       { .rfmax = 414000, .val = 0x2d },
+       { .rfmax = 417000, .val = 0x2e },
+       { .rfmax = 419000, .val = 0x2f },
+       { .rfmax = 422000, .val = 0x30 },
+       { .rfmax = 424000, .val = 0x31 },
+       { .rfmax = 427000, .val = 0x32 },
+       { .rfmax = 429000, .val = 0x33 },
+       { .rfmax = 432000, .val = 0x34 },
+       { .rfmax = 434000, .val = 0x35 },
+       { .rfmax = 437000, .val = 0x36 },
+       { .rfmax = 439000, .val = 0x37 },
+       { .rfmax = 442000, .val = 0x38 },
+       { .rfmax = 444000, .val = 0x39 },
+       { .rfmax = 447000, .val = 0x3a },
+       { .rfmax = 449000, .val = 0x3b },
+       { .rfmax = 457800, .val = 0x3c },
+       { .rfmax = 465000, .val = 0x0f },
+       { .rfmax = 477000, .val = 0x12 },
+       { .rfmax = 483000, .val = 0x14 },
+       { .rfmax = 502000, .val = 0x19 },
+       { .rfmax = 508000, .val = 0x1b },
+       { .rfmax = 519000, .val = 0x1c },
+       { .rfmax = 522000, .val = 0x1d },
+       { .rfmax = 524000, .val = 0x1e },
+       { .rfmax = 534000, .val = 0x1f },
+       { .rfmax = 549000, .val = 0x20 },
+       { .rfmax = 554000, .val = 0x22 },
+       { .rfmax = 584000, .val = 0x24 },
+       { .rfmax = 589000, .val = 0x26 },
+       { .rfmax = 658000, .val = 0x27 },
+       { .rfmax = 664000, .val = 0x2c },
+       { .rfmax = 669000, .val = 0x2d },
+       { .rfmax = 699000, .val = 0x2e },
+       { .rfmax = 704000, .val = 0x30 },
+       { .rfmax = 709000, .val = 0x31 },
+       { .rfmax = 714000, .val = 0x32 },
+       { .rfmax = 724000, .val = 0x33 },
+       { .rfmax = 729000, .val = 0x36 },
+       { .rfmax = 739000, .val = 0x38 },
+       { .rfmax = 744000, .val = 0x39 },
+       { .rfmax = 749000, .val = 0x3b },
+       { .rfmax = 754000, .val = 0x3c },
+       { .rfmax = 759000, .val = 0x3d },
+       { .rfmax = 764000, .val = 0x3e },
+       { .rfmax = 769000, .val = 0x3f },
+       { .rfmax = 774000, .val = 0x40 },
+       { .rfmax = 779000, .val = 0x41 },
+       { .rfmax = 784000, .val = 0x43 },
+       { .rfmax = 789000, .val = 0x46 },
+       { .rfmax = 794000, .val = 0x48 },
+       { .rfmax = 799000, .val = 0x4b },
+       { .rfmax = 804000, .val = 0x4f },
+       { .rfmax = 809000, .val = 0x54 },
+       { .rfmax = 814000, .val = 0x59 },
+       { .rfmax = 819000, .val = 0x5d },
+       { .rfmax = 824000, .val = 0x61 },
+       { .rfmax = 829000, .val = 0x68 },
+       { .rfmax = 834000, .val = 0x6e },
+       { .rfmax = 839000, .val = 0x75 },
+       { .rfmax = 844000, .val = 0x7e },
+       { .rfmax = 849000, .val = 0x82 },
+       { .rfmax = 854000, .val = 0x84 },
+       { .rfmax = 859000, .val = 0x8f },
+       { .rfmax = 865000, .val = 0x9a },
+       { .rfmax =      0, .val = 0x00 }, /* end */
+};
+
+/*---------------------------------------------------------------------*/
+
+struct tda18271_thermo_map {
+       u8 d;
+       u8 r0;
+       u8 r1;
+};
+
+static struct tda18271_thermo_map tda18271_thermometer[] = {
+       { .d = 0x00, .r0 = 60, .r1 =  92 },
+       { .d = 0x01, .r0 = 62, .r1 =  94 },
+       { .d = 0x02, .r0 = 66, .r1 =  98 },
+       { .d = 0x03, .r0 = 64, .r1 =  96 },
+       { .d = 0x04, .r0 = 74, .r1 = 106 },
+       { .d = 0x05, .r0 = 72, .r1 = 104 },
+       { .d = 0x06, .r0 = 68, .r1 = 100 },
+       { .d = 0x07, .r0 = 70, .r1 = 102 },
+       { .d = 0x08, .r0 = 90, .r1 = 122 },
+       { .d = 0x09, .r0 = 88, .r1 = 120 },
+       { .d = 0x0a, .r0 = 84, .r1 = 116 },
+       { .d = 0x0b, .r0 = 86, .r1 = 118 },
+       { .d = 0x0c, .r0 = 76, .r1 = 108 },
+       { .d = 0x0d, .r0 = 78, .r1 = 110 },
+       { .d = 0x0e, .r0 = 82, .r1 = 114 },
+       { .d = 0x0f, .r0 = 80, .r1 = 112 },
+       { .d = 0x00, .r0 =  0, .r1 =   0 }, /* end */
+};
+
+int tda18271_lookup_thermometer(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       unsigned char *regs = priv->tda18271_regs;
+       int val, i = 0;
+
+       while (tda18271_thermometer[i].d < (regs[R_TM] & 0x0f)) {
+               if (tda18271_thermometer[i + 1].d == 0)
+                       break;
+               i++;
+       }
+
+       if ((regs[R_TM] & 0x20) == 0x20)
+               val = tda18271_thermometer[i].r1;
+       else
+               val = tda18271_thermometer[i].r0;
+
+       tda_map("(%d) tm = %d\n", i, val);
+
+       return val;
+}
+
+/*---------------------------------------------------------------------*/
+
+struct tda18271_cid_target_map {
+       u32 rfmax;
+       u8  target;
+       u16 limit;
+};
+
+static struct tda18271_cid_target_map tda18271_cid_target[] = {
+       { .rfmax =  46000, .target = 0x04, .limit =  1800 },
+       { .rfmax =  52200, .target = 0x0a, .limit =  1500 },
+       { .rfmax =  79100, .target = 0x01, .limit =  4000 },
+       { .rfmax = 136800, .target = 0x18, .limit =  4000 },
+       { .rfmax = 156700, .target = 0x18, .limit =  4000 },
+       { .rfmax = 156700, .target = 0x18, .limit =  4000 },
+       { .rfmax = 186250, .target = 0x0a, .limit =  4000 },
+       { .rfmax = 230000, .target = 0x0a, .limit =  4000 },
+       { .rfmax = 345000, .target = 0x18, .limit =  4000 },
+       { .rfmax = 426000, .target = 0x0e, .limit =  4000 },
+       { .rfmax = 489500, .target = 0x1e, .limit =  4000 },
+       { .rfmax = 697500, .target = 0x32, .limit =  4000 },
+       { .rfmax = 842000, .target = 0x3a, .limit =  4000 },
+       { .rfmax =      0, .target = 0x00, .limit =     0 }, /* end */
+};
+
+int tda18271_lookup_cid_target(struct dvb_frontend *fe,
+                              u32 *freq, u8 *cid_target, u16 *count_limit)
+{
+       int i = 0;
+
+       while ((tda18271_cid_target[i].rfmax * 1000) < *freq) {
+               if (tda18271_cid_target[i + 1].rfmax == 0)
+                       break;
+               i++;
+       }
+       *cid_target  = tda18271_cid_target[i].target;
+       *count_limit = tda18271_cid_target[i].limit;
+
+       tda_map("(%d) cid_target = %02x, count_limit = %d\n", i,
+               tda18271_cid_target[i].target, tda18271_cid_target[i].limit);
+
+       return 0;
+}
+
+/*---------------------------------------------------------------------*/
+
+static struct tda18271_rf_tracking_filter_cal tda18271_rf_band_template[] = {
+       { .rfmax =  47900, .rfband = 0x00,
+         .rf1_def =  46000, .rf2_def =      0, .rf3_def =      0 },
+       { .rfmax =  61100, .rfband = 0x01,
+         .rf1_def =  52200, .rf2_def =      0, .rf3_def =      0 },
+       { .rfmax = 152600, .rfband = 0x02,
+         .rf1_def =  70100, .rf2_def = 136800, .rf3_def =      0 },
+       { .rfmax = 164700, .rfband = 0x03,
+         .rf1_def = 156700, .rf2_def =      0, .rf3_def =      0 },
+       { .rfmax = 203500, .rfband = 0x04,
+         .rf1_def = 186250, .rf2_def =      0, .rf3_def =      0 },
+       { .rfmax = 457800, .rfband = 0x05,
+         .rf1_def = 230000, .rf2_def = 345000, .rf3_def = 426000 },
+       { .rfmax = 865000, .rfband = 0x06,
+         .rf1_def = 489500, .rf2_def = 697500, .rf3_def = 842000 },
+       { .rfmax =      0, .rfband = 0x00,
+         .rf1_def =      0, .rf2_def =      0, .rf3_def =      0 }, /* end */
+};
+
+int tda18271_lookup_rf_band(struct dvb_frontend *fe, u32 *freq, u8 *rf_band)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
+       int i = 0;
+
+       while ((map[i].rfmax * 1000) < *freq) {
+               if (tda18271_debug & DBG_ADV)
+                       tda_map("(%d) rfmax = %d < freq = %d, "
+                               "rf1_def = %d, rf2_def = %d, rf3_def = %d, "
+                               "rf1 = %d, rf2 = %d, rf3 = %d, "
+                               "rf_a1 = %d, rf_a2 = %d, "
+                               "rf_b1 = %d, rf_b2 = %d\n",
+                               i, map[i].rfmax * 1000, *freq,
+                               map[i].rf1_def, map[i].rf2_def, map[i].rf3_def,
+                               map[i].rf1, map[i].rf2, map[i].rf3,
+                               map[i].rf_a1, map[i].rf_a2,
+                               map[i].rf_b1, map[i].rf_b2);
+               if (map[i].rfmax == 0)
+                       return -EINVAL;
+               i++;
+       }
+       if (rf_band)
+               *rf_band = map[i].rfband;
+
+       tda_map("(%d) rf_band = %02x\n", i, map[i].rfband);
+
+       return i;
+}
+
+/*---------------------------------------------------------------------*/
+
+struct tda18271_map_layout {
+       struct tda18271_pll_map *main_pll;
+       struct tda18271_pll_map *cal_pll;
+
+       struct tda18271_map *rf_cal;
+       struct tda18271_map *rf_cal_kmco;
+       struct tda18271_map *rf_cal_dc_over_dt;
+
+       struct tda18271_map *bp_filter;
+       struct tda18271_map *rf_band;
+       struct tda18271_map *gain_taper;
+       struct tda18271_map *ir_measure;
+};
+
+/*---------------------------------------------------------------------*/
+
+int tda18271_lookup_pll_map(struct dvb_frontend *fe,
+                           enum tda18271_map_type map_type,
+                           u32 *freq, u8 *post_div, u8 *div)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_pll_map *map = NULL;
+       unsigned int i = 0;
+       char *map_name;
+       int ret = 0;
+
+       BUG_ON(!priv->maps);
+
+       switch (map_type) {
+       case MAIN_PLL:
+               map = priv->maps->main_pll;
+               map_name = "main_pll";
+               break;
+       case CAL_PLL:
+               map = priv->maps->cal_pll;
+               map_name = "cal_pll";
+               break;
+       default:
+               /* we should never get here */
+               map_name = "undefined";
+               break;
+       }
+
+       if (!map) {
+               tda_warn("%s map is not set!\n", map_name);
+               ret = -EINVAL;
+               goto fail;
+       }
+
+       while ((map[i].lomax * 1000) < *freq) {
+               if (map[i + 1].lomax == 0) {
+                       tda_map("%s: frequency (%d) out of range\n",
+                               map_name, *freq);
+                       ret = -ERANGE;
+                       break;
+               }
+               i++;
+       }
+       *post_div = map[i].pd;
+       *div      = map[i].d;
+
+       tda_map("(%d) %s: post div = 0x%02x, div = 0x%02x\n",
+               i, map_name, *post_div, *div);
+fail:
+       return ret;
+}
+
+int tda18271_lookup_map(struct dvb_frontend *fe,
+                       enum tda18271_map_type map_type,
+                       u32 *freq, u8 *val)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       struct tda18271_map *map = NULL;
+       unsigned int i = 0;
+       char *map_name;
+       int ret = 0;
+
+       BUG_ON(!priv->maps);
+
+       switch (map_type) {
+       case BP_FILTER:
+               map = priv->maps->bp_filter;
+               map_name = "bp_filter";
+               break;
+       case RF_CAL_KMCO:
+               map = priv->maps->rf_cal_kmco;
+               map_name = "km";
+               break;
+       case RF_BAND:
+               map = priv->maps->rf_band;
+               map_name = "rf_band";
+               break;
+       case GAIN_TAPER:
+               map = priv->maps->gain_taper;
+               map_name = "gain_taper";
+               break;
+       case RF_CAL:
+               map = priv->maps->rf_cal;
+               map_name = "rf_cal";
+               break;
+       case IR_MEASURE:
+               map = priv->maps->ir_measure;
+               map_name = "ir_measure";
+               break;
+       case RF_CAL_DC_OVER_DT:
+               map = priv->maps->rf_cal_dc_over_dt;
+               map_name = "rf_cal_dc_over_dt";
+               break;
+       default:
+               /* we should never get here */
+               map_name = "undefined";
+               break;
+       }
+
+       if (!map) {
+               tda_warn("%s map is not set!\n", map_name);
+               ret = -EINVAL;
+               goto fail;
+       }
+
+       while ((map[i].rfmax * 1000) < *freq) {
+               if (map[i + 1].rfmax == 0) {
+                       tda_map("%s: frequency (%d) out of range\n",
+                               map_name, *freq);
+                       ret = -ERANGE;
+                       break;
+               }
+               i++;
+       }
+       *val = map[i].val;
+
+       tda_map("(%d) %s: 0x%02x\n", i, map_name, *val);
+fail:
+       return ret;
+}
+
+/*---------------------------------------------------------------------*/
+
+static struct tda18271_std_map tda18271c1_std_map = {
+       .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
+       .atv_b    = { .if_freq = 6750, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_dk   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+       .atv_gh   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+       .atv_i    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+       .atv_l    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+       .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 7,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
+       .atv_mn   = { .if_freq = 5750, .fm_rfn = 0, .agc_mode = 1, .std = 5,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
+       .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+       .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+       .dvbt_7   = { .if_freq = 3800, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+       .dvbt_8   = { .if_freq = 4300, .fm_rfn = 0, .agc_mode = 3, .std = 6,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1e */
+       .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+       .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
+};
+
+static struct tda18271_std_map tda18271c2_std_map = {
+       .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
+       .atv_b    = { .if_freq = 6000, .fm_rfn = 0, .agc_mode = 1, .std = 5,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
+       .atv_dk   = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_gh   = { .if_freq = 7100, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_i    = { .if_freq = 7250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_l    = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
+       .atv_mn   = { .if_freq = 5400, .fm_rfn = 0, .agc_mode = 1, .std = 4,
+                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0c */
+       .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+       .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+       .dvbt_7   = { .if_freq = 3500, .fm_rfn = 0, .agc_mode = 3, .std = 4,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
+       .dvbt_8   = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+       .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
+       .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
+                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
+};
+
+/*---------------------------------------------------------------------*/
+
+static struct tda18271_map_layout tda18271c1_map_layout = {
+       .main_pll          = tda18271c1_main_pll,
+       .cal_pll           = tda18271c1_cal_pll,
+
+       .rf_cal            = tda18271c1_rf_cal,
+       .rf_cal_kmco       = tda18271c1_km,
+
+       .bp_filter         = tda18271_bp_filter,
+       .rf_band           = tda18271_rf_band,
+       .gain_taper        = tda18271_gain_taper,
+       .ir_measure        = tda18271_ir_measure,
+};
+
+static struct tda18271_map_layout tda18271c2_map_layout = {
+       .main_pll          = tda18271c2_main_pll,
+       .cal_pll           = tda18271c2_cal_pll,
+
+       .rf_cal            = tda18271c2_rf_cal,
+       .rf_cal_kmco       = tda18271c2_km,
+
+       .rf_cal_dc_over_dt = tda18271_rf_cal_dc_over_dt,
+
+       .bp_filter         = tda18271_bp_filter,
+       .rf_band           = tda18271_rf_band,
+       .gain_taper        = tda18271_gain_taper,
+       .ir_measure        = tda18271_ir_measure,
+};
+
+int tda18271_assign_map_layout(struct dvb_frontend *fe)
+{
+       struct tda18271_priv *priv = fe->tuner_priv;
+       int ret = 0;
+
+       switch (priv->id) {
+       case TDA18271HDC1:
+               priv->maps = &tda18271c1_map_layout;
+               memcpy(&priv->std, &tda18271c1_std_map,
+                      sizeof(struct tda18271_std_map));
+               break;
+       case TDA18271HDC2:
+               priv->maps = &tda18271c2_map_layout;
+               memcpy(&priv->std, &tda18271c2_std_map,
+                      sizeof(struct tda18271_std_map));
+               break;
+       default:
+               ret = -EINVAL;
+               break;
+       }
+       memcpy(priv->rf_cal_state, &tda18271_rf_band_template,
+              sizeof(tda18271_rf_band_template));
+
+       return ret;
+}
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda18271-priv.h b/drivers/media/common/tuners/tda18271-priv.h
new file mode 100644 (file)
index 0000000..2bc5eb3
--- /dev/null
@@ -0,0 +1,220 @@
+/*
+    tda18271-priv.h - private header for the NXP TDA18271 silicon tuner
+
+    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TDA18271_PRIV_H__
+#define __TDA18271_PRIV_H__
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/mutex.h>
+#include "tuner-i2c.h"
+#include "tda18271.h"
+
+#define R_ID     0x00  /* ID byte                */
+#define R_TM     0x01  /* Thermo byte            */
+#define R_PL     0x02  /* Power level byte       */
+#define R_EP1    0x03  /* Easy Prog byte 1       */
+#define R_EP2    0x04  /* Easy Prog byte 2       */
+#define R_EP3    0x05  /* Easy Prog byte 3       */
+#define R_EP4    0x06  /* Easy Prog byte 4       */
+#define R_EP5    0x07  /* Easy Prog byte 5       */
+#define R_CPD    0x08  /* Cal Post-Divider byte  */
+#define R_CD1    0x09  /* Cal Divider byte 1     */
+#define R_CD2    0x0a  /* Cal Divider byte 2     */
+#define R_CD3    0x0b  /* Cal Divider byte 3     */
+#define R_MPD    0x0c  /* Main Post-Divider byte */
+#define R_MD1    0x0d  /* Main Divider byte 1    */
+#define R_MD2    0x0e  /* Main Divider byte 2    */
+#define R_MD3    0x0f  /* Main Divider byte 3    */
+#define R_EB1    0x10  /* Extended byte 1        */
+#define R_EB2    0x11  /* Extended byte 2        */
+#define R_EB3    0x12  /* Extended byte 3        */
+#define R_EB4    0x13  /* Extended byte 4        */
+#define R_EB5    0x14  /* Extended byte 5        */
+#define R_EB6    0x15  /* Extended byte 6        */
+#define R_EB7    0x16  /* Extended byte 7        */
+#define R_EB8    0x17  /* Extended byte 8        */
+#define R_EB9    0x18  /* Extended byte 9        */
+#define R_EB10   0x19  /* Extended byte 10       */
+#define R_EB11   0x1a  /* Extended byte 11       */
+#define R_EB12   0x1b  /* Extended byte 12       */
+#define R_EB13   0x1c  /* Extended byte 13       */
+#define R_EB14   0x1d  /* Extended byte 14       */
+#define R_EB15   0x1e  /* Extended byte 15       */
+#define R_EB16   0x1f  /* Extended byte 16       */
+#define R_EB17   0x20  /* Extended byte 17       */
+#define R_EB18   0x21  /* Extended byte 18       */
+#define R_EB19   0x22  /* Extended byte 19       */
+#define R_EB20   0x23  /* Extended byte 20       */
+#define R_EB21   0x24  /* Extended byte 21       */
+#define R_EB22   0x25  /* Extended byte 22       */
+#define R_EB23   0x26  /* Extended byte 23       */
+
+#define TDA18271_NUM_REGS 39
+
+/*---------------------------------------------------------------------*/
+
+struct tda18271_rf_tracking_filter_cal {
+       u32 rfmax;
+       u8  rfband;
+       u32 rf1_def;
+       u32 rf2_def;
+       u32 rf3_def;
+       u32 rf1;
+       u32 rf2;
+       u32 rf3;
+       int rf_a1;
+       int rf_b1;
+       int rf_a2;
+       int rf_b2;
+};
+
+enum tda18271_pll {
+       TDA18271_MAIN_PLL,
+       TDA18271_CAL_PLL,
+};
+
+enum tda18271_mode {
+       TDA18271_ANALOG,
+       TDA18271_DIGITAL,
+};
+
+struct tda18271_map_layout;
+
+enum tda18271_ver {
+       TDA18271HDC1,
+       TDA18271HDC2,
+};
+
+struct tda18271_priv {
+       unsigned char tda18271_regs[TDA18271_NUM_REGS];
+
+       struct list_head        hybrid_tuner_instance_list;
+       struct tuner_i2c_props  i2c_props;
+
+       enum tda18271_mode mode;
+       enum tda18271_role role;
+       enum tda18271_i2c_gate gate;
+       enum tda18271_ver id;
+
+       unsigned int tm_rfcal;
+       unsigned int cal_initialized:1;
+       unsigned int small_i2c:1;
+
+       struct tda18271_map_layout *maps;
+       struct tda18271_std_map std;
+       struct tda18271_rf_tracking_filter_cal rf_cal_state[8];
+
+       struct mutex lock;
+
+       u32 frequency;
+       u32 bandwidth;
+};
+
+/*---------------------------------------------------------------------*/
+
+extern int tda18271_debug;
+
+#define DBG_INFO 1
+#define DBG_MAP  2
+#define DBG_REG  4
+#define DBG_ADV  8
+#define DBG_CAL  16
+
+#define tda_printk(kern, fmt, arg...) \
+       printk(kern "%s: " fmt, __func__, ##arg)
+
+#define dprintk(kern, lvl, fmt, arg...) do {\
+       if (tda18271_debug & lvl) \
+               tda_printk(kern, fmt, ##arg); } while (0)
+
+#define tda_info(fmt, arg...) printk(KERN_INFO              fmt, ##arg)
+#define tda_warn(fmt, arg...) tda_printk(KERN_WARNING,      fmt, ##arg)
+#define tda_err(fmt, arg...)  tda_printk(KERN_ERR,          fmt, ##arg)
+#define tda_dbg(fmt, arg...)  dprintk(KERN_DEBUG, DBG_INFO, fmt, ##arg)
+#define tda_map(fmt, arg...)  dprintk(KERN_DEBUG, DBG_MAP,  fmt, ##arg)
+#define tda_reg(fmt, arg...)  dprintk(KERN_DEBUG, DBG_REG,  fmt, ##arg)
+#define tda_cal(fmt, arg...)  dprintk(KERN_DEBUG, DBG_CAL,  fmt, ##arg)
+
+/*---------------------------------------------------------------------*/
+
+enum tda18271_map_type {
+       /* tda18271_pll_map */
+       MAIN_PLL,
+       CAL_PLL,
+       /* tda18271_map */
+       RF_CAL,
+       RF_CAL_KMCO,
+       RF_CAL_DC_OVER_DT,
+       BP_FILTER,
+       RF_BAND,
+       GAIN_TAPER,
+       IR_MEASURE,
+};
+
+extern int tda18271_lookup_pll_map(struct dvb_frontend *fe,
+                                  enum tda18271_map_type map_type,
+                                  u32 *freq, u8 *post_div, u8 *div);
+extern int tda18271_lookup_map(struct dvb_frontend *fe,
+                              enum tda18271_map_type map_type,
+                              u32 *freq, u8 *val);
+
+extern int tda18271_lookup_thermometer(struct dvb_frontend *fe);
+
+extern int tda18271_lookup_rf_band(struct dvb_frontend *fe,
+                                  u32 *freq, u8 *rf_band);
+
+extern int tda18271_lookup_cid_target(struct dvb_frontend *fe,
+                                     u32 *freq, u8 *cid_target,
+                                     u16 *count_limit);
+
+extern int tda18271_assign_map_layout(struct dvb_frontend *fe);
+
+/*---------------------------------------------------------------------*/
+
+extern int tda18271_read_regs(struct dvb_frontend *fe);
+extern int tda18271_read_extended(struct dvb_frontend *fe);
+extern int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len);
+extern int tda18271_init_regs(struct dvb_frontend *fe);
+
+extern int tda18271_charge_pump_source(struct dvb_frontend *fe,
+                                      enum tda18271_pll pll, int force);
+extern int tda18271_set_standby_mode(struct dvb_frontend *fe,
+                                    int sm, int sm_lt, int sm_xt);
+
+extern int tda18271_calc_main_pll(struct dvb_frontend *fe, u32 freq);
+extern int tda18271_calc_cal_pll(struct dvb_frontend *fe, u32 freq);
+
+extern int tda18271_calc_bp_filter(struct dvb_frontend *fe, u32 *freq);
+extern int tda18271_calc_km(struct dvb_frontend *fe, u32 *freq);
+extern int tda18271_calc_rf_band(struct dvb_frontend *fe, u32 *freq);
+extern int tda18271_calc_gain_taper(struct dvb_frontend *fe, u32 *freq);
+extern int tda18271_calc_ir_measure(struct dvb_frontend *fe, u32 *freq);
+extern int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq);
+
+#endif /* __TDA18271_PRIV_H__ */
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda18271.h b/drivers/media/common/tuners/tda18271.h
new file mode 100644 (file)
index 0000000..0e7af8d
--- /dev/null
@@ -0,0 +1,99 @@
+/*
+    tda18271.h - header for the Philips / NXP TDA18271 silicon tuner
+
+    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TDA18271_H__
+#define __TDA18271_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+struct tda18271_std_map_item {
+       u16 if_freq;
+
+       /* EP3[4:3] */
+       unsigned int agc_mode:2;
+       /* EP3[2:0] */
+       unsigned int std:3;
+       /* EP4[7] */
+       unsigned int fm_rfn:1;
+       /* EP4[4:2] */
+       unsigned int if_lvl:3;
+       /* EB22[6:0] */
+       unsigned int rfagc_top:7;
+};
+
+struct tda18271_std_map {
+       struct tda18271_std_map_item fm_radio;
+       struct tda18271_std_map_item atv_b;
+       struct tda18271_std_map_item atv_dk;
+       struct tda18271_std_map_item atv_gh;
+       struct tda18271_std_map_item atv_i;
+       struct tda18271_std_map_item atv_l;
+       struct tda18271_std_map_item atv_lc;
+       struct tda18271_std_map_item atv_mn;
+       struct tda18271_std_map_item atsc_6;
+       struct tda18271_std_map_item dvbt_6;
+       struct tda18271_std_map_item dvbt_7;
+       struct tda18271_std_map_item dvbt_8;
+       struct tda18271_std_map_item qam_6;
+       struct tda18271_std_map_item qam_8;
+};
+
+enum tda18271_role {
+       TDA18271_MASTER = 0,
+       TDA18271_SLAVE,
+};
+
+enum tda18271_i2c_gate {
+       TDA18271_GATE_AUTO = 0,
+       TDA18271_GATE_ANALOG,
+       TDA18271_GATE_DIGITAL,
+};
+
+struct tda18271_config {
+       /* override default if freq / std settings (optional) */
+       struct tda18271_std_map *std_map;
+
+       /* master / slave tuner: master uses main pll, slave uses cal pll */
+       enum tda18271_role role;
+
+       /* use i2c gate provided by analog or digital demod */
+       enum tda18271_i2c_gate gate;
+
+       /* some i2c providers cant write all 39 registers at once */
+       unsigned int small_i2c:1;
+};
+
+#if defined(CONFIG_DVB_TDA18271) || (defined(CONFIG_DVB_TDA18271_MODULE) && defined(MODULE))
+extern struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
+                                           struct i2c_adapter *i2c,
+                                           struct tda18271_config *cfg);
+#else
+static inline struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe,
+                                                  u8 addr,
+                                                  struct i2c_adapter *i2c,
+                                                  struct tda18271_config *cfg)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TDA18271_H__ */
diff --git a/drivers/media/common/tuners/tda827x.c b/drivers/media/common/tuners/tda827x.c
new file mode 100644 (file)
index 0000000..d30d2c9
--- /dev/null
@@ -0,0 +1,852 @@
+/*
+ *
+ * (c) 2005 Hartmut Hackmann
+ * (c) 2007 Michael Krufky
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <asm/types.h>
+#include <linux/dvb/frontend.h>
+#include <linux/videodev2.h>
+
+#include "tda827x.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
+
+#define dprintk(args...) \
+       do {                                        \
+               if (debug) printk(KERN_DEBUG "tda827x: " args); \
+       } while (0)
+
+struct tda827x_priv {
+       int i2c_addr;
+       struct i2c_adapter *i2c_adap;
+       struct tda827x_config *cfg;
+
+       unsigned int sgIF;
+       unsigned char lpsel;
+
+       u32 frequency;
+       u32 bandwidth;
+};
+
+static void tda827x_set_std(struct dvb_frontend *fe,
+                           struct analog_parameters *params)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       char *mode;
+
+       priv->lpsel = 0;
+       if (params->std & V4L2_STD_MN) {
+               priv->sgIF = 92;
+               priv->lpsel = 1;
+               mode = "MN";
+       } else if (params->std & V4L2_STD_B) {
+               priv->sgIF = 108;
+               mode = "B";
+       } else if (params->std & V4L2_STD_GH) {
+               priv->sgIF = 124;
+               mode = "GH";
+       } else if (params->std & V4L2_STD_PAL_I) {
+               priv->sgIF = 124;
+               mode = "I";
+       } else if (params->std & V4L2_STD_DK) {
+               priv->sgIF = 124;
+               mode = "DK";
+       } else if (params->std & V4L2_STD_SECAM_L) {
+               priv->sgIF = 124;
+               mode = "L";
+       } else if (params->std & V4L2_STD_SECAM_LC) {
+               priv->sgIF = 20;
+               mode = "LC";
+       } else {
+               priv->sgIF = 124;
+               mode = "xx";
+       }
+
+       if (params->mode == V4L2_TUNER_RADIO)
+               priv->sgIF = 88; /* if frequency is 5.5 MHz */
+
+       dprintk("setting tda827x to system %s\n", mode);
+}
+
+
+/* ------------------------------------------------------------------ */
+
+struct tda827x_data {
+       u32 lomax;
+       u8  spd;
+       u8  bs;
+       u8  bp;
+       u8  cp;
+       u8  gc3;
+       u8 div1p5;
+};
+
+static const struct tda827x_data tda827x_table[] = {
+       { .lomax =  62000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
+       { .lomax =  66000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
+       { .lomax =  76000000, .spd = 3, .bs = 1, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
+       { .lomax =  84000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
+       { .lomax =  93000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax =  98000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 109000000, .spd = 3, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 123000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 133000000, .spd = 2, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 151000000, .spd = 2, .bs = 1, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 154000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 181000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 0, .div1p5 = 0},
+       { .lomax = 185000000, .spd = 2, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 217000000, .spd = 2, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 244000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 265000000, .spd = 1, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 302000000, .spd = 1, .bs = 1, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 324000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 370000000, .spd = 1, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 454000000, .spd = 1, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 493000000, .spd = 0, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 530000000, .spd = 0, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
+       { .lomax = 554000000, .spd = 0, .bs = 1, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
+       { .lomax = 604000000, .spd = 0, .bs = 1, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
+       { .lomax = 696000000, .spd = 0, .bs = 2, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
+       { .lomax = 740000000, .spd = 0, .bs = 2, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
+       { .lomax = 820000000, .spd = 0, .bs = 3, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
+       { .lomax = 865000000, .spd = 0, .bs = 3, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
+       { .lomax =         0, .spd = 0, .bs = 0, .bp = 0, .cp = 0, .gc3 = 0, .div1p5 = 0}
+};
+
+static int tda827xo_set_params(struct dvb_frontend *fe,
+                              struct dvb_frontend_parameters *params)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       u8 buf[14];
+
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = buf, .len = sizeof(buf) };
+       int i, tuner_freq, if_freq;
+       u32 N;
+
+       dprintk("%s:\n", __func__);
+       switch (params->u.ofdm.bandwidth) {
+       case BANDWIDTH_6_MHZ:
+               if_freq = 4000000;
+               break;
+       case BANDWIDTH_7_MHZ:
+               if_freq = 4500000;
+               break;
+       default:                   /* 8 MHz or Auto */
+               if_freq = 5000000;
+               break;
+       }
+       tuner_freq = params->frequency + if_freq;
+
+       i = 0;
+       while (tda827x_table[i].lomax < tuner_freq) {
+               if (tda827x_table[i + 1].lomax == 0)
+                       break;
+               i++;
+       }
+
+       N = ((tuner_freq + 125000) / 250000) << (tda827x_table[i].spd + 2);
+       buf[0] = 0;
+       buf[1] = (N>>8) | 0x40;
+       buf[2] = N & 0xff;
+       buf[3] = 0;
+       buf[4] = 0x52;
+       buf[5] = (tda827x_table[i].spd << 6) + (tda827x_table[i].div1p5 << 5) +
+                               (tda827x_table[i].bs << 3) +
+                               tda827x_table[i].bp;
+       buf[6] = (tda827x_table[i].gc3 << 4) + 0x8f;
+       buf[7] = 0xbf;
+       buf[8] = 0x2a;
+       buf[9] = 0x05;
+       buf[10] = 0xff;
+       buf[11] = 0x00;
+       buf[12] = 0x00;
+       buf[13] = 0x40;
+
+       msg.len = 14;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
+               printk("%s: could not write to tuner at addr: 0x%02x\n",
+                      __func__, priv->i2c_addr << 1);
+               return -EIO;
+       }
+       msleep(500);
+       /* correct CP value */
+       buf[0] = 0x30;
+       buf[1] = 0x50 + tda827x_table[i].cp;
+       msg.len = 2;
+
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       priv->frequency = tuner_freq - if_freq; // FIXME
+       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
+
+       return 0;
+}
+
+static int tda827xo_sleep(struct dvb_frontend *fe)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       static u8 buf[] = { 0x30, 0xd0 };
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = buf, .len = sizeof(buf) };
+
+       dprintk("%s:\n", __func__);
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       if (priv->cfg && priv->cfg->sleep)
+               priv->cfg->sleep(fe);
+
+       return 0;
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda827xo_set_analog_params(struct dvb_frontend *fe,
+                                     struct analog_parameters *params)
+{
+       unsigned char tuner_reg[8];
+       unsigned char reg2[2];
+       u32 N;
+       int i;
+       struct tda827x_priv *priv = fe->tuner_priv;
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0 };
+       unsigned int freq = params->frequency;
+
+       tda827x_set_std(fe, params);
+
+       if (params->mode == V4L2_TUNER_RADIO)
+               freq = freq / 1000;
+
+       N = freq + priv->sgIF;
+
+       i = 0;
+       while (tda827x_table[i].lomax < N * 62500) {
+               if (tda827x_table[i + 1].lomax == 0)
+                       break;
+               i++;
+       }
+
+       N = N << tda827x_table[i].spd;
+
+       tuner_reg[0] = 0;
+       tuner_reg[1] = (unsigned char)(N>>8);
+       tuner_reg[2] = (unsigned char) N;
+       tuner_reg[3] = 0x40;
+       tuner_reg[4] = 0x52 + (priv->lpsel << 5);
+       tuner_reg[5] = (tda827x_table[i].spd    << 6) +
+                      (tda827x_table[i].div1p5 << 5) +
+                      (tda827x_table[i].bs     << 3) + tda827x_table[i].bp;
+       tuner_reg[6] = 0x8f + (tda827x_table[i].gc3 << 4);
+       tuner_reg[7] = 0x8f;
+
+       msg.buf = tuner_reg;
+       msg.len = 8;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msg.buf = reg2;
+       msg.len = 2;
+       reg2[0] = 0x80;
+       reg2[1] = 0;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       reg2[0] = 0x60;
+       reg2[1] = 0xbf;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       reg2[0] = 0x30;
+       reg2[1] = tuner_reg[4] + 0x80;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(1);
+       reg2[0] = 0x30;
+       reg2[1] = tuner_reg[4] + 4;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(1);
+       reg2[0] = 0x30;
+       reg2[1] = tuner_reg[4];
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(550);
+       reg2[0] = 0x30;
+       reg2[1] = (tuner_reg[4] & 0xfc) + tda827x_table[i].cp;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       reg2[0] = 0x60;
+       reg2[1] = 0x3f;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       reg2[0] = 0x80;
+       reg2[1] = 0x08;   /* Vsync en */
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       priv->frequency = freq * 62500;
+
+       return 0;
+}
+
+static void tda827xo_agcf(struct dvb_frontend *fe)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       unsigned char data[] = { 0x80, 0x0c };
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = data, .len = 2};
+
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+}
+
+/* ------------------------------------------------------------------ */
+
+struct tda827xa_data {
+       u32 lomax;
+       u8  svco;
+       u8  spd;
+       u8  scr;
+       u8  sbs;
+       u8  gc3;
+};
+
+static const struct tda827xa_data tda827xa_dvbt[] = {
+       { .lomax =  56875000, .svco = 3, .spd = 4, .scr = 0, .sbs = 0, .gc3 = 1},
+       { .lomax =  67250000, .svco = 0, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
+       { .lomax =  81250000, .svco = 1, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
+       { .lomax =  97500000, .svco = 2, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
+       { .lomax = 113750000, .svco = 3, .spd = 3, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 134500000, .svco = 0, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 154000000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 162500000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 183000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 195000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 227500000, .svco = 3, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 269000000, .svco = 0, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 290000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 325000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 390000000, .svco = 2, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 455000000, .svco = 3, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 520000000, .svco = 0, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 538000000, .svco = 0, .spd = 0, .scr = 1, .sbs = 3, .gc3 = 1},
+       { .lomax = 550000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 620000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 650000000, .svco = 1, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 700000000, .svco = 2, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 780000000, .svco = 2, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 820000000, .svco = 3, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 870000000, .svco = 3, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 911000000, .svco = 3, .spd = 0, .scr = 2, .sbs = 4, .gc3 = 0},
+       { .lomax =         0, .svco = 0, .spd = 0, .scr = 0, .sbs = 0, .gc3 = 0}
+};
+
+static struct tda827xa_data tda827xa_analog[] = {
+       { .lomax =  56875000, .svco = 3, .spd = 4, .scr = 0, .sbs = 0, .gc3 = 3},
+       { .lomax =  67250000, .svco = 0, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
+       { .lomax =  81250000, .svco = 1, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
+       { .lomax =  97500000, .svco = 2, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
+       { .lomax = 113750000, .svco = 3, .spd = 3, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 134500000, .svco = 0, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 154000000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 162500000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 183000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
+       { .lomax = 195000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 227500000, .svco = 3, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 3},
+       { .lomax = 269000000, .svco = 0, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 3},
+       { .lomax = 325000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
+       { .lomax = 390000000, .svco = 2, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 3},
+       { .lomax = 455000000, .svco = 3, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 3},
+       { .lomax = 520000000, .svco = 0, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 538000000, .svco = 0, .spd = 0, .scr = 1, .sbs = 3, .gc3 = 1},
+       { .lomax = 554000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
+       { .lomax = 620000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 650000000, .svco = 1, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 700000000, .svco = 2, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 780000000, .svco = 2, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 820000000, .svco = 3, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
+       { .lomax = 870000000, .svco = 3, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
+       { .lomax = 911000000, .svco = 3, .spd = 0, .scr = 2, .sbs = 4, .gc3 = 0},
+       { .lomax =         0, .svco = 0, .spd = 0, .scr = 0, .sbs = 0, .gc3 = 0}
+};
+
+static int tda827xa_sleep(struct dvb_frontend *fe)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       static u8 buf[] = { 0x30, 0x90 };
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = buf, .len = sizeof(buf) };
+
+       dprintk("%s:\n", __func__);
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 0);
+
+       if (priv->cfg && priv->cfg->sleep)
+               priv->cfg->sleep(fe);
+
+       return 0;
+}
+
+static void tda827xa_lna_gain(struct dvb_frontend *fe, int high,
+                             struct analog_parameters *params)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       unsigned char buf[] = {0x22, 0x01};
+       int arg;
+       int gp_func;
+       struct i2c_msg msg = { .addr = priv->cfg->switch_addr, .flags = 0,
+                              .buf = buf, .len = sizeof(buf) };
+
+       if (NULL == priv->cfg) {
+               dprintk("tda827x_config not defined, cannot set LNA gain!\n");
+               return;
+       }
+       if (priv->cfg->config) {
+               if (high)
+                       dprintk("setting LNA to high gain\n");
+               else
+                       dprintk("setting LNA to low gain\n");
+       }
+       switch (priv->cfg->config) {
+       case 0: /* no LNA */
+               break;
+       case 1: /* switch is GPIO 0 of tda8290 */
+       case 2:
+               if (params == NULL) {
+                       gp_func = 0;
+                       arg  = 0;
+               } else {
+                       /* turn Vsync on */
+                       gp_func = 1;
+                       if (params->std & V4L2_STD_MN)
+                               arg = 1;
+                       else
+                               arg = 0;
+               }
+               if (priv->cfg->tuner_callback)
+                       priv->cfg->tuner_callback(priv->i2c_adap->algo_data,
+                                                               gp_func, arg);
+               buf[1] = high ? 0 : 1;
+               if (priv->cfg->config == 2)
+                       buf[1] = high ? 1 : 0;
+               i2c_transfer(priv->i2c_adap, &msg, 1);
+               break;
+       case 3: /* switch with GPIO of saa713x */
+               if (priv->cfg->tuner_callback)
+                       priv->cfg->tuner_callback(priv->i2c_adap->algo_data, 0, high);
+               break;
+       }
+}
+
+static int tda827xa_set_params(struct dvb_frontend *fe,
+                              struct dvb_frontend_parameters *params)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       u8 buf[11];
+
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = buf, .len = sizeof(buf) };
+
+       int i, tuner_freq, if_freq;
+       u32 N;
+
+       dprintk("%s:\n", __func__);
+
+       tda827xa_lna_gain(fe, 1, NULL);
+       msleep(20);
+
+       switch (params->u.ofdm.bandwidth) {
+       case BANDWIDTH_6_MHZ:
+               if_freq = 4000000;
+               break;
+       case BANDWIDTH_7_MHZ:
+               if_freq = 4500000;
+               break;
+       default:                   /* 8 MHz or Auto */
+               if_freq = 5000000;
+               break;
+       }
+       tuner_freq = params->frequency + if_freq;
+
+       i = 0;
+       while (tda827xa_dvbt[i].lomax < tuner_freq) {
+               if(tda827xa_dvbt[i + 1].lomax == 0)
+                       break;
+               i++;
+       }
+
+       N = ((tuner_freq + 31250) / 62500) << tda827xa_dvbt[i].spd;
+       buf[0] = 0;            // subaddress
+       buf[1] = N >> 8;
+       buf[2] = N & 0xff;
+       buf[3] = 0;
+       buf[4] = 0x16;
+       buf[5] = (tda827xa_dvbt[i].spd << 5) + (tda827xa_dvbt[i].svco << 3) +
+                       tda827xa_dvbt[i].sbs;
+       buf[6] = 0x4b + (tda827xa_dvbt[i].gc3 << 4);
+       buf[7] = 0x1c;
+       buf[8] = 0x06;
+       buf[9] = 0x24;
+       buf[10] = 0x00;
+       msg.len = 11;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
+               printk("%s: could not write to tuner at addr: 0x%02x\n",
+                      __func__, priv->i2c_addr << 1);
+               return -EIO;
+       }
+       buf[0] = 0x90;
+       buf[1] = 0xff;
+       buf[2] = 0x60;
+       buf[3] = 0x00;
+       buf[4] = 0x59;  // lpsel, for 6MHz + 2
+       msg.len = 5;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       buf[0] = 0xa0;
+       buf[1] = 0x40;
+       msg.len = 2;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(11);
+       msg.flags = I2C_M_RD;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+       msg.flags = 0;
+
+       buf[1] >>= 4;
+       dprintk("tda8275a AGC2 gain is: %d\n", buf[1]);
+       if ((buf[1]) < 2) {
+               tda827xa_lna_gain(fe, 0, NULL);
+               buf[0] = 0x60;
+               buf[1] = 0x0c;
+               if (fe->ops.i2c_gate_ctrl)
+                       fe->ops.i2c_gate_ctrl(fe, 1);
+               i2c_transfer(priv->i2c_adap, &msg, 1);
+       }
+
+       buf[0] = 0xc0;
+       buf[1] = 0x99;    // lpsel, for 6MHz + 2
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       buf[0] = 0x60;
+       buf[1] = 0x3c;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       /* correct CP value */
+       buf[0] = 0x30;
+       buf[1] = 0x10 + tda827xa_dvbt[i].scr;
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(163);
+       buf[0] = 0xc0;
+       buf[1] = 0x39;  // lpsel, for 6MHz + 2
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(3);
+       /* freeze AGC1 */
+       buf[0] = 0x50;
+       buf[1] = 0x4f + (tda827xa_dvbt[i].gc3 << 4);
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       priv->frequency = tuner_freq - if_freq; // FIXME
+       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
+
+       return 0;
+}
+
+
+static int tda827xa_set_analog_params(struct dvb_frontend *fe,
+                                     struct analog_parameters *params)
+{
+       unsigned char tuner_reg[11];
+       u32 N;
+       int i;
+       struct tda827x_priv *priv = fe->tuner_priv;
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
+                              .buf = tuner_reg, .len = sizeof(tuner_reg) };
+       unsigned int freq = params->frequency;
+
+       tda827x_set_std(fe, params);
+
+       tda827xa_lna_gain(fe, 1, params);
+       msleep(10);
+
+       if (params->mode == V4L2_TUNER_RADIO)
+               freq = freq / 1000;
+
+       N = freq + priv->sgIF;
+
+       i = 0;
+       while (tda827xa_analog[i].lomax < N * 62500) {
+               if (tda827xa_analog[i + 1].lomax == 0)
+                       break;
+               i++;
+       }
+
+       N = N << tda827xa_analog[i].spd;
+
+       tuner_reg[0] = 0;
+       tuner_reg[1] = (unsigned char)(N>>8);
+       tuner_reg[2] = (unsigned char) N;
+       tuner_reg[3] = 0;
+       tuner_reg[4] = 0x16;
+       tuner_reg[5] = (tda827xa_analog[i].spd << 5) +
+                      (tda827xa_analog[i].svco << 3) +
+                       tda827xa_analog[i].sbs;
+       tuner_reg[6] = 0x8b + (tda827xa_analog[i].gc3 << 4);
+       tuner_reg[7] = 0x1c;
+       tuner_reg[8] = 4;
+       tuner_reg[9] = 0x20;
+       tuner_reg[10] = 0x00;
+       msg.len = 11;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0x90;
+       tuner_reg[1] = 0xff;
+       tuner_reg[2] = 0xe0;
+       tuner_reg[3] = 0;
+       tuner_reg[4] = 0x99 + (priv->lpsel << 1);
+       msg.len = 5;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0xa0;
+       tuner_reg[1] = 0xc0;
+       msg.len = 2;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0x30;
+       tuner_reg[1] = 0x10 + tda827xa_analog[i].scr;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msg.flags = I2C_M_RD;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+       msg.flags = 0;
+       tuner_reg[1] >>= 4;
+       dprintk("AGC2 gain is: %d\n", tuner_reg[1]);
+       if (tuner_reg[1] < 1)
+               tda827xa_lna_gain(fe, 0, params);
+
+       msleep(100);
+       tuner_reg[0] = 0x60;
+       tuner_reg[1] = 0x3c;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       msleep(163);
+       tuner_reg[0] = 0x50;
+       tuner_reg[1] = 0x8f + (tda827xa_analog[i].gc3 << 4);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0x80;
+       tuner_reg[1] = 0x28;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0xb0;
+       tuner_reg[1] = 0x01;
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       tuner_reg[0] = 0xc0;
+       tuner_reg[1] = 0x19 + (priv->lpsel << 1);
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+
+       priv->frequency = freq * 62500;
+
+       return 0;
+}
+
+static void tda827xa_agcf(struct dvb_frontend *fe)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       unsigned char data[] = {0x80, 0x2c};
+       struct i2c_msg msg = {.addr = priv->i2c_addr, .flags = 0,
+                             .buf = data, .len = 2};
+       i2c_transfer(priv->i2c_adap, &msg, 1);
+}
+
+/* ------------------------------------------------------------------ */
+
+static int tda827x_release(struct dvb_frontend *fe)
+{
+       kfree(fe->tuner_priv);
+       fe->tuner_priv = NULL;
+       return 0;
+}
+
+static int tda827x_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+       return 0;
+}
+
+static int tda827x_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       *bandwidth = priv->bandwidth;
+       return 0;
+}
+
+static int tda827x_init(struct dvb_frontend *fe)
+{
+       struct tda827x_priv *priv = fe->tuner_priv;
+       dprintk("%s:\n", __func__);
+       if (priv->cfg && priv->cfg->init)
+               priv->cfg->init(fe);
+
+       return 0;
+}
+
+static int tda827x_probe_version(struct dvb_frontend *fe);
+
+static int tda827x_initial_init(struct dvb_frontend *fe)
+{
+       int ret;
+       ret = tda827x_probe_version(fe);
+       if (ret)
+               return ret;
+       return fe->ops.tuner_ops.init(fe);
+}
+
+static int tda827x_initial_sleep(struct dvb_frontend *fe)
+{
+       int ret;
+       ret = tda827x_probe_version(fe);
+       if (ret)
+               return ret;
+       return fe->ops.tuner_ops.sleep(fe);
+}
+
+static struct dvb_tuner_ops tda827xo_tuner_ops = {
+       .info = {
+               .name = "Philips TDA827X",
+               .frequency_min  =  55000000,
+               .frequency_max  = 860000000,
+               .frequency_step =    250000
+       },
+       .release = tda827x_release,
+       .init = tda827x_initial_init,
+       .sleep = tda827x_initial_sleep,
+       .set_params = tda827xo_set_params,
+       .set_analog_params = tda827xo_set_analog_params,
+       .get_frequency = tda827x_get_frequency,
+       .get_bandwidth = tda827x_get_bandwidth,
+};
+
+static struct dvb_tuner_ops tda827xa_tuner_ops = {
+       .info = {
+               .name = "Philips TDA827XA",
+               .frequency_min  =  44000000,
+               .frequency_max  = 906000000,
+               .frequency_step =     62500
+       },
+       .release = tda827x_release,
+       .init = tda827x_init,
+       .sleep = tda827xa_sleep,
+       .set_params = tda827xa_set_params,
+       .set_analog_params = tda827xa_set_analog_params,
+       .get_frequency = tda827x_get_frequency,
+       .get_bandwidth = tda827x_get_bandwidth,
+};
+
+static int tda827x_probe_version(struct dvb_frontend *fe)
+{      u8 data;
+       struct tda827x_priv *priv = fe->tuner_priv;
+       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = I2C_M_RD,
+                              .buf = &data, .len = 1 };
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
+               printk("%s: could not read from tuner at addr: 0x%02x\n",
+                      __func__, msg.addr << 1);
+               return -EIO;
+       }
+       if ((data & 0x3c) == 0) {
+               dprintk("tda827x tuner found\n");
+               fe->ops.tuner_ops.init  = tda827x_init;
+               fe->ops.tuner_ops.sleep = tda827xo_sleep;
+               if (priv->cfg)
+                       priv->cfg->agcf = tda827xo_agcf;
+       } else {
+               dprintk("tda827xa tuner found\n");
+               memcpy(&fe->ops.tuner_ops, &tda827xa_tuner_ops, sizeof(struct dvb_tuner_ops));
+               if (priv->cfg)
+                       priv->cfg->agcf = tda827xa_agcf;
+       }
+       return 0;
+}
+
+struct dvb_frontend *tda827x_attach(struct dvb_frontend *fe, int addr,
+                                   struct i2c_adapter *i2c,
+                                   struct tda827x_config *cfg)
+{
+       struct tda827x_priv *priv = NULL;
+
+       dprintk("%s:\n", __func__);
+       priv = kzalloc(sizeof(struct tda827x_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+
+       priv->i2c_addr = addr;
+       priv->i2c_adap = i2c;
+       priv->cfg = cfg;
+       memcpy(&fe->ops.tuner_ops, &tda827xo_tuner_ops, sizeof(struct dvb_tuner_ops));
+       fe->tuner_priv = priv;
+
+       dprintk("type set to %s\n", fe->ops.tuner_ops.info.name);
+
+       return fe;
+}
+EXPORT_SYMBOL_GPL(tda827x_attach);
+
+MODULE_DESCRIPTION("DVB TDA827x driver");
+MODULE_AUTHOR("Hartmut Hackmann <hartmut.hackmann@t-online.de>");
+MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
+MODULE_LICENSE("GPL");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda827x.h b/drivers/media/common/tuners/tda827x.h
new file mode 100644 (file)
index 0000000..b73c235
--- /dev/null
@@ -0,0 +1,69 @@
+  /*
+     DVB Driver for Philips tda827x / tda827xa Silicon tuners
+
+     (c) 2005 Hartmut Hackmann
+     (c) 2007 Michael Krufky
+
+     This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+
+     This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
+     GNU General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+  */
+
+#ifndef __DVB_TDA827X_H__
+#define __DVB_TDA827X_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+struct tda827x_config
+{
+       /* saa7134 - provided callbacks */
+       int (*init) (struct dvb_frontend *fe);
+       int (*sleep) (struct dvb_frontend *fe);
+
+       /* interface to tda829x driver */
+       unsigned int config;
+       int          switch_addr;
+       int (*tuner_callback) (void *dev, int command, int arg);
+
+       void (*agcf)(struct dvb_frontend *fe);
+};
+
+
+/**
+ * Attach a tda827x tuner to the supplied frontend structure.
+ *
+ * @param fe Frontend to attach to.
+ * @param addr i2c address of the tuner.
+ * @param i2c i2c adapter to use.
+ * @param cfg optional callback function pointers.
+ * @return FE pointer on success, NULL on failure.
+ */
+#if defined(CONFIG_DVB_TDA827X) || (defined(CONFIG_DVB_TDA827X_MODULE) && defined(MODULE))
+extern struct dvb_frontend* tda827x_attach(struct dvb_frontend *fe, int addr,
+                                          struct i2c_adapter *i2c,
+                                          struct tda827x_config *cfg);
+#else
+static inline struct dvb_frontend* tda827x_attach(struct dvb_frontend *fe,
+                                                 int addr,
+                                                 struct i2c_adapter *i2c,
+                                                 struct tda827x_config *cfg)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif // CONFIG_DVB_TDA827X
+
+#endif // __DVB_TDA827X_H__
diff --git a/drivers/media/common/tuners/tda8290.c b/drivers/media/common/tuners/tda8290.c
new file mode 100644 (file)
index 0000000..0ebb5b5
--- /dev/null
@@ -0,0 +1,804 @@
+/*
+
+   i2c tv tuner chip device driver
+   controls the philips tda8290+75 tuner chip combo.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   This "tda8290" module was split apart from the original "tuner" module.
+*/
+
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/videodev.h>
+#include "tuner-i2c.h"
+#include "tda8290.h"
+#include "tda827x.h"
+#include "tda18271.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+/* ---------------------------------------------------------------------- */
+
+struct tda8290_priv {
+       struct tuner_i2c_props i2c_props;
+
+       unsigned char tda8290_easy_mode;
+
+       unsigned char tda827x_addr;
+
+       unsigned char ver;
+#define TDA8290   1
+#define TDA8295   2
+#define TDA8275   4
+#define TDA8275A  8
+#define TDA18271 16
+
+       struct tda827x_config cfg;
+};
+
+/*---------------------------------------------------------------------*/
+
+static int tda8290_i2c_bridge(struct dvb_frontend *fe, int close)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char  enable[2] = { 0x21, 0xC0 };
+       unsigned char disable[2] = { 0x21, 0x00 };
+       unsigned char *msg;
+
+       if (close) {
+               msg = enable;
+               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
+               /* let the bridge stabilize */
+               msleep(20);
+       } else {
+               msg = disable;
+               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
+       }
+
+       return 0;
+}
+
+static int tda8295_i2c_bridge(struct dvb_frontend *fe, int close)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char  enable[2] = { 0x45, 0xc1 };
+       unsigned char disable[2] = { 0x46, 0x00 };
+       unsigned char buf[3] = { 0x45, 0x01, 0x00 };
+       unsigned char *msg;
+
+       if (close) {
+               msg = enable;
+               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
+               /* let the bridge stabilize */
+               msleep(20);
+       } else {
+               msg = disable;
+               tuner_i2c_xfer_send(&priv->i2c_props, msg, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &msg[1], 1);
+
+               buf[2] = msg[1];
+               buf[2] &= ~0x04;
+               tuner_i2c_xfer_send(&priv->i2c_props, buf, 3);
+               msleep(5);
+
+               msg[1] |= 0x04;
+               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
+       }
+
+       return 0;
+}
+
+/*---------------------------------------------------------------------*/
+
+static void set_audio(struct dvb_frontend *fe,
+                     struct analog_parameters *params)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       char* mode;
+
+       if (params->std & V4L2_STD_MN) {
+               priv->tda8290_easy_mode = 0x01;
+               mode = "MN";
+       } else if (params->std & V4L2_STD_B) {
+               priv->tda8290_easy_mode = 0x02;
+               mode = "B";
+       } else if (params->std & V4L2_STD_GH) {
+               priv->tda8290_easy_mode = 0x04;
+               mode = "GH";
+       } else if (params->std & V4L2_STD_PAL_I) {
+               priv->tda8290_easy_mode = 0x08;
+               mode = "I";
+       } else if (params->std & V4L2_STD_DK) {
+               priv->tda8290_easy_mode = 0x10;
+               mode = "DK";
+       } else if (params->std & V4L2_STD_SECAM_L) {
+               priv->tda8290_easy_mode = 0x20;
+               mode = "L";
+       } else if (params->std & V4L2_STD_SECAM_LC) {
+               priv->tda8290_easy_mode = 0x40;
+               mode = "LC";
+       } else {
+               priv->tda8290_easy_mode = 0x10;
+               mode = "xx";
+       }
+
+       tuner_dbg("setting tda829x to system %s\n", mode);
+}
+
+static void tda8290_set_params(struct dvb_frontend *fe,
+                              struct analog_parameters *params)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char soft_reset[]  = { 0x00, 0x00 };
+       unsigned char easy_mode[]   = { 0x01, priv->tda8290_easy_mode };
+       unsigned char expert_mode[] = { 0x01, 0x80 };
+       unsigned char agc_out_on[]  = { 0x02, 0x00 };
+       unsigned char gainset_off[] = { 0x28, 0x14 };
+       unsigned char if_agc_spd[]  = { 0x0f, 0x88 };
+       unsigned char adc_head_6[]  = { 0x05, 0x04 };
+       unsigned char adc_head_9[]  = { 0x05, 0x02 };
+       unsigned char adc_head_12[] = { 0x05, 0x01 };
+       unsigned char pll_bw_nom[]  = { 0x0d, 0x47 };
+       unsigned char pll_bw_low[]  = { 0x0d, 0x27 };
+       unsigned char gainset_2[]   = { 0x28, 0x64 };
+       unsigned char agc_rst_on[]  = { 0x0e, 0x0b };
+       unsigned char agc_rst_off[] = { 0x0e, 0x09 };
+       unsigned char if_agc_set[]  = { 0x0f, 0x81 };
+       unsigned char addr_adc_sat  = 0x1a;
+       unsigned char addr_agc_stat = 0x1d;
+       unsigned char addr_pll_stat = 0x1b;
+       unsigned char adc_sat, agc_stat,
+                     pll_stat;
+       int i;
+
+       set_audio(fe, params);
+
+       if (priv->cfg.config)
+               tuner_dbg("tda827xa config is 0x%02x\n", priv->cfg.config);
+       tuner_i2c_xfer_send(&priv->i2c_props, easy_mode, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, agc_out_on, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, soft_reset, 2);
+       msleep(1);
+
+       expert_mode[1] = priv->tda8290_easy_mode + 0x80;
+       tuner_i2c_xfer_send(&priv->i2c_props, expert_mode, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, gainset_off, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, if_agc_spd, 2);
+       if (priv->tda8290_easy_mode & 0x60)
+               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_9, 2);
+       else
+               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_6, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_nom, 2);
+
+       tda8290_i2c_bridge(fe, 1);
+
+       if (fe->ops.tuner_ops.set_analog_params)
+               fe->ops.tuner_ops.set_analog_params(fe, params);
+
+       for (i = 0; i < 3; i++) {
+               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
+               if (pll_stat & 0x80) {
+                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
+                       tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
+                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
+                       tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
+                       tuner_dbg("tda8290 is locked, AGC: %d\n", agc_stat);
+                       break;
+               } else {
+                       tuner_dbg("tda8290 not locked, no signal?\n");
+                       msleep(100);
+               }
+       }
+       /* adjust headroom resp. gain */
+       if ((agc_stat > 115) || (!(pll_stat & 0x80) && (adc_sat < 20))) {
+               tuner_dbg("adjust gain, step 1. Agc: %d, ADC stat: %d, lock: %d\n",
+                          agc_stat, adc_sat, pll_stat & 0x80);
+               tuner_i2c_xfer_send(&priv->i2c_props, gainset_2, 2);
+               msleep(100);
+               tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
+               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
+               if ((agc_stat > 115) || !(pll_stat & 0x80)) {
+                       tuner_dbg("adjust gain, step 2. Agc: %d, lock: %d\n",
+                                  agc_stat, pll_stat & 0x80);
+                       if (priv->cfg.agcf)
+                               priv->cfg.agcf(fe);
+                       msleep(100);
+                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
+                       tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
+                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
+                       tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
+                       if((agc_stat > 115) || !(pll_stat & 0x80)) {
+                               tuner_dbg("adjust gain, step 3. Agc: %d\n", agc_stat);
+                               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_12, 2);
+                               tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_low, 2);
+                               msleep(100);
+                       }
+               }
+       }
+
+       /* l/ l' deadlock? */
+       if(priv->tda8290_easy_mode & 0x60) {
+               tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
+               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
+               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
+               if ((adc_sat > 20) || !(pll_stat & 0x80)) {
+                       tuner_dbg("trying to resolve SECAM L deadlock\n");
+                       tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_on, 2);
+                       msleep(40);
+                       tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_off, 2);
+               }
+       }
+
+       tda8290_i2c_bridge(fe, 0);
+       tuner_i2c_xfer_send(&priv->i2c_props, if_agc_set, 2);
+}
+
+/*---------------------------------------------------------------------*/
+
+static void tda8295_power(struct dvb_frontend *fe, int enable)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char buf[] = { 0x30, 0x00 }; /* clb_stdbt */
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
+
+       if (enable)
+               buf[1] = 0x01;
+       else
+               buf[1] = 0x03;
+
+       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
+}
+
+static void tda8295_set_easy_mode(struct dvb_frontend *fe, int enable)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char buf[] = { 0x01, 0x00 };
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
+
+       if (enable)
+               buf[1] = 0x01; /* rising edge sets regs 0x02 - 0x23 */
+       else
+               buf[1] = 0x00; /* reset active bit */
+
+       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
+}
+
+static void tda8295_set_video_std(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char buf[] = { 0x00, priv->tda8290_easy_mode };
+
+       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
+
+       tda8295_set_easy_mode(fe, 1);
+       msleep(20);
+       tda8295_set_easy_mode(fe, 0);
+}
+
+/*---------------------------------------------------------------------*/
+
+static void tda8295_agc1_out(struct dvb_frontend *fe, int enable)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char buf[] = { 0x02, 0x00 }; /* DIV_FUNC */
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
+
+       if (enable)
+               buf[1] &= ~0x40;
+       else
+               buf[1] |= 0x40;
+
+       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
+}
+
+static void tda8295_agc2_out(struct dvb_frontend *fe, int enable)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char set_gpio_cf[]    = { 0x44, 0x00 };
+       unsigned char set_gpio_val[]   = { 0x46, 0x00 };
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_cf[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_cf[1], 1);
+       tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_val[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_val[1], 1);
+
+       set_gpio_cf[1] &= 0xf0; /* clear GPIO_0 bits 3-0 */
+
+       if (enable) {
+               set_gpio_cf[1]  |= 0x01; /* config GPIO_0 as Open Drain Out */
+               set_gpio_val[1] &= 0xfe; /* set GPIO_0 pin low */
+       }
+       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_cf, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_val, 2);
+}
+
+static int tda8295_has_signal(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char hvpll_stat = 0x26;
+       unsigned char ret;
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &hvpll_stat, 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &ret, 1);
+       return (ret & 0x01) ? 65535 : 0;
+}
+
+/*---------------------------------------------------------------------*/
+
+static void tda8295_set_params(struct dvb_frontend *fe,
+                              struct analog_parameters *params)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char blanking_mode[]     = { 0x1d, 0x00 };
+
+       set_audio(fe, params);
+
+       tuner_dbg("%s: freq = %d\n", __func__, params->frequency);
+
+       tda8295_power(fe, 1);
+       tda8295_agc1_out(fe, 1);
+
+       tuner_i2c_xfer_send(&priv->i2c_props, &blanking_mode[0], 1);
+       tuner_i2c_xfer_recv(&priv->i2c_props, &blanking_mode[1], 1);
+
+       tda8295_set_video_std(fe);
+
+       blanking_mode[1] = 0x03;
+       tuner_i2c_xfer_send(&priv->i2c_props, blanking_mode, 2);
+       msleep(20);
+
+       tda8295_i2c_bridge(fe, 1);
+
+       if (fe->ops.tuner_ops.set_analog_params)
+               fe->ops.tuner_ops.set_analog_params(fe, params);
+
+       if (priv->cfg.agcf)
+               priv->cfg.agcf(fe);
+
+       if (tda8295_has_signal(fe))
+               tuner_dbg("tda8295 is locked\n");
+       else
+               tuner_dbg("tda8295 not locked, no signal?\n");
+
+       tda8295_i2c_bridge(fe, 0);
+}
+
+/*---------------------------------------------------------------------*/
+
+static int tda8290_has_signal(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char i2c_get_afc[1] = { 0x1B };
+       unsigned char afc = 0;
+
+       tuner_i2c_xfer_send(&priv->i2c_props, i2c_get_afc, ARRAY_SIZE(i2c_get_afc));
+       tuner_i2c_xfer_recv(&priv->i2c_props, &afc, 1);
+       return (afc & 0x80)? 65535:0;
+}
+
+/*---------------------------------------------------------------------*/
+
+static void tda8290_standby(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char cb1[] = { 0x30, 0xD0 };
+       unsigned char tda8290_standby[] = { 0x00, 0x02 };
+       unsigned char tda8290_agc_tri[] = { 0x02, 0x20 };
+       struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0, .buf=cb1, .len = 2};
+
+       tda8290_i2c_bridge(fe, 1);
+       if (priv->ver & TDA8275A)
+               cb1[1] = 0x90;
+       i2c_transfer(priv->i2c_props.adap, &msg, 1);
+       tda8290_i2c_bridge(fe, 0);
+       tuner_i2c_xfer_send(&priv->i2c_props, tda8290_agc_tri, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, tda8290_standby, 2);
+}
+
+static void tda8295_standby(struct dvb_frontend *fe)
+{
+       tda8295_agc1_out(fe, 0); /* Put AGC in tri-state */
+
+       tda8295_power(fe, 0);
+}
+
+static void tda8290_init_if(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       unsigned char set_VS[] = { 0x30, 0x6F };
+       unsigned char set_GP00_CF[] = { 0x20, 0x01 };
+       unsigned char set_GP01_CF[] = { 0x20, 0x0B };
+
+       if ((priv->cfg.config == 1) || (priv->cfg.config == 2))
+               tuner_i2c_xfer_send(&priv->i2c_props, set_GP00_CF, 2);
+       else
+               tuner_i2c_xfer_send(&priv->i2c_props, set_GP01_CF, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_VS, 2);
+}
+
+static void tda8295_init_if(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       static unsigned char set_adc_ctl[]       = { 0x33, 0x14 };
+       static unsigned char set_adc_ctl2[]      = { 0x34, 0x00 };
+       static unsigned char set_pll_reg6[]      = { 0x3e, 0x63 };
+       static unsigned char set_pll_reg0[]      = { 0x38, 0x23 };
+       static unsigned char set_pll_reg7[]      = { 0x3f, 0x01 };
+       static unsigned char set_pll_reg10[]     = { 0x42, 0x61 };
+       static unsigned char set_gpio_reg0[]     = { 0x44, 0x0b };
+
+       tda8295_power(fe, 1);
+
+       tda8295_set_easy_mode(fe, 0);
+       tda8295_set_video_std(fe);
+
+       tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl2, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg6, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg0, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg7, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg10, 2);
+       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_reg0, 2);
+
+       tda8295_agc1_out(fe, 0);
+       tda8295_agc2_out(fe, 0);
+}
+
+static void tda8290_init_tuner(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       unsigned char tda8275_init[]  = { 0x00, 0x00, 0x00, 0x40, 0xdC, 0x04, 0xAf,
+                                         0x3F, 0x2A, 0x04, 0xFF, 0x00, 0x00, 0x40 };
+       unsigned char tda8275a_init[] = { 0x00, 0x00, 0x00, 0x00, 0xdC, 0x05, 0x8b,
+                                         0x0c, 0x04, 0x20, 0xFF, 0x00, 0x00, 0x4b };
+       struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0,
+                             .buf=tda8275_init, .len = 14};
+       if (priv->ver & TDA8275A)
+               msg.buf = tda8275a_init;
+
+       tda8290_i2c_bridge(fe, 1);
+       i2c_transfer(priv->i2c_props.adap, &msg, 1);
+       tda8290_i2c_bridge(fe, 0);
+}
+
+/*---------------------------------------------------------------------*/
+
+static void tda829x_release(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+
+       /* only try to release the tuner if we've
+        * attached it from within this module */
+       if (priv->ver & (TDA18271 | TDA8275 | TDA8275A))
+               if (fe->ops.tuner_ops.release)
+                       fe->ops.tuner_ops.release(fe);
+
+       kfree(fe->analog_demod_priv);
+       fe->analog_demod_priv = NULL;
+}
+
+static struct tda18271_config tda829x_tda18271_config = {
+       .gate    = TDA18271_GATE_ANALOG,
+};
+
+static int tda829x_find_tuner(struct dvb_frontend *fe)
+{
+       struct tda8290_priv *priv = fe->analog_demod_priv;
+       struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
+       int i, ret, tuners_found;
+       u32 tuner_addrs;
+       u8 data;
+       struct i2c_msg msg = { .flags = I2C_M_RD, .buf = &data, .len = 1 };
+
+       if (NULL == analog_ops->i2c_gate_ctrl)
+               return -EINVAL;
+
+       analog_ops->i2c_gate_ctrl(fe, 1);
+
+       /* probe for tuner chip */
+       tuners_found = 0;
+       tuner_addrs = 0;
+       for (i = 0x60; i <= 0x63; i++) {
+               msg.addr = i;
+               ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
+               if (ret == 1) {
+                       tuners_found++;
+                       tuner_addrs = (tuner_addrs << 8) + i;
+               }
+       }
+       /* if there is more than one tuner, we expect the right one is
+          behind the bridge and we choose the highest address that doesn't
+          give a response now
+        */
+
+       analog_ops->i2c_gate_ctrl(fe, 0);
+
+       if (tuners_found > 1)
+               for (i = 0; i < tuners_found; i++) {
+                       msg.addr = tuner_addrs  & 0xff;
+                       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
+                       if (ret == 1)
+                               tuner_addrs = tuner_addrs >> 8;
+                       else
+                               break;
+               }
+
+       if (tuner_addrs == 0) {
+               tuner_addrs = 0x60;
+               tuner_info("could not clearly identify tuner address, "
+                          "defaulting to %x\n", tuner_addrs);
+       } else {
+               tuner_addrs = tuner_addrs & 0xff;
+               tuner_info("setting tuner address to %x\n", tuner_addrs);
+       }
+       priv->tda827x_addr = tuner_addrs;
+       msg.addr = tuner_addrs;
+
+       analog_ops->i2c_gate_ctrl(fe, 1);
+       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
+
+       if (ret != 1) {
+               tuner_warn("tuner access failed!\n");
+               return -EREMOTEIO;
+       }
+
+       if ((data == 0x83) || (data == 0x84)) {
+               priv->ver |= TDA18271;
+               tda18271_attach(fe, priv->tda827x_addr,
+                               priv->i2c_props.adap,
+                               &tda829x_tda18271_config);
+       } else {
+               if ((data & 0x3c) == 0)
+                       priv->ver |= TDA8275;
+               else
+                       priv->ver |= TDA8275A;
+
+               tda827x_attach(fe, priv->tda827x_addr, priv->i2c_props.adap, &priv->cfg);
+               priv->cfg.switch_addr = priv->i2c_props.addr;
+       }
+       if (fe->ops.tuner_ops.init)
+               fe->ops.tuner_ops.init(fe);
+
+       if (fe->ops.tuner_ops.sleep)
+               fe->ops.tuner_ops.sleep(fe);
+
+       analog_ops->i2c_gate_ctrl(fe, 0);
+
+       return 0;
+}
+
+static int tda8290_probe(struct tuner_i2c_props *i2c_props)
+{
+#define TDA8290_ID 0x89
+       unsigned char tda8290_id[] = { 0x1f, 0x00 };
+
+       /* detect tda8290 */
+       tuner_i2c_xfer_send(i2c_props, &tda8290_id[0], 1);
+       tuner_i2c_xfer_recv(i2c_props, &tda8290_id[1], 1);
+
+       if (tda8290_id[1] == TDA8290_ID) {
+               if (debug)
+                       printk(KERN_DEBUG "%s: tda8290 detected @ %d-%04x\n",
+                              __func__, i2c_adapter_id(i2c_props->adap),
+                              i2c_props->addr);
+               return 0;
+       }
+
+       return -ENODEV;
+}
+
+static int tda8295_probe(struct tuner_i2c_props *i2c_props)
+{
+#define TDA8295_ID 0x8a
+       unsigned char tda8295_id[] = { 0x2f, 0x00 };
+
+       /* detect tda8295 */
+       tuner_i2c_xfer_send(i2c_props, &tda8295_id[0], 1);
+       tuner_i2c_xfer_recv(i2c_props, &tda8295_id[1], 1);
+
+       if (tda8295_id[1] == TDA8295_ID) {
+               if (debug)
+                       printk(KERN_DEBUG "%s: tda8295 detected @ %d-%04x\n",
+                              __func__, i2c_adapter_id(i2c_props->adap),
+                              i2c_props->addr);
+               return 0;
+       }
+
+       return -ENODEV;
+}
+
+static struct analog_demod_ops tda8290_ops = {
+       .set_params     = tda8290_set_params,
+       .has_signal     = tda8290_has_signal,
+       .standby        = tda8290_standby,
+       .release        = tda829x_release,
+       .i2c_gate_ctrl  = tda8290_i2c_bridge,
+};
+
+static struct analog_demod_ops tda8295_ops = {
+       .set_params     = tda8295_set_params,
+       .has_signal     = tda8295_has_signal,
+       .standby        = tda8295_standby,
+       .release        = tda829x_release,
+       .i2c_gate_ctrl  = tda8295_i2c_bridge,
+};
+
+struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
+                                   struct i2c_adapter *i2c_adap, u8 i2c_addr,
+                                   struct tda829x_config *cfg)
+{
+       struct tda8290_priv *priv = NULL;
+       char *name;
+
+       priv = kzalloc(sizeof(struct tda8290_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+       fe->analog_demod_priv = priv;
+
+       priv->i2c_props.addr     = i2c_addr;
+       priv->i2c_props.adap     = i2c_adap;
+       priv->i2c_props.name     = "tda829x";
+       if (cfg) {
+               priv->cfg.config         = cfg->lna_cfg;
+               priv->cfg.tuner_callback = cfg->tuner_callback;
+       }
+
+       if (tda8290_probe(&priv->i2c_props) == 0) {
+               priv->ver = TDA8290;
+               memcpy(&fe->ops.analog_ops, &tda8290_ops,
+                      sizeof(struct analog_demod_ops));
+       }
+
+       if (tda8295_probe(&priv->i2c_props) == 0) {
+               priv->ver = TDA8295;
+               memcpy(&fe->ops.analog_ops, &tda8295_ops,
+                      sizeof(struct analog_demod_ops));
+       }
+
+       if ((!(cfg) || (TDA829X_PROBE_TUNER == cfg->probe_tuner)) &&
+           (tda829x_find_tuner(fe) < 0))
+               goto fail;
+
+       switch (priv->ver) {
+       case TDA8290:
+               name = "tda8290";
+               break;
+       case TDA8295:
+               name = "tda8295";
+               break;
+       case TDA8290 | TDA8275:
+               name = "tda8290+75";
+               break;
+       case TDA8295 | TDA8275:
+               name = "tda8295+75";
+               break;
+       case TDA8290 | TDA8275A:
+               name = "tda8290+75a";
+               break;
+       case TDA8295 | TDA8275A:
+               name = "tda8295+75a";
+               break;
+       case TDA8290 | TDA18271:
+               name = "tda8290+18271";
+               break;
+       case TDA8295 | TDA18271:
+               name = "tda8295+18271";
+               break;
+       default:
+               goto fail;
+       }
+       tuner_info("type set to %s\n", name);
+
+       fe->ops.analog_ops.info.name = name;
+
+       if (priv->ver & TDA8290) {
+               tda8290_init_tuner(fe);
+               tda8290_init_if(fe);
+       } else if (priv->ver & TDA8295)
+               tda8295_init_if(fe);
+
+       return fe;
+
+fail:
+       tda829x_release(fe);
+       return NULL;
+}
+EXPORT_SYMBOL_GPL(tda829x_attach);
+
+int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr)
+{
+       struct tuner_i2c_props i2c_props = {
+               .adap = i2c_adap,
+               .addr = i2c_addr,
+       };
+
+       unsigned char soft_reset[]   = { 0x00, 0x00 };
+       unsigned char easy_mode_b[]  = { 0x01, 0x02 };
+       unsigned char easy_mode_g[]  = { 0x01, 0x04 };
+       unsigned char restore_9886[] = { 0x00, 0xd6, 0x30 };
+       unsigned char addr_dto_lsb = 0x07;
+       unsigned char data;
+#define PROBE_BUFFER_SIZE 8
+       unsigned char buf[PROBE_BUFFER_SIZE];
+       int i;
+
+       /* rule out tda9887, which would return the same byte repeatedly */
+       tuner_i2c_xfer_send(&i2c_props, soft_reset, 1);
+       tuner_i2c_xfer_recv(&i2c_props, buf, PROBE_BUFFER_SIZE);
+       for (i = 1; i < PROBE_BUFFER_SIZE; i++) {
+               if (buf[i] != buf[0])
+                       break;
+       }
+
+       /* all bytes are equal, not a tda829x - probably a tda9887 */
+       if (i == PROBE_BUFFER_SIZE)
+               return -ENODEV;
+
+       if ((tda8290_probe(&i2c_props) == 0) ||
+           (tda8295_probe(&i2c_props) == 0))
+               return 0;
+
+       /* fall back to old probing method */
+       tuner_i2c_xfer_send(&i2c_props, easy_mode_b, 2);
+       tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
+       tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
+       tuner_i2c_xfer_recv(&i2c_props, &data, 1);
+       if (data == 0) {
+               tuner_i2c_xfer_send(&i2c_props, easy_mode_g, 2);
+               tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
+               tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
+               tuner_i2c_xfer_recv(&i2c_props, &data, 1);
+               if (data == 0x7b) {
+                       return 0;
+               }
+       }
+       tuner_i2c_xfer_send(&i2c_props, restore_9886, 3);
+       return -ENODEV;
+}
+EXPORT_SYMBOL_GPL(tda829x_probe);
+
+MODULE_DESCRIPTION("Philips/NXP TDA8290/TDA8295 analog IF demodulator driver");
+MODULE_AUTHOR("Gerd Knorr, Hartmut Hackmann, Michael Krufky");
+MODULE_LICENSE("GPL");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda8290.h b/drivers/media/common/tuners/tda8290.h
new file mode 100644 (file)
index 0000000..d3bbf27
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TDA8290_H__
+#define __TDA8290_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+struct tda829x_config {
+       unsigned int lna_cfg;
+       int (*tuner_callback) (void *dev, int command, int arg);
+
+       unsigned int probe_tuner:1;
+#define TDA829X_PROBE_TUNER 0
+#define TDA829X_DONT_PROBE  1
+};
+
+#if defined(CONFIG_TUNER_TDA8290) || (defined(CONFIG_TUNER_TDA8290_MODULE) && defined(MODULE))
+extern int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr);
+
+extern struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
+                                          struct i2c_adapter *i2c_adap,
+                                          u8 i2c_addr,
+                                          struct tda829x_config *cfg);
+#else
+static inline int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return -EINVAL;
+}
+
+static inline struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
+                                                 struct i2c_adapter *i2c_adap,
+                                                 u8 i2c_addr,
+                                                 struct tda829x_config *cfg)
+{
+       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
+              __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TDA8290_H__ */
diff --git a/drivers/media/common/tuners/tda9887.c b/drivers/media/common/tuners/tda9887.c
new file mode 100644 (file)
index 0000000..a0545ba
--- /dev/null
@@ -0,0 +1,717 @@
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/i2c.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/videodev.h>
+#include <media/v4l2-common.h>
+#include <media/tuner.h>
+#include "tuner-i2c.h"
+#include "tda9887.h"
+
+
+/* Chips:
+   TDA9885 (PAL, NTSC)
+   TDA9886 (PAL, SECAM, NTSC)
+   TDA9887 (PAL, SECAM, NTSC, FM Radio)
+
+   Used as part of several tuners
+*/
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+static DEFINE_MUTEX(tda9887_list_mutex);
+static LIST_HEAD(hybrid_tuner_instance_list);
+
+struct tda9887_priv {
+       struct tuner_i2c_props i2c_props;
+       struct list_head hybrid_tuner_instance_list;
+
+       unsigned char      data[4];
+       unsigned int       config;
+       unsigned int       mode;
+       unsigned int       audmode;
+       v4l2_std_id        std;
+};
+
+/* ---------------------------------------------------------------------- */
+
+#define UNSET       (-1U)
+
+struct tvnorm {
+       v4l2_std_id       std;
+       char              *name;
+       unsigned char     b;
+       unsigned char     c;
+       unsigned char     e;
+};
+
+/* ---------------------------------------------------------------------- */
+
+//
+// TDA defines
+//
+
+//// first reg (b)
+#define cVideoTrapBypassOFF     0x00    // bit b0
+#define cVideoTrapBypassON      0x01    // bit b0
+
+#define cAutoMuteFmInactive     0x00    // bit b1
+#define cAutoMuteFmActive       0x02    // bit b1
+
+#define cIntercarrier           0x00    // bit b2
+#define cQSS                    0x04    // bit b2
+
+#define cPositiveAmTV           0x00    // bit b3:4
+#define cFmRadio                0x08    // bit b3:4
+#define cNegativeFmTV           0x10    // bit b3:4
+
+
+#define cForcedMuteAudioON      0x20    // bit b5
+#define cForcedMuteAudioOFF     0x00    // bit b5
+
+#define cOutputPort1Active      0x00    // bit b6
+#define cOutputPort1Inactive    0x40    // bit b6
+
+#define cOutputPort2Active      0x00    // bit b7
+#define cOutputPort2Inactive    0x80    // bit b7
+
+
+//// second reg (c)
+#define cDeemphasisOFF          0x00    // bit c5
+#define cDeemphasisON           0x20    // bit c5
+
+#define cDeemphasis75           0x00    // bit c6
+#define cDeemphasis50           0x40    // bit c6
+
+#define cAudioGain0             0x00    // bit c7
+#define cAudioGain6             0x80    // bit c7
+
+#define cTopMask                0x1f    // bit c0:4
+#define cTopDefault            0x10    // bit c0:4
+
+//// third reg (e)
+#define cAudioIF_4_5             0x00    // bit e0:1
+#define cAudioIF_5_5             0x01    // bit e0:1
+#define cAudioIF_6_0             0x02    // bit e0:1
+#define cAudioIF_6_5             0x03    // bit e0:1
+
+
+#define cVideoIFMask           0x1c    // bit e2:4
+/* Video IF selection in TV Mode (bit B3=0) */
+#define cVideoIF_58_75           0x00    // bit e2:4
+#define cVideoIF_45_75           0x04    // bit e2:4
+#define cVideoIF_38_90           0x08    // bit e2:4
+#define cVideoIF_38_00           0x0C    // bit e2:4
+#define cVideoIF_33_90           0x10    // bit e2:4
+#define cVideoIF_33_40           0x14    // bit e2:4
+#define cRadioIF_45_75           0x18    // bit e2:4
+#define cRadioIF_38_90           0x1C    // bit e2:4
+
+/* IF1 selection in Radio Mode (bit B3=1) */
+#define cRadioIF_33_30         0x00    // bit e2,4 (also 0x10,0x14)
+#define cRadioIF_41_30         0x04    // bit e2,4
+
+/* Output of AFC pin in radio mode when bit E7=1 */
+#define cRadioAGC_SIF          0x00    // bit e3
+#define cRadioAGC_FM           0x08    // bit e3
+
+#define cTunerGainNormal         0x00    // bit e5
+#define cTunerGainLow            0x20    // bit e5
+
+#define cGating_18               0x00    // bit e6
+#define cGating_36               0x40    // bit e6
+
+#define cAgcOutON                0x80    // bit e7
+#define cAgcOutOFF               0x00    // bit e7
+
+/* ---------------------------------------------------------------------- */
+
+static struct tvnorm tvnorms[] = {
+       {
+               .std   = V4L2_STD_PAL_BG | V4L2_STD_PAL_H | V4L2_STD_PAL_N,
+               .name  = "PAL-BGHN",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis50  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_5_5   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_PAL_I,
+               .name  = "PAL-I",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis50  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_6_0   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_PAL_DK,
+               .name  = "PAL-DK",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis50  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_6_5   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_PAL_M | V4L2_STD_PAL_Nc,
+               .name  = "PAL-M/Nc",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis75  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_4_5   |
+                          cVideoIF_45_75 ),
+       },{
+               .std   = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H,
+               .name  = "SECAM-BGH",
+               .b     = ( cPositiveAmTV  |
+                          cQSS           ),
+               .c     = ( cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_5_5   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_SECAM_L,
+               .name  = "SECAM-L",
+               .b     = ( cPositiveAmTV  |
+                          cQSS           ),
+               .c     = ( cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_6_5   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_SECAM_LC,
+               .name  = "SECAM-L'",
+               .b     = ( cOutputPort2Inactive |
+                          cPositiveAmTV  |
+                          cQSS           ),
+               .c     = ( cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_6_5   |
+                          cVideoIF_33_90 ),
+       },{
+               .std   = V4L2_STD_SECAM_DK,
+               .name  = "SECAM-DK",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis50  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_6_5   |
+                          cVideoIF_38_90 ),
+       },{
+               .std   = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
+               .name  = "NTSC-M",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis75  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_4_5   |
+                          cVideoIF_45_75 ),
+       },{
+               .std   = V4L2_STD_NTSC_M_JP,
+               .name  = "NTSC-M-JP",
+               .b     = ( cNegativeFmTV  |
+                          cQSS           ),
+               .c     = ( cDeemphasisON  |
+                          cDeemphasis50  |
+                          cTopDefault),
+               .e     = ( cGating_36     |
+                          cAudioIF_4_5   |
+                          cVideoIF_58_75 ),
+       }
+};
+
+static struct tvnorm radio_stereo = {
+       .name = "Radio Stereo",
+       .b    = ( cFmRadio       |
+                 cQSS           ),
+       .c    = ( cDeemphasisOFF |
+                 cAudioGain6    |
+                 cTopDefault),
+       .e    = ( cTunerGainLow  |
+                 cAudioIF_5_5   |
+                 cRadioIF_38_90 ),
+};
+
+static struct tvnorm radio_mono = {
+       .name = "Radio Mono",
+       .b    = ( cFmRadio       |
+                 cQSS           ),
+       .c    = ( cDeemphasisON  |
+                 cDeemphasis75  |
+                 cTopDefault),
+       .e    = ( cTunerGainLow  |
+                 cAudioIF_5_5   |
+                 cRadioIF_38_90 ),
+};
+
+/* ---------------------------------------------------------------------- */
+
+static void dump_read_message(struct dvb_frontend *fe, unsigned char *buf)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       static char *afc[16] = {
+               "- 12.5 kHz",
+               "- 37.5 kHz",
+               "- 62.5 kHz",
+               "- 87.5 kHz",
+               "-112.5 kHz",
+               "-137.5 kHz",
+               "-162.5 kHz",
+               "-187.5 kHz [min]",
+               "+187.5 kHz [max]",
+               "+162.5 kHz",
+               "+137.5 kHz",
+               "+112.5 kHz",
+               "+ 87.5 kHz",
+               "+ 62.5 kHz",
+               "+ 37.5 kHz",
+               "+ 12.5 kHz",
+       };
+       tuner_info("read: 0x%2x\n", buf[0]);
+       tuner_info("  after power on : %s\n", (buf[0] & 0x01) ? "yes" : "no");
+       tuner_info("  afc            : %s\n", afc[(buf[0] >> 1) & 0x0f]);
+       tuner_info("  fmif level     : %s\n", (buf[0] & 0x20) ? "high" : "low");
+       tuner_info("  afc window     : %s\n", (buf[0] & 0x40) ? "in" : "out");
+       tuner_info("  vfi level      : %s\n", (buf[0] & 0x80) ? "high" : "low");
+}
+
+static void dump_write_message(struct dvb_frontend *fe, unsigned char *buf)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       static char *sound[4] = {
+               "AM/TV",
+               "FM/radio",
+               "FM/TV",
+               "FM/radio"
+       };
+       static char *adjust[32] = {
+               "-16", "-15", "-14", "-13", "-12", "-11", "-10", "-9",
+               "-8",  "-7",  "-6",  "-5",  "-4",  "-3",  "-2",  "-1",
+               "0",   "+1",  "+2",  "+3",  "+4",  "+5",  "+6",  "+7",
+               "+8",  "+9",  "+10", "+11", "+12", "+13", "+14", "+15"
+       };
+       static char *deemph[4] = {
+               "no", "no", "75", "50"
+       };
+       static char *carrier[4] = {
+               "4.5 MHz",
+               "5.5 MHz",
+               "6.0 MHz",
+               "6.5 MHz / AM"
+       };
+       static char *vif[8] = {
+               "58.75 MHz",
+               "45.75 MHz",
+               "38.9 MHz",
+               "38.0 MHz",
+               "33.9 MHz",
+               "33.4 MHz",
+               "45.75 MHz + pin13",
+               "38.9 MHz + pin13",
+       };
+       static char *rif[4] = {
+               "44 MHz",
+               "52 MHz",
+               "52 MHz",
+               "44 MHz",
+       };
+
+       tuner_info("write: byte B 0x%02x\n", buf[1]);
+       tuner_info("  B0   video mode      : %s\n",
+                  (buf[1] & 0x01) ? "video trap" : "sound trap");
+       tuner_info("  B1   auto mute fm    : %s\n",
+                  (buf[1] & 0x02) ? "yes" : "no");
+       tuner_info("  B2   carrier mode    : %s\n",
+                  (buf[1] & 0x04) ? "QSS" : "Intercarrier");
+       tuner_info("  B3-4 tv sound/radio  : %s\n",
+                  sound[(buf[1] & 0x18) >> 3]);
+       tuner_info("  B5   force mute audio: %s\n",
+                  (buf[1] & 0x20) ? "yes" : "no");
+       tuner_info("  B6   output port 1   : %s\n",
+                  (buf[1] & 0x40) ? "high (inactive)" : "low (active)");
+       tuner_info("  B7   output port 2   : %s\n",
+                  (buf[1] & 0x80) ? "high (inactive)" : "low (active)");
+
+       tuner_info("write: byte C 0x%02x\n", buf[2]);
+       tuner_info("  C0-4 top adjustment  : %s dB\n",
+                  adjust[buf[2] & 0x1f]);
+       tuner_info("  C5-6 de-emphasis     : %s\n",
+                  deemph[(buf[2] & 0x60) >> 5]);
+       tuner_info("  C7   audio gain      : %s\n",
+                  (buf[2] & 0x80) ? "-6" : "0");
+
+       tuner_info("write: byte E 0x%02x\n", buf[3]);
+       tuner_info("  E0-1 sound carrier   : %s\n",
+                  carrier[(buf[3] & 0x03)]);
+       tuner_info("  E6   l pll gating   : %s\n",
+                  (buf[3] & 0x40) ? "36" : "13");
+
+       if (buf[1] & 0x08) {
+               /* radio */
+               tuner_info("  E2-4 video if        : %s\n",
+                          rif[(buf[3] & 0x0c) >> 2]);
+               tuner_info("  E7   vif agc output  : %s\n",
+                          (buf[3] & 0x80)
+                          ? ((buf[3] & 0x10) ? "fm-agc radio" :
+                                               "sif-agc radio")
+                          : "fm radio carrier afc");
+       } else {
+               /* video */
+               tuner_info("  E2-4 video if        : %s\n",
+                          vif[(buf[3] & 0x1c) >> 2]);
+               tuner_info("  E5   tuner gain      : %s\n",
+                          (buf[3] & 0x80)
+                          ? ((buf[3] & 0x20) ? "external" : "normal")
+                          : ((buf[3] & 0x20) ? "minimum"  : "normal"));
+               tuner_info("  E7   vif agc output  : %s\n",
+                          (buf[3] & 0x80) ? ((buf[3] & 0x20)
+                               ? "pin3 port, pin22 vif agc out"
+                               : "pin22 port, pin3 vif acg ext in")
+                               : "pin3+pin22 port");
+       }
+       tuner_info("--\n");
+}
+
+/* ---------------------------------------------------------------------- */
+
+static int tda9887_set_tvnorm(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       struct tvnorm *norm = NULL;
+       char *buf = priv->data;
+       int i;
+
+       if (priv->mode == V4L2_TUNER_RADIO) {
+               if (priv->audmode == V4L2_TUNER_MODE_MONO)
+                       norm = &radio_mono;
+               else
+                       norm = &radio_stereo;
+       } else {
+               for (i = 0; i < ARRAY_SIZE(tvnorms); i++) {
+                       if (tvnorms[i].std & priv->std) {
+                               norm = tvnorms+i;
+                               break;
+                       }
+               }
+       }
+       if (NULL == norm) {
+               tuner_dbg("Unsupported tvnorm entry - audio muted\n");
+               return -1;
+       }
+
+       tuner_dbg("configure for: %s\n", norm->name);
+       buf[1] = norm->b;
+       buf[2] = norm->c;
+       buf[3] = norm->e;
+       return 0;
+}
+
+static unsigned int port1  = UNSET;
+static unsigned int port2  = UNSET;
+static unsigned int qss    = UNSET;
+static unsigned int adjust = UNSET;
+
+module_param(port1, int, 0644);
+module_param(port2, int, 0644);
+module_param(qss, int, 0644);
+module_param(adjust, int, 0644);
+
+static int tda9887_set_insmod(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       char *buf = priv->data;
+
+       if (UNSET != port1) {
+               if (port1)
+                       buf[1] |= cOutputPort1Inactive;
+               else
+                       buf[1] &= ~cOutputPort1Inactive;
+       }
+       if (UNSET != port2) {
+               if (port2)
+                       buf[1] |= cOutputPort2Inactive;
+               else
+                       buf[1] &= ~cOutputPort2Inactive;
+       }
+
+       if (UNSET != qss) {
+               if (qss)
+                       buf[1] |= cQSS;
+               else
+                       buf[1] &= ~cQSS;
+       }
+
+       if (adjust >= 0x00 && adjust < 0x20) {
+               buf[2] &= ~cTopMask;
+               buf[2] |= adjust;
+       }
+       return 0;
+}
+
+static int tda9887_do_config(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       char *buf = priv->data;
+
+       if (priv->config & TDA9887_PORT1_ACTIVE)
+               buf[1] &= ~cOutputPort1Inactive;
+       if (priv->config & TDA9887_PORT1_INACTIVE)
+               buf[1] |= cOutputPort1Inactive;
+       if (priv->config & TDA9887_PORT2_ACTIVE)
+               buf[1] &= ~cOutputPort2Inactive;
+       if (priv->config & TDA9887_PORT2_INACTIVE)
+               buf[1] |= cOutputPort2Inactive;
+
+       if (priv->config & TDA9887_QSS)
+               buf[1] |= cQSS;
+       if (priv->config & TDA9887_INTERCARRIER)
+               buf[1] &= ~cQSS;
+
+       if (priv->config & TDA9887_AUTOMUTE)
+               buf[1] |= cAutoMuteFmActive;
+       if (priv->config & TDA9887_DEEMPHASIS_MASK) {
+               buf[2] &= ~0x60;
+               switch (priv->config & TDA9887_DEEMPHASIS_MASK) {
+               case TDA9887_DEEMPHASIS_NONE:
+                       buf[2] |= cDeemphasisOFF;
+                       break;
+               case TDA9887_DEEMPHASIS_50:
+                       buf[2] |= cDeemphasisON | cDeemphasis50;
+                       break;
+               case TDA9887_DEEMPHASIS_75:
+                       buf[2] |= cDeemphasisON | cDeemphasis75;
+                       break;
+               }
+       }
+       if (priv->config & TDA9887_TOP_SET) {
+               buf[2] &= ~cTopMask;
+               buf[2] |= (priv->config >> 8) & cTopMask;
+       }
+       if ((priv->config & TDA9887_INTERCARRIER_NTSC) &&
+           (priv->std & V4L2_STD_NTSC))
+               buf[1] &= ~cQSS;
+       if (priv->config & TDA9887_GATING_18)
+               buf[3] &= ~cGating_36;
+
+       if (priv->mode == V4L2_TUNER_RADIO) {
+               if (priv->config & TDA9887_RIF_41_3) {
+                       buf[3] &= ~cVideoIFMask;
+                       buf[3] |= cRadioIF_41_30;
+               }
+               if (priv->config & TDA9887_GAIN_NORMAL)
+                       buf[3] &= ~cTunerGainLow;
+       }
+
+       return 0;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static int tda9887_status(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       unsigned char buf[1];
+       int rc;
+
+       memset(buf,0,sizeof(buf));
+       if (1 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props,buf,1)))
+               tuner_info("i2c i/o error: rc == %d (should be 1)\n", rc);
+       dump_read_message(fe, buf);
+       return 0;
+}
+
+static void tda9887_configure(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       int rc;
+
+       memset(priv->data,0,sizeof(priv->data));
+       tda9887_set_tvnorm(fe);
+
+       /* A note on the port settings:
+          These settings tend to depend on the specifics of the board.
+          By default they are set to inactive (bit value 1) by this driver,
+          overwriting any changes made by the tvnorm. This means that it
+          is the responsibility of the module using the tda9887 to set
+          these values in case of changes in the tvnorm.
+          In many cases port 2 should be made active (0) when selecting
+          SECAM-L, and port 2 should remain inactive (1) for SECAM-L'.
+
+          For the other standards the tda9887 application note says that
+          the ports should be set to active (0), but, again, that may
+          differ depending on the precise hardware configuration.
+        */
+       priv->data[1] |= cOutputPort1Inactive;
+       priv->data[1] |= cOutputPort2Inactive;
+
+       tda9887_do_config(fe);
+       tda9887_set_insmod(fe);
+
+       if (priv->mode == T_STANDBY)
+               priv->data[1] |= cForcedMuteAudioON;
+
+       tuner_dbg("writing: b=0x%02x c=0x%02x e=0x%02x\n",
+                 priv->data[1], priv->data[2], priv->data[3]);
+       if (debug > 1)
+               dump_write_message(fe, priv->data);
+
+       if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,priv->data,4)))
+               tuner_info("i2c i/o error: rc == %d (should be 4)\n", rc);
+
+       if (debug > 2) {
+               msleep_interruptible(1000);
+               tda9887_status(fe);
+       }
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void tda9887_tuner_status(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       tuner_info("Data bytes: b=0x%02x c=0x%02x e=0x%02x\n",
+                  priv->data[1], priv->data[2], priv->data[3]);
+}
+
+static int tda9887_get_afc(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+       static int AFC_BITS_2_kHz[] = {
+               -12500,  -37500,  -62500,  -97500,
+               -112500, -137500, -162500, -187500,
+               187500,  162500,  137500,  112500,
+               97500 ,  62500,   37500 ,  12500
+       };
+       int afc=0;
+       __u8 reg = 0;
+
+       if (1 == tuner_i2c_xfer_recv(&priv->i2c_props,&reg,1))
+               afc = AFC_BITS_2_kHz[(reg>>1)&0x0f];
+
+       return afc;
+}
+
+static void tda9887_standby(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       priv->mode = T_STANDBY;
+
+       tda9887_configure(fe);
+}
+
+static void tda9887_set_params(struct dvb_frontend *fe,
+                              struct analog_parameters *params)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       priv->mode    = params->mode;
+       priv->audmode = params->audmode;
+       priv->std     = params->std;
+       tda9887_configure(fe);
+}
+
+static int tda9887_set_config(struct dvb_frontend *fe, void *priv_cfg)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       priv->config = *(unsigned int *)priv_cfg;
+       tda9887_configure(fe);
+
+       return 0;
+}
+
+static void tda9887_release(struct dvb_frontend *fe)
+{
+       struct tda9887_priv *priv = fe->analog_demod_priv;
+
+       mutex_lock(&tda9887_list_mutex);
+
+       if (priv)
+               hybrid_tuner_release_state(priv);
+
+       mutex_unlock(&tda9887_list_mutex);
+
+       fe->analog_demod_priv = NULL;
+}
+
+static struct analog_demod_ops tda9887_ops = {
+       .info           = {
+               .name   = "tda9887",
+       },
+       .set_params     = tda9887_set_params,
+       .standby        = tda9887_standby,
+       .tuner_status   = tda9887_tuner_status,
+       .get_afc        = tda9887_get_afc,
+       .release        = tda9887_release,
+       .set_config     = tda9887_set_config,
+};
+
+struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
+                                   struct i2c_adapter *i2c_adap,
+                                   u8 i2c_addr)
+{
+       struct tda9887_priv *priv = NULL;
+       int instance;
+
+       mutex_lock(&tda9887_list_mutex);
+
+       instance = hybrid_tuner_request_state(struct tda9887_priv, priv,
+                                             hybrid_tuner_instance_list,
+                                             i2c_adap, i2c_addr, "tda9887");
+       switch (instance) {
+       case 0:
+               mutex_unlock(&tda9887_list_mutex);
+               return NULL;
+               break;
+       case 1:
+               fe->analog_demod_priv = priv;
+               priv->mode = T_STANDBY;
+               tuner_info("tda988[5/6/7] found\n");
+               break;
+       default:
+               fe->analog_demod_priv = priv;
+               break;
+       }
+
+       mutex_unlock(&tda9887_list_mutex);
+
+       memcpy(&fe->ops.analog_ops, &tda9887_ops,
+              sizeof(struct analog_demod_ops));
+
+       return fe;
+}
+EXPORT_SYMBOL_GPL(tda9887_attach);
+
+MODULE_LICENSE("GPL");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tda9887.h b/drivers/media/common/tuners/tda9887.h
new file mode 100644 (file)
index 0000000..be49dcb
--- /dev/null
@@ -0,0 +1,38 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TDA9887_H__
+#define __TDA9887_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+/* ------------------------------------------------------------------------ */
+#if defined(CONFIG_TUNER_TDA9887) || (defined(CONFIG_TUNER_TDA9887_MODULE) && defined(MODULE))
+extern struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
+                                          struct i2c_adapter *i2c_adap,
+                                          u8 i2c_addr);
+#else
+static inline struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
+                                                 struct i2c_adapter *i2c_adap,
+                                                 u8 i2c_addr)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TDA9887_H__ */
diff --git a/drivers/media/common/tuners/tea5761.c b/drivers/media/common/tuners/tea5761.c
new file mode 100644 (file)
index 0000000..b93cdef
--- /dev/null
@@ -0,0 +1,324 @@
+/*
+ * For Philips TEA5761 FM Chip
+ * I2C address is allways 0x20 (0x10 at 7-bit mode).
+ *
+ * Copyright (c) 2005-2007 Mauro Carvalho Chehab (mchehab@infradead.org)
+ * This code is placed under the terms of the GNUv2 General Public License
+ *
+ */
+
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/videodev.h>
+#include <media/tuner.h>
+#include "tuner-i2c.h"
+#include "tea5761.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+struct tea5761_priv {
+       struct tuner_i2c_props i2c_props;
+
+       u32 frequency;
+};
+
+/*****************************************************************************/
+
+/***************************
+ * TEA5761HN I2C registers *
+ ***************************/
+
+/* INTREG - Read: bytes 0 and 1 / Write: byte 0 */
+
+       /* first byte for reading */
+#define TEA5761_INTREG_IFFLAG          0x10
+#define TEA5761_INTREG_LEVFLAG         0x8
+#define TEA5761_INTREG_FRRFLAG         0x2
+#define TEA5761_INTREG_BLFLAG          0x1
+
+       /* second byte for reading / byte for writing */
+#define TEA5761_INTREG_IFMSK           0x10
+#define TEA5761_INTREG_LEVMSK          0x8
+#define TEA5761_INTREG_FRMSK           0x2
+#define TEA5761_INTREG_BLMSK           0x1
+
+/* FRQSET - Read: bytes 2 and 3 / Write: byte 1 and 2 */
+
+       /* First byte */
+#define TEA5761_FRQSET_SEARCH_UP 0x80          /* 1=Station search from botton to up */
+#define TEA5761_FRQSET_SEARCH_MODE 0x40                /* 1=Search mode */
+
+       /* Bits 0-5 for divider MSB */
+
+       /* Second byte */
+       /* Bits 0-7 for divider LSB */
+
+/* TNCTRL - Read: bytes 4 and 5 / Write: Bytes 3 and 4 */
+
+       /* first byte */
+
+#define TEA5761_TNCTRL_PUPD_0  0x40    /* Power UP/Power Down MSB */
+#define TEA5761_TNCTRL_BLIM    0X20    /* 1= Japan Frequencies, 0= European frequencies */
+#define TEA5761_TNCTRL_SWPM    0x10    /* 1= software port is FRRFLAG */
+#define TEA5761_TNCTRL_IFCTC   0x08    /* 1= IF count time 15.02 ms, 0= IF count time 2.02 ms */
+#define TEA5761_TNCTRL_AFM     0x04
+#define TEA5761_TNCTRL_SMUTE   0x02    /* 1= Soft mute */
+#define TEA5761_TNCTRL_SNC     0x01
+
+       /* second byte */
+
+#define TEA5761_TNCTRL_MU      0x80    /* 1=Hard mute */
+#define TEA5761_TNCTRL_SSL_1   0x40
+#define TEA5761_TNCTRL_SSL_0   0x20
+#define TEA5761_TNCTRL_HLSI    0x10
+#define TEA5761_TNCTRL_MST     0x08    /* 1 = mono */
+#define TEA5761_TNCTRL_SWP     0x04
+#define TEA5761_TNCTRL_DTC     0x02    /* 1 = deemphasis 50 us, 0 = deemphasis 75 us */
+#define TEA5761_TNCTRL_AHLSI   0x01
+
+/* FRQCHECK - Read: bytes 6 and 7  */
+       /* First byte */
+
+       /* Bits 0-5 for divider MSB */
+
+       /* Second byte */
+       /* Bits 0-7 for divider LSB */
+
+/* TUNCHECK - Read: bytes 8 and 9  */
+
+       /* First byte */
+#define TEA5761_TUNCHECK_IF_MASK       0x7e    /* IF count */
+#define TEA5761_TUNCHECK_TUNTO         0x01
+
+       /* Second byte */
+#define TEA5761_TUNCHECK_LEV_MASK      0xf0    /* Level Count */
+#define TEA5761_TUNCHECK_LD            0x08
+#define TEA5761_TUNCHECK_STEREO                0x04
+
+/* TESTREG - Read: bytes 10 and 11 / Write: bytes 5 and 6 */
+
+       /* All zero = no test mode */
+
+/* MANID - Read: bytes 12 and 13 */
+
+       /* First byte - should be 0x10 */
+#define TEA5767_MANID_VERSION_MASK     0xf0    /* Version = 1 */
+#define TEA5767_MANID_ID_MSB_MASK      0x0f    /* Manufacurer ID - should be 0 */
+
+       /* Second byte - Should be 0x2b */
+
+#define TEA5767_MANID_ID_LSB_MASK      0xfe    /* Manufacturer ID - should be 0x15 */
+#define TEA5767_MANID_IDAV             0x01    /* 1 = Chip has ID, 0 = Chip has no ID */
+
+/* Chip ID - Read: bytes 14 and 15 */
+
+       /* First byte - should be 0x57 */
+
+       /* Second byte - should be 0x61 */
+
+/*****************************************************************************/
+
+#define FREQ_OFFSET 0 /* for TEA5767, it is 700 to give the right freq */
+static void tea5761_status_dump(unsigned char *buffer)
+{
+       unsigned int div, frq;
+
+       div = ((buffer[2] & 0x3f) << 8) | buffer[3];
+
+       frq = 1000 * (div * 32768 / 1000 + FREQ_OFFSET + 225) / 4;      /* Freq in KHz */
+
+       printk(KERN_INFO "tea5761: Frequency %d.%03d KHz (divider = 0x%04x)\n",
+              frq / 1000, frq % 1000, div);
+}
+
+/* Freq should be specifyed at 62.5 Hz */
+static int set_radio_freq(struct dvb_frontend *fe,
+                         struct analog_parameters *params)
+{
+       struct tea5761_priv *priv = fe->tuner_priv;
+       unsigned int frq = params->frequency;
+       unsigned char buffer[7] = {0, 0, 0, 0, 0, 0, 0 };
+       unsigned div;
+       int rc;
+
+       tuner_dbg("radio freq counter %d\n", frq);
+
+       if (params->mode == T_STANDBY) {
+               tuner_dbg("TEA5761 set to standby mode\n");
+               buffer[5] |= TEA5761_TNCTRL_MU;
+       } else {
+               buffer[4] |= TEA5761_TNCTRL_PUPD_0;
+       }
+
+
+       if (params->audmode == V4L2_TUNER_MODE_MONO) {
+               tuner_dbg("TEA5761 set to mono\n");
+               buffer[5] |= TEA5761_TNCTRL_MST;
+       } else {
+               tuner_dbg("TEA5761 set to stereo\n");
+       }
+
+       div = (1000 * (frq * 4 / 16 + 700 + 225) ) >> 15;
+       buffer[1] = (div >> 8) & 0x3f;
+       buffer[2] = div & 0xff;
+
+       if (debug)
+               tea5761_status_dump(buffer);
+
+       if (7 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 7)))
+               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
+
+       priv->frequency = frq * 125 / 2;
+
+       return 0;
+}
+
+static int tea5761_read_status(struct dvb_frontend *fe, char *buffer)
+{
+       struct tea5761_priv *priv = fe->tuner_priv;
+       int rc;
+
+       memset(buffer, 0, 16);
+       if (16 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 16))) {
+               tuner_warn("i2c i/o error: rc == %d (should be 16)\n", rc);
+               return -EREMOTEIO;
+       }
+
+       return 0;
+}
+
+static inline int tea5761_signal(struct dvb_frontend *fe, const char *buffer)
+{
+       struct tea5761_priv *priv = fe->tuner_priv;
+
+       int signal = ((buffer[9] & TEA5761_TUNCHECK_LEV_MASK) << (13 - 4));
+
+       tuner_dbg("Signal strength: %d\n", signal);
+
+       return signal;
+}
+
+static inline int tea5761_stereo(struct dvb_frontend *fe, const char *buffer)
+{
+       struct tea5761_priv *priv = fe->tuner_priv;
+
+       int stereo = buffer[9] & TEA5761_TUNCHECK_STEREO;
+
+       tuner_dbg("Radio ST GET = %02x\n", stereo);
+
+       return (stereo ? V4L2_TUNER_SUB_STEREO : 0);
+}
+
+static int tea5761_get_status(struct dvb_frontend *fe, u32 *status)
+{
+       unsigned char buffer[16];
+
+       *status = 0;
+
+       if (0 == tea5761_read_status(fe, buffer)) {
+               if (tea5761_signal(fe, buffer))
+                       *status = TUNER_STATUS_LOCKED;
+               if (tea5761_stereo(fe, buffer))
+                       *status |= TUNER_STATUS_STEREO;
+       }
+
+       return 0;
+}
+
+static int tea5761_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
+{
+       unsigned char buffer[16];
+
+       *strength = 0;
+
+       if (0 == tea5761_read_status(fe, buffer))
+               *strength = tea5761_signal(fe, buffer);
+
+       return 0;
+}
+
+int tea5761_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr)
+{
+       unsigned char buffer[16];
+       int rc;
+       struct tuner_i2c_props i2c = { .adap = i2c_adap, .addr = i2c_addr };
+
+       if (16 != (rc = tuner_i2c_xfer_recv(&i2c, buffer, 16))) {
+               printk(KERN_WARNING "it is not a TEA5761. Received %i chars.\n", rc);
+               return -EINVAL;
+       }
+
+       if ((buffer[13] != 0x2b) || (buffer[14] != 0x57) || (buffer[15] != 0x061)) {
+               printk(KERN_WARNING "Manufacturer ID= 0x%02x, Chip ID = %02x%02x."
+                                   " It is not a TEA5761\n",
+                                   buffer[13], buffer[14], buffer[15]);
+               return -EINVAL;
+       }
+       printk(KERN_WARNING "tea5761: TEA%02x%02x detected. "
+                           "Manufacturer ID= 0x%02x\n",
+                           buffer[14], buffer[15], buffer[13]);
+
+       return 0;
+}
+
+static int tea5761_release(struct dvb_frontend *fe)
+{
+       kfree(fe->tuner_priv);
+       fe->tuner_priv = NULL;
+
+       return 0;
+}
+
+static int tea5761_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct tea5761_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+       return 0;
+}
+
+static struct dvb_tuner_ops tea5761_tuner_ops = {
+       .info = {
+               .name           = "tea5761", // Philips TEA5761HN FM Radio
+       },
+       .set_analog_params = set_radio_freq,
+       .release           = tea5761_release,
+       .get_frequency     = tea5761_get_frequency,
+       .get_status        = tea5761_get_status,
+       .get_rf_strength   = tea5761_get_rf_strength,
+};
+
+struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
+                                   struct i2c_adapter* i2c_adap,
+                                   u8 i2c_addr)
+{
+       struct tea5761_priv *priv = NULL;
+
+       if (tea5761_autodetection(i2c_adap, i2c_addr) == EINVAL)
+               return NULL;
+
+       priv = kzalloc(sizeof(struct tea5761_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+       fe->tuner_priv = priv;
+
+       priv->i2c_props.addr = i2c_addr;
+       priv->i2c_props.adap = i2c_adap;
+       priv->i2c_props.name = "tea5761";
+
+       memcpy(&fe->ops.tuner_ops, &tea5761_tuner_ops,
+              sizeof(struct dvb_tuner_ops));
+
+       tuner_info("type set to %s\n", "Philips TEA5761HN FM Radio");
+
+       return fe;
+}
+
+
+EXPORT_SYMBOL_GPL(tea5761_attach);
+EXPORT_SYMBOL_GPL(tea5761_autodetection);
+
+MODULE_DESCRIPTION("Philips TEA5761 FM tuner driver");
+MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/common/tuners/tea5761.h b/drivers/media/common/tuners/tea5761.h
new file mode 100644 (file)
index 0000000..8eb6272
--- /dev/null
@@ -0,0 +1,47 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TEA5761_H__
+#define __TEA5761_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+#if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
+extern int tea5761_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr);
+
+extern struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
+                                          struct i2c_adapter* i2c_adap,
+                                          u8 i2c_addr);
+#else
+static inline int tea5761_autodetection(struct i2c_adapter* i2c_adap,
+                                       u8 i2c_addr)
+{
+       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
+              __func__);
+       return -EINVAL;
+}
+
+static inline struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
+                                                  struct i2c_adapter* i2c_adap,
+                                                  u8 i2c_addr)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TEA5761_H__ */
diff --git a/drivers/media/common/tuners/tea5767.c b/drivers/media/common/tuners/tea5767.c
new file mode 100644 (file)
index 0000000..f6e7d7a
--- /dev/null
@@ -0,0 +1,474 @@
+/*
+ * For Philips TEA5767 FM Chip used on some TV Cards like Prolink Pixelview
+ * I2C address is allways 0xC0.
+ *
+ *
+ * Copyright (c) 2005 Mauro Carvalho Chehab (mchehab@infradead.org)
+ * This code is placed under the terms of the GNU General Public License
+ *
+ * tea5767 autodetection thanks to Torsten Seeboth and Atsushi Nakagawa
+ * from their contributions on DScaler.
+ */
+
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/videodev.h>
+#include "tuner-i2c.h"
+#include "tea5767.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+/*****************************************************************************/
+
+struct tea5767_priv {
+       struct tuner_i2c_props  i2c_props;
+       u32                     frequency;
+       struct tea5767_ctrl     ctrl;
+};
+
+/*****************************************************************************/
+
+/******************************
+ * Write mode register values *
+ ******************************/
+
+/* First register */
+#define TEA5767_MUTE           0x80    /* Mutes output */
+#define TEA5767_SEARCH         0x40    /* Activates station search */
+/* Bits 0-5 for divider MSB */
+
+/* Second register */
+/* Bits 0-7 for divider LSB */
+
+/* Third register */
+
+/* Station search from botton to up */
+#define TEA5767_SEARCH_UP      0x80
+
+/* Searches with ADC output = 10 */
+#define TEA5767_SRCH_HIGH_LVL  0x60
+
+/* Searches with ADC output = 10 */
+#define TEA5767_SRCH_MID_LVL   0x40
+
+/* Searches with ADC output = 5 */
+#define TEA5767_SRCH_LOW_LVL   0x20
+
+/* if on, div=4*(Frf+Fif)/Fref otherwise, div=4*(Frf-Fif)/Freq) */
+#define TEA5767_HIGH_LO_INJECT 0x10
+
+/* Disable stereo */
+#define TEA5767_MONO           0x08
+
+/* Disable right channel and turns to mono */
+#define TEA5767_MUTE_RIGHT     0x04
+
+/* Disable left channel and turns to mono */
+#define TEA5767_MUTE_LEFT      0x02
+
+#define TEA5767_PORT1_HIGH     0x01
+
+/* Fourth register */
+#define TEA5767_PORT2_HIGH     0x80
+/* Chips stops working. Only I2C bus remains on */
+#define TEA5767_STDBY          0x40
+
+/* Japan freq (76-108 MHz. If disabled, 87.5-108 MHz */
+#define TEA5767_JAPAN_BAND     0x20
+
+/* Unselected means 32.768 KHz freq as reference. Otherwise Xtal at 13 MHz */
+#define TEA5767_XTAL_32768     0x10
+
+/* Cuts weak signals */
+#define TEA5767_SOFT_MUTE      0x08
+
+/* Activates high cut control */
+#define TEA5767_HIGH_CUT_CTRL  0x04
+
+/* Activates stereo noise control */
+#define TEA5767_ST_NOISE_CTL   0x02
+
+/* If activate PORT 1 indicates SEARCH or else it is used as PORT1 */
+#define TEA5767_SRCH_IND       0x01
+
+/* Fifth register */
+
+/* By activating, it will use Xtal at 13 MHz as reference for divider */
+#define TEA5767_PLLREF_ENABLE  0x80
+
+/* By activating, deemphasis=50, or else, deemphasis of 50us */
+#define TEA5767_DEEMPH_75      0X40
+
+/*****************************
+ * Read mode register values *
+ *****************************/
+
+/* First register */
+#define TEA5767_READY_FLAG_MASK        0x80
+#define TEA5767_BAND_LIMIT_MASK        0X40
+/* Bits 0-5 for divider MSB after search or preset */
+
+/* Second register */
+/* Bits 0-7 for divider LSB after search or preset */
+
+/* Third register */
+#define TEA5767_STEREO_MASK    0x80
+#define TEA5767_IF_CNTR_MASK   0x7f
+
+/* Fourth register */
+#define TEA5767_ADC_LEVEL_MASK 0xf0
+
+/* should be 0 */
+#define TEA5767_CHIP_ID_MASK   0x0f
+
+/* Fifth register */
+/* Reserved for future extensions */
+#define TEA5767_RESERVED_MASK  0xff
+
+/*****************************************************************************/
+
+static void tea5767_status_dump(struct tea5767_priv *priv,
+                               unsigned char *buffer)
+{
+       unsigned int div, frq;
+
+       if (TEA5767_READY_FLAG_MASK & buffer[0])
+               tuner_info("Ready Flag ON\n");
+       else
+               tuner_info("Ready Flag OFF\n");
+
+       if (TEA5767_BAND_LIMIT_MASK & buffer[0])
+               tuner_info("Tuner at band limit\n");
+       else
+               tuner_info("Tuner not at band limit\n");
+
+       div = ((buffer[0] & 0x3f) << 8) | buffer[1];
+
+       switch (priv->ctrl.xtal_freq) {
+       case TEA5767_HIGH_LO_13MHz:
+               frq = (div * 50000 - 700000 - 225000) / 4;      /* Freq in KHz */
+               break;
+       case TEA5767_LOW_LO_13MHz:
+               frq = (div * 50000 + 700000 + 225000) / 4;      /* Freq in KHz */
+               break;
+       case TEA5767_LOW_LO_32768:
+               frq = (div * 32768 + 700000 + 225000) / 4;      /* Freq in KHz */
+               break;
+       case TEA5767_HIGH_LO_32768:
+       default:
+               frq = (div * 32768 - 700000 - 225000) / 4;      /* Freq in KHz */
+               break;
+       }
+       buffer[0] = (div >> 8) & 0x3f;
+       buffer[1] = div & 0xff;
+
+       tuner_info("Frequency %d.%03d KHz (divider = 0x%04x)\n",
+                  frq / 1000, frq % 1000, div);
+
+       if (TEA5767_STEREO_MASK & buffer[2])
+               tuner_info("Stereo\n");
+       else
+               tuner_info("Mono\n");
+
+       tuner_info("IF Counter = %d\n", buffer[2] & TEA5767_IF_CNTR_MASK);
+
+       tuner_info("ADC Level = %d\n",
+                  (buffer[3] & TEA5767_ADC_LEVEL_MASK) >> 4);
+
+       tuner_info("Chip ID = %d\n", (buffer[3] & TEA5767_CHIP_ID_MASK));
+
+       tuner_info("Reserved = 0x%02x\n",
+                  (buffer[4] & TEA5767_RESERVED_MASK));
+}
+
+/* Freq should be specifyed at 62.5 Hz */
+static int set_radio_freq(struct dvb_frontend *fe,
+                         struct analog_parameters *params)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+       unsigned int frq = params->frequency;
+       unsigned char buffer[5];
+       unsigned div;
+       int rc;
+
+       tuner_dbg("radio freq = %d.%03d MHz\n", frq/16000,(frq/16)%1000);
+
+       buffer[2] = 0;
+
+       if (priv->ctrl.port1)
+               buffer[2] |= TEA5767_PORT1_HIGH;
+
+       if (params->audmode == V4L2_TUNER_MODE_MONO) {
+               tuner_dbg("TEA5767 set to mono\n");
+               buffer[2] |= TEA5767_MONO;
+       } else {
+               tuner_dbg("TEA5767 set to stereo\n");
+       }
+
+
+       buffer[3] = 0;
+
+       if (priv->ctrl.port2)
+               buffer[3] |= TEA5767_PORT2_HIGH;
+
+       if (priv->ctrl.high_cut)
+               buffer[3] |= TEA5767_HIGH_CUT_CTRL;
+
+       if (priv->ctrl.st_noise)
+               buffer[3] |= TEA5767_ST_NOISE_CTL;
+
+       if (priv->ctrl.soft_mute)
+               buffer[3] |= TEA5767_SOFT_MUTE;
+
+       if (priv->ctrl.japan_band)
+               buffer[3] |= TEA5767_JAPAN_BAND;
+
+       buffer[4] = 0;
+
+       if (priv->ctrl.deemph_75)
+               buffer[4] |= TEA5767_DEEMPH_75;
+
+       if (priv->ctrl.pllref)
+               buffer[4] |= TEA5767_PLLREF_ENABLE;
+
+
+       /* Rounds freq to next decimal value - for 62.5 KHz step */
+       /* frq = 20*(frq/16)+radio_frq[frq%16]; */
+
+       switch (priv->ctrl.xtal_freq) {
+       case TEA5767_HIGH_LO_13MHz:
+               tuner_dbg("radio HIGH LO inject xtal @ 13 MHz\n");
+               buffer[2] |= TEA5767_HIGH_LO_INJECT;
+               div = (frq * (4000 / 16) + 700000 + 225000 + 25000) / 50000;
+               break;
+       case TEA5767_LOW_LO_13MHz:
+               tuner_dbg("radio LOW LO inject xtal @ 13 MHz\n");
+
+               div = (frq * (4000 / 16) - 700000 - 225000 + 25000) / 50000;
+               break;
+       case TEA5767_LOW_LO_32768:
+               tuner_dbg("radio LOW LO inject xtal @ 32,768 MHz\n");
+               buffer[3] |= TEA5767_XTAL_32768;
+               /* const 700=4000*175 Khz - to adjust freq to right value */
+               div = ((frq * (4000 / 16) - 700000 - 225000) + 16384) >> 15;
+               break;
+       case TEA5767_HIGH_LO_32768:
+       default:
+               tuner_dbg("radio HIGH LO inject xtal @ 32,768 MHz\n");
+
+               buffer[2] |= TEA5767_HIGH_LO_INJECT;
+               buffer[3] |= TEA5767_XTAL_32768;
+               div = ((frq * (4000 / 16) + 700000 + 225000) + 16384) >> 15;
+               break;
+       }
+       buffer[0] = (div >> 8) & 0x3f;
+       buffer[1] = div & 0xff;
+
+       if (5 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 5)))
+               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
+
+       if (debug) {
+               if (5 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 5)))
+                       tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
+               else
+                       tea5767_status_dump(priv, buffer);
+       }
+
+       priv->frequency = frq * 125 / 2;
+
+       return 0;
+}
+
+static int tea5767_read_status(struct dvb_frontend *fe, char *buffer)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+       int rc;
+
+       memset(buffer, 0, 5);
+       if (5 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 5))) {
+               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
+               return -EREMOTEIO;
+       }
+
+       return 0;
+}
+
+static inline int tea5767_signal(struct dvb_frontend *fe, const char *buffer)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+
+       int signal = ((buffer[3] & TEA5767_ADC_LEVEL_MASK) << 8);
+
+       tuner_dbg("Signal strength: %d\n", signal);
+
+       return signal;
+}
+
+static inline int tea5767_stereo(struct dvb_frontend *fe, const char *buffer)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+
+       int stereo = buffer[2] & TEA5767_STEREO_MASK;
+
+       tuner_dbg("Radio ST GET = %02x\n", stereo);
+
+       return (stereo ? V4L2_TUNER_SUB_STEREO : 0);
+}
+
+static int tea5767_get_status(struct dvb_frontend *fe, u32 *status)
+{
+       unsigned char buffer[5];
+
+       *status = 0;
+
+       if (0 == tea5767_read_status(fe, buffer)) {
+               if (tea5767_signal(fe, buffer))
+                       *status = TUNER_STATUS_LOCKED;
+               if (tea5767_stereo(fe, buffer))
+                       *status |= TUNER_STATUS_STEREO;
+       }
+
+       return 0;
+}
+
+static int tea5767_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
+{
+       unsigned char buffer[5];
+
+       *strength = 0;
+
+       if (0 == tea5767_read_status(fe, buffer))
+               *strength = tea5767_signal(fe, buffer);
+
+       return 0;
+}
+
+static int tea5767_standby(struct dvb_frontend *fe)
+{
+       unsigned char buffer[5];
+       struct tea5767_priv *priv = fe->tuner_priv;
+       unsigned div, rc;
+
+       div = (87500 * 4 + 700 + 225 + 25) / 50; /* Set frequency to 87.5 MHz */
+       buffer[0] = (div >> 8) & 0x3f;
+       buffer[1] = div & 0xff;
+       buffer[2] = TEA5767_PORT1_HIGH;
+       buffer[3] = TEA5767_PORT2_HIGH | TEA5767_HIGH_CUT_CTRL |
+                   TEA5767_ST_NOISE_CTL | TEA5767_JAPAN_BAND | TEA5767_STDBY;
+       buffer[4] = 0;
+
+       if (5 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 5)))
+               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
+
+       return 0;
+}
+
+int tea5767_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr)
+{
+       struct tuner_i2c_props i2c = { .adap = i2c_adap, .addr = i2c_addr };
+       unsigned char buffer[7] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+       int rc;
+
+       if ((rc = tuner_i2c_xfer_recv(&i2c, buffer, 7))< 5) {
+               printk(KERN_WARNING "It is not a TEA5767. Received %i bytes.\n", rc);
+               return EINVAL;
+       }
+
+       /* If all bytes are the same then it's a TV tuner and not a tea5767 */
+       if (buffer[0] == buffer[1] && buffer[0] == buffer[2] &&
+           buffer[0] == buffer[3] && buffer[0] == buffer[4]) {
+               printk(KERN_WARNING "All bytes are equal. It is not a TEA5767\n");
+               return EINVAL;
+       }
+
+       /*  Status bytes:
+        *  Byte 4: bit 3:1 : CI (Chip Identification) == 0
+        *          bit 0   : internally set to 0
+        *  Byte 5: bit 7:0 : == 0
+        */
+       if (((buffer[3] & 0x0f) != 0x00) || (buffer[4] != 0x00)) {
+               printk(KERN_WARNING "Chip ID is not zero. It is not a TEA5767\n");
+               return EINVAL;
+       }
+
+
+       return 0;
+}
+
+static int tea5767_release(struct dvb_frontend *fe)
+{
+       kfree(fe->tuner_priv);
+       fe->tuner_priv = NULL;
+
+       return 0;
+}
+
+static int tea5767_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+
+       return 0;
+}
+
+static int tea5767_set_config (struct dvb_frontend *fe, void *priv_cfg)
+{
+       struct tea5767_priv *priv = fe->tuner_priv;
+
+       memcpy(&priv->ctrl, priv_cfg, sizeof(priv->ctrl));
+
+       return 0;
+}
+
+static struct dvb_tuner_ops tea5767_tuner_ops = {
+       .info = {
+               .name           = "tea5767", // Philips TEA5767HN FM Radio
+       },
+
+       .set_analog_params = set_radio_freq,
+       .set_config        = tea5767_set_config,
+       .sleep             = tea5767_standby,
+       .release           = tea5767_release,
+       .get_frequency     = tea5767_get_frequency,
+       .get_status        = tea5767_get_status,
+       .get_rf_strength   = tea5767_get_rf_strength,
+};
+
+struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
+                                   struct i2c_adapter* i2c_adap,
+                                   u8 i2c_addr)
+{
+       struct tea5767_priv *priv = NULL;
+
+       priv = kzalloc(sizeof(struct tea5767_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+       fe->tuner_priv = priv;
+
+       priv->i2c_props.addr  = i2c_addr;
+       priv->i2c_props.adap  = i2c_adap;
+       priv->i2c_props.name  = "tea5767";
+
+       priv->ctrl.xtal_freq  = TEA5767_HIGH_LO_32768;
+       priv->ctrl.port1      = 1;
+       priv->ctrl.port2      = 1;
+       priv->ctrl.high_cut   = 1;
+       priv->ctrl.st_noise   = 1;
+       priv->ctrl.japan_band = 1;
+
+       memcpy(&fe->ops.tuner_ops, &tea5767_tuner_ops,
+              sizeof(struct dvb_tuner_ops));
+
+       tuner_info("type set to %s\n", "Philips TEA5767HN FM Radio");
+
+       return fe;
+}
+
+EXPORT_SYMBOL_GPL(tea5767_attach);
+EXPORT_SYMBOL_GPL(tea5767_autodetection);
+
+MODULE_DESCRIPTION("Philips TEA5767 FM tuner driver");
+MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/common/tuners/tea5767.h b/drivers/media/common/tuners/tea5767.h
new file mode 100644 (file)
index 0000000..7b547c0
--- /dev/null
@@ -0,0 +1,66 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TEA5767_H__
+#define __TEA5767_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+enum tea5767_xtal {
+       TEA5767_LOW_LO_32768    = 0,
+       TEA5767_HIGH_LO_32768   = 1,
+       TEA5767_LOW_LO_13MHz    = 2,
+       TEA5767_HIGH_LO_13MHz   = 3,
+};
+
+struct tea5767_ctrl {
+       unsigned int            port1:1;
+       unsigned int            port2:1;
+       unsigned int            high_cut:1;
+       unsigned int            st_noise:1;
+       unsigned int            soft_mute:1;
+       unsigned int            japan_band:1;
+       unsigned int            deemph_75:1;
+       unsigned int            pllref:1;
+       enum tea5767_xtal       xtal_freq;
+};
+
+#if defined(CONFIG_TUNER_TEA5767) || (defined(CONFIG_TUNER_TEA5767_MODULE) && defined(MODULE))
+extern int tea5767_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr);
+
+extern struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
+                                          struct i2c_adapter* i2c_adap,
+                                          u8 i2c_addr);
+#else
+static inline int tea5767_autodetection(struct i2c_adapter* i2c_adap,
+                                       u8 i2c_addr)
+{
+       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
+              __func__);
+       return -EINVAL;
+}
+
+static inline struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
+                                                  struct i2c_adapter* i2c_adap,
+                                                  u8 i2c_addr)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TEA5767_H__ */
diff --git a/drivers/media/common/tuners/tuner-i2c.h b/drivers/media/common/tuners/tuner-i2c.h
new file mode 100644 (file)
index 0000000..3ad6c8e
--- /dev/null
@@ -0,0 +1,173 @@
+/*
+    tuner-i2c.h - i2c interface for different tuners
+
+    Copyright (C) 2007 Michael Krufky (mkrufky@linuxtv.org)
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TUNER_I2C_H__
+#define __TUNER_I2C_H__
+
+#include <linux/i2c.h>
+
+struct tuner_i2c_props {
+       u8 addr;
+       struct i2c_adapter *adap;
+
+       /* used for tuner instance management */
+       int count;
+       char *name;
+};
+
+static inline int tuner_i2c_xfer_send(struct tuner_i2c_props *props, char *buf, int len)
+{
+       struct i2c_msg msg = { .addr = props->addr, .flags = 0,
+                              .buf = buf, .len = len };
+       int ret = i2c_transfer(props->adap, &msg, 1);
+
+       return (ret == 1) ? len : ret;
+}
+
+static inline int tuner_i2c_xfer_recv(struct tuner_i2c_props *props, char *buf, int len)
+{
+       struct i2c_msg msg = { .addr = props->addr, .flags = I2C_M_RD,
+                              .buf = buf, .len = len };
+       int ret = i2c_transfer(props->adap, &msg, 1);
+
+       return (ret == 1) ? len : ret;
+}
+
+static inline int tuner_i2c_xfer_send_recv(struct tuner_i2c_props *props,
+                                          char *obuf, int olen,
+                                          char *ibuf, int ilen)
+{
+       struct i2c_msg msg[2] = { { .addr = props->addr, .flags = 0,
+                                   .buf = obuf, .len = olen },
+                                 { .addr = props->addr, .flags = I2C_M_RD,
+                                   .buf = ibuf, .len = ilen } };
+       int ret = i2c_transfer(props->adap, msg, 2);
+
+       return (ret == 2) ? ilen : ret;
+}
+
+/* Callers must declare as a global for the module:
+ *
+ * static LIST_HEAD(hybrid_tuner_instance_list);
+ *
+ * hybrid_tuner_instance_list should be the third argument
+ * passed into hybrid_tuner_request_state().
+ *
+ * state structure must contain the following:
+ *
+ *     struct list_head        hybrid_tuner_instance_list;
+ *     struct tuner_i2c_props  i2c_props;
+ *
+ * hybrid_tuner_instance_list (both within state structure and globally)
+ * is only required if the driver is using hybrid_tuner_request_state
+ * and hybrid_tuner_release_state to manage state sharing between
+ * multiple instances of hybrid tuners.
+ */
+
+#define tuner_printk(kernlvl, i2cprops, fmt, arg...) do {              \
+       printk(kernlvl "%s %d-%04x: " fmt, i2cprops.name,               \
+                       i2cprops.adap ?                                 \
+                               i2c_adapter_id(i2cprops.adap) : -1,     \
+                       i2cprops.addr, ##arg);                          \
+        } while (0)
+
+/* TO DO: convert all callers of these macros to pass in
+ * struct tuner_i2c_props, then remove the macro wrappers */
+
+#define __tuner_warn(i2cprops, fmt, arg...) do {                       \
+       tuner_printk(KERN_WARNING, i2cprops, fmt, ##arg);               \
+       } while (0)
+
+#define __tuner_info(i2cprops, fmt, arg...) do {                       \
+       tuner_printk(KERN_INFO, i2cprops, fmt, ##arg);                  \
+       } while (0)
+
+#define __tuner_err(i2cprops, fmt, arg...) do {                                \
+       tuner_printk(KERN_ERR, i2cprops, fmt, ##arg);                   \
+       } while (0)
+
+#define __tuner_dbg(i2cprops, fmt, arg...) do {                                \
+       if ((debug))                                                    \
+               tuner_printk(KERN_DEBUG, i2cprops, fmt, ##arg);         \
+       } while (0)
+
+#define tuner_warn(fmt, arg...) __tuner_warn(priv->i2c_props, fmt, ##arg)
+#define tuner_info(fmt, arg...) __tuner_info(priv->i2c_props, fmt, ##arg)
+#define tuner_err(fmt, arg...) __tuner_err(priv->i2c_props, fmt, ##arg)
+#define tuner_dbg(fmt, arg...) __tuner_dbg(priv->i2c_props, fmt, ##arg)
+
+/****************************************************************************/
+
+/* The return value of hybrid_tuner_request_state indicates the number of
+ * instances using this tuner object.
+ *
+ * 0 - no instances, indicates an error - kzalloc must have failed
+ *
+ * 1 - one instance, indicates that the tuner object was created successfully
+ *
+ * 2 (or more) instances, indicates that an existing tuner object was found
+ */
+
+#define hybrid_tuner_request_state(type, state, list, i2cadap, i2caddr, devname)\
+({                                                                     \
+       int __ret = 0;                                                  \
+       list_for_each_entry(state, &list, hybrid_tuner_instance_list) { \
+               if (((i2cadap) && (state->i2c_props.adap)) &&           \
+                   ((i2c_adapter_id(state->i2c_props.adap) ==          \
+                     i2c_adapter_id(i2cadap)) &&                       \
+                    (i2caddr == state->i2c_props.addr))) {             \
+                       __tuner_info(state->i2c_props,                  \
+                                    "attaching existing instance\n");  \
+                       state->i2c_props.count++;                       \
+                       __ret = state->i2c_props.count;                 \
+                       break;                                          \
+               }                                                       \
+       }                                                               \
+       if (0 == __ret) {                                               \
+               state = kzalloc(sizeof(type), GFP_KERNEL);              \
+               if (NULL == state)                                      \
+                       goto __fail;                                    \
+               state->i2c_props.addr = i2caddr;                        \
+               state->i2c_props.adap = i2cadap;                        \
+               state->i2c_props.name = devname;                        \
+               __tuner_info(state->i2c_props,                          \
+                            "creating new instance\n");                \
+               list_add_tail(&state->hybrid_tuner_instance_list, &list);\
+               state->i2c_props.count++;                               \
+               __ret = state->i2c_props.count;                         \
+       }                                                               \
+__fail:                                                                        \
+       __ret;                                                          \
+})
+
+#define hybrid_tuner_release_state(state)                              \
+({                                                                     \
+       int __ret;                                                      \
+       state->i2c_props.count--;                                       \
+       __ret = state->i2c_props.count;                                 \
+       if (!state->i2c_props.count) {                                  \
+               __tuner_info(state->i2c_props, "destroying instance\n");\
+               list_del(&state->hybrid_tuner_instance_list);           \
+               kfree(state);                                           \
+       }                                                               \
+       __ret;                                                          \
+})
+
+#endif /* __TUNER_I2C_H__ */
diff --git a/drivers/media/common/tuners/tuner-simple.c b/drivers/media/common/tuners/tuner-simple.c
new file mode 100644 (file)
index 0000000..be8d903
--- /dev/null
@@ -0,0 +1,1093 @@
+/*
+ * i2c tv tuner chip device driver
+ * controls all those simple 4-control-bytes style tuners.
+ *
+ * This "tuner-simple" module was split apart from the original "tuner" module.
+ */
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/videodev.h>
+#include <media/tuner.h>
+#include <media/v4l2-common.h>
+#include <media/tuner-types.h>
+#include "tuner-i2c.h"
+#include "tuner-simple.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+#define TUNER_SIMPLE_MAX 64
+static unsigned int simple_devcount;
+
+static int offset;
+module_param(offset, int, 0664);
+MODULE_PARM_DESC(offset, "Allows to specify an offset for tuner");
+
+static unsigned int atv_input[TUNER_SIMPLE_MAX] = \
+                       { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
+static unsigned int dtv_input[TUNER_SIMPLE_MAX] = \
+                       { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
+module_param_array(atv_input, int, NULL, 0644);
+module_param_array(dtv_input, int, NULL, 0644);
+MODULE_PARM_DESC(atv_input, "specify atv rf input, 0 for autoselect");
+MODULE_PARM_DESC(dtv_input, "specify dtv rf input, 0 for autoselect");
+
+/* ---------------------------------------------------------------------- */
+
+/* tv standard selection for Temic 4046 FM5
+   this value takes the low bits of control byte 2
+   from datasheet Rev.01, Feb.00
+     standard     BG      I       L       L2      D
+     picture IF   38.9    38.9    38.9    33.95   38.9
+     sound 1      33.4    32.9    32.4    40.45   32.4
+     sound 2      33.16
+     NICAM        33.05   32.348  33.05           33.05
+ */
+#define TEMIC_SET_PAL_I         0x05
+#define TEMIC_SET_PAL_DK        0x09
+#define TEMIC_SET_PAL_L         0x0a /* SECAM ? */
+#define TEMIC_SET_PAL_L2        0x0b /* change IF ! */
+#define TEMIC_SET_PAL_BG        0x0c
+
+/* tv tuner system standard selection for Philips FQ1216ME
+   this value takes the low bits of control byte 2
+   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
+     standard          BG      DK      I       L       L`
+     picture carrier   38.90   38.90   38.90   38.90   33.95
+     colour            34.47   34.47   34.47   34.47   38.38
+     sound 1           33.40   32.40   32.90   32.40   40.45
+     sound 2           33.16   -       -       -       -
+     NICAM             33.05   33.05   32.35   33.05   39.80
+ */
+#define PHILIPS_SET_PAL_I      0x01 /* Bit 2 always zero !*/
+#define PHILIPS_SET_PAL_BGDK   0x09
+#define PHILIPS_SET_PAL_L2     0x0a
+#define PHILIPS_SET_PAL_L      0x0b
+
+/* system switching for Philips FI1216MF MK2
+   from datasheet "1996 Jul 09",
+    standard         BG     L      L'
+    picture carrier  38.90  38.90  33.95
+    colour          34.47  34.37  38.38
+    sound 1          33.40  32.40  40.45
+    sound 2          33.16  -      -
+    NICAM            33.05  33.05  39.80
+ */
+#define PHILIPS_MF_SET_STD_BG  0x01 /* Bit 2 must be zero, Bit 3 is system output */
+#define PHILIPS_MF_SET_STD_L   0x03 /* Used on Secam France */
+#define PHILIPS_MF_SET_STD_LC  0x02 /* Used on SECAM L' */
+
+/* Control byte */
+
+#define TUNER_RATIO_MASK        0x06 /* Bit cb1:cb2 */
+#define TUNER_RATIO_SELECT_50   0x00
+#define TUNER_RATIO_SELECT_32   0x02
+#define TUNER_RATIO_SELECT_166  0x04
+#define TUNER_RATIO_SELECT_62   0x06
+
+#define TUNER_CHARGE_PUMP       0x40  /* Bit cb6 */
+
+/* Status byte */
+
+#define TUNER_POR        0x80
+#define TUNER_FL          0x40
+#define TUNER_MODE        0x38
+#define TUNER_AFC         0x07
+#define TUNER_SIGNAL      0x07
+#define TUNER_STEREO      0x10
+
+#define TUNER_PLL_LOCKED   0x40
+#define TUNER_STEREO_MK3   0x04
+
+static DEFINE_MUTEX(tuner_simple_list_mutex);
+static LIST_HEAD(hybrid_tuner_instance_list);
+
+struct tuner_simple_priv {
+       unsigned int nr;
+       u16 last_div;
+
+       struct tuner_i2c_props i2c_props;
+       struct list_head hybrid_tuner_instance_list;
+
+       unsigned int type;
+       struct tunertype *tun;
+
+       u32 frequency;
+       u32 bandwidth;
+};
+
+/* ---------------------------------------------------------------------- */
+
+static int tuner_read_status(struct dvb_frontend *fe)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       unsigned char byte;
+
+       if (1 != tuner_i2c_xfer_recv(&priv->i2c_props, &byte, 1))
+               return 0;
+
+       return byte;
+}
+
+static inline int tuner_signal(const int status)
+{
+       return (status & TUNER_SIGNAL) << 13;
+}
+
+static inline int tuner_stereo(const int type, const int status)
+{
+       switch (type) {
+       case TUNER_PHILIPS_FM1216ME_MK3:
+       case TUNER_PHILIPS_FM1236_MK3:
+       case TUNER_PHILIPS_FM1256_IH3:
+       case TUNER_LG_NTSC_TAPE:
+               return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
+       default:
+               return status & TUNER_STEREO;
+       }
+}
+
+static inline int tuner_islocked(const int status)
+{
+       return (status & TUNER_FL);
+}
+
+static inline int tuner_afcstatus(const int status)
+{
+       return (status & TUNER_AFC) - 2;
+}
+
+
+static int simple_get_status(struct dvb_frontend *fe, u32 *status)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       int tuner_status;
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       tuner_status = tuner_read_status(fe);
+
+       *status = 0;
+
+       if (tuner_islocked(tuner_status))
+               *status = TUNER_STATUS_LOCKED;
+       if (tuner_stereo(priv->type, tuner_status))
+               *status |= TUNER_STATUS_STEREO;
+
+       tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status));
+
+       return 0;
+}
+
+static int simple_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       int signal;
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       signal = tuner_signal(tuner_read_status(fe));
+
+       *strength = signal;
+
+       tuner_dbg("Signal strength: %d\n", signal);
+
+       return 0;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static inline char *tuner_param_name(enum param_type type)
+{
+       char *name;
+
+       switch (type) {
+       case TUNER_PARAM_TYPE_RADIO:
+               name = "radio";
+               break;
+       case TUNER_PARAM_TYPE_PAL:
+               name = "pal";
+               break;
+       case TUNER_PARAM_TYPE_SECAM:
+               name = "secam";
+               break;
+       case TUNER_PARAM_TYPE_NTSC:
+               name = "ntsc";
+               break;
+       case TUNER_PARAM_TYPE_DIGITAL:
+               name = "digital";
+               break;
+       default:
+               name = "unknown";
+               break;
+       }
+       return name;
+}
+
+static struct tuner_params *simple_tuner_params(struct dvb_frontend *fe,
+                                               enum param_type desired_type)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       struct tunertype *tun = priv->tun;
+       int i;
+
+       for (i = 0; i < tun->count; i++)
+               if (desired_type == tun->params[i].type)
+                       break;
+
+       /* use default tuner params if desired_type not available */
+       if (i == tun->count) {
+               tuner_dbg("desired params (%s) undefined for tuner %d\n",
+                         tuner_param_name(desired_type), priv->type);
+               i = 0;
+       }
+
+       tuner_dbg("using tuner params #%d (%s)\n", i,
+                 tuner_param_name(tun->params[i].type));
+
+       return &tun->params[i];
+}
+
+static int simple_config_lookup(struct dvb_frontend *fe,
+                               struct tuner_params *t_params,
+                               int *frequency, u8 *config, u8 *cb)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       int i;
+
+       for (i = 0; i < t_params->count; i++) {
+               if (*frequency > t_params->ranges[i].limit)
+                       continue;
+               break;
+       }
+       if (i == t_params->count) {
+               tuner_dbg("frequency out of range (%d > %d)\n",
+                         *frequency, t_params->ranges[i - 1].limit);
+               *frequency = t_params->ranges[--i].limit;
+       }
+       *config = t_params->ranges[i].config;
+       *cb     = t_params->ranges[i].cb;
+
+       tuner_dbg("freq = %d.%02d (%d), range = %d, "
+                 "config = 0x%02x, cb = 0x%02x\n",
+                 *frequency / 16, *frequency % 16 * 100 / 16, *frequency,
+                 i, *config, *cb);
+
+       return i;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static void simple_set_rf_input(struct dvb_frontend *fe,
+                               u8 *config, u8 *cb, unsigned int rf)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       switch (priv->type) {
+       case TUNER_PHILIPS_TUV1236D:
+               switch (rf) {
+               case 1:
+                       *cb |= 0x08;
+                       break;
+               default:
+                       *cb &= ~0x08;
+                       break;
+               }
+               break;
+       case TUNER_PHILIPS_FCV1236D:
+               switch (rf) {
+               case 1:
+                       *cb |= 0x01;
+                       break;
+               default:
+                       *cb &= ~0x01;
+                       break;
+               }
+               break;
+       default:
+               break;
+       }
+}
+
+static int simple_std_setup(struct dvb_frontend *fe,
+                           struct analog_parameters *params,
+                           u8 *config, u8 *cb)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       u8 tuneraddr;
+       int rc;
+
+       /* tv norm specific stuff for multi-norm tuners */
+       switch (priv->type) {
+       case TUNER_PHILIPS_SECAM: /* FI1216MF */
+               /* 0x01 -> ??? no change ??? */
+               /* 0x02 -> PAL BDGHI / SECAM L */
+               /* 0x04 -> ??? PAL others / SECAM others ??? */
+               *cb &= ~0x03;
+               if (params->std & V4L2_STD_SECAM_L)
+                       /* also valid for V4L2_STD_SECAM */
+                       *cb |= PHILIPS_MF_SET_STD_L;
+               else if (params->std & V4L2_STD_SECAM_LC)
+                       *cb |= PHILIPS_MF_SET_STD_LC;
+               else /* V4L2_STD_B|V4L2_STD_GH */
+                       *cb |= PHILIPS_MF_SET_STD_BG;
+               break;
+
+       case TUNER_TEMIC_4046FM5:
+               *cb &= ~0x0f;
+
+               if (params->std & V4L2_STD_PAL_BG) {
+                       *cb |= TEMIC_SET_PAL_BG;
+
+               } else if (params->std & V4L2_STD_PAL_I) {
+                       *cb |= TEMIC_SET_PAL_I;
+
+               } else if (params->std & V4L2_STD_PAL_DK) {
+                       *cb |= TEMIC_SET_PAL_DK;
+
+               } else if (params->std & V4L2_STD_SECAM_L) {
+                       *cb |= TEMIC_SET_PAL_L;
+
+               }
+               break;
+
+       case TUNER_PHILIPS_FQ1216ME:
+               *cb &= ~0x0f;
+
+               if (params->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
+                       *cb |= PHILIPS_SET_PAL_BGDK;
+
+               } else if (params->std & V4L2_STD_PAL_I) {
+                       *cb |= PHILIPS_SET_PAL_I;
+
+               } else if (params->std & V4L2_STD_SECAM_L) {
+                       *cb |= PHILIPS_SET_PAL_L;
+
+               }
+               break;
+
+       case TUNER_PHILIPS_FCV1236D:
+               /* 0x00 -> ATSC antenna input 1 */
+               /* 0x01 -> ATSC antenna input 2 */
+               /* 0x02 -> NTSC antenna input 1 */
+               /* 0x03 -> NTSC antenna input 2 */
+               *cb &= ~0x03;
+               if (!(params->std & V4L2_STD_ATSC))
+                       *cb |= 2;
+               break;
+
+       case TUNER_MICROTUNE_4042FI5:
+               /* Set the charge pump for fast tuning */
+               *config |= TUNER_CHARGE_PUMP;
+               break;
+
+       case TUNER_PHILIPS_TUV1236D:
+       {
+               /* 0x40 -> ATSC antenna input 1 */
+               /* 0x48 -> ATSC antenna input 2 */
+               /* 0x00 -> NTSC antenna input 1 */
+               /* 0x08 -> NTSC antenna input 2 */
+               u8 buffer[4] = { 0x14, 0x00, 0x17, 0x00};
+               *cb &= ~0x40;
+               if (params->std & V4L2_STD_ATSC) {
+                       *cb |= 0x40;
+                       buffer[1] = 0x04;
+               }
+               /* set to the correct mode (analog or digital) */
+               tuneraddr = priv->i2c_props.addr;
+               priv->i2c_props.addr = 0x0a;
+               rc = tuner_i2c_xfer_send(&priv->i2c_props, &buffer[0], 2);
+               if (2 != rc)
+                       tuner_warn("i2c i/o error: rc == %d "
+                                  "(should be 2)\n", rc);
+               rc = tuner_i2c_xfer_send(&priv->i2c_props, &buffer[2], 2);
+               if (2 != rc)
+                       tuner_warn("i2c i/o error: rc == %d "
+                                  "(should be 2)\n", rc);
+               priv->i2c_props.addr = tuneraddr;
+               break;
+       }
+       }
+       if (atv_input[priv->nr])
+               simple_set_rf_input(fe, config, cb, atv_input[priv->nr]);
+
+       return 0;
+}
+
+static int simple_post_tune(struct dvb_frontend *fe, u8 *buffer,
+                           u16 div, u8 config, u8 cb)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       int rc;
+
+       switch (priv->type) {
+       case TUNER_LG_TDVS_H06XF:
+               /* Set the Auxiliary Byte. */
+               buffer[0] = buffer[2];
+               buffer[0] &= ~0x20;
+               buffer[0] |= 0x18;
+               buffer[1] = 0x20;
+               tuner_dbg("tv 0x%02x 0x%02x\n", buffer[0], buffer[1]);
+
+               rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 2);
+               if (2 != rc)
+                       tuner_warn("i2c i/o error: rc == %d "
+                                  "(should be 2)\n", rc);
+               break;
+       case TUNER_MICROTUNE_4042FI5:
+       {
+               /* FIXME - this may also work for other tuners */
+               unsigned long timeout = jiffies + msecs_to_jiffies(1);
+               u8 status_byte = 0;
+
+               /* Wait until the PLL locks */
+               for (;;) {
+                       if (time_after(jiffies, timeout))
+                               return 0;
+                       rc = tuner_i2c_xfer_recv(&priv->i2c_props,
+                                                &status_byte, 1);
+                       if (1 != rc) {
+                               tuner_warn("i2c i/o read error: rc == %d "
+                                          "(should be 1)\n", rc);
+                               break;
+                       }
+                       if (status_byte & TUNER_PLL_LOCKED)
+                               break;
+                       udelay(10);
+               }
+
+               /* Set the charge pump for optimized phase noise figure */
+               config &= ~TUNER_CHARGE_PUMP;
+               buffer[0] = (div>>8) & 0x7f;
+               buffer[1] = div      & 0xff;
+               buffer[2] = config;
+               buffer[3] = cb;
+               tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
+                         buffer[0], buffer[1], buffer[2], buffer[3]);
+
+               rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
+               if (4 != rc)
+                       tuner_warn("i2c i/o error: rc == %d "
+                                  "(should be 4)\n", rc);
+               break;
+       }
+       }
+
+       return 0;
+}
+
+static int simple_radio_bandswitch(struct dvb_frontend *fe, u8 *buffer)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       switch (priv->type) {
+       case TUNER_TENA_9533_DI:
+       case TUNER_YMEC_TVF_5533MF:
+               tuner_dbg("This tuner doesn't have FM. "
+                         "Most cards have a TEA5767 for FM\n");
+               return 0;
+       case TUNER_PHILIPS_FM1216ME_MK3:
+       case TUNER_PHILIPS_FM1236_MK3:
+       case TUNER_PHILIPS_FMD1216ME_MK3:
+       case TUNER_LG_NTSC_TAPE:
+       case TUNER_PHILIPS_FM1256_IH3:
+               buffer[3] = 0x19;
+               break;
+       case TUNER_TNF_5335MF:
+               buffer[3] = 0x11;
+               break;
+       case TUNER_LG_PAL_FM:
+               buffer[3] = 0xa5;
+               break;
+       case TUNER_THOMSON_DTT761X:
+               buffer[3] = 0x39;
+               break;
+       case TUNER_MICROTUNE_4049FM5:
+       default:
+               buffer[3] = 0xa4;
+               break;
+       }
+
+       return 0;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static int simple_set_tv_freq(struct dvb_frontend *fe,
+                             struct analog_parameters *params)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       u8 config, cb;
+       u16 div;
+       struct tunertype *tun;
+       u8 buffer[4];
+       int rc, IFPCoff, i;
+       enum param_type desired_type;
+       struct tuner_params *t_params;
+
+       tun = priv->tun;
+
+       /* IFPCoff = Video Intermediate Frequency - Vif:
+               940  =16*58.75  NTSC/J (Japan)
+               732  =16*45.75  M/N STD
+               704  =16*44     ATSC (at DVB code)
+               632  =16*39.50  I U.K.
+               622.4=16*38.90  B/G D/K I, L STD
+               592  =16*37.00  D China
+               590  =16.36.875 B Australia
+               543.2=16*33.95  L' STD
+               171.2=16*10.70  FM Radio (at set_radio_freq)
+       */
+
+       if (params->std == V4L2_STD_NTSC_M_JP) {
+               IFPCoff      = 940;
+               desired_type = TUNER_PARAM_TYPE_NTSC;
+       } else if ((params->std & V4L2_STD_MN) &&
+                 !(params->std & ~V4L2_STD_MN)) {
+               IFPCoff      = 732;
+               desired_type = TUNER_PARAM_TYPE_NTSC;
+       } else if (params->std == V4L2_STD_SECAM_LC) {
+               IFPCoff      = 543;
+               desired_type = TUNER_PARAM_TYPE_SECAM;
+       } else {
+               IFPCoff      = 623;
+               desired_type = TUNER_PARAM_TYPE_PAL;
+       }
+
+       t_params = simple_tuner_params(fe, desired_type);
+
+       i = simple_config_lookup(fe, t_params, &params->frequency,
+                                &config, &cb);
+
+       div = params->frequency + IFPCoff + offset;
+
+       tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, "
+                 "Offset=%d.%02d MHz, div=%0d\n",
+                 params->frequency / 16, params->frequency % 16 * 100 / 16,
+                 IFPCoff / 16, IFPCoff % 16 * 100 / 16,
+                 offset / 16, offset % 16 * 100 / 16, div);
+
+       /* tv norm specific stuff for multi-norm tuners */
+       simple_std_setup(fe, params, &config, &cb);
+
+       if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
+               buffer[0] = config;
+               buffer[1] = cb;
+               buffer[2] = (div>>8) & 0x7f;
+               buffer[3] = div      & 0xff;
+       } else {
+               buffer[0] = (div>>8) & 0x7f;
+               buffer[1] = div      & 0xff;
+               buffer[2] = config;
+               buffer[3] = cb;
+       }
+       priv->last_div = div;
+       if (t_params->has_tda9887) {
+               struct v4l2_priv_tun_config tda9887_cfg;
+               int config = 0;
+               int is_secam_l = (params->std & (V4L2_STD_SECAM_L |
+                                                V4L2_STD_SECAM_LC)) &&
+                       !(params->std & ~(V4L2_STD_SECAM_L |
+                                         V4L2_STD_SECAM_LC));
+
+               tda9887_cfg.tuner = TUNER_TDA9887;
+               tda9887_cfg.priv  = &config;
+
+               if (params->std == V4L2_STD_SECAM_LC) {
+                       if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc)
+                               config |= TDA9887_PORT1_ACTIVE;
+                       if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc)
+                               config |= TDA9887_PORT2_ACTIVE;
+               } else {
+                       if (t_params->port1_active)
+                               config |= TDA9887_PORT1_ACTIVE;
+                       if (t_params->port2_active)
+                               config |= TDA9887_PORT2_ACTIVE;
+               }
+               if (t_params->intercarrier_mode)
+                       config |= TDA9887_INTERCARRIER;
+               if (is_secam_l) {
+                       if (i == 0 && t_params->default_top_secam_low)
+                               config |= TDA9887_TOP(t_params->default_top_secam_low);
+                       else if (i == 1 && t_params->default_top_secam_mid)
+                               config |= TDA9887_TOP(t_params->default_top_secam_mid);
+                       else if (t_params->default_top_secam_high)
+                               config |= TDA9887_TOP(t_params->default_top_secam_high);
+               } else {
+                       if (i == 0 && t_params->default_top_low)
+                               config |= TDA9887_TOP(t_params->default_top_low);
+                       else if (i == 1 && t_params->default_top_mid)
+                               config |= TDA9887_TOP(t_params->default_top_mid);
+                       else if (t_params->default_top_high)
+                               config |= TDA9887_TOP(t_params->default_top_high);
+               }
+               if (t_params->default_pll_gating_18)
+                       config |= TDA9887_GATING_18;
+               i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
+                                   &tda9887_cfg);
+       }
+       tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
+                 buffer[0], buffer[1], buffer[2], buffer[3]);
+
+       rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
+       if (4 != rc)
+               tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
+
+       simple_post_tune(fe, &buffer[0], div, config, cb);
+
+       return 0;
+}
+
+static int simple_set_radio_freq(struct dvb_frontend *fe,
+                                struct analog_parameters *params)
+{
+       struct tunertype *tun;
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       u8 buffer[4];
+       u16 div;
+       int rc, j;
+       struct tuner_params *t_params;
+       unsigned int freq = params->frequency;
+
+       tun = priv->tun;
+
+       for (j = tun->count-1; j > 0; j--)
+               if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO)
+                       break;
+       /* default t_params (j=0) will be used if desired type wasn't found */
+       t_params = &tun->params[j];
+
+       /* Select Radio 1st IF used */
+       switch (t_params->radio_if) {
+       case 0: /* 10.7 MHz */
+               freq += (unsigned int)(10.7*16000);
+               break;
+       case 1: /* 33.3 MHz */
+               freq += (unsigned int)(33.3*16000);
+               break;
+       case 2: /* 41.3 MHz */
+               freq += (unsigned int)(41.3*16000);
+               break;
+       default:
+               tuner_warn("Unsupported radio_if value %d\n",
+                          t_params->radio_if);
+               return 0;
+       }
+
+       /* Bandswitch byte */
+       simple_radio_bandswitch(fe, &buffer[0]);
+
+       buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) |
+                   TUNER_RATIO_SELECT_50; /* 50 kHz step */
+
+       /* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps
+          freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) =
+          freq * (1/800) */
+       div = (freq + 400) / 800;
+
+       if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
+               buffer[0] = buffer[2];
+               buffer[1] = buffer[3];
+               buffer[2] = (div>>8) & 0x7f;
+               buffer[3] = div      & 0xff;
+       } else {
+               buffer[0] = (div>>8) & 0x7f;
+               buffer[1] = div      & 0xff;
+       }
+
+       tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
+              buffer[0], buffer[1], buffer[2], buffer[3]);
+       priv->last_div = div;
+
+       if (t_params->has_tda9887) {
+               int config = 0;
+               struct v4l2_priv_tun_config tda9887_cfg;
+
+               tda9887_cfg.tuner = TUNER_TDA9887;
+               tda9887_cfg.priv = &config;
+
+               if (t_params->port1_active &&
+                   !t_params->port1_fm_high_sensitivity)
+                       config |= TDA9887_PORT1_ACTIVE;
+               if (t_params->port2_active &&
+                   !t_params->port2_fm_high_sensitivity)
+                       config |= TDA9887_PORT2_ACTIVE;
+               if (t_params->intercarrier_mode)
+                       config |= TDA9887_INTERCARRIER;
+/*             if (t_params->port1_set_for_fm_mono)
+                       config &= ~TDA9887_PORT1_ACTIVE;*/
+               if (t_params->fm_gain_normal)
+                       config |= TDA9887_GAIN_NORMAL;
+               if (t_params->radio_if == 2)
+                       config |= TDA9887_RIF_41_3;
+               i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
+                                   &tda9887_cfg);
+       }
+       rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
+       if (4 != rc)
+               tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
+
+       return 0;
+}
+
+static int simple_set_params(struct dvb_frontend *fe,
+                            struct analog_parameters *params)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       int ret = -EINVAL;
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       switch (params->mode) {
+       case V4L2_TUNER_RADIO:
+               ret = simple_set_radio_freq(fe, params);
+               priv->frequency = params->frequency * 125 / 2;
+               break;
+       case V4L2_TUNER_ANALOG_TV:
+       case V4L2_TUNER_DIGITAL_TV:
+               ret = simple_set_tv_freq(fe, params);
+               priv->frequency = params->frequency * 62500;
+               break;
+       }
+       priv->bandwidth = 0;
+
+       return ret;
+}
+
+static void simple_set_dvb(struct dvb_frontend *fe, u8 *buf,
+                          const struct dvb_frontend_parameters *params)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       switch (priv->type) {
+       case TUNER_PHILIPS_FMD1216ME_MK3:
+               if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ &&
+                   params->frequency >= 158870000)
+                       buf[3] |= 0x08;
+               break;
+       case TUNER_PHILIPS_TD1316:
+               /* determine band */
+               buf[3] |= (params->frequency < 161000000) ? 1 :
+                         (params->frequency < 444000000) ? 2 : 4;
+
+               /* setup PLL filter */
+               if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ)
+                       buf[3] |= 1 << 3;
+               break;
+       case TUNER_PHILIPS_TUV1236D:
+       case TUNER_PHILIPS_FCV1236D:
+       {
+               unsigned int new_rf;
+
+               if (dtv_input[priv->nr])
+                       new_rf = dtv_input[priv->nr];
+               else
+                       switch (params->u.vsb.modulation) {
+                       case QAM_64:
+                       case QAM_256:
+                               new_rf = 1;
+                               break;
+                       case VSB_8:
+                       default:
+                               new_rf = 0;
+                               break;
+                       }
+               simple_set_rf_input(fe, &buf[2], &buf[3], new_rf);
+               break;
+       }
+       default:
+               break;
+       }
+}
+
+static u32 simple_dvb_configure(struct dvb_frontend *fe, u8 *buf,
+                               const struct dvb_frontend_parameters *params)
+{
+       /* This function returns the tuned frequency on success, 0 on error */
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       struct tunertype *tun = priv->tun;
+       static struct tuner_params *t_params;
+       u8 config, cb;
+       u32 div;
+       int ret, frequency = params->frequency / 62500;
+
+       t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL);
+       ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb);
+       if (ret < 0)
+               return 0; /* failure */
+
+       div = ((frequency + t_params->iffreq) * 62500 + offset +
+              tun->stepsize/2) / tun->stepsize;
+
+       buf[0] = div >> 8;
+       buf[1] = div & 0xff;
+       buf[2] = config;
+       buf[3] = cb;
+
+       simple_set_dvb(fe, buf, params);
+
+       tuner_dbg("%s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
+                 tun->name, div, buf[0], buf[1], buf[2], buf[3]);
+
+       /* calculate the frequency we set it to */
+       return (div * tun->stepsize) - t_params->iffreq;
+}
+
+static int simple_dvb_calc_regs(struct dvb_frontend *fe,
+                               struct dvb_frontend_parameters *params,
+                               u8 *buf, int buf_len)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       u32 frequency;
+
+       if (buf_len < 5)
+               return -EINVAL;
+
+       frequency = simple_dvb_configure(fe, buf+1, params);
+       if (frequency == 0)
+               return -EINVAL;
+
+       buf[0] = priv->i2c_props.addr;
+
+       priv->frequency = frequency;
+       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
+               params->u.ofdm.bandwidth : 0;
+
+       return 5;
+}
+
+static int simple_dvb_set_params(struct dvb_frontend *fe,
+                                struct dvb_frontend_parameters *params)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       u32 prev_freq, prev_bw;
+       int ret;
+       u8 buf[5];
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       prev_freq = priv->frequency;
+       prev_bw   = priv->bandwidth;
+
+       ret = simple_dvb_calc_regs(fe, params, buf, 5);
+       if (ret != 5)
+               goto fail;
+
+       /* put analog demod in standby when tuning digital */
+       if (fe->ops.analog_ops.standby)
+               fe->ops.analog_ops.standby(fe);
+
+       if (fe->ops.i2c_gate_ctrl)
+               fe->ops.i2c_gate_ctrl(fe, 1);
+
+       /* buf[0] contains the i2c address, but *
+        * we already have it in i2c_props.addr */
+       ret = tuner_i2c_xfer_send(&priv->i2c_props, buf+1, 4);
+       if (ret != 4)
+               goto fail;
+
+       return 0;
+fail:
+       /* calc_regs sets frequency and bandwidth. if we failed, unset them */
+       priv->frequency = prev_freq;
+       priv->bandwidth = prev_bw;
+
+       return ret;
+}
+
+static int simple_init(struct dvb_frontend *fe)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       if (priv->tun->initdata) {
+               int ret;
+
+               if (fe->ops.i2c_gate_ctrl)
+                       fe->ops.i2c_gate_ctrl(fe, 1);
+
+               ret = tuner_i2c_xfer_send(&priv->i2c_props,
+                                         priv->tun->initdata + 1,
+                                         priv->tun->initdata[0]);
+               if (ret != priv->tun->initdata[0])
+                       return ret;
+       }
+
+       return 0;
+}
+
+static int simple_sleep(struct dvb_frontend *fe)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       if (priv->i2c_props.adap == NULL)
+               return -EINVAL;
+
+       if (priv->tun->sleepdata) {
+               int ret;
+
+               if (fe->ops.i2c_gate_ctrl)
+                       fe->ops.i2c_gate_ctrl(fe, 1);
+
+               ret = tuner_i2c_xfer_send(&priv->i2c_props,
+                                         priv->tun->sleepdata + 1,
+                                         priv->tun->sleepdata[0]);
+               if (ret != priv->tun->sleepdata[0])
+                       return ret;
+       }
+
+       return 0;
+}
+
+static int simple_release(struct dvb_frontend *fe)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+
+       mutex_lock(&tuner_simple_list_mutex);
+
+       if (priv)
+               hybrid_tuner_release_state(priv);
+
+       mutex_unlock(&tuner_simple_list_mutex);
+
+       fe->tuner_priv = NULL;
+
+       return 0;
+}
+
+static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       *frequency = priv->frequency;
+       return 0;
+}
+
+static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
+{
+       struct tuner_simple_priv *priv = fe->tuner_priv;
+       *bandwidth = priv->bandwidth;
+       return 0;
+}
+
+static struct dvb_tuner_ops simple_tuner_ops = {
+       .init              = simple_init,
+       .sleep             = simple_sleep,
+       .set_analog_params = simple_set_params,
+       .set_params        = simple_dvb_set_params,
+       .calc_regs         = simple_dvb_calc_regs,
+       .release           = simple_release,
+       .get_frequency     = simple_get_frequency,
+       .get_bandwidth     = simple_get_bandwidth,
+       .get_status        = simple_get_status,
+       .get_rf_strength   = simple_get_rf_strength,
+};
+
+struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
+                                        struct i2c_adapter *i2c_adap,
+                                        u8 i2c_addr,
+                                        unsigned int type)
+{
+       struct tuner_simple_priv *priv = NULL;
+       int instance;
+
+       if (type >= tuner_count) {
+               printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n",
+                      __func__, type, tuner_count-1);
+               return NULL;
+       }
+
+       /* If i2c_adap is set, check that the tuner is at the correct address.
+        * Otherwise, if i2c_adap is NULL, the tuner will be programmed directly
+        * by the digital demod via calc_regs.
+        */
+       if (i2c_adap != NULL) {
+               u8 b[1];
+               struct i2c_msg msg = {
+                       .addr = i2c_addr, .flags = I2C_M_RD,
+                       .buf = b, .len = 1,
+               };
+
+               if (fe->ops.i2c_gate_ctrl)
+                       fe->ops.i2c_gate_ctrl(fe, 1);
+
+               if (1 != i2c_transfer(i2c_adap, &msg, 1))
+                       tuner_warn("unable to probe %s, proceeding anyway.",
+                                  tuners[type].name);
+
+               if (fe->ops.i2c_gate_ctrl)
+                       fe->ops.i2c_gate_ctrl(fe, 0);
+       }
+
+       mutex_lock(&tuner_simple_list_mutex);
+
+       instance = hybrid_tuner_request_state(struct tuner_simple_priv, priv,
+                                             hybrid_tuner_instance_list,
+                                             i2c_adap, i2c_addr,
+                                             "tuner-simple");
+       switch (instance) {
+       case 0:
+               mutex_unlock(&tuner_simple_list_mutex);
+               return NULL;
+               break;
+       case 1:
+               fe->tuner_priv = priv;
+
+               priv->type = type;
+               priv->tun  = &tuners[type];
+               priv->nr   = simple_devcount++;
+               break;
+       default:
+               fe->tuner_priv = priv;
+               break;
+       }
+
+       mutex_unlock(&tuner_simple_list_mutex);
+
+       memcpy(&fe->ops.tuner_ops, &simple_tuner_ops,
+              sizeof(struct dvb_tuner_ops));
+
+       tuner_info("type set to %d (%s)\n", type, priv->tun->name);
+
+       if ((debug) || ((atv_input[priv->nr] > 0) ||
+                       (dtv_input[priv->nr] > 0))) {
+               if (0 == atv_input[priv->nr])
+                       tuner_info("tuner %d atv rf input will be "
+                                  "autoselected\n", priv->nr);
+               else
+                       tuner_info("tuner %d atv rf input will be "
+                                  "set to input %d (insmod option)\n",
+                                  priv->nr, atv_input[priv->nr]);
+               if (0 == dtv_input[priv->nr])
+                       tuner_info("tuner %d dtv rf input will be "
+                                  "autoselected\n", priv->nr);
+               else
+                       tuner_info("tuner %d dtv rf input will be "
+                                  "set to input %d (insmod option)\n",
+                                  priv->nr, dtv_input[priv->nr]);
+       }
+
+       strlcpy(fe->ops.tuner_ops.info.name, priv->tun->name,
+               sizeof(fe->ops.tuner_ops.info.name));
+
+       return fe;
+}
+EXPORT_SYMBOL_GPL(simple_tuner_attach);
+
+MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver");
+MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
+MODULE_LICENSE("GPL");
+
+/*
+ * Overrides for Emacs so that we follow Linus's tabbing style.
+ * ---------------------------------------------------------------------------
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/common/tuners/tuner-simple.h b/drivers/media/common/tuners/tuner-simple.h
new file mode 100644 (file)
index 0000000..e46cf01
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#ifndef __TUNER_SIMPLE_H__
+#define __TUNER_SIMPLE_H__
+
+#include <linux/i2c.h>
+#include "dvb_frontend.h"
+
+#if defined(CONFIG_TUNER_SIMPLE) || (defined(CONFIG_TUNER_SIMPLE_MODULE) && defined(MODULE))
+extern struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
+                                               struct i2c_adapter *i2c_adap,
+                                               u8 i2c_addr,
+                                               unsigned int type);
+#else
+static inline struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
+                                                      struct i2c_adapter *i2c_adap,
+                                                      u8 i2c_addr,
+                                                      unsigned int type)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TUNER_SIMPLE_H__ */
diff --git a/drivers/media/common/tuners/tuner-types.c b/drivers/media/common/tuners/tuner-types.c
new file mode 100644 (file)
index 0000000..10dddca
--- /dev/null
@@ -0,0 +1,1652 @@
+/*
+ *
+ * i2c tv tuner chip device type database.
+ *
+ */
+
+#include <linux/i2c.h>
+#include <media/tuner.h>
+#include <media/tuner-types.h>
+
+/* ---------------------------------------------------------------------- */
+
+/*
+ *     The floats in the tuner struct are computed at compile time
+ *     by gcc and cast back to integers. Thus we don't violate the
+ *     "no float in kernel" rule.
+ *
+ *     A tuner_range may be referenced by multiple tuner_params structs.
+ *     There are many duplicates in here. Reusing tuner_range structs,
+ *     rather than defining new ones for each tuner, will cut down on
+ *     memory usage, and is preferred when possible.
+ *
+ *     Each tuner_params array may contain one or more elements, one
+ *     for each video standard.
+ *
+ *     FIXME: tuner_params struct contains an element, tda988x. We must
+ *     set this for all tuners that contain a tda988x chip, and then we
+ *     can remove this setting from the various card structs.
+ *
+ *     FIXME: Right now, all tuners are using the first tuner_params[]
+ *     array element for analog mode. In the future, we will be merging
+ *     similar tuner definitions together, such that each tuner definition
+ *     will have a tuner_params struct for each available video standard.
+ *     At that point, the tuner_params[] array element will be chosen
+ *     based on the video standard in use.
+ */
+
+/* The following was taken from dvb-pll.c: */
+
+/* Set AGC TOP value to 103 dBuV:
+ *     0x80 = Control Byte
+ *     0x40 = 250 uA charge pump (irrelevant)
+ *     0x18 = Aux Byte to follow
+ *     0x06 = 64.5 kHz divider (irrelevant)
+ *     0x01 = Disable Vt (aka sleep)
+ *
+ *     0x00 = AGC Time constant 2s Iagc = 300 nA (vs 0x80 = 9 nA)
+ *     0x50 = AGC Take over point = 103 dBuV
+ */
+static u8 tua603x_agc103[] = { 2, 0x80|0x40|0x18|0x06|0x01, 0x00|0x50 };
+
+/*     0x04 = 166.67 kHz divider
+ *
+ *     0x80 = AGC Time constant 50ms Iagc = 9 uA
+ *     0x20 = AGC Take over point = 112 dBuV
+ */
+static u8 tua603x_agc112[] = { 2, 0x80|0x40|0x18|0x04|0x01, 0x80|0x20 };
+
+/* 0-9 */
+/* ------------ TUNER_TEMIC_PAL - TEMIC PAL ------------ */
+
+static struct tuner_range tuner_temic_pal_ranges[] = {
+       { 16 * 140.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0x04, },
+       { 16 * 999.99        , 0x8e, 0x01, },
+};
+
+static struct tuner_params tuner_temic_pal_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_PAL_I - Philips PAL_I ------------ */
+
+static struct tuner_range tuner_philips_pal_i_ranges[] = {
+       { 16 * 140.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_philips_pal_i_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_pal_i_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_pal_i_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_NTSC - Philips NTSC ------------ */
+
+static struct tuner_range tuner_philips_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 451.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_philips_ntsc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_philips_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_ntsc_ranges),
+               .cb_first_if_lower_freq = 1,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_SECAM - Philips SECAM ------------ */
+
+static struct tuner_range tuner_philips_secam_ranges[] = {
+       { 16 * 168.25 /*MHz*/, 0x8e, 0xa7, },
+       { 16 * 447.25 /*MHz*/, 0x8e, 0x97, },
+       { 16 * 999.99        , 0x8e, 0x37, },
+};
+
+static struct tuner_params tuner_philips_secam_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_SECAM,
+               .ranges = tuner_philips_secam_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_secam_ranges),
+               .cb_first_if_lower_freq = 1,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_PAL - Philips PAL ------------ */
+
+static struct tuner_range tuner_philips_pal_ranges[] = {
+       { 16 * 168.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 447.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_philips_pal_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_pal_ranges),
+               .cb_first_if_lower_freq = 1,
+       },
+};
+
+/* ------------ TUNER_TEMIC_NTSC - TEMIC NTSC ------------ */
+
+static struct tuner_range tuner_temic_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0x04, },
+       { 16 * 999.99        , 0x8e, 0x01, },
+};
+
+static struct tuner_params tuner_temic_ntsc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_temic_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_PAL_I - TEMIC PAL_I ------------ */
+
+static struct tuner_range tuner_temic_pal_i_ranges[] = {
+       { 16 * 170.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 450.00 /*MHz*/, 0x8e, 0x04, },
+       { 16 * 999.99        , 0x8e, 0x01, },
+};
+
+static struct tuner_params tuner_temic_pal_i_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_pal_i_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_pal_i_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4036FY5_NTSC - TEMIC NTSC ------------ */
+
+static struct tuner_range tuner_temic_4036fy5_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_4036fy5_ntsc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_temic_4036fy5_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4036fy5_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_ALPS_TSBH1_NTSC - TEMIC NTSC ------------ */
+
+static struct tuner_range tuner_alps_tsb_1_ranges[] = {
+       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 385.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_alps_tsbh1_ntsc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_alps_tsb_1_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_1_ranges),
+       },
+};
+
+/* 10-19 */
+/* ------------ TUNER_ALPS_TSBE1_PAL - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_alps_tsb_1_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_alps_tsb_1_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_1_ranges),
+       },
+};
+
+/* ------------ TUNER_ALPS_TSBB5_PAL_I - Alps PAL_I ------------ */
+
+static struct tuner_range tuner_alps_tsb_5_pal_ranges[] = {
+       { 16 * 133.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 351.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_alps_tsbb5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_alps_tsb_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_ALPS_TSBE5_PAL - Alps PAL ------------ */
+
+static struct tuner_params tuner_alps_tsbe5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_alps_tsb_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_ALPS_TSBC5_PAL - Alps PAL ------------ */
+
+static struct tuner_params tuner_alps_tsbc5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_alps_tsb_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4006FH5_PAL - TEMIC PAL ------------ */
+
+static struct tuner_range tuner_lg_pal_ranges[] = {
+       { 16 * 170.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 450.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_4006fh5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_ALPS_TSHC6_NTSC - Alps NTSC ------------ */
+
+static struct tuner_range tuner_alps_tshc6_ntsc_ranges[] = {
+       { 16 * 137.25 /*MHz*/, 0x8e, 0x14, },
+       { 16 * 385.25 /*MHz*/, 0x8e, 0x12, },
+       { 16 * 999.99        , 0x8e, 0x11, },
+};
+
+static struct tuner_params tuner_alps_tshc6_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_alps_tshc6_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_alps_tshc6_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_PAL_DK - TEMIC PAL ------------ */
+
+static struct tuner_range tuner_temic_pal_dk_ranges[] = {
+       { 16 * 168.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 456.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_pal_dk_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_pal_dk_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_pal_dk_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_NTSC_M - Philips NTSC ------------ */
+
+static struct tuner_range tuner_philips_ntsc_m_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 454.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_philips_ntsc_m_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_philips_ntsc_m_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4066FY5_PAL_I - TEMIC PAL_I ------------ */
+
+static struct tuner_range tuner_temic_40x6f_5_pal_ranges[] = {
+       { 16 * 169.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 454.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_4066fy5_pal_i_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_40x6f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4006FN5_MULTI_PAL - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_temic_4006fn5_multi_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_40x6f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
+       },
+};
+
+/* 20-29 */
+/* ------------ TUNER_TEMIC_4009FR5_PAL - TEMIC PAL ------------ */
+
+static struct tuner_range tuner_temic_4009f_5_pal_ranges[] = {
+       { 16 * 141.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 464.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_4009f_5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_4009f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4039FR5_NTSC - TEMIC NTSC ------------ */
+
+static struct tuner_range tuner_temic_4x3x_f_5_ntsc_ranges[] = {
+       { 16 * 158.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 453.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_temic_4039fr5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_temic_4x3x_f_5_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4x3x_f_5_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4046FM5 - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_temic_4046fm5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_40x6f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_PAL_DK - Philips PAL ------------ */
+
+static struct tuner_params tuner_philips_pal_dk_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FQ1216ME - Philips PAL ------------ */
+
+static struct tuner_params tuner_philips_fq1216me_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_active = 1,
+               .port2_invert_for_secam_lc = 1,
+       },
+};
+
+/* ------------ TUNER_LG_PAL_I_FM - LGINNOTEK PAL_I ------------ */
+
+static struct tuner_params tuner_lg_pal_i_fm_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_PAL_I - LGINNOTEK PAL_I ------------ */
+
+static struct tuner_params tuner_lg_pal_i_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_NTSC_FM - LGINNOTEK NTSC ------------ */
+
+static struct tuner_range tuner_lg_ntsc_fm_ranges[] = {
+       { 16 * 210.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 497.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_lg_ntsc_fm_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_lg_ntsc_fm_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_ntsc_fm_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_PAL_FM - LGINNOTEK PAL ------------ */
+
+static struct tuner_params tuner_lg_pal_fm_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_PAL - LGINNOTEK PAL ------------ */
+
+static struct tuner_params tuner_lg_pal_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
+       },
+};
+
+/* 30-39 */
+/* ------------ TUNER_TEMIC_4009FN5_MULTI_PAL_FM - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_temic_4009_fn5_multi_pal_fm_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_4009f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_SHARP_2U5JF5540_NTSC - SHARP NTSC ------------ */
+
+static struct tuner_range tuner_sharp_2u5jf5540_ntsc_ranges[] = {
+       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 317.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_sharp_2u5jf5540_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_sharp_2u5jf5540_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_sharp_2u5jf5540_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_Samsung_PAL_TCPM9091PD27 - Samsung PAL ------------ */
+
+static struct tuner_range tuner_samsung_pal_tcpm9091pd27_ranges[] = {
+       { 16 * 169 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 464 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99     , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_samsung_pal_tcpm9091pd27_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_samsung_pal_tcpm9091pd27_ranges,
+               .count  = ARRAY_SIZE(tuner_samsung_pal_tcpm9091pd27_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4106FH5 - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_temic_4106fh5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_4009f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4012FY5 - TEMIC PAL ------------ */
+
+static struct tuner_params tuner_temic_4012fy5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_TEMIC_4136FY5 - TEMIC NTSC ------------ */
+
+static struct tuner_params tuner_temic_4136_fy5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_temic_4x3x_f_5_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4x3x_f_5_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_PAL_NEW_TAPC - LGINNOTEK PAL ------------ */
+
+static struct tuner_range tuner_lg_new_tapc_ranges[] = {
+       { 16 * 170.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 450.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_lg_pal_new_tapc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_new_tapc_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FM1216ME_MK3 - Philips PAL ------------ */
+
+static struct tuner_range tuner_fm1216me_mk3_pal_ranges[] = {
+       { 16 * 158.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 442.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x04, },
+};
+
+static struct tuner_params tuner_fm1216me_mk3_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_fm1216me_mk3_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_fm1216me_mk3_pal_ranges),
+               .cb_first_if_lower_freq = 1,
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_active = 1,
+               .port2_invert_for_secam_lc = 1,
+               .port1_fm_high_sensitivity = 1,
+               .default_top_mid = -2,
+               .default_top_secam_mid = -2,
+               .default_top_secam_high = -2,
+       },
+};
+
+/* ------------ TUNER_LG_NTSC_NEW_TAPC - LGINNOTEK NTSC ------------ */
+
+static struct tuner_params tuner_lg_ntsc_new_tapc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_lg_new_tapc_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
+       },
+};
+
+/* 40-49 */
+/* ------------ TUNER_HITACHI_NTSC - HITACHI NTSC ------------ */
+
+static struct tuner_params tuner_hitachi_ntsc_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_lg_new_tapc_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_PAL_MK - Philips PAL ------------ */
+
+static struct tuner_range tuner_philips_pal_mk_pal_ranges[] = {
+       { 16 * 140.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0xc2, },
+       { 16 * 999.99        , 0x8e, 0xcf, },
+};
+
+static struct tuner_params tuner_philips_pal_mk_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_pal_mk_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_pal_mk_pal_ranges),
+       },
+};
+
+/* ---- TUNER_PHILIPS_FCV1236D - Philips FCV1236D (ATSC/NTSC) ---- */
+
+static struct tuner_range tuner_philips_fcv1236d_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0x8e, 0xa2, },
+       { 16 * 451.25 /*MHz*/, 0x8e, 0x92, },
+       { 16 * 999.99        , 0x8e, 0x32, },
+};
+
+static struct tuner_range tuner_philips_fcv1236d_atsc_ranges[] = {
+       { 16 * 159.00 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 453.00 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_philips_fcv1236d_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_philips_fcv1236d_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_philips_fcv1236d_atsc_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_atsc_ranges),
+               .iffreq = 16 * 44.00,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FM1236_MK3 - Philips NTSC ------------ */
+
+static struct tuner_range tuner_fm1236_mk3_ntsc_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 442.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x04, },
+};
+
+static struct tuner_params tuner_fm1236_mk3_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_fm1236_mk3_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
+               .cb_first_if_lower_freq = 1,
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_active = 1,
+               .port1_fm_high_sensitivity = 1,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_4IN1 - Philips NTSC ------------ */
+
+static struct tuner_params tuner_philips_4in1_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_fm1236_mk3_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_MICROTUNE_4049FM5 - Microtune PAL ------------ */
+
+static struct tuner_params tuner_microtune_4049_fm5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_temic_4009f_5_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
+               .has_tda9887 = 1,
+               .port1_invert_for_secam_lc = 1,
+               .default_pll_gating_18 = 1,
+               .fm_gain_normal=1,
+               .radio_if = 1, /* 33.3 MHz */
+       },
+};
+
+/* ------------ TUNER_PANASONIC_VP27 - Panasonic NTSC ------------ */
+
+static struct tuner_range tuner_panasonic_vp27_ntsc_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0xce, 0x01, },
+       { 16 * 454.00 /*MHz*/, 0xce, 0x02, },
+       { 16 * 999.99        , 0xce, 0x08, },
+};
+
+static struct tuner_params tuner_panasonic_vp27_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_panasonic_vp27_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_panasonic_vp27_ntsc_ranges),
+               .has_tda9887 = 1,
+               .intercarrier_mode = 1,
+               .default_top_low = -3,
+               .default_top_mid = -3,
+               .default_top_high = -3,
+       },
+};
+
+/* ------------ TUNER_TNF_8831BGFF - Philips PAL ------------ */
+
+static struct tuner_range tuner_tnf_8831bgff_pal_ranges[] = {
+       { 16 * 161.25 /*MHz*/, 0x8e, 0xa0, },
+       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
+       { 16 * 999.99        , 0x8e, 0x30, },
+};
+
+static struct tuner_params tuner_tnf_8831bgff_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_tnf_8831bgff_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_tnf_8831bgff_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_MICROTUNE_4042FI5 - Microtune NTSC ------------ */
+
+static struct tuner_range tuner_microtune_4042fi5_ntsc_ranges[] = {
+       { 16 * 162.00 /*MHz*/, 0x8e, 0xa2, },
+       { 16 * 457.00 /*MHz*/, 0x8e, 0x94, },
+       { 16 * 999.99        , 0x8e, 0x31, },
+};
+
+static struct tuner_range tuner_microtune_4042fi5_atsc_ranges[] = {
+       { 16 * 162.00 /*MHz*/, 0x8e, 0xa1, },
+       { 16 * 457.00 /*MHz*/, 0x8e, 0x91, },
+       { 16 * 999.99        , 0x8e, 0x31, },
+};
+
+static struct tuner_params tuner_microtune_4042fi5_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_microtune_4042fi5_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_microtune_4042fi5_atsc_ranges,
+               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_atsc_ranges),
+               .iffreq = 16 * 44.00 /*MHz*/,
+       },
+};
+
+/* 50-59 */
+/* ------------ TUNER_TCL_2002N - TCL NTSC ------------ */
+
+static struct tuner_range tuner_tcl_2002n_ntsc_ranges[] = {
+       { 16 * 172.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 448.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_tcl_2002n_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_tcl_2002n_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tcl_2002n_ntsc_ranges),
+               .cb_first_if_lower_freq = 1,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FM1256_IH3 - Philips PAL ------------ */
+
+static struct tuner_params tuner_philips_fm1256_ih3_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_fm1236_mk3_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
+               .radio_if = 1, /* 33.3 MHz */
+       },
+};
+
+/* ------------ TUNER_THOMSON_DTT7610 - THOMSON ATSC ------------ */
+
+/* single range used for both ntsc and atsc */
+static struct tuner_range tuner_thomson_dtt7610_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0x8e, 0x39, },
+       { 16 * 454.00 /*MHz*/, 0x8e, 0x3a, },
+       { 16 * 999.99        , 0x8e, 0x3c, },
+};
+
+static struct tuner_params tuner_thomson_dtt7610_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_thomson_dtt7610_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_thomson_dtt7610_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_ntsc_ranges),
+               .iffreq = 16 * 44.00 /*MHz*/,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FQ1286 - Philips NTSC ------------ */
+
+static struct tuner_range tuner_philips_fq1286_ntsc_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0x8e, 0x41, },
+       { 16 * 454.00 /*MHz*/, 0x8e, 0x42, },
+       { 16 * 999.99        , 0x8e, 0x04, },
+};
+
+static struct tuner_params tuner_philips_fq1286_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_philips_fq1286_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fq1286_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_TCL_2002MB - TCL PAL ------------ */
+
+static struct tuner_range tuner_tcl_2002mb_pal_ranges[] = {
+       { 16 * 170.00 /*MHz*/, 0xce, 0x01, },
+       { 16 * 450.00 /*MHz*/, 0xce, 0x02, },
+       { 16 * 999.99        , 0xce, 0x08, },
+};
+
+static struct tuner_params tuner_tcl_2002mb_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_tcl_2002mb_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_tcl_2002mb_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FQ1216AME_MK4 - Philips PAL ------------ */
+
+static struct tuner_range tuner_philips_fq12_6a___mk4_pal_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0xce, 0x01, },
+       { 16 * 442.00 /*MHz*/, 0xce, 0x02, },
+       { 16 * 999.99        , 0xce, 0x04, },
+};
+
+static struct tuner_params tuner_philips_fq1216ame_mk4_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_fq12_6a___mk4_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fq12_6a___mk4_pal_ranges),
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_invert_for_secam_lc = 1,
+               .default_top_mid = -2,
+               .default_top_secam_low = -2,
+               .default_top_secam_mid = -2,
+               .default_top_secam_high = -2,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FQ1236A_MK4 - Philips NTSC ------------ */
+
+static struct tuner_params tuner_philips_fq1236a_mk4_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_fm1236_mk3_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_YMEC_TVF_8531MF - Philips NTSC ------------ */
+
+static struct tuner_params tuner_ymec_tvf_8531mf_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_philips_ntsc_m_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_ranges),
+       },
+};
+
+/* ------------ TUNER_YMEC_TVF_5533MF - Philips NTSC ------------ */
+
+static struct tuner_range tuner_ymec_tvf_5533mf_ntsc_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 454.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x04, },
+};
+
+static struct tuner_params tuner_ymec_tvf_5533mf_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_ymec_tvf_5533mf_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_ymec_tvf_5533mf_ntsc_ranges),
+       },
+};
+
+/* 60-69 */
+/* ------------ TUNER_THOMSON_DTT761X - THOMSON ATSC ------------ */
+/* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
+
+static struct tuner_range tuner_thomson_dtt761x_ntsc_ranges[] = {
+       { 16 * 145.25 /*MHz*/, 0x8e, 0x39, },
+       { 16 * 415.25 /*MHz*/, 0x8e, 0x3a, },
+       { 16 * 999.99        , 0x8e, 0x3c, },
+};
+
+static struct tuner_range tuner_thomson_dtt761x_atsc_ranges[] = {
+       { 16 * 147.00 /*MHz*/, 0x8e, 0x39, },
+       { 16 * 417.00 /*MHz*/, 0x8e, 0x3a, },
+       { 16 * 999.99        , 0x8e, 0x3c, },
+};
+
+static struct tuner_params tuner_thomson_dtt761x_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_thomson_dtt761x_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_ntsc_ranges),
+               .has_tda9887 = 1,
+               .fm_gain_normal = 1,
+               .radio_if = 2, /* 41.3 MHz */
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_thomson_dtt761x_atsc_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_atsc_ranges),
+               .iffreq = 16 * 44.00, /*MHz*/
+       },
+};
+
+/* ------------ TUNER_TENA_9533_DI - Philips PAL ------------ */
+
+static struct tuner_range tuner_tena_9533_di_pal_ranges[] = {
+       { 16 * 160.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 464.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x04, },
+};
+
+static struct tuner_params tuner_tena_9533_di_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_tena_9533_di_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_tena_9533_di_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_FMD1216ME_MK3 - Philips PAL ------------ */
+
+static struct tuner_range tuner_philips_fmd1216me_mk3_pal_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0x86, 0x51, },
+       { 16 * 442.00 /*MHz*/, 0x86, 0x52, },
+       { 16 * 999.99        , 0x86, 0x54, },
+};
+
+static struct tuner_range tuner_philips_fmd1216me_mk3_dvb_ranges[] = {
+       { 16 * 143.87 /*MHz*/, 0xbc, 0x41 },
+       { 16 * 158.87 /*MHz*/, 0xf4, 0x41 },
+       { 16 * 329.87 /*MHz*/, 0xbc, 0x42 },
+       { 16 * 441.87 /*MHz*/, 0xf4, 0x42 },
+       { 16 * 625.87 /*MHz*/, 0xbc, 0x44 },
+       { 16 * 803.87 /*MHz*/, 0xf4, 0x44 },
+       { 16 * 999.99        , 0xfc, 0x44 },
+};
+
+static struct tuner_params tuner_philips_fmd1216me_mk3_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_fmd1216me_mk3_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_pal_ranges),
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_active = 1,
+               .port2_fm_high_sensitivity = 1,
+               .port2_invert_for_secam_lc = 1,
+               .port1_set_for_fm_mono = 1,
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_philips_fmd1216me_mk3_dvb_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_dvb_ranges),
+               .iffreq = 16 * 36.125, /*MHz*/
+       },
+};
+
+
+/* ------ TUNER_LG_TDVS_H06XF - LG INNOTEK / INFINEON ATSC ----- */
+
+static struct tuner_range tuner_tua6034_ntsc_ranges[] = {
+       { 16 * 165.00 /*MHz*/, 0x8e, 0x01 },
+       { 16 * 450.00 /*MHz*/, 0x8e, 0x02 },
+       { 16 * 999.99        , 0x8e, 0x04 },
+};
+
+static struct tuner_range tuner_tua6034_atsc_ranges[] = {
+       { 16 * 165.00 /*MHz*/, 0xce, 0x01 },
+       { 16 * 450.00 /*MHz*/, 0xce, 0x02 },
+       { 16 * 999.99        , 0xce, 0x04 },
+};
+
+static struct tuner_params tuner_lg_tdvs_h06xf_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_tua6034_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tua6034_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_tua6034_atsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tua6034_atsc_ranges),
+               .iffreq = 16 * 44.00,
+       },
+};
+
+/* ------------ TUNER_YMEC_TVF66T5_B_DFF - Philips PAL ------------ */
+
+static struct tuner_range tuner_ymec_tvf66t5_b_dff_pal_ranges[] = {
+       { 16 * 160.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 464.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_ymec_tvf66t5_b_dff_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_ymec_tvf66t5_b_dff_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_ymec_tvf66t5_b_dff_pal_ranges),
+       },
+};
+
+/* ------------ TUNER_LG_NTSC_TALN_MINI - LGINNOTEK NTSC ------------ */
+
+static struct tuner_range tuner_lg_taln_ntsc_ranges[] = {
+       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 373.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_range tuner_lg_taln_pal_secam_ranges[] = {
+       { 16 * 150.00 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 425.00 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_lg_taln_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_lg_taln_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_taln_ntsc_ranges),
+       },{
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_lg_taln_pal_secam_ranges,
+               .count  = ARRAY_SIZE(tuner_lg_taln_pal_secam_ranges),
+       },
+};
+
+/* ------------ TUNER_PHILIPS_TD1316 - Philips PAL ------------ */
+
+static struct tuner_range tuner_philips_td1316_pal_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0xc8, 0xa1, },
+       { 16 * 442.00 /*MHz*/, 0xc8, 0xa2, },
+       { 16 * 999.99        , 0xc8, 0xa4, },
+};
+
+static struct tuner_range tuner_philips_td1316_dvb_ranges[] = {
+       { 16 *  93.834 /*MHz*/, 0xca, 0x60, },
+       { 16 * 123.834 /*MHz*/, 0xca, 0xa0, },
+       { 16 * 163.834 /*MHz*/, 0xca, 0xc0, },
+       { 16 * 253.834 /*MHz*/, 0xca, 0x60, },
+       { 16 * 383.834 /*MHz*/, 0xca, 0xa0, },
+       { 16 * 443.834 /*MHz*/, 0xca, 0xc0, },
+       { 16 * 583.834 /*MHz*/, 0xca, 0x60, },
+       { 16 * 793.834 /*MHz*/, 0xca, 0xa0, },
+       { 16 * 999.999        , 0xca, 0xe0, },
+};
+
+static struct tuner_params tuner_philips_td1316_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_philips_td1316_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_td1316_pal_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_philips_td1316_dvb_ranges,
+               .count  = ARRAY_SIZE(tuner_philips_td1316_dvb_ranges),
+               .iffreq = 16 * 36.166667 /*MHz*/,
+       },
+};
+
+/* ------------ TUNER_PHILIPS_TUV1236D - Philips ATSC ------------ */
+
+static struct tuner_range tuner_tuv1236d_ntsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0xce, 0x01, },
+       { 16 * 454.00 /*MHz*/, 0xce, 0x02, },
+       { 16 * 999.99        , 0xce, 0x04, },
+};
+
+static struct tuner_range tuner_tuv1236d_atsc_ranges[] = {
+       { 16 * 157.25 /*MHz*/, 0xc6, 0x41, },
+       { 16 * 454.00 /*MHz*/, 0xc6, 0x42, },
+       { 16 * 999.99        , 0xc6, 0x44, },
+};
+
+static struct tuner_params tuner_tuv1236d_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_tuv1236d_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tuv1236d_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_tuv1236d_atsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tuv1236d_atsc_ranges),
+               .iffreq = 16 * 44.00,
+       },
+};
+
+/* ------------ TUNER_TNF_xxx5  - Texas Instruments--------- */
+/* This is known to work with Tenna TVF58t5-MFF and TVF5835 MFF
+ *     but it is expected to work also with other Tenna/Ymec
+ *     models based on TI SN 761677 chip on both PAL and NTSC
+ */
+
+static struct tuner_range tuner_tnf_5335_d_if_pal_ranges[] = {
+       { 16 * 168.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 471.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_range tuner_tnf_5335mf_ntsc_ranges[] = {
+       { 16 * 169.25 /*MHz*/, 0x8e, 0x01, },
+       { 16 * 469.25 /*MHz*/, 0x8e, 0x02, },
+       { 16 * 999.99        , 0x8e, 0x08, },
+};
+
+static struct tuner_params tuner_tnf_5335mf_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_tnf_5335mf_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_tnf_5335mf_ntsc_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_tnf_5335_d_if_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_tnf_5335_d_if_pal_ranges),
+       },
+};
+
+/* 70-79 */
+/* ------------ TUNER_SAMSUNG_TCPN_2121P30A - Samsung NTSC ------------ */
+
+/* '+ 4' turns on the Low Noise Amplifier */
+static struct tuner_range tuner_samsung_tcpn_2121p30a_ntsc_ranges[] = {
+       { 16 * 130.00 /*MHz*/, 0xce, 0x01 + 4, },
+       { 16 * 364.50 /*MHz*/, 0xce, 0x02 + 4, },
+       { 16 * 999.99        , 0xce, 0x08 + 4, },
+};
+
+static struct tuner_params tuner_samsung_tcpn_2121p30a_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_NTSC,
+               .ranges = tuner_samsung_tcpn_2121p30a_ntsc_ranges,
+               .count  = ARRAY_SIZE(tuner_samsung_tcpn_2121p30a_ntsc_ranges),
+       },
+};
+
+/* ------------ TUNER_THOMSON_FE6600 - DViCO Hybrid PAL ------------ */
+
+static struct tuner_range tuner_thomson_fe6600_pal_ranges[] = {
+       { 16 * 160.00 /*MHz*/, 0xfe, 0x11, },
+       { 16 * 442.00 /*MHz*/, 0xf6, 0x12, },
+       { 16 * 999.99        , 0xf6, 0x18, },
+};
+
+static struct tuner_range tuner_thomson_fe6600_dvb_ranges[] = {
+       { 16 * 250.00 /*MHz*/, 0xb4, 0x12, },
+       { 16 * 455.00 /*MHz*/, 0xfe, 0x11, },
+       { 16 * 775.50 /*MHz*/, 0xbc, 0x18, },
+       { 16 * 999.99        , 0xf4, 0x18, },
+};
+
+static struct tuner_params tuner_thomson_fe6600_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_thomson_fe6600_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_fe6600_pal_ranges),
+       },
+       {
+               .type   = TUNER_PARAM_TYPE_DIGITAL,
+               .ranges = tuner_thomson_fe6600_dvb_ranges,
+               .count  = ARRAY_SIZE(tuner_thomson_fe6600_dvb_ranges),
+               .iffreq = 16 * 36.125 /*MHz*/,
+       },
+};
+
+/* ------------ TUNER_SAMSUNG_TCPG_6121P30A - Samsung PAL ------------ */
+
+/* '+ 4' turns on the Low Noise Amplifier */
+static struct tuner_range tuner_samsung_tcpg_6121p30a_pal_ranges[] = {
+       { 16 * 146.25 /*MHz*/, 0xce, 0x01 + 4, },
+       { 16 * 428.50 /*MHz*/, 0xce, 0x02 + 4, },
+       { 16 * 999.99        , 0xce, 0x08 + 4, },
+};
+
+static struct tuner_params tuner_samsung_tcpg_6121p30a_params[] = {
+       {
+               .type   = TUNER_PARAM_TYPE_PAL,
+               .ranges = tuner_samsung_tcpg_6121p30a_pal_ranges,
+               .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_pal_ranges),
+               .has_tda9887 = 1,
+               .port1_active = 1,
+               .port2_active = 1,
+               .port2_invert_for_secam_lc = 1,
+       },
+};
+
+/* --------------------------------------------------------------------- */
+
+struct tunertype tuners[] = {
+       /* 0-9 */
+       [TUNER_TEMIC_PAL] = { /* TEMIC PAL */
+               .name   = "Temic PAL (4002 FH5)",
+               .params = tuner_temic_pal_params,
+               .count  = ARRAY_SIZE(tuner_temic_pal_params),
+       },
+       [TUNER_PHILIPS_PAL_I] = { /* Philips PAL_I */
+               .name   = "Philips PAL_I (FI1246 and compatibles)",
+               .params = tuner_philips_pal_i_params,
+               .count  = ARRAY_SIZE(tuner_philips_pal_i_params),
+       },
+       [TUNER_PHILIPS_NTSC] = { /* Philips NTSC */
+               .name   = "Philips NTSC (FI1236,FM1236 and compatibles)",
+               .params = tuner_philips_ntsc_params,
+               .count  = ARRAY_SIZE(tuner_philips_ntsc_params),
+       },
+       [TUNER_PHILIPS_SECAM] = { /* Philips SECAM */
+               .name   = "Philips (SECAM+PAL_BG) (FI1216MF, FM1216MF, FR1216MF)",
+               .params = tuner_philips_secam_params,
+               .count  = ARRAY_SIZE(tuner_philips_secam_params),
+       },
+       [TUNER_ABSENT] = { /* Tuner Absent */
+               .name   = "NoTuner",
+       },
+       [TUNER_PHILIPS_PAL] = { /* Philips PAL */
+               .name   = "Philips PAL_BG (FI1216 and compatibles)",
+               .params = tuner_philips_pal_params,
+               .count  = ARRAY_SIZE(tuner_philips_pal_params),
+       },
+       [TUNER_TEMIC_NTSC] = { /* TEMIC NTSC */
+               .name   = "Temic NTSC (4032 FY5)",
+               .params = tuner_temic_ntsc_params,
+               .count  = ARRAY_SIZE(tuner_temic_ntsc_params),
+       },
+       [TUNER_TEMIC_PAL_I] = { /* TEMIC PAL_I */
+               .name   = "Temic PAL_I (4062 FY5)",
+               .params = tuner_temic_pal_i_params,
+               .count  = ARRAY_SIZE(tuner_temic_pal_i_params),
+       },
+       [TUNER_TEMIC_4036FY5_NTSC] = { /* TEMIC NTSC */
+               .name   = "Temic NTSC (4036 FY5)",
+               .params = tuner_temic_4036fy5_ntsc_params,
+               .count  = ARRAY_SIZE(tuner_temic_4036fy5_ntsc_params),
+       },
+       [TUNER_ALPS_TSBH1_NTSC] = { /* TEMIC NTSC */
+               .name   = "Alps HSBH1",
+               .params = tuner_alps_tsbh1_ntsc_params,
+               .count  = ARRAY_SIZE(tuner_alps_tsbh1_ntsc_params),
+       },
+
+       /* 10-19 */
+       [TUNER_ALPS_TSBE1_PAL] = { /* TEMIC PAL */
+               .name   = "Alps TSBE1",
+               .params = tuner_alps_tsb_1_params,
+               .count  = ARRAY_SIZE(tuner_alps_tsb_1_params),
+       },
+       [TUNER_ALPS_TSBB5_PAL_I] = { /* Alps PAL_I */
+               .name   = "Alps TSBB5",
+               .params = tuner_alps_tsbb5_params,
+               .count  = ARRAY_SIZE(tuner_alps_tsbb5_params),
+       },
+       [TUNER_ALPS_TSBE5_PAL] = { /* Alps PAL */
+               .name   = "Alps TSBE5",
+               .params = tuner_alps_tsbe5_params,
+               .count  = ARRAY_SIZE(tuner_alps_tsbe5_params),
+       },
+       [TUNER_ALPS_TSBC5_PAL] = { /* Alps PAL */
+               .name   = "Alps TSBC5",
+               .params = tuner_alps_tsbc5_params,
+               .count  = ARRAY_SIZE(tuner_alps_tsbc5_params),
+       },
+       [TUNER_TEMIC_4006FH5_PAL] = { /* TEMIC PAL */
+               .name   = "Temic PAL_BG (4006FH5)",
+               .params = tuner_temic_4006fh5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4006fh5_params),
+       },
+       [TUNER_ALPS_TSHC6_NTSC] = { /* Alps NTSC */
+               .name   = "Alps TSCH6",
+               .params = tuner_alps_tshc6_params,
+               .count  = ARRAY_SIZE(tuner_alps_tshc6_params),
+       },
+       [TUNER_TEMIC_PAL_DK] = { /* TEMIC PAL */
+               .name   = "Temic PAL_DK (4016 FY5)",
+               .params = tuner_temic_pal_dk_params,
+               .count  = ARRAY_SIZE(tuner_temic_pal_dk_params),
+       },
+       [TUNER_PHILIPS_NTSC_M] = { /* Philips NTSC */
+               .name   = "Philips NTSC_M (MK2)",
+               .params = tuner_philips_ntsc_m_params,
+               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_params),
+       },
+       [TUNER_TEMIC_4066FY5_PAL_I] = { /* TEMIC PAL_I */
+               .name   = "Temic PAL_I (4066 FY5)",
+               .params = tuner_temic_4066fy5_pal_i_params,
+               .count  = ARRAY_SIZE(tuner_temic_4066fy5_pal_i_params),
+       },
+       [TUNER_TEMIC_4006FN5_MULTI_PAL] = { /* TEMIC PAL */
+               .name   = "Temic PAL* auto (4006 FN5)",
+               .params = tuner_temic_4006fn5_multi_params,
+               .count  = ARRAY_SIZE(tuner_temic_4006fn5_multi_params),
+       },
+
+       /* 20-29 */
+       [TUNER_TEMIC_4009FR5_PAL] = { /* TEMIC PAL */
+               .name   = "Temic PAL_BG (4009 FR5) or PAL_I (4069 FR5)",
+               .params = tuner_temic_4009f_5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4009f_5_params),
+       },
+       [TUNER_TEMIC_4039FR5_NTSC] = { /* TEMIC NTSC */
+               .name   = "Temic NTSC (4039 FR5)",
+               .params = tuner_temic_4039fr5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4039fr5_params),
+       },
+       [TUNER_TEMIC_4046FM5] = { /* TEMIC PAL */
+               .name   = "Temic PAL/SECAM multi (4046 FM5)",
+               .params = tuner_temic_4046fm5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4046fm5_params),
+       },
+       [TUNER_PHILIPS_PAL_DK] = { /* Philips PAL */
+               .name   = "Philips PAL_DK (FI1256 and compatibles)",
+               .params = tuner_philips_pal_dk_params,
+               .count  = ARRAY_SIZE(tuner_philips_pal_dk_params),
+       },
+       [TUNER_PHILIPS_FQ1216ME] = { /* Philips PAL */
+               .name   = "Philips PAL/SECAM multi (FQ1216ME)",
+               .params = tuner_philips_fq1216me_params,
+               .count  = ARRAY_SIZE(tuner_philips_fq1216me_params),
+       },
+       [TUNER_LG_PAL_I_FM] = { /* LGINNOTEK PAL_I */
+               .name   = "LG PAL_I+FM (TAPC-I001D)",
+               .params = tuner_lg_pal_i_fm_params,
+               .count  = ARRAY_SIZE(tuner_lg_pal_i_fm_params),
+       },
+       [TUNER_LG_PAL_I] = { /* LGINNOTEK PAL_I */
+               .name   = "LG PAL_I (TAPC-I701D)",
+               .params = tuner_lg_pal_i_params,
+               .count  = ARRAY_SIZE(tuner_lg_pal_i_params),
+       },
+       [TUNER_LG_NTSC_FM] = { /* LGINNOTEK NTSC */
+               .name   = "LG NTSC+FM (TPI8NSR01F)",
+               .params = tuner_lg_ntsc_fm_params,
+               .count  = ARRAY_SIZE(tuner_lg_ntsc_fm_params),
+       },
+       [TUNER_LG_PAL_FM] = { /* LGINNOTEK PAL */
+               .name   = "LG PAL_BG+FM (TPI8PSB01D)",
+               .params = tuner_lg_pal_fm_params,
+               .count  = ARRAY_SIZE(tuner_lg_pal_fm_params),
+       },
+       [TUNER_LG_PAL] = { /* LGINNOTEK PAL */
+               .name   = "LG PAL_BG (TPI8PSB11D)",
+               .params = tuner_lg_pal_params,
+               .count  = ARRAY_SIZE(tuner_lg_pal_params),
+       },
+
+       /* 30-39 */
+       [TUNER_TEMIC_4009FN5_MULTI_PAL_FM] = { /* TEMIC PAL */
+               .name   = "Temic PAL* auto + FM (4009 FN5)",
+               .params = tuner_temic_4009_fn5_multi_pal_fm_params,
+               .count  = ARRAY_SIZE(tuner_temic_4009_fn5_multi_pal_fm_params),
+       },
+       [TUNER_SHARP_2U5JF5540_NTSC] = { /* SHARP NTSC */
+               .name   = "SHARP NTSC_JP (2U5JF5540)",
+               .params = tuner_sharp_2u5jf5540_params,
+               .count  = ARRAY_SIZE(tuner_sharp_2u5jf5540_params),
+       },
+       [TUNER_Samsung_PAL_TCPM9091PD27] = { /* Samsung PAL */
+               .name   = "Samsung PAL TCPM9091PD27",
+               .params = tuner_samsung_pal_tcpm9091pd27_params,
+               .count  = ARRAY_SIZE(tuner_samsung_pal_tcpm9091pd27_params),
+       },
+       [TUNER_MT2032] = { /* Microtune PAL|NTSC */
+               .name   = "MT20xx universal",
+               /* see mt20xx.c for details */ },
+       [TUNER_TEMIC_4106FH5] = { /* TEMIC PAL */
+               .name   = "Temic PAL_BG (4106 FH5)",
+               .params = tuner_temic_4106fh5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4106fh5_params),
+       },
+       [TUNER_TEMIC_4012FY5] = { /* TEMIC PAL */
+               .name   = "Temic PAL_DK/SECAM_L (4012 FY5)",
+               .params = tuner_temic_4012fy5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4012fy5_params),
+       },
+       [TUNER_TEMIC_4136FY5] = { /* TEMIC NTSC */
+               .name   = "Temic NTSC (4136 FY5)",
+               .params = tuner_temic_4136_fy5_params,
+               .count  = ARRAY_SIZE(tuner_temic_4136_fy5_params),
+       },
+       [TUNER_LG_PAL_NEW_TAPC] = { /* LGINNOTEK PAL */
+               .name   = "LG PAL (newer TAPC series)",
+               .params = tuner_lg_pal_new_tapc_params,
+               .count  = ARRAY_SIZE(tuner_lg_pal_new_tapc_params),
+       },
+       [TUNER_PHILIPS_FM1216ME_MK3] = { /* Philips PAL */
+               .name   = "Philips PAL/SECAM multi (FM1216ME MK3)",
+               .params = tuner_fm1216me_mk3_params,
+               .count  = ARRAY_SIZE(tuner_fm1216me_mk3_params),
+       },
+       [TUNER_LG_NTSC_NEW_TAPC] = { /* LGINNOTEK NTSC */
+               .name   = "LG NTSC (newer TAPC series)",
+               .params = tuner_lg_ntsc_new_tapc_params,
+               .count  = ARRAY_SIZE(tuner_lg_ntsc_new_tapc_params),
+       },
+
+       /* 40-49 */
+       [TUNER_HITACHI_NTSC] = { /* HITACHI NTSC */
+               .name   = "HITACHI V7-J180AT",
+               .params = tuner_hitachi_ntsc_params,
+               .count  = ARRAY_SIZE(tuner_hitachi_ntsc_params),
+       },
+       [TUNER_PHILIPS_PAL_MK] = { /* Philips PAL */
+               .name   = "Philips PAL_MK (FI1216 MK)",
+               .params = tuner_philips_pal_mk_params,
+               .count  = ARRAY_SIZE(tuner_philips_pal_mk_params),
+       },
+       [TUNER_PHILIPS_FCV1236D] = { /* Philips ATSC */
+               .name   = "Philips FCV1236D ATSC/NTSC dual in",
+               .params = tuner_philips_fcv1236d_params,
+               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_params),
+               .min = 16 *  53.00,
+               .max = 16 * 803.00,
+               .stepsize = 62500,
+       },
+       [TUNER_PHILIPS_FM1236_MK3] = { /* Philips NTSC */
+               .name   = "Philips NTSC MK3 (FM1236MK3 or FM1236/F)",
+               .params = tuner_fm1236_mk3_params,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_params),
+       },
+       [TUNER_PHILIPS_4IN1] = { /* Philips NTSC */
+               .name   = "Philips 4 in 1 (ATI TV Wonder Pro/Conexant)",
+               .params = tuner_philips_4in1_params,
+               .count  = ARRAY_SIZE(tuner_philips_4in1_params),
+       },
+       [TUNER_MICROTUNE_4049FM5] = { /* Microtune PAL */
+               .name   = "Microtune 4049 FM5",
+               .params = tuner_microtune_4049_fm5_params,
+               .count  = ARRAY_SIZE(tuner_microtune_4049_fm5_params),
+       },
+       [TUNER_PANASONIC_VP27] = { /* Panasonic NTSC */
+               .name   = "Panasonic VP27s/ENGE4324D",
+               .params = tuner_panasonic_vp27_params,
+               .count  = ARRAY_SIZE(tuner_panasonic_vp27_params),
+       },
+       [TUNER_LG_NTSC_TAPE] = { /* LGINNOTEK NTSC */
+               .name   = "LG NTSC (TAPE series)",
+               .params = tuner_fm1236_mk3_params,
+               .count  = ARRAY_SIZE(tuner_fm1236_mk3_params),
+       },
+       [TUNER_TNF_8831BGFF] = { /* Philips PAL */
+               .name   = "Tenna TNF 8831 BGFF)",
+               .params = tuner_tnf_8831bgff_params,
+               .count  = ARRAY_SIZE(tuner_tnf_8831bgff_params),
+       },
+       [TUNER_MICROTUNE_4042FI5] = { /* Microtune NTSC */
+               .name   = "Microtune 4042 FI5 ATSC/NTSC dual in",
+               .params = tuner_microtune_4042fi5_params,
+               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_params),
+               .min    = 16 *  57.00,
+               .max    = 16 * 858.00,
+               .stepsize = 62500,
+       },
+
+       /* 50-59 */
+       [TUNER_TCL_2002N] = { /* TCL NTSC */
+               .name   = "TCL 2002N",
+               .params = tuner_tcl_2002n_params,
+               .count  = ARRAY_SIZE(tuner_tcl_2002n_params),
+       },
+       [TUNER_PHILIPS_FM1256_IH3] = { /* Philips PAL */
+               .name   = "Philips PAL/SECAM_D (FM 1256 I-H3)",
+               .params = tuner_philips_fm1256_ih3_params,
+               .count  = ARRAY_SIZE(tuner_philips_fm1256_ih3_params),
+       },
+       [TUNER_THOMSON_DTT7610] = { /* THOMSON ATSC */
+               .name   = "Thomson DTT 7610 (ATSC/NTSC)",
+               .params = tuner_thomson_dtt7610_params,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_params),
+               .min    = 16 *  44.00,
+               .max    = 16 * 958.00,
+               .stepsize = 62500,
+       },
+       [TUNER_PHILIPS_FQ1286] = { /* Philips NTSC */
+               .name   = "Philips FQ1286",
+               .params = tuner_philips_fq1286_params,
+               .count  = ARRAY_SIZE(tuner_philips_fq1286_params),
+       },
+       [TUNER_PHILIPS_TDA8290] = { /* Philips PAL|NTSC */
+               .name   = "Philips/NXP TDA 8290/8295 + 8275/8275A/18271",
+               /* see tda8290.c for details */ },
+       [TUNER_TCL_2002MB] = { /* TCL PAL */
+               .name   = "TCL 2002MB",
+               .params = tuner_tcl_2002mb_params,
+               .count  = ARRAY_SIZE(tuner_tcl_2002mb_params),
+       },
+       [TUNER_PHILIPS_FQ1216AME_MK4] = { /* Philips PAL */
+               .name   = "Philips PAL/SECAM multi (FQ1216AME MK4)",
+               .params = tuner_philips_fq1216ame_mk4_params,
+               .count  = ARRAY_SIZE(tuner_philips_fq1216ame_mk4_params),
+       },
+       [TUNER_PHILIPS_FQ1236A_MK4] = { /* Philips NTSC */
+               .name   = "Philips FQ1236A MK4",
+               .params = tuner_philips_fq1236a_mk4_params,
+               .count  = ARRAY_SIZE(tuner_philips_fq1236a_mk4_params),
+       },
+       [TUNER_YMEC_TVF_8531MF] = { /* Philips NTSC */
+               .name   = "Ymec TVision TVF-8531MF/8831MF/8731MF",
+               .params = tuner_ymec_tvf_8531mf_params,
+               .count  = ARRAY_SIZE(tuner_ymec_tvf_8531mf_params),
+       },
+       [TUNER_YMEC_TVF_5533MF] = { /* Philips NTSC */
+               .name   = "Ymec TVision TVF-5533MF",
+               .params = tuner_ymec_tvf_5533mf_params,
+               .count  = ARRAY_SIZE(tuner_ymec_tvf_5533mf_params),
+       },
+
+       /* 60-69 */
+       [TUNER_THOMSON_DTT761X] = { /* THOMSON ATSC */
+               /* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
+               .name   = "Thomson DTT 761X (ATSC/NTSC)",
+               .params = tuner_thomson_dtt761x_params,
+               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_params),
+               .min    = 16 *  57.00,
+               .max    = 16 * 863.00,
+               .stepsize = 62500,
+               .initdata = tua603x_agc103,
+       },
+       [TUNER_TENA_9533_DI] = { /* Philips PAL */
+               .name   = "Tena TNF9533-D/IF/TNF9533-B/DF",
+               .params = tuner_tena_9533_di_params,
+               .count  = ARRAY_SIZE(tuner_tena_9533_di_params),
+       },
+       [TUNER_TEA5767] = { /* Philips RADIO */
+               .name   = "Philips TEA5767HN FM Radio",
+               /* see tea5767.c for details */
+       },
+       [TUNER_PHILIPS_FMD1216ME_MK3] = { /* Philips PAL */
+               .name   = "Philips FMD1216ME MK3 Hybrid Tuner",
+               .params = tuner_philips_fmd1216me_mk3_params,
+               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_params),
+               .min = 16 *  50.87,
+               .max = 16 * 858.00,
+               .stepsize = 166667,
+               .initdata = tua603x_agc112,
+               .sleepdata = (u8[]){ 4, 0x9c, 0x60, 0x85, 0x54 },
+       },
+       [TUNER_LG_TDVS_H06XF] = { /* LGINNOTEK ATSC */
+               .name   = "LG TDVS-H06xF", /* H061F, H062F & H064F */
+               .params = tuner_lg_tdvs_h06xf_params,
+               .count  = ARRAY_SIZE(tuner_lg_tdvs_h06xf_params),
+               .min    = 16 *  54.00,
+               .max    = 16 * 863.00,
+               .stepsize = 62500,
+               .initdata = tua603x_agc103,
+       },
+       [TUNER_YMEC_TVF66T5_B_DFF] = { /* Philips PAL */
+               .name   = "Ymec TVF66T5-B/DFF",
+               .params = tuner_ymec_tvf66t5_b_dff_params,
+               .count  = ARRAY_SIZE(tuner_ymec_tvf66t5_b_dff_params),
+       },
+       [TUNER_LG_TALN] = { /* LGINNOTEK NTSC / PAL / SECAM */
+               .name   = "LG TALN series",
+               .params = tuner_lg_taln_params,
+               .count  = ARRAY_SIZE(tuner_lg_taln_params),
+       },
+       [TUNER_PHILIPS_TD1316] = { /* Philips PAL */
+               .name   = "Philips TD1316 Hybrid Tuner",
+               .params = tuner_philips_td1316_params,
+               .count  = ARRAY_SIZE(tuner_philips_td1316_params),
+               .min    = 16 *  87.00,
+               .max    = 16 * 895.00,
+               .stepsize = 166667,
+       },
+       [TUNER_PHILIPS_TUV1236D] = { /* Philips ATSC */
+               .name   = "Philips TUV1236D ATSC/NTSC dual in",
+               .params = tuner_tuv1236d_params,
+               .count  = ARRAY_SIZE(tuner_tuv1236d_params),
+               .min    = 16 *  54.00,
+               .max    = 16 * 864.00,
+               .stepsize = 62500,
+       },
+       [TUNER_TNF_5335MF] = { /* Tenna PAL/NTSC */
+               .name   = "Tena TNF 5335 and similar models",
+               .params = tuner_tnf_5335mf_params,
+               .count  = ARRAY_SIZE(tuner_tnf_5335mf_params),
+       },
+
+       /* 70-79 */
+       [TUNER_SAMSUNG_TCPN_2121P30A] = { /* Samsung NTSC */
+               .name   = "Samsung TCPN 2121P30A",
+               .params = tuner_samsung_tcpn_2121p30a_params,
+               .count  = ARRAY_SIZE(tuner_samsung_tcpn_2121p30a_params),
+       },
+       [TUNER_XC2028] = { /* Xceive 2028 */
+               .name   = "Xceive xc2028/xc3028 tuner",
+               /* see tuner-xc2028.c for details */
+       },
+       [TUNER_THOMSON_FE6600] = { /* Thomson PAL / DVB-T */
+               .name   = "Thomson FE6600",
+               .params = tuner_thomson_fe6600_params,
+               .count  = ARRAY_SIZE(tuner_thomson_fe6600_params),
+               .min    = 16 *  44.25,
+               .max    = 16 * 858.00,
+               .stepsize = 166667,
+       },
+       [TUNER_SAMSUNG_TCPG_6121P30A] = { /* Samsung PAL */
+               .name   = "Samsung TCPG 6121P30A",
+               .params = tuner_samsung_tcpg_6121p30a_params,
+               .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_params),
+       },
+       [TUNER_TDA9887] = { /* Philips TDA 9887 IF PLL Demodulator.
+                               This chip is part of some modern tuners */
+               .name   = "Philips TDA988[5,6,7] IF PLL Demodulator",
+               /* see tda9887.c for details */
+       },
+       [TUNER_TEA5761] = { /* Philips RADIO */
+               .name   = "Philips TEA5761 FM Radio",
+               /* see tea5767.c for details */
+       },
+       [TUNER_XC5000] = { /* Xceive 5000 */
+               .name   = "Xceive 5000 tuner",
+               /* see xc5000.c for details */
+       },
+};
+EXPORT_SYMBOL(tuners);
+
+unsigned const int tuner_count = ARRAY_SIZE(tuners);
+EXPORT_SYMBOL(tuner_count);
+
+MODULE_DESCRIPTION("Simple tuner device type database");
+MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/common/tuners/tuner-xc2028-types.h b/drivers/media/common/tuners/tuner-xc2028-types.h
new file mode 100644 (file)
index 0000000..74dc46a
--- /dev/null
@@ -0,0 +1,141 @@
+/* tuner-xc2028_types
+ *
+ * This file includes internal tipes to be used inside tuner-xc2028.
+ * Shouldn't be included outside tuner-xc2028
+ *
+ * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
+ * This code is placed under the terms of the GNU General Public License v2
+ */
+
+/* xc3028 firmware types */
+
+/* BASE firmware should be loaded before any other firmware */
+#define BASE           (1<<0)
+#define BASE_TYPES     (BASE|F8MHZ|MTS|FM|INPUT1|INPUT2|INIT1)
+
+/* F8MHZ marks BASE firmwares for 8 MHz Bandwidth */
+#define F8MHZ          (1<<1)
+
+/* Multichannel Television Sound (MTS)
+   Those firmwares are capable of using xc2038 DSP to decode audio and
+   produce a baseband audio output on some pins of the chip.
+   There are MTS firmwares for the most used video standards. It should be
+   required to use MTS firmwares, depending on the way audio is routed into
+   the bridge chip
+ */
+#define MTS            (1<<2)
+
+/* FIXME: I have no idea what's the difference between
+   D2620 and D2633 firmwares
+ */
+#define D2620          (1<<3)
+#define D2633          (1<<4)
+
+/* DTV firmwares for 6, 7 and 8 MHz
+   DTV6 - 6MHz - ATSC/DVB-C/DVB-T/ISDB-T/DOCSIS
+   DTV8 - 8MHz - DVB-C/DVB-T
+ */
+#define DTV6           (1 << 5)
+#define QAM            (1 << 6)
+#define DTV7           (1<<7)
+#define DTV78          (1<<8)
+#define DTV8           (1<<9)
+
+#define DTV_TYPES      (D2620|D2633|DTV6|QAM|DTV7|DTV78|DTV8|ATSC)
+
+/* There's a FM | BASE firmware + FM specific firmware (std=0) */
+#define        FM              (1<<10)
+
+#define STD_SPECIFIC_TYPES (MTS|FM|LCD|NOGD)
+
+/* Applies only for FM firmware
+   Makes it use RF input 1 (pin #2) instead of input 2 (pin #4)
+ */
+#define INPUT1         (1<<11)
+
+
+/* LCD firmwares exist only for MTS STD/MN (PAL or NTSC/M)
+       and for non-MTS STD/MN (PAL, NTSC/M or NTSC/Kr)
+       There are variants both with and without NOGD
+       Those firmwares produce better result with LCD displays
+ */
+#define LCD            (1<<12)
+
+/* NOGD firmwares exist only for MTS STD/MN (PAL or NTSC/M)
+       and for non-MTS STD/MN (PAL, NTSC/M or NTSC/Kr)
+       The NOGD firmwares don't have group delay compensation filter
+ */
+#define NOGD           (1<<13)
+
+/* Old firmwares were broken into init0 and init1 */
+#define INIT1          (1<<14)
+
+/* SCODE firmware selects particular behaviours */
+#define MONO           (1 << 15)
+#define ATSC           (1 << 16)
+#define IF             (1 << 17)
+#define LG60           (1 << 18)
+#define ATI638         (1 << 19)
+#define OREN538        (1 << 20)
+#define OREN36         (1 << 21)
+#define TOYOTA388      (1 << 22)
+#define TOYOTA794      (1 << 23)
+#define DIBCOM52       (1 << 24)
+#define ZARLINK456     (1 << 25)
+#define CHINA          (1 << 26)
+#define F6MHZ          (1 << 27)
+#define INPUT2         (1 << 28)
+#define SCODE          (1 << 29)
+
+/* This flag identifies that the scode table has a new format */
+#define HAS_IF         (1 << 30)
+
+/* There are different scode tables for MTS and non-MTS.
+   The MTS firmwares support mono only
+  */
+#define SCODE_TYPES (SCODE | MTS)
+
+
+/* Newer types not defined on videodev2.h.
+   The original idea were to move all those types to videodev2.h, but
+   it seemed overkill, since, with the exception of SECAM/K3, the other
+   types seem to be autodetected.
+   It is not clear where secam/k3 is used, nor we have a feedback of this
+   working or being autodetected by the standard secam firmware.
+ */
+
+#define V4L2_STD_SECAM_K3      (0x04000000)
+
+/* Audio types */
+
+#define V4L2_STD_A2_A          (1LL<<32)
+#define V4L2_STD_A2_B          (1LL<<33)
+#define V4L2_STD_NICAM_A       (1LL<<34)
+#define V4L2_STD_NICAM_B       (1LL<<35)
+#define V4L2_STD_AM            (1LL<<36)
+#define V4L2_STD_BTSC          (1LL<<37)
+#define V4L2_STD_EIAJ          (1LL<<38)
+
+#define V4L2_STD_A2            (V4L2_STD_A2_A    | V4L2_STD_A2_B)
+#define V4L2_STD_NICAM         (V4L2_STD_NICAM_A | V4L2_STD_NICAM_B)
+
+/* To preserve backward compatibilty,
+   (std & V4L2_STD_AUDIO) = 0 means that ALL audio stds are supported
+ */
+
+#define V4L2_STD_AUDIO         (V4L2_STD_A2    | \
+                                V4L2_STD_NICAM | \
+                                V4L2_STD_AM    | \
+                                V4L2_STD_BTSC  | \
+                                V4L2_STD_EIAJ)
+
+/* Used standards with audio restrictions */
+
+#define V4L2_STD_PAL_BG_A2_A   (V4L2_STD_PAL_BG | V4L2_STD_A2_A)
+#define V4L2_STD_PAL_BG_A2_B   (V4L2_STD_PAL_BG | V4L2_STD_A2_B)
+#define V4L2_STD_PAL_BG_NICAM_A        (V4L2_STD_PAL_BG | V4L2_STD_NICAM_A)
+#define V4L2_STD_PAL_BG_NICAM_B        (V4L2_STD_PAL_BG | V4L2_STD_NICAM_B)
+#define V4L2_STD_PAL_DK_A2     (V4L2_STD_PAL_DK | V4L2_STD_A2)
+#define V4L2_STD_PAL_DK_NICAM  (V4L2_STD_PAL_DK | V4L2_STD_NICAM)
+#define V4L2_STD_SECAM_L_NICAM (V4L2_STD_SECAM_L | V4L2_STD_NICAM)
+#define V4L2_STD_SECAM_L_AM    (V4L2_STD_SECAM_L | V4L2_STD_AM)
diff --git a/drivers/media/common/tuners/tuner-xc2028.c b/drivers/media/common/tuners/tuner-xc2028.c
new file mode 100644 (file)
index 0000000..9e9003c
--- /dev/null
@@ -0,0 +1,1227 @@
+/* tuner-xc2028
+ *
+ * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
+ *
+ * Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)
+ *       - frontend interface
+ *
+ * This code is placed under the terms of the GNU General Public License v2
+ */
+
+#include <linux/i2c.h>
+#include <asm/div64.h>
+#include <linux/firmware.h>
+#include <linux/videodev2.h>
+#include <linux/delay.h>
+#include <media/tuner.h>
+#include <linux/mutex.h>
+#include "tuner-i2c.h"
+#include "tuner-xc2028.h"
+#include "tuner-xc2028-types.h"
+
+#include <linux/dvb/frontend.h>
+#include "dvb_frontend.h"
+
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable verbose debug messages");
+
+static char audio_std[8];
+module_param_string(audio_std, audio_std, sizeof(audio_std), 0);
+MODULE_PARM_DESC(audio_std,
+       "Audio standard. XC3028 audio decoder explicitly "
+       "needs to know what audio\n"
+       "standard is needed for some video standards with audio A2 or NICAM.\n"
+       "The valid values are:\n"
+       "A2\n"
+       "A2/A\n"
+       "A2/B\n"
+       "NICAM\n"
+       "NICAM/A\n"
+       "NICAM/B\n");
+
+static char firmware_name[FIRMWARE_NAME_MAX];
+module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
+MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
+                               "default firmware name\n");
+
+static LIST_HEAD(xc2028_list);
+static DEFINE_MUTEX(xc2028_list_mutex);
+
+/* struct for storing firmware table */
+struct firmware_description {
+       unsigned int  type;
+       v4l2_std_id   id;
+       __u16         int_freq;
+       unsigned char *ptr;
+       unsigned int  size;
+};
+
+struct firmware_properties {
+       unsigned int    type;
+       v4l2_std_id     id;
+       v4l2_std_id     std_req;
+       __u16           int_freq;
+       unsigned int    scode_table;
+       int             scode_nr;
+};
+
+struct xc2028_data {
+       struct list_head        xc2028_list;
+       struct tuner_i2c_props  i2c_props;
+       int                     (*tuner_callback) (void *dev,
+                                                  int command, int arg);
+       void                    *video_dev;
+       int                     count;
+       __u32                   frequency;
+
+       struct firmware_description *firm;
+       int                     firm_size;
+       __u16                   firm_version;
+
+       __u16                   hwmodel;
+       __u16                   hwvers;
+
+       struct xc2028_ctrl      ctrl;
+
+       struct firmware_properties cur_fw;
+
+       struct mutex lock;
+};
+
+#define i2c_send(priv, buf, size) ({                                   \
+       int _rc;                                                        \
+       _rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);         \
+       if (size != _rc)                                                \
+               tuner_info("i2c output error: rc = %d (should be %d)\n",\
+                          _rc, (int)size);                             \
+       _rc;                                                            \
+})
+
+#define i2c_rcv(priv, buf, size) ({                                    \
+       int _rc;                                                        \
+       _rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size);         \
+       if (size != _rc)                                                \
+               tuner_err("i2c input error: rc = %d (should be %d)\n",  \
+                          _rc, (int)size);                             \
+       _rc;                                                            \
+})
+
+#define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({               \
+       int _rc;                                                        \
+       _rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize,   \
+                                      ibuf, isize);                    \
+       if (isize != _rc)                                               \
+               tuner_err("i2c input error: rc = %d (should be %d)\n",  \
+                          _rc, (int)isize);                            \
+       _rc;                                                            \
+})
+
+#define send_seq(priv, data...)        ({                                      \
+       static u8 _val[] = data;                                        \
+       int _rc;                                                        \
+       if (sizeof(_val) !=                                             \
+                       (_rc = tuner_i2c_xfer_send(&priv->i2c_props,    \
+                                               _val, sizeof(_val)))) { \
+               tuner_err("Error on line %d: %d\n", __LINE__, _rc);     \
+       } else                                                          \
+               msleep(10);                                             \
+       _rc;                                                            \
+})
+
+static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val)
+{
+       unsigned char buf[2];
+       unsigned char ibuf[2];
+
+       tuner_dbg("%s %04x called\n", __func__, reg);
+
+       buf[0] = reg >> 8;
+       buf[1] = (unsigned char) reg;
+
+       if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2)
+               return -EIO;
+
+       *val = (ibuf[1]) | (ibuf[0] << 8);
+       return 0;
+}
+
+#define dump_firm_type(t)      dump_firm_type_and_int_freq(t, 0)
+static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
+{
+        if (type & BASE)
+               printk("BASE ");
+        if (type & INIT1)
+               printk("INIT1 ");
+        if (type & F8MHZ)
+               printk("F8MHZ ");
+        if (type & MTS)
+               printk("MTS ");
+        if (type & D2620)
+               printk("D2620 ");
+        if (type & D2633)
+               printk("D2633 ");
+        if (type & DTV6)
+               printk("DTV6 ");
+        if (type & QAM)
+               printk("QAM ");
+        if (type & DTV7)
+               printk("DTV7 ");
+        if (type & DTV78)
+               printk("DTV78 ");
+        if (type & DTV8)
+               printk("DTV8 ");
+        if (type & FM)
+               printk("FM ");
+        if (type & INPUT1)
+               printk("INPUT1 ");
+        if (type & LCD)
+               printk("LCD ");
+        if (type & NOGD)
+               printk("NOGD ");
+        if (type & MONO)
+               printk("MONO ");
+        if (type & ATSC)
+               printk("ATSC ");
+        if (type & IF)
+               printk("IF ");
+        if (type & LG60)
+               printk("LG60 ");
+        if (type & ATI638)
+               printk("ATI638 ");
+        if (type & OREN538)
+               printk("OREN538 ");
+        if (type & OREN36)
+               printk("OREN36 ");
+        if (type & TOYOTA388)
+               printk("TOYOTA388 ");
+        if (type & TOYOTA794)
+               printk("TOYOTA794 ");
+        if (type & DIBCOM52)
+               printk("DIBCOM52 ");
+        if (type & ZARLINK456)
+               printk("ZARLINK456 ");
+        if (type & CHINA)
+               printk("CHINA ");
+        if (type & F6MHZ)
+               printk("F6MHZ ");
+        if (type & INPUT2)
+               printk("INPUT2 ");
+        if (type & SCODE)
+               printk("SCODE ");
+        if (type & HAS_IF)
+               printk("HAS_IF_%d ", int_freq);
+}
+
+static  v4l2_std_id parse_audio_std_option(void)
+{
+       if (strcasecmp(audio_std, "A2") == 0)
+               return V4L2_STD_A2;
+       if (strcasecmp(audio_std, "A2/A") == 0)
+               return V4L2_STD_A2_A;
+       if (strcasecmp(audio_std, "A2/B") == 0)
+               return V4L2_STD_A2_B;
+       if (strcasecmp(audio_std, "NICAM") == 0)
+               return V4L2_STD_NICAM;
+       if (strcasecmp(audio_std, "NICAM/A") == 0)
+               return V4L2_STD_NICAM_A;
+       if (strcasecmp(audio_std, "NICAM/B") == 0)
+               return V4L2_STD_NICAM_B;
+
+       return 0;
+}
+
+static void free_firmware(struct xc2028_data *priv)
+{
+       int i;
+       tuner_dbg("%s called\n", __func__);
+
+       if (!priv->firm)
+               return;
+
+       for (i = 0; i < priv->firm_size; i++)
+               kfree(priv->firm[i].ptr);
+
+       kfree(priv->firm);
+
+       priv->firm = NULL;
+       priv->firm_size = 0;
+
+       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
+}
+
+static int load_all_firmwares(struct dvb_frontend *fe)
+{
+       struct xc2028_data    *priv = fe->tuner_priv;
+       const struct firmware *fw   = NULL;
+       unsigned char         *p, *endp;
+       int                   rc = 0;
+       int                   n, n_array;
+       char                  name[33];
+       char                  *fname;
+
+       tuner_dbg("%s called\n", __func__);
+
+       if (!firmware_name[0])
+               fname = priv->ctrl.fname;
+       else
+               fname = firmware_name;
+
+       tuner_dbg("Reading firmware %s\n", fname);
+       rc = request_firmware(&fw, fname, &priv->i2c_props.adap->dev);
+       if (rc < 0) {
+               if (rc == -ENOENT)
+                       tuner_err("Error: firmware %s not found.\n",
+                                  fname);
+               else
+                       tuner_err("Error %d while requesting firmware %s \n",
+                                  rc, fname);
+
+               return rc;
+       }
+       p = fw->data;
+       endp = p + fw->size;
+
+       if (fw->size < sizeof(name) - 1 + 2 + 2) {
+               tuner_err("Error: firmware file %s has invalid size!\n",
+                         fname);
+               goto corrupt;
+       }
+
+       memcpy(name, p, sizeof(name) - 1);
+       name[sizeof(name) - 1] = 0;
+       p += sizeof(name) - 1;
+
+       priv->firm_version = le16_to_cpu(*(__u16 *) p);
+       p += 2;
+
+       n_array = le16_to_cpu(*(__u16 *) p);
+       p += 2;
+
+       tuner_info("Loading %d firmware images from %s, type: %s, ver %d.%d\n",
+                  n_array, fname, name,
+                  priv->firm_version >> 8, priv->firm_version & 0xff);
+
+       priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
+       if (priv->firm == NULL) {
+               tuner_err("Not enough memory to load firmware file.\n");
+               rc = -ENOMEM;
+               goto err;
+       }
+       priv->firm_size = n_array;
+
+       n = -1;
+       while (p < endp) {
+               __u32 type, size;
+               v4l2_std_id id;
+               __u16 int_freq = 0;
+
+               n++;
+               if (n >= n_array) {
+                       tuner_err("More firmware images in file than "
+                                 "were expected!\n");
+                       goto corrupt;
+               }
+
+               /* Checks if there's enough bytes to read */
+               if (p + sizeof(type) + sizeof(id) + sizeof(size) > endp) {
+                       tuner_err("Firmware header is incomplete!\n");
+                       goto corrupt;
+               }
+
+               type = le32_to_cpu(*(__u32 *) p);
+               p += sizeof(type);
+
+               id = le64_to_cpu(*(v4l2_std_id *) p);
+               p += sizeof(id);
+
+               if (type & HAS_IF) {
+                       int_freq = le16_to_cpu(*(__u16 *) p);
+                       p += sizeof(int_freq);
+               }
+
+               size = le32_to_cpu(*(__u32 *) p);
+               p += sizeof(size);
+
+               if ((!size) || (size + p > endp)) {
+                       tuner_err("Firmware type ");
+                       dump_firm_type(type);
+                       printk("(%x), id %llx is corrupted "
+                              "(size=%d, expected %d)\n",
+                              type, (unsigned long long)id,
+                              (unsigned)(endp - p), size);
+                       goto corrupt;
+               }
+
+               priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
+               if (priv->firm[n].ptr == NULL) {
+                       tuner_err("Not enough memory to load firmware file.\n");
+                       rc = -ENOMEM;
+                       goto err;
+               }
+               tuner_dbg("Reading firmware type ");
+               if (debug) {
+                       dump_firm_type_and_int_freq(type, int_freq);
+                       printk("(%x), id %llx, size=%d.\n",
+                              type, (unsigned long long)id, size);
+               }
+
+               memcpy(priv->firm[n].ptr, p, size);
+               priv->firm[n].type = type;
+               priv->firm[n].id   = id;
+               priv->firm[n].size = size;
+               priv->firm[n].int_freq = int_freq;
+
+               p += size;
+       }
+
+       if (n + 1 != priv->firm_size) {
+               tuner_err("Firmware file is incomplete!\n");
+               goto corrupt;
+       }
+
+       goto done;
+
+corrupt:
+       rc = -EINVAL;
+       tuner_err("Error: firmware file is corrupted!\n");
+
+err:
+       tuner_info("Releasing partially loaded firmware file.\n");
+       free_firmware(priv);
+
+done:
+       release_firmware(fw);
+       if (rc == 0)
+               tuner_dbg("Firmware files loaded.\n");
+
+       return rc;
+}
+
+static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
+                        v4l2_std_id *id)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       int                 i, best_i = -1, best_nr_matches = 0;
+       unsigned int        type_mask = 0;
+
+       tuner_dbg("%s called, want type=", __func__);
+       if (debug) {
+               dump_firm_type(type);
+               printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
+       }
+
+       if (!priv->firm) {
+               tuner_err("Error! firmware not loaded\n");
+               return -EINVAL;
+       }
+
+       if (((type & ~SCODE) == 0) && (*id == 0))
+               *id = V4L2_STD_PAL;
+
+       if (type & BASE)
+               type_mask = BASE_TYPES;
+       else if (type & SCODE) {
+               type &= SCODE_TYPES;
+               type_mask = SCODE_TYPES & ~HAS_IF;
+       } else if (type & DTV_TYPES)
+               type_mask = DTV_TYPES;
+       else if (type & STD_SPECIFIC_TYPES)
+               type_mask = STD_SPECIFIC_TYPES;
+
+       type &= type_mask;
+
+       if (!(type & SCODE))
+               type_mask = ~0;
+
+       /* Seek for exact match */
+       for (i = 0; i < priv->firm_size; i++) {
+               if ((type == (priv->firm[i].type & type_mask)) &&
+                   (*id == priv->firm[i].id))
+                       goto found;
+       }
+
+       /* Seek for generic video standard match */
+       for (i = 0; i < priv->firm_size; i++) {
+               v4l2_std_id match_mask;
+               int nr_matches;
+
+               if (type != (priv->firm[i].type & type_mask))
+                       continue;
+
+               match_mask = *id & priv->firm[i].id;
+               if (!match_mask)
+                       continue;
+
+               if ((*id & match_mask) == *id)
+                       goto found; /* Supports all the requested standards */
+
+               nr_matches = hweight64(match_mask);
+               if (nr_matches > best_nr_matches) {
+                       best_nr_matches = nr_matches;
+                       best_i = i;
+               }
+       }
+
+       if (best_nr_matches > 0) {
+               tuner_dbg("Selecting best matching firmware (%d bits) for "
+                         "type=", best_nr_matches);
+               dump_firm_type(type);
+               printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
+               i = best_i;
+               goto found;
+       }
+
+       /*FIXME: Would make sense to seek for type "hint" match ? */
+
+       i = -ENOENT;
+       goto ret;
+
+found:
+       *id = priv->firm[i].id;
+
+ret:
+       tuner_dbg("%s firmware for type=", (i < 0) ? "Can't find" : "Found");
+       if (debug) {
+               dump_firm_type(type);
+               printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
+       }
+       return i;
+}
+
+static int load_firmware(struct dvb_frontend *fe, unsigned int type,
+                        v4l2_std_id *id)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       int                pos, rc;
+       unsigned char      *p, *endp, buf[priv->ctrl.max_len];
+
+       tuner_dbg("%s called\n", __func__);
+
+       pos = seek_firmware(fe, type, id);
+       if (pos < 0)
+               return pos;
+
+       tuner_info("Loading firmware for type=");
+       dump_firm_type(priv->firm[pos].type);
+       printk("(%x), id %016llx.\n", priv->firm[pos].type,
+              (unsigned long long)*id);
+
+       p = priv->firm[pos].ptr;
+       endp = p + priv->firm[pos].size;
+
+       while (p < endp) {
+               __u16 size;
+
+               /* Checks if there's enough bytes to read */
+               if (p + sizeof(size) > endp) {
+                       tuner_err("Firmware chunk size is wrong\n");
+                       return -EINVAL;
+               }
+
+               size = le16_to_cpu(*(__u16 *) p);
+               p += sizeof(size);
+
+               if (size == 0xffff)
+                       return 0;
+
+               if (!size) {
+                       /* Special callback command received */
+                       rc = priv->tuner_callback(priv->video_dev,
+                                                 XC2028_TUNER_RESET, 0);
+                       if (rc < 0) {
+                               tuner_err("Error at RESET code %d\n",
+                                          (*p) & 0x7f);
+                               return -EINVAL;
+                       }
+                       continue;
+               }
+               if (size >= 0xff00) {
+                       switch (size) {
+                       case 0xff00:
+                               rc = priv->tuner_callback(priv->video_dev,
+                                                       XC2028_RESET_CLK, 0);
+                               if (rc < 0) {
+                                       tuner_err("Error at RESET code %d\n",
+                                                 (*p) & 0x7f);
+                                       return -EINVAL;
+                               }
+                               break;
+                       default:
+                               tuner_info("Invalid RESET code %d\n",
+                                          size & 0x7f);
+                               return -EINVAL;
+
+                       }
+                       continue;
+               }
+
+               /* Checks for a sleep command */
+               if (size & 0x8000) {
+                       msleep(size & 0x7fff);
+                       continue;
+               }
+
+               if ((size + p > endp)) {
+                       tuner_err("missing bytes: need %d, have %d\n",
+                                  size, (int)(endp - p));
+                       return -EINVAL;
+               }
+
+               buf[0] = *p;
+               p++;
+               size--;
+
+               /* Sends message chunks */
+               while (size > 0) {
+                       int len = (size < priv->ctrl.max_len - 1) ?
+                                  size : priv->ctrl.max_len - 1;
+
+                       memcpy(buf + 1, p, len);
+
+                       rc = i2c_send(priv, buf, len + 1);
+                       if (rc < 0) {
+                               tuner_err("%d returned from send\n", rc);
+                               return -EINVAL;
+                       }
+
+                       p += len;
+                       size -= len;
+               }
+       }
+       return 0;
+}
+
+static int load_scode(struct dvb_frontend *fe, unsigned int type,
+                        v4l2_std_id *id, __u16 int_freq, int scode)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       int                pos, rc;
+       unsigned char      *p;
+
+       tuner_dbg("%s called\n", __func__);
+
+       if (!int_freq) {
+               pos = seek_firmware(fe, type, id);
+               if (pos < 0)
+                       return pos;
+       } else {
+               for (pos = 0; pos < priv->firm_size; pos++) {
+                       if ((priv->firm[pos].int_freq == int_freq) &&
+                           (priv->firm[pos].type & HAS_IF))
+                               break;
+               }
+               if (pos == priv->firm_size)
+                       return -ENOENT;
+       }
+
+       p = priv->firm[pos].ptr;
+
+       if (priv->firm[pos].type & HAS_IF) {
+               if (priv->firm[pos].size != 12 * 16 || scode >= 16)
+                       return -EINVAL;
+               p += 12 * scode;
+       } else {
+               /* 16 SCODE entries per file; each SCODE entry is 12 bytes and
+                * has a 2-byte size header in the firmware format. */
+               if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||
+                   le16_to_cpu(*(__u16 *)(p + 14 * scode)) != 12)
+                       return -EINVAL;
+               p += 14 * scode + 2;
+       }
+
+       tuner_info("Loading SCODE for type=");
+       dump_firm_type_and_int_freq(priv->firm[pos].type,
+                                   priv->firm[pos].int_freq);
+       printk("(%x), id %016llx.\n", priv->firm[pos].type,
+              (unsigned long long)*id);
+
+       if (priv->firm_version < 0x0202)
+               rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00});
+       else
+               rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00});
+       if (rc < 0)
+               return -EIO;
+
+       rc = i2c_send(priv, p, 12);
+       if (rc < 0)
+               return -EIO;
+
+       rc = send_seq(priv, {0x00, 0x8c});
+       if (rc < 0)
+               return -EIO;
+
+       return 0;
+}
+
+static int check_firmware(struct dvb_frontend *fe, unsigned int type,
+                         v4l2_std_id std, __u16 int_freq)
+{
+       struct xc2028_data         *priv = fe->tuner_priv;
+       struct firmware_properties new_fw;
+       int                        rc = 0, is_retry = 0;
+       u16                        version, hwmodel;
+       v4l2_std_id                std0;
+
+       tuner_dbg("%s called\n", __func__);
+
+       if (!priv->firm) {
+               if (!priv->ctrl.fname) {
+                       tuner_info("xc2028/3028 firmware name not set!\n");
+                       return -EINVAL;
+               }
+
+               rc = load_all_firmwares(fe);
+               if (rc < 0)
+                       return rc;
+       }
+
+       if (priv->ctrl.mts && !(type & FM))
+               type |= MTS;
+
+retry:
+       new_fw.type = type;
+       new_fw.id = std;
+       new_fw.std_req = std;
+       new_fw.scode_table = SCODE | priv->ctrl.scode_table;
+       new_fw.scode_nr = 0;
+       new_fw.int_freq = int_freq;
+
+       tuner_dbg("checking firmware, user requested type=");
+       if (debug) {
+               dump_firm_type(new_fw.type);
+               printk("(%x), id %016llx, ", new_fw.type,
+                      (unsigned long long)new_fw.std_req);
+               if (!int_freq) {
+                       printk("scode_tbl ");
+                       dump_firm_type(priv->ctrl.scode_table);
+                       printk("(%x), ", priv->ctrl.scode_table);
+               } else
+                       printk("int_freq %d, ", new_fw.int_freq);
+               printk("scode_nr %d\n", new_fw.scode_nr);
+       }
+
+       /* No need to reload base firmware if it matches */
+       if (((BASE | new_fw.type) & BASE_TYPES) ==
+           (priv->cur_fw.type & BASE_TYPES)) {
+               tuner_dbg("BASE firmware not changed.\n");
+               goto skip_base;
+       }
+
+       /* Updating BASE - forget about all currently loaded firmware */
+       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
+
+       /* Reset is needed before loading firmware */
+       rc = priv->tuner_callback(priv->video_dev,
+                                 XC2028_TUNER_RESET, 0);
+       if (rc < 0)
+               goto fail;
+
+       /* BASE firmwares are all std0 */
+       std0 = 0;
+       rc = load_firmware(fe, BASE | new_fw.type, &std0);
+       if (rc < 0) {
+               tuner_err("Error %d while loading base firmware\n",
+                         rc);
+               goto fail;
+       }
+
+       /* Load INIT1, if needed */
+       tuner_dbg("Load init1 firmware, if exists\n");
+
+       rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0);
+       if (rc == -ENOENT)
+               rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ,
+                                  &std0);
+       if (rc < 0 && rc != -ENOENT) {
+               tuner_err("Error %d while loading init1 firmware\n",
+                         rc);
+               goto fail;
+       }
+
+skip_base:
+       /*
+        * No need to reload standard specific firmware if base firmware
+        * was not reloaded and requested video standards have not changed.
+        */
+       if (priv->cur_fw.type == (BASE | new_fw.type) &&
+           priv->cur_fw.std_req == std) {
+               tuner_dbg("Std-specific firmware already loaded.\n");
+               goto skip_std_specific;
+       }
+
+       /* Reloading std-specific firmware forces a SCODE update */
+       priv->cur_fw.scode_table = 0;
+
+       rc = load_firmware(fe, new_fw.type, &new_fw.id);
+       if (rc == -ENOENT)
+               rc = load_firmware(fe, new_fw.type & ~F8MHZ, &new_fw.id);
+
+       if (rc < 0)
+               goto fail;
+
+skip_std_specific:
+       if (priv->cur_fw.scode_table == new_fw.scode_table &&
+           priv->cur_fw.scode_nr == new_fw.scode_nr) {
+               tuner_dbg("SCODE firmware already loaded.\n");
+               goto check_device;
+       }
+
+       if (new_fw.type & FM)
+               goto check_device;
+
+       /* Load SCODE firmware, if exists */
+       tuner_dbg("Trying to load scode %d\n", new_fw.scode_nr);
+
+       rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
+                       new_fw.int_freq, new_fw.scode_nr);
+
+check_device:
+       if (xc2028_get_reg(priv, 0x0004, &version) < 0 ||
+           xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) {
+               tuner_err("Unable to read tuner registers.\n");
+               goto fail;
+       }
+
+       tuner_dbg("Device is Xceive %d version %d.%d, "
+                 "firmware version %d.%d\n",
+                 hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8,
+                 (version & 0xf0) >> 4, version & 0xf);
+
+       /* Check firmware version against what we downloaded. */
+       if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
+               tuner_err("Incorrect readback of firmware version.\n");
+               goto fail;
+       }
+
+       /* Check that the tuner hardware model remains consistent over time. */
+       if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) {
+               priv->hwmodel = hwmodel;
+               priv->hwvers  = version & 0xff00;
+       } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
+                  priv->hwvers != (version & 0xff00)) {
+               tuner_err("Read invalid device hardware information - tuner "
+                         "hung?\n");
+               goto fail;
+       }
+
+       memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
+
+       /*
+        * By setting BASE in cur_fw.type only after successfully loading all
+        * firmwares, we can:
+        * 1. Identify that BASE firmware with type=0 has been loaded;
+        * 2. Tell whether BASE firmware was just changed the next time through.
+        */
+       priv->cur_fw.type |= BASE;
+
+       return 0;
+
+fail:
+       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
+       if (!is_retry) {
+               msleep(50);
+               is_retry = 1;
+               tuner_dbg("Retrying firmware load\n");
+               goto retry;
+       }
+
+       if (rc == -ENOENT)
+               rc = -EINVAL;
+       return rc;
+}
+
+static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       u16                 frq_lock, signal = 0;
+       int                 rc;
+
+       tuner_dbg("%s called\n", __func__);
+
+       mutex_lock(&priv->lock);
+
+       /* Sync Lock Indicator */
+       rc = xc2028_get_reg(priv, 0x0002, &frq_lock);
+       if (rc < 0)
+               goto ret;
+
+       /* Frequency is locked */
+       if (frq_lock == 1)
+               signal = 32768;
+
+       /* Get SNR of the video signal */
+       rc = xc2028_get_reg(priv, 0x0040, &signal);
+       if (rc < 0)
+               goto ret;
+
+       /* Use both frq_lock and signal to generate the result */
+       signal = signal || ((signal & 0x07) << 12);
+
+ret:
+       mutex_unlock(&priv->lock);
+
+       *strength = signal;
+
+       tuner_dbg("signal strength is %d\n", signal);
+
+       return rc;
+}
+
+#define DIV 15625
+
+static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */,
+                           enum tuner_mode new_mode,
+                           unsigned int type,
+                           v4l2_std_id std,
+                           u16 int_freq)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       int                rc = -EINVAL;
+       unsigned char      buf[4];
+       u32                div, offset = 0;
+
+       tuner_dbg("%s called\n", __func__);
+
+       mutex_lock(&priv->lock);
+
+       tuner_dbg("should set frequency %d kHz\n", freq / 1000);
+
+       if (check_firmware(fe, type, std, int_freq) < 0)
+               goto ret;
+
+       /* On some cases xc2028 can disable video output, if
+        * very weak signals are received. By sending a soft
+        * reset, this is re-enabled. So, it is better to always
+        * send a soft reset before changing channels, to be sure
+        * that xc2028 will be in a safe state.
+        * Maybe this might also be needed for DTV.
+        */
+       if (new_mode == T_ANALOG_TV) {
+               rc = send_seq(priv, {0x00, 0x00});
+       } else if (priv->cur_fw.type & ATSC) {
+               offset = 1750000;
+       } else {
+               offset = 2750000;
+               /*
+                * We must adjust the offset by 500kHz in two cases in order
+                * to correctly center the IF output:
+                * 1) When the ZARLINK456 or DIBCOM52 tables were explicitly
+                *    selected and a 7MHz channel is tuned;
+                * 2) When tuning a VHF channel with DTV78 firmware.
+                */
+               if (((priv->cur_fw.type & DTV7) &&
+                    (priv->cur_fw.scode_table & (ZARLINK456 | DIBCOM52))) ||
+                   ((priv->cur_fw.type & DTV78) && freq < 470000000))
+                       offset -= 500000;
+       }
+
+       div = (freq - offset + DIV / 2) / DIV;
+
+       /* CMD= Set frequency */
+       if (priv->firm_version < 0x0202)
+               rc = send_seq(priv, {0x00, 0x02, 0x00, 0x00});
+       else
+               rc = send_seq(priv, {0x80, 0x02, 0x00, 0x00});
+       if (rc < 0)
+               goto ret;
+
+       /* Return code shouldn't be checked.
+          The reset CLK is needed only with tm6000.
+          Driver should work fine even if this fails.
+        */
+       priv->tuner_callback(priv->video_dev, XC2028_RESET_CLK, 1);
+
+       msleep(10);
+
+       buf[0] = 0xff & (div >> 24);
+       buf[1] = 0xff & (div >> 16);
+       buf[2] = 0xff & (div >> 8);
+       buf[3] = 0xff & (div);
+
+       rc = i2c_send(priv, buf, sizeof(buf));
+       if (rc < 0)
+               goto ret;
+       msleep(100);
+
+       priv->frequency = freq;
+
+       tuner_dbg("divisor= %02x %02x %02x %02x (freq=%d.%03d)\n",
+              buf[0], buf[1], buf[2], buf[3],
+              freq / 1000000, (freq % 1000000) / 1000);
+
+       rc = 0;
+
+ret:
+       mutex_unlock(&priv->lock);
+
+       return rc;
+}
+
+static int xc2028_set_analog_freq(struct dvb_frontend *fe,
+                             struct analog_parameters *p)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       unsigned int       type=0;
+
+       tuner_dbg("%s called\n", __func__);
+
+       if (p->mode == V4L2_TUNER_RADIO) {
+               type |= FM;
+               if (priv->ctrl.input1)
+                       type |= INPUT1;
+               return generic_set_freq(fe, (625l * p->frequency) / 10,
+                               T_ANALOG_TV, type, 0, 0);
+       }
+
+       /* if std is not defined, choose one */
+       if (!p->std)
+               p->std = V4L2_STD_MN;
+
+       /* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */
+       if (!(p->std & V4L2_STD_MN))
+               type |= F8MHZ;
+
+       /* Add audio hack to std mask */
+       p->std |= parse_audio_std_option();
+
+       return generic_set_freq(fe, 62500l * p->frequency,
+                               T_ANALOG_TV, type, p->std, 0);
+}
+
+static int xc2028_set_params(struct dvb_frontend *fe,
+                            struct dvb_frontend_parameters *p)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       unsigned int       type=0;
+       fe_bandwidth_t     bw = BANDWIDTH_8_MHZ;
+       u16                demod = 0;
+
+       tuner_dbg("%s called\n", __func__);
+
+       if (priv->ctrl.d2633)
+               type |= D2633;
+       else
+               type |= D2620;
+
+       switch(fe->ops.info.type) {
+       case FE_OFDM:
+               bw = p->u.ofdm.bandwidth;
+               break;
+       case FE_QAM:
+               tuner_info("WARN: There are some reports that "
+                          "QAM 6 MHz doesn't work.\n"
+                          "If this works for you, please report by "
+                          "e-mail to: v4l-dvb-maintainer@linuxtv.org\n");
+               bw = BANDWIDTH_6_MHZ;
+               type |= QAM;
+               break;
+       case FE_ATSC:
+               bw = BANDWIDTH_6_MHZ;
+               /* The only ATSC firmware (at least on v2.7) is D2633,
+                  so overrides ctrl->d2633 */
+               type |= ATSC| D2633;
+               type &= ~D2620;
+               break;
+       /* DVB-S is not supported */
+       default:
+               return -EINVAL;
+       }
+
+       switch (bw) {
+       case BANDWIDTH_8_MHZ:
+               if (p->frequency < 470000000)
+                       priv->ctrl.vhfbw7 = 0;
+               else
+                       priv->ctrl.uhfbw8 = 1;
+               type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8;
+               type |= F8MHZ;
+               break;
+       case BANDWIDTH_7_MHZ:
+               if (p->frequency < 470000000)
+                       priv->ctrl.vhfbw7 = 1;
+               else
+                       priv->ctrl.uhfbw8 = 0;
+               type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7;
+               type |= F8MHZ;
+               break;
+       case BANDWIDTH_6_MHZ:
+               type |= DTV6;
+               priv->ctrl.vhfbw7 = 0;
+               priv->ctrl.uhfbw8 = 0;
+               break;
+       default:
+               tuner_err("error: bandwidth not supported.\n");
+       };
+
+       /* All S-code tables need a 200kHz shift */
+       if (priv->ctrl.demod)
+               demod = priv->ctrl.demod + 200;
+
+       return generic_set_freq(fe, p->frequency,
+                               T_DIGITAL_TV, type, 0, demod);
+}
+
+
+static int xc2028_dvb_release(struct dvb_frontend *fe)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+
+       tuner_dbg("%s called\n", __func__);
+
+       mutex_lock(&xc2028_list_mutex);
+
+       priv->count--;
+
+       if (!priv->count) {
+               list_del(&priv->xc2028_list);
+
+               kfree(priv->ctrl.fname);
+
+               free_firmware(priv);
+               kfree(priv);
+               fe->tuner_priv = NULL;
+       }
+
+       mutex_unlock(&xc2028_list_mutex);
+
+       return 0;
+}
+
+static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+
+       tuner_dbg("%s called\n", __func__);
+
+       *frequency = priv->frequency;
+
+       return 0;
+}
+
+static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
+{
+       struct xc2028_data *priv = fe->tuner_priv;
+       struct xc2028_ctrl *p    = priv_cfg;
+       int                 rc   = 0;
+
+       tuner_dbg("%s called\n", __func__);
+
+       mutex_lock(&priv->lock);
+
+       memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
+       if (priv->ctrl.max_len < 9)
+               priv->ctrl.max_len = 13;
+
+       if (p->fname) {
+               if (priv->ctrl.fname && strcmp(p->fname, priv->ctrl.fname)) {
+                       kfree(priv->ctrl.fname);
+                       free_firmware(priv);
+               }
+
+               priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
+               if (priv->ctrl.fname == NULL)
+                       rc = -ENOMEM;
+       }
+
+       mutex_unlock(&priv->lock);
+
+       return rc;
+}
+
+static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
+       .info = {
+                .name = "Xceive XC3028",
+                .frequency_min = 42000000,
+                .frequency_max = 864000000,
+                .frequency_step = 50000,
+                },
+
+       .set_config        = xc2028_set_config,
+       .set_analog_params = xc2028_set_analog_freq,
+       .release           = xc2028_dvb_release,
+       .get_frequency     = xc2028_get_frequency,
+       .get_rf_strength   = xc2028_signal,
+       .set_params        = xc2028_set_params,
+};
+
+struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
+                                  struct xc2028_config *cfg)
+{
+       struct xc2028_data *priv;
+       void               *video_dev;
+
+       if (debug)
+               printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");
+
+       if (NULL == cfg)
+               return NULL;
+
+       if (!fe) {
+               printk(KERN_ERR "xc2028: No frontend!\n");
+               return NULL;
+       }
+
+       video_dev = cfg->i2c_adap->algo_data;
+
+       if (debug)
+               printk(KERN_DEBUG "xc2028: video_dev =%p\n", video_dev);
+
+       mutex_lock(&xc2028_list_mutex);
+
+       list_for_each_entry(priv, &xc2028_list, xc2028_list) {
+               if (&priv->i2c_props.adap->dev == &cfg->i2c_adap->dev) {
+                       video_dev = NULL;
+                       if (debug)
+                               printk(KERN_DEBUG "xc2028: reusing device\n");
+
+                       break;
+               }
+       }
+
+       if (video_dev) {
+               priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+               if (priv == NULL) {
+                       mutex_unlock(&xc2028_list_mutex);
+                       return NULL;
+               }
+
+               priv->i2c_props.addr = cfg->i2c_addr;
+               priv->i2c_props.adap = cfg->i2c_adap;
+               priv->i2c_props.name = "xc2028";
+
+               priv->video_dev = video_dev;
+               priv->tuner_callback = cfg->callback;
+               priv->ctrl.max_len = 13;
+
+               mutex_init(&priv->lock);
+
+               list_add_tail(&priv->xc2028_list, &xc2028_list);
+       }
+
+       fe->tuner_priv = priv;
+       priv->count++;
+
+       if (debug)
+               printk(KERN_DEBUG "xc2028: usage count is %i\n", priv->count);
+
+       memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
+              sizeof(xc2028_dvb_tuner_ops));
+
+       tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
+
+       if (cfg->ctrl)
+               xc2028_set_config(fe, cfg->ctrl);
+
+       mutex_unlock(&xc2028_list_mutex);
+
+       return fe;
+}
+
+EXPORT_SYMBOL(xc2028_attach);
+
+MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
+MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
+MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/common/tuners/tuner-xc2028.h b/drivers/media/common/tuners/tuner-xc2028.h
new file mode 100644 (file)
index 0000000..fc2f132
--- /dev/null
@@ -0,0 +1,63 @@
+/* tuner-xc2028
+ *
+ * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
+ * This code is placed under the terms of the GNU General Public License v2
+ */
+
+#ifndef __TUNER_XC2028_H__
+#define __TUNER_XC2028_H__
+
+#include "dvb_frontend.h"
+
+#define XC2028_DEFAULT_FIRMWARE "xc3028-v27.fw"
+
+/*      Dmoduler               IF (kHz) */
+#define        XC3028_FE_DEFAULT       0               /* Don't load SCODE */
+#define XC3028_FE_LG60         6000
+#define        XC3028_FE_ATI638        6380
+#define        XC3028_FE_OREN538       5380
+#define        XC3028_FE_OREN36        3600
+#define        XC3028_FE_TOYOTA388     3880
+#define        XC3028_FE_TOYOTA794     7940
+#define        XC3028_FE_DIBCOM52      5200
+#define        XC3028_FE_ZARLINK456    4560
+#define        XC3028_FE_CHINA         5200
+
+struct xc2028_ctrl {
+       char                    *fname;
+       int                     max_len;
+       unsigned int            scode_table;
+       unsigned int            mts   :1;
+       unsigned int            d2633 :1;
+       unsigned int            input1:1;
+       unsigned int            vhfbw7:1;
+       unsigned int            uhfbw8:1;
+       unsigned int            demod;
+};
+
+struct xc2028_config {
+       struct i2c_adapter *i2c_adap;
+       u8                 i2c_addr;
+       void               *video_dev;
+       struct xc2028_ctrl *ctrl;
+       int                (*callback) (void *dev, int command, int arg);
+};
+
+/* xc2028 commands for callback */
+#define XC2028_TUNER_RESET     0
+#define XC2028_RESET_CLK       1
+
+#if defined(CONFIG_TUNER_XC2028) || (defined(CONFIG_TUNER_XC2028_MODULE) && defined(MODULE))
+extern struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
+                                         struct xc2028_config *cfg);
+#else
+static inline struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
+                                                struct xc2028_config *cfg)
+{
+       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
+              __func__);
+       return NULL;
+}
+#endif
+
+#endif /* __TUNER_XC2028_H__ */
diff --git a/drivers/media/common/tuners/xc5000.c b/drivers/media/common/tuners/xc5000.c
new file mode 100644 (file)
index 0000000..43d35bd
--- /dev/null
@@ -0,0 +1,964 @@
+/*
+ *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
+ *
+ *  Copyright (c) 2007 Xceive Corporation
+ *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/videodev2.h>
+#include <linux/delay.h>
+#include <linux/dvb/frontend.h>
+#include <linux/i2c.h>
+
+#include "dvb_frontend.h"
+
+#include "xc5000.h"
+#include "xc5000_priv.h"
+
+static int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
+
+#define dprintk(level,fmt, arg...) if (debug >= level) \
+       printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
+
+#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.1.fw"
+#define XC5000_DEFAULT_FIRMWARE_SIZE 12332
+
+/* Misc Defines */
+#define MAX_TV_STANDARD                        23
+#define XC_MAX_I2C_WRITE_LENGTH                64
+
+/* Signal Types */
+#define XC_RF_MODE_AIR                 0
+#define XC_RF_MODE_CABLE               1
+
+/* Result codes */
+#define XC_RESULT_SUCCESS              0
+#define XC_RESULT_RESET_FAILURE                1
+#define XC_RESULT_I2C_WRITE_FAILURE    2
+#define XC_RESULT_I2C_READ_FAILURE     3
+#define XC_RESULT_OUT_OF_RANGE         5
+
+/* Product id */
+#define XC_PRODUCT_ID_FW_NOT_LOADED    0x2000
+#define XC_PRODUCT_ID_FW_LOADED        0x1388
+
+/* Registers */
+#define XREG_INIT         0x00
+#define XREG_VIDEO_MODE   0x01
+#define XREG_AUDIO_MODE   0x02
+#define XREG_RF_FREQ      0x03
+#define XREG_D_CODE       0x04
+#define XREG_IF_OUT       0x05
+#define XREG_SEEK_MODE    0x07
+#define XREG_POWER_DOWN   0x0A
+#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
+#define XREG_SMOOTHEDCVBS 0x0E
+#define XREG_XTALFREQ     0x0F
+#define XREG_FINERFFREQ   0x10
+#define XREG_DDIMODE      0x11
+
+#define XREG_ADC_ENV      0x00
+#define XREG_QUALITY      0x01
+#define XREG_FRAME_LINES  0x02
+#define XREG_HSYNC_FREQ   0x03
+#define XREG_LOCK         0x04
+#define XREG_FREQ_ERROR   0x05
+#define XREG_SNR          0x06
+#define XREG_VERSION      0x07
+#define XREG_PRODUCT_ID   0x08
+#define XREG_BUSY         0x09
+
+/*
+   Basic firmware description. This will remain with
+   the driver for documentation purposes.
+
+   This represents an I2C firmware file encoded as a
+   string of unsigned char. Format is as follows:
+
+   char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
+   char[1  ]=len0_LSB  -> length of first write transaction
+   char[2  ]=data0 -> first byte to be sent
+   char[3  ]=data1
+   char[4  ]=data2
+   char[   ]=...
+   char[M  ]=dataN  -> last byte to be sent
+   char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
+   char[M+2]=len1_LSB  -> length of second write transaction
+   char[M+3]=data0
+   char[M+4]=data1
+   ...
+   etc.
+
+   The [len] value should be interpreted as follows:
+
+   len= len_MSB _ len_LSB
+   len=1111_1111_1111_1111   : End of I2C_SEQUENCE
+   len=0000_0000_0000_0000   : Reset command: Do hardware reset
+   len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
+   len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
+
+   For the RESET and WAIT commands, the two following bytes will contain
+   immediately the length of the following transaction.
+
+*/
+typedef struct {
+       char *Name;
+       u16 AudioMode;
+       u16 VideoMode;
+} XC_TV_STANDARD;
+
+/* Tuner standards */
+#define MN_NTSC_PAL_BTSC       0
+#define MN_NTSC_PAL_A2         1
+#define MN_NTSC_PAL_EIAJ       2
+#define MN_NTSC_PAL_Mono       3
+#define BG_PAL_A2              4
+#define BG_PAL_NICAM           5
+#define BG_PAL_MONO            6
+#define I_PAL_NICAM            7
+#define I_PAL_NICAM_MONO       8
+#define DK_PAL_A2              9
+#define DK_PAL_NICAM           10
+#define DK_PAL_MONO            11
+#define DK_SECAM_A2DK1         12
+#define DK_SECAM_A2LDK3        13
+#define DK_SECAM_A2MONO        14
+#define L_SECAM_NICAM          15
+#define LC_SECAM_NICAM         16
+#define DTV6                   17
+#define DTV8                   18
+#define DTV7_8                 19
+#define DTV7                   20
+#define FM_Radio_INPUT2        21
+#define FM_Radio_INPUT1        22
+
+static XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
+       {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
+       {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
+       {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
+       {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
+       {"B/G-PAL-A2",        0x0A00, 0x8049},
+       {"B/G-PAL-NICAM",     0x0C04, 0x8049},
+       {"B/G-PAL-MONO",      0x0878, 0x8059},
+       {"I-PAL-NICAM",       0x1080, 0x8009},
+       {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
+       {"D/K-PAL-A2",        0x1600, 0x8009},
+       {"D/K-PAL-NICAM",     0x0E80, 0x8009},
+       {"D/K-PAL-MONO",      0x1478, 0x8009},
+       {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
+       {"D/K-SECAM-A2 L/DK3",0x0E00, 0x8009},
+       {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
+       {"L-SECAM-NICAM",     0x8E82, 0x0009},
+       {"L'-SECAM-NICAM",    0x8E82, 0x4009},
+       {"DTV6",              0x00C0, 0x8002},
+       {"DTV8",              0x00C0, 0x800B},
+       {"DTV7/8",            0x00C0, 0x801B},
+       {"DTV7",              0x00C0, 0x8007},
+       {"FM Radio-INPUT2",   0x9802, 0x9002},
+       {"FM Radio-INPUT1",   0x0208, 0x9002}
+};
+
+static int  xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
+static int  xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
+static void xc5000_TunerReset(struct dvb_frontend *fe);
+
+static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
+{
+       return xc5000_writeregs(priv, buf, len)
+               ? XC_RESULT_I2C_WRITE_FAILURE : XC_RESULT_SUCCESS;
+}
+
+static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
+{
+       return xc5000_readregs(priv, buf, len)
+               ? XC_RESULT_I2C_READ_FAILURE : XC_RESULT_SUCCESS;
+}
+
+static int xc_reset(struct dvb_frontend *fe)
+{
+       xc5000_TunerReset(fe);
+       return XC_RESULT_SUCCESS;
+}
+
+static void xc_wait(int wait_ms)
+{
+       msleep(wait_ms);
+}
+
+static void xc5000_TunerReset(struct dvb_frontend *fe)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       int ret;
+
+       dprintk(1, "%s()\n", __func__);
+
+       if (priv->cfg->tuner_callback) {
+               ret = priv->cfg->tuner_callback(priv->cfg->priv,
+                                               XC5000_TUNER_RESET, 0);
+               if (ret)
+                       printk(KERN_ERR "xc5000: reset failed\n");
+       } else
+               printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
+}
+
+static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
+{
+       u8 buf[4];
+       int WatchDogTimer = 5;
+       int result;
+
+       buf[0] = (regAddr >> 8) & 0xFF;
+       buf[1] = regAddr & 0xFF;
+       buf[2] = (i2cData >> 8) & 0xFF;
+       buf[3] = i2cData & 0xFF;
+       result = xc_send_i2c_data(priv, buf, 4);
+       if (result == XC_RESULT_SUCCESS) {
+               /* wait for busy flag to clear */
+               while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
+                       buf[0] = 0;
+                       buf[1] = XREG_BUSY;
+
+                       result = xc_send_i2c_data(priv, buf, 2);
+                       if (result == XC_RESULT_SUCCESS) {
+                               result = xc_read_i2c_data(priv, buf, 2);
+                               if (result == XC_RESULT_SUCCESS) {
+                                       if ((buf[0] == 0) && (buf[1] == 0)) {
+                                               /* busy flag cleared */
+                                       break;
+                                       } else {
+                                               xc_wait(100); /* wait 5 ms */
+                                               WatchDogTimer--;
+                                       }
+                               }
+                       }
+               }
+       }
+       if (WatchDogTimer < 0)
+               result = XC_RESULT_I2C_WRITE_FAILURE;
+
+       return result;
+}
+
+static int xc_read_reg(struct xc5000_priv *priv, u16 regAddr, u16 *i2cData)
+{
+       u8 buf[2];
+       int result;
+
+       buf[0] = (regAddr >> 8) & 0xFF;
+       buf[1] = regAddr & 0xFF;
+       result = xc_send_i2c_data(priv, buf, 2);
+       if (result != XC_RESULT_SUCCESS)
+               return result;
+
+       result = xc_read_i2c_data(priv, buf, 2);
+       if (result != XC_RESULT_SUCCESS)
+               return result;
+
+       *i2cData = buf[0] * 256 + buf[1];
+       return result;
+}
+
+static int xc_load_i2c_sequence(struct dvb_frontend *fe, u8 i2c_sequence[])
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+
+       int i, nbytes_to_send, result;
+       unsigned int len, pos, index;
+       u8 buf[XC_MAX_I2C_WRITE_LENGTH];
+
+       index=0;
+       while ((i2c_sequence[index]!=0xFF) || (i2c_sequence[index+1]!=0xFF)) {
+               len = i2c_sequence[index]* 256 + i2c_sequence[index+1];
+               if (len == 0x0000) {
+                       /* RESET command */
+                       result = xc_reset(fe);
+                       index += 2;
+                       if (result != XC_RESULT_SUCCESS)
+                               return result;
+               } else if (len & 0x8000) {
+                       /* WAIT command */
+                       xc_wait(len & 0x7FFF);
+                       index += 2;
+               } else {
+                       /* Send i2c data whilst ensuring individual transactions
+                        * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
+                        */
+                       index += 2;
+                       buf[0] = i2c_sequence[index];
+                       buf[1] = i2c_sequence[index + 1];
+                       pos = 2;
+                       while (pos < len) {
+                               if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) {
+                                       nbytes_to_send = XC_MAX_I2C_WRITE_LENGTH;
+                               } else {
+                                       nbytes_to_send = (len - pos + 2);
+                               }
+                               for (i=2; i<nbytes_to_send; i++) {
+                                       buf[i] = i2c_sequence[index + pos + i - 2];
+                               }
+                               result = xc_send_i2c_data(priv, buf, nbytes_to_send);
+
+                               if (result != XC_RESULT_SUCCESS)
+                                       return result;
+
+                               pos += nbytes_to_send - 2;
+                       }
+                       index += len;
+               }
+       }
+       return XC_RESULT_SUCCESS;
+}
+
+static int xc_initialize(struct xc5000_priv *priv)
+{
+       dprintk(1, "%s()\n", __func__);
+       return xc_write_reg(priv, XREG_INIT, 0);
+}
+
+static int xc_SetTVStandard(struct xc5000_priv *priv,
+       u16 VideoMode, u16 AudioMode)
+{
+       int ret;
+       dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
+       dprintk(1, "%s() Standard = %s\n",
+               __func__,
+               XC5000_Standard[priv->video_standard].Name);
+
+       ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
+       if (ret == XC_RESULT_SUCCESS)
+               ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
+
+       return ret;
+}
+
+static int xc_shutdown(struct xc5000_priv *priv)
+{
+       return 0;
+       /* Fixme: cannot bring tuner back alive once shutdown
+        *        without reloading the driver modules.
+        *    return xc_write_reg(priv, XREG_POWER_DOWN, 0);
+        */
+}
+
+static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
+{
+       dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
+               rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
+
+       if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE))
+       {
+               rf_mode = XC_RF_MODE_CABLE;
+               printk(KERN_ERR
+                       "%s(), Invalid mode, defaulting to CABLE",
+                       __func__);
+       }
+       return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
+}
+
+static const struct dvb_tuner_ops xc5000_tuner_ops;
+
+static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
+{
+       u16 freq_code;
+
+       dprintk(1, "%s(%u)\n", __func__, freq_hz);
+
+       if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
+               (freq_hz < xc5000_tuner_ops.info.frequency_min))
+               return XC_RESULT_OUT_OF_RANGE;
+
+       freq_code = (u16)(freq_hz / 15625);
+
+       return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
+}
+
+
+static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
+{
+       u32 freq_code = (freq_khz * 1024)/1000;
+       dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
+               __func__, freq_khz, freq_code);
+
+       return xc_write_reg(priv, XREG_IF_OUT, freq_code);
+}
+
+
+static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
+{
+       return xc_read_reg(priv, XREG_ADC_ENV, adc_envelope);
+}
+
+static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
+{
+       int result;
+       u16 regData;
+       u32 tmp;
+
+       result = xc_read_reg(priv, XREG_FREQ_ERROR, &regData);
+       if (result)
+               return result;
+
+       tmp = (u32)regData;
+       (*freq_error_hz) = (tmp * 15625) / 1000;
+       return result;
+}
+
+static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
+{
+       return xc_read_reg(priv, XREG_LOCK, lock_status);
+}
+
+static int xc_get_version(struct xc5000_priv *priv,
+       u8 *hw_majorversion, u8 *hw_minorversion,
+       u8 *fw_majorversion, u8 *fw_minorversion)
+{
+       u16 data;
+       int result;
+
+       result = xc_read_reg(priv, XREG_VERSION, &data);
+       if (result)
+               return result;
+
+       (*hw_majorversion) = (data >> 12) & 0x0F;
+       (*hw_minorversion) = (data >>  8) & 0x0F;
+       (*fw_majorversion) = (data >>  4) & 0x0F;
+       (*fw_minorversion) = data & 0x0F;
+
+       return 0;
+}
+
+static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
+{
+       u16 regData;
+       int result;
+
+       result = xc_read_reg(priv, XREG_HSYNC_FREQ, &regData);
+       if (result)
+               return result;
+
+       (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
+       return result;
+}
+
+static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
+{
+       return xc_read_reg(priv, XREG_FRAME_LINES, frame_lines);
+}
+
+static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
+{
+       return xc_read_reg(priv, XREG_QUALITY, quality);
+}
+
+static u16 WaitForLock(struct xc5000_priv *priv)
+{
+       u16 lockState = 0;
+       int watchDogCount = 40;
+
+       while ((lockState == 0) && (watchDogCount > 0)) {
+               xc_get_lock_status(priv, &lockState);
+               if (lockState != 1) {
+                       xc_wait(5);
+                       watchDogCount--;
+               }
+       }
+       return lockState;
+}
+
+static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz)
+{
+       int found = 0;
+
+       dprintk(1, "%s(%u)\n", __func__, freq_hz);
+
+       if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
+               return 0;
+
+       if (WaitForLock(priv) == 1)
+               found = 1;
+
+       return found;
+}
+
+static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
+{
+       u8 buf[2] = { reg >> 8, reg & 0xff };
+       u8 bval[2] = { 0, 0 };
+       struct i2c_msg msg[2] = {
+               { .addr = priv->cfg->i2c_address,
+                       .flags = 0, .buf = &buf[0], .len = 2 },
+               { .addr = priv->cfg->i2c_address,
+                       .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
+       };
+
+       if (i2c_transfer(priv->i2c, msg, 2) != 2) {
+               printk(KERN_WARNING "xc5000: I2C read failed\n");
+               return -EREMOTEIO;
+       }
+
+       *val = (bval[0] << 8) | bval[1];
+       return 0;
+}
+
+static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len)
+{
+       struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
+               .flags = 0, .buf = buf, .len = len };
+
+       if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
+               printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n",
+                       (int)len);
+               return -EREMOTEIO;
+       }
+       return 0;
+}
+
+static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len)
+{
+       struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
+               .flags = I2C_M_RD, .buf = buf, .len = len };
+
+       if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
+               printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n",(int)len);
+               return -EREMOTEIO;
+       }
+       return 0;
+}
+
+static int xc5000_fwupload(struct dvb_frontend* fe)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       const struct firmware *fw;
+       int ret;
+
+       /* request the firmware, this will block and timeout */
+       printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
+               XC5000_DEFAULT_FIRMWARE);
+
+       ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE, &priv->i2c->dev);
+       if (ret) {
+               printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
+               ret = XC_RESULT_RESET_FAILURE;
+               goto out;
+       } else {
+               printk(KERN_INFO "xc5000: firmware read %Zu bytes.\n",
+                      fw->size);
+               ret = XC_RESULT_SUCCESS;
+       }
+
+       if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
+               printk(KERN_ERR "xc5000: firmware incorrect size\n");
+               ret = XC_RESULT_RESET_FAILURE;
+       } else {
+               printk(KERN_INFO "xc5000: firmware upload\n");
+               ret = xc_load_i2c_sequence(fe,  fw->data );
+       }
+
+out:
+       release_firmware(fw);
+       return ret;
+}
+
+static void xc_debug_dump(struct xc5000_priv *priv)
+{
+       u16 adc_envelope;
+       u32 freq_error_hz = 0;
+       u16 lock_status;
+       u32 hsync_freq_hz = 0;
+       u16 frame_lines;
+       u16 quality;
+       u8 hw_majorversion = 0, hw_minorversion = 0;
+       u8 fw_majorversion = 0, fw_minorversion = 0;
+
+       /* Wait for stats to stabilize.
+        * Frame Lines needs two frame times after initial lock
+        * before it is valid.
+        */
+       xc_wait(100);
+
+       xc_get_ADC_Envelope(priv,  &adc_envelope);
+       dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
+
+       xc_get_frequency_error(priv, &freq_error_hz);
+       dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
+
+       xc_get_lock_status(priv,  &lock_status);
+       dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
+               lock_status);
+
+       xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
+               &fw_majorversion, &fw_minorversion);
+       dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
+               hw_majorversion, hw_minorversion,
+               fw_majorversion, fw_minorversion);
+
+       xc_get_hsync_freq(priv,  &hsync_freq_hz);
+       dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
+
+       xc_get_frame_lines(priv,  &frame_lines);
+       dprintk(1, "*** Frame lines = %d\n", frame_lines);
+
+       xc_get_quality(priv,  &quality);
+       dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
+}
+
+static int xc5000_set_params(struct dvb_frontend *fe,
+       struct dvb_frontend_parameters *params)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       int ret;
+
+       dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
+
+       switch(params->u.vsb.modulation) {
+       case VSB_8:
+       case VSB_16:
+               dprintk(1, "%s() VSB modulation\n", __func__);
+               priv->rf_mode = XC_RF_MODE_AIR;
+               priv->freq_hz = params->frequency - 1750000;
+               priv->bandwidth = BANDWIDTH_6_MHZ;
+               priv->video_standard = DTV6;
+               break;
+       case QAM_64:
+       case QAM_256:
+       case QAM_AUTO:
+               dprintk(1, "%s() QAM modulation\n", __func__);
+               priv->rf_mode = XC_RF_MODE_CABLE;
+               priv->freq_hz = params->frequency - 1750000;
+               priv->bandwidth = BANDWIDTH_6_MHZ;
+               priv->video_standard = DTV6;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       dprintk(1, "%s() frequency=%d (compensated)\n",
+               __func__, priv->freq_hz);
+
+       ret = xc_SetSignalSource(priv, priv->rf_mode);
+       if (ret != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR
+                       "xc5000: xc_SetSignalSource(%d) failed\n",
+                       priv->rf_mode);
+               return -EREMOTEIO;
+       }
+
+       ret = xc_SetTVStandard(priv,
+               XC5000_Standard[priv->video_standard].VideoMode,
+               XC5000_Standard[priv->video_standard].AudioMode);
+       if (ret != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
+               return -EREMOTEIO;
+       }
+
+       ret = xc_set_IF_frequency(priv, priv->cfg->if_khz);
+       if (ret != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
+                       priv->cfg->if_khz);
+               return -EIO;
+       }
+
+       xc_tune_channel(priv, priv->freq_hz);
+
+       if (debug)
+               xc_debug_dump(priv);
+
+       return 0;
+}
+
+static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
+
+static int xc5000_set_analog_params(struct dvb_frontend *fe,
+       struct analog_parameters *params)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       int ret;
+
+       if(priv->fwloaded == 0)
+               xc_load_fw_and_init_tuner(fe);
+
+       dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
+               __func__, params->frequency);
+
+       priv->rf_mode = XC_RF_MODE_CABLE; /* Fix me: it could be air. */
+
+       /* params->frequency is in units of 62.5khz */
+       priv->freq_hz = params->frequency * 62500;
+
+       /* FIX ME: Some video standards may have several possible audio
+                  standards. We simply default to one of them here.
+        */
+       if(params->std & V4L2_STD_MN) {
+               /* default to BTSC audio standard */
+               priv->video_standard = MN_NTSC_PAL_BTSC;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_PAL_BG) {
+               /* default to NICAM audio standard */
+               priv->video_standard = BG_PAL_NICAM;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_PAL_I) {
+               /* default to NICAM audio standard */
+               priv->video_standard = I_PAL_NICAM;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_PAL_DK) {
+               /* default to NICAM audio standard */
+               priv->video_standard = DK_PAL_NICAM;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_SECAM_DK) {
+               /* default to A2 DK1 audio standard */
+               priv->video_standard = DK_SECAM_A2DK1;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_SECAM_L) {
+               priv->video_standard = L_SECAM_NICAM;
+               goto tune_channel;
+       }
+
+       if(params->std & V4L2_STD_SECAM_LC) {
+               priv->video_standard = LC_SECAM_NICAM;
+               goto tune_channel;
+       }
+
+tune_channel:
+       ret = xc_SetSignalSource(priv, priv->rf_mode);
+       if (ret != XC_RESULT_SUCCESS) {
+       printk(KERN_ERR
+                       "xc5000: xc_SetSignalSource(%d) failed\n",
+                       priv->rf_mode);
+               return -EREMOTEIO;
+       }
+
+       ret = xc_SetTVStandard(priv,
+               XC5000_Standard[priv->video_standard].VideoMode,
+               XC5000_Standard[priv->video_standard].AudioMode);
+       if (ret != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
+               return -EREMOTEIO;
+       }
+
+       xc_tune_channel(priv, priv->freq_hz);
+
+       if (debug)
+               xc_debug_dump(priv);
+
+       return 0;
+}
+
+static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       dprintk(1, "%s()\n", __func__);
+       *freq = priv->freq_hz;
+       return 0;
+}
+
+static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       dprintk(1, "%s()\n", __func__);
+
+       *bw = priv->bandwidth;
+       return 0;
+}
+
+static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       u16 lock_status = 0;
+
+       xc_get_lock_status(priv, &lock_status);
+
+       dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
+
+       *status = lock_status;
+
+       return 0;
+}
+
+static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       int ret = 0;
+
+       if (priv->fwloaded == 0) {
+               ret = xc5000_fwupload(fe);
+               if (ret != XC_RESULT_SUCCESS)
+                       return ret;
+               priv->fwloaded = 1;
+       }
+
+       /* Start the tuner self-calibration process */
+       ret |= xc_initialize(priv);
+
+       /* Wait for calibration to complete.
+        * We could continue but XC5000 will clock stretch subsequent
+        * I2C transactions until calibration is complete.  This way we
+        * don't have to rely on clock stretching working.
+        */
+       xc_wait( 100 );
+
+       /* Default to "CABLE" mode */
+       ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
+
+       return ret;
+}
+
+static int xc5000_sleep(struct dvb_frontend *fe)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       int ret;
+
+       dprintk(1, "%s()\n", __func__);
+
+       /* On Pinnacle PCTV HD 800i, the tuner cannot be reinitialized
+        * once shutdown without reloading the driver. Maybe I am not
+        * doing something right.
+        *
+        */
+
+       ret = xc_shutdown(priv);
+       if(ret != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR
+                       "xc5000: %s() unable to shutdown tuner\n",
+                       __func__);
+               return -EREMOTEIO;
+       }
+       else {
+               /* priv->fwloaded = 0; */
+               return XC_RESULT_SUCCESS;
+       }
+}
+
+static int xc5000_init(struct dvb_frontend *fe)
+{
+       struct xc5000_priv *priv = fe->tuner_priv;
+       dprintk(1, "%s()\n", __func__);
+
+       if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
+               printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
+               return -EREMOTEIO;
+       }
+
+       if (debug)
+               xc_debug_dump(priv);
+
+       return 0;
+}
+
+static int xc5000_release(struct dvb_frontend *fe)
+{
+       dprintk(1, "%s()\n", __func__);
+       kfree(fe->tuner_priv);
+       fe->tuner_priv = NULL;
+       return 0;
+}
+
+static const struct dvb_tuner_ops xc5000_tuner_ops = {
+       .info = {
+               .name           = "Xceive XC5000",
+               .frequency_min  =    1000000,
+               .frequency_max  = 1023000000,
+               .frequency_step =      50000,
+       },
+
+       .release           = xc5000_release,
+       .init              = xc5000_init,
+       .sleep             = xc5000_sleep,
+
+       .set_params        = xc5000_set_params,
+       .set_analog_params = xc5000_set_analog_params,
+       .get_frequency     = xc5000_get_frequency,
+       .get_bandwidth     = xc5000_get_bandwidth,
+       .get_status        = xc5000_get_status
+};
+
+struct dvb_frontend * xc5000_attach(struct dvb_frontend *fe,
+       struct i2c_adapter *i2c,
+       struct xc5000_config *cfg)
+{
+       struct xc5000_priv *priv = NULL;
+       u16 id = 0;
+
+       dprintk(1, "%s()\n", __func__);
+
+       priv = kzalloc(sizeof(struct xc5000_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return NULL;
+
+       priv->cfg = cfg;
+       priv->bandwidth = BANDWIDTH_6_MHZ;
+       priv->i2c = i2c;
+
+       /* Check if firmware has been loaded. It is possible that another
+          instance of the driver has loaded the firmware.
+        */
+       if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) {
+               kfree(priv);
+               return NULL;
+       }
+
+       switch(id) {
+       case XC_PRODUCT_ID_FW_LOADED:
+               printk(KERN_INFO
+                       "xc5000: Successfully identified at address 0x%02x\n",
+                       cfg->i2c_address);
+               printk(KERN_INFO
+                       "xc5000: Firmware has been loaded previously\n");
+               priv->fwloaded = 1;
+               break;
+       case XC_PRODUCT_ID_FW_NOT_LOADED:
+               printk(KERN_INFO
+                       "xc5000: Successfully identified at address 0x%02x\n",
+                       cfg->i2c_address);
+               printk(KERN_INFO
+                       "xc5000: Firmware has not been loaded previously\n");
+               priv->fwloaded = 0;
+               break;
+       default:
+               printk(KERN_ERR
+                       "xc5000: Device not found at addr 0x%02x (0x%x)\n",
+                       cfg->i2c_address, id);
+               kfree(priv);
+               return NULL;
+       }
+
+       memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
+               sizeof(struct dvb_tuner_ops));
+
+       fe->tuner_priv = priv;
+
+       return fe;
+}
+EXPORT_SYMBOL(xc5000_attach);
+
+MODULE_AUTHOR("Steven Toth");
+MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/common/tuners/xc5000.h b/drivers/media/common/tuners/xc5000.h
new file mode 100644 (file)
index 0000000..b890883
--- /dev/null
@@ -0,0 +1,63 @@
+/*
+ *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
+ *
+ *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __XC5000_H__
+#define __XC5000_H__
+
+#include <linux/firmware.h>
+
+struct dvb_frontend;
+struct i2c_adapter;
+
+struct xc5000_config {
+       u8   i2c_address;
+       u32  if_khz;
+
+       /* For each bridge framework, when it attaches either analog or digital,
+        * it has to store a reference back to its _core equivalent structure,
+        * so that it can service the hardware by steering gpio's etc.
+        * Each bridge implementation is different so cast priv accordingly.
+        * The xc5000 driver cares not for this value, other than ensuring
+        * it's passed back to a bridge during tuner_callback().
+        */
+       void *priv;
+       int  (*tuner_callback) (void *priv, int command, int arg);
+};
+
+/* xc5000 callback command */
+#define XC5000_TUNER_RESET             0
+
+#if defined(CONFIG_DVB_TUNER_XC5000) || \
+    (defined(CONFIG_DVB_TUNER_XC5000_MODULE) && defined(MODULE))
+extern struct dvb_frontend* xc5000_attach(struct dvb_frontend *fe,
+                                         struct i2c_adapter *i2c,
+                                         struct xc5000_config *cfg);
+#else
+static inline struct dvb_frontend* xc5000_attach(struct dvb_frontend *fe,
+                                                struct i2c_adapter *i2c,
+                                                struct xc5000_config *cfg)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
+       return NULL;
+}
+#endif // CONFIG_DVB_TUNER_XC5000
+
+#endif // __XC5000_H__
diff --git a/drivers/media/common/tuners/xc5000_priv.h b/drivers/media/common/tuners/xc5000_priv.h
new file mode 100644 (file)
index 0000000..13b2d19
--- /dev/null
@@ -0,0 +1,36 @@
+/*
+ *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
+ *
+ *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef XC5000_PRIV_H
+#define XC5000_PRIV_H
+
+struct xc5000_priv {
+       struct xc5000_config *cfg;
+       struct i2c_adapter   *i2c;
+
+       u32 freq_hz;
+       u32 bandwidth;
+       u8  video_standard;
+       u8  rf_mode;
+       u8  fwloaded;
+};
+
+#endif
index 03ef88acd9b826bbafc60ccad5a12be6e0302ceb..7b21b49f1945ad56430f6bf16ac99bdaed89f52b 100644 (file)
@@ -1,9 +1,7 @@
 #
-# Multimedia device configuration
+# DVB device configuration
 #
 
-source "drivers/media/dvb/dvb-core/Kconfig"
-
 menuconfig DVB_CAPTURE_DRIVERS
        bool "DVB/ATSC adapters"
        depends on DVB_CORE
index 870e2848c2962418b343ef2ae4ae5fcc561c0a5d..d9db066f9854f19a7572848b8834c0c1c29ee6a0 100644 (file)
@@ -14,4 +14,4 @@ b2c2-flexcop-usb-objs = flexcop-usb.o
 obj-$(CONFIG_DVB_B2C2_FLEXCOP_USB) += b2c2-flexcop-usb.o
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
-EXTRA_CFLAGS += -Idrivers/media/video/
+EXTRA_CFLAGS += -Idrivers/media/common/tuners/
index 9d3e68b5d6ebc22e9b8fb4adfdbf42aa50784d20..d98f1d49ffa89bab91f5c936189b7adc445f1c80 100644 (file)
@@ -3,4 +3,4 @@ obj-$(CONFIG_DVB_BT8XX) += bt878.o dvb-bt8xx.o dst.o dst_ca.o
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 EXTRA_CFLAGS += -Idrivers/media/video/bt8xx
-EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
diff --git a/drivers/media/dvb/dvb-core/Kconfig b/drivers/media/dvb/dvb-core/Kconfig
deleted file mode 100644 (file)
index e3e6839..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-config DVB_CORE
-       tristate "DVB for Linux"
-       depends on NET && INET
-       select CRC32
-       help
-         Support Digital Video Broadcasting hardware.  Enable this if you
-         own a DVB adapter and want to use it or if you compile Linux for
-         a digital SetTopBox.
-
-         DVB core utility functions for device handling, software fallbacks etc.
-         Say Y when you have a DVB card and want to use it. Say Y if your want
-         to build your drivers outside the kernel, but need the DVB core. All
-         in-kernel drivers will select this automatically if needed.
-
-         API specs and user tools are available from <http://www.linuxtv.org/>.
-
-         Please report problems regarding this driver to the LinuxDVB
-         mailing list.
-
-         If unsure say N.
-
-config DVB_CORE_ATTACH
-       bool "Load and attach frontend modules as needed"
-       depends on DVB_CORE
-       depends on MODULES
-       help
-         Remove the static dependency of DVB card drivers on all
-         frontend modules for all possible card variants. Instead,
-         allow the card drivers to only load the frontend modules
-         they require. This saves several KBytes of memory.
-
-         Note: You will need module-init-tools v3.2 or later for this feature.
-
-         If unsure say Y.
index 60a910052c16fa0c0488214b5daadd36782e38a5..c6511a6c0ab82dbd9d429d31991c72657ff74a18 100644 (file)
@@ -63,5 +63,5 @@ obj-$(CONFIG_DVB_USB_AF9005_REMOTE) += dvb-usb-af9005-remote.o
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/ -Idrivers/media/dvb/frontends/
 # due to tuner-xc3028
-EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 
index f5fceb3cdb3cb0d71b34e7fa8a1bc272cc04f65e..75e7d20b2984c1659148641f6314c13716dd6a99 100644 (file)
@@ -333,20 +333,6 @@ config DVB_TDA826X
        help
          A DVB-S silicon tuner module. Say Y when you want to support this tuner.
 
-config DVB_TDA827X
-       tristate "Philips TDA827X silicon tuner"
-       depends on DVB_CORE && I2C
-       default m if DVB_FE_CUSTOMISE
-       help
-         A DVB-T silicon tuner module. Say Y when you want to support this tuner.
-
-config DVB_TDA18271
-       tristate "NXP TDA18271 silicon tuner"
-       depends on I2C
-       default m if DVB_FE_CUSTOMISE
-       help
-         A silicon tuner module. Say Y when you want to support this tuner.
-
 config DVB_TUNER_QT1010
        tristate "Quantek QT1010 silicon tuner"
        depends on DVB_CORE && I2C
@@ -384,15 +370,6 @@ config DVB_TUNER_DIB0070
          This device is only used inside a SiP called togther with a
          demodulator for now.
 
-config DVB_TUNER_XC5000
-       tristate "Xceive XC5000 silicon tuner"
-       depends on I2C
-       default m if DVB_FE_CUSTOMISE
-       help
-         A driver for the silicon tuner XC5000 from Xceive.
-         This device is only used inside a SiP called togther with a
-         demodulator for now.
-
 config DVB_TUNER_ITD1000
        tristate "Integrant ITD1000 Zero IF tuner for DVB-S/DSS"
        depends on DVB_CORE && I2C
index 9747c73dc8269c78c9d8c4e6e7aecbb0a6dded15..9b4438a13d0b50eaece2f57569d26b8e51eb6517 100644 (file)
@@ -3,9 +3,7 @@
 #
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core/
-EXTRA_CFLAGS += -Idrivers/media/video/
-
-tda18271-objs := tda18271-tables.o tda18271-common.o tda18271-fe.o
+EXTRA_CFLAGS += -Idrivers/media/common/tuners/
 
 obj-$(CONFIG_DVB_PLL) += dvb-pll.o
 obj-$(CONFIG_DVB_STV0299) += stv0299.o
@@ -42,8 +40,6 @@ obj-$(CONFIG_DVB_ISL6405) += isl6405.o
 obj-$(CONFIG_DVB_ISL6421) += isl6421.o
 obj-$(CONFIG_DVB_TDA10086) += tda10086.o
 obj-$(CONFIG_DVB_TDA826X) += tda826x.o
-obj-$(CONFIG_DVB_TDA827X) += tda827x.o
-obj-$(CONFIG_DVB_TDA18271) += tda18271.o
 obj-$(CONFIG_DVB_TUNER_MT2060) += mt2060.o
 obj-$(CONFIG_DVB_TUNER_MT2266) += mt2266.o
 obj-$(CONFIG_DVB_TUNER_DIB0070) += dib0070.o
@@ -51,7 +47,6 @@ obj-$(CONFIG_DVB_TUNER_QT1010) += qt1010.o
 obj-$(CONFIG_DVB_TUA6100) += tua6100.o
 obj-$(CONFIG_DVB_TUNER_MT2131) += mt2131.o
 obj-$(CONFIG_DVB_S5H1409) += s5h1409.o
-obj-$(CONFIG_DVB_TUNER_XC5000) += xc5000.o
 obj-$(CONFIG_DVB_TUNER_ITD1000) += itd1000.o
 obj-$(CONFIG_DVB_AU8522) += au8522.o
 obj-$(CONFIG_DVB_TDA10048) += tda10048.o
diff --git a/drivers/media/dvb/frontends/tda18271-common.c b/drivers/media/dvb/frontends/tda18271-common.c
deleted file mode 100644 (file)
index e27a762..0000000
+++ /dev/null
@@ -1,666 +0,0 @@
-/*
-    tda18271-common.c - driver for the Philips / NXP TDA18271 silicon tuner
-
-    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include "tda18271-priv.h"
-
-static int tda18271_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       enum tda18271_i2c_gate gate;
-       int ret = 0;
-
-       switch (priv->gate) {
-       case TDA18271_GATE_DIGITAL:
-       case TDA18271_GATE_ANALOG:
-               gate = priv->gate;
-               break;
-       case TDA18271_GATE_AUTO:
-       default:
-               switch (priv->mode) {
-               case TDA18271_DIGITAL:
-                       gate = TDA18271_GATE_DIGITAL;
-                       break;
-               case TDA18271_ANALOG:
-               default:
-                       gate = TDA18271_GATE_ANALOG;
-                       break;
-               }
-       }
-
-       switch (gate) {
-       case TDA18271_GATE_ANALOG:
-               if (fe->ops.analog_ops.i2c_gate_ctrl)
-                       ret = fe->ops.analog_ops.i2c_gate_ctrl(fe, enable);
-               break;
-       case TDA18271_GATE_DIGITAL:
-               if (fe->ops.i2c_gate_ctrl)
-                       ret = fe->ops.i2c_gate_ctrl(fe, enable);
-               break;
-       default:
-               ret = -EINVAL;
-               break;
-       }
-
-       return ret;
-};
-
-/*---------------------------------------------------------------------*/
-
-static void tda18271_dump_regs(struct dvb_frontend *fe, int extended)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       tda_reg("=== TDA18271 REG DUMP ===\n");
-       tda_reg("ID_BYTE            = 0x%02x\n", 0xff & regs[R_ID]);
-       tda_reg("THERMO_BYTE        = 0x%02x\n", 0xff & regs[R_TM]);
-       tda_reg("POWER_LEVEL_BYTE   = 0x%02x\n", 0xff & regs[R_PL]);
-       tda_reg("EASY_PROG_BYTE_1   = 0x%02x\n", 0xff & regs[R_EP1]);
-       tda_reg("EASY_PROG_BYTE_2   = 0x%02x\n", 0xff & regs[R_EP2]);
-       tda_reg("EASY_PROG_BYTE_3   = 0x%02x\n", 0xff & regs[R_EP3]);
-       tda_reg("EASY_PROG_BYTE_4   = 0x%02x\n", 0xff & regs[R_EP4]);
-       tda_reg("EASY_PROG_BYTE_5   = 0x%02x\n", 0xff & regs[R_EP5]);
-       tda_reg("CAL_POST_DIV_BYTE  = 0x%02x\n", 0xff & regs[R_CPD]);
-       tda_reg("CAL_DIV_BYTE_1     = 0x%02x\n", 0xff & regs[R_CD1]);
-       tda_reg("CAL_DIV_BYTE_2     = 0x%02x\n", 0xff & regs[R_CD2]);
-       tda_reg("CAL_DIV_BYTE_3     = 0x%02x\n", 0xff & regs[R_CD3]);
-       tda_reg("MAIN_POST_DIV_BYTE = 0x%02x\n", 0xff & regs[R_MPD]);
-       tda_reg("MAIN_DIV_BYTE_1    = 0x%02x\n", 0xff & regs[R_MD1]);
-       tda_reg("MAIN_DIV_BYTE_2    = 0x%02x\n", 0xff & regs[R_MD2]);
-       tda_reg("MAIN_DIV_BYTE_3    = 0x%02x\n", 0xff & regs[R_MD3]);
-
-       /* only dump extended regs if DBG_ADV is set */
-       if (!(tda18271_debug & DBG_ADV))
-               return;
-
-       /* W indicates write-only registers.
-        * Register dump for write-only registers shows last value written. */
-
-       tda_reg("EXTENDED_BYTE_1    = 0x%02x\n", 0xff & regs[R_EB1]);
-       tda_reg("EXTENDED_BYTE_2    = 0x%02x\n", 0xff & regs[R_EB2]);
-       tda_reg("EXTENDED_BYTE_3    = 0x%02x\n", 0xff & regs[R_EB3]);
-       tda_reg("EXTENDED_BYTE_4    = 0x%02x\n", 0xff & regs[R_EB4]);
-       tda_reg("EXTENDED_BYTE_5    = 0x%02x\n", 0xff & regs[R_EB5]);
-       tda_reg("EXTENDED_BYTE_6    = 0x%02x\n", 0xff & regs[R_EB6]);
-       tda_reg("EXTENDED_BYTE_7    = 0x%02x\n", 0xff & regs[R_EB7]);
-       tda_reg("EXTENDED_BYTE_8    = 0x%02x\n", 0xff & regs[R_EB8]);
-       tda_reg("EXTENDED_BYTE_9  W = 0x%02x\n", 0xff & regs[R_EB9]);
-       tda_reg("EXTENDED_BYTE_10   = 0x%02x\n", 0xff & regs[R_EB10]);
-       tda_reg("EXTENDED_BYTE_11   = 0x%02x\n", 0xff & regs[R_EB11]);
-       tda_reg("EXTENDED_BYTE_12   = 0x%02x\n", 0xff & regs[R_EB12]);
-       tda_reg("EXTENDED_BYTE_13   = 0x%02x\n", 0xff & regs[R_EB13]);
-       tda_reg("EXTENDED_BYTE_14   = 0x%02x\n", 0xff & regs[R_EB14]);
-       tda_reg("EXTENDED_BYTE_15   = 0x%02x\n", 0xff & regs[R_EB15]);
-       tda_reg("EXTENDED_BYTE_16 W = 0x%02x\n", 0xff & regs[R_EB16]);
-       tda_reg("EXTENDED_BYTE_17 W = 0x%02x\n", 0xff & regs[R_EB17]);
-       tda_reg("EXTENDED_BYTE_18   = 0x%02x\n", 0xff & regs[R_EB18]);
-       tda_reg("EXTENDED_BYTE_19 W = 0x%02x\n", 0xff & regs[R_EB19]);
-       tda_reg("EXTENDED_BYTE_20 W = 0x%02x\n", 0xff & regs[R_EB20]);
-       tda_reg("EXTENDED_BYTE_21   = 0x%02x\n", 0xff & regs[R_EB21]);
-       tda_reg("EXTENDED_BYTE_22   = 0x%02x\n", 0xff & regs[R_EB22]);
-       tda_reg("EXTENDED_BYTE_23   = 0x%02x\n", 0xff & regs[R_EB23]);
-}
-
-int tda18271_read_regs(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       unsigned char buf = 0x00;
-       int ret;
-       struct i2c_msg msg[] = {
-               { .addr = priv->i2c_props.addr, .flags = 0,
-                 .buf = &buf, .len = 1 },
-               { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
-                 .buf = regs, .len = 16 }
-       };
-
-       tda18271_i2c_gate_ctrl(fe, 1);
-
-       /* read all registers */
-       ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
-
-       tda18271_i2c_gate_ctrl(fe, 0);
-
-       if (ret != 2)
-               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
-
-       if (tda18271_debug & DBG_REG)
-               tda18271_dump_regs(fe, 0);
-
-       return (ret == 2 ? 0 : ret);
-}
-
-int tda18271_read_extended(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       unsigned char regdump[TDA18271_NUM_REGS];
-       unsigned char buf = 0x00;
-       int ret, i;
-       struct i2c_msg msg[] = {
-               { .addr = priv->i2c_props.addr, .flags = 0,
-                 .buf = &buf, .len = 1 },
-               { .addr = priv->i2c_props.addr, .flags = I2C_M_RD,
-                 .buf = regdump, .len = TDA18271_NUM_REGS }
-       };
-
-       tda18271_i2c_gate_ctrl(fe, 1);
-
-       /* read all registers */
-       ret = i2c_transfer(priv->i2c_props.adap, msg, 2);
-
-       tda18271_i2c_gate_ctrl(fe, 0);
-
-       if (ret != 2)
-               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
-
-       for (i = 0; i < TDA18271_NUM_REGS; i++) {
-               /* don't update write-only registers */
-               if ((i != R_EB9)  &&
-                   (i != R_EB16) &&
-                   (i != R_EB17) &&
-                   (i != R_EB19) &&
-                   (i != R_EB20))
-               regs[i] = regdump[i];
-       }
-
-       if (tda18271_debug & DBG_REG)
-               tda18271_dump_regs(fe, 1);
-
-       return (ret == 2 ? 0 : ret);
-}
-
-int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       unsigned char buf[TDA18271_NUM_REGS + 1];
-       struct i2c_msg msg = { .addr = priv->i2c_props.addr, .flags = 0,
-                              .buf = buf, .len = len + 1 };
-       int i, ret;
-
-       BUG_ON((len == 0) || (idx + len > sizeof(buf)));
-
-       buf[0] = idx;
-       for (i = 1; i <= len; i++)
-               buf[i] = regs[idx - 1 + i];
-
-       tda18271_i2c_gate_ctrl(fe, 1);
-
-       /* write registers */
-       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
-
-       tda18271_i2c_gate_ctrl(fe, 0);
-
-       if (ret != 1)
-               tda_err("ERROR: i2c_transfer returned: %d\n", ret);
-
-       return (ret == 1 ? 0 : ret);
-}
-
-/*---------------------------------------------------------------------*/
-
-int tda18271_charge_pump_source(struct dvb_frontend *fe,
-                               enum tda18271_pll pll, int force)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       int r_cp = (pll == TDA18271_CAL_PLL) ? R_EB7 : R_EB4;
-
-       regs[r_cp] &= ~0x20;
-       regs[r_cp] |= ((force & 1) << 5);
-       tda18271_write_regs(fe, r_cp, 1);
-
-       return 0;
-}
-
-int tda18271_init_regs(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       tda_dbg("initializing registers for device @ %d-%04x\n",
-               i2c_adapter_id(priv->i2c_props.adap),
-               priv->i2c_props.addr);
-
-       /* initialize registers */
-       switch (priv->id) {
-       case TDA18271HDC1:
-               regs[R_ID]   = 0x83;
-               break;
-       case TDA18271HDC2:
-               regs[R_ID]   = 0x84;
-               break;
-       };
-
-       regs[R_TM]   = 0x08;
-       regs[R_PL]   = 0x80;
-       regs[R_EP1]  = 0xc6;
-       regs[R_EP2]  = 0xdf;
-       regs[R_EP3]  = 0x16;
-       regs[R_EP4]  = 0x60;
-       regs[R_EP5]  = 0x80;
-       regs[R_CPD]  = 0x80;
-       regs[R_CD1]  = 0x00;
-       regs[R_CD2]  = 0x00;
-       regs[R_CD3]  = 0x00;
-       regs[R_MPD]  = 0x00;
-       regs[R_MD1]  = 0x00;
-       regs[R_MD2]  = 0x00;
-       regs[R_MD3]  = 0x00;
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               regs[R_EB1]  = 0xff;
-               break;
-       case TDA18271HDC2:
-               regs[R_EB1]  = 0xfc;
-               break;
-       };
-
-       regs[R_EB2]  = 0x01;
-       regs[R_EB3]  = 0x84;
-       regs[R_EB4]  = 0x41;
-       regs[R_EB5]  = 0x01;
-       regs[R_EB6]  = 0x84;
-       regs[R_EB7]  = 0x40;
-       regs[R_EB8]  = 0x07;
-       regs[R_EB9]  = 0x00;
-       regs[R_EB10] = 0x00;
-       regs[R_EB11] = 0x96;
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               regs[R_EB12] = 0x0f;
-               break;
-       case TDA18271HDC2:
-               regs[R_EB12] = 0x33;
-               break;
-       };
-
-       regs[R_EB13] = 0xc1;
-       regs[R_EB14] = 0x00;
-       regs[R_EB15] = 0x8f;
-       regs[R_EB16] = 0x00;
-       regs[R_EB17] = 0x00;
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               regs[R_EB18] = 0x00;
-               break;
-       case TDA18271HDC2:
-               regs[R_EB18] = 0x8c;
-               break;
-       };
-
-       regs[R_EB19] = 0x00;
-       regs[R_EB20] = 0x20;
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               regs[R_EB21] = 0x33;
-               break;
-       case TDA18271HDC2:
-               regs[R_EB21] = 0xb3;
-               break;
-       };
-
-       regs[R_EB22] = 0x48;
-       regs[R_EB23] = 0xb0;
-
-       if (priv->small_i2c) {
-               tda18271_write_regs(fe, 0x00, 0x10);
-               tda18271_write_regs(fe, 0x10, 0x10);
-               tda18271_write_regs(fe, 0x20, 0x07);
-       } else
-               tda18271_write_regs(fe, 0x00, TDA18271_NUM_REGS);
-
-       /* setup agc1 gain */
-       regs[R_EB17] = 0x00;
-       tda18271_write_regs(fe, R_EB17, 1);
-       regs[R_EB17] = 0x03;
-       tda18271_write_regs(fe, R_EB17, 1);
-       regs[R_EB17] = 0x43;
-       tda18271_write_regs(fe, R_EB17, 1);
-       regs[R_EB17] = 0x4c;
-       tda18271_write_regs(fe, R_EB17, 1);
-
-       /* setup agc2 gain */
-       if ((priv->id) == TDA18271HDC1) {
-               regs[R_EB20] = 0xa0;
-               tda18271_write_regs(fe, R_EB20, 1);
-               regs[R_EB20] = 0xa7;
-               tda18271_write_regs(fe, R_EB20, 1);
-               regs[R_EB20] = 0xe7;
-               tda18271_write_regs(fe, R_EB20, 1);
-               regs[R_EB20] = 0xec;
-               tda18271_write_regs(fe, R_EB20, 1);
-       }
-
-       /* image rejection calibration */
-
-       /* low-band */
-       regs[R_EP3] = 0x1f;
-       regs[R_EP4] = 0x66;
-       regs[R_EP5] = 0x81;
-       regs[R_CPD] = 0xcc;
-       regs[R_CD1] = 0x6c;
-       regs[R_CD2] = 0x00;
-       regs[R_CD3] = 0x00;
-       regs[R_MPD] = 0xcd;
-       regs[R_MD1] = 0x77;
-       regs[R_MD2] = 0x08;
-       regs[R_MD3] = 0x00;
-
-       tda18271_write_regs(fe, R_EP3, 11);
-
-       if ((priv->id) == TDA18271HDC2) {
-               /* main pll cp source on */
-               tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
-               msleep(1);
-
-               /* main pll cp source off */
-               tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
-       }
-
-       msleep(5); /* pll locking */
-
-       /* launch detector */
-       tda18271_write_regs(fe, R_EP1, 1);
-       msleep(5); /* wanted low measurement */
-
-       regs[R_EP5] = 0x85;
-       regs[R_CPD] = 0xcb;
-       regs[R_CD1] = 0x66;
-       regs[R_CD2] = 0x70;
-
-       tda18271_write_regs(fe, R_EP3, 7);
-       msleep(5); /* pll locking */
-
-       /* launch optimization algorithm */
-       tda18271_write_regs(fe, R_EP2, 1);
-       msleep(30); /* image low optimization completion */
-
-       /* mid-band */
-       regs[R_EP5] = 0x82;
-       regs[R_CPD] = 0xa8;
-       regs[R_CD2] = 0x00;
-       regs[R_MPD] = 0xa9;
-       regs[R_MD1] = 0x73;
-       regs[R_MD2] = 0x1a;
-
-       tda18271_write_regs(fe, R_EP3, 11);
-       msleep(5); /* pll locking */
-
-       /* launch detector */
-       tda18271_write_regs(fe, R_EP1, 1);
-       msleep(5); /* wanted mid measurement */
-
-       regs[R_EP5] = 0x86;
-       regs[R_CPD] = 0xa8;
-       regs[R_CD1] = 0x66;
-       regs[R_CD2] = 0xa0;
-
-       tda18271_write_regs(fe, R_EP3, 7);
-       msleep(5); /* pll locking */
-
-       /* launch optimization algorithm */
-       tda18271_write_regs(fe, R_EP2, 1);
-       msleep(30); /* image mid optimization completion */
-
-       /* high-band */
-       regs[R_EP5] = 0x83;
-       regs[R_CPD] = 0x98;
-       regs[R_CD1] = 0x65;
-       regs[R_CD2] = 0x00;
-       regs[R_MPD] = 0x99;
-       regs[R_MD1] = 0x71;
-       regs[R_MD2] = 0xcd;
-
-       tda18271_write_regs(fe, R_EP3, 11);
-       msleep(5); /* pll locking */
-
-       /* launch detector */
-       tda18271_write_regs(fe, R_EP1, 1);
-       msleep(5); /* wanted high measurement */
-
-       regs[R_EP5] = 0x87;
-       regs[R_CD1] = 0x65;
-       regs[R_CD2] = 0x50;
-
-       tda18271_write_regs(fe, R_EP3, 7);
-       msleep(5); /* pll locking */
-
-       /* launch optimization algorithm */
-       tda18271_write_regs(fe, R_EP2, 1);
-       msleep(30); /* image high optimization completion */
-
-       /* return to normal mode */
-       regs[R_EP4] = 0x64;
-       tda18271_write_regs(fe, R_EP4, 1);
-
-       /* synchronize */
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       return 0;
-}
-
-/*---------------------------------------------------------------------*/
-
-/*
- *  Standby modes, EP3 [7:5]
- *
- *  | SM  || SM_LT || SM_XT || mode description
- *  |=====\\=======\\=======\\===================================
- *  |  0  ||   0   ||   0   || normal mode
- *  |-----||-------||-------||-----------------------------------
- *  |     ||       ||       || standby mode w/ slave tuner output
- *  |  1  ||   0   ||   0   || & loop thru & xtal oscillator on
- *  |-----||-------||-------||-----------------------------------
- *  |  1  ||   1   ||   0   || standby mode w/ xtal oscillator on
- *  |-----||-------||-------||-----------------------------------
- *  |  1  ||   1   ||   1   || power off
- *
- */
-
-int tda18271_set_standby_mode(struct dvb_frontend *fe,
-                             int sm, int sm_lt, int sm_xt)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       tda_dbg("sm = %d, sm_lt = %d, sm_xt = %d\n", sm, sm_lt, sm_xt);
-
-       regs[R_EP3]  &= ~0xe0; /* clear sm, sm_lt, sm_xt */
-       regs[R_EP3]  |= sm    ? (1 << 7) : 0 |
-                       sm_lt ? (1 << 6) : 0 |
-                       sm_xt ? (1 << 5) : 0;
-
-       tda18271_write_regs(fe, R_EP3, 1);
-
-       return 0;
-}
-
-/*---------------------------------------------------------------------*/
-
-int tda18271_calc_main_pll(struct dvb_frontend *fe, u32 freq)
-{
-       /* sets main post divider & divider bytes, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 d, pd;
-       u32 div;
-
-       int ret = tda18271_lookup_pll_map(fe, MAIN_PLL, &freq, &pd, &d);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_MPD]   = (0x77 & pd);
-
-       switch (priv->mode) {
-       case TDA18271_ANALOG:
-               regs[R_MPD]  &= ~0x08;
-               break;
-       case TDA18271_DIGITAL:
-               regs[R_MPD]  |=  0x08;
-               break;
-       }
-
-       div =  ((d * (freq / 1000)) << 7) / 125;
-
-       regs[R_MD1]   = 0x7f & (div >> 16);
-       regs[R_MD2]   = 0xff & (div >> 8);
-       regs[R_MD3]   = 0xff & div;
-fail:
-       return ret;
-}
-
-int tda18271_calc_cal_pll(struct dvb_frontend *fe, u32 freq)
-{
-       /* sets cal post divider & divider bytes, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 d, pd;
-       u32 div;
-
-       int ret = tda18271_lookup_pll_map(fe, CAL_PLL, &freq, &pd, &d);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_CPD]   = pd;
-
-       div =  ((d * (freq / 1000)) << 7) / 125;
-
-       regs[R_CD1]   = 0x7f & (div >> 16);
-       regs[R_CD2]   = 0xff & (div >> 8);
-       regs[R_CD3]   = 0xff & div;
-fail:
-       return ret;
-}
-
-/*---------------------------------------------------------------------*/
-
-int tda18271_calc_bp_filter(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets bp filter bits, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       int ret = tda18271_lookup_map(fe, BP_FILTER, freq, &val);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_EP1]  &= ~0x07; /* clear bp filter bits */
-       regs[R_EP1]  |= (0x07 & val);
-fail:
-       return ret;
-}
-
-int tda18271_calc_km(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets K & M bits, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       int ret = tda18271_lookup_map(fe, RF_CAL_KMCO, freq, &val);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_EB13] &= ~0x7c; /* clear k & m bits */
-       regs[R_EB13] |= (0x7c & val);
-fail:
-       return ret;
-}
-
-int tda18271_calc_rf_band(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets rf band bits, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       int ret = tda18271_lookup_map(fe, RF_BAND, freq, &val);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_EP2]  &= ~0xe0; /* clear rf band bits */
-       regs[R_EP2]  |= (0xe0 & (val << 5));
-fail:
-       return ret;
-}
-
-int tda18271_calc_gain_taper(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets gain taper bits, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       int ret = tda18271_lookup_map(fe, GAIN_TAPER, freq, &val);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_EP2]  &= ~0x1f; /* clear gain taper bits */
-       regs[R_EP2]  |= (0x1f & val);
-fail:
-       return ret;
-}
-
-int tda18271_calc_ir_measure(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets IR Meas bits, but does not write them */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       int ret = tda18271_lookup_map(fe, IR_MEASURE, freq, &val);
-       if (ret < 0)
-               goto fail;
-
-       regs[R_EP5] &= ~0x07;
-       regs[R_EP5] |= (0x07 & val);
-fail:
-       return ret;
-}
-
-int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq)
-{
-       /* sets rf cal byte (RFC_Cprog), but does not write it */
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u8 val;
-
-       tda18271_lookup_map(fe, RF_CAL, freq, &val);
-
-       regs[R_EB14] = val;
-
-       return 0;
-}
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/dvb/frontends/tda18271-fe.c b/drivers/media/dvb/frontends/tda18271-fe.c
deleted file mode 100644 (file)
index b262100..0000000
+++ /dev/null
@@ -1,1153 +0,0 @@
-/*
-    tda18271-fe.c - driver for the Philips / NXP TDA18271 silicon tuner
-
-    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include <linux/delay.h>
-#include <linux/videodev2.h>
-#include "tda18271-priv.h"
-
-int tda18271_debug;
-module_param_named(debug, tda18271_debug, int, 0644);
-MODULE_PARM_DESC(debug, "set debug level "
-                "(info=1, map=2, reg=4, adv=8, cal=16 (or-able))");
-
-static int tda18271_cal_on_startup;
-module_param_named(cal, tda18271_cal_on_startup, int, 0644);
-MODULE_PARM_DESC(cal, "perform RF tracking filter calibration on startup");
-
-static DEFINE_MUTEX(tda18271_list_mutex);
-static LIST_HEAD(hybrid_tuner_instance_list);
-
-/*---------------------------------------------------------------------*/
-
-static inline int charge_pump_source(struct dvb_frontend *fe, int force)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       return tda18271_charge_pump_source(fe,
-                                          (priv->role == TDA18271_SLAVE) ?
-                                          TDA18271_CAL_PLL :
-                                          TDA18271_MAIN_PLL, force);
-}
-
-static int tda18271_channel_configuration(struct dvb_frontend *fe,
-                                         struct tda18271_std_map_item *map,
-                                         u32 freq, u32 bw)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u32 N;
-
-       /* update TV broadcast parameters */
-
-       /* set standard */
-       regs[R_EP3]  &= ~0x1f; /* clear std bits */
-       regs[R_EP3]  |= (map->agc_mode << 3) | map->std;
-
-       /* set rfagc to high speed mode */
-       regs[R_EP3] &= ~0x04;
-
-       /* set cal mode to normal */
-       regs[R_EP4]  &= ~0x03;
-
-       /* update IF output level & IF notch frequency */
-       regs[R_EP4]  &= ~0x1c; /* clear if level bits */
-       regs[R_EP4]  |= (map->if_lvl << 2);
-
-       switch (priv->mode) {
-       case TDA18271_ANALOG:
-               regs[R_MPD]  &= ~0x80; /* IF notch = 0 */
-               break;
-       case TDA18271_DIGITAL:
-               regs[R_MPD]  |= 0x80; /* IF notch = 1 */
-               break;
-       }
-
-       /* update FM_RFn */
-       regs[R_EP4]  &= ~0x80;
-       regs[R_EP4]  |= map->fm_rfn << 7;
-
-       /* update rf top / if top */
-       regs[R_EB22]  = 0x00;
-       regs[R_EB22] |= map->rfagc_top;
-       tda18271_write_regs(fe, R_EB22, 1);
-
-       /* --------------------------------------------------------------- */
-
-       /* disable Power Level Indicator */
-       regs[R_EP1]  |= 0x40;
-
-       /* frequency dependent parameters */
-
-       tda18271_calc_ir_measure(fe, &freq);
-
-       tda18271_calc_bp_filter(fe, &freq);
-
-       tda18271_calc_rf_band(fe, &freq);
-
-       tda18271_calc_gain_taper(fe, &freq);
-
-       /* --------------------------------------------------------------- */
-
-       /* dual tuner and agc1 extra configuration */
-
-       switch (priv->role) {
-       case TDA18271_MASTER:
-               regs[R_EB1]  |= 0x04; /* main vco */
-               break;
-       case TDA18271_SLAVE:
-               regs[R_EB1]  &= ~0x04; /* cal vco */
-               break;
-       }
-
-       /* agc1 always active */
-       regs[R_EB1]  &= ~0x02;
-
-       /* agc1 has priority on agc2 */
-       regs[R_EB1]  &= ~0x01;
-
-       tda18271_write_regs(fe, R_EB1, 1);
-
-       /* --------------------------------------------------------------- */
-
-       N = map->if_freq * 1000 + freq;
-
-       switch (priv->role) {
-       case TDA18271_MASTER:
-               tda18271_calc_main_pll(fe, N);
-               tda18271_write_regs(fe, R_MPD, 4);
-               break;
-       case TDA18271_SLAVE:
-               tda18271_calc_cal_pll(fe, N);
-               tda18271_write_regs(fe, R_CPD, 4);
-
-               regs[R_MPD] = regs[R_CPD] & 0x7f;
-               tda18271_write_regs(fe, R_MPD, 1);
-               break;
-       }
-
-       tda18271_write_regs(fe, R_TM, 7);
-
-       /* force charge pump source */
-       charge_pump_source(fe, 1);
-
-       msleep(1);
-
-       /* return pll to normal operation */
-       charge_pump_source(fe, 0);
-
-       msleep(20);
-
-       /* set rfagc to normal speed mode */
-       if (map->fm_rfn)
-               regs[R_EP3] &= ~0x04;
-       else
-               regs[R_EP3] |= 0x04;
-       tda18271_write_regs(fe, R_EP3, 1);
-
-       return 0;
-}
-
-static int tda18271_read_thermometer(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       int tm;
-
-       /* switch thermometer on */
-       regs[R_TM]   |= 0x10;
-       tda18271_write_regs(fe, R_TM, 1);
-
-       /* read thermometer info */
-       tda18271_read_regs(fe);
-
-       if ((((regs[R_TM] & 0x0f) == 0x00) && ((regs[R_TM] & 0x20) == 0x20)) ||
-           (((regs[R_TM] & 0x0f) == 0x08) && ((regs[R_TM] & 0x20) == 0x00))) {
-
-               if ((regs[R_TM] & 0x20) == 0x20)
-                       regs[R_TM] &= ~0x20;
-               else
-                       regs[R_TM] |= 0x20;
-
-               tda18271_write_regs(fe, R_TM, 1);
-
-               msleep(10); /* temperature sensing */
-
-               /* read thermometer info */
-               tda18271_read_regs(fe);
-       }
-
-       tm = tda18271_lookup_thermometer(fe);
-
-       /* switch thermometer off */
-       regs[R_TM]   &= ~0x10;
-       tda18271_write_regs(fe, R_TM, 1);
-
-       /* set CAL mode to normal */
-       regs[R_EP4]  &= ~0x03;
-       tda18271_write_regs(fe, R_EP4, 1);
-
-       return tm;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda18271c2_rf_tracking_filters_correction(struct dvb_frontend *fe,
-                                                    u32 freq)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
-       unsigned char *regs = priv->tda18271_regs;
-       int tm_current, rfcal_comp, approx, i;
-       u8 dc_over_dt, rf_tab;
-
-       /* power up */
-       tda18271_set_standby_mode(fe, 0, 0, 0);
-
-       /* read die current temperature */
-       tm_current = tda18271_read_thermometer(fe);
-
-       /* frequency dependent parameters */
-
-       tda18271_calc_rf_cal(fe, &freq);
-       rf_tab = regs[R_EB14];
-
-       i = tda18271_lookup_rf_band(fe, &freq, NULL);
-       if (i < 0)
-               return -EINVAL;
-
-       if ((0 == map[i].rf3) || (freq / 1000 < map[i].rf2)) {
-               approx = map[i].rf_a1 *
-                       (freq / 1000 - map[i].rf1) + map[i].rf_b1 + rf_tab;
-       } else {
-               approx = map[i].rf_a2 *
-                       (freq / 1000 - map[i].rf2) + map[i].rf_b2 + rf_tab;
-       }
-
-       if (approx < 0)
-               approx = 0;
-       if (approx > 255)
-               approx = 255;
-
-       tda18271_lookup_map(fe, RF_CAL_DC_OVER_DT, &freq, &dc_over_dt);
-
-       /* calculate temperature compensation */
-       rfcal_comp = dc_over_dt * (tm_current - priv->tm_rfcal);
-
-       regs[R_EB14] = approx + rfcal_comp;
-       tda18271_write_regs(fe, R_EB14, 1);
-
-       return 0;
-}
-
-static int tda18271_por(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       /* power up detector 1 */
-       regs[R_EB12] &= ~0x20;
-       tda18271_write_regs(fe, R_EB12, 1);
-
-       regs[R_EB18] &= ~0x80; /* turn agc1 loop on */
-       regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
-       tda18271_write_regs(fe, R_EB18, 1);
-
-       regs[R_EB21] |= 0x03; /* set agc2_gain to -6 dB */
-
-       /* POR mode */
-       tda18271_set_standby_mode(fe, 1, 0, 0);
-
-       /* disable 1.5 MHz low pass filter */
-       regs[R_EB23] &= ~0x04; /* forcelp_fc2_en = 0 */
-       regs[R_EB23] &= ~0x02; /* XXX: lp_fc[2] = 0 */
-       tda18271_write_regs(fe, R_EB21, 3);
-
-       return 0;
-}
-
-static int tda18271_calibrate_rf(struct dvb_frontend *fe, u32 freq)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u32 N;
-
-       /* set CAL mode to normal */
-       regs[R_EP4]  &= ~0x03;
-       tda18271_write_regs(fe, R_EP4, 1);
-
-       /* switch off agc1 */
-       regs[R_EP3]  |= 0x40; /* sm_lt = 1 */
-
-       regs[R_EB18] |= 0x03; /* set agc1_gain to 15 dB */
-       tda18271_write_regs(fe, R_EB18, 1);
-
-       /* frequency dependent parameters */
-
-       tda18271_calc_bp_filter(fe, &freq);
-       tda18271_calc_gain_taper(fe, &freq);
-       tda18271_calc_rf_band(fe, &freq);
-       tda18271_calc_km(fe, &freq);
-
-       tda18271_write_regs(fe, R_EP1, 3);
-       tda18271_write_regs(fe, R_EB13, 1);
-
-       /* main pll charge pump source */
-       tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 1);
-
-       /* cal pll charge pump source */
-       tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 1);
-
-       /* force dcdc converter to 0 V */
-       regs[R_EB14] = 0x00;
-       tda18271_write_regs(fe, R_EB14, 1);
-
-       /* disable plls lock */
-       regs[R_EB20] &= ~0x20;
-       tda18271_write_regs(fe, R_EB20, 1);
-
-       /* set CAL mode to RF tracking filter calibration */
-       regs[R_EP4]  |= 0x03;
-       tda18271_write_regs(fe, R_EP4, 2);
-
-       /* --------------------------------------------------------------- */
-
-       /* set the internal calibration signal */
-       N = freq;
-
-       tda18271_calc_cal_pll(fe, N);
-       tda18271_write_regs(fe, R_CPD, 4);
-
-       /* downconvert internal calibration */
-       N += 1000000;
-
-       tda18271_calc_main_pll(fe, N);
-       tda18271_write_regs(fe, R_MPD, 4);
-
-       msleep(5);
-
-       tda18271_write_regs(fe, R_EP2, 1);
-       tda18271_write_regs(fe, R_EP1, 1);
-       tda18271_write_regs(fe, R_EP2, 1);
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       /* --------------------------------------------------------------- */
-
-       /* normal operation for the main pll */
-       tda18271_charge_pump_source(fe, TDA18271_MAIN_PLL, 0);
-
-       /* normal operation for the cal pll  */
-       tda18271_charge_pump_source(fe, TDA18271_CAL_PLL, 0);
-
-       msleep(10); /* plls locking */
-
-       /* launch the rf tracking filters calibration */
-       regs[R_EB20]  |= 0x20;
-       tda18271_write_regs(fe, R_EB20, 1);
-
-       msleep(60); /* calibration */
-
-       /* --------------------------------------------------------------- */
-
-       /* set CAL mode to normal */
-       regs[R_EP4]  &= ~0x03;
-
-       /* switch on agc1 */
-       regs[R_EP3]  &= ~0x40; /* sm_lt = 0 */
-
-       regs[R_EB18] &= ~0x03; /* set agc1_gain to  6 dB */
-       tda18271_write_regs(fe, R_EB18, 1);
-
-       tda18271_write_regs(fe, R_EP3, 2);
-
-       /* synchronization */
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       /* get calibration result */
-       tda18271_read_extended(fe);
-
-       return regs[R_EB14];
-}
-
-static int tda18271_powerscan(struct dvb_frontend *fe,
-                             u32 *freq_in, u32 *freq_out)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       int sgn, bcal, count, wait;
-       u8 cid_target;
-       u16 count_limit;
-       u32 freq;
-
-       freq = *freq_in;
-
-       tda18271_calc_rf_band(fe, &freq);
-       tda18271_calc_rf_cal(fe, &freq);
-       tda18271_calc_gain_taper(fe, &freq);
-       tda18271_lookup_cid_target(fe, &freq, &cid_target, &count_limit);
-
-       tda18271_write_regs(fe, R_EP2, 1);
-       tda18271_write_regs(fe, R_EB14, 1);
-
-       /* downconvert frequency */
-       freq += 1000000;
-
-       tda18271_calc_main_pll(fe, freq);
-       tda18271_write_regs(fe, R_MPD, 4);
-
-       msleep(5); /* pll locking */
-
-       /* detection mode */
-       regs[R_EP4]  &= ~0x03;
-       regs[R_EP4]  |= 0x01;
-       tda18271_write_regs(fe, R_EP4, 1);
-
-       /* launch power detection measurement */
-       tda18271_write_regs(fe, R_EP2, 1);
-
-       /* read power detection info, stored in EB10 */
-       tda18271_read_extended(fe);
-
-       /* algorithm initialization */
-       sgn = 1;
-       *freq_out = *freq_in;
-       bcal = 0;
-       count = 0;
-       wait = false;
-
-       while ((regs[R_EB10] & 0x3f) < cid_target) {
-               /* downconvert updated freq to 1 MHz */
-               freq = *freq_in + (sgn * count) + 1000000;
-
-               tda18271_calc_main_pll(fe, freq);
-               tda18271_write_regs(fe, R_MPD, 4);
-
-               if (wait) {
-                       msleep(5); /* pll locking */
-                       wait = false;
-               } else
-                       udelay(100); /* pll locking */
-
-               /* launch power detection measurement */
-               tda18271_write_regs(fe, R_EP2, 1);
-
-               /* read power detection info, stored in EB10 */
-               tda18271_read_extended(fe);
-
-               count += 200;
-
-               if (count <= count_limit)
-                       continue;
-
-               if (sgn <= 0)
-                       break;
-
-               sgn = -1 * sgn;
-               count = 200;
-               wait = true;
-       }
-
-       if ((regs[R_EB10] & 0x3f) >= cid_target) {
-               bcal = 1;
-               *freq_out = freq - 1000000;
-       } else
-               bcal = 0;
-
-       tda_cal("bcal = %d, freq_in = %d, freq_out = %d (freq = %d)\n",
-               bcal, *freq_in, *freq_out, freq);
-
-       return bcal;
-}
-
-static int tda18271_powerscan_init(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       /* set standard to digital */
-       regs[R_EP3]  &= ~0x1f; /* clear std bits */
-       regs[R_EP3]  |= 0x12;
-
-       /* set cal mode to normal */
-       regs[R_EP4]  &= ~0x03;
-
-       /* update IF output level & IF notch frequency */
-       regs[R_EP4]  &= ~0x1c; /* clear if level bits */
-
-       tda18271_write_regs(fe, R_EP3, 2);
-
-       regs[R_EB18] &= ~0x03; /* set agc1_gain to   6 dB */
-       tda18271_write_regs(fe, R_EB18, 1);
-
-       regs[R_EB21] &= ~0x03; /* set agc2_gain to -15 dB */
-
-       /* 1.5 MHz low pass filter */
-       regs[R_EB23] |= 0x04; /* forcelp_fc2_en = 1 */
-       regs[R_EB23] |= 0x02; /* lp_fc[2] = 1 */
-
-       tda18271_write_regs(fe, R_EB21, 3);
-
-       return 0;
-}
-
-static int tda18271_rf_tracking_filters_init(struct dvb_frontend *fe, u32 freq)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
-       unsigned char *regs = priv->tda18271_regs;
-       int bcal, rf, i;
-#define RF1 0
-#define RF2 1
-#define RF3 2
-       u32 rf_default[3];
-       u32 rf_freq[3];
-       u8 prog_cal[3];
-       u8 prog_tab[3];
-
-       i = tda18271_lookup_rf_band(fe, &freq, NULL);
-
-       if (i < 0)
-               return i;
-
-       rf_default[RF1] = 1000 * map[i].rf1_def;
-       rf_default[RF2] = 1000 * map[i].rf2_def;
-       rf_default[RF3] = 1000 * map[i].rf3_def;
-
-       for (rf = RF1; rf <= RF3; rf++) {
-               if (0 == rf_default[rf])
-                       return 0;
-               tda_cal("freq = %d, rf = %d\n", freq, rf);
-
-               /* look for optimized calibration frequency */
-               bcal = tda18271_powerscan(fe, &rf_default[rf], &rf_freq[rf]);
-
-               tda18271_calc_rf_cal(fe, &rf_freq[rf]);
-               prog_tab[rf] = regs[R_EB14];
-
-               if (1 == bcal)
-                       prog_cal[rf] = tda18271_calibrate_rf(fe, rf_freq[rf]);
-               else
-                       prog_cal[rf] = prog_tab[rf];
-
-               switch (rf) {
-               case RF1:
-                       map[i].rf_a1 = 0;
-                       map[i].rf_b1 = prog_cal[RF1] - prog_tab[RF1];
-                       map[i].rf1   = rf_freq[RF1] / 1000;
-                       break;
-               case RF2:
-                       map[i].rf_a1 = (prog_cal[RF2] - prog_tab[RF2] -
-                                       prog_cal[RF1] + prog_tab[RF1]) /
-                               ((rf_freq[RF2] - rf_freq[RF1]) / 1000);
-                       map[i].rf2   = rf_freq[RF2] / 1000;
-                       break;
-               case RF3:
-                       map[i].rf_a2 = (prog_cal[RF3] - prog_tab[RF3] -
-                                       prog_cal[RF2] + prog_tab[RF2]) /
-                               ((rf_freq[RF3] - rf_freq[RF2]) / 1000);
-                       map[i].rf_b2 = prog_cal[RF2] - prog_tab[RF2];
-                       map[i].rf3   = rf_freq[RF3] / 1000;
-                       break;
-               default:
-                       BUG();
-               }
-       }
-
-       return 0;
-}
-
-static int tda18271_calc_rf_filter_curve(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned int i;
-
-       tda_info("tda18271: performing RF tracking filter calibration\n");
-
-       /* wait for die temperature stabilization */
-       msleep(200);
-
-       tda18271_powerscan_init(fe);
-
-       /* rf band calibration */
-       for (i = 0; priv->rf_cal_state[i].rfmax != 0; i++)
-               tda18271_rf_tracking_filters_init(fe, 1000 *
-                                                 priv->rf_cal_state[i].rfmax);
-
-       priv->tm_rfcal = tda18271_read_thermometer(fe);
-
-       return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda18271c2_rf_cal_init(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       /* test RF_CAL_OK to see if we need init */
-       if ((regs[R_EP1] & 0x10) == 0)
-               priv->cal_initialized = false;
-
-       if (priv->cal_initialized)
-               return 0;
-
-       tda18271_calc_rf_filter_curve(fe);
-
-       tda18271_por(fe);
-
-       tda_info("tda18271: RF tracking filter calibration complete\n");
-
-       priv->cal_initialized = true;
-
-       return 0;
-}
-
-static int tda18271c1_rf_tracking_filter_calibration(struct dvb_frontend *fe,
-                                                    u32 freq, u32 bw)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       u32 N = 0;
-
-       /* calculate bp filter */
-       tda18271_calc_bp_filter(fe, &freq);
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       regs[R_EB4]  &= 0x07;
-       regs[R_EB4]  |= 0x60;
-       tda18271_write_regs(fe, R_EB4, 1);
-
-       regs[R_EB7]   = 0x60;
-       tda18271_write_regs(fe, R_EB7, 1);
-
-       regs[R_EB14]  = 0x00;
-       tda18271_write_regs(fe, R_EB14, 1);
-
-       regs[R_EB20]  = 0xcc;
-       tda18271_write_regs(fe, R_EB20, 1);
-
-       /* set cal mode to RF tracking filter calibration */
-       regs[R_EP4]  |= 0x03;
-
-       /* calculate cal pll */
-
-       switch (priv->mode) {
-       case TDA18271_ANALOG:
-               N = freq - 1250000;
-               break;
-       case TDA18271_DIGITAL:
-               N = freq + bw / 2;
-               break;
-       }
-
-       tda18271_calc_cal_pll(fe, N);
-
-       /* calculate main pll */
-
-       switch (priv->mode) {
-       case TDA18271_ANALOG:
-               N = freq - 250000;
-               break;
-       case TDA18271_DIGITAL:
-               N = freq + bw / 2 + 1000000;
-               break;
-       }
-
-       tda18271_calc_main_pll(fe, N);
-
-       tda18271_write_regs(fe, R_EP3, 11);
-       msleep(5); /* RF tracking filter calibration initialization */
-
-       /* search for K,M,CO for RF calibration */
-       tda18271_calc_km(fe, &freq);
-       tda18271_write_regs(fe, R_EB13, 1);
-
-       /* search for rf band */
-       tda18271_calc_rf_band(fe, &freq);
-
-       /* search for gain taper */
-       tda18271_calc_gain_taper(fe, &freq);
-
-       tda18271_write_regs(fe, R_EP2, 1);
-       tda18271_write_regs(fe, R_EP1, 1);
-       tda18271_write_regs(fe, R_EP2, 1);
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       regs[R_EB4]  &= 0x07;
-       regs[R_EB4]  |= 0x40;
-       tda18271_write_regs(fe, R_EB4, 1);
-
-       regs[R_EB7]   = 0x40;
-       tda18271_write_regs(fe, R_EB7, 1);
-       msleep(10); /* pll locking */
-
-       regs[R_EB20]  = 0xec;
-       tda18271_write_regs(fe, R_EB20, 1);
-       msleep(60); /* RF tracking filter calibration completion */
-
-       regs[R_EP4]  &= ~0x03; /* set cal mode to normal */
-       tda18271_write_regs(fe, R_EP4, 1);
-
-       tda18271_write_regs(fe, R_EP1, 1);
-
-       /* RF tracking filter correction for VHF_Low band */
-       if (0 == tda18271_calc_rf_cal(fe, &freq))
-               tda18271_write_regs(fe, R_EB14, 1);
-
-       return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda18271_ir_cal_init(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-
-       tda18271_read_regs(fe);
-
-       /* test IR_CAL_OK to see if we need init */
-       if ((regs[R_EP1] & 0x08) == 0)
-               tda18271_init_regs(fe);
-
-       return 0;
-}
-
-static int tda18271_init(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-
-       mutex_lock(&priv->lock);
-
-       /* power up */
-       tda18271_set_standby_mode(fe, 0, 0, 0);
-
-       /* initialization */
-       tda18271_ir_cal_init(fe);
-
-       if (priv->id == TDA18271HDC2)
-               tda18271c2_rf_cal_init(fe);
-
-       mutex_unlock(&priv->lock);
-
-       return 0;
-}
-
-static int tda18271_tune(struct dvb_frontend *fe,
-                        struct tda18271_std_map_item *map, u32 freq, u32 bw)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-
-       tda_dbg("freq = %d, ifc = %d, bw = %d, agc_mode = %d, std = %d\n",
-               freq, map->if_freq, bw, map->agc_mode, map->std);
-
-       tda18271_init(fe);
-
-       mutex_lock(&priv->lock);
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               tda18271c1_rf_tracking_filter_calibration(fe, freq, bw);
-               break;
-       case TDA18271HDC2:
-               tda18271c2_rf_tracking_filters_correction(fe, freq);
-               break;
-       }
-       tda18271_channel_configuration(fe, map, freq, bw);
-
-       mutex_unlock(&priv->lock);
-
-       return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda18271_set_params(struct dvb_frontend *fe,
-                              struct dvb_frontend_parameters *params)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_std_map *std_map = &priv->std;
-       struct tda18271_std_map_item *map;
-       int ret;
-       u32 bw, freq = params->frequency;
-
-       priv->mode = TDA18271_DIGITAL;
-
-       if (fe->ops.info.type == FE_ATSC) {
-               switch (params->u.vsb.modulation) {
-               case VSB_8:
-               case VSB_16:
-                       map = &std_map->atsc_6;
-                       break;
-               case QAM_64:
-               case QAM_256:
-                       map = &std_map->qam_6;
-                       break;
-               default:
-                       tda_warn("modulation not set!\n");
-                       return -EINVAL;
-               }
-#if 0
-               /* userspace request is already center adjusted */
-               freq += 1750000; /* Adjust to center (+1.75MHZ) */
-#endif
-               bw = 6000000;
-       } else if (fe->ops.info.type == FE_OFDM) {
-               switch (params->u.ofdm.bandwidth) {
-               case BANDWIDTH_6_MHZ:
-                       bw = 6000000;
-                       map = &std_map->dvbt_6;
-                       break;
-               case BANDWIDTH_7_MHZ:
-                       bw = 7000000;
-                       map = &std_map->dvbt_7;
-                       break;
-               case BANDWIDTH_8_MHZ:
-                       bw = 8000000;
-                       map = &std_map->dvbt_8;
-                       break;
-               default:
-                       tda_warn("bandwidth not set!\n");
-                       return -EINVAL;
-               }
-       } else {
-               tda_warn("modulation type not supported!\n");
-               return -EINVAL;
-       }
-
-       /* When tuning digital, the analog demod must be tri-stated */
-       if (fe->ops.analog_ops.standby)
-               fe->ops.analog_ops.standby(fe);
-
-       ret = tda18271_tune(fe, map, freq, bw);
-
-       if (ret < 0)
-               goto fail;
-
-       priv->frequency = freq;
-       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
-               params->u.ofdm.bandwidth : 0;
-fail:
-       return ret;
-}
-
-static int tda18271_set_analog_params(struct dvb_frontend *fe,
-                                     struct analog_parameters *params)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_std_map *std_map = &priv->std;
-       struct tda18271_std_map_item *map;
-       char *mode;
-       int ret;
-       u32 freq = params->frequency * 62500;
-
-       priv->mode = TDA18271_ANALOG;
-
-       if (params->mode == V4L2_TUNER_RADIO) {
-               freq = freq / 1000;
-               map = &std_map->fm_radio;
-               mode = "fm";
-       } else if (params->std & V4L2_STD_MN) {
-               map = &std_map->atv_mn;
-               mode = "MN";
-       } else if (params->std & V4L2_STD_B) {
-               map = &std_map->atv_b;
-               mode = "B";
-       } else if (params->std & V4L2_STD_GH) {
-               map = &std_map->atv_gh;
-               mode = "GH";
-       } else if (params->std & V4L2_STD_PAL_I) {
-               map = &std_map->atv_i;
-               mode = "I";
-       } else if (params->std & V4L2_STD_DK) {
-               map = &std_map->atv_dk;
-               mode = "DK";
-       } else if (params->std & V4L2_STD_SECAM_L) {
-               map = &std_map->atv_l;
-               mode = "L";
-       } else if (params->std & V4L2_STD_SECAM_LC) {
-               map = &std_map->atv_lc;
-               mode = "L'";
-       } else {
-               map = &std_map->atv_i;
-               mode = "xx";
-       }
-
-       tda_dbg("setting tda18271 to system %s\n", mode);
-
-       ret = tda18271_tune(fe, map, freq, 0);
-
-       if (ret < 0)
-               goto fail;
-
-       priv->frequency = freq;
-       priv->bandwidth = 0;
-fail:
-       return ret;
-}
-
-static int tda18271_sleep(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-
-       mutex_lock(&priv->lock);
-
-       /* standby mode w/ slave tuner output
-        * & loop thru & xtal oscillator on */
-       tda18271_set_standby_mode(fe, 1, 0, 0);
-
-       mutex_unlock(&priv->lock);
-
-       return 0;
-}
-
-static int tda18271_release(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-
-       mutex_lock(&tda18271_list_mutex);
-
-       if (priv)
-               hybrid_tuner_release_state(priv);
-
-       mutex_unlock(&tda18271_list_mutex);
-
-       fe->tuner_priv = NULL;
-
-       return 0;
-}
-
-static int tda18271_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-       return 0;
-}
-
-static int tda18271_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       *bandwidth = priv->bandwidth;
-       return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-#define tda18271_update_std(std_cfg, name) do {                                \
-       if (map->std_cfg.if_freq +                                      \
-               map->std_cfg.agc_mode + map->std_cfg.std +              \
-               map->std_cfg.if_lvl + map->std_cfg.rfagc_top > 0) {     \
-               tda_dbg("Using custom std config for %s\n", name);      \
-               memcpy(&std->std_cfg, &map->std_cfg,                    \
-                       sizeof(struct tda18271_std_map_item));          \
-       } } while (0)
-
-#define tda18271_dump_std_item(std_cfg, name) do {                     \
-       tda_dbg("(%s) if_freq = %d, agc_mode = %d, std = %d, "          \
-               "if_lvl = %d, rfagc_top = 0x%02x\n",                    \
-               name, std->std_cfg.if_freq,                             \
-               std->std_cfg.agc_mode, std->std_cfg.std,                \
-               std->std_cfg.if_lvl, std->std_cfg.rfagc_top);           \
-       } while (0)
-
-static int tda18271_dump_std_map(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_std_map *std = &priv->std;
-
-       tda_dbg("========== STANDARD MAP SETTINGS ==========\n");
-       tda18271_dump_std_item(fm_radio, "  fm  ");
-       tda18271_dump_std_item(atv_b,  "atv b ");
-       tda18271_dump_std_item(atv_dk, "atv dk");
-       tda18271_dump_std_item(atv_gh, "atv gh");
-       tda18271_dump_std_item(atv_i,  "atv i ");
-       tda18271_dump_std_item(atv_l,  "atv l ");
-       tda18271_dump_std_item(atv_lc, "atv l'");
-       tda18271_dump_std_item(atv_mn, "atv mn");
-       tda18271_dump_std_item(atsc_6, "atsc 6");
-       tda18271_dump_std_item(dvbt_6, "dvbt 6");
-       tda18271_dump_std_item(dvbt_7, "dvbt 7");
-       tda18271_dump_std_item(dvbt_8, "dvbt 8");
-       tda18271_dump_std_item(qam_6,  "qam 6 ");
-       tda18271_dump_std_item(qam_8,  "qam 8 ");
-
-       return 0;
-}
-
-static int tda18271_update_std_map(struct dvb_frontend *fe,
-                                  struct tda18271_std_map *map)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_std_map *std = &priv->std;
-
-       if (!map)
-               return -EINVAL;
-
-       tda18271_update_std(fm_radio, "fm");
-       tda18271_update_std(atv_b,  "atv b");
-       tda18271_update_std(atv_dk, "atv dk");
-       tda18271_update_std(atv_gh, "atv gh");
-       tda18271_update_std(atv_i,  "atv i");
-       tda18271_update_std(atv_l,  "atv l");
-       tda18271_update_std(atv_lc, "atv l'");
-       tda18271_update_std(atv_mn, "atv mn");
-       tda18271_update_std(atsc_6, "atsc 6");
-       tda18271_update_std(dvbt_6, "dvbt 6");
-       tda18271_update_std(dvbt_7, "dvbt 7");
-       tda18271_update_std(dvbt_8, "dvbt 8");
-       tda18271_update_std(qam_6,  "qam 6");
-       tda18271_update_std(qam_8,  "qam 8");
-
-       return 0;
-}
-
-static int tda18271_get_id(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       char *name;
-       int ret = 0;
-
-       mutex_lock(&priv->lock);
-       tda18271_read_regs(fe);
-       mutex_unlock(&priv->lock);
-
-       switch (regs[R_ID] & 0x7f) {
-       case 3:
-               name = "TDA18271HD/C1";
-               priv->id = TDA18271HDC1;
-               break;
-       case 4:
-               name = "TDA18271HD/C2";
-               priv->id = TDA18271HDC2;
-               break;
-       default:
-               name = "Unknown device";
-               ret = -EINVAL;
-               break;
-       }
-
-       tda_info("%s detected @ %d-%04x%s\n", name,
-                i2c_adapter_id(priv->i2c_props.adap),
-                priv->i2c_props.addr,
-                (0 == ret) ? "" : ", device not supported.");
-
-       return ret;
-}
-
-static struct dvb_tuner_ops tda18271_tuner_ops = {
-       .info = {
-               .name = "NXP TDA18271HD",
-               .frequency_min  =  45000000,
-               .frequency_max  = 864000000,
-               .frequency_step =     62500
-       },
-       .init              = tda18271_init,
-       .sleep             = tda18271_sleep,
-       .set_params        = tda18271_set_params,
-       .set_analog_params = tda18271_set_analog_params,
-       .release           = tda18271_release,
-       .get_frequency     = tda18271_get_frequency,
-       .get_bandwidth     = tda18271_get_bandwidth,
-};
-
-struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
-                                    struct i2c_adapter *i2c,
-                                    struct tda18271_config *cfg)
-{
-       struct tda18271_priv *priv = NULL;
-       int instance;
-
-       mutex_lock(&tda18271_list_mutex);
-
-       instance = hybrid_tuner_request_state(struct tda18271_priv, priv,
-                                             hybrid_tuner_instance_list,
-                                             i2c, addr, "tda18271");
-       switch (instance) {
-       case 0:
-               goto fail;
-               break;
-       case 1:
-               /* new tuner instance */
-               priv->gate = (cfg) ? cfg->gate : TDA18271_GATE_AUTO;
-               priv->role = (cfg) ? cfg->role : TDA18271_MASTER;
-               priv->cal_initialized = false;
-               mutex_init(&priv->lock);
-
-               fe->tuner_priv = priv;
-
-               if (cfg)
-                       priv->small_i2c = cfg->small_i2c;
-
-               if (tda18271_get_id(fe) < 0)
-                       goto fail;
-
-               if (tda18271_assign_map_layout(fe) < 0)
-                       goto fail;
-
-               mutex_lock(&priv->lock);
-               tda18271_init_regs(fe);
-
-               if ((tda18271_cal_on_startup) && (priv->id == TDA18271HDC2))
-                       tda18271c2_rf_cal_init(fe);
-
-               mutex_unlock(&priv->lock);
-               break;
-       default:
-               /* existing tuner instance */
-               fe->tuner_priv = priv;
-
-               /* allow dvb driver to override i2c gate setting */
-               if ((cfg) && (cfg->gate != TDA18271_GATE_ANALOG))
-                       priv->gate = cfg->gate;
-               break;
-       }
-
-       /* override default std map with values in config struct */
-       if ((cfg) && (cfg->std_map))
-               tda18271_update_std_map(fe, cfg->std_map);
-
-       mutex_unlock(&tda18271_list_mutex);
-
-       memcpy(&fe->ops.tuner_ops, &tda18271_tuner_ops,
-              sizeof(struct dvb_tuner_ops));
-
-       if (tda18271_debug & (DBG_MAP | DBG_ADV))
-               tda18271_dump_std_map(fe);
-
-       return fe;
-fail:
-       mutex_unlock(&tda18271_list_mutex);
-
-       tda18271_release(fe);
-       return NULL;
-}
-EXPORT_SYMBOL_GPL(tda18271_attach);
-MODULE_DESCRIPTION("NXP TDA18271HD analog / digital tuner driver");
-MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
-MODULE_LICENSE("GPL");
-MODULE_VERSION("0.3");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/dvb/frontends/tda18271-priv.h b/drivers/media/dvb/frontends/tda18271-priv.h
deleted file mode 100644 (file)
index 2bc5eb3..0000000
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
-    tda18271-priv.h - private header for the NXP TDA18271 silicon tuner
-
-    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TDA18271_PRIV_H__
-#define __TDA18271_PRIV_H__
-
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/mutex.h>
-#include "tuner-i2c.h"
-#include "tda18271.h"
-
-#define R_ID     0x00  /* ID byte                */
-#define R_TM     0x01  /* Thermo byte            */
-#define R_PL     0x02  /* Power level byte       */
-#define R_EP1    0x03  /* Easy Prog byte 1       */
-#define R_EP2    0x04  /* Easy Prog byte 2       */
-#define R_EP3    0x05  /* Easy Prog byte 3       */
-#define R_EP4    0x06  /* Easy Prog byte 4       */
-#define R_EP5    0x07  /* Easy Prog byte 5       */
-#define R_CPD    0x08  /* Cal Post-Divider byte  */
-#define R_CD1    0x09  /* Cal Divider byte 1     */
-#define R_CD2    0x0a  /* Cal Divider byte 2     */
-#define R_CD3    0x0b  /* Cal Divider byte 3     */
-#define R_MPD    0x0c  /* Main Post-Divider byte */
-#define R_MD1    0x0d  /* Main Divider byte 1    */
-#define R_MD2    0x0e  /* Main Divider byte 2    */
-#define R_MD3    0x0f  /* Main Divider byte 3    */
-#define R_EB1    0x10  /* Extended byte 1        */
-#define R_EB2    0x11  /* Extended byte 2        */
-#define R_EB3    0x12  /* Extended byte 3        */
-#define R_EB4    0x13  /* Extended byte 4        */
-#define R_EB5    0x14  /* Extended byte 5        */
-#define R_EB6    0x15  /* Extended byte 6        */
-#define R_EB7    0x16  /* Extended byte 7        */
-#define R_EB8    0x17  /* Extended byte 8        */
-#define R_EB9    0x18  /* Extended byte 9        */
-#define R_EB10   0x19  /* Extended byte 10       */
-#define R_EB11   0x1a  /* Extended byte 11       */
-#define R_EB12   0x1b  /* Extended byte 12       */
-#define R_EB13   0x1c  /* Extended byte 13       */
-#define R_EB14   0x1d  /* Extended byte 14       */
-#define R_EB15   0x1e  /* Extended byte 15       */
-#define R_EB16   0x1f  /* Extended byte 16       */
-#define R_EB17   0x20  /* Extended byte 17       */
-#define R_EB18   0x21  /* Extended byte 18       */
-#define R_EB19   0x22  /* Extended byte 19       */
-#define R_EB20   0x23  /* Extended byte 20       */
-#define R_EB21   0x24  /* Extended byte 21       */
-#define R_EB22   0x25  /* Extended byte 22       */
-#define R_EB23   0x26  /* Extended byte 23       */
-
-#define TDA18271_NUM_REGS 39
-
-/*---------------------------------------------------------------------*/
-
-struct tda18271_rf_tracking_filter_cal {
-       u32 rfmax;
-       u8  rfband;
-       u32 rf1_def;
-       u32 rf2_def;
-       u32 rf3_def;
-       u32 rf1;
-       u32 rf2;
-       u32 rf3;
-       int rf_a1;
-       int rf_b1;
-       int rf_a2;
-       int rf_b2;
-};
-
-enum tda18271_pll {
-       TDA18271_MAIN_PLL,
-       TDA18271_CAL_PLL,
-};
-
-enum tda18271_mode {
-       TDA18271_ANALOG,
-       TDA18271_DIGITAL,
-};
-
-struct tda18271_map_layout;
-
-enum tda18271_ver {
-       TDA18271HDC1,
-       TDA18271HDC2,
-};
-
-struct tda18271_priv {
-       unsigned char tda18271_regs[TDA18271_NUM_REGS];
-
-       struct list_head        hybrid_tuner_instance_list;
-       struct tuner_i2c_props  i2c_props;
-
-       enum tda18271_mode mode;
-       enum tda18271_role role;
-       enum tda18271_i2c_gate gate;
-       enum tda18271_ver id;
-
-       unsigned int tm_rfcal;
-       unsigned int cal_initialized:1;
-       unsigned int small_i2c:1;
-
-       struct tda18271_map_layout *maps;
-       struct tda18271_std_map std;
-       struct tda18271_rf_tracking_filter_cal rf_cal_state[8];
-
-       struct mutex lock;
-
-       u32 frequency;
-       u32 bandwidth;
-};
-
-/*---------------------------------------------------------------------*/
-
-extern int tda18271_debug;
-
-#define DBG_INFO 1
-#define DBG_MAP  2
-#define DBG_REG  4
-#define DBG_ADV  8
-#define DBG_CAL  16
-
-#define tda_printk(kern, fmt, arg...) \
-       printk(kern "%s: " fmt, __func__, ##arg)
-
-#define dprintk(kern, lvl, fmt, arg...) do {\
-       if (tda18271_debug & lvl) \
-               tda_printk(kern, fmt, ##arg); } while (0)
-
-#define tda_info(fmt, arg...) printk(KERN_INFO              fmt, ##arg)
-#define tda_warn(fmt, arg...) tda_printk(KERN_WARNING,      fmt, ##arg)
-#define tda_err(fmt, arg...)  tda_printk(KERN_ERR,          fmt, ##arg)
-#define tda_dbg(fmt, arg...)  dprintk(KERN_DEBUG, DBG_INFO, fmt, ##arg)
-#define tda_map(fmt, arg...)  dprintk(KERN_DEBUG, DBG_MAP,  fmt, ##arg)
-#define tda_reg(fmt, arg...)  dprintk(KERN_DEBUG, DBG_REG,  fmt, ##arg)
-#define tda_cal(fmt, arg...)  dprintk(KERN_DEBUG, DBG_CAL,  fmt, ##arg)
-
-/*---------------------------------------------------------------------*/
-
-enum tda18271_map_type {
-       /* tda18271_pll_map */
-       MAIN_PLL,
-       CAL_PLL,
-       /* tda18271_map */
-       RF_CAL,
-       RF_CAL_KMCO,
-       RF_CAL_DC_OVER_DT,
-       BP_FILTER,
-       RF_BAND,
-       GAIN_TAPER,
-       IR_MEASURE,
-};
-
-extern int tda18271_lookup_pll_map(struct dvb_frontend *fe,
-                                  enum tda18271_map_type map_type,
-                                  u32 *freq, u8 *post_div, u8 *div);
-extern int tda18271_lookup_map(struct dvb_frontend *fe,
-                              enum tda18271_map_type map_type,
-                              u32 *freq, u8 *val);
-
-extern int tda18271_lookup_thermometer(struct dvb_frontend *fe);
-
-extern int tda18271_lookup_rf_band(struct dvb_frontend *fe,
-                                  u32 *freq, u8 *rf_band);
-
-extern int tda18271_lookup_cid_target(struct dvb_frontend *fe,
-                                     u32 *freq, u8 *cid_target,
-                                     u16 *count_limit);
-
-extern int tda18271_assign_map_layout(struct dvb_frontend *fe);
-
-/*---------------------------------------------------------------------*/
-
-extern int tda18271_read_regs(struct dvb_frontend *fe);
-extern int tda18271_read_extended(struct dvb_frontend *fe);
-extern int tda18271_write_regs(struct dvb_frontend *fe, int idx, int len);
-extern int tda18271_init_regs(struct dvb_frontend *fe);
-
-extern int tda18271_charge_pump_source(struct dvb_frontend *fe,
-                                      enum tda18271_pll pll, int force);
-extern int tda18271_set_standby_mode(struct dvb_frontend *fe,
-                                    int sm, int sm_lt, int sm_xt);
-
-extern int tda18271_calc_main_pll(struct dvb_frontend *fe, u32 freq);
-extern int tda18271_calc_cal_pll(struct dvb_frontend *fe, u32 freq);
-
-extern int tda18271_calc_bp_filter(struct dvb_frontend *fe, u32 *freq);
-extern int tda18271_calc_km(struct dvb_frontend *fe, u32 *freq);
-extern int tda18271_calc_rf_band(struct dvb_frontend *fe, u32 *freq);
-extern int tda18271_calc_gain_taper(struct dvb_frontend *fe, u32 *freq);
-extern int tda18271_calc_ir_measure(struct dvb_frontend *fe, u32 *freq);
-extern int tda18271_calc_rf_cal(struct dvb_frontend *fe, u32 *freq);
-
-#endif /* __TDA18271_PRIV_H__ */
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/dvb/frontends/tda18271-tables.c b/drivers/media/dvb/frontends/tda18271-tables.c
deleted file mode 100644 (file)
index 83e7561..0000000
+++ /dev/null
@@ -1,1313 +0,0 @@
-/*
-    tda18271-tables.c - driver for the Philips / NXP TDA18271 silicon tuner
-
-    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#include "tda18271-priv.h"
-
-struct tda18271_pll_map {
-       u32 lomax;
-       u8 pd; /* post div */
-       u8 d;  /*      div */
-};
-
-struct tda18271_map {
-       u32 rfmax;
-       u8  val;
-};
-
-/*---------------------------------------------------------------------*/
-
-static struct tda18271_pll_map tda18271c1_main_pll[] = {
-       { .lomax =  32000, .pd = 0x5f, .d = 0xf0 },
-       { .lomax =  35000, .pd = 0x5e, .d = 0xe0 },
-       { .lomax =  37000, .pd = 0x5d, .d = 0xd0 },
-       { .lomax =  41000, .pd = 0x5c, .d = 0xc0 },
-       { .lomax =  44000, .pd = 0x5b, .d = 0xb0 },
-       { .lomax =  49000, .pd = 0x5a, .d = 0xa0 },
-       { .lomax =  54000, .pd = 0x59, .d = 0x90 },
-       { .lomax =  61000, .pd = 0x58, .d = 0x80 },
-       { .lomax =  65000, .pd = 0x4f, .d = 0x78 },
-       { .lomax =  70000, .pd = 0x4e, .d = 0x70 },
-       { .lomax =  75000, .pd = 0x4d, .d = 0x68 },
-       { .lomax =  82000, .pd = 0x4c, .d = 0x60 },
-       { .lomax =  89000, .pd = 0x4b, .d = 0x58 },
-       { .lomax =  98000, .pd = 0x4a, .d = 0x50 },
-       { .lomax = 109000, .pd = 0x49, .d = 0x48 },
-       { .lomax = 123000, .pd = 0x48, .d = 0x40 },
-       { .lomax = 131000, .pd = 0x3f, .d = 0x3c },
-       { .lomax = 141000, .pd = 0x3e, .d = 0x38 },
-       { .lomax = 151000, .pd = 0x3d, .d = 0x34 },
-       { .lomax = 164000, .pd = 0x3c, .d = 0x30 },
-       { .lomax = 179000, .pd = 0x3b, .d = 0x2c },
-       { .lomax = 197000, .pd = 0x3a, .d = 0x28 },
-       { .lomax = 219000, .pd = 0x39, .d = 0x24 },
-       { .lomax = 246000, .pd = 0x38, .d = 0x20 },
-       { .lomax = 263000, .pd = 0x2f, .d = 0x1e },
-       { .lomax = 282000, .pd = 0x2e, .d = 0x1c },
-       { .lomax = 303000, .pd = 0x2d, .d = 0x1a },
-       { .lomax = 329000, .pd = 0x2c, .d = 0x18 },
-       { .lomax = 359000, .pd = 0x2b, .d = 0x16 },
-       { .lomax = 395000, .pd = 0x2a, .d = 0x14 },
-       { .lomax = 438000, .pd = 0x29, .d = 0x12 },
-       { .lomax = 493000, .pd = 0x28, .d = 0x10 },
-       { .lomax = 526000, .pd = 0x1f, .d = 0x0f },
-       { .lomax = 564000, .pd = 0x1e, .d = 0x0e },
-       { .lomax = 607000, .pd = 0x1d, .d = 0x0d },
-       { .lomax = 658000, .pd = 0x1c, .d = 0x0c },
-       { .lomax = 718000, .pd = 0x1b, .d = 0x0b },
-       { .lomax = 790000, .pd = 0x1a, .d = 0x0a },
-       { .lomax = 877000, .pd = 0x19, .d = 0x09 },
-       { .lomax = 987000, .pd = 0x18, .d = 0x08 },
-       { .lomax =      0, .pd = 0x00, .d = 0x00 }, /* end */
-};
-
-static struct tda18271_pll_map tda18271c2_main_pll[] = {
-       { .lomax =  33125, .pd = 0x57, .d = 0xf0 },
-       { .lomax =  35500, .pd = 0x56, .d = 0xe0 },
-       { .lomax =  38188, .pd = 0x55, .d = 0xd0 },
-       { .lomax =  41375, .pd = 0x54, .d = 0xc0 },
-       { .lomax =  45125, .pd = 0x53, .d = 0xb0 },
-       { .lomax =  49688, .pd = 0x52, .d = 0xa0 },
-       { .lomax =  55188, .pd = 0x51, .d = 0x90 },
-       { .lomax =  62125, .pd = 0x50, .d = 0x80 },
-       { .lomax =  66250, .pd = 0x47, .d = 0x78 },
-       { .lomax =  71000, .pd = 0x46, .d = 0x70 },
-       { .lomax =  76375, .pd = 0x45, .d = 0x68 },
-       { .lomax =  82750, .pd = 0x44, .d = 0x60 },
-       { .lomax =  90250, .pd = 0x43, .d = 0x58 },
-       { .lomax =  99375, .pd = 0x42, .d = 0x50 },
-       { .lomax = 110375, .pd = 0x41, .d = 0x48 },
-       { .lomax = 124250, .pd = 0x40, .d = 0x40 },
-       { .lomax = 132500, .pd = 0x37, .d = 0x3c },
-       { .lomax = 142000, .pd = 0x36, .d = 0x38 },
-       { .lomax = 152750, .pd = 0x35, .d = 0x34 },
-       { .lomax = 165500, .pd = 0x34, .d = 0x30 },
-       { .lomax = 180500, .pd = 0x33, .d = 0x2c },
-       { .lomax = 198750, .pd = 0x32, .d = 0x28 },
-       { .lomax = 220750, .pd = 0x31, .d = 0x24 },
-       { .lomax = 248500, .pd = 0x30, .d = 0x20 },
-       { .lomax = 265000, .pd = 0x27, .d = 0x1e },
-       { .lomax = 284000, .pd = 0x26, .d = 0x1c },
-       { .lomax = 305500, .pd = 0x25, .d = 0x1a },
-       { .lomax = 331000, .pd = 0x24, .d = 0x18 },
-       { .lomax = 361000, .pd = 0x23, .d = 0x16 },
-       { .lomax = 397500, .pd = 0x22, .d = 0x14 },
-       { .lomax = 441500, .pd = 0x21, .d = 0x12 },
-       { .lomax = 497000, .pd = 0x20, .d = 0x10 },
-       { .lomax = 530000, .pd = 0x17, .d = 0x0f },
-       { .lomax = 568000, .pd = 0x16, .d = 0x0e },
-       { .lomax = 611000, .pd = 0x15, .d = 0x0d },
-       { .lomax = 662000, .pd = 0x14, .d = 0x0c },
-       { .lomax = 722000, .pd = 0x13, .d = 0x0b },
-       { .lomax = 795000, .pd = 0x12, .d = 0x0a },
-       { .lomax = 883000, .pd = 0x11, .d = 0x09 },
-       { .lomax = 994000, .pd = 0x10, .d = 0x08 },
-       { .lomax =      0, .pd = 0x00, .d = 0x00 }, /* end */
-};
-
-static struct tda18271_pll_map tda18271c1_cal_pll[] = {
-       { .lomax =   33000, .pd = 0xdd, .d = 0xd0 },
-       { .lomax =   36000, .pd = 0xdc, .d = 0xc0 },
-       { .lomax =   40000, .pd = 0xdb, .d = 0xb0 },
-       { .lomax =   44000, .pd = 0xda, .d = 0xa0 },
-       { .lomax =   49000, .pd = 0xd9, .d = 0x90 },
-       { .lomax =   55000, .pd = 0xd8, .d = 0x80 },
-       { .lomax =   63000, .pd = 0xd3, .d = 0x70 },
-       { .lomax =   67000, .pd = 0xcd, .d = 0x68 },
-       { .lomax =   73000, .pd = 0xcc, .d = 0x60 },
-       { .lomax =   80000, .pd = 0xcb, .d = 0x58 },
-       { .lomax =   88000, .pd = 0xca, .d = 0x50 },
-       { .lomax =   98000, .pd = 0xc9, .d = 0x48 },
-       { .lomax =  110000, .pd = 0xc8, .d = 0x40 },
-       { .lomax =  126000, .pd = 0xc3, .d = 0x38 },
-       { .lomax =  135000, .pd = 0xbd, .d = 0x34 },
-       { .lomax =  147000, .pd = 0xbc, .d = 0x30 },
-       { .lomax =  160000, .pd = 0xbb, .d = 0x2c },
-       { .lomax =  176000, .pd = 0xba, .d = 0x28 },
-       { .lomax =  196000, .pd = 0xb9, .d = 0x24 },
-       { .lomax =  220000, .pd = 0xb8, .d = 0x20 },
-       { .lomax =  252000, .pd = 0xb3, .d = 0x1c },
-       { .lomax =  271000, .pd = 0xad, .d = 0x1a },
-       { .lomax =  294000, .pd = 0xac, .d = 0x18 },
-       { .lomax =  321000, .pd = 0xab, .d = 0x16 },
-       { .lomax =  353000, .pd = 0xaa, .d = 0x14 },
-       { .lomax =  392000, .pd = 0xa9, .d = 0x12 },
-       { .lomax =  441000, .pd = 0xa8, .d = 0x10 },
-       { .lomax =  505000, .pd = 0xa3, .d = 0x0e },
-       { .lomax =  543000, .pd = 0x9d, .d = 0x0d },
-       { .lomax =  589000, .pd = 0x9c, .d = 0x0c },
-       { .lomax =  642000, .pd = 0x9b, .d = 0x0b },
-       { .lomax =  707000, .pd = 0x9a, .d = 0x0a },
-       { .lomax =  785000, .pd = 0x99, .d = 0x09 },
-       { .lomax =  883000, .pd = 0x98, .d = 0x08 },
-       { .lomax = 1010000, .pd = 0x93, .d = 0x07 },
-       { .lomax =       0, .pd = 0x00, .d = 0x00 }, /* end */
-};
-
-static struct tda18271_pll_map tda18271c2_cal_pll[] = {
-       { .lomax =   33813, .pd = 0xdd, .d = 0xd0 },
-       { .lomax =   36625, .pd = 0xdc, .d = 0xc0 },
-       { .lomax =   39938, .pd = 0xdb, .d = 0xb0 },
-       { .lomax =   43938, .pd = 0xda, .d = 0xa0 },
-       { .lomax =   48813, .pd = 0xd9, .d = 0x90 },
-       { .lomax =   54938, .pd = 0xd8, .d = 0x80 },
-       { .lomax =   62813, .pd = 0xd3, .d = 0x70 },
-       { .lomax =   67625, .pd = 0xcd, .d = 0x68 },
-       { .lomax =   73250, .pd = 0xcc, .d = 0x60 },
-       { .lomax =   79875, .pd = 0xcb, .d = 0x58 },
-       { .lomax =   87875, .pd = 0xca, .d = 0x50 },
-       { .lomax =   97625, .pd = 0xc9, .d = 0x48 },
-       { .lomax =  109875, .pd = 0xc8, .d = 0x40 },
-       { .lomax =  125625, .pd = 0xc3, .d = 0x38 },
-       { .lomax =  135250, .pd = 0xbd, .d = 0x34 },
-       { .lomax =  146500, .pd = 0xbc, .d = 0x30 },
-       { .lomax =  159750, .pd = 0xbb, .d = 0x2c },
-       { .lomax =  175750, .pd = 0xba, .d = 0x28 },
-       { .lomax =  195250, .pd = 0xb9, .d = 0x24 },
-       { .lomax =  219750, .pd = 0xb8, .d = 0x20 },
-       { .lomax =  251250, .pd = 0xb3, .d = 0x1c },
-       { .lomax =  270500, .pd = 0xad, .d = 0x1a },
-       { .lomax =  293000, .pd = 0xac, .d = 0x18 },
-       { .lomax =  319500, .pd = 0xab, .d = 0x16 },
-       { .lomax =  351500, .pd = 0xaa, .d = 0x14 },
-       { .lomax =  390500, .pd = 0xa9, .d = 0x12 },
-       { .lomax =  439500, .pd = 0xa8, .d = 0x10 },
-       { .lomax =  502500, .pd = 0xa3, .d = 0x0e },
-       { .lomax =  541000, .pd = 0x9d, .d = 0x0d },
-       { .lomax =  586000, .pd = 0x9c, .d = 0x0c },
-       { .lomax =  639000, .pd = 0x9b, .d = 0x0b },
-       { .lomax =  703000, .pd = 0x9a, .d = 0x0a },
-       { .lomax =  781000, .pd = 0x99, .d = 0x09 },
-       { .lomax =  879000, .pd = 0x98, .d = 0x08 },
-       { .lomax =       0, .pd = 0x00, .d = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271_bp_filter[] = {
-       { .rfmax =  62000, .val = 0x00 },
-       { .rfmax =  84000, .val = 0x01 },
-       { .rfmax = 100000, .val = 0x02 },
-       { .rfmax = 140000, .val = 0x03 },
-       { .rfmax = 170000, .val = 0x04 },
-       { .rfmax = 180000, .val = 0x05 },
-       { .rfmax = 865000, .val = 0x06 },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271c1_km[] = {
-       { .rfmax =  61100, .val = 0x74 },
-       { .rfmax = 350000, .val = 0x40 },
-       { .rfmax = 720000, .val = 0x30 },
-       { .rfmax = 865000, .val = 0x40 },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271c2_km[] = {
-       { .rfmax =  47900, .val = 0x38 },
-       { .rfmax =  61100, .val = 0x44 },
-       { .rfmax = 350000, .val = 0x30 },
-       { .rfmax = 720000, .val = 0x24 },
-       { .rfmax = 865000, .val = 0x3c },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271_rf_band[] = {
-       { .rfmax =  47900, .val = 0x00 },
-       { .rfmax =  61100, .val = 0x01 },
-/*     { .rfmax = 152600, .val = 0x02 }, */
-       { .rfmax = 121200, .val = 0x02 },
-       { .rfmax = 164700, .val = 0x03 },
-       { .rfmax = 203500, .val = 0x04 },
-       { .rfmax = 457800, .val = 0x05 },
-       { .rfmax = 865000, .val = 0x06 },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271_gain_taper[] = {
-       { .rfmax =  45400, .val = 0x1f },
-       { .rfmax =  45800, .val = 0x1e },
-       { .rfmax =  46200, .val = 0x1d },
-       { .rfmax =  46700, .val = 0x1c },
-       { .rfmax =  47100, .val = 0x1b },
-       { .rfmax =  47500, .val = 0x1a },
-       { .rfmax =  47900, .val = 0x19 },
-       { .rfmax =  49600, .val = 0x17 },
-       { .rfmax =  51200, .val = 0x16 },
-       { .rfmax =  52900, .val = 0x15 },
-       { .rfmax =  54500, .val = 0x14 },
-       { .rfmax =  56200, .val = 0x13 },
-       { .rfmax =  57800, .val = 0x12 },
-       { .rfmax =  59500, .val = 0x11 },
-       { .rfmax =  61100, .val = 0x10 },
-       { .rfmax =  67600, .val = 0x0d },
-       { .rfmax =  74200, .val = 0x0c },
-       { .rfmax =  80700, .val = 0x0b },
-       { .rfmax =  87200, .val = 0x0a },
-       { .rfmax =  93800, .val = 0x09 },
-       { .rfmax = 100300, .val = 0x08 },
-       { .rfmax = 106900, .val = 0x07 },
-       { .rfmax = 113400, .val = 0x06 },
-       { .rfmax = 119900, .val = 0x05 },
-       { .rfmax = 126500, .val = 0x04 },
-       { .rfmax = 133000, .val = 0x03 },
-       { .rfmax = 139500, .val = 0x02 },
-       { .rfmax = 146100, .val = 0x01 },
-       { .rfmax = 152600, .val = 0x00 },
-       { .rfmax = 154300, .val = 0x1f },
-       { .rfmax = 156100, .val = 0x1e },
-       { .rfmax = 157800, .val = 0x1d },
-       { .rfmax = 159500, .val = 0x1c },
-       { .rfmax = 161200, .val = 0x1b },
-       { .rfmax = 163000, .val = 0x1a },
-       { .rfmax = 164700, .val = 0x19 },
-       { .rfmax = 170200, .val = 0x17 },
-       { .rfmax = 175800, .val = 0x16 },
-       { .rfmax = 181300, .val = 0x15 },
-       { .rfmax = 186900, .val = 0x14 },
-       { .rfmax = 192400, .val = 0x13 },
-       { .rfmax = 198000, .val = 0x12 },
-       { .rfmax = 203500, .val = 0x11 },
-       { .rfmax = 216200, .val = 0x14 },
-       { .rfmax = 228900, .val = 0x13 },
-       { .rfmax = 241600, .val = 0x12 },
-       { .rfmax = 254400, .val = 0x11 },
-       { .rfmax = 267100, .val = 0x10 },
-       { .rfmax = 279800, .val = 0x0f },
-       { .rfmax = 292500, .val = 0x0e },
-       { .rfmax = 305200, .val = 0x0d },
-       { .rfmax = 317900, .val = 0x0c },
-       { .rfmax = 330700, .val = 0x0b },
-       { .rfmax = 343400, .val = 0x0a },
-       { .rfmax = 356100, .val = 0x09 },
-       { .rfmax = 368800, .val = 0x08 },
-       { .rfmax = 381500, .val = 0x07 },
-       { .rfmax = 394200, .val = 0x06 },
-       { .rfmax = 406900, .val = 0x05 },
-       { .rfmax = 419700, .val = 0x04 },
-       { .rfmax = 432400, .val = 0x03 },
-       { .rfmax = 445100, .val = 0x02 },
-       { .rfmax = 457800, .val = 0x01 },
-       { .rfmax = 476300, .val = 0x19 },
-       { .rfmax = 494800, .val = 0x18 },
-       { .rfmax = 513300, .val = 0x17 },
-       { .rfmax = 531800, .val = 0x16 },
-       { .rfmax = 550300, .val = 0x15 },
-       { .rfmax = 568900, .val = 0x14 },
-       { .rfmax = 587400, .val = 0x13 },
-       { .rfmax = 605900, .val = 0x12 },
-       { .rfmax = 624400, .val = 0x11 },
-       { .rfmax = 642900, .val = 0x10 },
-       { .rfmax = 661400, .val = 0x0f },
-       { .rfmax = 679900, .val = 0x0e },
-       { .rfmax = 698400, .val = 0x0d },
-       { .rfmax = 716900, .val = 0x0c },
-       { .rfmax = 735400, .val = 0x0b },
-       { .rfmax = 753900, .val = 0x0a },
-       { .rfmax = 772500, .val = 0x09 },
-       { .rfmax = 791000, .val = 0x08 },
-       { .rfmax = 809500, .val = 0x07 },
-       { .rfmax = 828000, .val = 0x06 },
-       { .rfmax = 846500, .val = 0x05 },
-       { .rfmax = 865000, .val = 0x04 },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271c1_rf_cal[] = {
-       { .rfmax = 41000, .val = 0x1e },
-       { .rfmax = 43000, .val = 0x30 },
-       { .rfmax = 45000, .val = 0x43 },
-       { .rfmax = 46000, .val = 0x4d },
-       { .rfmax = 47000, .val = 0x54 },
-       { .rfmax = 47900, .val = 0x64 },
-       { .rfmax = 49100, .val = 0x20 },
-       { .rfmax = 50000, .val = 0x22 },
-       { .rfmax = 51000, .val = 0x2a },
-       { .rfmax = 53000, .val = 0x32 },
-       { .rfmax = 55000, .val = 0x35 },
-       { .rfmax = 56000, .val = 0x3c },
-       { .rfmax = 57000, .val = 0x3f },
-       { .rfmax = 58000, .val = 0x48 },
-       { .rfmax = 59000, .val = 0x4d },
-       { .rfmax = 60000, .val = 0x58 },
-       { .rfmax = 61100, .val = 0x5f },
-       { .rfmax =     0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271c2_rf_cal[] = {
-       { .rfmax =  41000, .val = 0x0f },
-       { .rfmax =  43000, .val = 0x1c },
-       { .rfmax =  45000, .val = 0x2f },
-       { .rfmax =  46000, .val = 0x39 },
-       { .rfmax =  47000, .val = 0x40 },
-       { .rfmax =  47900, .val = 0x50 },
-       { .rfmax =  49100, .val = 0x16 },
-       { .rfmax =  50000, .val = 0x18 },
-       { .rfmax =  51000, .val = 0x20 },
-       { .rfmax =  53000, .val = 0x28 },
-       { .rfmax =  55000, .val = 0x2b },
-       { .rfmax =  56000, .val = 0x32 },
-       { .rfmax =  57000, .val = 0x35 },
-       { .rfmax =  58000, .val = 0x3e },
-       { .rfmax =  59000, .val = 0x43 },
-       { .rfmax =  60000, .val = 0x4e },
-       { .rfmax =  61100, .val = 0x55 },
-       { .rfmax =  63000, .val = 0x0f },
-       { .rfmax =  64000, .val = 0x11 },
-       { .rfmax =  65000, .val = 0x12 },
-       { .rfmax =  66000, .val = 0x15 },
-       { .rfmax =  67000, .val = 0x16 },
-       { .rfmax =  68000, .val = 0x17 },
-       { .rfmax =  70000, .val = 0x19 },
-       { .rfmax =  71000, .val = 0x1c },
-       { .rfmax =  72000, .val = 0x1d },
-       { .rfmax =  73000, .val = 0x1f },
-       { .rfmax =  74000, .val = 0x20 },
-       { .rfmax =  75000, .val = 0x21 },
-       { .rfmax =  76000, .val = 0x24 },
-       { .rfmax =  77000, .val = 0x25 },
-       { .rfmax =  78000, .val = 0x27 },
-       { .rfmax =  80000, .val = 0x28 },
-       { .rfmax =  81000, .val = 0x29 },
-       { .rfmax =  82000, .val = 0x2d },
-       { .rfmax =  83000, .val = 0x2e },
-       { .rfmax =  84000, .val = 0x2f },
-       { .rfmax =  85000, .val = 0x31 },
-       { .rfmax =  86000, .val = 0x33 },
-       { .rfmax =  87000, .val = 0x34 },
-       { .rfmax =  88000, .val = 0x35 },
-       { .rfmax =  89000, .val = 0x37 },
-       { .rfmax =  90000, .val = 0x38 },
-       { .rfmax =  91000, .val = 0x39 },
-       { .rfmax =  93000, .val = 0x3c },
-       { .rfmax =  94000, .val = 0x3e },
-       { .rfmax =  95000, .val = 0x3f },
-       { .rfmax =  96000, .val = 0x40 },
-       { .rfmax =  97000, .val = 0x42 },
-       { .rfmax =  99000, .val = 0x45 },
-       { .rfmax = 100000, .val = 0x46 },
-       { .rfmax = 102000, .val = 0x48 },
-       { .rfmax = 103000, .val = 0x4a },
-       { .rfmax = 105000, .val = 0x4d },
-       { .rfmax = 106000, .val = 0x4e },
-       { .rfmax = 107000, .val = 0x50 },
-       { .rfmax = 108000, .val = 0x51 },
-       { .rfmax = 110000, .val = 0x54 },
-       { .rfmax = 111000, .val = 0x56 },
-       { .rfmax = 112000, .val = 0x57 },
-       { .rfmax = 113000, .val = 0x58 },
-       { .rfmax = 114000, .val = 0x59 },
-       { .rfmax = 115000, .val = 0x5c },
-       { .rfmax = 116000, .val = 0x5d },
-       { .rfmax = 117000, .val = 0x5f },
-       { .rfmax = 119000, .val = 0x60 },
-       { .rfmax = 120000, .val = 0x64 },
-       { .rfmax = 121000, .val = 0x65 },
-       { .rfmax = 122000, .val = 0x66 },
-       { .rfmax = 123000, .val = 0x68 },
-       { .rfmax = 124000, .val = 0x69 },
-       { .rfmax = 125000, .val = 0x6c },
-       { .rfmax = 126000, .val = 0x6d },
-       { .rfmax = 127000, .val = 0x6e },
-       { .rfmax = 128000, .val = 0x70 },
-       { .rfmax = 129000, .val = 0x71 },
-       { .rfmax = 130000, .val = 0x75 },
-       { .rfmax = 131000, .val = 0x77 },
-       { .rfmax = 132000, .val = 0x78 },
-       { .rfmax = 133000, .val = 0x7b },
-       { .rfmax = 134000, .val = 0x7e },
-       { .rfmax = 135000, .val = 0x81 },
-       { .rfmax = 136000, .val = 0x82 },
-       { .rfmax = 137000, .val = 0x87 },
-       { .rfmax = 138000, .val = 0x88 },
-       { .rfmax = 139000, .val = 0x8d },
-       { .rfmax = 140000, .val = 0x8e },
-       { .rfmax = 141000, .val = 0x91 },
-       { .rfmax = 142000, .val = 0x95 },
-       { .rfmax = 143000, .val = 0x9a },
-       { .rfmax = 144000, .val = 0x9d },
-       { .rfmax = 145000, .val = 0xa1 },
-       { .rfmax = 146000, .val = 0xa2 },
-       { .rfmax = 147000, .val = 0xa4 },
-       { .rfmax = 148000, .val = 0xa9 },
-       { .rfmax = 149000, .val = 0xae },
-       { .rfmax = 150000, .val = 0xb0 },
-       { .rfmax = 151000, .val = 0xb1 },
-       { .rfmax = 152000, .val = 0xb7 },
-       { .rfmax = 153000, .val = 0xbd },
-       { .rfmax = 154000, .val = 0x20 },
-       { .rfmax = 155000, .val = 0x22 },
-       { .rfmax = 156000, .val = 0x24 },
-       { .rfmax = 157000, .val = 0x25 },
-       { .rfmax = 158000, .val = 0x27 },
-       { .rfmax = 159000, .val = 0x29 },
-       { .rfmax = 160000, .val = 0x2c },
-       { .rfmax = 161000, .val = 0x2d },
-       { .rfmax = 163000, .val = 0x2e },
-       { .rfmax = 164000, .val = 0x2f },
-       { .rfmax = 165000, .val = 0x30 },
-       { .rfmax = 166000, .val = 0x11 },
-       { .rfmax = 167000, .val = 0x12 },
-       { .rfmax = 168000, .val = 0x13 },
-       { .rfmax = 169000, .val = 0x14 },
-       { .rfmax = 170000, .val = 0x15 },
-       { .rfmax = 172000, .val = 0x16 },
-       { .rfmax = 173000, .val = 0x17 },
-       { .rfmax = 174000, .val = 0x18 },
-       { .rfmax = 175000, .val = 0x1a },
-       { .rfmax = 176000, .val = 0x1b },
-       { .rfmax = 178000, .val = 0x1d },
-       { .rfmax = 179000, .val = 0x1e },
-       { .rfmax = 180000, .val = 0x1f },
-       { .rfmax = 181000, .val = 0x20 },
-       { .rfmax = 182000, .val = 0x21 },
-       { .rfmax = 183000, .val = 0x22 },
-       { .rfmax = 184000, .val = 0x24 },
-       { .rfmax = 185000, .val = 0x25 },
-       { .rfmax = 186000, .val = 0x26 },
-       { .rfmax = 187000, .val = 0x27 },
-       { .rfmax = 188000, .val = 0x29 },
-       { .rfmax = 189000, .val = 0x2a },
-       { .rfmax = 190000, .val = 0x2c },
-       { .rfmax = 191000, .val = 0x2d },
-       { .rfmax = 192000, .val = 0x2e },
-       { .rfmax = 193000, .val = 0x2f },
-       { .rfmax = 194000, .val = 0x30 },
-       { .rfmax = 195000, .val = 0x33 },
-       { .rfmax = 196000, .val = 0x35 },
-       { .rfmax = 198000, .val = 0x36 },
-       { .rfmax = 200000, .val = 0x38 },
-       { .rfmax = 201000, .val = 0x3c },
-       { .rfmax = 202000, .val = 0x3d },
-       { .rfmax = 203500, .val = 0x3e },
-       { .rfmax = 206000, .val = 0x0e },
-       { .rfmax = 208000, .val = 0x0f },
-       { .rfmax = 212000, .val = 0x10 },
-       { .rfmax = 216000, .val = 0x11 },
-       { .rfmax = 217000, .val = 0x12 },
-       { .rfmax = 218000, .val = 0x13 },
-       { .rfmax = 220000, .val = 0x14 },
-       { .rfmax = 222000, .val = 0x15 },
-       { .rfmax = 225000, .val = 0x16 },
-       { .rfmax = 228000, .val = 0x17 },
-       { .rfmax = 231000, .val = 0x18 },
-       { .rfmax = 234000, .val = 0x19 },
-       { .rfmax = 235000, .val = 0x1a },
-       { .rfmax = 236000, .val = 0x1b },
-       { .rfmax = 237000, .val = 0x1c },
-       { .rfmax = 240000, .val = 0x1d },
-       { .rfmax = 242000, .val = 0x1f },
-       { .rfmax = 247000, .val = 0x20 },
-       { .rfmax = 249000, .val = 0x21 },
-       { .rfmax = 252000, .val = 0x22 },
-       { .rfmax = 253000, .val = 0x23 },
-       { .rfmax = 254000, .val = 0x24 },
-       { .rfmax = 256000, .val = 0x25 },
-       { .rfmax = 259000, .val = 0x26 },
-       { .rfmax = 262000, .val = 0x27 },
-       { .rfmax = 264000, .val = 0x28 },
-       { .rfmax = 267000, .val = 0x29 },
-       { .rfmax = 269000, .val = 0x2a },
-       { .rfmax = 271000, .val = 0x2b },
-       { .rfmax = 273000, .val = 0x2c },
-       { .rfmax = 275000, .val = 0x2d },
-       { .rfmax = 277000, .val = 0x2e },
-       { .rfmax = 279000, .val = 0x2f },
-       { .rfmax = 282000, .val = 0x30 },
-       { .rfmax = 284000, .val = 0x31 },
-       { .rfmax = 286000, .val = 0x32 },
-       { .rfmax = 287000, .val = 0x33 },
-       { .rfmax = 290000, .val = 0x34 },
-       { .rfmax = 293000, .val = 0x35 },
-       { .rfmax = 295000, .val = 0x36 },
-       { .rfmax = 297000, .val = 0x37 },
-       { .rfmax = 300000, .val = 0x38 },
-       { .rfmax = 303000, .val = 0x39 },
-       { .rfmax = 305000, .val = 0x3a },
-       { .rfmax = 306000, .val = 0x3b },
-       { .rfmax = 307000, .val = 0x3c },
-       { .rfmax = 310000, .val = 0x3d },
-       { .rfmax = 312000, .val = 0x3e },
-       { .rfmax = 315000, .val = 0x3f },
-       { .rfmax = 318000, .val = 0x40 },
-       { .rfmax = 320000, .val = 0x41 },
-       { .rfmax = 323000, .val = 0x42 },
-       { .rfmax = 324000, .val = 0x43 },
-       { .rfmax = 325000, .val = 0x44 },
-       { .rfmax = 327000, .val = 0x45 },
-       { .rfmax = 331000, .val = 0x46 },
-       { .rfmax = 334000, .val = 0x47 },
-       { .rfmax = 337000, .val = 0x48 },
-       { .rfmax = 339000, .val = 0x49 },
-       { .rfmax = 340000, .val = 0x4a },
-       { .rfmax = 341000, .val = 0x4b },
-       { .rfmax = 343000, .val = 0x4c },
-       { .rfmax = 345000, .val = 0x4d },
-       { .rfmax = 349000, .val = 0x4e },
-       { .rfmax = 352000, .val = 0x4f },
-       { .rfmax = 353000, .val = 0x50 },
-       { .rfmax = 355000, .val = 0x51 },
-       { .rfmax = 357000, .val = 0x52 },
-       { .rfmax = 359000, .val = 0x53 },
-       { .rfmax = 361000, .val = 0x54 },
-       { .rfmax = 362000, .val = 0x55 },
-       { .rfmax = 364000, .val = 0x56 },
-       { .rfmax = 368000, .val = 0x57 },
-       { .rfmax = 370000, .val = 0x58 },
-       { .rfmax = 372000, .val = 0x59 },
-       { .rfmax = 375000, .val = 0x5a },
-       { .rfmax = 376000, .val = 0x5b },
-       { .rfmax = 377000, .val = 0x5c },
-       { .rfmax = 379000, .val = 0x5d },
-       { .rfmax = 382000, .val = 0x5e },
-       { .rfmax = 384000, .val = 0x5f },
-       { .rfmax = 385000, .val = 0x60 },
-       { .rfmax = 386000, .val = 0x61 },
-       { .rfmax = 388000, .val = 0x62 },
-       { .rfmax = 390000, .val = 0x63 },
-       { .rfmax = 393000, .val = 0x64 },
-       { .rfmax = 394000, .val = 0x65 },
-       { .rfmax = 396000, .val = 0x66 },
-       { .rfmax = 397000, .val = 0x67 },
-       { .rfmax = 398000, .val = 0x68 },
-       { .rfmax = 400000, .val = 0x69 },
-       { .rfmax = 402000, .val = 0x6a },
-       { .rfmax = 403000, .val = 0x6b },
-       { .rfmax = 407000, .val = 0x6c },
-       { .rfmax = 408000, .val = 0x6d },
-       { .rfmax = 409000, .val = 0x6e },
-       { .rfmax = 410000, .val = 0x6f },
-       { .rfmax = 411000, .val = 0x70 },
-       { .rfmax = 412000, .val = 0x71 },
-       { .rfmax = 413000, .val = 0x72 },
-       { .rfmax = 414000, .val = 0x73 },
-       { .rfmax = 417000, .val = 0x74 },
-       { .rfmax = 418000, .val = 0x75 },
-       { .rfmax = 420000, .val = 0x76 },
-       { .rfmax = 422000, .val = 0x77 },
-       { .rfmax = 423000, .val = 0x78 },
-       { .rfmax = 424000, .val = 0x79 },
-       { .rfmax = 427000, .val = 0x7a },
-       { .rfmax = 428000, .val = 0x7b },
-       { .rfmax = 429000, .val = 0x7d },
-       { .rfmax = 432000, .val = 0x7f },
-       { .rfmax = 434000, .val = 0x80 },
-       { .rfmax = 435000, .val = 0x81 },
-       { .rfmax = 436000, .val = 0x83 },
-       { .rfmax = 437000, .val = 0x84 },
-       { .rfmax = 438000, .val = 0x85 },
-       { .rfmax = 439000, .val = 0x86 },
-       { .rfmax = 440000, .val = 0x87 },
-       { .rfmax = 441000, .val = 0x88 },
-       { .rfmax = 442000, .val = 0x89 },
-       { .rfmax = 445000, .val = 0x8a },
-       { .rfmax = 446000, .val = 0x8b },
-       { .rfmax = 447000, .val = 0x8c },
-       { .rfmax = 448000, .val = 0x8e },
-       { .rfmax = 449000, .val = 0x8f },
-       { .rfmax = 450000, .val = 0x90 },
-       { .rfmax = 452000, .val = 0x91 },
-       { .rfmax = 453000, .val = 0x93 },
-       { .rfmax = 454000, .val = 0x94 },
-       { .rfmax = 456000, .val = 0x96 },
-       { .rfmax = 457000, .val = 0x98 },
-       { .rfmax = 461000, .val = 0x11 },
-       { .rfmax = 468000, .val = 0x12 },
-       { .rfmax = 472000, .val = 0x13 },
-       { .rfmax = 473000, .val = 0x14 },
-       { .rfmax = 474000, .val = 0x15 },
-       { .rfmax = 481000, .val = 0x16 },
-       { .rfmax = 486000, .val = 0x17 },
-       { .rfmax = 491000, .val = 0x18 },
-       { .rfmax = 498000, .val = 0x19 },
-       { .rfmax = 499000, .val = 0x1a },
-       { .rfmax = 501000, .val = 0x1b },
-       { .rfmax = 506000, .val = 0x1c },
-       { .rfmax = 511000, .val = 0x1d },
-       { .rfmax = 516000, .val = 0x1e },
-       { .rfmax = 520000, .val = 0x1f },
-       { .rfmax = 521000, .val = 0x20 },
-       { .rfmax = 525000, .val = 0x21 },
-       { .rfmax = 529000, .val = 0x22 },
-       { .rfmax = 533000, .val = 0x23 },
-       { .rfmax = 539000, .val = 0x24 },
-       { .rfmax = 541000, .val = 0x25 },
-       { .rfmax = 547000, .val = 0x26 },
-       { .rfmax = 549000, .val = 0x27 },
-       { .rfmax = 551000, .val = 0x28 },
-       { .rfmax = 556000, .val = 0x29 },
-       { .rfmax = 561000, .val = 0x2a },
-       { .rfmax = 563000, .val = 0x2b },
-       { .rfmax = 565000, .val = 0x2c },
-       { .rfmax = 569000, .val = 0x2d },
-       { .rfmax = 571000, .val = 0x2e },
-       { .rfmax = 577000, .val = 0x2f },
-       { .rfmax = 580000, .val = 0x30 },
-       { .rfmax = 582000, .val = 0x31 },
-       { .rfmax = 584000, .val = 0x32 },
-       { .rfmax = 588000, .val = 0x33 },
-       { .rfmax = 591000, .val = 0x34 },
-       { .rfmax = 596000, .val = 0x35 },
-       { .rfmax = 598000, .val = 0x36 },
-       { .rfmax = 603000, .val = 0x37 },
-       { .rfmax = 604000, .val = 0x38 },
-       { .rfmax = 606000, .val = 0x39 },
-       { .rfmax = 612000, .val = 0x3a },
-       { .rfmax = 615000, .val = 0x3b },
-       { .rfmax = 617000, .val = 0x3c },
-       { .rfmax = 621000, .val = 0x3d },
-       { .rfmax = 622000, .val = 0x3e },
-       { .rfmax = 625000, .val = 0x3f },
-       { .rfmax = 632000, .val = 0x40 },
-       { .rfmax = 633000, .val = 0x41 },
-       { .rfmax = 634000, .val = 0x42 },
-       { .rfmax = 642000, .val = 0x43 },
-       { .rfmax = 643000, .val = 0x44 },
-       { .rfmax = 647000, .val = 0x45 },
-       { .rfmax = 650000, .val = 0x46 },
-       { .rfmax = 652000, .val = 0x47 },
-       { .rfmax = 657000, .val = 0x48 },
-       { .rfmax = 661000, .val = 0x49 },
-       { .rfmax = 662000, .val = 0x4a },
-       { .rfmax = 665000, .val = 0x4b },
-       { .rfmax = 667000, .val = 0x4c },
-       { .rfmax = 670000, .val = 0x4d },
-       { .rfmax = 673000, .val = 0x4e },
-       { .rfmax = 676000, .val = 0x4f },
-       { .rfmax = 677000, .val = 0x50 },
-       { .rfmax = 681000, .val = 0x51 },
-       { .rfmax = 683000, .val = 0x52 },
-       { .rfmax = 686000, .val = 0x53 },
-       { .rfmax = 688000, .val = 0x54 },
-       { .rfmax = 689000, .val = 0x55 },
-       { .rfmax = 691000, .val = 0x56 },
-       { .rfmax = 695000, .val = 0x57 },
-       { .rfmax = 698000, .val = 0x58 },
-       { .rfmax = 703000, .val = 0x59 },
-       { .rfmax = 704000, .val = 0x5a },
-       { .rfmax = 705000, .val = 0x5b },
-       { .rfmax = 707000, .val = 0x5c },
-       { .rfmax = 710000, .val = 0x5d },
-       { .rfmax = 712000, .val = 0x5e },
-       { .rfmax = 717000, .val = 0x5f },
-       { .rfmax = 718000, .val = 0x60 },
-       { .rfmax = 721000, .val = 0x61 },
-       { .rfmax = 722000, .val = 0x62 },
-       { .rfmax = 723000, .val = 0x63 },
-       { .rfmax = 725000, .val = 0x64 },
-       { .rfmax = 727000, .val = 0x65 },
-       { .rfmax = 730000, .val = 0x66 },
-       { .rfmax = 732000, .val = 0x67 },
-       { .rfmax = 735000, .val = 0x68 },
-       { .rfmax = 740000, .val = 0x69 },
-       { .rfmax = 741000, .val = 0x6a },
-       { .rfmax = 742000, .val = 0x6b },
-       { .rfmax = 743000, .val = 0x6c },
-       { .rfmax = 745000, .val = 0x6d },
-       { .rfmax = 747000, .val = 0x6e },
-       { .rfmax = 748000, .val = 0x6f },
-       { .rfmax = 750000, .val = 0x70 },
-       { .rfmax = 752000, .val = 0x71 },
-       { .rfmax = 754000, .val = 0x72 },
-       { .rfmax = 757000, .val = 0x73 },
-       { .rfmax = 758000, .val = 0x74 },
-       { .rfmax = 760000, .val = 0x75 },
-       { .rfmax = 763000, .val = 0x76 },
-       { .rfmax = 764000, .val = 0x77 },
-       { .rfmax = 766000, .val = 0x78 },
-       { .rfmax = 767000, .val = 0x79 },
-       { .rfmax = 768000, .val = 0x7a },
-       { .rfmax = 773000, .val = 0x7b },
-       { .rfmax = 774000, .val = 0x7c },
-       { .rfmax = 776000, .val = 0x7d },
-       { .rfmax = 777000, .val = 0x7e },
-       { .rfmax = 778000, .val = 0x7f },
-       { .rfmax = 779000, .val = 0x80 },
-       { .rfmax = 781000, .val = 0x81 },
-       { .rfmax = 783000, .val = 0x82 },
-       { .rfmax = 784000, .val = 0x83 },
-       { .rfmax = 785000, .val = 0x84 },
-       { .rfmax = 786000, .val = 0x85 },
-       { .rfmax = 793000, .val = 0x86 },
-       { .rfmax = 794000, .val = 0x87 },
-       { .rfmax = 795000, .val = 0x88 },
-       { .rfmax = 797000, .val = 0x89 },
-       { .rfmax = 799000, .val = 0x8a },
-       { .rfmax = 801000, .val = 0x8b },
-       { .rfmax = 802000, .val = 0x8c },
-       { .rfmax = 803000, .val = 0x8d },
-       { .rfmax = 804000, .val = 0x8e },
-       { .rfmax = 810000, .val = 0x90 },
-       { .rfmax = 811000, .val = 0x91 },
-       { .rfmax = 812000, .val = 0x92 },
-       { .rfmax = 814000, .val = 0x93 },
-       { .rfmax = 816000, .val = 0x94 },
-       { .rfmax = 817000, .val = 0x96 },
-       { .rfmax = 818000, .val = 0x97 },
-       { .rfmax = 820000, .val = 0x98 },
-       { .rfmax = 821000, .val = 0x99 },
-       { .rfmax = 822000, .val = 0x9a },
-       { .rfmax = 828000, .val = 0x9b },
-       { .rfmax = 829000, .val = 0x9d },
-       { .rfmax = 830000, .val = 0x9f },
-       { .rfmax = 831000, .val = 0xa0 },
-       { .rfmax = 833000, .val = 0xa1 },
-       { .rfmax = 835000, .val = 0xa2 },
-       { .rfmax = 836000, .val = 0xa3 },
-       { .rfmax = 837000, .val = 0xa4 },
-       { .rfmax = 838000, .val = 0xa6 },
-       { .rfmax = 840000, .val = 0xa8 },
-       { .rfmax = 842000, .val = 0xa9 },
-       { .rfmax = 845000, .val = 0xaa },
-       { .rfmax = 846000, .val = 0xab },
-       { .rfmax = 847000, .val = 0xad },
-       { .rfmax = 848000, .val = 0xae },
-       { .rfmax = 852000, .val = 0xaf },
-       { .rfmax = 853000, .val = 0xb0 },
-       { .rfmax = 858000, .val = 0xb1 },
-       { .rfmax = 860000, .val = 0xb2 },
-       { .rfmax = 861000, .val = 0xb3 },
-       { .rfmax = 862000, .val = 0xb4 },
-       { .rfmax = 863000, .val = 0xb6 },
-       { .rfmax = 864000, .val = 0xb8 },
-       { .rfmax = 865000, .val = 0xb9 },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-static struct tda18271_map tda18271_ir_measure[] = {
-       { .rfmax =  30000, .val = 4 },
-       { .rfmax = 200000, .val = 5 },
-       { .rfmax = 600000, .val = 6 },
-       { .rfmax = 865000, .val = 7 },
-       { .rfmax =      0, .val = 0 }, /* end */
-};
-
-static struct tda18271_map tda18271_rf_cal_dc_over_dt[] = {
-       { .rfmax =  47900, .val = 0x00 },
-       { .rfmax =  55000, .val = 0x00 },
-       { .rfmax =  61100, .val = 0x0a },
-       { .rfmax =  64000, .val = 0x0a },
-       { .rfmax =  82000, .val = 0x14 },
-       { .rfmax =  84000, .val = 0x19 },
-       { .rfmax = 119000, .val = 0x1c },
-       { .rfmax = 124000, .val = 0x20 },
-       { .rfmax = 129000, .val = 0x2a },
-       { .rfmax = 134000, .val = 0x32 },
-       { .rfmax = 139000, .val = 0x39 },
-       { .rfmax = 144000, .val = 0x3e },
-       { .rfmax = 149000, .val = 0x3f },
-       { .rfmax = 152600, .val = 0x40 },
-       { .rfmax = 154000, .val = 0x40 },
-       { .rfmax = 164700, .val = 0x41 },
-       { .rfmax = 203500, .val = 0x32 },
-       { .rfmax = 353000, .val = 0x19 },
-       { .rfmax = 356000, .val = 0x1a },
-       { .rfmax = 359000, .val = 0x1b },
-       { .rfmax = 363000, .val = 0x1c },
-       { .rfmax = 366000, .val = 0x1d },
-       { .rfmax = 369000, .val = 0x1e },
-       { .rfmax = 373000, .val = 0x1f },
-       { .rfmax = 376000, .val = 0x20 },
-       { .rfmax = 379000, .val = 0x21 },
-       { .rfmax = 383000, .val = 0x22 },
-       { .rfmax = 386000, .val = 0x23 },
-       { .rfmax = 389000, .val = 0x24 },
-       { .rfmax = 393000, .val = 0x25 },
-       { .rfmax = 396000, .val = 0x26 },
-       { .rfmax = 399000, .val = 0x27 },
-       { .rfmax = 402000, .val = 0x28 },
-       { .rfmax = 404000, .val = 0x29 },
-       { .rfmax = 407000, .val = 0x2a },
-       { .rfmax = 409000, .val = 0x2b },
-       { .rfmax = 412000, .val = 0x2c },
-       { .rfmax = 414000, .val = 0x2d },
-       { .rfmax = 417000, .val = 0x2e },
-       { .rfmax = 419000, .val = 0x2f },
-       { .rfmax = 422000, .val = 0x30 },
-       { .rfmax = 424000, .val = 0x31 },
-       { .rfmax = 427000, .val = 0x32 },
-       { .rfmax = 429000, .val = 0x33 },
-       { .rfmax = 432000, .val = 0x34 },
-       { .rfmax = 434000, .val = 0x35 },
-       { .rfmax = 437000, .val = 0x36 },
-       { .rfmax = 439000, .val = 0x37 },
-       { .rfmax = 442000, .val = 0x38 },
-       { .rfmax = 444000, .val = 0x39 },
-       { .rfmax = 447000, .val = 0x3a },
-       { .rfmax = 449000, .val = 0x3b },
-       { .rfmax = 457800, .val = 0x3c },
-       { .rfmax = 465000, .val = 0x0f },
-       { .rfmax = 477000, .val = 0x12 },
-       { .rfmax = 483000, .val = 0x14 },
-       { .rfmax = 502000, .val = 0x19 },
-       { .rfmax = 508000, .val = 0x1b },
-       { .rfmax = 519000, .val = 0x1c },
-       { .rfmax = 522000, .val = 0x1d },
-       { .rfmax = 524000, .val = 0x1e },
-       { .rfmax = 534000, .val = 0x1f },
-       { .rfmax = 549000, .val = 0x20 },
-       { .rfmax = 554000, .val = 0x22 },
-       { .rfmax = 584000, .val = 0x24 },
-       { .rfmax = 589000, .val = 0x26 },
-       { .rfmax = 658000, .val = 0x27 },
-       { .rfmax = 664000, .val = 0x2c },
-       { .rfmax = 669000, .val = 0x2d },
-       { .rfmax = 699000, .val = 0x2e },
-       { .rfmax = 704000, .val = 0x30 },
-       { .rfmax = 709000, .val = 0x31 },
-       { .rfmax = 714000, .val = 0x32 },
-       { .rfmax = 724000, .val = 0x33 },
-       { .rfmax = 729000, .val = 0x36 },
-       { .rfmax = 739000, .val = 0x38 },
-       { .rfmax = 744000, .val = 0x39 },
-       { .rfmax = 749000, .val = 0x3b },
-       { .rfmax = 754000, .val = 0x3c },
-       { .rfmax = 759000, .val = 0x3d },
-       { .rfmax = 764000, .val = 0x3e },
-       { .rfmax = 769000, .val = 0x3f },
-       { .rfmax = 774000, .val = 0x40 },
-       { .rfmax = 779000, .val = 0x41 },
-       { .rfmax = 784000, .val = 0x43 },
-       { .rfmax = 789000, .val = 0x46 },
-       { .rfmax = 794000, .val = 0x48 },
-       { .rfmax = 799000, .val = 0x4b },
-       { .rfmax = 804000, .val = 0x4f },
-       { .rfmax = 809000, .val = 0x54 },
-       { .rfmax = 814000, .val = 0x59 },
-       { .rfmax = 819000, .val = 0x5d },
-       { .rfmax = 824000, .val = 0x61 },
-       { .rfmax = 829000, .val = 0x68 },
-       { .rfmax = 834000, .val = 0x6e },
-       { .rfmax = 839000, .val = 0x75 },
-       { .rfmax = 844000, .val = 0x7e },
-       { .rfmax = 849000, .val = 0x82 },
-       { .rfmax = 854000, .val = 0x84 },
-       { .rfmax = 859000, .val = 0x8f },
-       { .rfmax = 865000, .val = 0x9a },
-       { .rfmax =      0, .val = 0x00 }, /* end */
-};
-
-/*---------------------------------------------------------------------*/
-
-struct tda18271_thermo_map {
-       u8 d;
-       u8 r0;
-       u8 r1;
-};
-
-static struct tda18271_thermo_map tda18271_thermometer[] = {
-       { .d = 0x00, .r0 = 60, .r1 =  92 },
-       { .d = 0x01, .r0 = 62, .r1 =  94 },
-       { .d = 0x02, .r0 = 66, .r1 =  98 },
-       { .d = 0x03, .r0 = 64, .r1 =  96 },
-       { .d = 0x04, .r0 = 74, .r1 = 106 },
-       { .d = 0x05, .r0 = 72, .r1 = 104 },
-       { .d = 0x06, .r0 = 68, .r1 = 100 },
-       { .d = 0x07, .r0 = 70, .r1 = 102 },
-       { .d = 0x08, .r0 = 90, .r1 = 122 },
-       { .d = 0x09, .r0 = 88, .r1 = 120 },
-       { .d = 0x0a, .r0 = 84, .r1 = 116 },
-       { .d = 0x0b, .r0 = 86, .r1 = 118 },
-       { .d = 0x0c, .r0 = 76, .r1 = 108 },
-       { .d = 0x0d, .r0 = 78, .r1 = 110 },
-       { .d = 0x0e, .r0 = 82, .r1 = 114 },
-       { .d = 0x0f, .r0 = 80, .r1 = 112 },
-       { .d = 0x00, .r0 =  0, .r1 =   0 }, /* end */
-};
-
-int tda18271_lookup_thermometer(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       unsigned char *regs = priv->tda18271_regs;
-       int val, i = 0;
-
-       while (tda18271_thermometer[i].d < (regs[R_TM] & 0x0f)) {
-               if (tda18271_thermometer[i + 1].d == 0)
-                       break;
-               i++;
-       }
-
-       if ((regs[R_TM] & 0x20) == 0x20)
-               val = tda18271_thermometer[i].r1;
-       else
-               val = tda18271_thermometer[i].r0;
-
-       tda_map("(%d) tm = %d\n", i, val);
-
-       return val;
-}
-
-/*---------------------------------------------------------------------*/
-
-struct tda18271_cid_target_map {
-       u32 rfmax;
-       u8  target;
-       u16 limit;
-};
-
-static struct tda18271_cid_target_map tda18271_cid_target[] = {
-       { .rfmax =  46000, .target = 0x04, .limit =  1800 },
-       { .rfmax =  52200, .target = 0x0a, .limit =  1500 },
-       { .rfmax =  79100, .target = 0x01, .limit =  4000 },
-       { .rfmax = 136800, .target = 0x18, .limit =  4000 },
-       { .rfmax = 156700, .target = 0x18, .limit =  4000 },
-       { .rfmax = 156700, .target = 0x18, .limit =  4000 },
-       { .rfmax = 186250, .target = 0x0a, .limit =  4000 },
-       { .rfmax = 230000, .target = 0x0a, .limit =  4000 },
-       { .rfmax = 345000, .target = 0x18, .limit =  4000 },
-       { .rfmax = 426000, .target = 0x0e, .limit =  4000 },
-       { .rfmax = 489500, .target = 0x1e, .limit =  4000 },
-       { .rfmax = 697500, .target = 0x32, .limit =  4000 },
-       { .rfmax = 842000, .target = 0x3a, .limit =  4000 },
-       { .rfmax =      0, .target = 0x00, .limit =     0 }, /* end */
-};
-
-int tda18271_lookup_cid_target(struct dvb_frontend *fe,
-                              u32 *freq, u8 *cid_target, u16 *count_limit)
-{
-       int i = 0;
-
-       while ((tda18271_cid_target[i].rfmax * 1000) < *freq) {
-               if (tda18271_cid_target[i + 1].rfmax == 0)
-                       break;
-               i++;
-       }
-       *cid_target  = tda18271_cid_target[i].target;
-       *count_limit = tda18271_cid_target[i].limit;
-
-       tda_map("(%d) cid_target = %02x, count_limit = %d\n", i,
-               tda18271_cid_target[i].target, tda18271_cid_target[i].limit);
-
-       return 0;
-}
-
-/*---------------------------------------------------------------------*/
-
-static struct tda18271_rf_tracking_filter_cal tda18271_rf_band_template[] = {
-       { .rfmax =  47900, .rfband = 0x00,
-         .rf1_def =  46000, .rf2_def =      0, .rf3_def =      0 },
-       { .rfmax =  61100, .rfband = 0x01,
-         .rf1_def =  52200, .rf2_def =      0, .rf3_def =      0 },
-       { .rfmax = 152600, .rfband = 0x02,
-         .rf1_def =  70100, .rf2_def = 136800, .rf3_def =      0 },
-       { .rfmax = 164700, .rfband = 0x03,
-         .rf1_def = 156700, .rf2_def =      0, .rf3_def =      0 },
-       { .rfmax = 203500, .rfband = 0x04,
-         .rf1_def = 186250, .rf2_def =      0, .rf3_def =      0 },
-       { .rfmax = 457800, .rfband = 0x05,
-         .rf1_def = 230000, .rf2_def = 345000, .rf3_def = 426000 },
-       { .rfmax = 865000, .rfband = 0x06,
-         .rf1_def = 489500, .rf2_def = 697500, .rf3_def = 842000 },
-       { .rfmax =      0, .rfband = 0x00,
-         .rf1_def =      0, .rf2_def =      0, .rf3_def =      0 }, /* end */
-};
-
-int tda18271_lookup_rf_band(struct dvb_frontend *fe, u32 *freq, u8 *rf_band)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_rf_tracking_filter_cal *map = priv->rf_cal_state;
-       int i = 0;
-
-       while ((map[i].rfmax * 1000) < *freq) {
-               if (tda18271_debug & DBG_ADV)
-                       tda_map("(%d) rfmax = %d < freq = %d, "
-                               "rf1_def = %d, rf2_def = %d, rf3_def = %d, "
-                               "rf1 = %d, rf2 = %d, rf3 = %d, "
-                               "rf_a1 = %d, rf_a2 = %d, "
-                               "rf_b1 = %d, rf_b2 = %d\n",
-                               i, map[i].rfmax * 1000, *freq,
-                               map[i].rf1_def, map[i].rf2_def, map[i].rf3_def,
-                               map[i].rf1, map[i].rf2, map[i].rf3,
-                               map[i].rf_a1, map[i].rf_a2,
-                               map[i].rf_b1, map[i].rf_b2);
-               if (map[i].rfmax == 0)
-                       return -EINVAL;
-               i++;
-       }
-       if (rf_band)
-               *rf_band = map[i].rfband;
-
-       tda_map("(%d) rf_band = %02x\n", i, map[i].rfband);
-
-       return i;
-}
-
-/*---------------------------------------------------------------------*/
-
-struct tda18271_map_layout {
-       struct tda18271_pll_map *main_pll;
-       struct tda18271_pll_map *cal_pll;
-
-       struct tda18271_map *rf_cal;
-       struct tda18271_map *rf_cal_kmco;
-       struct tda18271_map *rf_cal_dc_over_dt;
-
-       struct tda18271_map *bp_filter;
-       struct tda18271_map *rf_band;
-       struct tda18271_map *gain_taper;
-       struct tda18271_map *ir_measure;
-};
-
-/*---------------------------------------------------------------------*/
-
-int tda18271_lookup_pll_map(struct dvb_frontend *fe,
-                           enum tda18271_map_type map_type,
-                           u32 *freq, u8 *post_div, u8 *div)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_pll_map *map = NULL;
-       unsigned int i = 0;
-       char *map_name;
-       int ret = 0;
-
-       BUG_ON(!priv->maps);
-
-       switch (map_type) {
-       case MAIN_PLL:
-               map = priv->maps->main_pll;
-               map_name = "main_pll";
-               break;
-       case CAL_PLL:
-               map = priv->maps->cal_pll;
-               map_name = "cal_pll";
-               break;
-       default:
-               /* we should never get here */
-               map_name = "undefined";
-               break;
-       }
-
-       if (!map) {
-               tda_warn("%s map is not set!\n", map_name);
-               ret = -EINVAL;
-               goto fail;
-       }
-
-       while ((map[i].lomax * 1000) < *freq) {
-               if (map[i + 1].lomax == 0) {
-                       tda_map("%s: frequency (%d) out of range\n",
-                               map_name, *freq);
-                       ret = -ERANGE;
-                       break;
-               }
-               i++;
-       }
-       *post_div = map[i].pd;
-       *div      = map[i].d;
-
-       tda_map("(%d) %s: post div = 0x%02x, div = 0x%02x\n",
-               i, map_name, *post_div, *div);
-fail:
-       return ret;
-}
-
-int tda18271_lookup_map(struct dvb_frontend *fe,
-                       enum tda18271_map_type map_type,
-                       u32 *freq, u8 *val)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       struct tda18271_map *map = NULL;
-       unsigned int i = 0;
-       char *map_name;
-       int ret = 0;
-
-       BUG_ON(!priv->maps);
-
-       switch (map_type) {
-       case BP_FILTER:
-               map = priv->maps->bp_filter;
-               map_name = "bp_filter";
-               break;
-       case RF_CAL_KMCO:
-               map = priv->maps->rf_cal_kmco;
-               map_name = "km";
-               break;
-       case RF_BAND:
-               map = priv->maps->rf_band;
-               map_name = "rf_band";
-               break;
-       case GAIN_TAPER:
-               map = priv->maps->gain_taper;
-               map_name = "gain_taper";
-               break;
-       case RF_CAL:
-               map = priv->maps->rf_cal;
-               map_name = "rf_cal";
-               break;
-       case IR_MEASURE:
-               map = priv->maps->ir_measure;
-               map_name = "ir_measure";
-               break;
-       case RF_CAL_DC_OVER_DT:
-               map = priv->maps->rf_cal_dc_over_dt;
-               map_name = "rf_cal_dc_over_dt";
-               break;
-       default:
-               /* we should never get here */
-               map_name = "undefined";
-               break;
-       }
-
-       if (!map) {
-               tda_warn("%s map is not set!\n", map_name);
-               ret = -EINVAL;
-               goto fail;
-       }
-
-       while ((map[i].rfmax * 1000) < *freq) {
-               if (map[i + 1].rfmax == 0) {
-                       tda_map("%s: frequency (%d) out of range\n",
-                               map_name, *freq);
-                       ret = -ERANGE;
-                       break;
-               }
-               i++;
-       }
-       *val = map[i].val;
-
-       tda_map("(%d) %s: 0x%02x\n", i, map_name, *val);
-fail:
-       return ret;
-}
-
-/*---------------------------------------------------------------------*/
-
-static struct tda18271_std_map tda18271c1_std_map = {
-       .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
-       .atv_b    = { .if_freq = 6750, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_dk   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
-       .atv_gh   = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
-       .atv_i    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
-       .atv_l    = { .if_freq = 7750, .fm_rfn = 0, .agc_mode = 1, .std = 7,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
-       .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 7,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0f */
-       .atv_mn   = { .if_freq = 5750, .fm_rfn = 0, .agc_mode = 1, .std = 5,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
-       .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
-       .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
-       .dvbt_7   = { .if_freq = 3800, .fm_rfn = 0, .agc_mode = 3, .std = 5,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
-       .dvbt_8   = { .if_freq = 4300, .fm_rfn = 0, .agc_mode = 3, .std = 6,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1e */
-       .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
-       .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
-};
-
-static struct tda18271_std_map tda18271c2_std_map = {
-       .fm_radio = { .if_freq = 1250, .fm_rfn = 1, .agc_mode = 3, .std = 0,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x18 */
-       .atv_b    = { .if_freq = 6000, .fm_rfn = 0, .agc_mode = 1, .std = 5,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0d */
-       .atv_dk   = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_gh   = { .if_freq = 7100, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_i    = { .if_freq = 7250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_l    = { .if_freq = 6900, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_lc   = { .if_freq = 1250, .fm_rfn = 0, .agc_mode = 1, .std = 6,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0e */
-       .atv_mn   = { .if_freq = 5400, .fm_rfn = 0, .agc_mode = 1, .std = 4,
-                     .if_lvl = 0, .rfagc_top = 0x2c, }, /* EP3[4:0] 0x0c */
-       .atsc_6   = { .if_freq = 3250, .fm_rfn = 0, .agc_mode = 3, .std = 4,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
-       .dvbt_6   = { .if_freq = 3300, .fm_rfn = 0, .agc_mode = 3, .std = 4,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
-       .dvbt_7   = { .if_freq = 3500, .fm_rfn = 0, .agc_mode = 3, .std = 4,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1c */
-       .dvbt_8   = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
-       .qam_6    = { .if_freq = 4000, .fm_rfn = 0, .agc_mode = 3, .std = 5,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1d */
-       .qam_8    = { .if_freq = 5000, .fm_rfn = 0, .agc_mode = 3, .std = 7,
-                     .if_lvl = 1, .rfagc_top = 0x37, }, /* EP3[4:0] 0x1f */
-};
-
-/*---------------------------------------------------------------------*/
-
-static struct tda18271_map_layout tda18271c1_map_layout = {
-       .main_pll          = tda18271c1_main_pll,
-       .cal_pll           = tda18271c1_cal_pll,
-
-       .rf_cal            = tda18271c1_rf_cal,
-       .rf_cal_kmco       = tda18271c1_km,
-
-       .bp_filter         = tda18271_bp_filter,
-       .rf_band           = tda18271_rf_band,
-       .gain_taper        = tda18271_gain_taper,
-       .ir_measure        = tda18271_ir_measure,
-};
-
-static struct tda18271_map_layout tda18271c2_map_layout = {
-       .main_pll          = tda18271c2_main_pll,
-       .cal_pll           = tda18271c2_cal_pll,
-
-       .rf_cal            = tda18271c2_rf_cal,
-       .rf_cal_kmco       = tda18271c2_km,
-
-       .rf_cal_dc_over_dt = tda18271_rf_cal_dc_over_dt,
-
-       .bp_filter         = tda18271_bp_filter,
-       .rf_band           = tda18271_rf_band,
-       .gain_taper        = tda18271_gain_taper,
-       .ir_measure        = tda18271_ir_measure,
-};
-
-int tda18271_assign_map_layout(struct dvb_frontend *fe)
-{
-       struct tda18271_priv *priv = fe->tuner_priv;
-       int ret = 0;
-
-       switch (priv->id) {
-       case TDA18271HDC1:
-               priv->maps = &tda18271c1_map_layout;
-               memcpy(&priv->std, &tda18271c1_std_map,
-                      sizeof(struct tda18271_std_map));
-               break;
-       case TDA18271HDC2:
-               priv->maps = &tda18271c2_map_layout;
-               memcpy(&priv->std, &tda18271c2_std_map,
-                      sizeof(struct tda18271_std_map));
-               break;
-       default:
-               ret = -EINVAL;
-               break;
-       }
-       memcpy(priv->rf_cal_state, &tda18271_rf_band_template,
-              sizeof(tda18271_rf_band_template));
-
-       return ret;
-}
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/dvb/frontends/tda18271.h b/drivers/media/dvb/frontends/tda18271.h
deleted file mode 100644 (file)
index 0e7af8d..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
-    tda18271.h - header for the Philips / NXP TDA18271 silicon tuner
-
-    Copyright (C) 2007, 2008 Michael Krufky <mkrufky@linuxtv.org>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TDA18271_H__
-#define __TDA18271_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-struct tda18271_std_map_item {
-       u16 if_freq;
-
-       /* EP3[4:3] */
-       unsigned int agc_mode:2;
-       /* EP3[2:0] */
-       unsigned int std:3;
-       /* EP4[7] */
-       unsigned int fm_rfn:1;
-       /* EP4[4:2] */
-       unsigned int if_lvl:3;
-       /* EB22[6:0] */
-       unsigned int rfagc_top:7;
-};
-
-struct tda18271_std_map {
-       struct tda18271_std_map_item fm_radio;
-       struct tda18271_std_map_item atv_b;
-       struct tda18271_std_map_item atv_dk;
-       struct tda18271_std_map_item atv_gh;
-       struct tda18271_std_map_item atv_i;
-       struct tda18271_std_map_item atv_l;
-       struct tda18271_std_map_item atv_lc;
-       struct tda18271_std_map_item atv_mn;
-       struct tda18271_std_map_item atsc_6;
-       struct tda18271_std_map_item dvbt_6;
-       struct tda18271_std_map_item dvbt_7;
-       struct tda18271_std_map_item dvbt_8;
-       struct tda18271_std_map_item qam_6;
-       struct tda18271_std_map_item qam_8;
-};
-
-enum tda18271_role {
-       TDA18271_MASTER = 0,
-       TDA18271_SLAVE,
-};
-
-enum tda18271_i2c_gate {
-       TDA18271_GATE_AUTO = 0,
-       TDA18271_GATE_ANALOG,
-       TDA18271_GATE_DIGITAL,
-};
-
-struct tda18271_config {
-       /* override default if freq / std settings (optional) */
-       struct tda18271_std_map *std_map;
-
-       /* master / slave tuner: master uses main pll, slave uses cal pll */
-       enum tda18271_role role;
-
-       /* use i2c gate provided by analog or digital demod */
-       enum tda18271_i2c_gate gate;
-
-       /* some i2c providers cant write all 39 registers at once */
-       unsigned int small_i2c:1;
-};
-
-#if defined(CONFIG_DVB_TDA18271) || (defined(CONFIG_DVB_TDA18271_MODULE) && defined(MODULE))
-extern struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe, u8 addr,
-                                           struct i2c_adapter *i2c,
-                                           struct tda18271_config *cfg);
-#else
-static inline struct dvb_frontend *tda18271_attach(struct dvb_frontend *fe,
-                                                  u8 addr,
-                                                  struct i2c_adapter *i2c,
-                                                  struct tda18271_config *cfg)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TDA18271_H__ */
diff --git a/drivers/media/dvb/frontends/tda827x.c b/drivers/media/dvb/frontends/tda827x.c
deleted file mode 100644 (file)
index d30d2c9..0000000
+++ /dev/null
@@ -1,852 +0,0 @@
-/*
- *
- * (c) 2005 Hartmut Hackmann
- * (c) 2007 Michael Krufky
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/module.h>
-#include <asm/types.h>
-#include <linux/dvb/frontend.h>
-#include <linux/videodev2.h>
-
-#include "tda827x.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
-
-#define dprintk(args...) \
-       do {                                        \
-               if (debug) printk(KERN_DEBUG "tda827x: " args); \
-       } while (0)
-
-struct tda827x_priv {
-       int i2c_addr;
-       struct i2c_adapter *i2c_adap;
-       struct tda827x_config *cfg;
-
-       unsigned int sgIF;
-       unsigned char lpsel;
-
-       u32 frequency;
-       u32 bandwidth;
-};
-
-static void tda827x_set_std(struct dvb_frontend *fe,
-                           struct analog_parameters *params)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       char *mode;
-
-       priv->lpsel = 0;
-       if (params->std & V4L2_STD_MN) {
-               priv->sgIF = 92;
-               priv->lpsel = 1;
-               mode = "MN";
-       } else if (params->std & V4L2_STD_B) {
-               priv->sgIF = 108;
-               mode = "B";
-       } else if (params->std & V4L2_STD_GH) {
-               priv->sgIF = 124;
-               mode = "GH";
-       } else if (params->std & V4L2_STD_PAL_I) {
-               priv->sgIF = 124;
-               mode = "I";
-       } else if (params->std & V4L2_STD_DK) {
-               priv->sgIF = 124;
-               mode = "DK";
-       } else if (params->std & V4L2_STD_SECAM_L) {
-               priv->sgIF = 124;
-               mode = "L";
-       } else if (params->std & V4L2_STD_SECAM_LC) {
-               priv->sgIF = 20;
-               mode = "LC";
-       } else {
-               priv->sgIF = 124;
-               mode = "xx";
-       }
-
-       if (params->mode == V4L2_TUNER_RADIO)
-               priv->sgIF = 88; /* if frequency is 5.5 MHz */
-
-       dprintk("setting tda827x to system %s\n", mode);
-}
-
-
-/* ------------------------------------------------------------------ */
-
-struct tda827x_data {
-       u32 lomax;
-       u8  spd;
-       u8  bs;
-       u8  bp;
-       u8  cp;
-       u8  gc3;
-       u8 div1p5;
-};
-
-static const struct tda827x_data tda827x_table[] = {
-       { .lomax =  62000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
-       { .lomax =  66000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 1},
-       { .lomax =  76000000, .spd = 3, .bs = 1, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
-       { .lomax =  84000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 3, .div1p5 = 0},
-       { .lomax =  93000000, .spd = 3, .bs = 2, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax =  98000000, .spd = 3, .bs = 3, .bp = 0, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 109000000, .spd = 3, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 123000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 133000000, .spd = 2, .bs = 3, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 151000000, .spd = 2, .bs = 1, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 154000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 181000000, .spd = 2, .bs = 2, .bp = 1, .cp = 0, .gc3 = 0, .div1p5 = 0},
-       { .lomax = 185000000, .spd = 2, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 217000000, .spd = 2, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 244000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 265000000, .spd = 1, .bs = 3, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 302000000, .spd = 1, .bs = 1, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 324000000, .spd = 1, .bs = 2, .bp = 2, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 370000000, .spd = 1, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 454000000, .spd = 1, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 493000000, .spd = 0, .bs = 2, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 530000000, .spd = 0, .bs = 3, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 1},
-       { .lomax = 554000000, .spd = 0, .bs = 1, .bp = 3, .cp = 0, .gc3 = 1, .div1p5 = 0},
-       { .lomax = 604000000, .spd = 0, .bs = 1, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
-       { .lomax = 696000000, .spd = 0, .bs = 2, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
-       { .lomax = 740000000, .spd = 0, .bs = 2, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
-       { .lomax = 820000000, .spd = 0, .bs = 3, .bp = 4, .cp = 0, .gc3 = 0, .div1p5 = 0},
-       { .lomax = 865000000, .spd = 0, .bs = 3, .bp = 4, .cp = 1, .gc3 = 0, .div1p5 = 0},
-       { .lomax =         0, .spd = 0, .bs = 0, .bp = 0, .cp = 0, .gc3 = 0, .div1p5 = 0}
-};
-
-static int tda827xo_set_params(struct dvb_frontend *fe,
-                              struct dvb_frontend_parameters *params)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       u8 buf[14];
-
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
-       int i, tuner_freq, if_freq;
-       u32 N;
-
-       dprintk("%s:\n", __func__);
-       switch (params->u.ofdm.bandwidth) {
-       case BANDWIDTH_6_MHZ:
-               if_freq = 4000000;
-               break;
-       case BANDWIDTH_7_MHZ:
-               if_freq = 4500000;
-               break;
-       default:                   /* 8 MHz or Auto */
-               if_freq = 5000000;
-               break;
-       }
-       tuner_freq = params->frequency + if_freq;
-
-       i = 0;
-       while (tda827x_table[i].lomax < tuner_freq) {
-               if (tda827x_table[i + 1].lomax == 0)
-                       break;
-               i++;
-       }
-
-       N = ((tuner_freq + 125000) / 250000) << (tda827x_table[i].spd + 2);
-       buf[0] = 0;
-       buf[1] = (N>>8) | 0x40;
-       buf[2] = N & 0xff;
-       buf[3] = 0;
-       buf[4] = 0x52;
-       buf[5] = (tda827x_table[i].spd << 6) + (tda827x_table[i].div1p5 << 5) +
-                               (tda827x_table[i].bs << 3) +
-                               tda827x_table[i].bp;
-       buf[6] = (tda827x_table[i].gc3 << 4) + 0x8f;
-       buf[7] = 0xbf;
-       buf[8] = 0x2a;
-       buf[9] = 0x05;
-       buf[10] = 0xff;
-       buf[11] = 0x00;
-       buf[12] = 0x00;
-       buf[13] = 0x40;
-
-       msg.len = 14;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
-               printk("%s: could not write to tuner at addr: 0x%02x\n",
-                      __func__, priv->i2c_addr << 1);
-               return -EIO;
-       }
-       msleep(500);
-       /* correct CP value */
-       buf[0] = 0x30;
-       buf[1] = 0x50 + tda827x_table[i].cp;
-       msg.len = 2;
-
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       priv->frequency = tuner_freq - if_freq; // FIXME
-       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
-
-       return 0;
-}
-
-static int tda827xo_sleep(struct dvb_frontend *fe)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       static u8 buf[] = { 0x30, 0xd0 };
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
-
-       dprintk("%s:\n", __func__);
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       if (priv->cfg && priv->cfg->sleep)
-               priv->cfg->sleep(fe);
-
-       return 0;
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda827xo_set_analog_params(struct dvb_frontend *fe,
-                                     struct analog_parameters *params)
-{
-       unsigned char tuner_reg[8];
-       unsigned char reg2[2];
-       u32 N;
-       int i;
-       struct tda827x_priv *priv = fe->tuner_priv;
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0 };
-       unsigned int freq = params->frequency;
-
-       tda827x_set_std(fe, params);
-
-       if (params->mode == V4L2_TUNER_RADIO)
-               freq = freq / 1000;
-
-       N = freq + priv->sgIF;
-
-       i = 0;
-       while (tda827x_table[i].lomax < N * 62500) {
-               if (tda827x_table[i + 1].lomax == 0)
-                       break;
-               i++;
-       }
-
-       N = N << tda827x_table[i].spd;
-
-       tuner_reg[0] = 0;
-       tuner_reg[1] = (unsigned char)(N>>8);
-       tuner_reg[2] = (unsigned char) N;
-       tuner_reg[3] = 0x40;
-       tuner_reg[4] = 0x52 + (priv->lpsel << 5);
-       tuner_reg[5] = (tda827x_table[i].spd    << 6) +
-                      (tda827x_table[i].div1p5 << 5) +
-                      (tda827x_table[i].bs     << 3) + tda827x_table[i].bp;
-       tuner_reg[6] = 0x8f + (tda827x_table[i].gc3 << 4);
-       tuner_reg[7] = 0x8f;
-
-       msg.buf = tuner_reg;
-       msg.len = 8;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msg.buf = reg2;
-       msg.len = 2;
-       reg2[0] = 0x80;
-       reg2[1] = 0;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       reg2[0] = 0x60;
-       reg2[1] = 0xbf;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       reg2[0] = 0x30;
-       reg2[1] = tuner_reg[4] + 0x80;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(1);
-       reg2[0] = 0x30;
-       reg2[1] = tuner_reg[4] + 4;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(1);
-       reg2[0] = 0x30;
-       reg2[1] = tuner_reg[4];
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(550);
-       reg2[0] = 0x30;
-       reg2[1] = (tuner_reg[4] & 0xfc) + tda827x_table[i].cp;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       reg2[0] = 0x60;
-       reg2[1] = 0x3f;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       reg2[0] = 0x80;
-       reg2[1] = 0x08;   /* Vsync en */
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       priv->frequency = freq * 62500;
-
-       return 0;
-}
-
-static void tda827xo_agcf(struct dvb_frontend *fe)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       unsigned char data[] = { 0x80, 0x0c };
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = data, .len = 2};
-
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-}
-
-/* ------------------------------------------------------------------ */
-
-struct tda827xa_data {
-       u32 lomax;
-       u8  svco;
-       u8  spd;
-       u8  scr;
-       u8  sbs;
-       u8  gc3;
-};
-
-static const struct tda827xa_data tda827xa_dvbt[] = {
-       { .lomax =  56875000, .svco = 3, .spd = 4, .scr = 0, .sbs = 0, .gc3 = 1},
-       { .lomax =  67250000, .svco = 0, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
-       { .lomax =  81250000, .svco = 1, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
-       { .lomax =  97500000, .svco = 2, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 1},
-       { .lomax = 113750000, .svco = 3, .spd = 3, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 134500000, .svco = 0, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 154000000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 162500000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 183000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 195000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 227500000, .svco = 3, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 269000000, .svco = 0, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 290000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 325000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 390000000, .svco = 2, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 455000000, .svco = 3, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 520000000, .svco = 0, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 538000000, .svco = 0, .spd = 0, .scr = 1, .sbs = 3, .gc3 = 1},
-       { .lomax = 550000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 620000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 650000000, .svco = 1, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 700000000, .svco = 2, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 780000000, .svco = 2, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 820000000, .svco = 3, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 870000000, .svco = 3, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 911000000, .svco = 3, .spd = 0, .scr = 2, .sbs = 4, .gc3 = 0},
-       { .lomax =         0, .svco = 0, .spd = 0, .scr = 0, .sbs = 0, .gc3 = 0}
-};
-
-static struct tda827xa_data tda827xa_analog[] = {
-       { .lomax =  56875000, .svco = 3, .spd = 4, .scr = 0, .sbs = 0, .gc3 = 3},
-       { .lomax =  67250000, .svco = 0, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
-       { .lomax =  81250000, .svco = 1, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
-       { .lomax =  97500000, .svco = 2, .spd = 3, .scr = 0, .sbs = 0, .gc3 = 3},
-       { .lomax = 113750000, .svco = 3, .spd = 3, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 134500000, .svco = 0, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 154000000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 162500000, .svco = 1, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 183000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 1, .gc3 = 1},
-       { .lomax = 195000000, .svco = 2, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 227500000, .svco = 3, .spd = 2, .scr = 0, .sbs = 2, .gc3 = 3},
-       { .lomax = 269000000, .svco = 0, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 3},
-       { .lomax = 325000000, .svco = 1, .spd = 1, .scr = 0, .sbs = 2, .gc3 = 1},
-       { .lomax = 390000000, .svco = 2, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 3},
-       { .lomax = 455000000, .svco = 3, .spd = 1, .scr = 0, .sbs = 3, .gc3 = 3},
-       { .lomax = 520000000, .svco = 0, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 538000000, .svco = 0, .spd = 0, .scr = 1, .sbs = 3, .gc3 = 1},
-       { .lomax = 554000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 3, .gc3 = 1},
-       { .lomax = 620000000, .svco = 1, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 650000000, .svco = 1, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 700000000, .svco = 2, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 780000000, .svco = 2, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 820000000, .svco = 3, .spd = 0, .scr = 0, .sbs = 4, .gc3 = 0},
-       { .lomax = 870000000, .svco = 3, .spd = 0, .scr = 1, .sbs = 4, .gc3 = 0},
-       { .lomax = 911000000, .svco = 3, .spd = 0, .scr = 2, .sbs = 4, .gc3 = 0},
-       { .lomax =         0, .svco = 0, .spd = 0, .scr = 0, .sbs = 0, .gc3 = 0}
-};
-
-static int tda827xa_sleep(struct dvb_frontend *fe)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       static u8 buf[] = { 0x30, 0x90 };
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
-
-       dprintk("%s:\n", __func__);
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 0);
-
-       if (priv->cfg && priv->cfg->sleep)
-               priv->cfg->sleep(fe);
-
-       return 0;
-}
-
-static void tda827xa_lna_gain(struct dvb_frontend *fe, int high,
-                             struct analog_parameters *params)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       unsigned char buf[] = {0x22, 0x01};
-       int arg;
-       int gp_func;
-       struct i2c_msg msg = { .addr = priv->cfg->switch_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
-
-       if (NULL == priv->cfg) {
-               dprintk("tda827x_config not defined, cannot set LNA gain!\n");
-               return;
-       }
-       if (priv->cfg->config) {
-               if (high)
-                       dprintk("setting LNA to high gain\n");
-               else
-                       dprintk("setting LNA to low gain\n");
-       }
-       switch (priv->cfg->config) {
-       case 0: /* no LNA */
-               break;
-       case 1: /* switch is GPIO 0 of tda8290 */
-       case 2:
-               if (params == NULL) {
-                       gp_func = 0;
-                       arg  = 0;
-               } else {
-                       /* turn Vsync on */
-                       gp_func = 1;
-                       if (params->std & V4L2_STD_MN)
-                               arg = 1;
-                       else
-                               arg = 0;
-               }
-               if (priv->cfg->tuner_callback)
-                       priv->cfg->tuner_callback(priv->i2c_adap->algo_data,
-                                                               gp_func, arg);
-               buf[1] = high ? 0 : 1;
-               if (priv->cfg->config == 2)
-                       buf[1] = high ? 1 : 0;
-               i2c_transfer(priv->i2c_adap, &msg, 1);
-               break;
-       case 3: /* switch with GPIO of saa713x */
-               if (priv->cfg->tuner_callback)
-                       priv->cfg->tuner_callback(priv->i2c_adap->algo_data, 0, high);
-               break;
-       }
-}
-
-static int tda827xa_set_params(struct dvb_frontend *fe,
-                              struct dvb_frontend_parameters *params)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       u8 buf[11];
-
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = buf, .len = sizeof(buf) };
-
-       int i, tuner_freq, if_freq;
-       u32 N;
-
-       dprintk("%s:\n", __func__);
-
-       tda827xa_lna_gain(fe, 1, NULL);
-       msleep(20);
-
-       switch (params->u.ofdm.bandwidth) {
-       case BANDWIDTH_6_MHZ:
-               if_freq = 4000000;
-               break;
-       case BANDWIDTH_7_MHZ:
-               if_freq = 4500000;
-               break;
-       default:                   /* 8 MHz or Auto */
-               if_freq = 5000000;
-               break;
-       }
-       tuner_freq = params->frequency + if_freq;
-
-       i = 0;
-       while (tda827xa_dvbt[i].lomax < tuner_freq) {
-               if(tda827xa_dvbt[i + 1].lomax == 0)
-                       break;
-               i++;
-       }
-
-       N = ((tuner_freq + 31250) / 62500) << tda827xa_dvbt[i].spd;
-       buf[0] = 0;            // subaddress
-       buf[1] = N >> 8;
-       buf[2] = N & 0xff;
-       buf[3] = 0;
-       buf[4] = 0x16;
-       buf[5] = (tda827xa_dvbt[i].spd << 5) + (tda827xa_dvbt[i].svco << 3) +
-                       tda827xa_dvbt[i].sbs;
-       buf[6] = 0x4b + (tda827xa_dvbt[i].gc3 << 4);
-       buf[7] = 0x1c;
-       buf[8] = 0x06;
-       buf[9] = 0x24;
-       buf[10] = 0x00;
-       msg.len = 11;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
-               printk("%s: could not write to tuner at addr: 0x%02x\n",
-                      __func__, priv->i2c_addr << 1);
-               return -EIO;
-       }
-       buf[0] = 0x90;
-       buf[1] = 0xff;
-       buf[2] = 0x60;
-       buf[3] = 0x00;
-       buf[4] = 0x59;  // lpsel, for 6MHz + 2
-       msg.len = 5;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       buf[0] = 0xa0;
-       buf[1] = 0x40;
-       msg.len = 2;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(11);
-       msg.flags = I2C_M_RD;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-       msg.flags = 0;
-
-       buf[1] >>= 4;
-       dprintk("tda8275a AGC2 gain is: %d\n", buf[1]);
-       if ((buf[1]) < 2) {
-               tda827xa_lna_gain(fe, 0, NULL);
-               buf[0] = 0x60;
-               buf[1] = 0x0c;
-               if (fe->ops.i2c_gate_ctrl)
-                       fe->ops.i2c_gate_ctrl(fe, 1);
-               i2c_transfer(priv->i2c_adap, &msg, 1);
-       }
-
-       buf[0] = 0xc0;
-       buf[1] = 0x99;    // lpsel, for 6MHz + 2
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       buf[0] = 0x60;
-       buf[1] = 0x3c;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       /* correct CP value */
-       buf[0] = 0x30;
-       buf[1] = 0x10 + tda827xa_dvbt[i].scr;
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(163);
-       buf[0] = 0xc0;
-       buf[1] = 0x39;  // lpsel, for 6MHz + 2
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(3);
-       /* freeze AGC1 */
-       buf[0] = 0x50;
-       buf[1] = 0x4f + (tda827xa_dvbt[i].gc3 << 4);
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       priv->frequency = tuner_freq - if_freq; // FIXME
-       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ? params->u.ofdm.bandwidth : 0;
-
-       return 0;
-}
-
-
-static int tda827xa_set_analog_params(struct dvb_frontend *fe,
-                                     struct analog_parameters *params)
-{
-       unsigned char tuner_reg[11];
-       u32 N;
-       int i;
-       struct tda827x_priv *priv = fe->tuner_priv;
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = 0,
-                              .buf = tuner_reg, .len = sizeof(tuner_reg) };
-       unsigned int freq = params->frequency;
-
-       tda827x_set_std(fe, params);
-
-       tda827xa_lna_gain(fe, 1, params);
-       msleep(10);
-
-       if (params->mode == V4L2_TUNER_RADIO)
-               freq = freq / 1000;
-
-       N = freq + priv->sgIF;
-
-       i = 0;
-       while (tda827xa_analog[i].lomax < N * 62500) {
-               if (tda827xa_analog[i + 1].lomax == 0)
-                       break;
-               i++;
-       }
-
-       N = N << tda827xa_analog[i].spd;
-
-       tuner_reg[0] = 0;
-       tuner_reg[1] = (unsigned char)(N>>8);
-       tuner_reg[2] = (unsigned char) N;
-       tuner_reg[3] = 0;
-       tuner_reg[4] = 0x16;
-       tuner_reg[5] = (tda827xa_analog[i].spd << 5) +
-                      (tda827xa_analog[i].svco << 3) +
-                       tda827xa_analog[i].sbs;
-       tuner_reg[6] = 0x8b + (tda827xa_analog[i].gc3 << 4);
-       tuner_reg[7] = 0x1c;
-       tuner_reg[8] = 4;
-       tuner_reg[9] = 0x20;
-       tuner_reg[10] = 0x00;
-       msg.len = 11;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0x90;
-       tuner_reg[1] = 0xff;
-       tuner_reg[2] = 0xe0;
-       tuner_reg[3] = 0;
-       tuner_reg[4] = 0x99 + (priv->lpsel << 1);
-       msg.len = 5;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0xa0;
-       tuner_reg[1] = 0xc0;
-       msg.len = 2;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0x30;
-       tuner_reg[1] = 0x10 + tda827xa_analog[i].scr;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msg.flags = I2C_M_RD;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-       msg.flags = 0;
-       tuner_reg[1] >>= 4;
-       dprintk("AGC2 gain is: %d\n", tuner_reg[1]);
-       if (tuner_reg[1] < 1)
-               tda827xa_lna_gain(fe, 0, params);
-
-       msleep(100);
-       tuner_reg[0] = 0x60;
-       tuner_reg[1] = 0x3c;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       msleep(163);
-       tuner_reg[0] = 0x50;
-       tuner_reg[1] = 0x8f + (tda827xa_analog[i].gc3 << 4);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0x80;
-       tuner_reg[1] = 0x28;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0xb0;
-       tuner_reg[1] = 0x01;
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       tuner_reg[0] = 0xc0;
-       tuner_reg[1] = 0x19 + (priv->lpsel << 1);
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-
-       priv->frequency = freq * 62500;
-
-       return 0;
-}
-
-static void tda827xa_agcf(struct dvb_frontend *fe)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       unsigned char data[] = {0x80, 0x2c};
-       struct i2c_msg msg = {.addr = priv->i2c_addr, .flags = 0,
-                             .buf = data, .len = 2};
-       i2c_transfer(priv->i2c_adap, &msg, 1);
-}
-
-/* ------------------------------------------------------------------ */
-
-static int tda827x_release(struct dvb_frontend *fe)
-{
-       kfree(fe->tuner_priv);
-       fe->tuner_priv = NULL;
-       return 0;
-}
-
-static int tda827x_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-       return 0;
-}
-
-static int tda827x_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       *bandwidth = priv->bandwidth;
-       return 0;
-}
-
-static int tda827x_init(struct dvb_frontend *fe)
-{
-       struct tda827x_priv *priv = fe->tuner_priv;
-       dprintk("%s:\n", __func__);
-       if (priv->cfg && priv->cfg->init)
-               priv->cfg->init(fe);
-
-       return 0;
-}
-
-static int tda827x_probe_version(struct dvb_frontend *fe);
-
-static int tda827x_initial_init(struct dvb_frontend *fe)
-{
-       int ret;
-       ret = tda827x_probe_version(fe);
-       if (ret)
-               return ret;
-       return fe->ops.tuner_ops.init(fe);
-}
-
-static int tda827x_initial_sleep(struct dvb_frontend *fe)
-{
-       int ret;
-       ret = tda827x_probe_version(fe);
-       if (ret)
-               return ret;
-       return fe->ops.tuner_ops.sleep(fe);
-}
-
-static struct dvb_tuner_ops tda827xo_tuner_ops = {
-       .info = {
-               .name = "Philips TDA827X",
-               .frequency_min  =  55000000,
-               .frequency_max  = 860000000,
-               .frequency_step =    250000
-       },
-       .release = tda827x_release,
-       .init = tda827x_initial_init,
-       .sleep = tda827x_initial_sleep,
-       .set_params = tda827xo_set_params,
-       .set_analog_params = tda827xo_set_analog_params,
-       .get_frequency = tda827x_get_frequency,
-       .get_bandwidth = tda827x_get_bandwidth,
-};
-
-static struct dvb_tuner_ops tda827xa_tuner_ops = {
-       .info = {
-               .name = "Philips TDA827XA",
-               .frequency_min  =  44000000,
-               .frequency_max  = 906000000,
-               .frequency_step =     62500
-       },
-       .release = tda827x_release,
-       .init = tda827x_init,
-       .sleep = tda827xa_sleep,
-       .set_params = tda827xa_set_params,
-       .set_analog_params = tda827xa_set_analog_params,
-       .get_frequency = tda827x_get_frequency,
-       .get_bandwidth = tda827x_get_bandwidth,
-};
-
-static int tda827x_probe_version(struct dvb_frontend *fe)
-{      u8 data;
-       struct tda827x_priv *priv = fe->tuner_priv;
-       struct i2c_msg msg = { .addr = priv->i2c_addr, .flags = I2C_M_RD,
-                              .buf = &data, .len = 1 };
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-       if (i2c_transfer(priv->i2c_adap, &msg, 1) != 1) {
-               printk("%s: could not read from tuner at addr: 0x%02x\n",
-                      __func__, msg.addr << 1);
-               return -EIO;
-       }
-       if ((data & 0x3c) == 0) {
-               dprintk("tda827x tuner found\n");
-               fe->ops.tuner_ops.init  = tda827x_init;
-               fe->ops.tuner_ops.sleep = tda827xo_sleep;
-               if (priv->cfg)
-                       priv->cfg->agcf = tda827xo_agcf;
-       } else {
-               dprintk("tda827xa tuner found\n");
-               memcpy(&fe->ops.tuner_ops, &tda827xa_tuner_ops, sizeof(struct dvb_tuner_ops));
-               if (priv->cfg)
-                       priv->cfg->agcf = tda827xa_agcf;
-       }
-       return 0;
-}
-
-struct dvb_frontend *tda827x_attach(struct dvb_frontend *fe, int addr,
-                                   struct i2c_adapter *i2c,
-                                   struct tda827x_config *cfg)
-{
-       struct tda827x_priv *priv = NULL;
-
-       dprintk("%s:\n", __func__);
-       priv = kzalloc(sizeof(struct tda827x_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-
-       priv->i2c_addr = addr;
-       priv->i2c_adap = i2c;
-       priv->cfg = cfg;
-       memcpy(&fe->ops.tuner_ops, &tda827xo_tuner_ops, sizeof(struct dvb_tuner_ops));
-       fe->tuner_priv = priv;
-
-       dprintk("type set to %s\n", fe->ops.tuner_ops.info.name);
-
-       return fe;
-}
-EXPORT_SYMBOL_GPL(tda827x_attach);
-
-MODULE_DESCRIPTION("DVB TDA827x driver");
-MODULE_AUTHOR("Hartmut Hackmann <hartmut.hackmann@t-online.de>");
-MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
-MODULE_LICENSE("GPL");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/dvb/frontends/tda827x.h b/drivers/media/dvb/frontends/tda827x.h
deleted file mode 100644 (file)
index b73c235..0000000
+++ /dev/null
@@ -1,69 +0,0 @@
-  /*
-     DVB Driver for Philips tda827x / tda827xa Silicon tuners
-
-     (c) 2005 Hartmut Hackmann
-     (c) 2007 Michael Krufky
-
-     This program is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published by
-     the Free Software Foundation; either version 2 of the License, or
-     (at your option) any later version.
-
-     This program is distributed in the hope that it will be useful,
-     but WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-
-     GNU General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with this program; if not, write to the Free Software
-     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-  */
-
-#ifndef __DVB_TDA827X_H__
-#define __DVB_TDA827X_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-struct tda827x_config
-{
-       /* saa7134 - provided callbacks */
-       int (*init) (struct dvb_frontend *fe);
-       int (*sleep) (struct dvb_frontend *fe);
-
-       /* interface to tda829x driver */
-       unsigned int config;
-       int          switch_addr;
-       int (*tuner_callback) (void *dev, int command, int arg);
-
-       void (*agcf)(struct dvb_frontend *fe);
-};
-
-
-/**
- * Attach a tda827x tuner to the supplied frontend structure.
- *
- * @param fe Frontend to attach to.
- * @param addr i2c address of the tuner.
- * @param i2c i2c adapter to use.
- * @param cfg optional callback function pointers.
- * @return FE pointer on success, NULL on failure.
- */
-#if defined(CONFIG_DVB_TDA827X) || (defined(CONFIG_DVB_TDA827X_MODULE) && defined(MODULE))
-extern struct dvb_frontend* tda827x_attach(struct dvb_frontend *fe, int addr,
-                                          struct i2c_adapter *i2c,
-                                          struct tda827x_config *cfg);
-#else
-static inline struct dvb_frontend* tda827x_attach(struct dvb_frontend *fe,
-                                                 int addr,
-                                                 struct i2c_adapter *i2c,
-                                                 struct tda827x_config *cfg)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif // CONFIG_DVB_TDA827X
-
-#endif // __DVB_TDA827X_H__
diff --git a/drivers/media/dvb/frontends/xc5000.c b/drivers/media/dvb/frontends/xc5000.c
deleted file mode 100644 (file)
index 43d35bd..0000000
+++ /dev/null
@@ -1,964 +0,0 @@
-/*
- *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
- *
- *  Copyright (c) 2007 Xceive Corporation
- *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/videodev2.h>
-#include <linux/delay.h>
-#include <linux/dvb/frontend.h>
-#include <linux/i2c.h>
-
-#include "dvb_frontend.h"
-
-#include "xc5000.h"
-#include "xc5000_priv.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
-
-#define dprintk(level,fmt, arg...) if (debug >= level) \
-       printk(KERN_INFO "%s: " fmt, "xc5000", ## arg)
-
-#define XC5000_DEFAULT_FIRMWARE "dvb-fe-xc5000-1.1.fw"
-#define XC5000_DEFAULT_FIRMWARE_SIZE 12332
-
-/* Misc Defines */
-#define MAX_TV_STANDARD                        23
-#define XC_MAX_I2C_WRITE_LENGTH                64
-
-/* Signal Types */
-#define XC_RF_MODE_AIR                 0
-#define XC_RF_MODE_CABLE               1
-
-/* Result codes */
-#define XC_RESULT_SUCCESS              0
-#define XC_RESULT_RESET_FAILURE                1
-#define XC_RESULT_I2C_WRITE_FAILURE    2
-#define XC_RESULT_I2C_READ_FAILURE     3
-#define XC_RESULT_OUT_OF_RANGE         5
-
-/* Product id */
-#define XC_PRODUCT_ID_FW_NOT_LOADED    0x2000
-#define XC_PRODUCT_ID_FW_LOADED        0x1388
-
-/* Registers */
-#define XREG_INIT         0x00
-#define XREG_VIDEO_MODE   0x01
-#define XREG_AUDIO_MODE   0x02
-#define XREG_RF_FREQ      0x03
-#define XREG_D_CODE       0x04
-#define XREG_IF_OUT       0x05
-#define XREG_SEEK_MODE    0x07
-#define XREG_POWER_DOWN   0x0A
-#define XREG_SIGNALSOURCE 0x0D /* 0=Air, 1=Cable */
-#define XREG_SMOOTHEDCVBS 0x0E
-#define XREG_XTALFREQ     0x0F
-#define XREG_FINERFFREQ   0x10
-#define XREG_DDIMODE      0x11
-
-#define XREG_ADC_ENV      0x00
-#define XREG_QUALITY      0x01
-#define XREG_FRAME_LINES  0x02
-#define XREG_HSYNC_FREQ   0x03
-#define XREG_LOCK         0x04
-#define XREG_FREQ_ERROR   0x05
-#define XREG_SNR          0x06
-#define XREG_VERSION      0x07
-#define XREG_PRODUCT_ID   0x08
-#define XREG_BUSY         0x09
-
-/*
-   Basic firmware description. This will remain with
-   the driver for documentation purposes.
-
-   This represents an I2C firmware file encoded as a
-   string of unsigned char. Format is as follows:
-
-   char[0  ]=len0_MSB  -> len = len_MSB * 256 + len_LSB
-   char[1  ]=len0_LSB  -> length of first write transaction
-   char[2  ]=data0 -> first byte to be sent
-   char[3  ]=data1
-   char[4  ]=data2
-   char[   ]=...
-   char[M  ]=dataN  -> last byte to be sent
-   char[M+1]=len1_MSB  -> len = len_MSB * 256 + len_LSB
-   char[M+2]=len1_LSB  -> length of second write transaction
-   char[M+3]=data0
-   char[M+4]=data1
-   ...
-   etc.
-
-   The [len] value should be interpreted as follows:
-
-   len= len_MSB _ len_LSB
-   len=1111_1111_1111_1111   : End of I2C_SEQUENCE
-   len=0000_0000_0000_0000   : Reset command: Do hardware reset
-   len=0NNN_NNNN_NNNN_NNNN   : Normal transaction: number of bytes = {1:32767)
-   len=1WWW_WWWW_WWWW_WWWW   : Wait command: wait for {1:32767} ms
-
-   For the RESET and WAIT commands, the two following bytes will contain
-   immediately the length of the following transaction.
-
-*/
-typedef struct {
-       char *Name;
-       u16 AudioMode;
-       u16 VideoMode;
-} XC_TV_STANDARD;
-
-/* Tuner standards */
-#define MN_NTSC_PAL_BTSC       0
-#define MN_NTSC_PAL_A2         1
-#define MN_NTSC_PAL_EIAJ       2
-#define MN_NTSC_PAL_Mono       3
-#define BG_PAL_A2              4
-#define BG_PAL_NICAM           5
-#define BG_PAL_MONO            6
-#define I_PAL_NICAM            7
-#define I_PAL_NICAM_MONO       8
-#define DK_PAL_A2              9
-#define DK_PAL_NICAM           10
-#define DK_PAL_MONO            11
-#define DK_SECAM_A2DK1         12
-#define DK_SECAM_A2LDK3        13
-#define DK_SECAM_A2MONO        14
-#define L_SECAM_NICAM          15
-#define LC_SECAM_NICAM         16
-#define DTV6                   17
-#define DTV8                   18
-#define DTV7_8                 19
-#define DTV7                   20
-#define FM_Radio_INPUT2        21
-#define FM_Radio_INPUT1        22
-
-static XC_TV_STANDARD XC5000_Standard[MAX_TV_STANDARD] = {
-       {"M/N-NTSC/PAL-BTSC", 0x0400, 0x8020},
-       {"M/N-NTSC/PAL-A2",   0x0600, 0x8020},
-       {"M/N-NTSC/PAL-EIAJ", 0x0440, 0x8020},
-       {"M/N-NTSC/PAL-Mono", 0x0478, 0x8020},
-       {"B/G-PAL-A2",        0x0A00, 0x8049},
-       {"B/G-PAL-NICAM",     0x0C04, 0x8049},
-       {"B/G-PAL-MONO",      0x0878, 0x8059},
-       {"I-PAL-NICAM",       0x1080, 0x8009},
-       {"I-PAL-NICAM-MONO",  0x0E78, 0x8009},
-       {"D/K-PAL-A2",        0x1600, 0x8009},
-       {"D/K-PAL-NICAM",     0x0E80, 0x8009},
-       {"D/K-PAL-MONO",      0x1478, 0x8009},
-       {"D/K-SECAM-A2 DK1",  0x1200, 0x8009},
-       {"D/K-SECAM-A2 L/DK3",0x0E00, 0x8009},
-       {"D/K-SECAM-A2 MONO", 0x1478, 0x8009},
-       {"L-SECAM-NICAM",     0x8E82, 0x0009},
-       {"L'-SECAM-NICAM",    0x8E82, 0x4009},
-       {"DTV6",              0x00C0, 0x8002},
-       {"DTV8",              0x00C0, 0x800B},
-       {"DTV7/8",            0x00C0, 0x801B},
-       {"DTV7",              0x00C0, 0x8007},
-       {"FM Radio-INPUT2",   0x9802, 0x9002},
-       {"FM Radio-INPUT1",   0x0208, 0x9002}
-};
-
-static int  xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len);
-static int  xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len);
-static void xc5000_TunerReset(struct dvb_frontend *fe);
-
-static int xc_send_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
-{
-       return xc5000_writeregs(priv, buf, len)
-               ? XC_RESULT_I2C_WRITE_FAILURE : XC_RESULT_SUCCESS;
-}
-
-static int xc_read_i2c_data(struct xc5000_priv *priv, u8 *buf, int len)
-{
-       return xc5000_readregs(priv, buf, len)
-               ? XC_RESULT_I2C_READ_FAILURE : XC_RESULT_SUCCESS;
-}
-
-static int xc_reset(struct dvb_frontend *fe)
-{
-       xc5000_TunerReset(fe);
-       return XC_RESULT_SUCCESS;
-}
-
-static void xc_wait(int wait_ms)
-{
-       msleep(wait_ms);
-}
-
-static void xc5000_TunerReset(struct dvb_frontend *fe)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       int ret;
-
-       dprintk(1, "%s()\n", __func__);
-
-       if (priv->cfg->tuner_callback) {
-               ret = priv->cfg->tuner_callback(priv->cfg->priv,
-                                               XC5000_TUNER_RESET, 0);
-               if (ret)
-                       printk(KERN_ERR "xc5000: reset failed\n");
-       } else
-               printk(KERN_ERR "xc5000: no tuner reset callback function, fatal\n");
-}
-
-static int xc_write_reg(struct xc5000_priv *priv, u16 regAddr, u16 i2cData)
-{
-       u8 buf[4];
-       int WatchDogTimer = 5;
-       int result;
-
-       buf[0] = (regAddr >> 8) & 0xFF;
-       buf[1] = regAddr & 0xFF;
-       buf[2] = (i2cData >> 8) & 0xFF;
-       buf[3] = i2cData & 0xFF;
-       result = xc_send_i2c_data(priv, buf, 4);
-       if (result == XC_RESULT_SUCCESS) {
-               /* wait for busy flag to clear */
-               while ((WatchDogTimer > 0) && (result == XC_RESULT_SUCCESS)) {
-                       buf[0] = 0;
-                       buf[1] = XREG_BUSY;
-
-                       result = xc_send_i2c_data(priv, buf, 2);
-                       if (result == XC_RESULT_SUCCESS) {
-                               result = xc_read_i2c_data(priv, buf, 2);
-                               if (result == XC_RESULT_SUCCESS) {
-                                       if ((buf[0] == 0) && (buf[1] == 0)) {
-                                               /* busy flag cleared */
-                                       break;
-                                       } else {
-                                               xc_wait(100); /* wait 5 ms */
-                                               WatchDogTimer--;
-                                       }
-                               }
-                       }
-               }
-       }
-       if (WatchDogTimer < 0)
-               result = XC_RESULT_I2C_WRITE_FAILURE;
-
-       return result;
-}
-
-static int xc_read_reg(struct xc5000_priv *priv, u16 regAddr, u16 *i2cData)
-{
-       u8 buf[2];
-       int result;
-
-       buf[0] = (regAddr >> 8) & 0xFF;
-       buf[1] = regAddr & 0xFF;
-       result = xc_send_i2c_data(priv, buf, 2);
-       if (result != XC_RESULT_SUCCESS)
-               return result;
-
-       result = xc_read_i2c_data(priv, buf, 2);
-       if (result != XC_RESULT_SUCCESS)
-               return result;
-
-       *i2cData = buf[0] * 256 + buf[1];
-       return result;
-}
-
-static int xc_load_i2c_sequence(struct dvb_frontend *fe, u8 i2c_sequence[])
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-
-       int i, nbytes_to_send, result;
-       unsigned int len, pos, index;
-       u8 buf[XC_MAX_I2C_WRITE_LENGTH];
-
-       index=0;
-       while ((i2c_sequence[index]!=0xFF) || (i2c_sequence[index+1]!=0xFF)) {
-               len = i2c_sequence[index]* 256 + i2c_sequence[index+1];
-               if (len == 0x0000) {
-                       /* RESET command */
-                       result = xc_reset(fe);
-                       index += 2;
-                       if (result != XC_RESULT_SUCCESS)
-                               return result;
-               } else if (len & 0x8000) {
-                       /* WAIT command */
-                       xc_wait(len & 0x7FFF);
-                       index += 2;
-               } else {
-                       /* Send i2c data whilst ensuring individual transactions
-                        * do not exceed XC_MAX_I2C_WRITE_LENGTH bytes.
-                        */
-                       index += 2;
-                       buf[0] = i2c_sequence[index];
-                       buf[1] = i2c_sequence[index + 1];
-                       pos = 2;
-                       while (pos < len) {
-                               if ((len - pos) > XC_MAX_I2C_WRITE_LENGTH - 2) {
-                                       nbytes_to_send = XC_MAX_I2C_WRITE_LENGTH;
-                               } else {
-                                       nbytes_to_send = (len - pos + 2);
-                               }
-                               for (i=2; i<nbytes_to_send; i++) {
-                                       buf[i] = i2c_sequence[index + pos + i - 2];
-                               }
-                               result = xc_send_i2c_data(priv, buf, nbytes_to_send);
-
-                               if (result != XC_RESULT_SUCCESS)
-                                       return result;
-
-                               pos += nbytes_to_send - 2;
-                       }
-                       index += len;
-               }
-       }
-       return XC_RESULT_SUCCESS;
-}
-
-static int xc_initialize(struct xc5000_priv *priv)
-{
-       dprintk(1, "%s()\n", __func__);
-       return xc_write_reg(priv, XREG_INIT, 0);
-}
-
-static int xc_SetTVStandard(struct xc5000_priv *priv,
-       u16 VideoMode, u16 AudioMode)
-{
-       int ret;
-       dprintk(1, "%s(0x%04x,0x%04x)\n", __func__, VideoMode, AudioMode);
-       dprintk(1, "%s() Standard = %s\n",
-               __func__,
-               XC5000_Standard[priv->video_standard].Name);
-
-       ret = xc_write_reg(priv, XREG_VIDEO_MODE, VideoMode);
-       if (ret == XC_RESULT_SUCCESS)
-               ret = xc_write_reg(priv, XREG_AUDIO_MODE, AudioMode);
-
-       return ret;
-}
-
-static int xc_shutdown(struct xc5000_priv *priv)
-{
-       return 0;
-       /* Fixme: cannot bring tuner back alive once shutdown
-        *        without reloading the driver modules.
-        *    return xc_write_reg(priv, XREG_POWER_DOWN, 0);
-        */
-}
-
-static int xc_SetSignalSource(struct xc5000_priv *priv, u16 rf_mode)
-{
-       dprintk(1, "%s(%d) Source = %s\n", __func__, rf_mode,
-               rf_mode == XC_RF_MODE_AIR ? "ANTENNA" : "CABLE");
-
-       if ((rf_mode != XC_RF_MODE_AIR) && (rf_mode != XC_RF_MODE_CABLE))
-       {
-               rf_mode = XC_RF_MODE_CABLE;
-               printk(KERN_ERR
-                       "%s(), Invalid mode, defaulting to CABLE",
-                       __func__);
-       }
-       return xc_write_reg(priv, XREG_SIGNALSOURCE, rf_mode);
-}
-
-static const struct dvb_tuner_ops xc5000_tuner_ops;
-
-static int xc_set_RF_frequency(struct xc5000_priv *priv, u32 freq_hz)
-{
-       u16 freq_code;
-
-       dprintk(1, "%s(%u)\n", __func__, freq_hz);
-
-       if ((freq_hz > xc5000_tuner_ops.info.frequency_max) ||
-               (freq_hz < xc5000_tuner_ops.info.frequency_min))
-               return XC_RESULT_OUT_OF_RANGE;
-
-       freq_code = (u16)(freq_hz / 15625);
-
-       return xc_write_reg(priv, XREG_RF_FREQ, freq_code);
-}
-
-
-static int xc_set_IF_frequency(struct xc5000_priv *priv, u32 freq_khz)
-{
-       u32 freq_code = (freq_khz * 1024)/1000;
-       dprintk(1, "%s(freq_khz = %d) freq_code = 0x%x\n",
-               __func__, freq_khz, freq_code);
-
-       return xc_write_reg(priv, XREG_IF_OUT, freq_code);
-}
-
-
-static int xc_get_ADC_Envelope(struct xc5000_priv *priv, u16 *adc_envelope)
-{
-       return xc_read_reg(priv, XREG_ADC_ENV, adc_envelope);
-}
-
-static int xc_get_frequency_error(struct xc5000_priv *priv, u32 *freq_error_hz)
-{
-       int result;
-       u16 regData;
-       u32 tmp;
-
-       result = xc_read_reg(priv, XREG_FREQ_ERROR, &regData);
-       if (result)
-               return result;
-
-       tmp = (u32)regData;
-       (*freq_error_hz) = (tmp * 15625) / 1000;
-       return result;
-}
-
-static int xc_get_lock_status(struct xc5000_priv *priv, u16 *lock_status)
-{
-       return xc_read_reg(priv, XREG_LOCK, lock_status);
-}
-
-static int xc_get_version(struct xc5000_priv *priv,
-       u8 *hw_majorversion, u8 *hw_minorversion,
-       u8 *fw_majorversion, u8 *fw_minorversion)
-{
-       u16 data;
-       int result;
-
-       result = xc_read_reg(priv, XREG_VERSION, &data);
-       if (result)
-               return result;
-
-       (*hw_majorversion) = (data >> 12) & 0x0F;
-       (*hw_minorversion) = (data >>  8) & 0x0F;
-       (*fw_majorversion) = (data >>  4) & 0x0F;
-       (*fw_minorversion) = data & 0x0F;
-
-       return 0;
-}
-
-static int xc_get_hsync_freq(struct xc5000_priv *priv, u32 *hsync_freq_hz)
-{
-       u16 regData;
-       int result;
-
-       result = xc_read_reg(priv, XREG_HSYNC_FREQ, &regData);
-       if (result)
-               return result;
-
-       (*hsync_freq_hz) = ((regData & 0x0fff) * 763)/100;
-       return result;
-}
-
-static int xc_get_frame_lines(struct xc5000_priv *priv, u16 *frame_lines)
-{
-       return xc_read_reg(priv, XREG_FRAME_LINES, frame_lines);
-}
-
-static int xc_get_quality(struct xc5000_priv *priv, u16 *quality)
-{
-       return xc_read_reg(priv, XREG_QUALITY, quality);
-}
-
-static u16 WaitForLock(struct xc5000_priv *priv)
-{
-       u16 lockState = 0;
-       int watchDogCount = 40;
-
-       while ((lockState == 0) && (watchDogCount > 0)) {
-               xc_get_lock_status(priv, &lockState);
-               if (lockState != 1) {
-                       xc_wait(5);
-                       watchDogCount--;
-               }
-       }
-       return lockState;
-}
-
-static int xc_tune_channel(struct xc5000_priv *priv, u32 freq_hz)
-{
-       int found = 0;
-
-       dprintk(1, "%s(%u)\n", __func__, freq_hz);
-
-       if (xc_set_RF_frequency(priv, freq_hz) != XC_RESULT_SUCCESS)
-               return 0;
-
-       if (WaitForLock(priv) == 1)
-               found = 1;
-
-       return found;
-}
-
-static int xc5000_readreg(struct xc5000_priv *priv, u16 reg, u16 *val)
-{
-       u8 buf[2] = { reg >> 8, reg & 0xff };
-       u8 bval[2] = { 0, 0 };
-       struct i2c_msg msg[2] = {
-               { .addr = priv->cfg->i2c_address,
-                       .flags = 0, .buf = &buf[0], .len = 2 },
-               { .addr = priv->cfg->i2c_address,
-                       .flags = I2C_M_RD, .buf = &bval[0], .len = 2 },
-       };
-
-       if (i2c_transfer(priv->i2c, msg, 2) != 2) {
-               printk(KERN_WARNING "xc5000: I2C read failed\n");
-               return -EREMOTEIO;
-       }
-
-       *val = (bval[0] << 8) | bval[1];
-       return 0;
-}
-
-static int xc5000_writeregs(struct xc5000_priv *priv, u8 *buf, u8 len)
-{
-       struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
-               .flags = 0, .buf = buf, .len = len };
-
-       if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
-               printk(KERN_ERR "xc5000: I2C write failed (len=%i)\n",
-                       (int)len);
-               return -EREMOTEIO;
-       }
-       return 0;
-}
-
-static int xc5000_readregs(struct xc5000_priv *priv, u8 *buf, u8 len)
-{
-       struct i2c_msg msg = { .addr = priv->cfg->i2c_address,
-               .flags = I2C_M_RD, .buf = buf, .len = len };
-
-       if (i2c_transfer(priv->i2c, &msg, 1) != 1) {
-               printk(KERN_ERR "xc5000 I2C read failed (len=%i)\n",(int)len);
-               return -EREMOTEIO;
-       }
-       return 0;
-}
-
-static int xc5000_fwupload(struct dvb_frontend* fe)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       const struct firmware *fw;
-       int ret;
-
-       /* request the firmware, this will block and timeout */
-       printk(KERN_INFO "xc5000: waiting for firmware upload (%s)...\n",
-               XC5000_DEFAULT_FIRMWARE);
-
-       ret = request_firmware(&fw, XC5000_DEFAULT_FIRMWARE, &priv->i2c->dev);
-       if (ret) {
-               printk(KERN_ERR "xc5000: Upload failed. (file not found?)\n");
-               ret = XC_RESULT_RESET_FAILURE;
-               goto out;
-       } else {
-               printk(KERN_INFO "xc5000: firmware read %Zu bytes.\n",
-                      fw->size);
-               ret = XC_RESULT_SUCCESS;
-       }
-
-       if (fw->size != XC5000_DEFAULT_FIRMWARE_SIZE) {
-               printk(KERN_ERR "xc5000: firmware incorrect size\n");
-               ret = XC_RESULT_RESET_FAILURE;
-       } else {
-               printk(KERN_INFO "xc5000: firmware upload\n");
-               ret = xc_load_i2c_sequence(fe,  fw->data );
-       }
-
-out:
-       release_firmware(fw);
-       return ret;
-}
-
-static void xc_debug_dump(struct xc5000_priv *priv)
-{
-       u16 adc_envelope;
-       u32 freq_error_hz = 0;
-       u16 lock_status;
-       u32 hsync_freq_hz = 0;
-       u16 frame_lines;
-       u16 quality;
-       u8 hw_majorversion = 0, hw_minorversion = 0;
-       u8 fw_majorversion = 0, fw_minorversion = 0;
-
-       /* Wait for stats to stabilize.
-        * Frame Lines needs two frame times after initial lock
-        * before it is valid.
-        */
-       xc_wait(100);
-
-       xc_get_ADC_Envelope(priv,  &adc_envelope);
-       dprintk(1, "*** ADC envelope (0-1023) = %d\n", adc_envelope);
-
-       xc_get_frequency_error(priv, &freq_error_hz);
-       dprintk(1, "*** Frequency error = %d Hz\n", freq_error_hz);
-
-       xc_get_lock_status(priv,  &lock_status);
-       dprintk(1, "*** Lock status (0-Wait, 1-Locked, 2-No-signal) = %d\n",
-               lock_status);
-
-       xc_get_version(priv,  &hw_majorversion, &hw_minorversion,
-               &fw_majorversion, &fw_minorversion);
-       dprintk(1, "*** HW: V%02x.%02x, FW: V%02x.%02x\n",
-               hw_majorversion, hw_minorversion,
-               fw_majorversion, fw_minorversion);
-
-       xc_get_hsync_freq(priv,  &hsync_freq_hz);
-       dprintk(1, "*** Horizontal sync frequency = %d Hz\n", hsync_freq_hz);
-
-       xc_get_frame_lines(priv,  &frame_lines);
-       dprintk(1, "*** Frame lines = %d\n", frame_lines);
-
-       xc_get_quality(priv,  &quality);
-       dprintk(1, "*** Quality (0:<8dB, 7:>56dB) = %d\n", quality);
-}
-
-static int xc5000_set_params(struct dvb_frontend *fe,
-       struct dvb_frontend_parameters *params)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       int ret;
-
-       dprintk(1, "%s() frequency=%d (Hz)\n", __func__, params->frequency);
-
-       switch(params->u.vsb.modulation) {
-       case VSB_8:
-       case VSB_16:
-               dprintk(1, "%s() VSB modulation\n", __func__);
-               priv->rf_mode = XC_RF_MODE_AIR;
-               priv->freq_hz = params->frequency - 1750000;
-               priv->bandwidth = BANDWIDTH_6_MHZ;
-               priv->video_standard = DTV6;
-               break;
-       case QAM_64:
-       case QAM_256:
-       case QAM_AUTO:
-               dprintk(1, "%s() QAM modulation\n", __func__);
-               priv->rf_mode = XC_RF_MODE_CABLE;
-               priv->freq_hz = params->frequency - 1750000;
-               priv->bandwidth = BANDWIDTH_6_MHZ;
-               priv->video_standard = DTV6;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       dprintk(1, "%s() frequency=%d (compensated)\n",
-               __func__, priv->freq_hz);
-
-       ret = xc_SetSignalSource(priv, priv->rf_mode);
-       if (ret != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR
-                       "xc5000: xc_SetSignalSource(%d) failed\n",
-                       priv->rf_mode);
-               return -EREMOTEIO;
-       }
-
-       ret = xc_SetTVStandard(priv,
-               XC5000_Standard[priv->video_standard].VideoMode,
-               XC5000_Standard[priv->video_standard].AudioMode);
-       if (ret != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
-               return -EREMOTEIO;
-       }
-
-       ret = xc_set_IF_frequency(priv, priv->cfg->if_khz);
-       if (ret != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR "xc5000: xc_Set_IF_frequency(%d) failed\n",
-                       priv->cfg->if_khz);
-               return -EIO;
-       }
-
-       xc_tune_channel(priv, priv->freq_hz);
-
-       if (debug)
-               xc_debug_dump(priv);
-
-       return 0;
-}
-
-static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe);
-
-static int xc5000_set_analog_params(struct dvb_frontend *fe,
-       struct analog_parameters *params)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       int ret;
-
-       if(priv->fwloaded == 0)
-               xc_load_fw_and_init_tuner(fe);
-
-       dprintk(1, "%s() frequency=%d (in units of 62.5khz)\n",
-               __func__, params->frequency);
-
-       priv->rf_mode = XC_RF_MODE_CABLE; /* Fix me: it could be air. */
-
-       /* params->frequency is in units of 62.5khz */
-       priv->freq_hz = params->frequency * 62500;
-
-       /* FIX ME: Some video standards may have several possible audio
-                  standards. We simply default to one of them here.
-        */
-       if(params->std & V4L2_STD_MN) {
-               /* default to BTSC audio standard */
-               priv->video_standard = MN_NTSC_PAL_BTSC;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_PAL_BG) {
-               /* default to NICAM audio standard */
-               priv->video_standard = BG_PAL_NICAM;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_PAL_I) {
-               /* default to NICAM audio standard */
-               priv->video_standard = I_PAL_NICAM;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_PAL_DK) {
-               /* default to NICAM audio standard */
-               priv->video_standard = DK_PAL_NICAM;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_SECAM_DK) {
-               /* default to A2 DK1 audio standard */
-               priv->video_standard = DK_SECAM_A2DK1;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_SECAM_L) {
-               priv->video_standard = L_SECAM_NICAM;
-               goto tune_channel;
-       }
-
-       if(params->std & V4L2_STD_SECAM_LC) {
-               priv->video_standard = LC_SECAM_NICAM;
-               goto tune_channel;
-       }
-
-tune_channel:
-       ret = xc_SetSignalSource(priv, priv->rf_mode);
-       if (ret != XC_RESULT_SUCCESS) {
-       printk(KERN_ERR
-                       "xc5000: xc_SetSignalSource(%d) failed\n",
-                       priv->rf_mode);
-               return -EREMOTEIO;
-       }
-
-       ret = xc_SetTVStandard(priv,
-               XC5000_Standard[priv->video_standard].VideoMode,
-               XC5000_Standard[priv->video_standard].AudioMode);
-       if (ret != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR "xc5000: xc_SetTVStandard failed\n");
-               return -EREMOTEIO;
-       }
-
-       xc_tune_channel(priv, priv->freq_hz);
-
-       if (debug)
-               xc_debug_dump(priv);
-
-       return 0;
-}
-
-static int xc5000_get_frequency(struct dvb_frontend *fe, u32 *freq)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       dprintk(1, "%s()\n", __func__);
-       *freq = priv->freq_hz;
-       return 0;
-}
-
-static int xc5000_get_bandwidth(struct dvb_frontend *fe, u32 *bw)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       dprintk(1, "%s()\n", __func__);
-
-       *bw = priv->bandwidth;
-       return 0;
-}
-
-static int xc5000_get_status(struct dvb_frontend *fe, u32 *status)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       u16 lock_status = 0;
-
-       xc_get_lock_status(priv, &lock_status);
-
-       dprintk(1, "%s() lock_status = 0x%08x\n", __func__, lock_status);
-
-       *status = lock_status;
-
-       return 0;
-}
-
-static int xc_load_fw_and_init_tuner(struct dvb_frontend *fe)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       int ret = 0;
-
-       if (priv->fwloaded == 0) {
-               ret = xc5000_fwupload(fe);
-               if (ret != XC_RESULT_SUCCESS)
-                       return ret;
-               priv->fwloaded = 1;
-       }
-
-       /* Start the tuner self-calibration process */
-       ret |= xc_initialize(priv);
-
-       /* Wait for calibration to complete.
-        * We could continue but XC5000 will clock stretch subsequent
-        * I2C transactions until calibration is complete.  This way we
-        * don't have to rely on clock stretching working.
-        */
-       xc_wait( 100 );
-
-       /* Default to "CABLE" mode */
-       ret |= xc_write_reg(priv, XREG_SIGNALSOURCE, XC_RF_MODE_CABLE);
-
-       return ret;
-}
-
-static int xc5000_sleep(struct dvb_frontend *fe)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       int ret;
-
-       dprintk(1, "%s()\n", __func__);
-
-       /* On Pinnacle PCTV HD 800i, the tuner cannot be reinitialized
-        * once shutdown without reloading the driver. Maybe I am not
-        * doing something right.
-        *
-        */
-
-       ret = xc_shutdown(priv);
-       if(ret != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR
-                       "xc5000: %s() unable to shutdown tuner\n",
-                       __func__);
-               return -EREMOTEIO;
-       }
-       else {
-               /* priv->fwloaded = 0; */
-               return XC_RESULT_SUCCESS;
-       }
-}
-
-static int xc5000_init(struct dvb_frontend *fe)
-{
-       struct xc5000_priv *priv = fe->tuner_priv;
-       dprintk(1, "%s()\n", __func__);
-
-       if (xc_load_fw_and_init_tuner(fe) != XC_RESULT_SUCCESS) {
-               printk(KERN_ERR "xc5000: Unable to initialise tuner\n");
-               return -EREMOTEIO;
-       }
-
-       if (debug)
-               xc_debug_dump(priv);
-
-       return 0;
-}
-
-static int xc5000_release(struct dvb_frontend *fe)
-{
-       dprintk(1, "%s()\n", __func__);
-       kfree(fe->tuner_priv);
-       fe->tuner_priv = NULL;
-       return 0;
-}
-
-static const struct dvb_tuner_ops xc5000_tuner_ops = {
-       .info = {
-               .name           = "Xceive XC5000",
-               .frequency_min  =    1000000,
-               .frequency_max  = 1023000000,
-               .frequency_step =      50000,
-       },
-
-       .release           = xc5000_release,
-       .init              = xc5000_init,
-       .sleep             = xc5000_sleep,
-
-       .set_params        = xc5000_set_params,
-       .set_analog_params = xc5000_set_analog_params,
-       .get_frequency     = xc5000_get_frequency,
-       .get_bandwidth     = xc5000_get_bandwidth,
-       .get_status        = xc5000_get_status
-};
-
-struct dvb_frontend * xc5000_attach(struct dvb_frontend *fe,
-       struct i2c_adapter *i2c,
-       struct xc5000_config *cfg)
-{
-       struct xc5000_priv *priv = NULL;
-       u16 id = 0;
-
-       dprintk(1, "%s()\n", __func__);
-
-       priv = kzalloc(sizeof(struct xc5000_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-
-       priv->cfg = cfg;
-       priv->bandwidth = BANDWIDTH_6_MHZ;
-       priv->i2c = i2c;
-
-       /* Check if firmware has been loaded. It is possible that another
-          instance of the driver has loaded the firmware.
-        */
-       if (xc5000_readreg(priv, XREG_PRODUCT_ID, &id) != 0) {
-               kfree(priv);
-               return NULL;
-       }
-
-       switch(id) {
-       case XC_PRODUCT_ID_FW_LOADED:
-               printk(KERN_INFO
-                       "xc5000: Successfully identified at address 0x%02x\n",
-                       cfg->i2c_address);
-               printk(KERN_INFO
-                       "xc5000: Firmware has been loaded previously\n");
-               priv->fwloaded = 1;
-               break;
-       case XC_PRODUCT_ID_FW_NOT_LOADED:
-               printk(KERN_INFO
-                       "xc5000: Successfully identified at address 0x%02x\n",
-                       cfg->i2c_address);
-               printk(KERN_INFO
-                       "xc5000: Firmware has not been loaded previously\n");
-               priv->fwloaded = 0;
-               break;
-       default:
-               printk(KERN_ERR
-                       "xc5000: Device not found at addr 0x%02x (0x%x)\n",
-                       cfg->i2c_address, id);
-               kfree(priv);
-               return NULL;
-       }
-
-       memcpy(&fe->ops.tuner_ops, &xc5000_tuner_ops,
-               sizeof(struct dvb_tuner_ops));
-
-       fe->tuner_priv = priv;
-
-       return fe;
-}
-EXPORT_SYMBOL(xc5000_attach);
-
-MODULE_AUTHOR("Steven Toth");
-MODULE_DESCRIPTION("Xceive xc5000 silicon tuner driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/frontends/xc5000.h b/drivers/media/dvb/frontends/xc5000.h
deleted file mode 100644 (file)
index b890883..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
- *
- *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef __XC5000_H__
-#define __XC5000_H__
-
-#include <linux/firmware.h>
-
-struct dvb_frontend;
-struct i2c_adapter;
-
-struct xc5000_config {
-       u8   i2c_address;
-       u32  if_khz;
-
-       /* For each bridge framework, when it attaches either analog or digital,
-        * it has to store a reference back to its _core equivalent structure,
-        * so that it can service the hardware by steering gpio's etc.
-        * Each bridge implementation is different so cast priv accordingly.
-        * The xc5000 driver cares not for this value, other than ensuring
-        * it's passed back to a bridge during tuner_callback().
-        */
-       void *priv;
-       int  (*tuner_callback) (void *priv, int command, int arg);
-};
-
-/* xc5000 callback command */
-#define XC5000_TUNER_RESET             0
-
-#if defined(CONFIG_DVB_TUNER_XC5000) || \
-    (defined(CONFIG_DVB_TUNER_XC5000_MODULE) && defined(MODULE))
-extern struct dvb_frontend* xc5000_attach(struct dvb_frontend *fe,
-                                         struct i2c_adapter *i2c,
-                                         struct xc5000_config *cfg);
-#else
-static inline struct dvb_frontend* xc5000_attach(struct dvb_frontend *fe,
-                                                struct i2c_adapter *i2c,
-                                                struct xc5000_config *cfg)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif // CONFIG_DVB_TUNER_XC5000
-
-#endif // __XC5000_H__
diff --git a/drivers/media/dvb/frontends/xc5000_priv.h b/drivers/media/dvb/frontends/xc5000_priv.h
deleted file mode 100644 (file)
index 13b2d19..0000000
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- *  Driver for Xceive XC5000 "QAM/8VSB single chip tuner"
- *
- *  Copyright (c) 2007 Steven Toth <stoth@hauppauge.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef XC5000_PRIV_H
-#define XC5000_PRIV_H
-
-struct xc5000_priv {
-       struct xc5000_config *cfg;
-       struct i2c_adapter   *i2c;
-
-       u32 freq_hz;
-       u32 bandwidth;
-       u8  video_standard;
-       u8  rf_mode;
-       u8  fwloaded;
-};
-
-#endif
index fe9a4cc141414c18523cb11c1b97dd0138b8c111..e99bfcf28112c18efe235a2fe17195ab91e2db2c 100644 (file)
@@ -1,3 +1,49 @@
+#
+# Generic video config states
+#
+
+config VIDEO_V4L2
+       tristate
+       depends on VIDEO_DEV && VIDEO_V4L2_COMMON
+       default VIDEO_DEV && VIDEO_V4L2_COMMON
+
+config VIDEO_V4L1
+       tristate
+       depends on VIDEO_DEV && VIDEO_V4L2_COMMON && VIDEO_ALLOW_V4L1
+       default VIDEO_DEV && VIDEO_V4L2_COMMON && VIDEO_ALLOW_V4L1
+
+config VIDEOBUF_GEN
+       tristate
+
+config VIDEOBUF_DMA_SG
+       depends on HAS_DMA
+       select VIDEOBUF_GEN
+       tristate
+
+config VIDEOBUF_VMALLOC
+       select VIDEOBUF_GEN
+       tristate
+
+config VIDEOBUF_DVB
+       tristate
+       select VIDEOBUF_GEN
+       select VIDEOBUF_DMA_SG
+
+config VIDEO_BTCX
+       tristate
+
+config VIDEO_IR_I2C
+       tristate
+
+config VIDEO_IR
+       tristate
+       depends on INPUT
+       select VIDEO_IR_I2C if I2C
+
+config VIDEO_TVEEPROM
+       tristate
+       depends on I2C
+
 #
 # Multimedia Video device configuration
 #
index be14227f37269adb548577df17407aa52c6905ae..73f87aede07473c38495b8c7048c215232cb5e30 100644 (file)
@@ -86,16 +86,6 @@ obj-$(CONFIG_TUNER_3036) += tuner-3036.o
 
 obj-$(CONFIG_VIDEO_TUNER) += tuner.o
 
-obj-$(CONFIG_TUNER_XC2028) += tuner-xc2028.o
-obj-$(CONFIG_TUNER_SIMPLE) += tuner-simple.o
-# tuner-types will be merged into tuner-simple, in the future
-obj-$(CONFIG_TUNER_SIMPLE) += tuner-types.o
-obj-$(CONFIG_TUNER_MT20XX) += mt20xx.o
-obj-$(CONFIG_TUNER_TDA8290) += tda8290.o
-obj-$(CONFIG_TUNER_TEA5767) += tea5767.o
-obj-$(CONFIG_TUNER_TEA5761) += tea5761.o
-obj-$(CONFIG_TUNER_TDA9887) += tda9887.o
-
 obj-$(CONFIG_VIDEOBUF_GEN) += videobuf-core.o
 obj-$(CONFIG_VIDEOBUF_DMA_SG) += videobuf-dma-sg.o
 obj-$(CONFIG_VIDEOBUF_VMALLOC) += videobuf-vmalloc.o
@@ -147,3 +137,4 @@ obj-$(CONFIG_VIDEO_AU0828) += au0828/
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
index 9f4f572c89c588c55412a0b5f617b098a7b39cae..cd2c58281b4eda4c26ac46483f10208389a881d5 100644 (file)
@@ -2,7 +2,7 @@ au0828-objs     := au0828-core.o au0828-i2c.o au0828-cards.o au0828-dvb.o
 
 obj-$(CONFIG_VIDEO_AU0828) += au0828.o
 
-EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 
index 924d216d95705c1bb30dfc562294fb3c69255734..e415f6fc447c5905ffd87ac96e611a1c6bc9cf86 100644 (file)
@@ -9,4 +9,5 @@ bttv-objs      :=      bttv-driver.o bttv-cards.o bttv-if.o \
 obj-$(CONFIG_VIDEO_BT848) += bttv.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
index d7b0721af062611215e6b516ec5c86e970911414..29c23b44c13c95bd498c705c024024297f885914 100644 (file)
@@ -3,6 +3,7 @@ cx23885-objs    := cx23885-cards.o cx23885-video.o cx23885-vbi.o cx23885-core.o cx2
 obj-$(CONFIG_VIDEO_CX23885) += cx23885.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 
index 532cee35eb3c4f49962cc4b627792f18798a113a..6ec30f242578984a4563c7ce5cc789c57e266502 100644 (file)
@@ -10,5 +10,6 @@ obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o
 obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
index 3d1c3cc337fe65c7407d728afab04990bdcd4e98..8137a8c94bfc365a1d63ffd677cf8cd1ed236d60 100644 (file)
@@ -8,6 +8,7 @@ obj-$(CONFIG_VIDEO_EM28XX_ALSA) += em28xx-alsa.o
 obj-$(CONFIG_VIDEO_EM28XX_DVB) += em28xx-dvb.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 
index a0389014fa88dc8dc156263e140232794b156e45..26ce0d6eaee1a3c15a918783130b26eb713827da 100644 (file)
@@ -8,6 +8,7 @@ obj-$(CONFIG_VIDEO_IVTV) += ivtv.o
 obj-$(CONFIG_VIDEO_FB_IVTV) += ivtvfb.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
 
diff --git a/drivers/media/video/mt20xx.c b/drivers/media/video/mt20xx.c
deleted file mode 100644 (file)
index fbcb282..0000000
+++ /dev/null
@@ -1,670 +0,0 @@
-/*
- * i2c tv tuner chip device driver
- * controls microtune tuners, mt2032 + mt2050 at the moment.
- *
- * This "mt20xx" module was split apart from the original "tuner" module.
- */
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/videodev.h>
-#include "tuner-i2c.h"
-#include "mt20xx.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-/* ---------------------------------------------------------------------- */
-
-static unsigned int optimize_vco  = 1;
-module_param(optimize_vco,      int, 0644);
-
-static unsigned int tv_antenna    = 1;
-module_param(tv_antenna,        int, 0644);
-
-static unsigned int radio_antenna;
-module_param(radio_antenna,     int, 0644);
-
-/* ---------------------------------------------------------------------- */
-
-#define MT2032 0x04
-#define MT2030 0x06
-#define MT2040 0x07
-#define MT2050 0x42
-
-static char *microtune_part[] = {
-       [ MT2030 ] = "MT2030",
-       [ MT2032 ] = "MT2032",
-       [ MT2040 ] = "MT2040",
-       [ MT2050 ] = "MT2050",
-};
-
-struct microtune_priv {
-       struct tuner_i2c_props i2c_props;
-
-       unsigned int xogc;
-       //unsigned int radio_if2;
-
-       u32 frequency;
-};
-
-static int microtune_release(struct dvb_frontend *fe)
-{
-       kfree(fe->tuner_priv);
-       fe->tuner_priv = NULL;
-
-       return 0;
-}
-
-static int microtune_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-       return 0;
-}
-
-// IsSpurInBand()?
-static int mt2032_spurcheck(struct dvb_frontend *fe,
-                           int f1, int f2, int spectrum_from,int spectrum_to)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int n1=1,n2,f;
-
-       f1=f1/1000; //scale to kHz to avoid 32bit overflows
-       f2=f2/1000;
-       spectrum_from/=1000;
-       spectrum_to/=1000;
-
-       tuner_dbg("spurcheck f1=%d f2=%d  from=%d to=%d\n",
-                 f1,f2,spectrum_from,spectrum_to);
-
-       do {
-           n2=-n1;
-           f=n1*(f1-f2);
-           do {
-               n2--;
-               f=f-f2;
-               tuner_dbg("spurtest n1=%d n2=%d ftest=%d\n",n1,n2,f);
-
-               if( (f>spectrum_from) && (f<spectrum_to))
-                       tuner_dbg("mt2032 spurcheck triggered: %d\n",n1);
-           } while ( (f>(f2-spectrum_to)) || (n2>-5));
-           n1++;
-       } while (n1<5);
-
-       return 1;
-}
-
-static int mt2032_compute_freq(struct dvb_frontend *fe,
-                              unsigned int rfin,
-                              unsigned int if1, unsigned int if2,
-                              unsigned int spectrum_from,
-                              unsigned int spectrum_to,
-                              unsigned char *buf,
-                              int *ret_sel,
-                              unsigned int xogc) //all in Hz
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned int fref,lo1,lo1n,lo1a,s,sel,lo1freq, desired_lo1,
-               desired_lo2,lo2,lo2n,lo2a,lo2num,lo2freq;
-
-       fref= 5250 *1000; //5.25MHz
-       desired_lo1=rfin+if1;
-
-       lo1=(2*(desired_lo1/1000)+(fref/1000)) / (2*fref/1000);
-       lo1n=lo1/8;
-       lo1a=lo1-(lo1n*8);
-
-       s=rfin/1000/1000+1090;
-
-       if(optimize_vco) {
-               if(s>1890) sel=0;
-               else if(s>1720) sel=1;
-               else if(s>1530) sel=2;
-               else if(s>1370) sel=3;
-               else sel=4; // >1090
-       }
-       else {
-               if(s>1790) sel=0; // <1958
-               else if(s>1617) sel=1;
-               else if(s>1449) sel=2;
-               else if(s>1291) sel=3;
-               else sel=4; // >1090
-       }
-       *ret_sel=sel;
-
-       lo1freq=(lo1a+8*lo1n)*fref;
-
-       tuner_dbg("mt2032: rfin=%d lo1=%d lo1n=%d lo1a=%d sel=%d, lo1freq=%d\n",
-                 rfin,lo1,lo1n,lo1a,sel,lo1freq);
-
-       desired_lo2=lo1freq-rfin-if2;
-       lo2=(desired_lo2)/fref;
-       lo2n=lo2/8;
-       lo2a=lo2-(lo2n*8);
-       lo2num=((desired_lo2/1000)%(fref/1000))* 3780/(fref/1000); //scale to fit in 32bit arith
-       lo2freq=(lo2a+8*lo2n)*fref + lo2num*(fref/1000)/3780*1000;
-
-       tuner_dbg("mt2032: rfin=%d lo2=%d lo2n=%d lo2a=%d num=%d lo2freq=%d\n",
-                 rfin,lo2,lo2n,lo2a,lo2num,lo2freq);
-
-       if(lo1a<0 || lo1a>7 || lo1n<17 ||lo1n>48 || lo2a<0 ||lo2a >7 ||lo2n<17 || lo2n>30) {
-               tuner_info("mt2032: frequency parameters out of range: %d %d %d %d\n",
-                          lo1a, lo1n, lo2a,lo2n);
-               return(-1);
-       }
-
-       mt2032_spurcheck(fe, lo1freq, desired_lo2,  spectrum_from, spectrum_to);
-       // should recalculate lo1 (one step up/down)
-
-       // set up MT2032 register map for transfer over i2c
-       buf[0]=lo1n-1;
-       buf[1]=lo1a | (sel<<4);
-       buf[2]=0x86; // LOGC
-       buf[3]=0x0f; //reserved
-       buf[4]=0x1f;
-       buf[5]=(lo2n-1) | (lo2a<<5);
-       if(rfin >400*1000*1000)
-               buf[6]=0xe4;
-       else
-               buf[6]=0xf4; // set PKEN per rev 1.2
-       buf[7]=8+xogc;
-       buf[8]=0xc3; //reserved
-       buf[9]=0x4e; //reserved
-       buf[10]=0xec; //reserved
-       buf[11]=(lo2num&0xff);
-       buf[12]=(lo2num>>8) |0x80; // Lo2RST
-
-       return 0;
-}
-
-static int mt2032_check_lo_lock(struct dvb_frontend *fe)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int try,lock=0;
-       unsigned char buf[2];
-
-       for(try=0;try<10;try++) {
-               buf[0]=0x0e;
-               tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-               tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
-               tuner_dbg("mt2032 Reg.E=0x%02x\n",buf[0]);
-               lock=buf[0] &0x06;
-
-               if (lock==6)
-                       break;
-
-               tuner_dbg("mt2032: pll wait 1ms for lock (0x%2x)\n",buf[0]);
-               udelay(1000);
-       }
-       return lock;
-}
-
-static int mt2032_optimize_vco(struct dvb_frontend *fe,int sel,int lock)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned char buf[2];
-       int tad1;
-
-       buf[0]=0x0f;
-       tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-       tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
-       tuner_dbg("mt2032 Reg.F=0x%02x\n",buf[0]);
-       tad1=buf[0]&0x07;
-
-       if(tad1 ==0) return lock;
-       if(tad1 ==1) return lock;
-
-       if(tad1==2) {
-               if(sel==0)
-                       return lock;
-               else sel--;
-       }
-       else {
-               if(sel<4)
-                       sel++;
-               else
-                       return lock;
-       }
-
-       tuner_dbg("mt2032 optimize_vco: sel=%d\n",sel);
-
-       buf[0]=0x0f;
-       buf[1]=sel;
-       tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-       lock=mt2032_check_lo_lock(fe);
-       return lock;
-}
-
-
-static void mt2032_set_if_freq(struct dvb_frontend *fe, unsigned int rfin,
-                              unsigned int if1, unsigned int if2,
-                              unsigned int from, unsigned int to)
-{
-       unsigned char buf[21];
-       int lint_try,ret,sel,lock=0;
-       struct microtune_priv *priv = fe->tuner_priv;
-
-       tuner_dbg("mt2032_set_if_freq rfin=%d if1=%d if2=%d from=%d to=%d\n",
-                 rfin,if1,if2,from,to);
-
-       buf[0]=0;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-       tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
-
-       buf[0]=0;
-       ret=mt2032_compute_freq(fe,rfin,if1,if2,from,to,&buf[1],&sel,priv->xogc);
-       if (ret<0)
-               return;
-
-       // send only the relevant registers per Rev. 1.2
-       buf[0]=0;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,4);
-       buf[5]=5;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,4);
-       buf[11]=11;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+11,3);
-       if(ret!=3)
-               tuner_warn("i2c i/o error: rc == %d (should be 3)\n",ret);
-
-       // wait for PLLs to lock (per manual), retry LINT if not.
-       for(lint_try=0; lint_try<2; lint_try++) {
-               lock=mt2032_check_lo_lock(fe);
-
-               if(optimize_vco)
-                       lock=mt2032_optimize_vco(fe,sel,lock);
-               if(lock==6) break;
-
-               tuner_dbg("mt2032: re-init PLLs by LINT\n");
-               buf[0]=7;
-               buf[1]=0x80 +8+priv->xogc; // set LINT to re-init PLLs
-               tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-               mdelay(10);
-               buf[1]=8+priv->xogc;
-               tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-       }
-
-       if (lock!=6)
-               tuner_warn("MT2032 Fatal Error: PLLs didn't lock.\n");
-
-       buf[0]=2;
-       buf[1]=0x20; // LOGC for optimal phase noise
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-       if (ret!=2)
-               tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
-}
-
-
-static int mt2032_set_tv_freq(struct dvb_frontend *fe,
-                             struct analog_parameters *params)
-{
-       int if2,from,to;
-
-       // signal bandwidth and picture carrier
-       if (params->std & V4L2_STD_525_60) {
-               // NTSC
-               from = 40750*1000;
-               to   = 46750*1000;
-               if2  = 45750*1000;
-       } else {
-               // PAL
-               from = 32900*1000;
-               to   = 39900*1000;
-               if2  = 38900*1000;
-       }
-
-       mt2032_set_if_freq(fe, params->frequency*62500,
-                          1090*1000*1000, if2, from, to);
-
-       return 0;
-}
-
-static int mt2032_set_radio_freq(struct dvb_frontend *fe,
-                                struct analog_parameters *params)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int if2;
-
-       if (params->std & V4L2_STD_525_60) {
-               tuner_dbg("pinnacle ntsc\n");
-               if2 = 41300 * 1000;
-       } else {
-               tuner_dbg("pinnacle pal\n");
-               if2 = 33300 * 1000;
-       }
-
-       // per Manual for FM tuning: first if center freq. 1085 MHz
-       mt2032_set_if_freq(fe, params->frequency * 125 / 2,
-                          1085*1000*1000,if2,if2,if2);
-
-       return 0;
-}
-
-static int mt2032_set_params(struct dvb_frontend *fe,
-                            struct analog_parameters *params)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int ret = -EINVAL;
-
-       switch (params->mode) {
-       case V4L2_TUNER_RADIO:
-               ret = mt2032_set_radio_freq(fe, params);
-               priv->frequency = params->frequency * 125 / 2;
-               break;
-       case V4L2_TUNER_ANALOG_TV:
-       case V4L2_TUNER_DIGITAL_TV:
-               ret = mt2032_set_tv_freq(fe, params);
-               priv->frequency = params->frequency * 62500;
-               break;
-       }
-
-       return ret;
-}
-
-static struct dvb_tuner_ops mt2032_tuner_ops = {
-       .set_analog_params = mt2032_set_params,
-       .release           = microtune_release,
-       .get_frequency     = microtune_get_frequency,
-};
-
-// Initialization as described in "MT203x Programming Procedures", Rev 1.2, Feb.2001
-static int mt2032_init(struct dvb_frontend *fe)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned char buf[21];
-       int ret,xogc,xok=0;
-
-       // Initialize Registers per spec.
-       buf[1]=2; // Index to register 2
-       buf[2]=0xff;
-       buf[3]=0x0f;
-       buf[4]=0x1f;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+1,4);
-
-       buf[5]=6; // Index register 6
-       buf[6]=0xe4;
-       buf[7]=0x8f;
-       buf[8]=0xc3;
-       buf[9]=0x4e;
-       buf[10]=0xec;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+5,6);
-
-       buf[12]=13;  // Index register 13
-       buf[13]=0x32;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf+12,2);
-
-       // Adjust XOGC (register 7), wait for XOK
-       xogc=7;
-       do {
-               tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
-               mdelay(10);
-               buf[0]=0x0e;
-               tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-               tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
-               xok=buf[0]&0x01;
-               tuner_dbg("mt2032: xok = 0x%02x\n",xok);
-               if (xok == 1) break;
-
-               xogc--;
-               tuner_dbg("mt2032: xogc = 0x%02x\n",xogc&0x07);
-               if (xogc == 3) {
-                       xogc=4; // min. 4 per spec
-                       break;
-               }
-               buf[0]=0x07;
-               buf[1]=0x88 + xogc;
-               ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-               if (ret!=2)
-                       tuner_warn("i2c i/o error: rc == %d (should be 2)\n",ret);
-       } while (xok != 1 );
-       priv->xogc=xogc;
-
-       memcpy(&fe->ops.tuner_ops, &mt2032_tuner_ops, sizeof(struct dvb_tuner_ops));
-
-       return(1);
-}
-
-static void mt2050_set_antenna(struct dvb_frontend *fe, unsigned char antenna)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned char buf[2];
-       int ret;
-
-       buf[0] = 6;
-       buf[1] = antenna ? 0x11 : 0x10;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2);
-       tuner_dbg("mt2050: enabled antenna connector %d\n", antenna);
-}
-
-static void mt2050_set_if_freq(struct dvb_frontend *fe,unsigned int freq, unsigned int if2)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned int if1=1218*1000*1000;
-       unsigned int f_lo1,f_lo2,lo1,lo2,f_lo1_modulo,f_lo2_modulo,num1,num2,div1a,div1b,div2a,div2b;
-       int ret;
-       unsigned char buf[6];
-
-       tuner_dbg("mt2050_set_if_freq freq=%d if1=%d if2=%d\n",
-                 freq,if1,if2);
-
-       f_lo1=freq+if1;
-       f_lo1=(f_lo1/1000000)*1000000;
-
-       f_lo2=f_lo1-freq-if2;
-       f_lo2=(f_lo2/50000)*50000;
-
-       lo1=f_lo1/4000000;
-       lo2=f_lo2/4000000;
-
-       f_lo1_modulo= f_lo1-(lo1*4000000);
-       f_lo2_modulo= f_lo2-(lo2*4000000);
-
-       num1=4*f_lo1_modulo/4000000;
-       num2=4096*(f_lo2_modulo/1000)/4000;
-
-       // todo spurchecks
-
-       div1a=(lo1/12)-1;
-       div1b=lo1-(div1a+1)*12;
-
-       div2a=(lo2/8)-1;
-       div2b=lo2-(div2a+1)*8;
-
-       if (debug > 1) {
-               tuner_dbg("lo1 lo2 = %d %d\n", lo1, lo2);
-               tuner_dbg("num1 num2 div1a div1b div2a div2b= %x %x %x %x %x %x\n",
-                         num1,num2,div1a,div1b,div2a,div2b);
-       }
-
-       buf[0]=1;
-       buf[1]= 4*div1b + num1;
-       if(freq<275*1000*1000) buf[1] = buf[1]|0x80;
-
-       buf[2]=div1a;
-       buf[3]=32*div2b + num2/256;
-       buf[4]=num2-(num2/256)*256;
-       buf[5]=div2a;
-       if(num2!=0) buf[5]=buf[5]|0x40;
-
-       if (debug > 1) {
-               int i;
-               tuner_dbg("bufs is: ");
-               for(i=0;i<6;i++)
-                       printk("%x ",buf[i]);
-               printk("\n");
-       }
-
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,6);
-       if (ret!=6)
-               tuner_warn("i2c i/o error: rc == %d (should be 6)\n",ret);
-}
-
-static int mt2050_set_tv_freq(struct dvb_frontend *fe,
-                             struct analog_parameters *params)
-{
-       unsigned int if2;
-
-       if (params->std & V4L2_STD_525_60) {
-               // NTSC
-               if2 = 45750*1000;
-       } else {
-               // PAL
-               if2 = 38900*1000;
-       }
-       if (V4L2_TUNER_DIGITAL_TV == params->mode) {
-               // DVB (pinnacle 300i)
-               if2 = 36150*1000;
-       }
-       mt2050_set_if_freq(fe, params->frequency*62500, if2);
-       mt2050_set_antenna(fe, tv_antenna);
-
-       return 0;
-}
-
-static int mt2050_set_radio_freq(struct dvb_frontend *fe,
-                                struct analog_parameters *params)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int if2;
-
-       if (params->std & V4L2_STD_525_60) {
-               tuner_dbg("pinnacle ntsc\n");
-               if2 = 41300 * 1000;
-       } else {
-               tuner_dbg("pinnacle pal\n");
-               if2 = 33300 * 1000;
-       }
-
-       mt2050_set_if_freq(fe, params->frequency * 125 / 2, if2);
-       mt2050_set_antenna(fe, radio_antenna);
-
-       return 0;
-}
-
-static int mt2050_set_params(struct dvb_frontend *fe,
-                            struct analog_parameters *params)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       int ret = -EINVAL;
-
-       switch (params->mode) {
-       case V4L2_TUNER_RADIO:
-               ret = mt2050_set_radio_freq(fe, params);
-               priv->frequency = params->frequency * 125 / 2;
-               break;
-       case V4L2_TUNER_ANALOG_TV:
-       case V4L2_TUNER_DIGITAL_TV:
-               ret = mt2050_set_tv_freq(fe, params);
-               priv->frequency = params->frequency * 62500;
-               break;
-       }
-
-       return ret;
-}
-
-static struct dvb_tuner_ops mt2050_tuner_ops = {
-       .set_analog_params = mt2050_set_params,
-       .release           = microtune_release,
-       .get_frequency     = microtune_get_frequency,
-};
-
-static int mt2050_init(struct dvb_frontend *fe)
-{
-       struct microtune_priv *priv = fe->tuner_priv;
-       unsigned char buf[2];
-       int ret;
-
-       buf[0]=6;
-       buf[1]=0x10;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); //  power
-
-       buf[0]=0x0f;
-       buf[1]=0x0f;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,2); // m1lo
-
-       buf[0]=0x0d;
-       ret=tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-       tuner_i2c_xfer_recv(&priv->i2c_props,buf,1);
-
-       tuner_dbg("mt2050: sro is %x\n",buf[0]);
-
-       memcpy(&fe->ops.tuner_ops, &mt2050_tuner_ops, sizeof(struct dvb_tuner_ops));
-
-       return 0;
-}
-
-struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
-                                     struct i2c_adapter* i2c_adap,
-                                     u8 i2c_addr)
-{
-       struct microtune_priv *priv = NULL;
-       char *name;
-       unsigned char buf[21];
-       int company_code;
-
-       priv = kzalloc(sizeof(struct microtune_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-       fe->tuner_priv = priv;
-
-       priv->i2c_props.addr = i2c_addr;
-       priv->i2c_props.adap = i2c_adap;
-       priv->i2c_props.name = "mt20xx";
-
-       //priv->radio_if2 = 10700 * 1000;       /* 10.7MHz - FM radio */
-
-       memset(buf,0,sizeof(buf));
-
-       name = "unknown";
-
-       tuner_i2c_xfer_send(&priv->i2c_props,buf,1);
-       tuner_i2c_xfer_recv(&priv->i2c_props,buf,21);
-       if (debug) {
-               int i;
-               tuner_dbg("MT20xx hexdump:");
-               for(i=0;i<21;i++) {
-                       printk(" %02x",buf[i]);
-                       if(((i+1)%8)==0) printk(" ");
-               }
-               printk("\n");
-       }
-       company_code = buf[0x11] << 8 | buf[0x12];
-       tuner_info("microtune: companycode=%04x part=%02x rev=%02x\n",
-                  company_code,buf[0x13],buf[0x14]);
-
-
-       if (buf[0x13] < ARRAY_SIZE(microtune_part) &&
-           NULL != microtune_part[buf[0x13]])
-               name = microtune_part[buf[0x13]];
-       switch (buf[0x13]) {
-       case MT2032:
-               mt2032_init(fe);
-               break;
-       case MT2050:
-               mt2050_init(fe);
-               break;
-       default:
-               tuner_info("microtune %s found, not (yet?) supported, sorry :-/\n",
-                          name);
-               return NULL;
-       }
-
-       strlcpy(fe->ops.tuner_ops.info.name, name,
-               sizeof(fe->ops.tuner_ops.info.name));
-       tuner_info("microtune %s found, OK\n",name);
-       return fe;
-}
-
-EXPORT_SYMBOL_GPL(microtune_attach);
-
-MODULE_DESCRIPTION("Microtune tuner driver");
-MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
-MODULE_LICENSE("GPL");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/video/mt20xx.h b/drivers/media/video/mt20xx.h
deleted file mode 100644 (file)
index aa848e1..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __MT20XX_H__
-#define __MT20XX_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-#if defined(CONFIG_TUNER_MT20XX) || (defined(CONFIG_TUNER_MT20XX_MODULE) && defined(MODULE))
-extern struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
-                                            struct i2c_adapter* i2c_adap,
-                                            u8 i2c_addr);
-#else
-static inline struct dvb_frontend *microtune_attach(struct dvb_frontend *fe,
-                                            struct i2c_adapter* i2c_adap,
-                                            u8 i2c_addr)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __MT20XX_H__ */
index 5b3083c89aa9bcd1841c41d76c029d3ae682d4dc..4fda2de69ab7240022856bd4a2c3064b41c136d4 100644 (file)
@@ -16,5 +16,6 @@ pvrusb2-objs  := pvrusb2-i2c-core.o pvrusb2-i2c-cmd-v4l2.o \
 obj-$(CONFIG_VIDEO_PVRUSB2) += pvrusb2.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
index 9aff937ba7a5232ab506d8f1e0617f5089be3726..3dbaa19a6d00d7f3dbc81f7769681c91d5fff41e 100644 (file)
@@ -11,5 +11,6 @@ obj-$(CONFIG_VIDEO_SAA7134_ALSA) += saa7134-alsa.o
 obj-$(CONFIG_VIDEO_SAA7134_DVB) += saa7134-dvb.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
diff --git a/drivers/media/video/tda8290.c b/drivers/media/video/tda8290.c
deleted file mode 100644 (file)
index 0ebb5b5..0000000
+++ /dev/null
@@ -1,804 +0,0 @@
-/*
-
-   i2c tv tuner chip device driver
-   controls the philips tda8290+75 tuner chip combo.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-   This "tda8290" module was split apart from the original "tuner" module.
-*/
-
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/videodev.h>
-#include "tuner-i2c.h"
-#include "tda8290.h"
-#include "tda827x.h"
-#include "tda18271.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-/* ---------------------------------------------------------------------- */
-
-struct tda8290_priv {
-       struct tuner_i2c_props i2c_props;
-
-       unsigned char tda8290_easy_mode;
-
-       unsigned char tda827x_addr;
-
-       unsigned char ver;
-#define TDA8290   1
-#define TDA8295   2
-#define TDA8275   4
-#define TDA8275A  8
-#define TDA18271 16
-
-       struct tda827x_config cfg;
-};
-
-/*---------------------------------------------------------------------*/
-
-static int tda8290_i2c_bridge(struct dvb_frontend *fe, int close)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char  enable[2] = { 0x21, 0xC0 };
-       unsigned char disable[2] = { 0x21, 0x00 };
-       unsigned char *msg;
-
-       if (close) {
-               msg = enable;
-               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
-               /* let the bridge stabilize */
-               msleep(20);
-       } else {
-               msg = disable;
-               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
-       }
-
-       return 0;
-}
-
-static int tda8295_i2c_bridge(struct dvb_frontend *fe, int close)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char  enable[2] = { 0x45, 0xc1 };
-       unsigned char disable[2] = { 0x46, 0x00 };
-       unsigned char buf[3] = { 0x45, 0x01, 0x00 };
-       unsigned char *msg;
-
-       if (close) {
-               msg = enable;
-               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
-               /* let the bridge stabilize */
-               msleep(20);
-       } else {
-               msg = disable;
-               tuner_i2c_xfer_send(&priv->i2c_props, msg, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &msg[1], 1);
-
-               buf[2] = msg[1];
-               buf[2] &= ~0x04;
-               tuner_i2c_xfer_send(&priv->i2c_props, buf, 3);
-               msleep(5);
-
-               msg[1] |= 0x04;
-               tuner_i2c_xfer_send(&priv->i2c_props, msg, 2);
-       }
-
-       return 0;
-}
-
-/*---------------------------------------------------------------------*/
-
-static void set_audio(struct dvb_frontend *fe,
-                     struct analog_parameters *params)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       char* mode;
-
-       if (params->std & V4L2_STD_MN) {
-               priv->tda8290_easy_mode = 0x01;
-               mode = "MN";
-       } else if (params->std & V4L2_STD_B) {
-               priv->tda8290_easy_mode = 0x02;
-               mode = "B";
-       } else if (params->std & V4L2_STD_GH) {
-               priv->tda8290_easy_mode = 0x04;
-               mode = "GH";
-       } else if (params->std & V4L2_STD_PAL_I) {
-               priv->tda8290_easy_mode = 0x08;
-               mode = "I";
-       } else if (params->std & V4L2_STD_DK) {
-               priv->tda8290_easy_mode = 0x10;
-               mode = "DK";
-       } else if (params->std & V4L2_STD_SECAM_L) {
-               priv->tda8290_easy_mode = 0x20;
-               mode = "L";
-       } else if (params->std & V4L2_STD_SECAM_LC) {
-               priv->tda8290_easy_mode = 0x40;
-               mode = "LC";
-       } else {
-               priv->tda8290_easy_mode = 0x10;
-               mode = "xx";
-       }
-
-       tuner_dbg("setting tda829x to system %s\n", mode);
-}
-
-static void tda8290_set_params(struct dvb_frontend *fe,
-                              struct analog_parameters *params)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char soft_reset[]  = { 0x00, 0x00 };
-       unsigned char easy_mode[]   = { 0x01, priv->tda8290_easy_mode };
-       unsigned char expert_mode[] = { 0x01, 0x80 };
-       unsigned char agc_out_on[]  = { 0x02, 0x00 };
-       unsigned char gainset_off[] = { 0x28, 0x14 };
-       unsigned char if_agc_spd[]  = { 0x0f, 0x88 };
-       unsigned char adc_head_6[]  = { 0x05, 0x04 };
-       unsigned char adc_head_9[]  = { 0x05, 0x02 };
-       unsigned char adc_head_12[] = { 0x05, 0x01 };
-       unsigned char pll_bw_nom[]  = { 0x0d, 0x47 };
-       unsigned char pll_bw_low[]  = { 0x0d, 0x27 };
-       unsigned char gainset_2[]   = { 0x28, 0x64 };
-       unsigned char agc_rst_on[]  = { 0x0e, 0x0b };
-       unsigned char agc_rst_off[] = { 0x0e, 0x09 };
-       unsigned char if_agc_set[]  = { 0x0f, 0x81 };
-       unsigned char addr_adc_sat  = 0x1a;
-       unsigned char addr_agc_stat = 0x1d;
-       unsigned char addr_pll_stat = 0x1b;
-       unsigned char adc_sat, agc_stat,
-                     pll_stat;
-       int i;
-
-       set_audio(fe, params);
-
-       if (priv->cfg.config)
-               tuner_dbg("tda827xa config is 0x%02x\n", priv->cfg.config);
-       tuner_i2c_xfer_send(&priv->i2c_props, easy_mode, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, agc_out_on, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, soft_reset, 2);
-       msleep(1);
-
-       expert_mode[1] = priv->tda8290_easy_mode + 0x80;
-       tuner_i2c_xfer_send(&priv->i2c_props, expert_mode, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, gainset_off, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, if_agc_spd, 2);
-       if (priv->tda8290_easy_mode & 0x60)
-               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_9, 2);
-       else
-               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_6, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_nom, 2);
-
-       tda8290_i2c_bridge(fe, 1);
-
-       if (fe->ops.tuner_ops.set_analog_params)
-               fe->ops.tuner_ops.set_analog_params(fe, params);
-
-       for (i = 0; i < 3; i++) {
-               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
-               if (pll_stat & 0x80) {
-                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
-                       tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
-                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
-                       tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
-                       tuner_dbg("tda8290 is locked, AGC: %d\n", agc_stat);
-                       break;
-               } else {
-                       tuner_dbg("tda8290 not locked, no signal?\n");
-                       msleep(100);
-               }
-       }
-       /* adjust headroom resp. gain */
-       if ((agc_stat > 115) || (!(pll_stat & 0x80) && (adc_sat < 20))) {
-               tuner_dbg("adjust gain, step 1. Agc: %d, ADC stat: %d, lock: %d\n",
-                          agc_stat, adc_sat, pll_stat & 0x80);
-               tuner_i2c_xfer_send(&priv->i2c_props, gainset_2, 2);
-               msleep(100);
-               tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
-               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
-               if ((agc_stat > 115) || !(pll_stat & 0x80)) {
-                       tuner_dbg("adjust gain, step 2. Agc: %d, lock: %d\n",
-                                  agc_stat, pll_stat & 0x80);
-                       if (priv->cfg.agcf)
-                               priv->cfg.agcf(fe);
-                       msleep(100);
-                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_agc_stat, 1);
-                       tuner_i2c_xfer_recv(&priv->i2c_props, &agc_stat, 1);
-                       tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
-                       tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
-                       if((agc_stat > 115) || !(pll_stat & 0x80)) {
-                               tuner_dbg("adjust gain, step 3. Agc: %d\n", agc_stat);
-                               tuner_i2c_xfer_send(&priv->i2c_props, adc_head_12, 2);
-                               tuner_i2c_xfer_send(&priv->i2c_props, pll_bw_low, 2);
-                               msleep(100);
-                       }
-               }
-       }
-
-       /* l/ l' deadlock? */
-       if(priv->tda8290_easy_mode & 0x60) {
-               tuner_i2c_xfer_send(&priv->i2c_props, &addr_adc_sat, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &adc_sat, 1);
-               tuner_i2c_xfer_send(&priv->i2c_props, &addr_pll_stat, 1);
-               tuner_i2c_xfer_recv(&priv->i2c_props, &pll_stat, 1);
-               if ((adc_sat > 20) || !(pll_stat & 0x80)) {
-                       tuner_dbg("trying to resolve SECAM L deadlock\n");
-                       tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_on, 2);
-                       msleep(40);
-                       tuner_i2c_xfer_send(&priv->i2c_props, agc_rst_off, 2);
-               }
-       }
-
-       tda8290_i2c_bridge(fe, 0);
-       tuner_i2c_xfer_send(&priv->i2c_props, if_agc_set, 2);
-}
-
-/*---------------------------------------------------------------------*/
-
-static void tda8295_power(struct dvb_frontend *fe, int enable)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char buf[] = { 0x30, 0x00 }; /* clb_stdbt */
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
-
-       if (enable)
-               buf[1] = 0x01;
-       else
-               buf[1] = 0x03;
-
-       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
-}
-
-static void tda8295_set_easy_mode(struct dvb_frontend *fe, int enable)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char buf[] = { 0x01, 0x00 };
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
-
-       if (enable)
-               buf[1] = 0x01; /* rising edge sets regs 0x02 - 0x23 */
-       else
-               buf[1] = 0x00; /* reset active bit */
-
-       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
-}
-
-static void tda8295_set_video_std(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char buf[] = { 0x00, priv->tda8290_easy_mode };
-
-       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
-
-       tda8295_set_easy_mode(fe, 1);
-       msleep(20);
-       tda8295_set_easy_mode(fe, 0);
-}
-
-/*---------------------------------------------------------------------*/
-
-static void tda8295_agc1_out(struct dvb_frontend *fe, int enable)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char buf[] = { 0x02, 0x00 }; /* DIV_FUNC */
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &buf[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &buf[1], 1);
-
-       if (enable)
-               buf[1] &= ~0x40;
-       else
-               buf[1] |= 0x40;
-
-       tuner_i2c_xfer_send(&priv->i2c_props, buf, 2);
-}
-
-static void tda8295_agc2_out(struct dvb_frontend *fe, int enable)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char set_gpio_cf[]    = { 0x44, 0x00 };
-       unsigned char set_gpio_val[]   = { 0x46, 0x00 };
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_cf[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_cf[1], 1);
-       tuner_i2c_xfer_send(&priv->i2c_props, &set_gpio_val[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &set_gpio_val[1], 1);
-
-       set_gpio_cf[1] &= 0xf0; /* clear GPIO_0 bits 3-0 */
-
-       if (enable) {
-               set_gpio_cf[1]  |= 0x01; /* config GPIO_0 as Open Drain Out */
-               set_gpio_val[1] &= 0xfe; /* set GPIO_0 pin low */
-       }
-       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_cf, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_val, 2);
-}
-
-static int tda8295_has_signal(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char hvpll_stat = 0x26;
-       unsigned char ret;
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &hvpll_stat, 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &ret, 1);
-       return (ret & 0x01) ? 65535 : 0;
-}
-
-/*---------------------------------------------------------------------*/
-
-static void tda8295_set_params(struct dvb_frontend *fe,
-                              struct analog_parameters *params)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char blanking_mode[]     = { 0x1d, 0x00 };
-
-       set_audio(fe, params);
-
-       tuner_dbg("%s: freq = %d\n", __func__, params->frequency);
-
-       tda8295_power(fe, 1);
-       tda8295_agc1_out(fe, 1);
-
-       tuner_i2c_xfer_send(&priv->i2c_props, &blanking_mode[0], 1);
-       tuner_i2c_xfer_recv(&priv->i2c_props, &blanking_mode[1], 1);
-
-       tda8295_set_video_std(fe);
-
-       blanking_mode[1] = 0x03;
-       tuner_i2c_xfer_send(&priv->i2c_props, blanking_mode, 2);
-       msleep(20);
-
-       tda8295_i2c_bridge(fe, 1);
-
-       if (fe->ops.tuner_ops.set_analog_params)
-               fe->ops.tuner_ops.set_analog_params(fe, params);
-
-       if (priv->cfg.agcf)
-               priv->cfg.agcf(fe);
-
-       if (tda8295_has_signal(fe))
-               tuner_dbg("tda8295 is locked\n");
-       else
-               tuner_dbg("tda8295 not locked, no signal?\n");
-
-       tda8295_i2c_bridge(fe, 0);
-}
-
-/*---------------------------------------------------------------------*/
-
-static int tda8290_has_signal(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char i2c_get_afc[1] = { 0x1B };
-       unsigned char afc = 0;
-
-       tuner_i2c_xfer_send(&priv->i2c_props, i2c_get_afc, ARRAY_SIZE(i2c_get_afc));
-       tuner_i2c_xfer_recv(&priv->i2c_props, &afc, 1);
-       return (afc & 0x80)? 65535:0;
-}
-
-/*---------------------------------------------------------------------*/
-
-static void tda8290_standby(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char cb1[] = { 0x30, 0xD0 };
-       unsigned char tda8290_standby[] = { 0x00, 0x02 };
-       unsigned char tda8290_agc_tri[] = { 0x02, 0x20 };
-       struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0, .buf=cb1, .len = 2};
-
-       tda8290_i2c_bridge(fe, 1);
-       if (priv->ver & TDA8275A)
-               cb1[1] = 0x90;
-       i2c_transfer(priv->i2c_props.adap, &msg, 1);
-       tda8290_i2c_bridge(fe, 0);
-       tuner_i2c_xfer_send(&priv->i2c_props, tda8290_agc_tri, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, tda8290_standby, 2);
-}
-
-static void tda8295_standby(struct dvb_frontend *fe)
-{
-       tda8295_agc1_out(fe, 0); /* Put AGC in tri-state */
-
-       tda8295_power(fe, 0);
-}
-
-static void tda8290_init_if(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       unsigned char set_VS[] = { 0x30, 0x6F };
-       unsigned char set_GP00_CF[] = { 0x20, 0x01 };
-       unsigned char set_GP01_CF[] = { 0x20, 0x0B };
-
-       if ((priv->cfg.config == 1) || (priv->cfg.config == 2))
-               tuner_i2c_xfer_send(&priv->i2c_props, set_GP00_CF, 2);
-       else
-               tuner_i2c_xfer_send(&priv->i2c_props, set_GP01_CF, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_VS, 2);
-}
-
-static void tda8295_init_if(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       static unsigned char set_adc_ctl[]       = { 0x33, 0x14 };
-       static unsigned char set_adc_ctl2[]      = { 0x34, 0x00 };
-       static unsigned char set_pll_reg6[]      = { 0x3e, 0x63 };
-       static unsigned char set_pll_reg0[]      = { 0x38, 0x23 };
-       static unsigned char set_pll_reg7[]      = { 0x3f, 0x01 };
-       static unsigned char set_pll_reg10[]     = { 0x42, 0x61 };
-       static unsigned char set_gpio_reg0[]     = { 0x44, 0x0b };
-
-       tda8295_power(fe, 1);
-
-       tda8295_set_easy_mode(fe, 0);
-       tda8295_set_video_std(fe);
-
-       tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_adc_ctl2, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg6, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg0, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg7, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_pll_reg10, 2);
-       tuner_i2c_xfer_send(&priv->i2c_props, set_gpio_reg0, 2);
-
-       tda8295_agc1_out(fe, 0);
-       tda8295_agc2_out(fe, 0);
-}
-
-static void tda8290_init_tuner(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       unsigned char tda8275_init[]  = { 0x00, 0x00, 0x00, 0x40, 0xdC, 0x04, 0xAf,
-                                         0x3F, 0x2A, 0x04, 0xFF, 0x00, 0x00, 0x40 };
-       unsigned char tda8275a_init[] = { 0x00, 0x00, 0x00, 0x00, 0xdC, 0x05, 0x8b,
-                                         0x0c, 0x04, 0x20, 0xFF, 0x00, 0x00, 0x4b };
-       struct i2c_msg msg = {.addr = priv->tda827x_addr, .flags=0,
-                             .buf=tda8275_init, .len = 14};
-       if (priv->ver & TDA8275A)
-               msg.buf = tda8275a_init;
-
-       tda8290_i2c_bridge(fe, 1);
-       i2c_transfer(priv->i2c_props.adap, &msg, 1);
-       tda8290_i2c_bridge(fe, 0);
-}
-
-/*---------------------------------------------------------------------*/
-
-static void tda829x_release(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-
-       /* only try to release the tuner if we've
-        * attached it from within this module */
-       if (priv->ver & (TDA18271 | TDA8275 | TDA8275A))
-               if (fe->ops.tuner_ops.release)
-                       fe->ops.tuner_ops.release(fe);
-
-       kfree(fe->analog_demod_priv);
-       fe->analog_demod_priv = NULL;
-}
-
-static struct tda18271_config tda829x_tda18271_config = {
-       .gate    = TDA18271_GATE_ANALOG,
-};
-
-static int tda829x_find_tuner(struct dvb_frontend *fe)
-{
-       struct tda8290_priv *priv = fe->analog_demod_priv;
-       struct analog_demod_ops *analog_ops = &fe->ops.analog_ops;
-       int i, ret, tuners_found;
-       u32 tuner_addrs;
-       u8 data;
-       struct i2c_msg msg = { .flags = I2C_M_RD, .buf = &data, .len = 1 };
-
-       if (NULL == analog_ops->i2c_gate_ctrl)
-               return -EINVAL;
-
-       analog_ops->i2c_gate_ctrl(fe, 1);
-
-       /* probe for tuner chip */
-       tuners_found = 0;
-       tuner_addrs = 0;
-       for (i = 0x60; i <= 0x63; i++) {
-               msg.addr = i;
-               ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
-               if (ret == 1) {
-                       tuners_found++;
-                       tuner_addrs = (tuner_addrs << 8) + i;
-               }
-       }
-       /* if there is more than one tuner, we expect the right one is
-          behind the bridge and we choose the highest address that doesn't
-          give a response now
-        */
-
-       analog_ops->i2c_gate_ctrl(fe, 0);
-
-       if (tuners_found > 1)
-               for (i = 0; i < tuners_found; i++) {
-                       msg.addr = tuner_addrs  & 0xff;
-                       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
-                       if (ret == 1)
-                               tuner_addrs = tuner_addrs >> 8;
-                       else
-                               break;
-               }
-
-       if (tuner_addrs == 0) {
-               tuner_addrs = 0x60;
-               tuner_info("could not clearly identify tuner address, "
-                          "defaulting to %x\n", tuner_addrs);
-       } else {
-               tuner_addrs = tuner_addrs & 0xff;
-               tuner_info("setting tuner address to %x\n", tuner_addrs);
-       }
-       priv->tda827x_addr = tuner_addrs;
-       msg.addr = tuner_addrs;
-
-       analog_ops->i2c_gate_ctrl(fe, 1);
-       ret = i2c_transfer(priv->i2c_props.adap, &msg, 1);
-
-       if (ret != 1) {
-               tuner_warn("tuner access failed!\n");
-               return -EREMOTEIO;
-       }
-
-       if ((data == 0x83) || (data == 0x84)) {
-               priv->ver |= TDA18271;
-               tda18271_attach(fe, priv->tda827x_addr,
-                               priv->i2c_props.adap,
-                               &tda829x_tda18271_config);
-       } else {
-               if ((data & 0x3c) == 0)
-                       priv->ver |= TDA8275;
-               else
-                       priv->ver |= TDA8275A;
-
-               tda827x_attach(fe, priv->tda827x_addr, priv->i2c_props.adap, &priv->cfg);
-               priv->cfg.switch_addr = priv->i2c_props.addr;
-       }
-       if (fe->ops.tuner_ops.init)
-               fe->ops.tuner_ops.init(fe);
-
-       if (fe->ops.tuner_ops.sleep)
-               fe->ops.tuner_ops.sleep(fe);
-
-       analog_ops->i2c_gate_ctrl(fe, 0);
-
-       return 0;
-}
-
-static int tda8290_probe(struct tuner_i2c_props *i2c_props)
-{
-#define TDA8290_ID 0x89
-       unsigned char tda8290_id[] = { 0x1f, 0x00 };
-
-       /* detect tda8290 */
-       tuner_i2c_xfer_send(i2c_props, &tda8290_id[0], 1);
-       tuner_i2c_xfer_recv(i2c_props, &tda8290_id[1], 1);
-
-       if (tda8290_id[1] == TDA8290_ID) {
-               if (debug)
-                       printk(KERN_DEBUG "%s: tda8290 detected @ %d-%04x\n",
-                              __func__, i2c_adapter_id(i2c_props->adap),
-                              i2c_props->addr);
-               return 0;
-       }
-
-       return -ENODEV;
-}
-
-static int tda8295_probe(struct tuner_i2c_props *i2c_props)
-{
-#define TDA8295_ID 0x8a
-       unsigned char tda8295_id[] = { 0x2f, 0x00 };
-
-       /* detect tda8295 */
-       tuner_i2c_xfer_send(i2c_props, &tda8295_id[0], 1);
-       tuner_i2c_xfer_recv(i2c_props, &tda8295_id[1], 1);
-
-       if (tda8295_id[1] == TDA8295_ID) {
-               if (debug)
-                       printk(KERN_DEBUG "%s: tda8295 detected @ %d-%04x\n",
-                              __func__, i2c_adapter_id(i2c_props->adap),
-                              i2c_props->addr);
-               return 0;
-       }
-
-       return -ENODEV;
-}
-
-static struct analog_demod_ops tda8290_ops = {
-       .set_params     = tda8290_set_params,
-       .has_signal     = tda8290_has_signal,
-       .standby        = tda8290_standby,
-       .release        = tda829x_release,
-       .i2c_gate_ctrl  = tda8290_i2c_bridge,
-};
-
-static struct analog_demod_ops tda8295_ops = {
-       .set_params     = tda8295_set_params,
-       .has_signal     = tda8295_has_signal,
-       .standby        = tda8295_standby,
-       .release        = tda829x_release,
-       .i2c_gate_ctrl  = tda8295_i2c_bridge,
-};
-
-struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
-                                   struct i2c_adapter *i2c_adap, u8 i2c_addr,
-                                   struct tda829x_config *cfg)
-{
-       struct tda8290_priv *priv = NULL;
-       char *name;
-
-       priv = kzalloc(sizeof(struct tda8290_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-       fe->analog_demod_priv = priv;
-
-       priv->i2c_props.addr     = i2c_addr;
-       priv->i2c_props.adap     = i2c_adap;
-       priv->i2c_props.name     = "tda829x";
-       if (cfg) {
-               priv->cfg.config         = cfg->lna_cfg;
-               priv->cfg.tuner_callback = cfg->tuner_callback;
-       }
-
-       if (tda8290_probe(&priv->i2c_props) == 0) {
-               priv->ver = TDA8290;
-               memcpy(&fe->ops.analog_ops, &tda8290_ops,
-                      sizeof(struct analog_demod_ops));
-       }
-
-       if (tda8295_probe(&priv->i2c_props) == 0) {
-               priv->ver = TDA8295;
-               memcpy(&fe->ops.analog_ops, &tda8295_ops,
-                      sizeof(struct analog_demod_ops));
-       }
-
-       if ((!(cfg) || (TDA829X_PROBE_TUNER == cfg->probe_tuner)) &&
-           (tda829x_find_tuner(fe) < 0))
-               goto fail;
-
-       switch (priv->ver) {
-       case TDA8290:
-               name = "tda8290";
-               break;
-       case TDA8295:
-               name = "tda8295";
-               break;
-       case TDA8290 | TDA8275:
-               name = "tda8290+75";
-               break;
-       case TDA8295 | TDA8275:
-               name = "tda8295+75";
-               break;
-       case TDA8290 | TDA8275A:
-               name = "tda8290+75a";
-               break;
-       case TDA8295 | TDA8275A:
-               name = "tda8295+75a";
-               break;
-       case TDA8290 | TDA18271:
-               name = "tda8290+18271";
-               break;
-       case TDA8295 | TDA18271:
-               name = "tda8295+18271";
-               break;
-       default:
-               goto fail;
-       }
-       tuner_info("type set to %s\n", name);
-
-       fe->ops.analog_ops.info.name = name;
-
-       if (priv->ver & TDA8290) {
-               tda8290_init_tuner(fe);
-               tda8290_init_if(fe);
-       } else if (priv->ver & TDA8295)
-               tda8295_init_if(fe);
-
-       return fe;
-
-fail:
-       tda829x_release(fe);
-       return NULL;
-}
-EXPORT_SYMBOL_GPL(tda829x_attach);
-
-int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr)
-{
-       struct tuner_i2c_props i2c_props = {
-               .adap = i2c_adap,
-               .addr = i2c_addr,
-       };
-
-       unsigned char soft_reset[]   = { 0x00, 0x00 };
-       unsigned char easy_mode_b[]  = { 0x01, 0x02 };
-       unsigned char easy_mode_g[]  = { 0x01, 0x04 };
-       unsigned char restore_9886[] = { 0x00, 0xd6, 0x30 };
-       unsigned char addr_dto_lsb = 0x07;
-       unsigned char data;
-#define PROBE_BUFFER_SIZE 8
-       unsigned char buf[PROBE_BUFFER_SIZE];
-       int i;
-
-       /* rule out tda9887, which would return the same byte repeatedly */
-       tuner_i2c_xfer_send(&i2c_props, soft_reset, 1);
-       tuner_i2c_xfer_recv(&i2c_props, buf, PROBE_BUFFER_SIZE);
-       for (i = 1; i < PROBE_BUFFER_SIZE; i++) {
-               if (buf[i] != buf[0])
-                       break;
-       }
-
-       /* all bytes are equal, not a tda829x - probably a tda9887 */
-       if (i == PROBE_BUFFER_SIZE)
-               return -ENODEV;
-
-       if ((tda8290_probe(&i2c_props) == 0) ||
-           (tda8295_probe(&i2c_props) == 0))
-               return 0;
-
-       /* fall back to old probing method */
-       tuner_i2c_xfer_send(&i2c_props, easy_mode_b, 2);
-       tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
-       tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
-       tuner_i2c_xfer_recv(&i2c_props, &data, 1);
-       if (data == 0) {
-               tuner_i2c_xfer_send(&i2c_props, easy_mode_g, 2);
-               tuner_i2c_xfer_send(&i2c_props, soft_reset, 2);
-               tuner_i2c_xfer_send(&i2c_props, &addr_dto_lsb, 1);
-               tuner_i2c_xfer_recv(&i2c_props, &data, 1);
-               if (data == 0x7b) {
-                       return 0;
-               }
-       }
-       tuner_i2c_xfer_send(&i2c_props, restore_9886, 3);
-       return -ENODEV;
-}
-EXPORT_SYMBOL_GPL(tda829x_probe);
-
-MODULE_DESCRIPTION("Philips/NXP TDA8290/TDA8295 analog IF demodulator driver");
-MODULE_AUTHOR("Gerd Knorr, Hartmut Hackmann, Michael Krufky");
-MODULE_LICENSE("GPL");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/video/tda8290.h b/drivers/media/video/tda8290.h
deleted file mode 100644 (file)
index d3bbf27..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TDA8290_H__
-#define __TDA8290_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-struct tda829x_config {
-       unsigned int lna_cfg;
-       int (*tuner_callback) (void *dev, int command, int arg);
-
-       unsigned int probe_tuner:1;
-#define TDA829X_PROBE_TUNER 0
-#define TDA829X_DONT_PROBE  1
-};
-
-#if defined(CONFIG_TUNER_TDA8290) || (defined(CONFIG_TUNER_TDA8290_MODULE) && defined(MODULE))
-extern int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr);
-
-extern struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
-                                          struct i2c_adapter *i2c_adap,
-                                          u8 i2c_addr,
-                                          struct tda829x_config *cfg);
-#else
-static inline int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return -EINVAL;
-}
-
-static inline struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
-                                                 struct i2c_adapter *i2c_adap,
-                                                 u8 i2c_addr,
-                                                 struct tda829x_config *cfg)
-{
-       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TDA8290_H__ */
diff --git a/drivers/media/video/tda9887.c b/drivers/media/video/tda9887.c
deleted file mode 100644 (file)
index a0545ba..0000000
+++ /dev/null
@@ -1,717 +0,0 @@
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/i2c.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/delay.h>
-#include <linux/videodev.h>
-#include <media/v4l2-common.h>
-#include <media/tuner.h>
-#include "tuner-i2c.h"
-#include "tda9887.h"
-
-
-/* Chips:
-   TDA9885 (PAL, NTSC)
-   TDA9886 (PAL, SECAM, NTSC)
-   TDA9887 (PAL, SECAM, NTSC, FM Radio)
-
-   Used as part of several tuners
-*/
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-static DEFINE_MUTEX(tda9887_list_mutex);
-static LIST_HEAD(hybrid_tuner_instance_list);
-
-struct tda9887_priv {
-       struct tuner_i2c_props i2c_props;
-       struct list_head hybrid_tuner_instance_list;
-
-       unsigned char      data[4];
-       unsigned int       config;
-       unsigned int       mode;
-       unsigned int       audmode;
-       v4l2_std_id        std;
-};
-
-/* ---------------------------------------------------------------------- */
-
-#define UNSET       (-1U)
-
-struct tvnorm {
-       v4l2_std_id       std;
-       char              *name;
-       unsigned char     b;
-       unsigned char     c;
-       unsigned char     e;
-};
-
-/* ---------------------------------------------------------------------- */
-
-//
-// TDA defines
-//
-
-//// first reg (b)
-#define cVideoTrapBypassOFF     0x00    // bit b0
-#define cVideoTrapBypassON      0x01    // bit b0
-
-#define cAutoMuteFmInactive     0x00    // bit b1
-#define cAutoMuteFmActive       0x02    // bit b1
-
-#define cIntercarrier           0x00    // bit b2
-#define cQSS                    0x04    // bit b2
-
-#define cPositiveAmTV           0x00    // bit b3:4
-#define cFmRadio                0x08    // bit b3:4
-#define cNegativeFmTV           0x10    // bit b3:4
-
-
-#define cForcedMuteAudioON      0x20    // bit b5
-#define cForcedMuteAudioOFF     0x00    // bit b5
-
-#define cOutputPort1Active      0x00    // bit b6
-#define cOutputPort1Inactive    0x40    // bit b6
-
-#define cOutputPort2Active      0x00    // bit b7
-#define cOutputPort2Inactive    0x80    // bit b7
-
-
-//// second reg (c)
-#define cDeemphasisOFF          0x00    // bit c5
-#define cDeemphasisON           0x20    // bit c5
-
-#define cDeemphasis75           0x00    // bit c6
-#define cDeemphasis50           0x40    // bit c6
-
-#define cAudioGain0             0x00    // bit c7
-#define cAudioGain6             0x80    // bit c7
-
-#define cTopMask                0x1f    // bit c0:4
-#define cTopDefault            0x10    // bit c0:4
-
-//// third reg (e)
-#define cAudioIF_4_5             0x00    // bit e0:1
-#define cAudioIF_5_5             0x01    // bit e0:1
-#define cAudioIF_6_0             0x02    // bit e0:1
-#define cAudioIF_6_5             0x03    // bit e0:1
-
-
-#define cVideoIFMask           0x1c    // bit e2:4
-/* Video IF selection in TV Mode (bit B3=0) */
-#define cVideoIF_58_75           0x00    // bit e2:4
-#define cVideoIF_45_75           0x04    // bit e2:4
-#define cVideoIF_38_90           0x08    // bit e2:4
-#define cVideoIF_38_00           0x0C    // bit e2:4
-#define cVideoIF_33_90           0x10    // bit e2:4
-#define cVideoIF_33_40           0x14    // bit e2:4
-#define cRadioIF_45_75           0x18    // bit e2:4
-#define cRadioIF_38_90           0x1C    // bit e2:4
-
-/* IF1 selection in Radio Mode (bit B3=1) */
-#define cRadioIF_33_30         0x00    // bit e2,4 (also 0x10,0x14)
-#define cRadioIF_41_30         0x04    // bit e2,4
-
-/* Output of AFC pin in radio mode when bit E7=1 */
-#define cRadioAGC_SIF          0x00    // bit e3
-#define cRadioAGC_FM           0x08    // bit e3
-
-#define cTunerGainNormal         0x00    // bit e5
-#define cTunerGainLow            0x20    // bit e5
-
-#define cGating_18               0x00    // bit e6
-#define cGating_36               0x40    // bit e6
-
-#define cAgcOutON                0x80    // bit e7
-#define cAgcOutOFF               0x00    // bit e7
-
-/* ---------------------------------------------------------------------- */
-
-static struct tvnorm tvnorms[] = {
-       {
-               .std   = V4L2_STD_PAL_BG | V4L2_STD_PAL_H | V4L2_STD_PAL_N,
-               .name  = "PAL-BGHN",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis50  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_5_5   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_PAL_I,
-               .name  = "PAL-I",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis50  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_6_0   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_PAL_DK,
-               .name  = "PAL-DK",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis50  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_6_5   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_PAL_M | V4L2_STD_PAL_Nc,
-               .name  = "PAL-M/Nc",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis75  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_4_5   |
-                          cVideoIF_45_75 ),
-       },{
-               .std   = V4L2_STD_SECAM_B | V4L2_STD_SECAM_G | V4L2_STD_SECAM_H,
-               .name  = "SECAM-BGH",
-               .b     = ( cPositiveAmTV  |
-                          cQSS           ),
-               .c     = ( cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_5_5   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_SECAM_L,
-               .name  = "SECAM-L",
-               .b     = ( cPositiveAmTV  |
-                          cQSS           ),
-               .c     = ( cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_6_5   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_SECAM_LC,
-               .name  = "SECAM-L'",
-               .b     = ( cOutputPort2Inactive |
-                          cPositiveAmTV  |
-                          cQSS           ),
-               .c     = ( cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_6_5   |
-                          cVideoIF_33_90 ),
-       },{
-               .std   = V4L2_STD_SECAM_DK,
-               .name  = "SECAM-DK",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis50  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_6_5   |
-                          cVideoIF_38_90 ),
-       },{
-               .std   = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
-               .name  = "NTSC-M",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis75  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_4_5   |
-                          cVideoIF_45_75 ),
-       },{
-               .std   = V4L2_STD_NTSC_M_JP,
-               .name  = "NTSC-M-JP",
-               .b     = ( cNegativeFmTV  |
-                          cQSS           ),
-               .c     = ( cDeemphasisON  |
-                          cDeemphasis50  |
-                          cTopDefault),
-               .e     = ( cGating_36     |
-                          cAudioIF_4_5   |
-                          cVideoIF_58_75 ),
-       }
-};
-
-static struct tvnorm radio_stereo = {
-       .name = "Radio Stereo",
-       .b    = ( cFmRadio       |
-                 cQSS           ),
-       .c    = ( cDeemphasisOFF |
-                 cAudioGain6    |
-                 cTopDefault),
-       .e    = ( cTunerGainLow  |
-                 cAudioIF_5_5   |
-                 cRadioIF_38_90 ),
-};
-
-static struct tvnorm radio_mono = {
-       .name = "Radio Mono",
-       .b    = ( cFmRadio       |
-                 cQSS           ),
-       .c    = ( cDeemphasisON  |
-                 cDeemphasis75  |
-                 cTopDefault),
-       .e    = ( cTunerGainLow  |
-                 cAudioIF_5_5   |
-                 cRadioIF_38_90 ),
-};
-
-/* ---------------------------------------------------------------------- */
-
-static void dump_read_message(struct dvb_frontend *fe, unsigned char *buf)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       static char *afc[16] = {
-               "- 12.5 kHz",
-               "- 37.5 kHz",
-               "- 62.5 kHz",
-               "- 87.5 kHz",
-               "-112.5 kHz",
-               "-137.5 kHz",
-               "-162.5 kHz",
-               "-187.5 kHz [min]",
-               "+187.5 kHz [max]",
-               "+162.5 kHz",
-               "+137.5 kHz",
-               "+112.5 kHz",
-               "+ 87.5 kHz",
-               "+ 62.5 kHz",
-               "+ 37.5 kHz",
-               "+ 12.5 kHz",
-       };
-       tuner_info("read: 0x%2x\n", buf[0]);
-       tuner_info("  after power on : %s\n", (buf[0] & 0x01) ? "yes" : "no");
-       tuner_info("  afc            : %s\n", afc[(buf[0] >> 1) & 0x0f]);
-       tuner_info("  fmif level     : %s\n", (buf[0] & 0x20) ? "high" : "low");
-       tuner_info("  afc window     : %s\n", (buf[0] & 0x40) ? "in" : "out");
-       tuner_info("  vfi level      : %s\n", (buf[0] & 0x80) ? "high" : "low");
-}
-
-static void dump_write_message(struct dvb_frontend *fe, unsigned char *buf)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       static char *sound[4] = {
-               "AM/TV",
-               "FM/radio",
-               "FM/TV",
-               "FM/radio"
-       };
-       static char *adjust[32] = {
-               "-16", "-15", "-14", "-13", "-12", "-11", "-10", "-9",
-               "-8",  "-7",  "-6",  "-5",  "-4",  "-3",  "-2",  "-1",
-               "0",   "+1",  "+2",  "+3",  "+4",  "+5",  "+6",  "+7",
-               "+8",  "+9",  "+10", "+11", "+12", "+13", "+14", "+15"
-       };
-       static char *deemph[4] = {
-               "no", "no", "75", "50"
-       };
-       static char *carrier[4] = {
-               "4.5 MHz",
-               "5.5 MHz",
-               "6.0 MHz",
-               "6.5 MHz / AM"
-       };
-       static char *vif[8] = {
-               "58.75 MHz",
-               "45.75 MHz",
-               "38.9 MHz",
-               "38.0 MHz",
-               "33.9 MHz",
-               "33.4 MHz",
-               "45.75 MHz + pin13",
-               "38.9 MHz + pin13",
-       };
-       static char *rif[4] = {
-               "44 MHz",
-               "52 MHz",
-               "52 MHz",
-               "44 MHz",
-       };
-
-       tuner_info("write: byte B 0x%02x\n", buf[1]);
-       tuner_info("  B0   video mode      : %s\n",
-                  (buf[1] & 0x01) ? "video trap" : "sound trap");
-       tuner_info("  B1   auto mute fm    : %s\n",
-                  (buf[1] & 0x02) ? "yes" : "no");
-       tuner_info("  B2   carrier mode    : %s\n",
-                  (buf[1] & 0x04) ? "QSS" : "Intercarrier");
-       tuner_info("  B3-4 tv sound/radio  : %s\n",
-                  sound[(buf[1] & 0x18) >> 3]);
-       tuner_info("  B5   force mute audio: %s\n",
-                  (buf[1] & 0x20) ? "yes" : "no");
-       tuner_info("  B6   output port 1   : %s\n",
-                  (buf[1] & 0x40) ? "high (inactive)" : "low (active)");
-       tuner_info("  B7   output port 2   : %s\n",
-                  (buf[1] & 0x80) ? "high (inactive)" : "low (active)");
-
-       tuner_info("write: byte C 0x%02x\n", buf[2]);
-       tuner_info("  C0-4 top adjustment  : %s dB\n",
-                  adjust[buf[2] & 0x1f]);
-       tuner_info("  C5-6 de-emphasis     : %s\n",
-                  deemph[(buf[2] & 0x60) >> 5]);
-       tuner_info("  C7   audio gain      : %s\n",
-                  (buf[2] & 0x80) ? "-6" : "0");
-
-       tuner_info("write: byte E 0x%02x\n", buf[3]);
-       tuner_info("  E0-1 sound carrier   : %s\n",
-                  carrier[(buf[3] & 0x03)]);
-       tuner_info("  E6   l pll gating   : %s\n",
-                  (buf[3] & 0x40) ? "36" : "13");
-
-       if (buf[1] & 0x08) {
-               /* radio */
-               tuner_info("  E2-4 video if        : %s\n",
-                          rif[(buf[3] & 0x0c) >> 2]);
-               tuner_info("  E7   vif agc output  : %s\n",
-                          (buf[3] & 0x80)
-                          ? ((buf[3] & 0x10) ? "fm-agc radio" :
-                                               "sif-agc radio")
-                          : "fm radio carrier afc");
-       } else {
-               /* video */
-               tuner_info("  E2-4 video if        : %s\n",
-                          vif[(buf[3] & 0x1c) >> 2]);
-               tuner_info("  E5   tuner gain      : %s\n",
-                          (buf[3] & 0x80)
-                          ? ((buf[3] & 0x20) ? "external" : "normal")
-                          : ((buf[3] & 0x20) ? "minimum"  : "normal"));
-               tuner_info("  E7   vif agc output  : %s\n",
-                          (buf[3] & 0x80) ? ((buf[3] & 0x20)
-                               ? "pin3 port, pin22 vif agc out"
-                               : "pin22 port, pin3 vif acg ext in")
-                               : "pin3+pin22 port");
-       }
-       tuner_info("--\n");
-}
-
-/* ---------------------------------------------------------------------- */
-
-static int tda9887_set_tvnorm(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       struct tvnorm *norm = NULL;
-       char *buf = priv->data;
-       int i;
-
-       if (priv->mode == V4L2_TUNER_RADIO) {
-               if (priv->audmode == V4L2_TUNER_MODE_MONO)
-                       norm = &radio_mono;
-               else
-                       norm = &radio_stereo;
-       } else {
-               for (i = 0; i < ARRAY_SIZE(tvnorms); i++) {
-                       if (tvnorms[i].std & priv->std) {
-                               norm = tvnorms+i;
-                               break;
-                       }
-               }
-       }
-       if (NULL == norm) {
-               tuner_dbg("Unsupported tvnorm entry - audio muted\n");
-               return -1;
-       }
-
-       tuner_dbg("configure for: %s\n", norm->name);
-       buf[1] = norm->b;
-       buf[2] = norm->c;
-       buf[3] = norm->e;
-       return 0;
-}
-
-static unsigned int port1  = UNSET;
-static unsigned int port2  = UNSET;
-static unsigned int qss    = UNSET;
-static unsigned int adjust = UNSET;
-
-module_param(port1, int, 0644);
-module_param(port2, int, 0644);
-module_param(qss, int, 0644);
-module_param(adjust, int, 0644);
-
-static int tda9887_set_insmod(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       char *buf = priv->data;
-
-       if (UNSET != port1) {
-               if (port1)
-                       buf[1] |= cOutputPort1Inactive;
-               else
-                       buf[1] &= ~cOutputPort1Inactive;
-       }
-       if (UNSET != port2) {
-               if (port2)
-                       buf[1] |= cOutputPort2Inactive;
-               else
-                       buf[1] &= ~cOutputPort2Inactive;
-       }
-
-       if (UNSET != qss) {
-               if (qss)
-                       buf[1] |= cQSS;
-               else
-                       buf[1] &= ~cQSS;
-       }
-
-       if (adjust >= 0x00 && adjust < 0x20) {
-               buf[2] &= ~cTopMask;
-               buf[2] |= adjust;
-       }
-       return 0;
-}
-
-static int tda9887_do_config(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       char *buf = priv->data;
-
-       if (priv->config & TDA9887_PORT1_ACTIVE)
-               buf[1] &= ~cOutputPort1Inactive;
-       if (priv->config & TDA9887_PORT1_INACTIVE)
-               buf[1] |= cOutputPort1Inactive;
-       if (priv->config & TDA9887_PORT2_ACTIVE)
-               buf[1] &= ~cOutputPort2Inactive;
-       if (priv->config & TDA9887_PORT2_INACTIVE)
-               buf[1] |= cOutputPort2Inactive;
-
-       if (priv->config & TDA9887_QSS)
-               buf[1] |= cQSS;
-       if (priv->config & TDA9887_INTERCARRIER)
-               buf[1] &= ~cQSS;
-
-       if (priv->config & TDA9887_AUTOMUTE)
-               buf[1] |= cAutoMuteFmActive;
-       if (priv->config & TDA9887_DEEMPHASIS_MASK) {
-               buf[2] &= ~0x60;
-               switch (priv->config & TDA9887_DEEMPHASIS_MASK) {
-               case TDA9887_DEEMPHASIS_NONE:
-                       buf[2] |= cDeemphasisOFF;
-                       break;
-               case TDA9887_DEEMPHASIS_50:
-                       buf[2] |= cDeemphasisON | cDeemphasis50;
-                       break;
-               case TDA9887_DEEMPHASIS_75:
-                       buf[2] |= cDeemphasisON | cDeemphasis75;
-                       break;
-               }
-       }
-       if (priv->config & TDA9887_TOP_SET) {
-               buf[2] &= ~cTopMask;
-               buf[2] |= (priv->config >> 8) & cTopMask;
-       }
-       if ((priv->config & TDA9887_INTERCARRIER_NTSC) &&
-           (priv->std & V4L2_STD_NTSC))
-               buf[1] &= ~cQSS;
-       if (priv->config & TDA9887_GATING_18)
-               buf[3] &= ~cGating_36;
-
-       if (priv->mode == V4L2_TUNER_RADIO) {
-               if (priv->config & TDA9887_RIF_41_3) {
-                       buf[3] &= ~cVideoIFMask;
-                       buf[3] |= cRadioIF_41_30;
-               }
-               if (priv->config & TDA9887_GAIN_NORMAL)
-                       buf[3] &= ~cTunerGainLow;
-       }
-
-       return 0;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static int tda9887_status(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       unsigned char buf[1];
-       int rc;
-
-       memset(buf,0,sizeof(buf));
-       if (1 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props,buf,1)))
-               tuner_info("i2c i/o error: rc == %d (should be 1)\n", rc);
-       dump_read_message(fe, buf);
-       return 0;
-}
-
-static void tda9887_configure(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       int rc;
-
-       memset(priv->data,0,sizeof(priv->data));
-       tda9887_set_tvnorm(fe);
-
-       /* A note on the port settings:
-          These settings tend to depend on the specifics of the board.
-          By default they are set to inactive (bit value 1) by this driver,
-          overwriting any changes made by the tvnorm. This means that it
-          is the responsibility of the module using the tda9887 to set
-          these values in case of changes in the tvnorm.
-          In many cases port 2 should be made active (0) when selecting
-          SECAM-L, and port 2 should remain inactive (1) for SECAM-L'.
-
-          For the other standards the tda9887 application note says that
-          the ports should be set to active (0), but, again, that may
-          differ depending on the precise hardware configuration.
-        */
-       priv->data[1] |= cOutputPort1Inactive;
-       priv->data[1] |= cOutputPort2Inactive;
-
-       tda9887_do_config(fe);
-       tda9887_set_insmod(fe);
-
-       if (priv->mode == T_STANDBY)
-               priv->data[1] |= cForcedMuteAudioON;
-
-       tuner_dbg("writing: b=0x%02x c=0x%02x e=0x%02x\n",
-                 priv->data[1], priv->data[2], priv->data[3]);
-       if (debug > 1)
-               dump_write_message(fe, priv->data);
-
-       if (4 != (rc = tuner_i2c_xfer_send(&priv->i2c_props,priv->data,4)))
-               tuner_info("i2c i/o error: rc == %d (should be 4)\n", rc);
-
-       if (debug > 2) {
-               msleep_interruptible(1000);
-               tda9887_status(fe);
-       }
-}
-
-/* ---------------------------------------------------------------------- */
-
-static void tda9887_tuner_status(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       tuner_info("Data bytes: b=0x%02x c=0x%02x e=0x%02x\n",
-                  priv->data[1], priv->data[2], priv->data[3]);
-}
-
-static int tda9887_get_afc(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-       static int AFC_BITS_2_kHz[] = {
-               -12500,  -37500,  -62500,  -97500,
-               -112500, -137500, -162500, -187500,
-               187500,  162500,  137500,  112500,
-               97500 ,  62500,   37500 ,  12500
-       };
-       int afc=0;
-       __u8 reg = 0;
-
-       if (1 == tuner_i2c_xfer_recv(&priv->i2c_props,&reg,1))
-               afc = AFC_BITS_2_kHz[(reg>>1)&0x0f];
-
-       return afc;
-}
-
-static void tda9887_standby(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       priv->mode = T_STANDBY;
-
-       tda9887_configure(fe);
-}
-
-static void tda9887_set_params(struct dvb_frontend *fe,
-                              struct analog_parameters *params)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       priv->mode    = params->mode;
-       priv->audmode = params->audmode;
-       priv->std     = params->std;
-       tda9887_configure(fe);
-}
-
-static int tda9887_set_config(struct dvb_frontend *fe, void *priv_cfg)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       priv->config = *(unsigned int *)priv_cfg;
-       tda9887_configure(fe);
-
-       return 0;
-}
-
-static void tda9887_release(struct dvb_frontend *fe)
-{
-       struct tda9887_priv *priv = fe->analog_demod_priv;
-
-       mutex_lock(&tda9887_list_mutex);
-
-       if (priv)
-               hybrid_tuner_release_state(priv);
-
-       mutex_unlock(&tda9887_list_mutex);
-
-       fe->analog_demod_priv = NULL;
-}
-
-static struct analog_demod_ops tda9887_ops = {
-       .info           = {
-               .name   = "tda9887",
-       },
-       .set_params     = tda9887_set_params,
-       .standby        = tda9887_standby,
-       .tuner_status   = tda9887_tuner_status,
-       .get_afc        = tda9887_get_afc,
-       .release        = tda9887_release,
-       .set_config     = tda9887_set_config,
-};
-
-struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
-                                   struct i2c_adapter *i2c_adap,
-                                   u8 i2c_addr)
-{
-       struct tda9887_priv *priv = NULL;
-       int instance;
-
-       mutex_lock(&tda9887_list_mutex);
-
-       instance = hybrid_tuner_request_state(struct tda9887_priv, priv,
-                                             hybrid_tuner_instance_list,
-                                             i2c_adap, i2c_addr, "tda9887");
-       switch (instance) {
-       case 0:
-               mutex_unlock(&tda9887_list_mutex);
-               return NULL;
-               break;
-       case 1:
-               fe->analog_demod_priv = priv;
-               priv->mode = T_STANDBY;
-               tuner_info("tda988[5/6/7] found\n");
-               break;
-       default:
-               fe->analog_demod_priv = priv;
-               break;
-       }
-
-       mutex_unlock(&tda9887_list_mutex);
-
-       memcpy(&fe->ops.analog_ops, &tda9887_ops,
-              sizeof(struct analog_demod_ops));
-
-       return fe;
-}
-EXPORT_SYMBOL_GPL(tda9887_attach);
-
-MODULE_LICENSE("GPL");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/video/tda9887.h b/drivers/media/video/tda9887.h
deleted file mode 100644 (file)
index be49dcb..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TDA9887_H__
-#define __TDA9887_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-/* ------------------------------------------------------------------------ */
-#if defined(CONFIG_TUNER_TDA9887) || (defined(CONFIG_TUNER_TDA9887_MODULE) && defined(MODULE))
-extern struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
-                                          struct i2c_adapter *i2c_adap,
-                                          u8 i2c_addr);
-#else
-static inline struct dvb_frontend *tda9887_attach(struct dvb_frontend *fe,
-                                                 struct i2c_adapter *i2c_adap,
-                                                 u8 i2c_addr)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TDA9887_H__ */
diff --git a/drivers/media/video/tea5761.c b/drivers/media/video/tea5761.c
deleted file mode 100644 (file)
index b93cdef..0000000
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
- * For Philips TEA5761 FM Chip
- * I2C address is allways 0x20 (0x10 at 7-bit mode).
- *
- * Copyright (c) 2005-2007 Mauro Carvalho Chehab (mchehab@infradead.org)
- * This code is placed under the terms of the GNUv2 General Public License
- *
- */
-
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/videodev.h>
-#include <media/tuner.h>
-#include "tuner-i2c.h"
-#include "tea5761.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-struct tea5761_priv {
-       struct tuner_i2c_props i2c_props;
-
-       u32 frequency;
-};
-
-/*****************************************************************************/
-
-/***************************
- * TEA5761HN I2C registers *
- ***************************/
-
-/* INTREG - Read: bytes 0 and 1 / Write: byte 0 */
-
-       /* first byte for reading */
-#define TEA5761_INTREG_IFFLAG          0x10
-#define TEA5761_INTREG_LEVFLAG         0x8
-#define TEA5761_INTREG_FRRFLAG         0x2
-#define TEA5761_INTREG_BLFLAG          0x1
-
-       /* second byte for reading / byte for writing */
-#define TEA5761_INTREG_IFMSK           0x10
-#define TEA5761_INTREG_LEVMSK          0x8
-#define TEA5761_INTREG_FRMSK           0x2
-#define TEA5761_INTREG_BLMSK           0x1
-
-/* FRQSET - Read: bytes 2 and 3 / Write: byte 1 and 2 */
-
-       /* First byte */
-#define TEA5761_FRQSET_SEARCH_UP 0x80          /* 1=Station search from botton to up */
-#define TEA5761_FRQSET_SEARCH_MODE 0x40                /* 1=Search mode */
-
-       /* Bits 0-5 for divider MSB */
-
-       /* Second byte */
-       /* Bits 0-7 for divider LSB */
-
-/* TNCTRL - Read: bytes 4 and 5 / Write: Bytes 3 and 4 */
-
-       /* first byte */
-
-#define TEA5761_TNCTRL_PUPD_0  0x40    /* Power UP/Power Down MSB */
-#define TEA5761_TNCTRL_BLIM    0X20    /* 1= Japan Frequencies, 0= European frequencies */
-#define TEA5761_TNCTRL_SWPM    0x10    /* 1= software port is FRRFLAG */
-#define TEA5761_TNCTRL_IFCTC   0x08    /* 1= IF count time 15.02 ms, 0= IF count time 2.02 ms */
-#define TEA5761_TNCTRL_AFM     0x04
-#define TEA5761_TNCTRL_SMUTE   0x02    /* 1= Soft mute */
-#define TEA5761_TNCTRL_SNC     0x01
-
-       /* second byte */
-
-#define TEA5761_TNCTRL_MU      0x80    /* 1=Hard mute */
-#define TEA5761_TNCTRL_SSL_1   0x40
-#define TEA5761_TNCTRL_SSL_0   0x20
-#define TEA5761_TNCTRL_HLSI    0x10
-#define TEA5761_TNCTRL_MST     0x08    /* 1 = mono */
-#define TEA5761_TNCTRL_SWP     0x04
-#define TEA5761_TNCTRL_DTC     0x02    /* 1 = deemphasis 50 us, 0 = deemphasis 75 us */
-#define TEA5761_TNCTRL_AHLSI   0x01
-
-/* FRQCHECK - Read: bytes 6 and 7  */
-       /* First byte */
-
-       /* Bits 0-5 for divider MSB */
-
-       /* Second byte */
-       /* Bits 0-7 for divider LSB */
-
-/* TUNCHECK - Read: bytes 8 and 9  */
-
-       /* First byte */
-#define TEA5761_TUNCHECK_IF_MASK       0x7e    /* IF count */
-#define TEA5761_TUNCHECK_TUNTO         0x01
-
-       /* Second byte */
-#define TEA5761_TUNCHECK_LEV_MASK      0xf0    /* Level Count */
-#define TEA5761_TUNCHECK_LD            0x08
-#define TEA5761_TUNCHECK_STEREO                0x04
-
-/* TESTREG - Read: bytes 10 and 11 / Write: bytes 5 and 6 */
-
-       /* All zero = no test mode */
-
-/* MANID - Read: bytes 12 and 13 */
-
-       /* First byte - should be 0x10 */
-#define TEA5767_MANID_VERSION_MASK     0xf0    /* Version = 1 */
-#define TEA5767_MANID_ID_MSB_MASK      0x0f    /* Manufacurer ID - should be 0 */
-
-       /* Second byte - Should be 0x2b */
-
-#define TEA5767_MANID_ID_LSB_MASK      0xfe    /* Manufacturer ID - should be 0x15 */
-#define TEA5767_MANID_IDAV             0x01    /* 1 = Chip has ID, 0 = Chip has no ID */
-
-/* Chip ID - Read: bytes 14 and 15 */
-
-       /* First byte - should be 0x57 */
-
-       /* Second byte - should be 0x61 */
-
-/*****************************************************************************/
-
-#define FREQ_OFFSET 0 /* for TEA5767, it is 700 to give the right freq */
-static void tea5761_status_dump(unsigned char *buffer)
-{
-       unsigned int div, frq;
-
-       div = ((buffer[2] & 0x3f) << 8) | buffer[3];
-
-       frq = 1000 * (div * 32768 / 1000 + FREQ_OFFSET + 225) / 4;      /* Freq in KHz */
-
-       printk(KERN_INFO "tea5761: Frequency %d.%03d KHz (divider = 0x%04x)\n",
-              frq / 1000, frq % 1000, div);
-}
-
-/* Freq should be specifyed at 62.5 Hz */
-static int set_radio_freq(struct dvb_frontend *fe,
-                         struct analog_parameters *params)
-{
-       struct tea5761_priv *priv = fe->tuner_priv;
-       unsigned int frq = params->frequency;
-       unsigned char buffer[7] = {0, 0, 0, 0, 0, 0, 0 };
-       unsigned div;
-       int rc;
-
-       tuner_dbg("radio freq counter %d\n", frq);
-
-       if (params->mode == T_STANDBY) {
-               tuner_dbg("TEA5761 set to standby mode\n");
-               buffer[5] |= TEA5761_TNCTRL_MU;
-       } else {
-               buffer[4] |= TEA5761_TNCTRL_PUPD_0;
-       }
-
-
-       if (params->audmode == V4L2_TUNER_MODE_MONO) {
-               tuner_dbg("TEA5761 set to mono\n");
-               buffer[5] |= TEA5761_TNCTRL_MST;
-       } else {
-               tuner_dbg("TEA5761 set to stereo\n");
-       }
-
-       div = (1000 * (frq * 4 / 16 + 700 + 225) ) >> 15;
-       buffer[1] = (div >> 8) & 0x3f;
-       buffer[2] = div & 0xff;
-
-       if (debug)
-               tea5761_status_dump(buffer);
-
-       if (7 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 7)))
-               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
-
-       priv->frequency = frq * 125 / 2;
-
-       return 0;
-}
-
-static int tea5761_read_status(struct dvb_frontend *fe, char *buffer)
-{
-       struct tea5761_priv *priv = fe->tuner_priv;
-       int rc;
-
-       memset(buffer, 0, 16);
-       if (16 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 16))) {
-               tuner_warn("i2c i/o error: rc == %d (should be 16)\n", rc);
-               return -EREMOTEIO;
-       }
-
-       return 0;
-}
-
-static inline int tea5761_signal(struct dvb_frontend *fe, const char *buffer)
-{
-       struct tea5761_priv *priv = fe->tuner_priv;
-
-       int signal = ((buffer[9] & TEA5761_TUNCHECK_LEV_MASK) << (13 - 4));
-
-       tuner_dbg("Signal strength: %d\n", signal);
-
-       return signal;
-}
-
-static inline int tea5761_stereo(struct dvb_frontend *fe, const char *buffer)
-{
-       struct tea5761_priv *priv = fe->tuner_priv;
-
-       int stereo = buffer[9] & TEA5761_TUNCHECK_STEREO;
-
-       tuner_dbg("Radio ST GET = %02x\n", stereo);
-
-       return (stereo ? V4L2_TUNER_SUB_STEREO : 0);
-}
-
-static int tea5761_get_status(struct dvb_frontend *fe, u32 *status)
-{
-       unsigned char buffer[16];
-
-       *status = 0;
-
-       if (0 == tea5761_read_status(fe, buffer)) {
-               if (tea5761_signal(fe, buffer))
-                       *status = TUNER_STATUS_LOCKED;
-               if (tea5761_stereo(fe, buffer))
-                       *status |= TUNER_STATUS_STEREO;
-       }
-
-       return 0;
-}
-
-static int tea5761_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
-{
-       unsigned char buffer[16];
-
-       *strength = 0;
-
-       if (0 == tea5761_read_status(fe, buffer))
-               *strength = tea5761_signal(fe, buffer);
-
-       return 0;
-}
-
-int tea5761_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr)
-{
-       unsigned char buffer[16];
-       int rc;
-       struct tuner_i2c_props i2c = { .adap = i2c_adap, .addr = i2c_addr };
-
-       if (16 != (rc = tuner_i2c_xfer_recv(&i2c, buffer, 16))) {
-               printk(KERN_WARNING "it is not a TEA5761. Received %i chars.\n", rc);
-               return -EINVAL;
-       }
-
-       if ((buffer[13] != 0x2b) || (buffer[14] != 0x57) || (buffer[15] != 0x061)) {
-               printk(KERN_WARNING "Manufacturer ID= 0x%02x, Chip ID = %02x%02x."
-                                   " It is not a TEA5761\n",
-                                   buffer[13], buffer[14], buffer[15]);
-               return -EINVAL;
-       }
-       printk(KERN_WARNING "tea5761: TEA%02x%02x detected. "
-                           "Manufacturer ID= 0x%02x\n",
-                           buffer[14], buffer[15], buffer[13]);
-
-       return 0;
-}
-
-static int tea5761_release(struct dvb_frontend *fe)
-{
-       kfree(fe->tuner_priv);
-       fe->tuner_priv = NULL;
-
-       return 0;
-}
-
-static int tea5761_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct tea5761_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-       return 0;
-}
-
-static struct dvb_tuner_ops tea5761_tuner_ops = {
-       .info = {
-               .name           = "tea5761", // Philips TEA5761HN FM Radio
-       },
-       .set_analog_params = set_radio_freq,
-       .release           = tea5761_release,
-       .get_frequency     = tea5761_get_frequency,
-       .get_status        = tea5761_get_status,
-       .get_rf_strength   = tea5761_get_rf_strength,
-};
-
-struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
-                                   struct i2c_adapter* i2c_adap,
-                                   u8 i2c_addr)
-{
-       struct tea5761_priv *priv = NULL;
-
-       if (tea5761_autodetection(i2c_adap, i2c_addr) == EINVAL)
-               return NULL;
-
-       priv = kzalloc(sizeof(struct tea5761_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-       fe->tuner_priv = priv;
-
-       priv->i2c_props.addr = i2c_addr;
-       priv->i2c_props.adap = i2c_adap;
-       priv->i2c_props.name = "tea5761";
-
-       memcpy(&fe->ops.tuner_ops, &tea5761_tuner_ops,
-              sizeof(struct dvb_tuner_ops));
-
-       tuner_info("type set to %s\n", "Philips TEA5761HN FM Radio");
-
-       return fe;
-}
-
-
-EXPORT_SYMBOL_GPL(tea5761_attach);
-EXPORT_SYMBOL_GPL(tea5761_autodetection);
-
-MODULE_DESCRIPTION("Philips TEA5761 FM tuner driver");
-MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/tea5761.h b/drivers/media/video/tea5761.h
deleted file mode 100644 (file)
index 8eb6272..0000000
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TEA5761_H__
-#define __TEA5761_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-#if defined(CONFIG_TUNER_TEA5761) || (defined(CONFIG_TUNER_TEA5761_MODULE) && defined(MODULE))
-extern int tea5761_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr);
-
-extern struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
-                                          struct i2c_adapter* i2c_adap,
-                                          u8 i2c_addr);
-#else
-static inline int tea5761_autodetection(struct i2c_adapter* i2c_adap,
-                                       u8 i2c_addr)
-{
-       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __func__);
-       return -EINVAL;
-}
-
-static inline struct dvb_frontend *tea5761_attach(struct dvb_frontend *fe,
-                                                  struct i2c_adapter* i2c_adap,
-                                                  u8 i2c_addr)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TEA5761_H__ */
diff --git a/drivers/media/video/tea5767.c b/drivers/media/video/tea5767.c
deleted file mode 100644 (file)
index f6e7d7a..0000000
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
- * For Philips TEA5767 FM Chip used on some TV Cards like Prolink Pixelview
- * I2C address is allways 0xC0.
- *
- *
- * Copyright (c) 2005 Mauro Carvalho Chehab (mchehab@infradead.org)
- * This code is placed under the terms of the GNU General Public License
- *
- * tea5767 autodetection thanks to Torsten Seeboth and Atsushi Nakagawa
- * from their contributions on DScaler.
- */
-
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/videodev.h>
-#include "tuner-i2c.h"
-#include "tea5767.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-/*****************************************************************************/
-
-struct tea5767_priv {
-       struct tuner_i2c_props  i2c_props;
-       u32                     frequency;
-       struct tea5767_ctrl     ctrl;
-};
-
-/*****************************************************************************/
-
-/******************************
- * Write mode register values *
- ******************************/
-
-/* First register */
-#define TEA5767_MUTE           0x80    /* Mutes output */
-#define TEA5767_SEARCH         0x40    /* Activates station search */
-/* Bits 0-5 for divider MSB */
-
-/* Second register */
-/* Bits 0-7 for divider LSB */
-
-/* Third register */
-
-/* Station search from botton to up */
-#define TEA5767_SEARCH_UP      0x80
-
-/* Searches with ADC output = 10 */
-#define TEA5767_SRCH_HIGH_LVL  0x60
-
-/* Searches with ADC output = 10 */
-#define TEA5767_SRCH_MID_LVL   0x40
-
-/* Searches with ADC output = 5 */
-#define TEA5767_SRCH_LOW_LVL   0x20
-
-/* if on, div=4*(Frf+Fif)/Fref otherwise, div=4*(Frf-Fif)/Freq) */
-#define TEA5767_HIGH_LO_INJECT 0x10
-
-/* Disable stereo */
-#define TEA5767_MONO           0x08
-
-/* Disable right channel and turns to mono */
-#define TEA5767_MUTE_RIGHT     0x04
-
-/* Disable left channel and turns to mono */
-#define TEA5767_MUTE_LEFT      0x02
-
-#define TEA5767_PORT1_HIGH     0x01
-
-/* Fourth register */
-#define TEA5767_PORT2_HIGH     0x80
-/* Chips stops working. Only I2C bus remains on */
-#define TEA5767_STDBY          0x40
-
-/* Japan freq (76-108 MHz. If disabled, 87.5-108 MHz */
-#define TEA5767_JAPAN_BAND     0x20
-
-/* Unselected means 32.768 KHz freq as reference. Otherwise Xtal at 13 MHz */
-#define TEA5767_XTAL_32768     0x10
-
-/* Cuts weak signals */
-#define TEA5767_SOFT_MUTE      0x08
-
-/* Activates high cut control */
-#define TEA5767_HIGH_CUT_CTRL  0x04
-
-/* Activates stereo noise control */
-#define TEA5767_ST_NOISE_CTL   0x02
-
-/* If activate PORT 1 indicates SEARCH or else it is used as PORT1 */
-#define TEA5767_SRCH_IND       0x01
-
-/* Fifth register */
-
-/* By activating, it will use Xtal at 13 MHz as reference for divider */
-#define TEA5767_PLLREF_ENABLE  0x80
-
-/* By activating, deemphasis=50, or else, deemphasis of 50us */
-#define TEA5767_DEEMPH_75      0X40
-
-/*****************************
- * Read mode register values *
- *****************************/
-
-/* First register */
-#define TEA5767_READY_FLAG_MASK        0x80
-#define TEA5767_BAND_LIMIT_MASK        0X40
-/* Bits 0-5 for divider MSB after search or preset */
-
-/* Second register */
-/* Bits 0-7 for divider LSB after search or preset */
-
-/* Third register */
-#define TEA5767_STEREO_MASK    0x80
-#define TEA5767_IF_CNTR_MASK   0x7f
-
-/* Fourth register */
-#define TEA5767_ADC_LEVEL_MASK 0xf0
-
-/* should be 0 */
-#define TEA5767_CHIP_ID_MASK   0x0f
-
-/* Fifth register */
-/* Reserved for future extensions */
-#define TEA5767_RESERVED_MASK  0xff
-
-/*****************************************************************************/
-
-static void tea5767_status_dump(struct tea5767_priv *priv,
-                               unsigned char *buffer)
-{
-       unsigned int div, frq;
-
-       if (TEA5767_READY_FLAG_MASK & buffer[0])
-               tuner_info("Ready Flag ON\n");
-       else
-               tuner_info("Ready Flag OFF\n");
-
-       if (TEA5767_BAND_LIMIT_MASK & buffer[0])
-               tuner_info("Tuner at band limit\n");
-       else
-               tuner_info("Tuner not at band limit\n");
-
-       div = ((buffer[0] & 0x3f) << 8) | buffer[1];
-
-       switch (priv->ctrl.xtal_freq) {
-       case TEA5767_HIGH_LO_13MHz:
-               frq = (div * 50000 - 700000 - 225000) / 4;      /* Freq in KHz */
-               break;
-       case TEA5767_LOW_LO_13MHz:
-               frq = (div * 50000 + 700000 + 225000) / 4;      /* Freq in KHz */
-               break;
-       case TEA5767_LOW_LO_32768:
-               frq = (div * 32768 + 700000 + 225000) / 4;      /* Freq in KHz */
-               break;
-       case TEA5767_HIGH_LO_32768:
-       default:
-               frq = (div * 32768 - 700000 - 225000) / 4;      /* Freq in KHz */
-               break;
-       }
-       buffer[0] = (div >> 8) & 0x3f;
-       buffer[1] = div & 0xff;
-
-       tuner_info("Frequency %d.%03d KHz (divider = 0x%04x)\n",
-                  frq / 1000, frq % 1000, div);
-
-       if (TEA5767_STEREO_MASK & buffer[2])
-               tuner_info("Stereo\n");
-       else
-               tuner_info("Mono\n");
-
-       tuner_info("IF Counter = %d\n", buffer[2] & TEA5767_IF_CNTR_MASK);
-
-       tuner_info("ADC Level = %d\n",
-                  (buffer[3] & TEA5767_ADC_LEVEL_MASK) >> 4);
-
-       tuner_info("Chip ID = %d\n", (buffer[3] & TEA5767_CHIP_ID_MASK));
-
-       tuner_info("Reserved = 0x%02x\n",
-                  (buffer[4] & TEA5767_RESERVED_MASK));
-}
-
-/* Freq should be specifyed at 62.5 Hz */
-static int set_radio_freq(struct dvb_frontend *fe,
-                         struct analog_parameters *params)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-       unsigned int frq = params->frequency;
-       unsigned char buffer[5];
-       unsigned div;
-       int rc;
-
-       tuner_dbg("radio freq = %d.%03d MHz\n", frq/16000,(frq/16)%1000);
-
-       buffer[2] = 0;
-
-       if (priv->ctrl.port1)
-               buffer[2] |= TEA5767_PORT1_HIGH;
-
-       if (params->audmode == V4L2_TUNER_MODE_MONO) {
-               tuner_dbg("TEA5767 set to mono\n");
-               buffer[2] |= TEA5767_MONO;
-       } else {
-               tuner_dbg("TEA5767 set to stereo\n");
-       }
-
-
-       buffer[3] = 0;
-
-       if (priv->ctrl.port2)
-               buffer[3] |= TEA5767_PORT2_HIGH;
-
-       if (priv->ctrl.high_cut)
-               buffer[3] |= TEA5767_HIGH_CUT_CTRL;
-
-       if (priv->ctrl.st_noise)
-               buffer[3] |= TEA5767_ST_NOISE_CTL;
-
-       if (priv->ctrl.soft_mute)
-               buffer[3] |= TEA5767_SOFT_MUTE;
-
-       if (priv->ctrl.japan_band)
-               buffer[3] |= TEA5767_JAPAN_BAND;
-
-       buffer[4] = 0;
-
-       if (priv->ctrl.deemph_75)
-               buffer[4] |= TEA5767_DEEMPH_75;
-
-       if (priv->ctrl.pllref)
-               buffer[4] |= TEA5767_PLLREF_ENABLE;
-
-
-       /* Rounds freq to next decimal value - for 62.5 KHz step */
-       /* frq = 20*(frq/16)+radio_frq[frq%16]; */
-
-       switch (priv->ctrl.xtal_freq) {
-       case TEA5767_HIGH_LO_13MHz:
-               tuner_dbg("radio HIGH LO inject xtal @ 13 MHz\n");
-               buffer[2] |= TEA5767_HIGH_LO_INJECT;
-               div = (frq * (4000 / 16) + 700000 + 225000 + 25000) / 50000;
-               break;
-       case TEA5767_LOW_LO_13MHz:
-               tuner_dbg("radio LOW LO inject xtal @ 13 MHz\n");
-
-               div = (frq * (4000 / 16) - 700000 - 225000 + 25000) / 50000;
-               break;
-       case TEA5767_LOW_LO_32768:
-               tuner_dbg("radio LOW LO inject xtal @ 32,768 MHz\n");
-               buffer[3] |= TEA5767_XTAL_32768;
-               /* const 700=4000*175 Khz - to adjust freq to right value */
-               div = ((frq * (4000 / 16) - 700000 - 225000) + 16384) >> 15;
-               break;
-       case TEA5767_HIGH_LO_32768:
-       default:
-               tuner_dbg("radio HIGH LO inject xtal @ 32,768 MHz\n");
-
-               buffer[2] |= TEA5767_HIGH_LO_INJECT;
-               buffer[3] |= TEA5767_XTAL_32768;
-               div = ((frq * (4000 / 16) + 700000 + 225000) + 16384) >> 15;
-               break;
-       }
-       buffer[0] = (div >> 8) & 0x3f;
-       buffer[1] = div & 0xff;
-
-       if (5 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 5)))
-               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
-
-       if (debug) {
-               if (5 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 5)))
-                       tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
-               else
-                       tea5767_status_dump(priv, buffer);
-       }
-
-       priv->frequency = frq * 125 / 2;
-
-       return 0;
-}
-
-static int tea5767_read_status(struct dvb_frontend *fe, char *buffer)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-       int rc;
-
-       memset(buffer, 0, 5);
-       if (5 != (rc = tuner_i2c_xfer_recv(&priv->i2c_props, buffer, 5))) {
-               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
-               return -EREMOTEIO;
-       }
-
-       return 0;
-}
-
-static inline int tea5767_signal(struct dvb_frontend *fe, const char *buffer)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-
-       int signal = ((buffer[3] & TEA5767_ADC_LEVEL_MASK) << 8);
-
-       tuner_dbg("Signal strength: %d\n", signal);
-
-       return signal;
-}
-
-static inline int tea5767_stereo(struct dvb_frontend *fe, const char *buffer)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-
-       int stereo = buffer[2] & TEA5767_STEREO_MASK;
-
-       tuner_dbg("Radio ST GET = %02x\n", stereo);
-
-       return (stereo ? V4L2_TUNER_SUB_STEREO : 0);
-}
-
-static int tea5767_get_status(struct dvb_frontend *fe, u32 *status)
-{
-       unsigned char buffer[5];
-
-       *status = 0;
-
-       if (0 == tea5767_read_status(fe, buffer)) {
-               if (tea5767_signal(fe, buffer))
-                       *status = TUNER_STATUS_LOCKED;
-               if (tea5767_stereo(fe, buffer))
-                       *status |= TUNER_STATUS_STEREO;
-       }
-
-       return 0;
-}
-
-static int tea5767_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
-{
-       unsigned char buffer[5];
-
-       *strength = 0;
-
-       if (0 == tea5767_read_status(fe, buffer))
-               *strength = tea5767_signal(fe, buffer);
-
-       return 0;
-}
-
-static int tea5767_standby(struct dvb_frontend *fe)
-{
-       unsigned char buffer[5];
-       struct tea5767_priv *priv = fe->tuner_priv;
-       unsigned div, rc;
-
-       div = (87500 * 4 + 700 + 225 + 25) / 50; /* Set frequency to 87.5 MHz */
-       buffer[0] = (div >> 8) & 0x3f;
-       buffer[1] = div & 0xff;
-       buffer[2] = TEA5767_PORT1_HIGH;
-       buffer[3] = TEA5767_PORT2_HIGH | TEA5767_HIGH_CUT_CTRL |
-                   TEA5767_ST_NOISE_CTL | TEA5767_JAPAN_BAND | TEA5767_STDBY;
-       buffer[4] = 0;
-
-       if (5 != (rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 5)))
-               tuner_warn("i2c i/o error: rc == %d (should be 5)\n", rc);
-
-       return 0;
-}
-
-int tea5767_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr)
-{
-       struct tuner_i2c_props i2c = { .adap = i2c_adap, .addr = i2c_addr };
-       unsigned char buffer[7] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
-       int rc;
-
-       if ((rc = tuner_i2c_xfer_recv(&i2c, buffer, 7))< 5) {
-               printk(KERN_WARNING "It is not a TEA5767. Received %i bytes.\n", rc);
-               return EINVAL;
-       }
-
-       /* If all bytes are the same then it's a TV tuner and not a tea5767 */
-       if (buffer[0] == buffer[1] && buffer[0] == buffer[2] &&
-           buffer[0] == buffer[3] && buffer[0] == buffer[4]) {
-               printk(KERN_WARNING "All bytes are equal. It is not a TEA5767\n");
-               return EINVAL;
-       }
-
-       /*  Status bytes:
-        *  Byte 4: bit 3:1 : CI (Chip Identification) == 0
-        *          bit 0   : internally set to 0
-        *  Byte 5: bit 7:0 : == 0
-        */
-       if (((buffer[3] & 0x0f) != 0x00) || (buffer[4] != 0x00)) {
-               printk(KERN_WARNING "Chip ID is not zero. It is not a TEA5767\n");
-               return EINVAL;
-       }
-
-
-       return 0;
-}
-
-static int tea5767_release(struct dvb_frontend *fe)
-{
-       kfree(fe->tuner_priv);
-       fe->tuner_priv = NULL;
-
-       return 0;
-}
-
-static int tea5767_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-
-       return 0;
-}
-
-static int tea5767_set_config (struct dvb_frontend *fe, void *priv_cfg)
-{
-       struct tea5767_priv *priv = fe->tuner_priv;
-
-       memcpy(&priv->ctrl, priv_cfg, sizeof(priv->ctrl));
-
-       return 0;
-}
-
-static struct dvb_tuner_ops tea5767_tuner_ops = {
-       .info = {
-               .name           = "tea5767", // Philips TEA5767HN FM Radio
-       },
-
-       .set_analog_params = set_radio_freq,
-       .set_config        = tea5767_set_config,
-       .sleep             = tea5767_standby,
-       .release           = tea5767_release,
-       .get_frequency     = tea5767_get_frequency,
-       .get_status        = tea5767_get_status,
-       .get_rf_strength   = tea5767_get_rf_strength,
-};
-
-struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
-                                   struct i2c_adapter* i2c_adap,
-                                   u8 i2c_addr)
-{
-       struct tea5767_priv *priv = NULL;
-
-       priv = kzalloc(sizeof(struct tea5767_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return NULL;
-       fe->tuner_priv = priv;
-
-       priv->i2c_props.addr  = i2c_addr;
-       priv->i2c_props.adap  = i2c_adap;
-       priv->i2c_props.name  = "tea5767";
-
-       priv->ctrl.xtal_freq  = TEA5767_HIGH_LO_32768;
-       priv->ctrl.port1      = 1;
-       priv->ctrl.port2      = 1;
-       priv->ctrl.high_cut   = 1;
-       priv->ctrl.st_noise   = 1;
-       priv->ctrl.japan_band = 1;
-
-       memcpy(&fe->ops.tuner_ops, &tea5767_tuner_ops,
-              sizeof(struct dvb_tuner_ops));
-
-       tuner_info("type set to %s\n", "Philips TEA5767HN FM Radio");
-
-       return fe;
-}
-
-EXPORT_SYMBOL_GPL(tea5767_attach);
-EXPORT_SYMBOL_GPL(tea5767_autodetection);
-
-MODULE_DESCRIPTION("Philips TEA5767 FM tuner driver");
-MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/tea5767.h b/drivers/media/video/tea5767.h
deleted file mode 100644 (file)
index 7b547c0..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TEA5767_H__
-#define __TEA5767_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-enum tea5767_xtal {
-       TEA5767_LOW_LO_32768    = 0,
-       TEA5767_HIGH_LO_32768   = 1,
-       TEA5767_LOW_LO_13MHz    = 2,
-       TEA5767_HIGH_LO_13MHz   = 3,
-};
-
-struct tea5767_ctrl {
-       unsigned int            port1:1;
-       unsigned int            port2:1;
-       unsigned int            high_cut:1;
-       unsigned int            st_noise:1;
-       unsigned int            soft_mute:1;
-       unsigned int            japan_band:1;
-       unsigned int            deemph_75:1;
-       unsigned int            pllref:1;
-       enum tea5767_xtal       xtal_freq;
-};
-
-#if defined(CONFIG_TUNER_TEA5767) || (defined(CONFIG_TUNER_TEA5767_MODULE) && defined(MODULE))
-extern int tea5767_autodetection(struct i2c_adapter* i2c_adap, u8 i2c_addr);
-
-extern struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
-                                          struct i2c_adapter* i2c_adap,
-                                          u8 i2c_addr);
-#else
-static inline int tea5767_autodetection(struct i2c_adapter* i2c_adap,
-                                       u8 i2c_addr)
-{
-       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __func__);
-       return -EINVAL;
-}
-
-static inline struct dvb_frontend *tea5767_attach(struct dvb_frontend *fe,
-                                                  struct i2c_adapter* i2c_adap,
-                                                  u8 i2c_addr)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TEA5767_H__ */
diff --git a/drivers/media/video/tuner-i2c.h b/drivers/media/video/tuner-i2c.h
deleted file mode 100644 (file)
index 3ad6c8e..0000000
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
-    tuner-i2c.h - i2c interface for different tuners
-
-    Copyright (C) 2007 Michael Krufky (mkrufky@linuxtv.org)
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TUNER_I2C_H__
-#define __TUNER_I2C_H__
-
-#include <linux/i2c.h>
-
-struct tuner_i2c_props {
-       u8 addr;
-       struct i2c_adapter *adap;
-
-       /* used for tuner instance management */
-       int count;
-       char *name;
-};
-
-static inline int tuner_i2c_xfer_send(struct tuner_i2c_props *props, char *buf, int len)
-{
-       struct i2c_msg msg = { .addr = props->addr, .flags = 0,
-                              .buf = buf, .len = len };
-       int ret = i2c_transfer(props->adap, &msg, 1);
-
-       return (ret == 1) ? len : ret;
-}
-
-static inline int tuner_i2c_xfer_recv(struct tuner_i2c_props *props, char *buf, int len)
-{
-       struct i2c_msg msg = { .addr = props->addr, .flags = I2C_M_RD,
-                              .buf = buf, .len = len };
-       int ret = i2c_transfer(props->adap, &msg, 1);
-
-       return (ret == 1) ? len : ret;
-}
-
-static inline int tuner_i2c_xfer_send_recv(struct tuner_i2c_props *props,
-                                          char *obuf, int olen,
-                                          char *ibuf, int ilen)
-{
-       struct i2c_msg msg[2] = { { .addr = props->addr, .flags = 0,
-                                   .buf = obuf, .len = olen },
-                                 { .addr = props->addr, .flags = I2C_M_RD,
-                                   .buf = ibuf, .len = ilen } };
-       int ret = i2c_transfer(props->adap, msg, 2);
-
-       return (ret == 2) ? ilen : ret;
-}
-
-/* Callers must declare as a global for the module:
- *
- * static LIST_HEAD(hybrid_tuner_instance_list);
- *
- * hybrid_tuner_instance_list should be the third argument
- * passed into hybrid_tuner_request_state().
- *
- * state structure must contain the following:
- *
- *     struct list_head        hybrid_tuner_instance_list;
- *     struct tuner_i2c_props  i2c_props;
- *
- * hybrid_tuner_instance_list (both within state structure and globally)
- * is only required if the driver is using hybrid_tuner_request_state
- * and hybrid_tuner_release_state to manage state sharing between
- * multiple instances of hybrid tuners.
- */
-
-#define tuner_printk(kernlvl, i2cprops, fmt, arg...) do {              \
-       printk(kernlvl "%s %d-%04x: " fmt, i2cprops.name,               \
-                       i2cprops.adap ?                                 \
-                               i2c_adapter_id(i2cprops.adap) : -1,     \
-                       i2cprops.addr, ##arg);                          \
-        } while (0)
-
-/* TO DO: convert all callers of these macros to pass in
- * struct tuner_i2c_props, then remove the macro wrappers */
-
-#define __tuner_warn(i2cprops, fmt, arg...) do {                       \
-       tuner_printk(KERN_WARNING, i2cprops, fmt, ##arg);               \
-       } while (0)
-
-#define __tuner_info(i2cprops, fmt, arg...) do {                       \
-       tuner_printk(KERN_INFO, i2cprops, fmt, ##arg);                  \
-       } while (0)
-
-#define __tuner_err(i2cprops, fmt, arg...) do {                                \
-       tuner_printk(KERN_ERR, i2cprops, fmt, ##arg);                   \
-       } while (0)
-
-#define __tuner_dbg(i2cprops, fmt, arg...) do {                                \
-       if ((debug))                                                    \
-               tuner_printk(KERN_DEBUG, i2cprops, fmt, ##arg);         \
-       } while (0)
-
-#define tuner_warn(fmt, arg...) __tuner_warn(priv->i2c_props, fmt, ##arg)
-#define tuner_info(fmt, arg...) __tuner_info(priv->i2c_props, fmt, ##arg)
-#define tuner_err(fmt, arg...) __tuner_err(priv->i2c_props, fmt, ##arg)
-#define tuner_dbg(fmt, arg...) __tuner_dbg(priv->i2c_props, fmt, ##arg)
-
-/****************************************************************************/
-
-/* The return value of hybrid_tuner_request_state indicates the number of
- * instances using this tuner object.
- *
- * 0 - no instances, indicates an error - kzalloc must have failed
- *
- * 1 - one instance, indicates that the tuner object was created successfully
- *
- * 2 (or more) instances, indicates that an existing tuner object was found
- */
-
-#define hybrid_tuner_request_state(type, state, list, i2cadap, i2caddr, devname)\
-({                                                                     \
-       int __ret = 0;                                                  \
-       list_for_each_entry(state, &list, hybrid_tuner_instance_list) { \
-               if (((i2cadap) && (state->i2c_props.adap)) &&           \
-                   ((i2c_adapter_id(state->i2c_props.adap) ==          \
-                     i2c_adapter_id(i2cadap)) &&                       \
-                    (i2caddr == state->i2c_props.addr))) {             \
-                       __tuner_info(state->i2c_props,                  \
-                                    "attaching existing instance\n");  \
-                       state->i2c_props.count++;                       \
-                       __ret = state->i2c_props.count;                 \
-                       break;                                          \
-               }                                                       \
-       }                                                               \
-       if (0 == __ret) {                                               \
-               state = kzalloc(sizeof(type), GFP_KERNEL);              \
-               if (NULL == state)                                      \
-                       goto __fail;                                    \
-               state->i2c_props.addr = i2caddr;                        \
-               state->i2c_props.adap = i2cadap;                        \
-               state->i2c_props.name = devname;                        \
-               __tuner_info(state->i2c_props,                          \
-                            "creating new instance\n");                \
-               list_add_tail(&state->hybrid_tuner_instance_list, &list);\
-               state->i2c_props.count++;                               \
-               __ret = state->i2c_props.count;                         \
-       }                                                               \
-__fail:                                                                        \
-       __ret;                                                          \
-})
-
-#define hybrid_tuner_release_state(state)                              \
-({                                                                     \
-       int __ret;                                                      \
-       state->i2c_props.count--;                                       \
-       __ret = state->i2c_props.count;                                 \
-       if (!state->i2c_props.count) {                                  \
-               __tuner_info(state->i2c_props, "destroying instance\n");\
-               list_del(&state->hybrid_tuner_instance_list);           \
-               kfree(state);                                           \
-       }                                                               \
-       __ret;                                                          \
-})
-
-#endif /* __TUNER_I2C_H__ */
diff --git a/drivers/media/video/tuner-simple.c b/drivers/media/video/tuner-simple.c
deleted file mode 100644 (file)
index be8d903..0000000
+++ /dev/null
@@ -1,1093 +0,0 @@
-/*
- * i2c tv tuner chip device driver
- * controls all those simple 4-control-bytes style tuners.
- *
- * This "tuner-simple" module was split apart from the original "tuner" module.
- */
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/videodev.h>
-#include <media/tuner.h>
-#include <media/v4l2-common.h>
-#include <media/tuner-types.h>
-#include "tuner-i2c.h"
-#include "tuner-simple.h"
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-#define TUNER_SIMPLE_MAX 64
-static unsigned int simple_devcount;
-
-static int offset;
-module_param(offset, int, 0664);
-MODULE_PARM_DESC(offset, "Allows to specify an offset for tuner");
-
-static unsigned int atv_input[TUNER_SIMPLE_MAX] = \
-                       { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
-static unsigned int dtv_input[TUNER_SIMPLE_MAX] = \
-                       { [0 ... (TUNER_SIMPLE_MAX-1)] = 0 };
-module_param_array(atv_input, int, NULL, 0644);
-module_param_array(dtv_input, int, NULL, 0644);
-MODULE_PARM_DESC(atv_input, "specify atv rf input, 0 for autoselect");
-MODULE_PARM_DESC(dtv_input, "specify dtv rf input, 0 for autoselect");
-
-/* ---------------------------------------------------------------------- */
-
-/* tv standard selection for Temic 4046 FM5
-   this value takes the low bits of control byte 2
-   from datasheet Rev.01, Feb.00
-     standard     BG      I       L       L2      D
-     picture IF   38.9    38.9    38.9    33.95   38.9
-     sound 1      33.4    32.9    32.4    40.45   32.4
-     sound 2      33.16
-     NICAM        33.05   32.348  33.05           33.05
- */
-#define TEMIC_SET_PAL_I         0x05
-#define TEMIC_SET_PAL_DK        0x09
-#define TEMIC_SET_PAL_L         0x0a /* SECAM ? */
-#define TEMIC_SET_PAL_L2        0x0b /* change IF ! */
-#define TEMIC_SET_PAL_BG        0x0c
-
-/* tv tuner system standard selection for Philips FQ1216ME
-   this value takes the low bits of control byte 2
-   from datasheet "1999 Nov 16" (supersedes "1999 Mar 23")
-     standard          BG      DK      I       L       L`
-     picture carrier   38.90   38.90   38.90   38.90   33.95
-     colour            34.47   34.47   34.47   34.47   38.38
-     sound 1           33.40   32.40   32.90   32.40   40.45
-     sound 2           33.16   -       -       -       -
-     NICAM             33.05   33.05   32.35   33.05   39.80
- */
-#define PHILIPS_SET_PAL_I      0x01 /* Bit 2 always zero !*/
-#define PHILIPS_SET_PAL_BGDK   0x09
-#define PHILIPS_SET_PAL_L2     0x0a
-#define PHILIPS_SET_PAL_L      0x0b
-
-/* system switching for Philips FI1216MF MK2
-   from datasheet "1996 Jul 09",
-    standard         BG     L      L'
-    picture carrier  38.90  38.90  33.95
-    colour          34.47  34.37  38.38
-    sound 1          33.40  32.40  40.45
-    sound 2          33.16  -      -
-    NICAM            33.05  33.05  39.80
- */
-#define PHILIPS_MF_SET_STD_BG  0x01 /* Bit 2 must be zero, Bit 3 is system output */
-#define PHILIPS_MF_SET_STD_L   0x03 /* Used on Secam France */
-#define PHILIPS_MF_SET_STD_LC  0x02 /* Used on SECAM L' */
-
-/* Control byte */
-
-#define TUNER_RATIO_MASK        0x06 /* Bit cb1:cb2 */
-#define TUNER_RATIO_SELECT_50   0x00
-#define TUNER_RATIO_SELECT_32   0x02
-#define TUNER_RATIO_SELECT_166  0x04
-#define TUNER_RATIO_SELECT_62   0x06
-
-#define TUNER_CHARGE_PUMP       0x40  /* Bit cb6 */
-
-/* Status byte */
-
-#define TUNER_POR        0x80
-#define TUNER_FL          0x40
-#define TUNER_MODE        0x38
-#define TUNER_AFC         0x07
-#define TUNER_SIGNAL      0x07
-#define TUNER_STEREO      0x10
-
-#define TUNER_PLL_LOCKED   0x40
-#define TUNER_STEREO_MK3   0x04
-
-static DEFINE_MUTEX(tuner_simple_list_mutex);
-static LIST_HEAD(hybrid_tuner_instance_list);
-
-struct tuner_simple_priv {
-       unsigned int nr;
-       u16 last_div;
-
-       struct tuner_i2c_props i2c_props;
-       struct list_head hybrid_tuner_instance_list;
-
-       unsigned int type;
-       struct tunertype *tun;
-
-       u32 frequency;
-       u32 bandwidth;
-};
-
-/* ---------------------------------------------------------------------- */
-
-static int tuner_read_status(struct dvb_frontend *fe)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       unsigned char byte;
-
-       if (1 != tuner_i2c_xfer_recv(&priv->i2c_props, &byte, 1))
-               return 0;
-
-       return byte;
-}
-
-static inline int tuner_signal(const int status)
-{
-       return (status & TUNER_SIGNAL) << 13;
-}
-
-static inline int tuner_stereo(const int type, const int status)
-{
-       switch (type) {
-       case TUNER_PHILIPS_FM1216ME_MK3:
-       case TUNER_PHILIPS_FM1236_MK3:
-       case TUNER_PHILIPS_FM1256_IH3:
-       case TUNER_LG_NTSC_TAPE:
-               return ((status & TUNER_SIGNAL) == TUNER_STEREO_MK3);
-       default:
-               return status & TUNER_STEREO;
-       }
-}
-
-static inline int tuner_islocked(const int status)
-{
-       return (status & TUNER_FL);
-}
-
-static inline int tuner_afcstatus(const int status)
-{
-       return (status & TUNER_AFC) - 2;
-}
-
-
-static int simple_get_status(struct dvb_frontend *fe, u32 *status)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       int tuner_status;
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       tuner_status = tuner_read_status(fe);
-
-       *status = 0;
-
-       if (tuner_islocked(tuner_status))
-               *status = TUNER_STATUS_LOCKED;
-       if (tuner_stereo(priv->type, tuner_status))
-               *status |= TUNER_STATUS_STEREO;
-
-       tuner_dbg("AFC Status: %d\n", tuner_afcstatus(tuner_status));
-
-       return 0;
-}
-
-static int simple_get_rf_strength(struct dvb_frontend *fe, u16 *strength)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       int signal;
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       signal = tuner_signal(tuner_read_status(fe));
-
-       *strength = signal;
-
-       tuner_dbg("Signal strength: %d\n", signal);
-
-       return 0;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static inline char *tuner_param_name(enum param_type type)
-{
-       char *name;
-
-       switch (type) {
-       case TUNER_PARAM_TYPE_RADIO:
-               name = "radio";
-               break;
-       case TUNER_PARAM_TYPE_PAL:
-               name = "pal";
-               break;
-       case TUNER_PARAM_TYPE_SECAM:
-               name = "secam";
-               break;
-       case TUNER_PARAM_TYPE_NTSC:
-               name = "ntsc";
-               break;
-       case TUNER_PARAM_TYPE_DIGITAL:
-               name = "digital";
-               break;
-       default:
-               name = "unknown";
-               break;
-       }
-       return name;
-}
-
-static struct tuner_params *simple_tuner_params(struct dvb_frontend *fe,
-                                               enum param_type desired_type)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       struct tunertype *tun = priv->tun;
-       int i;
-
-       for (i = 0; i < tun->count; i++)
-               if (desired_type == tun->params[i].type)
-                       break;
-
-       /* use default tuner params if desired_type not available */
-       if (i == tun->count) {
-               tuner_dbg("desired params (%s) undefined for tuner %d\n",
-                         tuner_param_name(desired_type), priv->type);
-               i = 0;
-       }
-
-       tuner_dbg("using tuner params #%d (%s)\n", i,
-                 tuner_param_name(tun->params[i].type));
-
-       return &tun->params[i];
-}
-
-static int simple_config_lookup(struct dvb_frontend *fe,
-                               struct tuner_params *t_params,
-                               int *frequency, u8 *config, u8 *cb)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       int i;
-
-       for (i = 0; i < t_params->count; i++) {
-               if (*frequency > t_params->ranges[i].limit)
-                       continue;
-               break;
-       }
-       if (i == t_params->count) {
-               tuner_dbg("frequency out of range (%d > %d)\n",
-                         *frequency, t_params->ranges[i - 1].limit);
-               *frequency = t_params->ranges[--i].limit;
-       }
-       *config = t_params->ranges[i].config;
-       *cb     = t_params->ranges[i].cb;
-
-       tuner_dbg("freq = %d.%02d (%d), range = %d, "
-                 "config = 0x%02x, cb = 0x%02x\n",
-                 *frequency / 16, *frequency % 16 * 100 / 16, *frequency,
-                 i, *config, *cb);
-
-       return i;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static void simple_set_rf_input(struct dvb_frontend *fe,
-                               u8 *config, u8 *cb, unsigned int rf)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       switch (priv->type) {
-       case TUNER_PHILIPS_TUV1236D:
-               switch (rf) {
-               case 1:
-                       *cb |= 0x08;
-                       break;
-               default:
-                       *cb &= ~0x08;
-                       break;
-               }
-               break;
-       case TUNER_PHILIPS_FCV1236D:
-               switch (rf) {
-               case 1:
-                       *cb |= 0x01;
-                       break;
-               default:
-                       *cb &= ~0x01;
-                       break;
-               }
-               break;
-       default:
-               break;
-       }
-}
-
-static int simple_std_setup(struct dvb_frontend *fe,
-                           struct analog_parameters *params,
-                           u8 *config, u8 *cb)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       u8 tuneraddr;
-       int rc;
-
-       /* tv norm specific stuff for multi-norm tuners */
-       switch (priv->type) {
-       case TUNER_PHILIPS_SECAM: /* FI1216MF */
-               /* 0x01 -> ??? no change ??? */
-               /* 0x02 -> PAL BDGHI / SECAM L */
-               /* 0x04 -> ??? PAL others / SECAM others ??? */
-               *cb &= ~0x03;
-               if (params->std & V4L2_STD_SECAM_L)
-                       /* also valid for V4L2_STD_SECAM */
-                       *cb |= PHILIPS_MF_SET_STD_L;
-               else if (params->std & V4L2_STD_SECAM_LC)
-                       *cb |= PHILIPS_MF_SET_STD_LC;
-               else /* V4L2_STD_B|V4L2_STD_GH */
-                       *cb |= PHILIPS_MF_SET_STD_BG;
-               break;
-
-       case TUNER_TEMIC_4046FM5:
-               *cb &= ~0x0f;
-
-               if (params->std & V4L2_STD_PAL_BG) {
-                       *cb |= TEMIC_SET_PAL_BG;
-
-               } else if (params->std & V4L2_STD_PAL_I) {
-                       *cb |= TEMIC_SET_PAL_I;
-
-               } else if (params->std & V4L2_STD_PAL_DK) {
-                       *cb |= TEMIC_SET_PAL_DK;
-
-               } else if (params->std & V4L2_STD_SECAM_L) {
-                       *cb |= TEMIC_SET_PAL_L;
-
-               }
-               break;
-
-       case TUNER_PHILIPS_FQ1216ME:
-               *cb &= ~0x0f;
-
-               if (params->std & (V4L2_STD_PAL_BG|V4L2_STD_PAL_DK)) {
-                       *cb |= PHILIPS_SET_PAL_BGDK;
-
-               } else if (params->std & V4L2_STD_PAL_I) {
-                       *cb |= PHILIPS_SET_PAL_I;
-
-               } else if (params->std & V4L2_STD_SECAM_L) {
-                       *cb |= PHILIPS_SET_PAL_L;
-
-               }
-               break;
-
-       case TUNER_PHILIPS_FCV1236D:
-               /* 0x00 -> ATSC antenna input 1 */
-               /* 0x01 -> ATSC antenna input 2 */
-               /* 0x02 -> NTSC antenna input 1 */
-               /* 0x03 -> NTSC antenna input 2 */
-               *cb &= ~0x03;
-               if (!(params->std & V4L2_STD_ATSC))
-                       *cb |= 2;
-               break;
-
-       case TUNER_MICROTUNE_4042FI5:
-               /* Set the charge pump for fast tuning */
-               *config |= TUNER_CHARGE_PUMP;
-               break;
-
-       case TUNER_PHILIPS_TUV1236D:
-       {
-               /* 0x40 -> ATSC antenna input 1 */
-               /* 0x48 -> ATSC antenna input 2 */
-               /* 0x00 -> NTSC antenna input 1 */
-               /* 0x08 -> NTSC antenna input 2 */
-               u8 buffer[4] = { 0x14, 0x00, 0x17, 0x00};
-               *cb &= ~0x40;
-               if (params->std & V4L2_STD_ATSC) {
-                       *cb |= 0x40;
-                       buffer[1] = 0x04;
-               }
-               /* set to the correct mode (analog or digital) */
-               tuneraddr = priv->i2c_props.addr;
-               priv->i2c_props.addr = 0x0a;
-               rc = tuner_i2c_xfer_send(&priv->i2c_props, &buffer[0], 2);
-               if (2 != rc)
-                       tuner_warn("i2c i/o error: rc == %d "
-                                  "(should be 2)\n", rc);
-               rc = tuner_i2c_xfer_send(&priv->i2c_props, &buffer[2], 2);
-               if (2 != rc)
-                       tuner_warn("i2c i/o error: rc == %d "
-                                  "(should be 2)\n", rc);
-               priv->i2c_props.addr = tuneraddr;
-               break;
-       }
-       }
-       if (atv_input[priv->nr])
-               simple_set_rf_input(fe, config, cb, atv_input[priv->nr]);
-
-       return 0;
-}
-
-static int simple_post_tune(struct dvb_frontend *fe, u8 *buffer,
-                           u16 div, u8 config, u8 cb)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       int rc;
-
-       switch (priv->type) {
-       case TUNER_LG_TDVS_H06XF:
-               /* Set the Auxiliary Byte. */
-               buffer[0] = buffer[2];
-               buffer[0] &= ~0x20;
-               buffer[0] |= 0x18;
-               buffer[1] = 0x20;
-               tuner_dbg("tv 0x%02x 0x%02x\n", buffer[0], buffer[1]);
-
-               rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 2);
-               if (2 != rc)
-                       tuner_warn("i2c i/o error: rc == %d "
-                                  "(should be 2)\n", rc);
-               break;
-       case TUNER_MICROTUNE_4042FI5:
-       {
-               /* FIXME - this may also work for other tuners */
-               unsigned long timeout = jiffies + msecs_to_jiffies(1);
-               u8 status_byte = 0;
-
-               /* Wait until the PLL locks */
-               for (;;) {
-                       if (time_after(jiffies, timeout))
-                               return 0;
-                       rc = tuner_i2c_xfer_recv(&priv->i2c_props,
-                                                &status_byte, 1);
-                       if (1 != rc) {
-                               tuner_warn("i2c i/o read error: rc == %d "
-                                          "(should be 1)\n", rc);
-                               break;
-                       }
-                       if (status_byte & TUNER_PLL_LOCKED)
-                               break;
-                       udelay(10);
-               }
-
-               /* Set the charge pump for optimized phase noise figure */
-               config &= ~TUNER_CHARGE_PUMP;
-               buffer[0] = (div>>8) & 0x7f;
-               buffer[1] = div      & 0xff;
-               buffer[2] = config;
-               buffer[3] = cb;
-               tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
-                         buffer[0], buffer[1], buffer[2], buffer[3]);
-
-               rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
-               if (4 != rc)
-                       tuner_warn("i2c i/o error: rc == %d "
-                                  "(should be 4)\n", rc);
-               break;
-       }
-       }
-
-       return 0;
-}
-
-static int simple_radio_bandswitch(struct dvb_frontend *fe, u8 *buffer)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       switch (priv->type) {
-       case TUNER_TENA_9533_DI:
-       case TUNER_YMEC_TVF_5533MF:
-               tuner_dbg("This tuner doesn't have FM. "
-                         "Most cards have a TEA5767 for FM\n");
-               return 0;
-       case TUNER_PHILIPS_FM1216ME_MK3:
-       case TUNER_PHILIPS_FM1236_MK3:
-       case TUNER_PHILIPS_FMD1216ME_MK3:
-       case TUNER_LG_NTSC_TAPE:
-       case TUNER_PHILIPS_FM1256_IH3:
-               buffer[3] = 0x19;
-               break;
-       case TUNER_TNF_5335MF:
-               buffer[3] = 0x11;
-               break;
-       case TUNER_LG_PAL_FM:
-               buffer[3] = 0xa5;
-               break;
-       case TUNER_THOMSON_DTT761X:
-               buffer[3] = 0x39;
-               break;
-       case TUNER_MICROTUNE_4049FM5:
-       default:
-               buffer[3] = 0xa4;
-               break;
-       }
-
-       return 0;
-}
-
-/* ---------------------------------------------------------------------- */
-
-static int simple_set_tv_freq(struct dvb_frontend *fe,
-                             struct analog_parameters *params)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       u8 config, cb;
-       u16 div;
-       struct tunertype *tun;
-       u8 buffer[4];
-       int rc, IFPCoff, i;
-       enum param_type desired_type;
-       struct tuner_params *t_params;
-
-       tun = priv->tun;
-
-       /* IFPCoff = Video Intermediate Frequency - Vif:
-               940  =16*58.75  NTSC/J (Japan)
-               732  =16*45.75  M/N STD
-               704  =16*44     ATSC (at DVB code)
-               632  =16*39.50  I U.K.
-               622.4=16*38.90  B/G D/K I, L STD
-               592  =16*37.00  D China
-               590  =16.36.875 B Australia
-               543.2=16*33.95  L' STD
-               171.2=16*10.70  FM Radio (at set_radio_freq)
-       */
-
-       if (params->std == V4L2_STD_NTSC_M_JP) {
-               IFPCoff      = 940;
-               desired_type = TUNER_PARAM_TYPE_NTSC;
-       } else if ((params->std & V4L2_STD_MN) &&
-                 !(params->std & ~V4L2_STD_MN)) {
-               IFPCoff      = 732;
-               desired_type = TUNER_PARAM_TYPE_NTSC;
-       } else if (params->std == V4L2_STD_SECAM_LC) {
-               IFPCoff      = 543;
-               desired_type = TUNER_PARAM_TYPE_SECAM;
-       } else {
-               IFPCoff      = 623;
-               desired_type = TUNER_PARAM_TYPE_PAL;
-       }
-
-       t_params = simple_tuner_params(fe, desired_type);
-
-       i = simple_config_lookup(fe, t_params, &params->frequency,
-                                &config, &cb);
-
-       div = params->frequency + IFPCoff + offset;
-
-       tuner_dbg("Freq= %d.%02d MHz, V_IF=%d.%02d MHz, "
-                 "Offset=%d.%02d MHz, div=%0d\n",
-                 params->frequency / 16, params->frequency % 16 * 100 / 16,
-                 IFPCoff / 16, IFPCoff % 16 * 100 / 16,
-                 offset / 16, offset % 16 * 100 / 16, div);
-
-       /* tv norm specific stuff for multi-norm tuners */
-       simple_std_setup(fe, params, &config, &cb);
-
-       if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
-               buffer[0] = config;
-               buffer[1] = cb;
-               buffer[2] = (div>>8) & 0x7f;
-               buffer[3] = div      & 0xff;
-       } else {
-               buffer[0] = (div>>8) & 0x7f;
-               buffer[1] = div      & 0xff;
-               buffer[2] = config;
-               buffer[3] = cb;
-       }
-       priv->last_div = div;
-       if (t_params->has_tda9887) {
-               struct v4l2_priv_tun_config tda9887_cfg;
-               int config = 0;
-               int is_secam_l = (params->std & (V4L2_STD_SECAM_L |
-                                                V4L2_STD_SECAM_LC)) &&
-                       !(params->std & ~(V4L2_STD_SECAM_L |
-                                         V4L2_STD_SECAM_LC));
-
-               tda9887_cfg.tuner = TUNER_TDA9887;
-               tda9887_cfg.priv  = &config;
-
-               if (params->std == V4L2_STD_SECAM_LC) {
-                       if (t_params->port1_active ^ t_params->port1_invert_for_secam_lc)
-                               config |= TDA9887_PORT1_ACTIVE;
-                       if (t_params->port2_active ^ t_params->port2_invert_for_secam_lc)
-                               config |= TDA9887_PORT2_ACTIVE;
-               } else {
-                       if (t_params->port1_active)
-                               config |= TDA9887_PORT1_ACTIVE;
-                       if (t_params->port2_active)
-                               config |= TDA9887_PORT2_ACTIVE;
-               }
-               if (t_params->intercarrier_mode)
-                       config |= TDA9887_INTERCARRIER;
-               if (is_secam_l) {
-                       if (i == 0 && t_params->default_top_secam_low)
-                               config |= TDA9887_TOP(t_params->default_top_secam_low);
-                       else if (i == 1 && t_params->default_top_secam_mid)
-                               config |= TDA9887_TOP(t_params->default_top_secam_mid);
-                       else if (t_params->default_top_secam_high)
-                               config |= TDA9887_TOP(t_params->default_top_secam_high);
-               } else {
-                       if (i == 0 && t_params->default_top_low)
-                               config |= TDA9887_TOP(t_params->default_top_low);
-                       else if (i == 1 && t_params->default_top_mid)
-                               config |= TDA9887_TOP(t_params->default_top_mid);
-                       else if (t_params->default_top_high)
-                               config |= TDA9887_TOP(t_params->default_top_high);
-               }
-               if (t_params->default_pll_gating_18)
-                       config |= TDA9887_GATING_18;
-               i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
-                                   &tda9887_cfg);
-       }
-       tuner_dbg("tv 0x%02x 0x%02x 0x%02x 0x%02x\n",
-                 buffer[0], buffer[1], buffer[2], buffer[3]);
-
-       rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
-       if (4 != rc)
-               tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
-
-       simple_post_tune(fe, &buffer[0], div, config, cb);
-
-       return 0;
-}
-
-static int simple_set_radio_freq(struct dvb_frontend *fe,
-                                struct analog_parameters *params)
-{
-       struct tunertype *tun;
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       u8 buffer[4];
-       u16 div;
-       int rc, j;
-       struct tuner_params *t_params;
-       unsigned int freq = params->frequency;
-
-       tun = priv->tun;
-
-       for (j = tun->count-1; j > 0; j--)
-               if (tun->params[j].type == TUNER_PARAM_TYPE_RADIO)
-                       break;
-       /* default t_params (j=0) will be used if desired type wasn't found */
-       t_params = &tun->params[j];
-
-       /* Select Radio 1st IF used */
-       switch (t_params->radio_if) {
-       case 0: /* 10.7 MHz */
-               freq += (unsigned int)(10.7*16000);
-               break;
-       case 1: /* 33.3 MHz */
-               freq += (unsigned int)(33.3*16000);
-               break;
-       case 2: /* 41.3 MHz */
-               freq += (unsigned int)(41.3*16000);
-               break;
-       default:
-               tuner_warn("Unsupported radio_if value %d\n",
-                          t_params->radio_if);
-               return 0;
-       }
-
-       /* Bandswitch byte */
-       simple_radio_bandswitch(fe, &buffer[0]);
-
-       buffer[2] = (t_params->ranges[0].config & ~TUNER_RATIO_MASK) |
-                   TUNER_RATIO_SELECT_50; /* 50 kHz step */
-
-       /* Convert from 1/16 kHz V4L steps to 1/20 MHz (=50 kHz) PLL steps
-          freq * (1 Mhz / 16000 V4L steps) * (20 PLL steps / 1 MHz) =
-          freq * (1/800) */
-       div = (freq + 400) / 800;
-
-       if (t_params->cb_first_if_lower_freq && div < priv->last_div) {
-               buffer[0] = buffer[2];
-               buffer[1] = buffer[3];
-               buffer[2] = (div>>8) & 0x7f;
-               buffer[3] = div      & 0xff;
-       } else {
-               buffer[0] = (div>>8) & 0x7f;
-               buffer[1] = div      & 0xff;
-       }
-
-       tuner_dbg("radio 0x%02x 0x%02x 0x%02x 0x%02x\n",
-              buffer[0], buffer[1], buffer[2], buffer[3]);
-       priv->last_div = div;
-
-       if (t_params->has_tda9887) {
-               int config = 0;
-               struct v4l2_priv_tun_config tda9887_cfg;
-
-               tda9887_cfg.tuner = TUNER_TDA9887;
-               tda9887_cfg.priv = &config;
-
-               if (t_params->port1_active &&
-                   !t_params->port1_fm_high_sensitivity)
-                       config |= TDA9887_PORT1_ACTIVE;
-               if (t_params->port2_active &&
-                   !t_params->port2_fm_high_sensitivity)
-                       config |= TDA9887_PORT2_ACTIVE;
-               if (t_params->intercarrier_mode)
-                       config |= TDA9887_INTERCARRIER;
-/*             if (t_params->port1_set_for_fm_mono)
-                       config &= ~TDA9887_PORT1_ACTIVE;*/
-               if (t_params->fm_gain_normal)
-                       config |= TDA9887_GAIN_NORMAL;
-               if (t_params->radio_if == 2)
-                       config |= TDA9887_RIF_41_3;
-               i2c_clients_command(priv->i2c_props.adap, TUNER_SET_CONFIG,
-                                   &tda9887_cfg);
-       }
-       rc = tuner_i2c_xfer_send(&priv->i2c_props, buffer, 4);
-       if (4 != rc)
-               tuner_warn("i2c i/o error: rc == %d (should be 4)\n", rc);
-
-       return 0;
-}
-
-static int simple_set_params(struct dvb_frontend *fe,
-                            struct analog_parameters *params)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       int ret = -EINVAL;
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       switch (params->mode) {
-       case V4L2_TUNER_RADIO:
-               ret = simple_set_radio_freq(fe, params);
-               priv->frequency = params->frequency * 125 / 2;
-               break;
-       case V4L2_TUNER_ANALOG_TV:
-       case V4L2_TUNER_DIGITAL_TV:
-               ret = simple_set_tv_freq(fe, params);
-               priv->frequency = params->frequency * 62500;
-               break;
-       }
-       priv->bandwidth = 0;
-
-       return ret;
-}
-
-static void simple_set_dvb(struct dvb_frontend *fe, u8 *buf,
-                          const struct dvb_frontend_parameters *params)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       switch (priv->type) {
-       case TUNER_PHILIPS_FMD1216ME_MK3:
-               if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ &&
-                   params->frequency >= 158870000)
-                       buf[3] |= 0x08;
-               break;
-       case TUNER_PHILIPS_TD1316:
-               /* determine band */
-               buf[3] |= (params->frequency < 161000000) ? 1 :
-                         (params->frequency < 444000000) ? 2 : 4;
-
-               /* setup PLL filter */
-               if (params->u.ofdm.bandwidth == BANDWIDTH_8_MHZ)
-                       buf[3] |= 1 << 3;
-               break;
-       case TUNER_PHILIPS_TUV1236D:
-       case TUNER_PHILIPS_FCV1236D:
-       {
-               unsigned int new_rf;
-
-               if (dtv_input[priv->nr])
-                       new_rf = dtv_input[priv->nr];
-               else
-                       switch (params->u.vsb.modulation) {
-                       case QAM_64:
-                       case QAM_256:
-                               new_rf = 1;
-                               break;
-                       case VSB_8:
-                       default:
-                               new_rf = 0;
-                               break;
-                       }
-               simple_set_rf_input(fe, &buf[2], &buf[3], new_rf);
-               break;
-       }
-       default:
-               break;
-       }
-}
-
-static u32 simple_dvb_configure(struct dvb_frontend *fe, u8 *buf,
-                               const struct dvb_frontend_parameters *params)
-{
-       /* This function returns the tuned frequency on success, 0 on error */
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       struct tunertype *tun = priv->tun;
-       static struct tuner_params *t_params;
-       u8 config, cb;
-       u32 div;
-       int ret, frequency = params->frequency / 62500;
-
-       t_params = simple_tuner_params(fe, TUNER_PARAM_TYPE_DIGITAL);
-       ret = simple_config_lookup(fe, t_params, &frequency, &config, &cb);
-       if (ret < 0)
-               return 0; /* failure */
-
-       div = ((frequency + t_params->iffreq) * 62500 + offset +
-              tun->stepsize/2) / tun->stepsize;
-
-       buf[0] = div >> 8;
-       buf[1] = div & 0xff;
-       buf[2] = config;
-       buf[3] = cb;
-
-       simple_set_dvb(fe, buf, params);
-
-       tuner_dbg("%s: div=%d | buf=0x%02x,0x%02x,0x%02x,0x%02x\n",
-                 tun->name, div, buf[0], buf[1], buf[2], buf[3]);
-
-       /* calculate the frequency we set it to */
-       return (div * tun->stepsize) - t_params->iffreq;
-}
-
-static int simple_dvb_calc_regs(struct dvb_frontend *fe,
-                               struct dvb_frontend_parameters *params,
-                               u8 *buf, int buf_len)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       u32 frequency;
-
-       if (buf_len < 5)
-               return -EINVAL;
-
-       frequency = simple_dvb_configure(fe, buf+1, params);
-       if (frequency == 0)
-               return -EINVAL;
-
-       buf[0] = priv->i2c_props.addr;
-
-       priv->frequency = frequency;
-       priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
-               params->u.ofdm.bandwidth : 0;
-
-       return 5;
-}
-
-static int simple_dvb_set_params(struct dvb_frontend *fe,
-                                struct dvb_frontend_parameters *params)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       u32 prev_freq, prev_bw;
-       int ret;
-       u8 buf[5];
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       prev_freq = priv->frequency;
-       prev_bw   = priv->bandwidth;
-
-       ret = simple_dvb_calc_regs(fe, params, buf, 5);
-       if (ret != 5)
-               goto fail;
-
-       /* put analog demod in standby when tuning digital */
-       if (fe->ops.analog_ops.standby)
-               fe->ops.analog_ops.standby(fe);
-
-       if (fe->ops.i2c_gate_ctrl)
-               fe->ops.i2c_gate_ctrl(fe, 1);
-
-       /* buf[0] contains the i2c address, but *
-        * we already have it in i2c_props.addr */
-       ret = tuner_i2c_xfer_send(&priv->i2c_props, buf+1, 4);
-       if (ret != 4)
-               goto fail;
-
-       return 0;
-fail:
-       /* calc_regs sets frequency and bandwidth. if we failed, unset them */
-       priv->frequency = prev_freq;
-       priv->bandwidth = prev_bw;
-
-       return ret;
-}
-
-static int simple_init(struct dvb_frontend *fe)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       if (priv->tun->initdata) {
-               int ret;
-
-               if (fe->ops.i2c_gate_ctrl)
-                       fe->ops.i2c_gate_ctrl(fe, 1);
-
-               ret = tuner_i2c_xfer_send(&priv->i2c_props,
-                                         priv->tun->initdata + 1,
-                                         priv->tun->initdata[0]);
-               if (ret != priv->tun->initdata[0])
-                       return ret;
-       }
-
-       return 0;
-}
-
-static int simple_sleep(struct dvb_frontend *fe)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       if (priv->i2c_props.adap == NULL)
-               return -EINVAL;
-
-       if (priv->tun->sleepdata) {
-               int ret;
-
-               if (fe->ops.i2c_gate_ctrl)
-                       fe->ops.i2c_gate_ctrl(fe, 1);
-
-               ret = tuner_i2c_xfer_send(&priv->i2c_props,
-                                         priv->tun->sleepdata + 1,
-                                         priv->tun->sleepdata[0]);
-               if (ret != priv->tun->sleepdata[0])
-                       return ret;
-       }
-
-       return 0;
-}
-
-static int simple_release(struct dvb_frontend *fe)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-
-       mutex_lock(&tuner_simple_list_mutex);
-
-       if (priv)
-               hybrid_tuner_release_state(priv);
-
-       mutex_unlock(&tuner_simple_list_mutex);
-
-       fe->tuner_priv = NULL;
-
-       return 0;
-}
-
-static int simple_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       *frequency = priv->frequency;
-       return 0;
-}
-
-static int simple_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
-{
-       struct tuner_simple_priv *priv = fe->tuner_priv;
-       *bandwidth = priv->bandwidth;
-       return 0;
-}
-
-static struct dvb_tuner_ops simple_tuner_ops = {
-       .init              = simple_init,
-       .sleep             = simple_sleep,
-       .set_analog_params = simple_set_params,
-       .set_params        = simple_dvb_set_params,
-       .calc_regs         = simple_dvb_calc_regs,
-       .release           = simple_release,
-       .get_frequency     = simple_get_frequency,
-       .get_bandwidth     = simple_get_bandwidth,
-       .get_status        = simple_get_status,
-       .get_rf_strength   = simple_get_rf_strength,
-};
-
-struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
-                                        struct i2c_adapter *i2c_adap,
-                                        u8 i2c_addr,
-                                        unsigned int type)
-{
-       struct tuner_simple_priv *priv = NULL;
-       int instance;
-
-       if (type >= tuner_count) {
-               printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n",
-                      __func__, type, tuner_count-1);
-               return NULL;
-       }
-
-       /* If i2c_adap is set, check that the tuner is at the correct address.
-        * Otherwise, if i2c_adap is NULL, the tuner will be programmed directly
-        * by the digital demod via calc_regs.
-        */
-       if (i2c_adap != NULL) {
-               u8 b[1];
-               struct i2c_msg msg = {
-                       .addr = i2c_addr, .flags = I2C_M_RD,
-                       .buf = b, .len = 1,
-               };
-
-               if (fe->ops.i2c_gate_ctrl)
-                       fe->ops.i2c_gate_ctrl(fe, 1);
-
-               if (1 != i2c_transfer(i2c_adap, &msg, 1))
-                       tuner_warn("unable to probe %s, proceeding anyway.",
-                                  tuners[type].name);
-
-               if (fe->ops.i2c_gate_ctrl)
-                       fe->ops.i2c_gate_ctrl(fe, 0);
-       }
-
-       mutex_lock(&tuner_simple_list_mutex);
-
-       instance = hybrid_tuner_request_state(struct tuner_simple_priv, priv,
-                                             hybrid_tuner_instance_list,
-                                             i2c_adap, i2c_addr,
-                                             "tuner-simple");
-       switch (instance) {
-       case 0:
-               mutex_unlock(&tuner_simple_list_mutex);
-               return NULL;
-               break;
-       case 1:
-               fe->tuner_priv = priv;
-
-               priv->type = type;
-               priv->tun  = &tuners[type];
-               priv->nr   = simple_devcount++;
-               break;
-       default:
-               fe->tuner_priv = priv;
-               break;
-       }
-
-       mutex_unlock(&tuner_simple_list_mutex);
-
-       memcpy(&fe->ops.tuner_ops, &simple_tuner_ops,
-              sizeof(struct dvb_tuner_ops));
-
-       tuner_info("type set to %d (%s)\n", type, priv->tun->name);
-
-       if ((debug) || ((atv_input[priv->nr] > 0) ||
-                       (dtv_input[priv->nr] > 0))) {
-               if (0 == atv_input[priv->nr])
-                       tuner_info("tuner %d atv rf input will be "
-                                  "autoselected\n", priv->nr);
-               else
-                       tuner_info("tuner %d atv rf input will be "
-                                  "set to input %d (insmod option)\n",
-                                  priv->nr, atv_input[priv->nr]);
-               if (0 == dtv_input[priv->nr])
-                       tuner_info("tuner %d dtv rf input will be "
-                                  "autoselected\n", priv->nr);
-               else
-                       tuner_info("tuner %d dtv rf input will be "
-                                  "set to input %d (insmod option)\n",
-                                  priv->nr, dtv_input[priv->nr]);
-       }
-
-       strlcpy(fe->ops.tuner_ops.info.name, priv->tun->name,
-               sizeof(fe->ops.tuner_ops.info.name));
-
-       return fe;
-}
-EXPORT_SYMBOL_GPL(simple_tuner_attach);
-
-MODULE_DESCRIPTION("Simple 4-control-bytes style tuner driver");
-MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
-MODULE_LICENSE("GPL");
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-basic-offset: 8
- * End:
- */
diff --git a/drivers/media/video/tuner-simple.h b/drivers/media/video/tuner-simple.h
deleted file mode 100644 (file)
index e46cf01..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*/
-
-#ifndef __TUNER_SIMPLE_H__
-#define __TUNER_SIMPLE_H__
-
-#include <linux/i2c.h>
-#include "dvb_frontend.h"
-
-#if defined(CONFIG_TUNER_SIMPLE) || (defined(CONFIG_TUNER_SIMPLE_MODULE) && defined(MODULE))
-extern struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
-                                               struct i2c_adapter *i2c_adap,
-                                               u8 i2c_addr,
-                                               unsigned int type);
-#else
-static inline struct dvb_frontend *simple_tuner_attach(struct dvb_frontend *fe,
-                                                      struct i2c_adapter *i2c_adap,
-                                                      u8 i2c_addr,
-                                                      unsigned int type)
-{
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TUNER_SIMPLE_H__ */
diff --git a/drivers/media/video/tuner-types.c b/drivers/media/video/tuner-types.c
deleted file mode 100644 (file)
index 10dddca..0000000
+++ /dev/null
@@ -1,1652 +0,0 @@
-/*
- *
- * i2c tv tuner chip device type database.
- *
- */
-
-#include <linux/i2c.h>
-#include <media/tuner.h>
-#include <media/tuner-types.h>
-
-/* ---------------------------------------------------------------------- */
-
-/*
- *     The floats in the tuner struct are computed at compile time
- *     by gcc and cast back to integers. Thus we don't violate the
- *     "no float in kernel" rule.
- *
- *     A tuner_range may be referenced by multiple tuner_params structs.
- *     There are many duplicates in here. Reusing tuner_range structs,
- *     rather than defining new ones for each tuner, will cut down on
- *     memory usage, and is preferred when possible.
- *
- *     Each tuner_params array may contain one or more elements, one
- *     for each video standard.
- *
- *     FIXME: tuner_params struct contains an element, tda988x. We must
- *     set this for all tuners that contain a tda988x chip, and then we
- *     can remove this setting from the various card structs.
- *
- *     FIXME: Right now, all tuners are using the first tuner_params[]
- *     array element for analog mode. In the future, we will be merging
- *     similar tuner definitions together, such that each tuner definition
- *     will have a tuner_params struct for each available video standard.
- *     At that point, the tuner_params[] array element will be chosen
- *     based on the video standard in use.
- */
-
-/* The following was taken from dvb-pll.c: */
-
-/* Set AGC TOP value to 103 dBuV:
- *     0x80 = Control Byte
- *     0x40 = 250 uA charge pump (irrelevant)
- *     0x18 = Aux Byte to follow
- *     0x06 = 64.5 kHz divider (irrelevant)
- *     0x01 = Disable Vt (aka sleep)
- *
- *     0x00 = AGC Time constant 2s Iagc = 300 nA (vs 0x80 = 9 nA)
- *     0x50 = AGC Take over point = 103 dBuV
- */
-static u8 tua603x_agc103[] = { 2, 0x80|0x40|0x18|0x06|0x01, 0x00|0x50 };
-
-/*     0x04 = 166.67 kHz divider
- *
- *     0x80 = AGC Time constant 50ms Iagc = 9 uA
- *     0x20 = AGC Take over point = 112 dBuV
- */
-static u8 tua603x_agc112[] = { 2, 0x80|0x40|0x18|0x04|0x01, 0x80|0x20 };
-
-/* 0-9 */
-/* ------------ TUNER_TEMIC_PAL - TEMIC PAL ------------ */
-
-static struct tuner_range tuner_temic_pal_ranges[] = {
-       { 16 * 140.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0x04, },
-       { 16 * 999.99        , 0x8e, 0x01, },
-};
-
-static struct tuner_params tuner_temic_pal_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_PAL_I - Philips PAL_I ------------ */
-
-static struct tuner_range tuner_philips_pal_i_ranges[] = {
-       { 16 * 140.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_philips_pal_i_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_pal_i_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_pal_i_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_NTSC - Philips NTSC ------------ */
-
-static struct tuner_range tuner_philips_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 451.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_philips_ntsc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_philips_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_ntsc_ranges),
-               .cb_first_if_lower_freq = 1,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_SECAM - Philips SECAM ------------ */
-
-static struct tuner_range tuner_philips_secam_ranges[] = {
-       { 16 * 168.25 /*MHz*/, 0x8e, 0xa7, },
-       { 16 * 447.25 /*MHz*/, 0x8e, 0x97, },
-       { 16 * 999.99        , 0x8e, 0x37, },
-};
-
-static struct tuner_params tuner_philips_secam_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_SECAM,
-               .ranges = tuner_philips_secam_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_secam_ranges),
-               .cb_first_if_lower_freq = 1,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_PAL - Philips PAL ------------ */
-
-static struct tuner_range tuner_philips_pal_ranges[] = {
-       { 16 * 168.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 447.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_philips_pal_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_pal_ranges),
-               .cb_first_if_lower_freq = 1,
-       },
-};
-
-/* ------------ TUNER_TEMIC_NTSC - TEMIC NTSC ------------ */
-
-static struct tuner_range tuner_temic_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0x04, },
-       { 16 * 999.99        , 0x8e, 0x01, },
-};
-
-static struct tuner_params tuner_temic_ntsc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_temic_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_PAL_I - TEMIC PAL_I ------------ */
-
-static struct tuner_range tuner_temic_pal_i_ranges[] = {
-       { 16 * 170.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 450.00 /*MHz*/, 0x8e, 0x04, },
-       { 16 * 999.99        , 0x8e, 0x01, },
-};
-
-static struct tuner_params tuner_temic_pal_i_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_pal_i_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_pal_i_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4036FY5_NTSC - TEMIC NTSC ------------ */
-
-static struct tuner_range tuner_temic_4036fy5_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_4036fy5_ntsc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_temic_4036fy5_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4036fy5_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_ALPS_TSBH1_NTSC - TEMIC NTSC ------------ */
-
-static struct tuner_range tuner_alps_tsb_1_ranges[] = {
-       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 385.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_alps_tsbh1_ntsc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_alps_tsb_1_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_1_ranges),
-       },
-};
-
-/* 10-19 */
-/* ------------ TUNER_ALPS_TSBE1_PAL - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_alps_tsb_1_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_alps_tsb_1_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_1_ranges),
-       },
-};
-
-/* ------------ TUNER_ALPS_TSBB5_PAL_I - Alps PAL_I ------------ */
-
-static struct tuner_range tuner_alps_tsb_5_pal_ranges[] = {
-       { 16 * 133.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 351.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_alps_tsbb5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_alps_tsb_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_ALPS_TSBE5_PAL - Alps PAL ------------ */
-
-static struct tuner_params tuner_alps_tsbe5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_alps_tsb_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_ALPS_TSBC5_PAL - Alps PAL ------------ */
-
-static struct tuner_params tuner_alps_tsbc5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_alps_tsb_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4006FH5_PAL - TEMIC PAL ------------ */
-
-static struct tuner_range tuner_lg_pal_ranges[] = {
-       { 16 * 170.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 450.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_4006fh5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_ALPS_TSHC6_NTSC - Alps NTSC ------------ */
-
-static struct tuner_range tuner_alps_tshc6_ntsc_ranges[] = {
-       { 16 * 137.25 /*MHz*/, 0x8e, 0x14, },
-       { 16 * 385.25 /*MHz*/, 0x8e, 0x12, },
-       { 16 * 999.99        , 0x8e, 0x11, },
-};
-
-static struct tuner_params tuner_alps_tshc6_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_alps_tshc6_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_alps_tshc6_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_PAL_DK - TEMIC PAL ------------ */
-
-static struct tuner_range tuner_temic_pal_dk_ranges[] = {
-       { 16 * 168.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 456.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_pal_dk_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_pal_dk_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_pal_dk_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_NTSC_M - Philips NTSC ------------ */
-
-static struct tuner_range tuner_philips_ntsc_m_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 454.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_philips_ntsc_m_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_philips_ntsc_m_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4066FY5_PAL_I - TEMIC PAL_I ------------ */
-
-static struct tuner_range tuner_temic_40x6f_5_pal_ranges[] = {
-       { 16 * 169.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 454.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_4066fy5_pal_i_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_40x6f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4006FN5_MULTI_PAL - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_temic_4006fn5_multi_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_40x6f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
-       },
-};
-
-/* 20-29 */
-/* ------------ TUNER_TEMIC_4009FR5_PAL - TEMIC PAL ------------ */
-
-static struct tuner_range tuner_temic_4009f_5_pal_ranges[] = {
-       { 16 * 141.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 464.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_4009f_5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_4009f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4039FR5_NTSC - TEMIC NTSC ------------ */
-
-static struct tuner_range tuner_temic_4x3x_f_5_ntsc_ranges[] = {
-       { 16 * 158.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 453.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_temic_4039fr5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_temic_4x3x_f_5_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4x3x_f_5_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4046FM5 - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_temic_4046fm5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_40x6f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_40x6f_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_PAL_DK - Philips PAL ------------ */
-
-static struct tuner_params tuner_philips_pal_dk_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FQ1216ME - Philips PAL ------------ */
-
-static struct tuner_params tuner_philips_fq1216me_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_active = 1,
-               .port2_invert_for_secam_lc = 1,
-       },
-};
-
-/* ------------ TUNER_LG_PAL_I_FM - LGINNOTEK PAL_I ------------ */
-
-static struct tuner_params tuner_lg_pal_i_fm_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_PAL_I - LGINNOTEK PAL_I ------------ */
-
-static struct tuner_params tuner_lg_pal_i_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_NTSC_FM - LGINNOTEK NTSC ------------ */
-
-static struct tuner_range tuner_lg_ntsc_fm_ranges[] = {
-       { 16 * 210.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 497.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_lg_ntsc_fm_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_lg_ntsc_fm_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_ntsc_fm_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_PAL_FM - LGINNOTEK PAL ------------ */
-
-static struct tuner_params tuner_lg_pal_fm_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_PAL - LGINNOTEK PAL ------------ */
-
-static struct tuner_params tuner_lg_pal_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_pal_ranges),
-       },
-};
-
-/* 30-39 */
-/* ------------ TUNER_TEMIC_4009FN5_MULTI_PAL_FM - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_temic_4009_fn5_multi_pal_fm_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_4009f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_SHARP_2U5JF5540_NTSC - SHARP NTSC ------------ */
-
-static struct tuner_range tuner_sharp_2u5jf5540_ntsc_ranges[] = {
-       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 317.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_sharp_2u5jf5540_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_sharp_2u5jf5540_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_sharp_2u5jf5540_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_Samsung_PAL_TCPM9091PD27 - Samsung PAL ------------ */
-
-static struct tuner_range tuner_samsung_pal_tcpm9091pd27_ranges[] = {
-       { 16 * 169 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 464 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99     , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_samsung_pal_tcpm9091pd27_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_samsung_pal_tcpm9091pd27_ranges,
-               .count  = ARRAY_SIZE(tuner_samsung_pal_tcpm9091pd27_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4106FH5 - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_temic_4106fh5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_4009f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4012FY5 - TEMIC PAL ------------ */
-
-static struct tuner_params tuner_temic_4012fy5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_TEMIC_4136FY5 - TEMIC NTSC ------------ */
-
-static struct tuner_params tuner_temic_4136_fy5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_temic_4x3x_f_5_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4x3x_f_5_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_PAL_NEW_TAPC - LGINNOTEK PAL ------------ */
-
-static struct tuner_range tuner_lg_new_tapc_ranges[] = {
-       { 16 * 170.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 450.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_lg_pal_new_tapc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_new_tapc_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FM1216ME_MK3 - Philips PAL ------------ */
-
-static struct tuner_range tuner_fm1216me_mk3_pal_ranges[] = {
-       { 16 * 158.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 442.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x04, },
-};
-
-static struct tuner_params tuner_fm1216me_mk3_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_fm1216me_mk3_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_fm1216me_mk3_pal_ranges),
-               .cb_first_if_lower_freq = 1,
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_active = 1,
-               .port2_invert_for_secam_lc = 1,
-               .port1_fm_high_sensitivity = 1,
-               .default_top_mid = -2,
-               .default_top_secam_mid = -2,
-               .default_top_secam_high = -2,
-       },
-};
-
-/* ------------ TUNER_LG_NTSC_NEW_TAPC - LGINNOTEK NTSC ------------ */
-
-static struct tuner_params tuner_lg_ntsc_new_tapc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_lg_new_tapc_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
-       },
-};
-
-/* 40-49 */
-/* ------------ TUNER_HITACHI_NTSC - HITACHI NTSC ------------ */
-
-static struct tuner_params tuner_hitachi_ntsc_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_lg_new_tapc_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_new_tapc_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_PAL_MK - Philips PAL ------------ */
-
-static struct tuner_range tuner_philips_pal_mk_pal_ranges[] = {
-       { 16 * 140.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0xc2, },
-       { 16 * 999.99        , 0x8e, 0xcf, },
-};
-
-static struct tuner_params tuner_philips_pal_mk_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_pal_mk_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_pal_mk_pal_ranges),
-       },
-};
-
-/* ---- TUNER_PHILIPS_FCV1236D - Philips FCV1236D (ATSC/NTSC) ---- */
-
-static struct tuner_range tuner_philips_fcv1236d_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0x8e, 0xa2, },
-       { 16 * 451.25 /*MHz*/, 0x8e, 0x92, },
-       { 16 * 999.99        , 0x8e, 0x32, },
-};
-
-static struct tuner_range tuner_philips_fcv1236d_atsc_ranges[] = {
-       { 16 * 159.00 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 453.00 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_philips_fcv1236d_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_philips_fcv1236d_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_philips_fcv1236d_atsc_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_atsc_ranges),
-               .iffreq = 16 * 44.00,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FM1236_MK3 - Philips NTSC ------------ */
-
-static struct tuner_range tuner_fm1236_mk3_ntsc_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 442.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x04, },
-};
-
-static struct tuner_params tuner_fm1236_mk3_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_fm1236_mk3_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
-               .cb_first_if_lower_freq = 1,
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_active = 1,
-               .port1_fm_high_sensitivity = 1,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_4IN1 - Philips NTSC ------------ */
-
-static struct tuner_params tuner_philips_4in1_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_fm1236_mk3_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_MICROTUNE_4049FM5 - Microtune PAL ------------ */
-
-static struct tuner_params tuner_microtune_4049_fm5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_temic_4009f_5_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_temic_4009f_5_pal_ranges),
-               .has_tda9887 = 1,
-               .port1_invert_for_secam_lc = 1,
-               .default_pll_gating_18 = 1,
-               .fm_gain_normal=1,
-               .radio_if = 1, /* 33.3 MHz */
-       },
-};
-
-/* ------------ TUNER_PANASONIC_VP27 - Panasonic NTSC ------------ */
-
-static struct tuner_range tuner_panasonic_vp27_ntsc_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0xce, 0x01, },
-       { 16 * 454.00 /*MHz*/, 0xce, 0x02, },
-       { 16 * 999.99        , 0xce, 0x08, },
-};
-
-static struct tuner_params tuner_panasonic_vp27_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_panasonic_vp27_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_panasonic_vp27_ntsc_ranges),
-               .has_tda9887 = 1,
-               .intercarrier_mode = 1,
-               .default_top_low = -3,
-               .default_top_mid = -3,
-               .default_top_high = -3,
-       },
-};
-
-/* ------------ TUNER_TNF_8831BGFF - Philips PAL ------------ */
-
-static struct tuner_range tuner_tnf_8831bgff_pal_ranges[] = {
-       { 16 * 161.25 /*MHz*/, 0x8e, 0xa0, },
-       { 16 * 463.25 /*MHz*/, 0x8e, 0x90, },
-       { 16 * 999.99        , 0x8e, 0x30, },
-};
-
-static struct tuner_params tuner_tnf_8831bgff_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_tnf_8831bgff_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_tnf_8831bgff_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_MICROTUNE_4042FI5 - Microtune NTSC ------------ */
-
-static struct tuner_range tuner_microtune_4042fi5_ntsc_ranges[] = {
-       { 16 * 162.00 /*MHz*/, 0x8e, 0xa2, },
-       { 16 * 457.00 /*MHz*/, 0x8e, 0x94, },
-       { 16 * 999.99        , 0x8e, 0x31, },
-};
-
-static struct tuner_range tuner_microtune_4042fi5_atsc_ranges[] = {
-       { 16 * 162.00 /*MHz*/, 0x8e, 0xa1, },
-       { 16 * 457.00 /*MHz*/, 0x8e, 0x91, },
-       { 16 * 999.99        , 0x8e, 0x31, },
-};
-
-static struct tuner_params tuner_microtune_4042fi5_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_microtune_4042fi5_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_microtune_4042fi5_atsc_ranges,
-               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_atsc_ranges),
-               .iffreq = 16 * 44.00 /*MHz*/,
-       },
-};
-
-/* 50-59 */
-/* ------------ TUNER_TCL_2002N - TCL NTSC ------------ */
-
-static struct tuner_range tuner_tcl_2002n_ntsc_ranges[] = {
-       { 16 * 172.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 448.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_tcl_2002n_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_tcl_2002n_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tcl_2002n_ntsc_ranges),
-               .cb_first_if_lower_freq = 1,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FM1256_IH3 - Philips PAL ------------ */
-
-static struct tuner_params tuner_philips_fm1256_ih3_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_fm1236_mk3_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
-               .radio_if = 1, /* 33.3 MHz */
-       },
-};
-
-/* ------------ TUNER_THOMSON_DTT7610 - THOMSON ATSC ------------ */
-
-/* single range used for both ntsc and atsc */
-static struct tuner_range tuner_thomson_dtt7610_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0x8e, 0x39, },
-       { 16 * 454.00 /*MHz*/, 0x8e, 0x3a, },
-       { 16 * 999.99        , 0x8e, 0x3c, },
-};
-
-static struct tuner_params tuner_thomson_dtt7610_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_thomson_dtt7610_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_thomson_dtt7610_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_ntsc_ranges),
-               .iffreq = 16 * 44.00 /*MHz*/,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FQ1286 - Philips NTSC ------------ */
-
-static struct tuner_range tuner_philips_fq1286_ntsc_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0x8e, 0x41, },
-       { 16 * 454.00 /*MHz*/, 0x8e, 0x42, },
-       { 16 * 999.99        , 0x8e, 0x04, },
-};
-
-static struct tuner_params tuner_philips_fq1286_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_philips_fq1286_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fq1286_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_TCL_2002MB - TCL PAL ------------ */
-
-static struct tuner_range tuner_tcl_2002mb_pal_ranges[] = {
-       { 16 * 170.00 /*MHz*/, 0xce, 0x01, },
-       { 16 * 450.00 /*MHz*/, 0xce, 0x02, },
-       { 16 * 999.99        , 0xce, 0x08, },
-};
-
-static struct tuner_params tuner_tcl_2002mb_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_tcl_2002mb_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_tcl_2002mb_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FQ1216AME_MK4 - Philips PAL ------------ */
-
-static struct tuner_range tuner_philips_fq12_6a___mk4_pal_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0xce, 0x01, },
-       { 16 * 442.00 /*MHz*/, 0xce, 0x02, },
-       { 16 * 999.99        , 0xce, 0x04, },
-};
-
-static struct tuner_params tuner_philips_fq1216ame_mk4_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_fq12_6a___mk4_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fq12_6a___mk4_pal_ranges),
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_invert_for_secam_lc = 1,
-               .default_top_mid = -2,
-               .default_top_secam_low = -2,
-               .default_top_secam_mid = -2,
-               .default_top_secam_high = -2,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FQ1236A_MK4 - Philips NTSC ------------ */
-
-static struct tuner_params tuner_philips_fq1236a_mk4_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_fm1236_mk3_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_YMEC_TVF_8531MF - Philips NTSC ------------ */
-
-static struct tuner_params tuner_ymec_tvf_8531mf_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_philips_ntsc_m_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_ranges),
-       },
-};
-
-/* ------------ TUNER_YMEC_TVF_5533MF - Philips NTSC ------------ */
-
-static struct tuner_range tuner_ymec_tvf_5533mf_ntsc_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 454.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x04, },
-};
-
-static struct tuner_params tuner_ymec_tvf_5533mf_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_ymec_tvf_5533mf_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_ymec_tvf_5533mf_ntsc_ranges),
-       },
-};
-
-/* 60-69 */
-/* ------------ TUNER_THOMSON_DTT761X - THOMSON ATSC ------------ */
-/* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
-
-static struct tuner_range tuner_thomson_dtt761x_ntsc_ranges[] = {
-       { 16 * 145.25 /*MHz*/, 0x8e, 0x39, },
-       { 16 * 415.25 /*MHz*/, 0x8e, 0x3a, },
-       { 16 * 999.99        , 0x8e, 0x3c, },
-};
-
-static struct tuner_range tuner_thomson_dtt761x_atsc_ranges[] = {
-       { 16 * 147.00 /*MHz*/, 0x8e, 0x39, },
-       { 16 * 417.00 /*MHz*/, 0x8e, 0x3a, },
-       { 16 * 999.99        , 0x8e, 0x3c, },
-};
-
-static struct tuner_params tuner_thomson_dtt761x_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_thomson_dtt761x_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_ntsc_ranges),
-               .has_tda9887 = 1,
-               .fm_gain_normal = 1,
-               .radio_if = 2, /* 41.3 MHz */
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_thomson_dtt761x_atsc_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_atsc_ranges),
-               .iffreq = 16 * 44.00, /*MHz*/
-       },
-};
-
-/* ------------ TUNER_TENA_9533_DI - Philips PAL ------------ */
-
-static struct tuner_range tuner_tena_9533_di_pal_ranges[] = {
-       { 16 * 160.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 464.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x04, },
-};
-
-static struct tuner_params tuner_tena_9533_di_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_tena_9533_di_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_tena_9533_di_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_FMD1216ME_MK3 - Philips PAL ------------ */
-
-static struct tuner_range tuner_philips_fmd1216me_mk3_pal_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0x86, 0x51, },
-       { 16 * 442.00 /*MHz*/, 0x86, 0x52, },
-       { 16 * 999.99        , 0x86, 0x54, },
-};
-
-static struct tuner_range tuner_philips_fmd1216me_mk3_dvb_ranges[] = {
-       { 16 * 143.87 /*MHz*/, 0xbc, 0x41 },
-       { 16 * 158.87 /*MHz*/, 0xf4, 0x41 },
-       { 16 * 329.87 /*MHz*/, 0xbc, 0x42 },
-       { 16 * 441.87 /*MHz*/, 0xf4, 0x42 },
-       { 16 * 625.87 /*MHz*/, 0xbc, 0x44 },
-       { 16 * 803.87 /*MHz*/, 0xf4, 0x44 },
-       { 16 * 999.99        , 0xfc, 0x44 },
-};
-
-static struct tuner_params tuner_philips_fmd1216me_mk3_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_fmd1216me_mk3_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_pal_ranges),
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_active = 1,
-               .port2_fm_high_sensitivity = 1,
-               .port2_invert_for_secam_lc = 1,
-               .port1_set_for_fm_mono = 1,
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_philips_fmd1216me_mk3_dvb_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_dvb_ranges),
-               .iffreq = 16 * 36.125, /*MHz*/
-       },
-};
-
-
-/* ------ TUNER_LG_TDVS_H06XF - LG INNOTEK / INFINEON ATSC ----- */
-
-static struct tuner_range tuner_tua6034_ntsc_ranges[] = {
-       { 16 * 165.00 /*MHz*/, 0x8e, 0x01 },
-       { 16 * 450.00 /*MHz*/, 0x8e, 0x02 },
-       { 16 * 999.99        , 0x8e, 0x04 },
-};
-
-static struct tuner_range tuner_tua6034_atsc_ranges[] = {
-       { 16 * 165.00 /*MHz*/, 0xce, 0x01 },
-       { 16 * 450.00 /*MHz*/, 0xce, 0x02 },
-       { 16 * 999.99        , 0xce, 0x04 },
-};
-
-static struct tuner_params tuner_lg_tdvs_h06xf_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_tua6034_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tua6034_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_tua6034_atsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tua6034_atsc_ranges),
-               .iffreq = 16 * 44.00,
-       },
-};
-
-/* ------------ TUNER_YMEC_TVF66T5_B_DFF - Philips PAL ------------ */
-
-static struct tuner_range tuner_ymec_tvf66t5_b_dff_pal_ranges[] = {
-       { 16 * 160.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 464.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_ymec_tvf66t5_b_dff_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_ymec_tvf66t5_b_dff_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_ymec_tvf66t5_b_dff_pal_ranges),
-       },
-};
-
-/* ------------ TUNER_LG_NTSC_TALN_MINI - LGINNOTEK NTSC ------------ */
-
-static struct tuner_range tuner_lg_taln_ntsc_ranges[] = {
-       { 16 * 137.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 373.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_range tuner_lg_taln_pal_secam_ranges[] = {
-       { 16 * 150.00 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 425.00 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_lg_taln_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_lg_taln_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_taln_ntsc_ranges),
-       },{
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_lg_taln_pal_secam_ranges,
-               .count  = ARRAY_SIZE(tuner_lg_taln_pal_secam_ranges),
-       },
-};
-
-/* ------------ TUNER_PHILIPS_TD1316 - Philips PAL ------------ */
-
-static struct tuner_range tuner_philips_td1316_pal_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0xc8, 0xa1, },
-       { 16 * 442.00 /*MHz*/, 0xc8, 0xa2, },
-       { 16 * 999.99        , 0xc8, 0xa4, },
-};
-
-static struct tuner_range tuner_philips_td1316_dvb_ranges[] = {
-       { 16 *  93.834 /*MHz*/, 0xca, 0x60, },
-       { 16 * 123.834 /*MHz*/, 0xca, 0xa0, },
-       { 16 * 163.834 /*MHz*/, 0xca, 0xc0, },
-       { 16 * 253.834 /*MHz*/, 0xca, 0x60, },
-       { 16 * 383.834 /*MHz*/, 0xca, 0xa0, },
-       { 16 * 443.834 /*MHz*/, 0xca, 0xc0, },
-       { 16 * 583.834 /*MHz*/, 0xca, 0x60, },
-       { 16 * 793.834 /*MHz*/, 0xca, 0xa0, },
-       { 16 * 999.999        , 0xca, 0xe0, },
-};
-
-static struct tuner_params tuner_philips_td1316_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_philips_td1316_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_td1316_pal_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_philips_td1316_dvb_ranges,
-               .count  = ARRAY_SIZE(tuner_philips_td1316_dvb_ranges),
-               .iffreq = 16 * 36.166667 /*MHz*/,
-       },
-};
-
-/* ------------ TUNER_PHILIPS_TUV1236D - Philips ATSC ------------ */
-
-static struct tuner_range tuner_tuv1236d_ntsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0xce, 0x01, },
-       { 16 * 454.00 /*MHz*/, 0xce, 0x02, },
-       { 16 * 999.99        , 0xce, 0x04, },
-};
-
-static struct tuner_range tuner_tuv1236d_atsc_ranges[] = {
-       { 16 * 157.25 /*MHz*/, 0xc6, 0x41, },
-       { 16 * 454.00 /*MHz*/, 0xc6, 0x42, },
-       { 16 * 999.99        , 0xc6, 0x44, },
-};
-
-static struct tuner_params tuner_tuv1236d_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_tuv1236d_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tuv1236d_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_tuv1236d_atsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tuv1236d_atsc_ranges),
-               .iffreq = 16 * 44.00,
-       },
-};
-
-/* ------------ TUNER_TNF_xxx5  - Texas Instruments--------- */
-/* This is known to work with Tenna TVF58t5-MFF and TVF5835 MFF
- *     but it is expected to work also with other Tenna/Ymec
- *     models based on TI SN 761677 chip on both PAL and NTSC
- */
-
-static struct tuner_range tuner_tnf_5335_d_if_pal_ranges[] = {
-       { 16 * 168.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 471.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_range tuner_tnf_5335mf_ntsc_ranges[] = {
-       { 16 * 169.25 /*MHz*/, 0x8e, 0x01, },
-       { 16 * 469.25 /*MHz*/, 0x8e, 0x02, },
-       { 16 * 999.99        , 0x8e, 0x08, },
-};
-
-static struct tuner_params tuner_tnf_5335mf_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_tnf_5335mf_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_tnf_5335mf_ntsc_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_tnf_5335_d_if_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_tnf_5335_d_if_pal_ranges),
-       },
-};
-
-/* 70-79 */
-/* ------------ TUNER_SAMSUNG_TCPN_2121P30A - Samsung NTSC ------------ */
-
-/* '+ 4' turns on the Low Noise Amplifier */
-static struct tuner_range tuner_samsung_tcpn_2121p30a_ntsc_ranges[] = {
-       { 16 * 130.00 /*MHz*/, 0xce, 0x01 + 4, },
-       { 16 * 364.50 /*MHz*/, 0xce, 0x02 + 4, },
-       { 16 * 999.99        , 0xce, 0x08 + 4, },
-};
-
-static struct tuner_params tuner_samsung_tcpn_2121p30a_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_NTSC,
-               .ranges = tuner_samsung_tcpn_2121p30a_ntsc_ranges,
-               .count  = ARRAY_SIZE(tuner_samsung_tcpn_2121p30a_ntsc_ranges),
-       },
-};
-
-/* ------------ TUNER_THOMSON_FE6600 - DViCO Hybrid PAL ------------ */
-
-static struct tuner_range tuner_thomson_fe6600_pal_ranges[] = {
-       { 16 * 160.00 /*MHz*/, 0xfe, 0x11, },
-       { 16 * 442.00 /*MHz*/, 0xf6, 0x12, },
-       { 16 * 999.99        , 0xf6, 0x18, },
-};
-
-static struct tuner_range tuner_thomson_fe6600_dvb_ranges[] = {
-       { 16 * 250.00 /*MHz*/, 0xb4, 0x12, },
-       { 16 * 455.00 /*MHz*/, 0xfe, 0x11, },
-       { 16 * 775.50 /*MHz*/, 0xbc, 0x18, },
-       { 16 * 999.99        , 0xf4, 0x18, },
-};
-
-static struct tuner_params tuner_thomson_fe6600_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_thomson_fe6600_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_fe6600_pal_ranges),
-       },
-       {
-               .type   = TUNER_PARAM_TYPE_DIGITAL,
-               .ranges = tuner_thomson_fe6600_dvb_ranges,
-               .count  = ARRAY_SIZE(tuner_thomson_fe6600_dvb_ranges),
-               .iffreq = 16 * 36.125 /*MHz*/,
-       },
-};
-
-/* ------------ TUNER_SAMSUNG_TCPG_6121P30A - Samsung PAL ------------ */
-
-/* '+ 4' turns on the Low Noise Amplifier */
-static struct tuner_range tuner_samsung_tcpg_6121p30a_pal_ranges[] = {
-       { 16 * 146.25 /*MHz*/, 0xce, 0x01 + 4, },
-       { 16 * 428.50 /*MHz*/, 0xce, 0x02 + 4, },
-       { 16 * 999.99        , 0xce, 0x08 + 4, },
-};
-
-static struct tuner_params tuner_samsung_tcpg_6121p30a_params[] = {
-       {
-               .type   = TUNER_PARAM_TYPE_PAL,
-               .ranges = tuner_samsung_tcpg_6121p30a_pal_ranges,
-               .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_pal_ranges),
-               .has_tda9887 = 1,
-               .port1_active = 1,
-               .port2_active = 1,
-               .port2_invert_for_secam_lc = 1,
-       },
-};
-
-/* --------------------------------------------------------------------- */
-
-struct tunertype tuners[] = {
-       /* 0-9 */
-       [TUNER_TEMIC_PAL] = { /* TEMIC PAL */
-               .name   = "Temic PAL (4002 FH5)",
-               .params = tuner_temic_pal_params,
-               .count  = ARRAY_SIZE(tuner_temic_pal_params),
-       },
-       [TUNER_PHILIPS_PAL_I] = { /* Philips PAL_I */
-               .name   = "Philips PAL_I (FI1246 and compatibles)",
-               .params = tuner_philips_pal_i_params,
-               .count  = ARRAY_SIZE(tuner_philips_pal_i_params),
-       },
-       [TUNER_PHILIPS_NTSC] = { /* Philips NTSC */
-               .name   = "Philips NTSC (FI1236,FM1236 and compatibles)",
-               .params = tuner_philips_ntsc_params,
-               .count  = ARRAY_SIZE(tuner_philips_ntsc_params),
-       },
-       [TUNER_PHILIPS_SECAM] = { /* Philips SECAM */
-               .name   = "Philips (SECAM+PAL_BG) (FI1216MF, FM1216MF, FR1216MF)",
-               .params = tuner_philips_secam_params,
-               .count  = ARRAY_SIZE(tuner_philips_secam_params),
-       },
-       [TUNER_ABSENT] = { /* Tuner Absent */
-               .name   = "NoTuner",
-       },
-       [TUNER_PHILIPS_PAL] = { /* Philips PAL */
-               .name   = "Philips PAL_BG (FI1216 and compatibles)",
-               .params = tuner_philips_pal_params,
-               .count  = ARRAY_SIZE(tuner_philips_pal_params),
-       },
-       [TUNER_TEMIC_NTSC] = { /* TEMIC NTSC */
-               .name   = "Temic NTSC (4032 FY5)",
-               .params = tuner_temic_ntsc_params,
-               .count  = ARRAY_SIZE(tuner_temic_ntsc_params),
-       },
-       [TUNER_TEMIC_PAL_I] = { /* TEMIC PAL_I */
-               .name   = "Temic PAL_I (4062 FY5)",
-               .params = tuner_temic_pal_i_params,
-               .count  = ARRAY_SIZE(tuner_temic_pal_i_params),
-       },
-       [TUNER_TEMIC_4036FY5_NTSC] = { /* TEMIC NTSC */
-               .name   = "Temic NTSC (4036 FY5)",
-               .params = tuner_temic_4036fy5_ntsc_params,
-               .count  = ARRAY_SIZE(tuner_temic_4036fy5_ntsc_params),
-       },
-       [TUNER_ALPS_TSBH1_NTSC] = { /* TEMIC NTSC */
-               .name   = "Alps HSBH1",
-               .params = tuner_alps_tsbh1_ntsc_params,
-               .count  = ARRAY_SIZE(tuner_alps_tsbh1_ntsc_params),
-       },
-
-       /* 10-19 */
-       [TUNER_ALPS_TSBE1_PAL] = { /* TEMIC PAL */
-               .name   = "Alps TSBE1",
-               .params = tuner_alps_tsb_1_params,
-               .count  = ARRAY_SIZE(tuner_alps_tsb_1_params),
-       },
-       [TUNER_ALPS_TSBB5_PAL_I] = { /* Alps PAL_I */
-               .name   = "Alps TSBB5",
-               .params = tuner_alps_tsbb5_params,
-               .count  = ARRAY_SIZE(tuner_alps_tsbb5_params),
-       },
-       [TUNER_ALPS_TSBE5_PAL] = { /* Alps PAL */
-               .name   = "Alps TSBE5",
-               .params = tuner_alps_tsbe5_params,
-               .count  = ARRAY_SIZE(tuner_alps_tsbe5_params),
-       },
-       [TUNER_ALPS_TSBC5_PAL] = { /* Alps PAL */
-               .name   = "Alps TSBC5",
-               .params = tuner_alps_tsbc5_params,
-               .count  = ARRAY_SIZE(tuner_alps_tsbc5_params),
-       },
-       [TUNER_TEMIC_4006FH5_PAL] = { /* TEMIC PAL */
-               .name   = "Temic PAL_BG (4006FH5)",
-               .params = tuner_temic_4006fh5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4006fh5_params),
-       },
-       [TUNER_ALPS_TSHC6_NTSC] = { /* Alps NTSC */
-               .name   = "Alps TSCH6",
-               .params = tuner_alps_tshc6_params,
-               .count  = ARRAY_SIZE(tuner_alps_tshc6_params),
-       },
-       [TUNER_TEMIC_PAL_DK] = { /* TEMIC PAL */
-               .name   = "Temic PAL_DK (4016 FY5)",
-               .params = tuner_temic_pal_dk_params,
-               .count  = ARRAY_SIZE(tuner_temic_pal_dk_params),
-       },
-       [TUNER_PHILIPS_NTSC_M] = { /* Philips NTSC */
-               .name   = "Philips NTSC_M (MK2)",
-               .params = tuner_philips_ntsc_m_params,
-               .count  = ARRAY_SIZE(tuner_philips_ntsc_m_params),
-       },
-       [TUNER_TEMIC_4066FY5_PAL_I] = { /* TEMIC PAL_I */
-               .name   = "Temic PAL_I (4066 FY5)",
-               .params = tuner_temic_4066fy5_pal_i_params,
-               .count  = ARRAY_SIZE(tuner_temic_4066fy5_pal_i_params),
-       },
-       [TUNER_TEMIC_4006FN5_MULTI_PAL] = { /* TEMIC PAL */
-               .name   = "Temic PAL* auto (4006 FN5)",
-               .params = tuner_temic_4006fn5_multi_params,
-               .count  = ARRAY_SIZE(tuner_temic_4006fn5_multi_params),
-       },
-
-       /* 20-29 */
-       [TUNER_TEMIC_4009FR5_PAL] = { /* TEMIC PAL */
-               .name   = "Temic PAL_BG (4009 FR5) or PAL_I (4069 FR5)",
-               .params = tuner_temic_4009f_5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4009f_5_params),
-       },
-       [TUNER_TEMIC_4039FR5_NTSC] = { /* TEMIC NTSC */
-               .name   = "Temic NTSC (4039 FR5)",
-               .params = tuner_temic_4039fr5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4039fr5_params),
-       },
-       [TUNER_TEMIC_4046FM5] = { /* TEMIC PAL */
-               .name   = "Temic PAL/SECAM multi (4046 FM5)",
-               .params = tuner_temic_4046fm5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4046fm5_params),
-       },
-       [TUNER_PHILIPS_PAL_DK] = { /* Philips PAL */
-               .name   = "Philips PAL_DK (FI1256 and compatibles)",
-               .params = tuner_philips_pal_dk_params,
-               .count  = ARRAY_SIZE(tuner_philips_pal_dk_params),
-       },
-       [TUNER_PHILIPS_FQ1216ME] = { /* Philips PAL */
-               .name   = "Philips PAL/SECAM multi (FQ1216ME)",
-               .params = tuner_philips_fq1216me_params,
-               .count  = ARRAY_SIZE(tuner_philips_fq1216me_params),
-       },
-       [TUNER_LG_PAL_I_FM] = { /* LGINNOTEK PAL_I */
-               .name   = "LG PAL_I+FM (TAPC-I001D)",
-               .params = tuner_lg_pal_i_fm_params,
-               .count  = ARRAY_SIZE(tuner_lg_pal_i_fm_params),
-       },
-       [TUNER_LG_PAL_I] = { /* LGINNOTEK PAL_I */
-               .name   = "LG PAL_I (TAPC-I701D)",
-               .params = tuner_lg_pal_i_params,
-               .count  = ARRAY_SIZE(tuner_lg_pal_i_params),
-       },
-       [TUNER_LG_NTSC_FM] = { /* LGINNOTEK NTSC */
-               .name   = "LG NTSC+FM (TPI8NSR01F)",
-               .params = tuner_lg_ntsc_fm_params,
-               .count  = ARRAY_SIZE(tuner_lg_ntsc_fm_params),
-       },
-       [TUNER_LG_PAL_FM] = { /* LGINNOTEK PAL */
-               .name   = "LG PAL_BG+FM (TPI8PSB01D)",
-               .params = tuner_lg_pal_fm_params,
-               .count  = ARRAY_SIZE(tuner_lg_pal_fm_params),
-       },
-       [TUNER_LG_PAL] = { /* LGINNOTEK PAL */
-               .name   = "LG PAL_BG (TPI8PSB11D)",
-               .params = tuner_lg_pal_params,
-               .count  = ARRAY_SIZE(tuner_lg_pal_params),
-       },
-
-       /* 30-39 */
-       [TUNER_TEMIC_4009FN5_MULTI_PAL_FM] = { /* TEMIC PAL */
-               .name   = "Temic PAL* auto + FM (4009 FN5)",
-               .params = tuner_temic_4009_fn5_multi_pal_fm_params,
-               .count  = ARRAY_SIZE(tuner_temic_4009_fn5_multi_pal_fm_params),
-       },
-       [TUNER_SHARP_2U5JF5540_NTSC] = { /* SHARP NTSC */
-               .name   = "SHARP NTSC_JP (2U5JF5540)",
-               .params = tuner_sharp_2u5jf5540_params,
-               .count  = ARRAY_SIZE(tuner_sharp_2u5jf5540_params),
-       },
-       [TUNER_Samsung_PAL_TCPM9091PD27] = { /* Samsung PAL */
-               .name   = "Samsung PAL TCPM9091PD27",
-               .params = tuner_samsung_pal_tcpm9091pd27_params,
-               .count  = ARRAY_SIZE(tuner_samsung_pal_tcpm9091pd27_params),
-       },
-       [TUNER_MT2032] = { /* Microtune PAL|NTSC */
-               .name   = "MT20xx universal",
-               /* see mt20xx.c for details */ },
-       [TUNER_TEMIC_4106FH5] = { /* TEMIC PAL */
-               .name   = "Temic PAL_BG (4106 FH5)",
-               .params = tuner_temic_4106fh5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4106fh5_params),
-       },
-       [TUNER_TEMIC_4012FY5] = { /* TEMIC PAL */
-               .name   = "Temic PAL_DK/SECAM_L (4012 FY5)",
-               .params = tuner_temic_4012fy5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4012fy5_params),
-       },
-       [TUNER_TEMIC_4136FY5] = { /* TEMIC NTSC */
-               .name   = "Temic NTSC (4136 FY5)",
-               .params = tuner_temic_4136_fy5_params,
-               .count  = ARRAY_SIZE(tuner_temic_4136_fy5_params),
-       },
-       [TUNER_LG_PAL_NEW_TAPC] = { /* LGINNOTEK PAL */
-               .name   = "LG PAL (newer TAPC series)",
-               .params = tuner_lg_pal_new_tapc_params,
-               .count  = ARRAY_SIZE(tuner_lg_pal_new_tapc_params),
-       },
-       [TUNER_PHILIPS_FM1216ME_MK3] = { /* Philips PAL */
-               .name   = "Philips PAL/SECAM multi (FM1216ME MK3)",
-               .params = tuner_fm1216me_mk3_params,
-               .count  = ARRAY_SIZE(tuner_fm1216me_mk3_params),
-       },
-       [TUNER_LG_NTSC_NEW_TAPC] = { /* LGINNOTEK NTSC */
-               .name   = "LG NTSC (newer TAPC series)",
-               .params = tuner_lg_ntsc_new_tapc_params,
-               .count  = ARRAY_SIZE(tuner_lg_ntsc_new_tapc_params),
-       },
-
-       /* 40-49 */
-       [TUNER_HITACHI_NTSC] = { /* HITACHI NTSC */
-               .name   = "HITACHI V7-J180AT",
-               .params = tuner_hitachi_ntsc_params,
-               .count  = ARRAY_SIZE(tuner_hitachi_ntsc_params),
-       },
-       [TUNER_PHILIPS_PAL_MK] = { /* Philips PAL */
-               .name   = "Philips PAL_MK (FI1216 MK)",
-               .params = tuner_philips_pal_mk_params,
-               .count  = ARRAY_SIZE(tuner_philips_pal_mk_params),
-       },
-       [TUNER_PHILIPS_FCV1236D] = { /* Philips ATSC */
-               .name   = "Philips FCV1236D ATSC/NTSC dual in",
-               .params = tuner_philips_fcv1236d_params,
-               .count  = ARRAY_SIZE(tuner_philips_fcv1236d_params),
-               .min = 16 *  53.00,
-               .max = 16 * 803.00,
-               .stepsize = 62500,
-       },
-       [TUNER_PHILIPS_FM1236_MK3] = { /* Philips NTSC */
-               .name   = "Philips NTSC MK3 (FM1236MK3 or FM1236/F)",
-               .params = tuner_fm1236_mk3_params,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_params),
-       },
-       [TUNER_PHILIPS_4IN1] = { /* Philips NTSC */
-               .name   = "Philips 4 in 1 (ATI TV Wonder Pro/Conexant)",
-               .params = tuner_philips_4in1_params,
-               .count  = ARRAY_SIZE(tuner_philips_4in1_params),
-       },
-       [TUNER_MICROTUNE_4049FM5] = { /* Microtune PAL */
-               .name   = "Microtune 4049 FM5",
-               .params = tuner_microtune_4049_fm5_params,
-               .count  = ARRAY_SIZE(tuner_microtune_4049_fm5_params),
-       },
-       [TUNER_PANASONIC_VP27] = { /* Panasonic NTSC */
-               .name   = "Panasonic VP27s/ENGE4324D",
-               .params = tuner_panasonic_vp27_params,
-               .count  = ARRAY_SIZE(tuner_panasonic_vp27_params),
-       },
-       [TUNER_LG_NTSC_TAPE] = { /* LGINNOTEK NTSC */
-               .name   = "LG NTSC (TAPE series)",
-               .params = tuner_fm1236_mk3_params,
-               .count  = ARRAY_SIZE(tuner_fm1236_mk3_params),
-       },
-       [TUNER_TNF_8831BGFF] = { /* Philips PAL */
-               .name   = "Tenna TNF 8831 BGFF)",
-               .params = tuner_tnf_8831bgff_params,
-               .count  = ARRAY_SIZE(tuner_tnf_8831bgff_params),
-       },
-       [TUNER_MICROTUNE_4042FI5] = { /* Microtune NTSC */
-               .name   = "Microtune 4042 FI5 ATSC/NTSC dual in",
-               .params = tuner_microtune_4042fi5_params,
-               .count  = ARRAY_SIZE(tuner_microtune_4042fi5_params),
-               .min    = 16 *  57.00,
-               .max    = 16 * 858.00,
-               .stepsize = 62500,
-       },
-
-       /* 50-59 */
-       [TUNER_TCL_2002N] = { /* TCL NTSC */
-               .name   = "TCL 2002N",
-               .params = tuner_tcl_2002n_params,
-               .count  = ARRAY_SIZE(tuner_tcl_2002n_params),
-       },
-       [TUNER_PHILIPS_FM1256_IH3] = { /* Philips PAL */
-               .name   = "Philips PAL/SECAM_D (FM 1256 I-H3)",
-               .params = tuner_philips_fm1256_ih3_params,
-               .count  = ARRAY_SIZE(tuner_philips_fm1256_ih3_params),
-       },
-       [TUNER_THOMSON_DTT7610] = { /* THOMSON ATSC */
-               .name   = "Thomson DTT 7610 (ATSC/NTSC)",
-               .params = tuner_thomson_dtt7610_params,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt7610_params),
-               .min    = 16 *  44.00,
-               .max    = 16 * 958.00,
-               .stepsize = 62500,
-       },
-       [TUNER_PHILIPS_FQ1286] = { /* Philips NTSC */
-               .name   = "Philips FQ1286",
-               .params = tuner_philips_fq1286_params,
-               .count  = ARRAY_SIZE(tuner_philips_fq1286_params),
-       },
-       [TUNER_PHILIPS_TDA8290] = { /* Philips PAL|NTSC */
-               .name   = "Philips/NXP TDA 8290/8295 + 8275/8275A/18271",
-               /* see tda8290.c for details */ },
-       [TUNER_TCL_2002MB] = { /* TCL PAL */
-               .name   = "TCL 2002MB",
-               .params = tuner_tcl_2002mb_params,
-               .count  = ARRAY_SIZE(tuner_tcl_2002mb_params),
-       },
-       [TUNER_PHILIPS_FQ1216AME_MK4] = { /* Philips PAL */
-               .name   = "Philips PAL/SECAM multi (FQ1216AME MK4)",
-               .params = tuner_philips_fq1216ame_mk4_params,
-               .count  = ARRAY_SIZE(tuner_philips_fq1216ame_mk4_params),
-       },
-       [TUNER_PHILIPS_FQ1236A_MK4] = { /* Philips NTSC */
-               .name   = "Philips FQ1236A MK4",
-               .params = tuner_philips_fq1236a_mk4_params,
-               .count  = ARRAY_SIZE(tuner_philips_fq1236a_mk4_params),
-       },
-       [TUNER_YMEC_TVF_8531MF] = { /* Philips NTSC */
-               .name   = "Ymec TVision TVF-8531MF/8831MF/8731MF",
-               .params = tuner_ymec_tvf_8531mf_params,
-               .count  = ARRAY_SIZE(tuner_ymec_tvf_8531mf_params),
-       },
-       [TUNER_YMEC_TVF_5533MF] = { /* Philips NTSC */
-               .name   = "Ymec TVision TVF-5533MF",
-               .params = tuner_ymec_tvf_5533mf_params,
-               .count  = ARRAY_SIZE(tuner_ymec_tvf_5533mf_params),
-       },
-
-       /* 60-69 */
-       [TUNER_THOMSON_DTT761X] = { /* THOMSON ATSC */
-               /* DTT 7611 7611A 7612 7613 7613A 7614 7615 7615A */
-               .name   = "Thomson DTT 761X (ATSC/NTSC)",
-               .params = tuner_thomson_dtt761x_params,
-               .count  = ARRAY_SIZE(tuner_thomson_dtt761x_params),
-               .min    = 16 *  57.00,
-               .max    = 16 * 863.00,
-               .stepsize = 62500,
-               .initdata = tua603x_agc103,
-       },
-       [TUNER_TENA_9533_DI] = { /* Philips PAL */
-               .name   = "Tena TNF9533-D/IF/TNF9533-B/DF",
-               .params = tuner_tena_9533_di_params,
-               .count  = ARRAY_SIZE(tuner_tena_9533_di_params),
-       },
-       [TUNER_TEA5767] = { /* Philips RADIO */
-               .name   = "Philips TEA5767HN FM Radio",
-               /* see tea5767.c for details */
-       },
-       [TUNER_PHILIPS_FMD1216ME_MK3] = { /* Philips PAL */
-               .name   = "Philips FMD1216ME MK3 Hybrid Tuner",
-               .params = tuner_philips_fmd1216me_mk3_params,
-               .count  = ARRAY_SIZE(tuner_philips_fmd1216me_mk3_params),
-               .min = 16 *  50.87,
-               .max = 16 * 858.00,
-               .stepsize = 166667,
-               .initdata = tua603x_agc112,
-               .sleepdata = (u8[]){ 4, 0x9c, 0x60, 0x85, 0x54 },
-       },
-       [TUNER_LG_TDVS_H06XF] = { /* LGINNOTEK ATSC */
-               .name   = "LG TDVS-H06xF", /* H061F, H062F & H064F */
-               .params = tuner_lg_tdvs_h06xf_params,
-               .count  = ARRAY_SIZE(tuner_lg_tdvs_h06xf_params),
-               .min    = 16 *  54.00,
-               .max    = 16 * 863.00,
-               .stepsize = 62500,
-               .initdata = tua603x_agc103,
-       },
-       [TUNER_YMEC_TVF66T5_B_DFF] = { /* Philips PAL */
-               .name   = "Ymec TVF66T5-B/DFF",
-               .params = tuner_ymec_tvf66t5_b_dff_params,
-               .count  = ARRAY_SIZE(tuner_ymec_tvf66t5_b_dff_params),
-       },
-       [TUNER_LG_TALN] = { /* LGINNOTEK NTSC / PAL / SECAM */
-               .name   = "LG TALN series",
-               .params = tuner_lg_taln_params,
-               .count  = ARRAY_SIZE(tuner_lg_taln_params),
-       },
-       [TUNER_PHILIPS_TD1316] = { /* Philips PAL */
-               .name   = "Philips TD1316 Hybrid Tuner",
-               .params = tuner_philips_td1316_params,
-               .count  = ARRAY_SIZE(tuner_philips_td1316_params),
-               .min    = 16 *  87.00,
-               .max    = 16 * 895.00,
-               .stepsize = 166667,
-       },
-       [TUNER_PHILIPS_TUV1236D] = { /* Philips ATSC */
-               .name   = "Philips TUV1236D ATSC/NTSC dual in",
-               .params = tuner_tuv1236d_params,
-               .count  = ARRAY_SIZE(tuner_tuv1236d_params),
-               .min    = 16 *  54.00,
-               .max    = 16 * 864.00,
-               .stepsize = 62500,
-       },
-       [TUNER_TNF_5335MF] = { /* Tenna PAL/NTSC */
-               .name   = "Tena TNF 5335 and similar models",
-               .params = tuner_tnf_5335mf_params,
-               .count  = ARRAY_SIZE(tuner_tnf_5335mf_params),
-       },
-
-       /* 70-79 */
-       [TUNER_SAMSUNG_TCPN_2121P30A] = { /* Samsung NTSC */
-               .name   = "Samsung TCPN 2121P30A",
-               .params = tuner_samsung_tcpn_2121p30a_params,
-               .count  = ARRAY_SIZE(tuner_samsung_tcpn_2121p30a_params),
-       },
-       [TUNER_XC2028] = { /* Xceive 2028 */
-               .name   = "Xceive xc2028/xc3028 tuner",
-               /* see tuner-xc2028.c for details */
-       },
-       [TUNER_THOMSON_FE6600] = { /* Thomson PAL / DVB-T */
-               .name   = "Thomson FE6600",
-               .params = tuner_thomson_fe6600_params,
-               .count  = ARRAY_SIZE(tuner_thomson_fe6600_params),
-               .min    = 16 *  44.25,
-               .max    = 16 * 858.00,
-               .stepsize = 166667,
-       },
-       [TUNER_SAMSUNG_TCPG_6121P30A] = { /* Samsung PAL */
-               .name   = "Samsung TCPG 6121P30A",
-               .params = tuner_samsung_tcpg_6121p30a_params,
-               .count  = ARRAY_SIZE(tuner_samsung_tcpg_6121p30a_params),
-       },
-       [TUNER_TDA9887] = { /* Philips TDA 9887 IF PLL Demodulator.
-                               This chip is part of some modern tuners */
-               .name   = "Philips TDA988[5,6,7] IF PLL Demodulator",
-               /* see tda9887.c for details */
-       },
-       [TUNER_TEA5761] = { /* Philips RADIO */
-               .name   = "Philips TEA5761 FM Radio",
-               /* see tea5767.c for details */
-       },
-       [TUNER_XC5000] = { /* Xceive 5000 */
-               .name   = "Xceive 5000 tuner",
-               /* see xc5000.c for details */
-       },
-};
-EXPORT_SYMBOL(tuners);
-
-unsigned const int tuner_count = ARRAY_SIZE(tuners);
-EXPORT_SYMBOL(tuner_count);
-
-MODULE_DESCRIPTION("Simple tuner device type database");
-MODULE_AUTHOR("Ralph Metzler, Gerd Knorr, Gunther Mayer");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/tuner-xc2028-types.h b/drivers/media/video/tuner-xc2028-types.h
deleted file mode 100644 (file)
index 74dc46a..0000000
+++ /dev/null
@@ -1,141 +0,0 @@
-/* tuner-xc2028_types
- *
- * This file includes internal tipes to be used inside tuner-xc2028.
- * Shouldn't be included outside tuner-xc2028
- *
- * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
- * This code is placed under the terms of the GNU General Public License v2
- */
-
-/* xc3028 firmware types */
-
-/* BASE firmware should be loaded before any other firmware */
-#define BASE           (1<<0)
-#define BASE_TYPES     (BASE|F8MHZ|MTS|FM|INPUT1|INPUT2|INIT1)
-
-/* F8MHZ marks BASE firmwares for 8 MHz Bandwidth */
-#define F8MHZ          (1<<1)
-
-/* Multichannel Television Sound (MTS)
-   Those firmwares are capable of using xc2038 DSP to decode audio and
-   produce a baseband audio output on some pins of the chip.
-   There are MTS firmwares for the most used video standards. It should be
-   required to use MTS firmwares, depending on the way audio is routed into
-   the bridge chip
- */
-#define MTS            (1<<2)
-
-/* FIXME: I have no idea what's the difference between
-   D2620 and D2633 firmwares
- */
-#define D2620          (1<<3)
-#define D2633          (1<<4)
-
-/* DTV firmwares for 6, 7 and 8 MHz
-   DTV6 - 6MHz - ATSC/DVB-C/DVB-T/ISDB-T/DOCSIS
-   DTV8 - 8MHz - DVB-C/DVB-T
- */
-#define DTV6           (1 << 5)
-#define QAM            (1 << 6)
-#define DTV7           (1<<7)
-#define DTV78          (1<<8)
-#define DTV8           (1<<9)
-
-#define DTV_TYPES      (D2620|D2633|DTV6|QAM|DTV7|DTV78|DTV8|ATSC)
-
-/* There's a FM | BASE firmware + FM specific firmware (std=0) */
-#define        FM              (1<<10)
-
-#define STD_SPECIFIC_TYPES (MTS|FM|LCD|NOGD)
-
-/* Applies only for FM firmware
-   Makes it use RF input 1 (pin #2) instead of input 2 (pin #4)
- */
-#define INPUT1         (1<<11)
-
-
-/* LCD firmwares exist only for MTS STD/MN (PAL or NTSC/M)
-       and for non-MTS STD/MN (PAL, NTSC/M or NTSC/Kr)
-       There are variants both with and without NOGD
-       Those firmwares produce better result with LCD displays
- */
-#define LCD            (1<<12)
-
-/* NOGD firmwares exist only for MTS STD/MN (PAL or NTSC/M)
-       and for non-MTS STD/MN (PAL, NTSC/M or NTSC/Kr)
-       The NOGD firmwares don't have group delay compensation filter
- */
-#define NOGD           (1<<13)
-
-/* Old firmwares were broken into init0 and init1 */
-#define INIT1          (1<<14)
-
-/* SCODE firmware selects particular behaviours */
-#define MONO           (1 << 15)
-#define ATSC           (1 << 16)
-#define IF             (1 << 17)
-#define LG60           (1 << 18)
-#define ATI638         (1 << 19)
-#define OREN538        (1 << 20)
-#define OREN36         (1 << 21)
-#define TOYOTA388      (1 << 22)
-#define TOYOTA794      (1 << 23)
-#define DIBCOM52       (1 << 24)
-#define ZARLINK456     (1 << 25)
-#define CHINA          (1 << 26)
-#define F6MHZ          (1 << 27)
-#define INPUT2         (1 << 28)
-#define SCODE          (1 << 29)
-
-/* This flag identifies that the scode table has a new format */
-#define HAS_IF         (1 << 30)
-
-/* There are different scode tables for MTS and non-MTS.
-   The MTS firmwares support mono only
-  */
-#define SCODE_TYPES (SCODE | MTS)
-
-
-/* Newer types not defined on videodev2.h.
-   The original idea were to move all those types to videodev2.h, but
-   it seemed overkill, since, with the exception of SECAM/K3, the other
-   types seem to be autodetected.
-   It is not clear where secam/k3 is used, nor we have a feedback of this
-   working or being autodetected by the standard secam firmware.
- */
-
-#define V4L2_STD_SECAM_K3      (0x04000000)
-
-/* Audio types */
-
-#define V4L2_STD_A2_A          (1LL<<32)
-#define V4L2_STD_A2_B          (1LL<<33)
-#define V4L2_STD_NICAM_A       (1LL<<34)
-#define V4L2_STD_NICAM_B       (1LL<<35)
-#define V4L2_STD_AM            (1LL<<36)
-#define V4L2_STD_BTSC          (1LL<<37)
-#define V4L2_STD_EIAJ          (1LL<<38)
-
-#define V4L2_STD_A2            (V4L2_STD_A2_A    | V4L2_STD_A2_B)
-#define V4L2_STD_NICAM         (V4L2_STD_NICAM_A | V4L2_STD_NICAM_B)
-
-/* To preserve backward compatibilty,
-   (std & V4L2_STD_AUDIO) = 0 means that ALL audio stds are supported
- */
-
-#define V4L2_STD_AUDIO         (V4L2_STD_A2    | \
-                                V4L2_STD_NICAM | \
-                                V4L2_STD_AM    | \
-                                V4L2_STD_BTSC  | \
-                                V4L2_STD_EIAJ)
-
-/* Used standards with audio restrictions */
-
-#define V4L2_STD_PAL_BG_A2_A   (V4L2_STD_PAL_BG | V4L2_STD_A2_A)
-#define V4L2_STD_PAL_BG_A2_B   (V4L2_STD_PAL_BG | V4L2_STD_A2_B)
-#define V4L2_STD_PAL_BG_NICAM_A        (V4L2_STD_PAL_BG | V4L2_STD_NICAM_A)
-#define V4L2_STD_PAL_BG_NICAM_B        (V4L2_STD_PAL_BG | V4L2_STD_NICAM_B)
-#define V4L2_STD_PAL_DK_A2     (V4L2_STD_PAL_DK | V4L2_STD_A2)
-#define V4L2_STD_PAL_DK_NICAM  (V4L2_STD_PAL_DK | V4L2_STD_NICAM)
-#define V4L2_STD_SECAM_L_NICAM (V4L2_STD_SECAM_L | V4L2_STD_NICAM)
-#define V4L2_STD_SECAM_L_AM    (V4L2_STD_SECAM_L | V4L2_STD_AM)
diff --git a/drivers/media/video/tuner-xc2028.c b/drivers/media/video/tuner-xc2028.c
deleted file mode 100644 (file)
index 9e9003c..0000000
+++ /dev/null
@@ -1,1227 +0,0 @@
-/* tuner-xc2028
- *
- * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
- *
- * Copyright (c) 2007 Michel Ludwig (michel.ludwig@gmail.com)
- *       - frontend interface
- *
- * This code is placed under the terms of the GNU General Public License v2
- */
-
-#include <linux/i2c.h>
-#include <asm/div64.h>
-#include <linux/firmware.h>
-#include <linux/videodev2.h>
-#include <linux/delay.h>
-#include <media/tuner.h>
-#include <linux/mutex.h>
-#include "tuner-i2c.h"
-#include "tuner-xc2028.h"
-#include "tuner-xc2028-types.h"
-
-#include <linux/dvb/frontend.h>
-#include "dvb_frontend.h"
-
-
-static int debug;
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "enable verbose debug messages");
-
-static char audio_std[8];
-module_param_string(audio_std, audio_std, sizeof(audio_std), 0);
-MODULE_PARM_DESC(audio_std,
-       "Audio standard. XC3028 audio decoder explicitly "
-       "needs to know what audio\n"
-       "standard is needed for some video standards with audio A2 or NICAM.\n"
-       "The valid values are:\n"
-       "A2\n"
-       "A2/A\n"
-       "A2/B\n"
-       "NICAM\n"
-       "NICAM/A\n"
-       "NICAM/B\n");
-
-static char firmware_name[FIRMWARE_NAME_MAX];
-module_param_string(firmware_name, firmware_name, sizeof(firmware_name), 0);
-MODULE_PARM_DESC(firmware_name, "Firmware file name. Allows overriding the "
-                               "default firmware name\n");
-
-static LIST_HEAD(xc2028_list);
-static DEFINE_MUTEX(xc2028_list_mutex);
-
-/* struct for storing firmware table */
-struct firmware_description {
-       unsigned int  type;
-       v4l2_std_id   id;
-       __u16         int_freq;
-       unsigned char *ptr;
-       unsigned int  size;
-};
-
-struct firmware_properties {
-       unsigned int    type;
-       v4l2_std_id     id;
-       v4l2_std_id     std_req;
-       __u16           int_freq;
-       unsigned int    scode_table;
-       int             scode_nr;
-};
-
-struct xc2028_data {
-       struct list_head        xc2028_list;
-       struct tuner_i2c_props  i2c_props;
-       int                     (*tuner_callback) (void *dev,
-                                                  int command, int arg);
-       void                    *video_dev;
-       int                     count;
-       __u32                   frequency;
-
-       struct firmware_description *firm;
-       int                     firm_size;
-       __u16                   firm_version;
-
-       __u16                   hwmodel;
-       __u16                   hwvers;
-
-       struct xc2028_ctrl      ctrl;
-
-       struct firmware_properties cur_fw;
-
-       struct mutex lock;
-};
-
-#define i2c_send(priv, buf, size) ({                                   \
-       int _rc;                                                        \
-       _rc = tuner_i2c_xfer_send(&priv->i2c_props, buf, size);         \
-       if (size != _rc)                                                \
-               tuner_info("i2c output error: rc = %d (should be %d)\n",\
-                          _rc, (int)size);                             \
-       _rc;                                                            \
-})
-
-#define i2c_rcv(priv, buf, size) ({                                    \
-       int _rc;                                                        \
-       _rc = tuner_i2c_xfer_recv(&priv->i2c_props, buf, size);         \
-       if (size != _rc)                                                \
-               tuner_err("i2c input error: rc = %d (should be %d)\n",  \
-                          _rc, (int)size);                             \
-       _rc;                                                            \
-})
-
-#define i2c_send_recv(priv, obuf, osize, ibuf, isize) ({               \
-       int _rc;                                                        \
-       _rc = tuner_i2c_xfer_send_recv(&priv->i2c_props, obuf, osize,   \
-                                      ibuf, isize);                    \
-       if (isize != _rc)                                               \
-               tuner_err("i2c input error: rc = %d (should be %d)\n",  \
-                          _rc, (int)isize);                            \
-       _rc;                                                            \
-})
-
-#define send_seq(priv, data...)        ({                                      \
-       static u8 _val[] = data;                                        \
-       int _rc;                                                        \
-       if (sizeof(_val) !=                                             \
-                       (_rc = tuner_i2c_xfer_send(&priv->i2c_props,    \
-                                               _val, sizeof(_val)))) { \
-               tuner_err("Error on line %d: %d\n", __LINE__, _rc);     \
-       } else                                                          \
-               msleep(10);                                             \
-       _rc;                                                            \
-})
-
-static int xc2028_get_reg(struct xc2028_data *priv, u16 reg, u16 *val)
-{
-       unsigned char buf[2];
-       unsigned char ibuf[2];
-
-       tuner_dbg("%s %04x called\n", __func__, reg);
-
-       buf[0] = reg >> 8;
-       buf[1] = (unsigned char) reg;
-
-       if (i2c_send_recv(priv, buf, 2, ibuf, 2) != 2)
-               return -EIO;
-
-       *val = (ibuf[1]) | (ibuf[0] << 8);
-       return 0;
-}
-
-#define dump_firm_type(t)      dump_firm_type_and_int_freq(t, 0)
-static void dump_firm_type_and_int_freq(unsigned int type, u16 int_freq)
-{
-        if (type & BASE)
-               printk("BASE ");
-        if (type & INIT1)
-               printk("INIT1 ");
-        if (type & F8MHZ)
-               printk("F8MHZ ");
-        if (type & MTS)
-               printk("MTS ");
-        if (type & D2620)
-               printk("D2620 ");
-        if (type & D2633)
-               printk("D2633 ");
-        if (type & DTV6)
-               printk("DTV6 ");
-        if (type & QAM)
-               printk("QAM ");
-        if (type & DTV7)
-               printk("DTV7 ");
-        if (type & DTV78)
-               printk("DTV78 ");
-        if (type & DTV8)
-               printk("DTV8 ");
-        if (type & FM)
-               printk("FM ");
-        if (type & INPUT1)
-               printk("INPUT1 ");
-        if (type & LCD)
-               printk("LCD ");
-        if (type & NOGD)
-               printk("NOGD ");
-        if (type & MONO)
-               printk("MONO ");
-        if (type & ATSC)
-               printk("ATSC ");
-        if (type & IF)
-               printk("IF ");
-        if (type & LG60)
-               printk("LG60 ");
-        if (type & ATI638)
-               printk("ATI638 ");
-        if (type & OREN538)
-               printk("OREN538 ");
-        if (type & OREN36)
-               printk("OREN36 ");
-        if (type & TOYOTA388)
-               printk("TOYOTA388 ");
-        if (type & TOYOTA794)
-               printk("TOYOTA794 ");
-        if (type & DIBCOM52)
-               printk("DIBCOM52 ");
-        if (type & ZARLINK456)
-               printk("ZARLINK456 ");
-        if (type & CHINA)
-               printk("CHINA ");
-        if (type & F6MHZ)
-               printk("F6MHZ ");
-        if (type & INPUT2)
-               printk("INPUT2 ");
-        if (type & SCODE)
-               printk("SCODE ");
-        if (type & HAS_IF)
-               printk("HAS_IF_%d ", int_freq);
-}
-
-static  v4l2_std_id parse_audio_std_option(void)
-{
-       if (strcasecmp(audio_std, "A2") == 0)
-               return V4L2_STD_A2;
-       if (strcasecmp(audio_std, "A2/A") == 0)
-               return V4L2_STD_A2_A;
-       if (strcasecmp(audio_std, "A2/B") == 0)
-               return V4L2_STD_A2_B;
-       if (strcasecmp(audio_std, "NICAM") == 0)
-               return V4L2_STD_NICAM;
-       if (strcasecmp(audio_std, "NICAM/A") == 0)
-               return V4L2_STD_NICAM_A;
-       if (strcasecmp(audio_std, "NICAM/B") == 0)
-               return V4L2_STD_NICAM_B;
-
-       return 0;
-}
-
-static void free_firmware(struct xc2028_data *priv)
-{
-       int i;
-       tuner_dbg("%s called\n", __func__);
-
-       if (!priv->firm)
-               return;
-
-       for (i = 0; i < priv->firm_size; i++)
-               kfree(priv->firm[i].ptr);
-
-       kfree(priv->firm);
-
-       priv->firm = NULL;
-       priv->firm_size = 0;
-
-       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
-}
-
-static int load_all_firmwares(struct dvb_frontend *fe)
-{
-       struct xc2028_data    *priv = fe->tuner_priv;
-       const struct firmware *fw   = NULL;
-       unsigned char         *p, *endp;
-       int                   rc = 0;
-       int                   n, n_array;
-       char                  name[33];
-       char                  *fname;
-
-       tuner_dbg("%s called\n", __func__);
-
-       if (!firmware_name[0])
-               fname = priv->ctrl.fname;
-       else
-               fname = firmware_name;
-
-       tuner_dbg("Reading firmware %s\n", fname);
-       rc = request_firmware(&fw, fname, &priv->i2c_props.adap->dev);
-       if (rc < 0) {
-               if (rc == -ENOENT)
-                       tuner_err("Error: firmware %s not found.\n",
-                                  fname);
-               else
-                       tuner_err("Error %d while requesting firmware %s \n",
-                                  rc, fname);
-
-               return rc;
-       }
-       p = fw->data;
-       endp = p + fw->size;
-
-       if (fw->size < sizeof(name) - 1 + 2 + 2) {
-               tuner_err("Error: firmware file %s has invalid size!\n",
-                         fname);
-               goto corrupt;
-       }
-
-       memcpy(name, p, sizeof(name) - 1);
-       name[sizeof(name) - 1] = 0;
-       p += sizeof(name) - 1;
-
-       priv->firm_version = le16_to_cpu(*(__u16 *) p);
-       p += 2;
-
-       n_array = le16_to_cpu(*(__u16 *) p);
-       p += 2;
-
-       tuner_info("Loading %d firmware images from %s, type: %s, ver %d.%d\n",
-                  n_array, fname, name,
-                  priv->firm_version >> 8, priv->firm_version & 0xff);
-
-       priv->firm = kzalloc(sizeof(*priv->firm) * n_array, GFP_KERNEL);
-       if (priv->firm == NULL) {
-               tuner_err("Not enough memory to load firmware file.\n");
-               rc = -ENOMEM;
-               goto err;
-       }
-       priv->firm_size = n_array;
-
-       n = -1;
-       while (p < endp) {
-               __u32 type, size;
-               v4l2_std_id id;
-               __u16 int_freq = 0;
-
-               n++;
-               if (n >= n_array) {
-                       tuner_err("More firmware images in file than "
-                                 "were expected!\n");
-                       goto corrupt;
-               }
-
-               /* Checks if there's enough bytes to read */
-               if (p + sizeof(type) + sizeof(id) + sizeof(size) > endp) {
-                       tuner_err("Firmware header is incomplete!\n");
-                       goto corrupt;
-               }
-
-               type = le32_to_cpu(*(__u32 *) p);
-               p += sizeof(type);
-
-               id = le64_to_cpu(*(v4l2_std_id *) p);
-               p += sizeof(id);
-
-               if (type & HAS_IF) {
-                       int_freq = le16_to_cpu(*(__u16 *) p);
-                       p += sizeof(int_freq);
-               }
-
-               size = le32_to_cpu(*(__u32 *) p);
-               p += sizeof(size);
-
-               if ((!size) || (size + p > endp)) {
-                       tuner_err("Firmware type ");
-                       dump_firm_type(type);
-                       printk("(%x), id %llx is corrupted "
-                              "(size=%d, expected %d)\n",
-                              type, (unsigned long long)id,
-                              (unsigned)(endp - p), size);
-                       goto corrupt;
-               }
-
-               priv->firm[n].ptr = kzalloc(size, GFP_KERNEL);
-               if (priv->firm[n].ptr == NULL) {
-                       tuner_err("Not enough memory to load firmware file.\n");
-                       rc = -ENOMEM;
-                       goto err;
-               }
-               tuner_dbg("Reading firmware type ");
-               if (debug) {
-                       dump_firm_type_and_int_freq(type, int_freq);
-                       printk("(%x), id %llx, size=%d.\n",
-                              type, (unsigned long long)id, size);
-               }
-
-               memcpy(priv->firm[n].ptr, p, size);
-               priv->firm[n].type = type;
-               priv->firm[n].id   = id;
-               priv->firm[n].size = size;
-               priv->firm[n].int_freq = int_freq;
-
-               p += size;
-       }
-
-       if (n + 1 != priv->firm_size) {
-               tuner_err("Firmware file is incomplete!\n");
-               goto corrupt;
-       }
-
-       goto done;
-
-corrupt:
-       rc = -EINVAL;
-       tuner_err("Error: firmware file is corrupted!\n");
-
-err:
-       tuner_info("Releasing partially loaded firmware file.\n");
-       free_firmware(priv);
-
-done:
-       release_firmware(fw);
-       if (rc == 0)
-               tuner_dbg("Firmware files loaded.\n");
-
-       return rc;
-}
-
-static int seek_firmware(struct dvb_frontend *fe, unsigned int type,
-                        v4l2_std_id *id)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       int                 i, best_i = -1, best_nr_matches = 0;
-       unsigned int        type_mask = 0;
-
-       tuner_dbg("%s called, want type=", __func__);
-       if (debug) {
-               dump_firm_type(type);
-               printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
-       }
-
-       if (!priv->firm) {
-               tuner_err("Error! firmware not loaded\n");
-               return -EINVAL;
-       }
-
-       if (((type & ~SCODE) == 0) && (*id == 0))
-               *id = V4L2_STD_PAL;
-
-       if (type & BASE)
-               type_mask = BASE_TYPES;
-       else if (type & SCODE) {
-               type &= SCODE_TYPES;
-               type_mask = SCODE_TYPES & ~HAS_IF;
-       } else if (type & DTV_TYPES)
-               type_mask = DTV_TYPES;
-       else if (type & STD_SPECIFIC_TYPES)
-               type_mask = STD_SPECIFIC_TYPES;
-
-       type &= type_mask;
-
-       if (!(type & SCODE))
-               type_mask = ~0;
-
-       /* Seek for exact match */
-       for (i = 0; i < priv->firm_size; i++) {
-               if ((type == (priv->firm[i].type & type_mask)) &&
-                   (*id == priv->firm[i].id))
-                       goto found;
-       }
-
-       /* Seek for generic video standard match */
-       for (i = 0; i < priv->firm_size; i++) {
-               v4l2_std_id match_mask;
-               int nr_matches;
-
-               if (type != (priv->firm[i].type & type_mask))
-                       continue;
-
-               match_mask = *id & priv->firm[i].id;
-               if (!match_mask)
-                       continue;
-
-               if ((*id & match_mask) == *id)
-                       goto found; /* Supports all the requested standards */
-
-               nr_matches = hweight64(match_mask);
-               if (nr_matches > best_nr_matches) {
-                       best_nr_matches = nr_matches;
-                       best_i = i;
-               }
-       }
-
-       if (best_nr_matches > 0) {
-               tuner_dbg("Selecting best matching firmware (%d bits) for "
-                         "type=", best_nr_matches);
-               dump_firm_type(type);
-               printk("(%x), id %016llx:\n", type, (unsigned long long)*id);
-               i = best_i;
-               goto found;
-       }
-
-       /*FIXME: Would make sense to seek for type "hint" match ? */
-
-       i = -ENOENT;
-       goto ret;
-
-found:
-       *id = priv->firm[i].id;
-
-ret:
-       tuner_dbg("%s firmware for type=", (i < 0) ? "Can't find" : "Found");
-       if (debug) {
-               dump_firm_type(type);
-               printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
-       }
-       return i;
-}
-
-static int load_firmware(struct dvb_frontend *fe, unsigned int type,
-                        v4l2_std_id *id)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       int                pos, rc;
-       unsigned char      *p, *endp, buf[priv->ctrl.max_len];
-
-       tuner_dbg("%s called\n", __func__);
-
-       pos = seek_firmware(fe, type, id);
-       if (pos < 0)
-               return pos;
-
-       tuner_info("Loading firmware for type=");
-       dump_firm_type(priv->firm[pos].type);
-       printk("(%x), id %016llx.\n", priv->firm[pos].type,
-              (unsigned long long)*id);
-
-       p = priv->firm[pos].ptr;
-       endp = p + priv->firm[pos].size;
-
-       while (p < endp) {
-               __u16 size;
-
-               /* Checks if there's enough bytes to read */
-               if (p + sizeof(size) > endp) {
-                       tuner_err("Firmware chunk size is wrong\n");
-                       return -EINVAL;
-               }
-
-               size = le16_to_cpu(*(__u16 *) p);
-               p += sizeof(size);
-
-               if (size == 0xffff)
-                       return 0;
-
-               if (!size) {
-                       /* Special callback command received */
-                       rc = priv->tuner_callback(priv->video_dev,
-                                                 XC2028_TUNER_RESET, 0);
-                       if (rc < 0) {
-                               tuner_err("Error at RESET code %d\n",
-                                          (*p) & 0x7f);
-                               return -EINVAL;
-                       }
-                       continue;
-               }
-               if (size >= 0xff00) {
-                       switch (size) {
-                       case 0xff00:
-                               rc = priv->tuner_callback(priv->video_dev,
-                                                       XC2028_RESET_CLK, 0);
-                               if (rc < 0) {
-                                       tuner_err("Error at RESET code %d\n",
-                                                 (*p) & 0x7f);
-                                       return -EINVAL;
-                               }
-                               break;
-                       default:
-                               tuner_info("Invalid RESET code %d\n",
-                                          size & 0x7f);
-                               return -EINVAL;
-
-                       }
-                       continue;
-               }
-
-               /* Checks for a sleep command */
-               if (size & 0x8000) {
-                       msleep(size & 0x7fff);
-                       continue;
-               }
-
-               if ((size + p > endp)) {
-                       tuner_err("missing bytes: need %d, have %d\n",
-                                  size, (int)(endp - p));
-                       return -EINVAL;
-               }
-
-               buf[0] = *p;
-               p++;
-               size--;
-
-               /* Sends message chunks */
-               while (size > 0) {
-                       int len = (size < priv->ctrl.max_len - 1) ?
-                                  size : priv->ctrl.max_len - 1;
-
-                       memcpy(buf + 1, p, len);
-
-                       rc = i2c_send(priv, buf, len + 1);
-                       if (rc < 0) {
-                               tuner_err("%d returned from send\n", rc);
-                               return -EINVAL;
-                       }
-
-                       p += len;
-                       size -= len;
-               }
-       }
-       return 0;
-}
-
-static int load_scode(struct dvb_frontend *fe, unsigned int type,
-                        v4l2_std_id *id, __u16 int_freq, int scode)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       int                pos, rc;
-       unsigned char      *p;
-
-       tuner_dbg("%s called\n", __func__);
-
-       if (!int_freq) {
-               pos = seek_firmware(fe, type, id);
-               if (pos < 0)
-                       return pos;
-       } else {
-               for (pos = 0; pos < priv->firm_size; pos++) {
-                       if ((priv->firm[pos].int_freq == int_freq) &&
-                           (priv->firm[pos].type & HAS_IF))
-                               break;
-               }
-               if (pos == priv->firm_size)
-                       return -ENOENT;
-       }
-
-       p = priv->firm[pos].ptr;
-
-       if (priv->firm[pos].type & HAS_IF) {
-               if (priv->firm[pos].size != 12 * 16 || scode >= 16)
-                       return -EINVAL;
-               p += 12 * scode;
-       } else {
-               /* 16 SCODE entries per file; each SCODE entry is 12 bytes and
-                * has a 2-byte size header in the firmware format. */
-               if (priv->firm[pos].size != 14 * 16 || scode >= 16 ||
-                   le16_to_cpu(*(__u16 *)(p + 14 * scode)) != 12)
-                       return -EINVAL;
-               p += 14 * scode + 2;
-       }
-
-       tuner_info("Loading SCODE for type=");
-       dump_firm_type_and_int_freq(priv->firm[pos].type,
-                                   priv->firm[pos].int_freq);
-       printk("(%x), id %016llx.\n", priv->firm[pos].type,
-              (unsigned long long)*id);
-
-       if (priv->firm_version < 0x0202)
-               rc = send_seq(priv, {0x20, 0x00, 0x00, 0x00});
-       else
-               rc = send_seq(priv, {0xa0, 0x00, 0x00, 0x00});
-       if (rc < 0)
-               return -EIO;
-
-       rc = i2c_send(priv, p, 12);
-       if (rc < 0)
-               return -EIO;
-
-       rc = send_seq(priv, {0x00, 0x8c});
-       if (rc < 0)
-               return -EIO;
-
-       return 0;
-}
-
-static int check_firmware(struct dvb_frontend *fe, unsigned int type,
-                         v4l2_std_id std, __u16 int_freq)
-{
-       struct xc2028_data         *priv = fe->tuner_priv;
-       struct firmware_properties new_fw;
-       int                        rc = 0, is_retry = 0;
-       u16                        version, hwmodel;
-       v4l2_std_id                std0;
-
-       tuner_dbg("%s called\n", __func__);
-
-       if (!priv->firm) {
-               if (!priv->ctrl.fname) {
-                       tuner_info("xc2028/3028 firmware name not set!\n");
-                       return -EINVAL;
-               }
-
-               rc = load_all_firmwares(fe);
-               if (rc < 0)
-                       return rc;
-       }
-
-       if (priv->ctrl.mts && !(type & FM))
-               type |= MTS;
-
-retry:
-       new_fw.type = type;
-       new_fw.id = std;
-       new_fw.std_req = std;
-       new_fw.scode_table = SCODE | priv->ctrl.scode_table;
-       new_fw.scode_nr = 0;
-       new_fw.int_freq = int_freq;
-
-       tuner_dbg("checking firmware, user requested type=");
-       if (debug) {
-               dump_firm_type(new_fw.type);
-               printk("(%x), id %016llx, ", new_fw.type,
-                      (unsigned long long)new_fw.std_req);
-               if (!int_freq) {
-                       printk("scode_tbl ");
-                       dump_firm_type(priv->ctrl.scode_table);
-                       printk("(%x), ", priv->ctrl.scode_table);
-               } else
-                       printk("int_freq %d, ", new_fw.int_freq);
-               printk("scode_nr %d\n", new_fw.scode_nr);
-       }
-
-       /* No need to reload base firmware if it matches */
-       if (((BASE | new_fw.type) & BASE_TYPES) ==
-           (priv->cur_fw.type & BASE_TYPES)) {
-               tuner_dbg("BASE firmware not changed.\n");
-               goto skip_base;
-       }
-
-       /* Updating BASE - forget about all currently loaded firmware */
-       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
-
-       /* Reset is needed before loading firmware */
-       rc = priv->tuner_callback(priv->video_dev,
-                                 XC2028_TUNER_RESET, 0);
-       if (rc < 0)
-               goto fail;
-
-       /* BASE firmwares are all std0 */
-       std0 = 0;
-       rc = load_firmware(fe, BASE | new_fw.type, &std0);
-       if (rc < 0) {
-               tuner_err("Error %d while loading base firmware\n",
-                         rc);
-               goto fail;
-       }
-
-       /* Load INIT1, if needed */
-       tuner_dbg("Load init1 firmware, if exists\n");
-
-       rc = load_firmware(fe, BASE | INIT1 | new_fw.type, &std0);
-       if (rc == -ENOENT)
-               rc = load_firmware(fe, (BASE | INIT1 | new_fw.type) & ~F8MHZ,
-                                  &std0);
-       if (rc < 0 && rc != -ENOENT) {
-               tuner_err("Error %d while loading init1 firmware\n",
-                         rc);
-               goto fail;
-       }
-
-skip_base:
-       /*
-        * No need to reload standard specific firmware if base firmware
-        * was not reloaded and requested video standards have not changed.
-        */
-       if (priv->cur_fw.type == (BASE | new_fw.type) &&
-           priv->cur_fw.std_req == std) {
-               tuner_dbg("Std-specific firmware already loaded.\n");
-               goto skip_std_specific;
-       }
-
-       /* Reloading std-specific firmware forces a SCODE update */
-       priv->cur_fw.scode_table = 0;
-
-       rc = load_firmware(fe, new_fw.type, &new_fw.id);
-       if (rc == -ENOENT)
-               rc = load_firmware(fe, new_fw.type & ~F8MHZ, &new_fw.id);
-
-       if (rc < 0)
-               goto fail;
-
-skip_std_specific:
-       if (priv->cur_fw.scode_table == new_fw.scode_table &&
-           priv->cur_fw.scode_nr == new_fw.scode_nr) {
-               tuner_dbg("SCODE firmware already loaded.\n");
-               goto check_device;
-       }
-
-       if (new_fw.type & FM)
-               goto check_device;
-
-       /* Load SCODE firmware, if exists */
-       tuner_dbg("Trying to load scode %d\n", new_fw.scode_nr);
-
-       rc = load_scode(fe, new_fw.type | new_fw.scode_table, &new_fw.id,
-                       new_fw.int_freq, new_fw.scode_nr);
-
-check_device:
-       if (xc2028_get_reg(priv, 0x0004, &version) < 0 ||
-           xc2028_get_reg(priv, 0x0008, &hwmodel) < 0) {
-               tuner_err("Unable to read tuner registers.\n");
-               goto fail;
-       }
-
-       tuner_dbg("Device is Xceive %d version %d.%d, "
-                 "firmware version %d.%d\n",
-                 hwmodel, (version & 0xf000) >> 12, (version & 0xf00) >> 8,
-                 (version & 0xf0) >> 4, version & 0xf);
-
-       /* Check firmware version against what we downloaded. */
-       if (priv->firm_version != ((version & 0xf0) << 4 | (version & 0x0f))) {
-               tuner_err("Incorrect readback of firmware version.\n");
-               goto fail;
-       }
-
-       /* Check that the tuner hardware model remains consistent over time. */
-       if (priv->hwmodel == 0 && (hwmodel == 2028 || hwmodel == 3028)) {
-               priv->hwmodel = hwmodel;
-               priv->hwvers  = version & 0xff00;
-       } else if (priv->hwmodel == 0 || priv->hwmodel != hwmodel ||
-                  priv->hwvers != (version & 0xff00)) {
-               tuner_err("Read invalid device hardware information - tuner "
-                         "hung?\n");
-               goto fail;
-       }
-
-       memcpy(&priv->cur_fw, &new_fw, sizeof(priv->cur_fw));
-
-       /*
-        * By setting BASE in cur_fw.type only after successfully loading all
-        * firmwares, we can:
-        * 1. Identify that BASE firmware with type=0 has been loaded;
-        * 2. Tell whether BASE firmware was just changed the next time through.
-        */
-       priv->cur_fw.type |= BASE;
-
-       return 0;
-
-fail:
-       memset(&priv->cur_fw, 0, sizeof(priv->cur_fw));
-       if (!is_retry) {
-               msleep(50);
-               is_retry = 1;
-               tuner_dbg("Retrying firmware load\n");
-               goto retry;
-       }
-
-       if (rc == -ENOENT)
-               rc = -EINVAL;
-       return rc;
-}
-
-static int xc2028_signal(struct dvb_frontend *fe, u16 *strength)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       u16                 frq_lock, signal = 0;
-       int                 rc;
-
-       tuner_dbg("%s called\n", __func__);
-
-       mutex_lock(&priv->lock);
-
-       /* Sync Lock Indicator */
-       rc = xc2028_get_reg(priv, 0x0002, &frq_lock);
-       if (rc < 0)
-               goto ret;
-
-       /* Frequency is locked */
-       if (frq_lock == 1)
-               signal = 32768;
-
-       /* Get SNR of the video signal */
-       rc = xc2028_get_reg(priv, 0x0040, &signal);
-       if (rc < 0)
-               goto ret;
-
-       /* Use both frq_lock and signal to generate the result */
-       signal = signal || ((signal & 0x07) << 12);
-
-ret:
-       mutex_unlock(&priv->lock);
-
-       *strength = signal;
-
-       tuner_dbg("signal strength is %d\n", signal);
-
-       return rc;
-}
-
-#define DIV 15625
-
-static int generic_set_freq(struct dvb_frontend *fe, u32 freq /* in HZ */,
-                           enum tuner_mode new_mode,
-                           unsigned int type,
-                           v4l2_std_id std,
-                           u16 int_freq)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       int                rc = -EINVAL;
-       unsigned char      buf[4];
-       u32                div, offset = 0;
-
-       tuner_dbg("%s called\n", __func__);
-
-       mutex_lock(&priv->lock);
-
-       tuner_dbg("should set frequency %d kHz\n", freq / 1000);
-
-       if (check_firmware(fe, type, std, int_freq) < 0)
-               goto ret;
-
-       /* On some cases xc2028 can disable video output, if
-        * very weak signals are received. By sending a soft
-        * reset, this is re-enabled. So, it is better to always
-        * send a soft reset before changing channels, to be sure
-        * that xc2028 will be in a safe state.
-        * Maybe this might also be needed for DTV.
-        */
-       if (new_mode == T_ANALOG_TV) {
-               rc = send_seq(priv, {0x00, 0x00});
-       } else if (priv->cur_fw.type & ATSC) {
-               offset = 1750000;
-       } else {
-               offset = 2750000;
-               /*
-                * We must adjust the offset by 500kHz in two cases in order
-                * to correctly center the IF output:
-                * 1) When the ZARLINK456 or DIBCOM52 tables were explicitly
-                *    selected and a 7MHz channel is tuned;
-                * 2) When tuning a VHF channel with DTV78 firmware.
-                */
-               if (((priv->cur_fw.type & DTV7) &&
-                    (priv->cur_fw.scode_table & (ZARLINK456 | DIBCOM52))) ||
-                   ((priv->cur_fw.type & DTV78) && freq < 470000000))
-                       offset -= 500000;
-       }
-
-       div = (freq - offset + DIV / 2) / DIV;
-
-       /* CMD= Set frequency */
-       if (priv->firm_version < 0x0202)
-               rc = send_seq(priv, {0x00, 0x02, 0x00, 0x00});
-       else
-               rc = send_seq(priv, {0x80, 0x02, 0x00, 0x00});
-       if (rc < 0)
-               goto ret;
-
-       /* Return code shouldn't be checked.
-          The reset CLK is needed only with tm6000.
-          Driver should work fine even if this fails.
-        */
-       priv->tuner_callback(priv->video_dev, XC2028_RESET_CLK, 1);
-
-       msleep(10);
-
-       buf[0] = 0xff & (div >> 24);
-       buf[1] = 0xff & (div >> 16);
-       buf[2] = 0xff & (div >> 8);
-       buf[3] = 0xff & (div);
-
-       rc = i2c_send(priv, buf, sizeof(buf));
-       if (rc < 0)
-               goto ret;
-       msleep(100);
-
-       priv->frequency = freq;
-
-       tuner_dbg("divisor= %02x %02x %02x %02x (freq=%d.%03d)\n",
-              buf[0], buf[1], buf[2], buf[3],
-              freq / 1000000, (freq % 1000000) / 1000);
-
-       rc = 0;
-
-ret:
-       mutex_unlock(&priv->lock);
-
-       return rc;
-}
-
-static int xc2028_set_analog_freq(struct dvb_frontend *fe,
-                             struct analog_parameters *p)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       unsigned int       type=0;
-
-       tuner_dbg("%s called\n", __func__);
-
-       if (p->mode == V4L2_TUNER_RADIO) {
-               type |= FM;
-               if (priv->ctrl.input1)
-                       type |= INPUT1;
-               return generic_set_freq(fe, (625l * p->frequency) / 10,
-                               T_ANALOG_TV, type, 0, 0);
-       }
-
-       /* if std is not defined, choose one */
-       if (!p->std)
-               p->std = V4L2_STD_MN;
-
-       /* PAL/M, PAL/N, PAL/Nc and NTSC variants should use 6MHz firmware */
-       if (!(p->std & V4L2_STD_MN))
-               type |= F8MHZ;
-
-       /* Add audio hack to std mask */
-       p->std |= parse_audio_std_option();
-
-       return generic_set_freq(fe, 62500l * p->frequency,
-                               T_ANALOG_TV, type, p->std, 0);
-}
-
-static int xc2028_set_params(struct dvb_frontend *fe,
-                            struct dvb_frontend_parameters *p)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       unsigned int       type=0;
-       fe_bandwidth_t     bw = BANDWIDTH_8_MHZ;
-       u16                demod = 0;
-
-       tuner_dbg("%s called\n", __func__);
-
-       if (priv->ctrl.d2633)
-               type |= D2633;
-       else
-               type |= D2620;
-
-       switch(fe->ops.info.type) {
-       case FE_OFDM:
-               bw = p->u.ofdm.bandwidth;
-               break;
-       case FE_QAM:
-               tuner_info("WARN: There are some reports that "
-                          "QAM 6 MHz doesn't work.\n"
-                          "If this works for you, please report by "
-                          "e-mail to: v4l-dvb-maintainer@linuxtv.org\n");
-               bw = BANDWIDTH_6_MHZ;
-               type |= QAM;
-               break;
-       case FE_ATSC:
-               bw = BANDWIDTH_6_MHZ;
-               /* The only ATSC firmware (at least on v2.7) is D2633,
-                  so overrides ctrl->d2633 */
-               type |= ATSC| D2633;
-               type &= ~D2620;
-               break;
-       /* DVB-S is not supported */
-       default:
-               return -EINVAL;
-       }
-
-       switch (bw) {
-       case BANDWIDTH_8_MHZ:
-               if (p->frequency < 470000000)
-                       priv->ctrl.vhfbw7 = 0;
-               else
-                       priv->ctrl.uhfbw8 = 1;
-               type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV8;
-               type |= F8MHZ;
-               break;
-       case BANDWIDTH_7_MHZ:
-               if (p->frequency < 470000000)
-                       priv->ctrl.vhfbw7 = 1;
-               else
-                       priv->ctrl.uhfbw8 = 0;
-               type |= (priv->ctrl.vhfbw7 && priv->ctrl.uhfbw8) ? DTV78 : DTV7;
-               type |= F8MHZ;
-               break;
-       case BANDWIDTH_6_MHZ:
-               type |= DTV6;
-               priv->ctrl.vhfbw7 = 0;
-               priv->ctrl.uhfbw8 = 0;
-               break;
-       default:
-               tuner_err("error: bandwidth not supported.\n");
-       };
-
-       /* All S-code tables need a 200kHz shift */
-       if (priv->ctrl.demod)
-               demod = priv->ctrl.demod + 200;
-
-       return generic_set_freq(fe, p->frequency,
-                               T_DIGITAL_TV, type, 0, demod);
-}
-
-
-static int xc2028_dvb_release(struct dvb_frontend *fe)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-
-       tuner_dbg("%s called\n", __func__);
-
-       mutex_lock(&xc2028_list_mutex);
-
-       priv->count--;
-
-       if (!priv->count) {
-               list_del(&priv->xc2028_list);
-
-               kfree(priv->ctrl.fname);
-
-               free_firmware(priv);
-               kfree(priv);
-               fe->tuner_priv = NULL;
-       }
-
-       mutex_unlock(&xc2028_list_mutex);
-
-       return 0;
-}
-
-static int xc2028_get_frequency(struct dvb_frontend *fe, u32 *frequency)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-
-       tuner_dbg("%s called\n", __func__);
-
-       *frequency = priv->frequency;
-
-       return 0;
-}
-
-static int xc2028_set_config(struct dvb_frontend *fe, void *priv_cfg)
-{
-       struct xc2028_data *priv = fe->tuner_priv;
-       struct xc2028_ctrl *p    = priv_cfg;
-       int                 rc   = 0;
-
-       tuner_dbg("%s called\n", __func__);
-
-       mutex_lock(&priv->lock);
-
-       memcpy(&priv->ctrl, p, sizeof(priv->ctrl));
-       if (priv->ctrl.max_len < 9)
-               priv->ctrl.max_len = 13;
-
-       if (p->fname) {
-               if (priv->ctrl.fname && strcmp(p->fname, priv->ctrl.fname)) {
-                       kfree(priv->ctrl.fname);
-                       free_firmware(priv);
-               }
-
-               priv->ctrl.fname = kstrdup(p->fname, GFP_KERNEL);
-               if (priv->ctrl.fname == NULL)
-                       rc = -ENOMEM;
-       }
-
-       mutex_unlock(&priv->lock);
-
-       return rc;
-}
-
-static const struct dvb_tuner_ops xc2028_dvb_tuner_ops = {
-       .info = {
-                .name = "Xceive XC3028",
-                .frequency_min = 42000000,
-                .frequency_max = 864000000,
-                .frequency_step = 50000,
-                },
-
-       .set_config        = xc2028_set_config,
-       .set_analog_params = xc2028_set_analog_freq,
-       .release           = xc2028_dvb_release,
-       .get_frequency     = xc2028_get_frequency,
-       .get_rf_strength   = xc2028_signal,
-       .set_params        = xc2028_set_params,
-};
-
-struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
-                                  struct xc2028_config *cfg)
-{
-       struct xc2028_data *priv;
-       void               *video_dev;
-
-       if (debug)
-               printk(KERN_DEBUG "xc2028: Xcv2028/3028 init called!\n");
-
-       if (NULL == cfg)
-               return NULL;
-
-       if (!fe) {
-               printk(KERN_ERR "xc2028: No frontend!\n");
-               return NULL;
-       }
-
-       video_dev = cfg->i2c_adap->algo_data;
-
-       if (debug)
-               printk(KERN_DEBUG "xc2028: video_dev =%p\n", video_dev);
-
-       mutex_lock(&xc2028_list_mutex);
-
-       list_for_each_entry(priv, &xc2028_list, xc2028_list) {
-               if (&priv->i2c_props.adap->dev == &cfg->i2c_adap->dev) {
-                       video_dev = NULL;
-                       if (debug)
-                               printk(KERN_DEBUG "xc2028: reusing device\n");
-
-                       break;
-               }
-       }
-
-       if (video_dev) {
-               priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-               if (priv == NULL) {
-                       mutex_unlock(&xc2028_list_mutex);
-                       return NULL;
-               }
-
-               priv->i2c_props.addr = cfg->i2c_addr;
-               priv->i2c_props.adap = cfg->i2c_adap;
-               priv->i2c_props.name = "xc2028";
-
-               priv->video_dev = video_dev;
-               priv->tuner_callback = cfg->callback;
-               priv->ctrl.max_len = 13;
-
-               mutex_init(&priv->lock);
-
-               list_add_tail(&priv->xc2028_list, &xc2028_list);
-       }
-
-       fe->tuner_priv = priv;
-       priv->count++;
-
-       if (debug)
-               printk(KERN_DEBUG "xc2028: usage count is %i\n", priv->count);
-
-       memcpy(&fe->ops.tuner_ops, &xc2028_dvb_tuner_ops,
-              sizeof(xc2028_dvb_tuner_ops));
-
-       tuner_info("type set to %s\n", "XCeive xc2028/xc3028 tuner");
-
-       if (cfg->ctrl)
-               xc2028_set_config(fe, cfg->ctrl);
-
-       mutex_unlock(&xc2028_list_mutex);
-
-       return fe;
-}
-
-EXPORT_SYMBOL(xc2028_attach);
-
-MODULE_DESCRIPTION("Xceive xc2028/xc3028 tuner driver");
-MODULE_AUTHOR("Michel Ludwig <michel.ludwig@gmail.com>");
-MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
-MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/tuner-xc2028.h b/drivers/media/video/tuner-xc2028.h
deleted file mode 100644 (file)
index fc2f132..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-/* tuner-xc2028
- *
- * Copyright (c) 2007-2008 Mauro Carvalho Chehab (mchehab@infradead.org)
- * This code is placed under the terms of the GNU General Public License v2
- */
-
-#ifndef __TUNER_XC2028_H__
-#define __TUNER_XC2028_H__
-
-#include "dvb_frontend.h"
-
-#define XC2028_DEFAULT_FIRMWARE "xc3028-v27.fw"
-
-/*      Dmoduler               IF (kHz) */
-#define        XC3028_FE_DEFAULT       0               /* Don't load SCODE */
-#define XC3028_FE_LG60         6000
-#define        XC3028_FE_ATI638        6380
-#define        XC3028_FE_OREN538       5380
-#define        XC3028_FE_OREN36        3600
-#define        XC3028_FE_TOYOTA388     3880
-#define        XC3028_FE_TOYOTA794     7940
-#define        XC3028_FE_DIBCOM52      5200
-#define        XC3028_FE_ZARLINK456    4560
-#define        XC3028_FE_CHINA         5200
-
-struct xc2028_ctrl {
-       char                    *fname;
-       int                     max_len;
-       unsigned int            scode_table;
-       unsigned int            mts   :1;
-       unsigned int            d2633 :1;
-       unsigned int            input1:1;
-       unsigned int            vhfbw7:1;
-       unsigned int            uhfbw8:1;
-       unsigned int            demod;
-};
-
-struct xc2028_config {
-       struct i2c_adapter *i2c_adap;
-       u8                 i2c_addr;
-       void               *video_dev;
-       struct xc2028_ctrl *ctrl;
-       int                (*callback) (void *dev, int command, int arg);
-};
-
-/* xc2028 commands for callback */
-#define XC2028_TUNER_RESET     0
-#define XC2028_RESET_CLK       1
-
-#if defined(CONFIG_TUNER_XC2028) || (defined(CONFIG_TUNER_XC2028_MODULE) && defined(MODULE))
-extern struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
-                                         struct xc2028_config *cfg);
-#else
-static inline struct dvb_frontend *xc2028_attach(struct dvb_frontend *fe,
-                                                struct xc2028_config *cfg)
-{
-       printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __func__);
-       return NULL;
-}
-#endif
-
-#endif /* __TUNER_XC2028_H__ */
index 9ac92a80c645442ecba5d038e75b9479bebb05d6..338718750945bf8feb63e3d00a8e254b6781a3cc 100644 (file)
@@ -3,3 +3,4 @@ usbvision-objs  := usbvision-core.o usbvision-video.o usbvision-i2c.o usbvision-
 obj-$(CONFIG_VIDEO_USBVISION) += usbvision.o
 
 EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/common/tuners